From 55b09e701691463b065357cd3959f0ff77c3313d Mon Sep 17 00:00:00 2001 From: Coleen Phillimore Date: Wed, 13 Jun 2012 19:52:59 -0400 Subject: [PATCH 001/160] 7158800: Improve storage of symbol tables Use an alternate version of hashing algorithm for symbol string tables and after a certain bucket size to improve performance Reviewed-by: pbk, kamg, dlong, kvn, fparain --- hotspot/src/share/vm/classfile/altHashing.cpp | 304 + hotspot/src/share/vm/classfile/altHashing.hpp | 62 + .../src/share/vm/classfile/javaClasses.cpp | 22 +- .../src/share/vm/classfile/javaClasses.hpp | 24 +- .../src/share/vm/classfile/symbolTable.cpp | 153 +- .../src/share/vm/classfile/symbolTable.hpp | 40 +- hotspot/src/share/vm/memory/dump.cpp | 6 +- hotspot/src/share/vm/prims/jni.cpp | 2 + hotspot/src/share/vm/runtime/globals.hpp | 3 + hotspot/src/share/vm/runtime/init.cpp | 5 + hotspot/src/share/vm/runtime/safepoint.cpp | 17 +- hotspot/src/share/vm/utilities/hashtable.cpp | 51 +- hotspot/src/share/vm/utilities/hashtable.hpp | 39 +- .../share/vm/utilities/hashtable.inline.hpp | 23 +- hotspot/test/runtime/7158800/BadUtf8.java | 1254 + hotspot/test/runtime/7158800/InternTest.java | 80 + hotspot/test/runtime/7158800/badstrings.txt | 30001 ++++++++++++++++ 17 files changed, 32031 insertions(+), 55 deletions(-) create mode 100644 hotspot/src/share/vm/classfile/altHashing.cpp create mode 100644 hotspot/src/share/vm/classfile/altHashing.hpp create mode 100644 hotspot/test/runtime/7158800/BadUtf8.java create mode 100644 hotspot/test/runtime/7158800/InternTest.java create mode 100644 hotspot/test/runtime/7158800/badstrings.txt diff --git a/hotspot/src/share/vm/classfile/altHashing.cpp b/hotspot/src/share/vm/classfile/altHashing.cpp new file mode 100644 index 00000000000..096d17e9303 --- /dev/null +++ b/hotspot/src/share/vm/classfile/altHashing.cpp @@ -0,0 +1,304 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "classfile/altHashing.hpp" +#include "classfile/symbolTable.hpp" +#include "classfile/systemDictionary.hpp" +#include "oops/markOop.hpp" +#include "runtime/thread.hpp" + +// Get the hash code of the classes mirror if it exists, otherwise just +// return a random number, which is one of the possible hash code used for +// objects. We don't want to call the synchronizer hash code to install +// this value because it may safepoint. +intptr_t object_hash(klassOop k) { + intptr_t hc = k->java_mirror()->mark()->hash(); + return hc != markOopDesc::no_hash ? hc : os::random(); +} + +// Seed value used for each alternative hash calculated. +jint AltHashing::compute_seed() { + jlong nanos = os::javaTimeNanos(); + jlong now = os::javaTimeMillis(); + jint SEED_MATERIAL[8] = { + (jint) object_hash(SystemDictionary::String_klass()), + (jint) object_hash(SystemDictionary::System_klass()), + (jint) os::random(), // current thread isn't a java thread + (jint) (((julong)nanos) >> 32), + (jint) nanos, + (jint) (((julong)now) >> 32), + (jint) now, + (jint) (os::javaTimeNanos() >> 2) + }; + + return murmur3_32(SEED_MATERIAL, 8); +} + + +// Murmur3 hashing for Symbol +jint AltHashing::murmur3_32(jint seed, const jbyte* data, int len) { + jint h1 = seed; + int count = len; + int offset = 0; + + // body + while (count >= 4) { + jint k1 = (data[offset] & 0x0FF) + | (data[offset + 1] & 0x0FF) << 8 + | (data[offset + 2] & 0x0FF) << 16 + | data[offset + 3] << 24; + + count -= 4; + offset += 4; + + k1 *= 0xcc9e2d51; + k1 = Integer_rotateLeft(k1, 15); + k1 *= 0x1b873593; + + h1 ^= k1; + h1 = Integer_rotateLeft(h1, 13); + h1 = h1 * 5 + 0xe6546b64; + } + + // tail + + if (count > 0) { + jint k1 = 0; + + switch (count) { + case 3: + k1 ^= (data[offset + 2] & 0xff) << 16; + // fall through + case 2: + k1 ^= (data[offset + 1] & 0xff) << 8; + // fall through + case 1: + k1 ^= (data[offset] & 0xff); + // fall through + default: + k1 *= 0xcc9e2d51; + k1 = Integer_rotateLeft(k1, 15); + k1 *= 0x1b873593; + h1 ^= k1; + } + } + + // finalization + h1 ^= len; + + // finalization mix force all bits of a hash block to avalanche + h1 ^= ((unsigned int)h1) >> 16; + h1 *= 0x85ebca6b; + h1 ^= ((unsigned int)h1) >> 13; + h1 *= 0xc2b2ae35; + h1 ^= ((unsigned int)h1) >> 16; + + return h1; +} + +// Murmur3 hashing for Strings +jint AltHashing::murmur3_32(jint seed, const jchar* data, int len) { + jint h1 = seed; + + int off = 0; + int count = len; + + // body + while (count >= 2) { + jchar d1 = data[off++] & 0xFFFF; + jchar d2 = data[off++]; + jint k1 = (d1 | d2 << 16); + + count -= 2; + + k1 *= 0xcc9e2d51; + k1 = Integer_rotateLeft(k1, 15); + k1 *= 0x1b873593; + + h1 ^= k1; + h1 = Integer_rotateLeft(h1, 13); + h1 = h1 * 5 + 0xe6546b64; + } + + // tail + + if (count > 0) { + int k1 = data[off]; + + k1 *= 0xcc9e2d51; + k1 = Integer_rotateLeft(k1, 15); + k1 *= 0x1b873593; + h1 ^= k1; + } + + // finalization + h1 ^= len * 2; // (Character.SIZE / Byte.SIZE); + + // finalization mix force all bits of a hash block to avalanche + h1 ^= ((unsigned int)h1) >> 16; + h1 *= 0x85ebca6b; + h1 ^= ((unsigned int)h1) >> 13; + h1 *= 0xc2b2ae35; + h1 ^= ((unsigned int)h1) >> 16; + + return h1; +} + +// Hash used for the seed. +jint AltHashing::murmur3_32(jint seed, const int* data, int len) { + jint h1 = seed; + + int off = 0; + int end = len; + + // body + while (off < end) { + jint k1 = data[off++]; + + k1 *= 0xcc9e2d51; + k1 = Integer_rotateLeft(k1, 15); + k1 *= 0x1b873593; + + h1 ^= k1; + h1 = Integer_rotateLeft(h1, 13); + h1 = h1 * 5 + 0xe6546b64; + } + + // tail (always empty, as body is always 32-bit chunks) + + // finalization + + h1 ^= len * 4; // (Integer.SIZE / Byte.SIZE); + + // finalization mix force all bits of a hash block to avalanche + h1 ^= ((juint)h1) >> 16; + h1 *= 0x85ebca6b; + h1 ^= ((juint)h1) >> 13; + h1 *= 0xc2b2ae35; + h1 ^= ((juint)h1) >> 16; + + return h1; +} + +jint AltHashing::murmur3_32(const int* data, int len) { + return murmur3_32(0, data, len); +} + +#ifndef PRODUCT +// Overloaded versions for internal test. +jint AltHashing::murmur3_32(const jbyte* data, int len) { + return murmur3_32(0, data, len); +} + +jint AltHashing::murmur3_32(const jchar* data, int len) { + return murmur3_32(0, data, len); +} + +// Internal test for alternate hashing. Translated from JDK version +// test/sun/misc/Hashing.java +static const jbyte ONE_BYTE[] = { (jbyte) 0x80}; +static const jbyte TWO_BYTE[] = { (jbyte) 0x80, (jbyte) 0x81}; +static const jchar ONE_CHAR[] = { (jchar) 0x8180}; +static const jbyte THREE_BYTE[] = { (jbyte) 0x80, (jbyte) 0x81, (jbyte) 0x82}; +static const jbyte FOUR_BYTE[] = { (jbyte) 0x80, (jbyte) 0x81, (jbyte) 0x82, (jbyte) 0x83}; +static const jchar TWO_CHAR[] = { (jchar) 0x8180, (jchar) 0x8382}; +static const jint ONE_INT[] = { 0x83828180}; +static const jbyte SIX_BYTE[] = { (jbyte) 0x80, (jbyte) 0x81, (jbyte) 0x82, (jbyte) 0x83, (jbyte) 0x84, (jbyte) 0x85}; +static const jchar THREE_CHAR[] = { (jchar) 0x8180, (jchar) 0x8382, (jchar) 0x8584}; +static const jbyte EIGHT_BYTE[] = { + (jbyte) 0x80, (jbyte) 0x81, (jbyte) 0x82, + (jbyte) 0x83, (jbyte) 0x84, (jbyte) 0x85, + (jbyte) 0x86, (jbyte) 0x87}; +static const jchar FOUR_CHAR[] = { + (jchar) 0x8180, (jchar) 0x8382, + (jchar) 0x8584, (jchar) 0x8786}; + +static const jint TWO_INT[] = { 0x83828180, 0x87868584}; + +static const juint MURMUR3_32_X86_CHECK_VALUE = 0xB0F57EE3; + +void AltHashing::testMurmur3_32_ByteArray() { + // printf("testMurmur3_32_ByteArray\n"); + + jbyte* vector = new jbyte[256]; + jbyte* hashes = new jbyte[4 * 256]; + + for (int i = 0; i < 256; i++) { + vector[i] = (jbyte) i; + } + + // Hash subranges {}, {0}, {0,1}, {0,1,2}, ..., {0,...,255} + for (int i = 0; i < 256; i++) { + jint hash = murmur3_32(256 - i, vector, i); + hashes[i * 4] = (jbyte) hash; + hashes[i * 4 + 1] = (jbyte) (((juint)hash) >> 8); + hashes[i * 4 + 2] = (jbyte) (((juint)hash) >> 16); + hashes[i * 4 + 3] = (jbyte) (((juint)hash) >> 24); + } + + // hash to get const result. + juint final_hash = murmur3_32(hashes, 4*256); + + assert (MURMUR3_32_X86_CHECK_VALUE == final_hash, + err_msg( + "Calculated hash result not as expected. Expected %08X got %08X\n", + MURMUR3_32_X86_CHECK_VALUE, + final_hash)); +} + +void AltHashing::testEquivalentHashes() { + jint jbytes, jchars, ints; + + // printf("testEquivalentHashes\n"); + + jbytes = murmur3_32(TWO_BYTE, 2); + jchars = murmur3_32(ONE_CHAR, 1); + assert (jbytes == jchars, + err_msg("Hashes did not match. b:%08x != c:%08x\n", jbytes, jchars)); + + jbytes = murmur3_32(FOUR_BYTE, 4); + jchars = murmur3_32(TWO_CHAR, 2); + ints = murmur3_32(ONE_INT, 1); + assert ((jbytes == jchars) && (jbytes == ints), + err_msg("Hashes did not match. b:%08x != c:%08x != i:%08x\n", jbytes, jchars, ints)); + + jbytes = murmur3_32(SIX_BYTE, 6); + jchars = murmur3_32(THREE_CHAR, 3); + assert (jbytes == jchars, + err_msg("Hashes did not match. b:%08x != c:%08x\n", jbytes, jchars)); + + jbytes = murmur3_32(EIGHT_BYTE, 8); + jchars = murmur3_32(FOUR_CHAR, 4); + ints = murmur3_32(TWO_INT, 2); + assert ((jbytes == jchars) && (jbytes == ints), + err_msg("Hashes did not match. b:%08x != c:%08x != i:%08x\n", jbytes, jchars, ints)); +} + +// Returns true if the alternate hashcode is correct +void AltHashing::test_alt_hash() { + testMurmur3_32_ByteArray(); + testEquivalentHashes(); +} +#endif // PRODUCT diff --git a/hotspot/src/share/vm/classfile/altHashing.hpp b/hotspot/src/share/vm/classfile/altHashing.hpp new file mode 100644 index 00000000000..941b9a0dc37 --- /dev/null +++ b/hotspot/src/share/vm/classfile/altHashing.hpp @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_CLASSFILE_ALTHASHING_HPP +#define SHARE_VM_CLASSFILE_ALTHASHING_HPP + +#include "prims/jni.h" +#include "classfile/symbolTable.hpp" + +/** + * Hashing utilities. + * + * Implementation of Murmur3 hashing. + * This code was translated from src/share/classes/sun/misc/Hashing.java + * code in the JDK. + */ + +class AltHashing : AllStatic { + + // utility function copied from java/lang/Integer + static jint Integer_rotateLeft(jint i, int distance) { + return (i << distance) | (((juint)i) >> (32-distance)); + } + static jint murmur3_32(const int* data, int len); + static jint murmur3_32(jint seed, const int* data, int len); + +#ifndef PRODUCT + // Hashing functions used for internal testing + static jint murmur3_32(const jbyte* data, int len); + static jint murmur3_32(const jchar* data, int len); + static void testMurmur3_32_ByteArray(); + static void testEquivalentHashes(); +#endif // PRODUCT + + public: + static jint compute_seed(); + static jint murmur3_32(jint seed, const jbyte* data, int len); + static jint murmur3_32(jint seed, const jchar* data, int len); + NOT_PRODUCT(static void test_alt_hash();) +}; +#endif // SHARE_VM_CLASSFILE_ALTHASHING_HPP diff --git a/hotspot/src/share/vm/classfile/javaClasses.cpp b/hotspot/src/share/vm/classfile/javaClasses.cpp index eab75e181e3..0c452cf4a1e 100644 --- a/hotspot/src/share/vm/classfile/javaClasses.cpp +++ b/hotspot/src/share/vm/classfile/javaClasses.cpp @@ -23,6 +23,7 @@ */ #include "precompiled.hpp" +#include "classfile/altHashing.hpp" #include "classfile/javaClasses.hpp" #include "classfile/symbolTable.hpp" #include "classfile/vmSymbols.hpp" @@ -347,13 +348,26 @@ jchar* java_lang_String::as_unicode_string(oop java_string, int& length) { return result; } -unsigned int java_lang_String::hash_string(oop java_string) { +unsigned int java_lang_String::to_hash(oop java_string) { + int length = java_lang_String::length(java_string); + // Zero length string will hash to zero with String.toHash() function. + if (length == 0) return 0; + typeArrayOop value = java_lang_String::value(java_string); int offset = java_lang_String::offset(java_string); - int length = java_lang_String::length(java_string); + return java_lang_String::to_hash(value->char_at_addr(offset), length); +} - if (length == 0) return 0; - return hash_string(value->char_at_addr(offset), length); +unsigned int java_lang_String::hash_string(oop java_string) { + int length = java_lang_String::length(java_string); + // Zero length string doesn't hash necessarily hash to zero. + if (length == 0) { + return StringTable::hash_string(NULL, 0); + } + + typeArrayOop value = java_lang_String::value(java_string); + int offset = java_lang_String::offset(java_string); + return StringTable::hash_string(value->char_at_addr(offset), length); } Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) { diff --git a/hotspot/src/share/vm/classfile/javaClasses.hpp b/hotspot/src/share/vm/classfile/javaClasses.hpp index 708ea4f544a..9ada29863b5 100644 --- a/hotspot/src/share/vm/classfile/javaClasses.hpp +++ b/hotspot/src/share/vm/classfile/javaClasses.hpp @@ -158,20 +158,16 @@ class java_lang_String : AllStatic { static jchar* as_unicode_string(oop java_string, int& length); // Compute the hash value for a java.lang.String object which would - // contain the characters passed in. This hash value is used for at - // least two purposes. + // contain the characters passed in. // - // (a) As the hash value used by the StringTable for bucket selection - // and comparison (stored in the HashtableEntry structures). This - // is used in the String.intern() method. + // As the hash value used by the String object itself, in + // String.hashCode(). This value is normally calculated in Java code + // in the String.hashCode method(), but is precomputed for String + // objects in the shared archive file. + // hash P(31) from Kernighan & Ritchie // - // (b) As the hash value used by the String object itself, in - // String.hashCode(). This value is normally calculate in Java code - // in the String.hashCode method(), but is precomputed for String - // objects in the shared archive file. - // - // For this reason, THIS ALGORITHM MUST MATCH String.hashCode(). - static unsigned int hash_string(jchar* s, int len) { + // For this reason, THIS ALGORITHM MUST MATCH String.toHash(). + template static unsigned int to_hash(T* s, int len) { unsigned int h = 0; while (len-- > 0) { h = 31*h + (unsigned int) *s; @@ -179,6 +175,10 @@ class java_lang_String : AllStatic { } return h; } + static unsigned int to_hash(oop java_string); + + // This is the string hash code used by the StringTable, which may be + // the same as String.toHash or an alternate hash code. static unsigned int hash_string(oop java_string); static bool equals(oop java_string, jchar* chars, int len); diff --git a/hotspot/src/share/vm/classfile/symbolTable.cpp b/hotspot/src/share/vm/classfile/symbolTable.cpp index 66218822525..fabe679f3a8 100644 --- a/hotspot/src/share/vm/classfile/symbolTable.cpp +++ b/hotspot/src/share/vm/classfile/symbolTable.cpp @@ -23,6 +23,7 @@ */ #include "precompiled.hpp" +#include "classfile/altHashing.hpp" #include "classfile/javaClasses.hpp" #include "classfile/symbolTable.hpp" #include "classfile/systemDictionary.hpp" @@ -34,12 +35,15 @@ #include "oops/oop.inline2.hpp" #include "runtime/mutexLocker.hpp" #include "utilities/hashtable.inline.hpp" +#include "utilities/numberSeq.hpp" // -------------------------------------------------------------------------- SymbolTable* SymbolTable::_the_table = NULL; // Static arena for symbols that are not deallocated Arena* SymbolTable::_arena = NULL; +bool SymbolTable::_needs_rehashing = false; +jint SymbolTable::_seed = 0; Symbol* SymbolTable::allocate_symbol(const u1* name, int len, bool c_heap, TRAPS) { // Don't allow symbols to be created which cannot fit in a Symbol*. @@ -121,12 +125,41 @@ void SymbolTable::unlink() { } } +unsigned int SymbolTable::new_hash(Symbol* sym) { + ResourceMark rm; + // Use alternate hashing algorithm on this symbol. + return AltHashing::murmur3_32(seed(), (const jbyte*)sym->as_C_string(), sym->utf8_length()); +} + +// Create a new table and using alternate hash code, populate the new table +// with the existing strings. Set flag to use the alternate hash code afterwards. +void SymbolTable::rehash_table() { + assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); + assert(!DumpSharedSpaces, "this should never happen with -Xshare:dump"); + // Create a new symbol table + SymbolTable* new_table = new SymbolTable(); + + // Initialize the global seed for hashing. + _seed = AltHashing::compute_seed(); + assert(seed() != 0, "shouldn't be zero"); + + the_table()->move_to(new_table); + + // Delete the table and buckets (entries are reused in new table). + delete _the_table; + // Don't check if we need rehashing until the table gets unbalanced again. + // Then rehash with a new global seed. + _needs_rehashing = false; + _the_table = new_table; +} // Lookup a symbol in a bucket. Symbol* SymbolTable::lookup(int index, const char* name, int len, unsigned int hash) { + int count = 0; for (HashtableEntry* e = bucket(index); e != NULL; e = e->next()) { + count++; // count all entries in this bucket, not just ones with same hash if (e->hash() == hash) { Symbol* sym = e->literal(); if (sym->equals(name, len)) { @@ -136,9 +169,21 @@ Symbol* SymbolTable::lookup(int index, const char* name, } } } + // If the bucket size is too deep check if this hash code is insufficient. + if (count >= BasicHashtable::rehash_count && !needs_rehashing()) { + _needs_rehashing = check_rehash_table(count); + } return NULL; } +// Pick hashing algorithm, but return value already given if not using a new +// hash algorithm. +unsigned int SymbolTable::hash_symbol(const char* s, int len, unsigned int hashValue) { + return use_alternate_hashcode() ? + AltHashing::murmur3_32(seed(), (const jbyte*)s, len) : + (hashValue != 0 ? hashValue : java_lang_String::to_hash(s, len)); +} + // We take care not to be blocking while holding the // SymbolTable_lock. Otherwise, the system might deadlock, since the @@ -287,13 +332,17 @@ Symbol* SymbolTable::new_permanent_symbol(const char* name, TRAPS) { } Symbol* SymbolTable::basic_add(int index, u1 *name, int len, - unsigned int hashValue, bool c_heap, TRAPS) { + unsigned int hashValue_arg, bool c_heap, TRAPS) { assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(), "proposed name of symbol must be stable"); // Grab SymbolTable_lock first. MutexLocker ml(SymbolTable_lock, THREAD); + // Check if the symbol table has been rehashed, if so, need to recalculate + // the hash value. + unsigned int hashValue = hash_symbol((const char*)name, len, hashValue_arg); + // Since look-up was done lock-free, we need to check if another // thread beat us in the race to insert the symbol. Symbol* test = lookup(index, (char*)name, len, hashValue); @@ -332,10 +381,13 @@ bool SymbolTable::basic_add(Handle class_loader, constantPoolHandle cp, MutexLocker ml(SymbolTable_lock, THREAD); for (int i=0; iequals(names[i], lengths[i]), "symbol must be properly initialized"); // why wouldn't it be??? - HashtableEntry* entry = new_entry(hashValues[i], sym); + HashtableEntry* entry = new_entry(hashValue, sym); add_entry(index, entry); cp->symbol_at_put(cp_indices[i], sym); } @@ -370,6 +422,24 @@ void SymbolTable::verify() { } } +void SymbolTable::dump(outputStream* st) { + NumberSeq summary; + for (int i = 0; i < the_table()->table_size(); ++i) { + int count = 0; + for (HashtableEntry* e = the_table()->bucket(i); + e != NULL; e = e->next()) { + count++; + } + summary.add((double)count); + } + st->print_cr("SymbolTable statistics:"); + st->print_cr("Number of buckets : %7d", summary.num()); + st->print_cr("Average bucket size : %7.0f", summary.avg()); + st->print_cr("Variance of bucket size : %7.0f", summary.variance()); + st->print_cr("Std. dev. of bucket size: %7.0f", summary.sd()); + st->print_cr("Maximum bucket size : %7.0f", summary.maximum()); +} + //--------------------------------------------------------------------------- // Non-product code @@ -468,7 +538,6 @@ void SymbolTable::print() { } } } - #endif // PRODUCT // -------------------------------------------------------------------------- @@ -514,21 +583,36 @@ class StableMemoryChecker : public StackObj { // -------------------------------------------------------------------------- StringTable* StringTable::_the_table = NULL; +bool StringTable::_needs_rehashing = false; +jint StringTable::_seed = 0; + +// Pick hashing algorithm +unsigned int StringTable::hash_string(const jchar* s, int len, unsigned int hashValue) { + return use_alternate_hashcode() ? AltHashing::murmur3_32(seed(), s, len) : + (hashValue != 0 ? hashValue : java_lang_String::to_hash(s, len)); +} + oop StringTable::lookup(int index, jchar* name, int len, unsigned int hash) { + int count = 0; for (HashtableEntry* l = bucket(index); l != NULL; l = l->next()) { + count++; if (l->hash() == hash) { if (java_lang_String::equals(l->literal(), name, len)) { return l->literal(); } } } + // If the bucket size is too deep check if this hash code is insufficient. + if (count >= BasicHashtable::rehash_count && !needs_rehashing()) { + _needs_rehashing = check_rehash_table(count); + } return NULL; } oop StringTable::basic_add(int index, Handle string_or_null, jchar* name, - int len, unsigned int hashValue, TRAPS) { + int len, unsigned int hashValue_arg, TRAPS) { debug_only(StableMemoryChecker smc(name, len * sizeof(name[0]))); assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(), "proposed name of symbol must be stable"); @@ -547,6 +631,10 @@ oop StringTable::basic_add(int index, Handle string_or_null, jchar* name, assert(java_lang_String::equals(string(), name, len), "string must be properly initialized"); + // Check if the symbol table has been rehashed, if so, need to recalculate + // the hash value before second lookup. + unsigned int hashValue = hash_string(name, len, hashValue_arg); + // Since look-up was done lock-free, we need to check if another // thread beat us in the race to insert the symbol. @@ -566,7 +654,7 @@ oop StringTable::lookup(Symbol* symbol) { ResourceMark rm; int length; jchar* chars = symbol->as_unicode(length); - unsigned int hashValue = java_lang_String::hash_string(chars, length); + unsigned int hashValue = hash_string(chars, length); int index = the_table()->hash_to_index(hashValue); return the_table()->lookup(index, chars, length, hashValue); } @@ -574,7 +662,7 @@ oop StringTable::lookup(Symbol* symbol) { oop StringTable::intern(Handle string_or_null, jchar* name, int len, TRAPS) { - unsigned int hashValue = java_lang_String::hash_string(name, len); + unsigned int hashValue = hash_string(name, len); int index = the_table()->hash_to_index(hashValue); oop string = the_table()->lookup(index, name, len, hashValue); @@ -675,3 +763,52 @@ void StringTable::verify() { } } } + +void StringTable::dump(outputStream* st) { + NumberSeq summary; + for (int i = 0; i < the_table()->table_size(); ++i) { + HashtableEntry* p = the_table()->bucket(i); + int count = 0; + for ( ; p != NULL; p = p->next()) { + count++; + } + summary.add((double)count); + } + st->print_cr("StringTable statistics:"); + st->print_cr("Number of buckets : %7d", summary.num()); + st->print_cr("Average bucket size : %7.0f", summary.avg()); + st->print_cr("Variance of bucket size : %7.0f", summary.variance()); + st->print_cr("Std. dev. of bucket size: %7.0f", summary.sd()); + st->print_cr("Maximum bucket size : %7.0f", summary.maximum()); +} + + +unsigned int StringTable::new_hash(oop string) { + ResourceMark rm; + int length; + jchar* chars = java_lang_String::as_unicode_string(string, length); + // Use alternate hashing algorithm on the string + return AltHashing::murmur3_32(seed(), chars, length); +} + +// Create a new table and using alternate hash code, populate the new table +// with the existing strings. Set flag to use the alternate hash code afterwards. +void StringTable::rehash_table() { + assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); + assert(!DumpSharedSpaces, "this should never happen with -Xshare:dump"); + StringTable* new_table = new StringTable(); + + // Initialize new global seed for hashing. + _seed = AltHashing::compute_seed(); + assert(seed() != 0, "shouldn't be zero"); + + // Rehash the table + the_table()->move_to(new_table); + + // Delete the table and buckets (entries are reused in new table). + delete _the_table; + // Don't check if we need rehashing until the table gets unbalanced again. + // Then rehash with a new global seed. + _needs_rehashing = false; + _the_table = new_table; +} diff --git a/hotspot/src/share/vm/classfile/symbolTable.hpp b/hotspot/src/share/vm/classfile/symbolTable.hpp index 3e0777fc7c1..6afc2524498 100644 --- a/hotspot/src/share/vm/classfile/symbolTable.hpp +++ b/hotspot/src/share/vm/classfile/symbolTable.hpp @@ -40,6 +40,7 @@ // - symbolTableEntrys are allocated in blocks to reduce the space overhead. class BoolObjectClosure; +class outputStream; // Class to hold a newly created or referenced Symbol* temporarily in scope. @@ -78,6 +79,10 @@ private: // The symbol table static SymbolTable* _the_table; + // Set if one bucket is out of balance due to hash algorithm deficiency + static bool _needs_rehashing; + static jint _seed; + // For statistics static int symbols_removed; static int symbols_counted; @@ -119,6 +124,11 @@ private: static Arena* arena() { return _arena; } // called for statistics static void initialize_symbols(int arena_alloc_size = 0); + + static bool use_alternate_hashcode() { return _seed != 0; } + static jint seed() { return _seed; } + + unsigned int new_hash(Symbol* sym); public: enum { symbol_alloc_batch_size = 8, @@ -146,6 +156,8 @@ public: initialize_symbols(); } + static unsigned int hash_symbol(const char* s, int len, unsigned int hashValue = 0); + static Symbol* lookup(const char* name, int len, TRAPS); // lookup only, won't add. Also calculate hash. static Symbol* lookup_only(const char* name, int len, unsigned int& hash); @@ -208,6 +220,7 @@ public: // Debugging static void verify(); + static void dump(outputStream* st); // Sharing static void copy_buckets(char** top, char*end) { @@ -219,8 +232,13 @@ public: static void reverse(void* boundary = NULL) { the_table()->Hashtable::reverse(boundary); } + + // Rehash the symbol table if it gets out of balance + static void rehash_table(); + static bool needs_rehashing() { return _needs_rehashing; } }; + class StringTable : public Hashtable { friend class VMStructs; @@ -228,6 +246,10 @@ private: // The string table static StringTable* _the_table; + // Set if one bucket is out of balance due to hash algorithm deficiency + static bool _needs_rehashing; + static jint _seed; + static oop intern(Handle string_or_null, jchar* chars, int length, TRAPS); oop basic_add(int index, Handle string_or_null, jchar* name, int len, unsigned int hashValue, TRAPS); @@ -241,6 +263,10 @@ private: : Hashtable((int)StringTableSize, sizeof (HashtableEntry), t, number_of_entries) {} + static bool use_alternate_hashcode() { return _seed != 0; } + static jint seed() { return _seed; } + + unsigned int new_hash(oop s); public: // The string table static StringTable* the_table() { return _the_table; } @@ -265,6 +291,14 @@ public: // Invoke "f->do_oop" on the locations of all oops in the table. static void oops_do(OopClosure* f); + // Hashing algorithm, used as the hash value used by the + // StringTable for bucket selection and comparison (stored in the + // HashtableEntry structures). This is used in the String.intern() method. + static unsigned int hash_string(const jchar* s, int len, unsigned int hashValue = 0); + + // Internal test. + static void test_alt_hash() PRODUCT_RETURN; + // Probing static oop lookup(Symbol* symbol); @@ -275,6 +309,7 @@ public: // Debugging static void verify(); + static void dump(outputStream* st); // Sharing static void copy_buckets(char** top, char*end) { @@ -286,6 +321,9 @@ public: static void reverse() { the_table()->Hashtable::reverse(); } -}; + // Rehash the symbol table if it gets out of balance + static void rehash_table(); + static bool needs_rehashing() { return _needs_rehashing; } +}; #endif // SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP diff --git a/hotspot/src/share/vm/memory/dump.cpp b/hotspot/src/share/vm/memory/dump.cpp index e91d33135e4..c9950524220 100644 --- a/hotspot/src/share/vm/memory/dump.cpp +++ b/hotspot/src/share/vm/memory/dump.cpp @@ -62,8 +62,8 @@ public: // written later, increasing the likelihood that the shared page contain // the hash can be shared. // -// NOTE THAT the algorithm in StringTable::hash_string() MUST MATCH the -// algorithm in java.lang.String.hashCode(). +// NOTE THAT we have to call java_lang_String::to_hash() to match the +// algorithm in java.lang.String.toHash(). class StringHashCodeClosure: public OopClosure { private: @@ -80,7 +80,7 @@ public: oop obj = *p; if (obj->klass() == SystemDictionary::String_klass() && java_lang_String::has_hash_field()) { - int hash = java_lang_String::hash_string(obj); + int hash = java_lang_String::to_hash(obj); obj->int_field_put(hash_offset, hash); } } diff --git a/hotspot/src/share/vm/prims/jni.cpp b/hotspot/src/share/vm/prims/jni.cpp index b37f44a9120..166bbd6079d 100644 --- a/hotspot/src/share/vm/prims/jni.cpp +++ b/hotspot/src/share/vm/prims/jni.cpp @@ -23,6 +23,7 @@ */ #include "precompiled.hpp" +#include "classfile/altHashing.hpp" #include "classfile/classLoader.hpp" #include "classfile/javaClasses.hpp" #include "classfile/symbolTable.hpp" @@ -5053,6 +5054,7 @@ void execute_internal_vm_tests() { run_unit_test(arrayOopDesc::test_max_array_length()); run_unit_test(CollectedHeap::test_is_in()); run_unit_test(QuickSort::test_quick_sort()); + run_unit_test(AltHashing::test_alt_hash()); tty->print_cr("All internal VM tests passed"); } } diff --git a/hotspot/src/share/vm/runtime/globals.hpp b/hotspot/src/share/vm/runtime/globals.hpp index 1838252c37b..ff4adf0109e 100644 --- a/hotspot/src/share/vm/runtime/globals.hpp +++ b/hotspot/src/share/vm/runtime/globals.hpp @@ -2662,6 +2662,9 @@ class CommandLineFlags { product(bool, UseHeavyMonitors, false, \ "use heavyweight instead of lightweight Java monitors") \ \ + product(bool, PrintStringTableStatistics, false, \ + "print statistics about the StringTable and SymbolTable") \ + \ notproduct(bool, PrintSymbolTableSizeHistogram, false, \ "print histogram of the symbol table") \ \ diff --git a/hotspot/src/share/vm/runtime/init.cpp b/hotspot/src/share/vm/runtime/init.cpp index c0e870ea26e..d46de5c6532 100644 --- a/hotspot/src/share/vm/runtime/init.cpp +++ b/hotspot/src/share/vm/runtime/init.cpp @@ -23,6 +23,7 @@ */ #include "precompiled.hpp" +#include "classfile/symbolTable.hpp" #include "code/icBuffer.hpp" #include "gc_interface/collectedHeap.hpp" #include "interpreter/bytecodes.hpp" @@ -157,6 +158,10 @@ void exit_globals() { // Print the collected safepoint statistics. SafepointSynchronize::print_stat_on_exit(); } + if (PrintStringTableStatistics) { + SymbolTable::dump(tty); + StringTable::dump(tty); + } ostream_exit(); } } diff --git a/hotspot/src/share/vm/runtime/safepoint.cpp b/hotspot/src/share/vm/runtime/safepoint.cpp index 514e7c97657..c29d257cc3f 100644 --- a/hotspot/src/share/vm/runtime/safepoint.cpp +++ b/hotspot/src/share/vm/runtime/safepoint.cpp @@ -23,6 +23,7 @@ */ #include "precompiled.hpp" +#include "classfile/symbolTable.hpp" #include "classfile/systemDictionary.hpp" #include "code/codeCache.hpp" #include "code/icBuffer.hpp" @@ -526,8 +527,20 @@ void SafepointSynchronize::do_cleanup_tasks() { CompilationPolicy::policy()->do_safepoint_work(); } - TraceTime t4("sweeping nmethods", TraceSafepointCleanupTime); - NMethodSweeper::scan_stacks(); + { + TraceTime t4("sweeping nmethods", TraceSafepointCleanupTime); + NMethodSweeper::scan_stacks(); + } + + if (SymbolTable::needs_rehashing()) { + TraceTime t5("rehashing symbol table", TraceSafepointCleanupTime); + SymbolTable::rehash_table(); + } + + if (StringTable::needs_rehashing()) { + TraceTime t6("rehashing string table", TraceSafepointCleanupTime); + StringTable::rehash_table(); + } // rotate log files? if (UseGCLogFileRotation) { diff --git a/hotspot/src/share/vm/utilities/hashtable.cpp b/hotspot/src/share/vm/utilities/hashtable.cpp index 698e137ff82..1b722195d8b 100644 --- a/hotspot/src/share/vm/utilities/hashtable.cpp +++ b/hotspot/src/share/vm/utilities/hashtable.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -86,6 +86,55 @@ template HashtableEntry* Hashtable::new_entry(unsigned int hashV } +// Check to see if the hashtable is unbalanced. The caller set a flag to +// rehash at the next safepoint. If this bucket is 60 times greater than the +// expected average bucket length, it's an unbalanced hashtable. +// This is somewhat an arbitrary heuristic but if one bucket gets to +// rehash_count which is currently 100, there's probably something wrong. + +bool BasicHashtable::check_rehash_table(int count) { + assert(table_size() != 0, "underflow"); + if (count > (((double)number_of_entries()/(double)table_size())*rehash_multiple)) { + // Set a flag for the next safepoint, which should be at some guaranteed + // safepoint interval. + return true; + } + return false; +} + +// Create a new table and using alternate hash code, populate the new table +// with the existing elements. This can be used to change the hash code +// and could in the future change the size of the table. + +template void Hashtable::move_to(Hashtable* new_table) { + int saved_entry_count = number_of_entries(); + + // Iterate through the table and create a new entry for the new table + for (int i = 0; i < new_table->table_size(); ++i) { + for (HashtableEntry* p = bucket(i); p != NULL; ) { + HashtableEntry* next = p->next(); + T string = p->literal(); + // Use alternate hashing algorithm on the symbol in the first table + unsigned int hashValue = new_hash(string); + // Get a new index relative to the new table (can also change size) + int index = new_table->hash_to_index(hashValue); + p->set_hash(hashValue); + unlink_entry(p); + new_table->add_entry(index, p); + p = next; + } + } + // give the new table the free list as well + new_table->copy_freelist(this); + assert(new_table->number_of_entries() == saved_entry_count, "lost entry on dictionary copy?"); + + // Destroy memory used by the buckets in the hashtable. The memory + // for the elements has been used in a new table and is not + // destroyed. The memory reuse will benefit resizing the SystemDictionary + // to avoid a memory allocation spike at safepoint. + free_buckets(); +} + // Reverse the order of elements in the hash buckets. void BasicHashtable::reverse() { diff --git a/hotspot/src/share/vm/utilities/hashtable.hpp b/hotspot/src/share/vm/utilities/hashtable.hpp index 527470938d9..46b9c1bbe62 100644 --- a/hotspot/src/share/vm/utilities/hashtable.hpp +++ b/hotspot/src/share/vm/utilities/hashtable.hpp @@ -159,8 +159,6 @@ public: // Reverse the order of elements in each of the buckets. void reverse(); - static unsigned int hash_symbol(const char* s, int len); - private: // Instance variables int _table_size; @@ -179,6 +177,11 @@ protected: void verify_lookup_length(double load); #endif + enum { + rehash_count = 100, + rehash_multiple = 60 + }; + void initialize(int table_size, int entry_size, int number_of_entries); // Accessor @@ -193,6 +196,34 @@ protected: // Table entry management BasicHashtableEntry* new_entry(unsigned int hashValue); + // Check that the table is unbalanced + bool check_rehash_table(int count); + + // Used when moving the entry to another table + // Clean up links, but do not add to free_list + void unlink_entry(BasicHashtableEntry* entry) { + entry->set_next(NULL); + --_number_of_entries; + } + + // Move over freelist and free block for allocation + void copy_freelist(BasicHashtable* src) { + _free_list = src->_free_list; + src->_free_list = NULL; + _first_free_entry = src->_first_free_entry; + src->_first_free_entry = NULL; + _end_block = src->_end_block; + src->_end_block = NULL; + } + + // Free the buckets in this hashtable + void free_buckets() { + if (NULL != _buckets) { + FREE_C_HEAP_ARRAY(HashtableBucket, _buckets); + _buckets = NULL; + } + } + public: int table_size() { return _table_size; } void set_entry(int index, BasicHashtableEntry* entry); @@ -249,6 +280,10 @@ protected: HashtableEntry** bucket_addr(int i) { return (HashtableEntry**)BasicHashtable::bucket_addr(i); } + + // Function to move these elements into the new table. + void move_to(Hashtable* new_table); + virtual unsigned int new_hash(T) { ShouldNotReachHere(); return 0; } // should be overridden }; diff --git a/hotspot/src/share/vm/utilities/hashtable.inline.hpp b/hotspot/src/share/vm/utilities/hashtable.inline.hpp index 8cd2f89d0c8..68741427975 100644 --- a/hotspot/src/share/vm/utilities/hashtable.inline.hpp +++ b/hotspot/src/share/vm/utilities/hashtable.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -30,27 +30,6 @@ // Inline function definitions for hashtable.hpp. - -// -------------------------------------------------------------------------- -// Hash function - -// We originally used hashpjw, but hash P(31) gives just as good results -// and is slighly faster. We would like a hash function that looks at every -// character, since package names have large common prefixes, and also because -// hash_or_fail does error checking while iterating. - -// hash P(31) from Kernighan & Ritchie - -inline unsigned int BasicHashtable::hash_symbol(const char* s, int len) { - unsigned int h = 0; - while (len-- > 0) { - h = 31*h + (unsigned) *s; - s++; - } - return h; -} - - // -------------------------------------------------------------------------- // Initialize a table. diff --git a/hotspot/test/runtime/7158800/BadUtf8.java b/hotspot/test/runtime/7158800/BadUtf8.java new file mode 100644 index 00000000000..8b79762a365 --- /dev/null +++ b/hotspot/test/runtime/7158800/BadUtf8.java @@ -0,0 +1,1254 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7158800 + * @summary Test that 1200 symbols that hash to the same value triggers + * the symbol table alternate hashing mechanism. There isn't actually a + * way to verify this. + */ +// +// Generate large number of strings that hash to the same value +// to slow down symbol table lookup. + +import java.io.BufferedOutputStream; +import java.io.FileOutputStream; + +public class BadUtf8 { +static String[] strings = { + "EOcLKvbddZyPxYpb", + "DncLKvbdPxmAGrqj", + "DoCjjvbdpxoIHQdY", + "EPCkKvbdqYoHfqEY", + "DnbkKvbdezvYdiUX", + "DnbjjvbdeEoRbXCj", + "EObkKvbdbsCkUEKB", + "EOcLKvbdnUtyjiqf", + "DncLKvbdRWnDcMHc", + "DoCkKvbdrSUkOLAm", + "DncLKvbdfNFwGmJk", + "EPDLKvbdvAdYroFI", + "DoDLKvbdiGibyViu", + "DncLKvbdYqNEhmFR", + "DoCkKvbdEARhlzXX", + "DncLKvbdSZjHsCvA", + "DncKjvbdqTsgRqkU", + "DnbjjvbdqAiFAXHd", + "EPDKjvbdGcjvJaij", + "DnbkKvbdwtldpxkn", + "DoDKjvbdYkrETnMN", + "EPCjjvbdbBWEfQQX", + "EPCjjvbduMXwAtBX", + "DncLKvbdbsCkTcia", + "DoCjjvbdczYpYZRC", + "EOcKjvbdFeiqmhsq", + "DoCkKvbdKCicQibx", + "EOcKjvbdZLrEUOLm", + "DoCjjvbdaNKbStmH", + "DoDKjvbdJbjDQjDY", + "EPCkKvbdemFwGmKL", + "EPDKjvbdZQleImEq", + "DncKjvbdZjShPfbG", + "DnbjjvbdqYnhHREY", + "DoCkKvbdaRfDIUGL", + "DoDKjvbdLrWlyuQz", + "DnbjjvbdZisHofaf", + "EObjjvbdhtydvrUb", + "DnbjjvbdRotHKGEX", + "EObjjvbdNeEThhkE", + "EPCjjvbdZtJJZESn", + "DoDKjvbdnPyxvLYb", + "EPDKjvbdeEoRbWbj", + "EOcLKvbdFxttaEXb", + "EObjjvbddwystRez", + "EPCjjvbdJpzEnenF", + "DnbkKvbdTppntuIN", + "EPCkKvbdTukpKUBR", + "DnbkKvbdhlFEOUcZ", + "EObkKvbdlhdUQuRa", + "DnbjjvbdkClKqHUg", + "EOcKjvbdqTtGqqkU", + "DncKjvbdtkwvaUBX", + "DoDKjvbdsQWOjCuf", + "DncLKvbdEKIJuwjA", + "DncKjvbdGLErcIMu", + "EOcLKvbdNPwpumfs", + "EObkKvbdnVUzLJrG", + "DoCkKvbdcTDKsdKB", + "DncKjvbdKRZdoFme", + "EOcLKvbdemFvgNKL", + "EPCkKvbdznopdblY", + "EPDLKvbdOYPVzdOU", + "DnbjjvbdsZlPsAhO", + "DoDLKvbdKCjDRKDY", + "DoCkKvbdhuZeXSVC", + "EPDKjvbdOStVgEtp", + "DncLKvbdvwMAvBWV", + "EPDKjvbdBcoaWJlf", + "EOcKjvbdZxdKODMS", + "DoCjjvbdbsCkTcjB", + "EOcLKvbdwWlAuaWV", + "DnbjjvbdFejRnJUR", + "DnbjjvbdmIdTqVSB", + "DnbkKvbdqBIeAWhE", + "DncKjvbdrMzJyMIJ", + "DoCkKvbdZGvdAOsJ", + "DncLKvbdjggLfFnL", + "DoCjjvbdYqNFJMdq", + "DoCkKvbdqZPHfqDx", + "DncLKvbdOEdThiLE", + "DoCkKvbdZirgpGaf", + "EPDLKvbdziuQPdSt", + "EObkKvbdKQyeOenF", + "DoDLKvbduaDySndh", + "DoCjjvbdVUNUGLvK", + "DncKjvbdAMhYrvzY", + "DnbkKvbdnQZxvKxb", + "EPCjjvbdBhjakJFj", + "DncLKvbdmfeYNNfy", + "DoDLKvbdjlbLydfo", + "DoDLKvbdpyPIGpcx", + "EOcLKvbdnVUzLJqf", + "DoCjjvbdmJETqVSB", + "DoDLKvbdJTZAsMxM", + "DoCkKvbdnQZxvLZC", + "DoDKjvbdACqwizJQ", + "DncKjvbdvBEZSoFI", + "DncKjvbdGckVjCJj", + "DncLKvbdiMFENtcZ", + "Dnbjjvbdjuvmcaww", + "DnbkKvbdZyEKNblS", + "DoCjjvbduMYXBUBX", + "DnbjjvbdFWYopNJe", + "DoDKjvbdelfXGljL", + "DnbjjvbdakLenmcA", + "EPDKjvbdfILWRmpg", + "EObjjvbdSLYeuHLT", + "DoCjjvbdMfbolotk", + "EPDLKvbdrRuKnKaN", + "EOcKjvbdyzdnRhIh", + "DoDLKvbdGAoRZJzm", + "DoCjjvbdhlFDnUcZ", + "EPDLKvbdmpZyVkYb", + "DncKjvbdTpqPUuIN", + "DncLKvbdHDjvJaij", + "EPDLKvbdYlRcsmkm", + "EPDLKvbdvlvAMdFN", + "DncKjvbdIsZArmYM", + "EOcLKvbdegjuqnQg", + "EOcLKvbdZQmFJNFR", + "DoCjjvbdZxdJmcMS", + "EPCkKvbdlZTSTYgU", + "DoDKjvbdqceJPnWB", + "DncLKvbdVgwuxGxz", + "DncKjvbdDnbkLXDE", + "EPDLKvbdatbHYKsh", + "DncKjvbdEzsqFLbi", + "EPDLKvbdnVVZkKRf", + "EOcKjvbdKeegbBQu", + "EPCkKvbdKfGHaaRV", + "EPDKjvbdmIctRVRa", + "EPCjjvbdRMxBxnUz", + "DnbjjvbdJYTbILpp", + "EPCkKvbdTAEiHbPE", + "EOcLKvbdfelZnGgA", + "DoCjjvbdOStWGeUp", + "EOcLKvbdemGXHNJk", + "DoDKjvbdYTMAmUOx", + "EPCkKvbdpyOhGpcx", + "EPCkKvbdAMgxsWzY", + "DnbjjvbdYkrETnMN", + "EPDLKvbdUQqPUtgm", + "DncKjvbdehKurNqH", + "DoCjjvbdZMSETnLm", + "DoDKjvbdIHGyyXwg", + "EObjjvbdXGYzUAPT", + "DoCjjvbdhbPCeWqR", + "DoCkKvbdKNADzGuB", + "DnbjjvbdFeirOJTq", + "DncLKvbdaRecHtFk", + "DnbkKvbdzoPpeClY", + "EObkKvbdZRMeJMeR", + "DnbjjvbdYfvdAPSi", + "DncLKvbdJcKCqJcY", + "EOcLKvbdqvokbhyR", + "DoDLKvbdrRuLNjaN", + "DoCjjvbdTlWPBWOi", + "DoCkKvbdjvWnEBxX", + "DoDLKvbdTkunaVoJ", + "DoCkKvbdQZNAHTSK", + "EObjjvbdqwPkbhyR", + "EOcLKvbdNHDPlpUk", + "DncLKvbdIHHZxxYH", + "DncLKvbdtkxXAtAw", + "DncLKvbdSCEFMJZL", + "DnbjjvbdZQmEhldq", + "DoCjjvbdNGbolotk", + "DnbjjvbdnCKWwnmu", + "DncLKvbdzHZMANEw", + "DoDKjvbdmttykJrG", + "DnbkKvbdlrZUzSci", + "EPDKjvbdSKyGVHKs", + "DoCjjvbdKVuGEFGi", + "EPCjjvbdCIkBkIej", + "DncLKvbdzHZMAMeX", + "DnbkKvbdaSFbgsek", + "DncLKvbdHDjujBij", + "DoDKjvbdGZVUaDwb", + "DnbjjvbdZnnJFEzK", + "DoCkKvbdtcDUwWOo", + "DoCkKvbdlBMoNALA", + "EOcKjvbdNsUWHFUp", + "DoDLKvbdVUNUFlVj", + "DnbkKvbdhkdcnUcZ", + "DncLKvbdLiBkqYAS", + "EOcKjvbdzoPpdcLx", + "EPDKjvbdijGIJmXr", + "EOcKjvbdZisHofaf", + "DoDLKvbdeOdrkUUS", + "DoDLKvbdnPyxvKxb", + "EPDKjvbdIxUBhMRQ", + "DncLKvbdlhctRUqa", + "DoDLKvbdmgFXlnGy", + "DncKjvbdCJKbKiGK", + "EOcLKvbddndrjtUS", + "DnbjjvbdkDLjqGuH", + "DncKjvbdmIcsptqa", + "DoCkKvbdvvlAvBWV", + "EObjjvbdjblLQftg", + "DnbjjvbdCEQBWKMf", + "DnbjjvbdBdPaVilf", + "DoCkKvbdZxcjODLr", + "DoCkKvbdEObjjwCd", + "EPDKjvbdyTNhlqbH", + "EPCkKvbdUMVoAvPJ", + "DncKjvbdUxhUZjoO", + "DncKjvbdqqtjmkAm", + "DncKjvbdKfGICBRV", + "EPCjjvbdVrOXaeLc", + "EPDLKvbdwXLaWBWV", + "EPCkKvbdjblKqHUg", + "DnbjjvbduDCuWuoP", + "EPDKjvbdNGbpMouL", + "EObjjvbdBcoaVjNG", + "DncLKvbdrWpMDIxq", + "DncLKvbdhaoCdwRR", + "DnbkKvbdFxtuBDwb", + "DncKjvbdIjEAKPgE", + "EOcLKvbduCbuXVoP", + "DoDKjvbdZtIiZDsO", + "DnbjjvbdEztRElCi", + "DncLKvbdxmsHwsJD", + "DnbjjvbdRbEElIxk", + "DoDKjvbdWHwvXgYz", + "EOcKjvbdQlwbYnUz", + "EOcLKvbdVTltFkuj", + "DncKjvbdliETptqa", + "DnbkKvbddoErjtTr", + "DoCkKvbdgPazvdXh", + "DncKjvbdySmhlqag", + "DoCjjvbdbPgHDkzd", + "DoCkKvbdFWZPomKF", + "EObjjvbdssSSxydc", + "EObjjvbdzQnliJwA", + "EObkKvbdKCjCpibx", + "EPCjjvbdpyOhHREY", + "DncLKvbddjJqutzn", + "EObkKvbdBdQAujMf", + "EPCkKvbdLAjflbXq", + "DncLKvbdLBLGlaxR", + "DoDLKvbdrpWPJbuf", + "DoCjjvbdEKHiuxKA", + "DoCjjvbdXsMAlsnx", + "EObkKvbdptTgSSLU", + "DoDKjvbdnHFXmNfy", + "DncKjvbdCJKbKhej", + "EPCjjvbdhlEdOUby", + "EOcKjvbdKWUfEFGi", + "DoDKjvbdZQmFJMdq", + "EPCjjvbdiGjDZWKV", + "EObkKvbdVAbQrprZ", + "DoDKjvbdfekzNgHA", + "DoDLKvbdnHEwlmgZ", + "DncKjvbdwzHeexEr", + "DoCjjvbdmpZxujyC", + "EPDKjvbdwMvAMcdm", + "DoCjjvbdfHkVrNqH", + "EPCkKvbdYzbfRiuy", + "EPCkKvbdZtIiZDrn", + "DnbjjvbdjvWnDbYX", + "DoCjjvbdOStVgEtp", + "EPDLKvbdZMSETmlN", + "EPDKjvbdBhjajhej", + "EPCjjvbddoFTLUUS", + "DnbkKvbdsQVoJcWG", + "EPCjjvbdrEFJQNvB", + "DoCjjvbdMpYRWOGs", + "EOcLKvbdZirgpHBf", + "EPDLKvbdyOTIXsJD", + "DoCkKvbdKRZdnfNe", + "DnbjjvbdbBWFFoow", + "EPCjjvbdgFlZnHHA", + "DnbkKvbdGGJrOIsq", + "DoDLKvbduDCtwWPP", + "EObjjvbdNddUIhjd", + "DnbjjvbdxsNiMqag", + "EObjjvbddeOrCWbj", + "EObjjvbdPxmAGsRj", + "EOcLKvbddeOrCXDK", + "DoDLKvbddeOrBwCj", + "DoCjjvbdVqnYCElD", + "DnbkKvbdUyIUZjoO", + "EObjjvbdeFOrCXDK", + "EObkKvbdVrNxCFLc", + "EObjjvbdTfzmkwWF", + "EOcKjvbdIHGzZYYH", + "EPDKjvbdtbbuXWPP", + "DoCjjvbdZisIQHBf", + "EObjjvbdbsCkUDjB", + "EPCkKvbdVwJXudFH", + "EPDKjvbdrouoKDVf", + "EPCkKvbdFyVVBEYC", + "DncLKvbdZnnIeEzK", + "EPDLKvbdxVNFQxkn", + "DoDKjvbdpxnggRDx", + "DoDLKvbdqZOgfpcx", + "DncKjvbdCIjakJGK", + "EPCkKvbdCJLBjhej", + "DoDLKvbdnPzYvKxb", + "EOcKjvbdqTsgSRkU", + "EOcLKvbdLBLGlaxR", + "DoDLKvbdcbTMrAUN", + "DncLKvbdzitoodSt", + "DoDKjvbdJvUfDdfi", + "EOcLKvbdHDjvKCJj", + "EPCkKvbdeOeTKssr", + "DnbkKvbdlYrqsYft", + "DncLKvbdiiehKMxS", + "DncKjvbdURQoVUhN", + "DnbkKvbduMYXBUAw", + "DoDLKvbdSPtHJfEX", + "EObkKvbdqBJFAWgd", + "EOcKjvbdFpATWgFy", + "DoDLKvbdBsBDTfXS", + "DncKjvbdjhHLfFmk", + "DoCjjvbdCJKakIfK", + "DnbkKvbddoFSjtTr", + "EObkKvbdANIYsWzY", + "EObjjvbdCTAbtFvr", + "EObjjvbdrRtkOLAm", + "DnbkKvbdkxsSTYgU", + "DoCjjvbdnBiwXnmu", + "EObjjvbdwtmEqYlO", + "EPDKjvbdrylQTAhO", + "DoDLKvbdtbbtvvOo", + "EPCjjvbdZLrETmlN", + "EPDLKvbdWXJYWDdg", + "DoCkKvbdKQzFOfOF", + "EPCjjvbdwzIFfXeS", + "DncKjvbdRjyFuHLT", + "EPDLKvbdULunaWPJ", + "DncKjvbdUxhTykOn", + "DnbkKvbdJcKCqKDY", + "EPDLKvbdcbSmSATm", + "DnbkKvbdegjurNqH", + "EPDKjvbdZjTIQGbG", + "EPCjjvbdiLddNuCy", + "DoCjjvbdZQldiNEq", + "EOcLKvbdakMGPODA", + "EObjjvbdnHEwlmgZ", + "EOcLKvbdBsAcUGXS", + "EPCkKvbdiVZdwSUb", + "EOcLKvbddCTNSAUN", + "DnbkKvbdEXxMUUUM", + "DncKjvbdYpldiMeR", + "DoDKjvbdNddTiIjd", + "DoDLKvbdZLqdUNlN", + "EPCkKvbdiBncFWpq", + "DncLKvbdiCPDEvqR", + "EOcKjvbdUyHszKoO", + "DncKjvbdhtydvqtb", + "EPCjjvbdpxoHgQcx", + "EObkKvbdkWWnDaxX", + "DnbjjvbdBhkBkJFj", + "DoCkKvbdRacdkhyL", + "EOcLKvbdZjTHpHCG", + "EPCkKvbdMowqWOGs", + "DncLKvbdegjurNpg", + "EObjjvbdfMfWfmKL", + "EPDLKvbdZirgpGaf", + "DoDLKvbdiZuFlQnG", + "DncLKvbdFxuVAcxC", + "EObkKvbdZisHofaf", + "EOcKjvbdJSyBSmYM", + "EPDLKvbdVYgtZkPO", + "EOcKjvbdRbEFMJYk", + "DncLKvbdrEFIonWB", + "DncKjvbdKDJbqJcY", + "EOcLKvbdhfjCxuiu", + "EObjjvbdLLAhWAKZ", + "DoCkKvbdRXNcblID", + "DoDLKvbdcbSmSATm", + "EOcLKvbdwWlAvAuu", + "EObkKvbdiBnbdvpq", + "DoCkKvbdNQXpumgT", + "DncLKvbdkVwOECYX", + "DnbkKvbdfoazwDxI", + "DoDLKvbdbBWFFpPw", + "DoDLKvbdvBDxsPEh", + "EPDKjvbdJqZdoFme", + "DoDLKvbdIryArmXl", + "EPCjjvbdANIZSwZx", + "EPCkKvbdVhYVxGxz", + "DncKjvbdLAjgNCYR", + "DncKjvbdxxIjCQZk", + "DncKjvbdbiNKKewY", + "EPCjjvbdlrZVZsEJ", + "EPDKjvbdIryAsMwl", + "DoCkKvbdtAHRIAAr", + "EPDKjvbdJmAEZfuB", + "EPCkKvbdZjSgogBf", + "DoDLKvbdOXnuzcnU", + "DnbkKvbdehKvRnQg", + "EObjjvbdZyDimbkr", + "DoDKjvbdmajWwoOV", + "EOcKjvbdkMalZeHP", + "EOcKjvbdIjEAJpHE", + "EPCkKvbdDihKVxKA", + "DncKjvbdNddUIiKd", + "EObjjvbdqdFIpOWB", + "DoCkKvbdxnShXsJD", + "DoDLKvbdjmBkzEfo", + "EOcLKvbdatagYLTh", + "DoCjjvbdVhYVxHYz", + "DnbjjvbdJbjDRKDY", + "EPCjjvbdLBLHNCYR", + "DnbjjvbdnGeYNOGy", + "EOcLKvbdUsmTekvK", + "EPCjjvbdtkxXBTaX", + "EPCjjvbdzoPqFCkx", + "DncKjvbdCIjbKhej", + "DncKjvbdZLqdTmkm", + "DoDKjvbdsPunicVf", + "EOcKjvbdmgFXmNgZ", + "EObkKvbdiMFENuCy", + "DoDKjvbdhanbeXRR", + "EObkKvbdACqwiyhp", + "DncKjvbdZisIQHBf", + "EPCjjvbdgQBzwDwh", + "DnbjjvbdyYJJaoyk", + "DoDKjvbdxUldqZMO", + "EObkKvbdkClLQgVH", + "EPCjjvbdZQldiMeR", + "EPDLKvbdZyEKOClS", + "EPDLKvbdcIlikFvx", + "DoDKjvbdrzMQTBHn", + "DnbjjvbdVYgtZkPO", + "DoDLKvbdHEKuiajK", + "EPCkKvbdczZQXxqC", + "DoDKjvbdrDdiQNua", + "DncLKvbdcImKLGWx", + "DoCjjvbdVYgtZkPO", + "EPDLKvbdZnnIeFZj", + "EPDKjvbdMIakqYAS", + "DoCkKvbdSLYfUgLT", + "EPDLKvbdiCObdvpq", + "DnbjjvbdRpUHKFcw", + "DoDLKvbdIHHZyYXg", + "EPCjjvbdypoMhiwA", + "DnbkKvbdCEPaVjMf", + "DnbkKvbderAvzlDP", + "DnbkKvbdZQleImFR", + "EOcKjvbdKRZdneme", + "DoDLKvbdiBnbeXQq", + "DncLKvbdEPDKjvcE", + "EOcLKvbdauCGwkTh", + "DncLKvbdEvZQPmJe", + "EPCkKvbdURQnuVIN", + "DncLKvbdegjvSOQg", + "EPCjjvbdKaKgMawq", + "DnbkKvbdRzKISbvA", + "DncLKvbdiLdcnUcZ", + "EPDLKvbdkDMKpfuH", + "DoDLKvbdRbDdkhyL", + "DnbjjvbdDwxMUUTl", + "DnbkKvbdrpWPKCuf", + "DnbkKvbdNVSqjmAX", + "DoDKjvbdRbDeMIxk", + "EOcLKvbdcyxpXyRC", + "DncLKvbdRMwbYnUz", + "EObjjvbdqlzJxlHi", + "DoCkKvbdJYUCIMQp", + "DncLKvbdLZQjSzuG", + "EOcKjvbdxVNEqYkn", + "DnbkKvbdZoOIeFZj", + "DoCjjvbdBraCtFwS", + "EOcLKvbdliDsqVSB", + "EPCkKvbdeATqNXif", + "DncLKvbdkMbLydgP", + "EObjjvbdZxdJmbkr", + "DoCjjvbdraellHLZ", + "EObkKvbduDCuWvPP", + "DoCkKvbdpstGrSLU", + "DoCjjvbdLGFgbBQu", + "DnbkKvbdhtzFWquC", + "EObjjvbdoAKztHdO", + "EPDLKvbdatafxKtI", + "EPDKjvbdkWXNcaww", + "DoCkKvbdwkXEHzzG", + "EObkKvbdmgEwmNgZ", + "DncKjvbdBiLCLJFj", + "DoCjjvbdeOdsKssr", + "EOcLKvbdfILWSORH", + "EObkKvbdCDpAujMf", + "EPDKjvbdKDKDQibx", + "DoDKjvbdVUMtGLuj", + "EObkKvbdrXQMCiYq", + "DncKjvbdePEsLTtS", + "DncLKvbdDxYLtUTl", + "EPCkKvbdGYuVBEYC", + "DncLKvbdNeEUIiKd", + "EPCkKvbdpxoIHRDx", + "EObjjvbdFkEsDHlu", + "EObjjvbdssSSxzFD", + "DoCkKvbdUtNTfMVj", + "DnbjjvbdJcKDRKDY", + "DncKjvbdqiAKEmOe", + "DoDKjvbdtlXwAtBX", + "DnbkKvbdxmsIYTIc", + "EObkKvbdLrXMzUpz", + "DoCjjvbdkxsSSxft", + "DncKjvbdQlwaxnUz", + "EObkKvbdjhGlFfNk", + "EPCkKvbdxsNhmRag", + "DoDLKvbdMfcPmQUk", + "DoDKjvbdQvnEDLhD", + "EObjjvbdVgxVxHYz", + "DoDLKvbdlrYtyrdJ", + "DoCjjvbdezvYeIsw", + "DncLKvbdNddTiIjd", + "EPDLKvbdGGJrNiUR", + "EPDLKvbdRzJhTDWA", + "EPCjjvbdvvkaWBVu", + "EOcKjvbdRXNdCkgc", + "EOcKjvbdQZNAHTSK", + "EPCkKvbdsCGNLfkZ", + "EOcLKvbdDwwktTsl", + "EOcLKvbdqlzJyLgi", + "EOcLKvbdxsNiMqag", + "EOcLKvbdhzVFlROG", + "EOcKjvbdEztRFMCi", + "DnbkKvbdqiAJdmPF", + "EPDLKvbdjcMKqGtg", + "EObkKvbdTlWOaWOi", + "EPDLKvbdURRPUuHm", + "DoDKjvbdelfWgNKL", + "EOcLKvbdGAnqZJzm", + "EObjjvbdGZUuAdXb", + "DoDLKvbduLwwAtAw", + "DoCjjvbdZjTIQGbG", + "EPCjjvbdRNXbYnUz", + "EPDLKvbdiLeENtby", + "EObjjvbdMowpunGs", + "EOcKjvbdbiNJjevx", + "DoDKjvbdEYYLstTl", + "DoDLKvbdqUTfrRjt", + "DoDKjvbdbsCkUEJa", + "DoDKjvbdXsMBNUPY", + "EPCjjvbdRNXaxnUz", + "DoDLKvbdNGcQNQUk", + "DnbjjvbdEARiMywX", + "EPDKjvbdSKxfUfkT", + "DncKjvbdhtyeXRtb", + "DncKjvbdZLqcsnLm", + "EObkKvbdZnmheEzK", + "EObjjvbdtbcUvuno", + "DnbjjvbdrzMQTBHn", + "DnbjjvbdDwwktTsl", + "EPDKjvbdkxsSTYgU", + "DoDKjvbdIryArlxM", + "DoDKjvbdnBivxOnV", + "DoDKjvbdeATplwif", + "EOcLKvbdKeegbApu", + "EPCjjvbdMgDQMotk", + "DoCjjvbduCbtwWOo", + "DnbkKvbdyNsHwrhc", + "DnbkKvbdtvNxJpsA", + "EOcLKvbdqAheAWgd", + "DoCkKvbdURQoUtgm", + "EOcKjvbdqceIpOWB", + "DoCkKvbdVwIwudFH", + "DnbkKvbdbLMFnmcA", + "EOcLKvbdZjTHpHBf", + "EOcKjvbdRXNdCkhD", + "EPDLKvbdiHJcZViu", + "DoCjjvbdxxIjCPzL", + "DnbkKvbdBcpBWJmG", + "EPCkKvbdZyEKOCkr", + "EPDKjvbdOTUWHFVQ", + "DoCjjvbdIGgZxwwg", + "EPDLKvbdFjeSbhMu", + "EPDLKvbdhgKCxvJu", + "EOcLKvbdNsUWGdtp", + "EPDKjvbduVnXipsA", + "DncLKvbdGYuVBEXb", + "EPDLKvbdZtIhyESn", + "DoDKjvbdZxdJmcLr", + "DoCjjvbdUsltGLuj", + "DoDKjvbdDoDLKvbd", + "DncLKvbdrDdhpNvB", + "EPDLKvbdKCjDRJbx", + "DoDLKvbdxLWdHzyf", + "EObkKvbdrzMQTAhO", + "EOcLKvbdOFDtJJKd", + "EPCkKvbdrSVKmjaN", + "EOcKjvbdWWiYVdEg", + "EOcKjvbdWWhwvDdg", + "DncKjvbdpstHRqjt", + "EPCkKvbdKWVFceGi", + "DoCkKvbdZjShPfbG", + "DoCkKvbdSxKlNzkY", + "EPDLKvbdIwtCHkqQ", + "EOcKjvbdsCGNLgLZ", + "DncKjvbdzaAOfgCM", + "DoDLKvbdxmrhYSiD", + "DncLKvbdfMfWgMjL", + "EPDKjvbdqFdEsuaI", + "EOcLKvbdiLeDnUcZ", + "DoCjjvbdKVuFceHJ", + "DoCjjvbdfekzNgHA", + "EOcKjvbdOFEThiLE", + "EPDLKvbdqceJPnWB", + "DoDLKvbduCbtwWOo", + "DncKjvbdTqROtuIN", + "DncKjvbdpedFUWBI", + "DoDLKvbdrEFJQNua", + "DoDLKvbdyXhjCPyk", + "EPCkKvbdJYUBhLqQ", + "EPCkKvbdtcCuXVno", + "DoDLKvbdZLrEUOLm", + "EPCkKvbdpstGrRjt", + "DncLKvbddePSCXCj", + "EObkKvbdauCHXjsh", + "DoDLKvbdkHfkefNk", + "EObjjvbdMRwMzUpz", + "EObjjvbdaMkCTVNH", + "DoCkKvbdGGJrNhtR", + "EPDLKvbdvBDxrneI", + "EPDLKvbdIHHZxwxH", + "EOcLKvbdrJAJdmPF", + "EOcKjvbdGZUuAdXb", + "EOcLKvbdbUbHYLUI", + "DnbjjvbdJzofYEAN", + "EPDKjvbdFxtuBDxC", + "DnbkKvbdQvnDbkgc", + "EPDKjvbdJmADzGta", + "DoDKjvbdZRMdhleR", + "DnbkKvbdsrqsZZeD", + "EObkKvbdrovPJbuf", + "EPCjjvbddeOqbXCj", + "EObjjvbdtcDVXVoP", + "DncKjvbdMfbpNQVL", + "DoCkKvbdhbPCeXQq", + "DoCkKvbdNHComQVL", + "EObjjvbdvBDxroFI", + "EPCjjvbdnBivwoNu", + "EObjjvbdbhljKewY", + "EPDKjvbdZyDimcMS", + "EObkKvbdWSOXbElD", + "EOcKjvbdTfznMXVe", + "EPCjjvbdZtJJYcsO", + "DoCjjvbdRjxfVHLT", + "DoCkKvbdVTltGMVj", + "DncKjvbdYfwEAOri", + "DncKjvbdYkrEUOMN", + "EObkKvbdqGEEsuaI", + "DncLKvbdjJfHimXr", + "EPDLKvbddndsLUTr", + "DnbkKvbdqBJFAWhE", + "EPDLKvbdEOcKjwDE", + "EPCkKvbdtvOYJqTA", + "DncLKvbdkyTRsZHU", + "DoCjjvbdTppnuVIN", + "DncLKvbdwyhFeweS", + "DncKjvbdsBelkgKy", + "DoCjjvbdKDKCqJcY", + "DoCjjvbdkClKqHVH", + "DoCjjvbdcTCjtDia", + "EPDLKvbdUVkpJtAq", + "EPDLKvbdRyjITCvA", + "DnbjjvbdJuuFcdgJ", + "DoDKjvbdrJAJdmOe", + "DncKjvbdJcJbqKCx", + "DoDLKvbdJcJbqJcY", + "DoDKjvbdeEoSCXDK", + "DoDLKvbdSwjlNzkY", + "EObjjvbdzitopDrt", + "DoCkKvbdKWVGEEgJ", + "DncKjvbdpssfqrKt", + "EOcLKvbdUMWPBVoJ", + "DncKjvbdyzdmrIIh", + "EPCjjvbdxUldqZLn", + "DoDLKvbdySnImRbH", + "DoCjjvbdGdKvJaij", + "DoCkKvbdxZgeewdr", + "EObkKvbdiLddNuDZ", + "DnbjjvbdSCDdkiZL", + "DncKjvbdznpREcMY", + "EOcLKvbdaRebhTfL", + "DnbjjvbdZQldiMdq", + "EPCjjvbdbrbjtEKB", + "EOcKjvbdEARiMzXX", + "DoDLKvbdXrkaNTnx", + "EPCkKvbdQZNAHTRj", + "DoDLKvbdEzspeLcJ", + "EPCjjvbduVnYKRTA", + "EObjjvbdJXtBhMQp", + "EPDKjvbdeOdrjssr", + "EPCjjvbdLqwMytpz", + "EPDKjvbdUMVoBVoJ", + "DncKjvbdRpUGifDw", + "EPDLKvbdZyDinDLr", + "DnbkKvbdNrsufeVQ", + "EPCkKvbdZMSDtNlN", + "EPCkKvbdySnJNSCH", + "EPCjjvbdfMevfljL", + "DncLKvbdXsMBNTnx", + "DnbkKvbdpxoHfqDx", + "DncLKvbdUQpntthN", + "DncKjvbdIsZArlwl", + "DoDLKvbdZGwEAOsJ", + "EOcKjvbdVvhwvDdg", + "EOcLKvbduWNxJqTA", + "EPCjjvbdHEKvJaij", + "DoDKjvbdrpWOjCuf", + "DncLKvbdrpWOjDVf", + "DoCjjvbdIHGzYwwg", + "DoDLKvbdpxoIGqEY", + "DoDLKvbdJcJbqKDY", + "DoCjjvbdRWmdClHc", + "EPCjjvbdFWYopNJe", + "DncKjvbdmfdwlmfy", + "DoCkKvbdxUleQxlO", + "EObjjvbdnGdxMnGy", + "EPCjjvbdvvlAvBVu", + "DncLKvbddndsKssr", + "EObjjvbdZMRcsnLm", + "EOcKjvbdFxttaEXb", + "DncKjvbdVUNTfMVj", + "EOcLKvbdNrtWHFUp", + "DoDKjvbdwuMdqYlO", + "EPDLKvbdrXPkbhxq", + "EObjjvbdrEFIpNua", + "EObjjvbdziuQQDrt", + "EOcLKvbdqYoIGpcx", + "DnbjjvbdsQVoJcVf", + "EObkKvbdkDMKpgUg", + "EObjjvbdvBDyTPFI", + "DncKjvbduCbuWvOo", + "EPCjjvbdkVvnECYX", + "DncLKvbdZGvdAOri", + "DoCkKvbdrXPlDJZR", + "EOcLKvbduCcVWvOo", + "DoDKjvbdCEPaWJlf", + "EPDKjvbddoErjssr", + "DncKjvbdACqxKZiQ", + "EPCjjvbdUVlPitAq", + "EPDKjvbdjJfHjMxS", + "EObkKvbdAMhYsWzY", + "DoDKjvbdnBivxOmu", + "EOcLKvbdbiNKKfXY", + "EPDKjvbdYqMeIleR", + "EObkKvbdJmADygUa", + "EObjjvbdEPDLLWcE", + "EPCjjvbdrXPkcIxq", + "EOcLKvbdliDtQtqa", + "DoCjjvbdmoyxujyC", + "EPDLKvbddoFTLTsr", + "EOcLKvbdCWzdJEpW", + "DnbjjvbdrEEhpOWB", + "DoDKjvbdZLrDtNkm", + "EOcLKvbdLFfHbAqV", + "EOcKjvbdmttzLKSG", + "EOcLKvbdmbJvwoOV", + "EOcKjvbdUaCQrqSZ", + "DnbjjvbdmgExMnGy", + "EPDKjvbddndrkUUS", + "EObkKvbdDwwkstTl", + "DoCkKvbdcJMjLFwY", + "DnbjjvbdaNLBruMg", + "DoDLKvbdQYmAHTRj", + "DnbkKvbdsQWOicWG", + "EObkKvbdMRwMzUpz", + "DoDLKvbdZshiZDrn", + "EPDLKvbdnPzYujxb", + "EOcKjvbdCEQAujMf", + "EPDLKvbdKefHbApu", + "DoDLKvbdYpldiNFR", + "DoCkKvbdFWZQQNJe", + "DncLKvbdznpQeCkx", + "EOcKjvbdnQZxvKxb", + "DoCkKvbdVBBprpqy", + "DnbkKvbdZirhPfaf", + "DnbkKvbdegjvSNqH", + "EOcLKvbdqdEiPnWB", + "EObjjvbdBhkCKiGK", + "EObjjvbdxZgfGYFS", + "DnbjjvbdNQYQumgT", + "EPCjjvbdxsNhlrBg", + "DoCkKvbdQdDApRDr", + "DoCkKvbdxxIiaoyk", + "EPDKjvbdFeirNhtR", + "DoCjjvbdegjvSOQg", + "EObkKvbdqcdiQNvB", + "DncLKvbdiMEdNtcZ", + "DncLKvbdTqRPUthN", + "EPCkKvbdwygeexFS", + "DoDKjvbdyTOJMrBg", + "DncLKvbdeEoRavbj", + "EPCjjvbdtbcUvvOo", + "EObjjvbdKCicRJcY", + "EObjjvbdZyEKODMS", + "DnbjjvbdmJDtQtrB", + "DncLKvbdEARhlyvw", + "DnbjjvbdIxTbILqQ", + "EOcLKvbdwygefYFS", + "DoCjjvbdznoqFCkx", + "DoCjjvbdRpUGjGDw", + "DncKjvbdhzVGMQnG", + "EPCjjvbdhkeDnVCy", + "EObkKvbdOEdUIiKd", + "DncKjvbdrDeIomua", + "DncLKvbdiHJbxuiu", + "EPDKjvbddxZstRez", + "EPDLKvbdmSYuZrdJ", + "EObkKvbdVUNUFkvK", + "EPDLKvbdNeEUJIjd", + "DoCkKvbdiMEdNuCy", + "DoDLKvbdRDcApQcr", + "EPCjjvbdTlVoBVoJ", + "EObjjvbdLBKgNBwq", + "EPCkKvbdsCFllHKy", + "EObjjvbdnVUzLJqf", + "DoDKjvbdqrVLNkBN", + "DoCkKvbdqFcdtWBI", + "DncLKvbdbVCGxLTh", + "EOcLKvbdeFPSCXCj", + "EOcLKvbdRpTgKFdX", + "EObjjvbdznpQeDLx", + "EOcKjvbdjvXNcaxX", + "DnbjjvbdHDkWJbJj", + "DncKjvbdhkeENuDZ", + "DnbkKvbdnUtyjjSG", + "DoDKjvbdSQUHJfDw", + "DncKjvbdbUbHYLUI", + "EOcLKvbdNsTvGduQ", + "EPDLKvbdSZigsCvA", + "DncKjvbdMfcPlpUk", + "DoDLKvbdxrnIlrBg", + "DncKjvbdiLdcnVCy", + "EPCjjvbdmfeYNOHZ", + "DoCkKvbdjvWmcaxX", + "DoDKjvbdbUbHXkUI", + "DncKjvbdBhkBjiFj", + "DoDLKvbdNHColpVL", + "EOcKjvbdrykosAhO", + "DncLKvbdqGDeUVaI", + "DnbkKvbdhgJcZViu", + "DnbjjvbduLxXAtBX", + "EPCjjvbdYpleJNFR", + "EPDLKvbdQvmdClHc", + "DnbjjvbdJYTbIMRQ", + "DncLKvbdznpRFDMY", + "EOcLKvbdZnmiFEyj", + "DnbkKvbdrRuLOLAm", + "EObkKvbdhkeEOUby", + "DncLKvbdYlSEUOLm", + "DoCjjvbdhkdcmtby", + "DncLKvbdddnrCXDK", + "DoDLKvbdKaLHNCYR", + "EOcKjvbdcyxpYZQb", + "EPDLKvbdACqwjZhp", + "DoCkKvbdBsBDTevr", + "EObkKvbdeKJqvUzn", + "EObkKvbdcImJkGWx", + "DncLKvbdYSlAltOx", + "DncLKvbdlrYtyrdJ", + "EObkKvbdKxqJrztf", + "EOcKjvbdsQWPJcVf", + "DoDKjvbdkySqrxgU", + "EObjjvbdeEoRbXCj", + "EOcKjvbdHDkVjBij", + "DoDLKvbdCTBCsfXS", + "DoCjjvbdKCjDQibx", + "DoCjjvbdlhdTqUrB", + "DoDKjvbdTulQKTaR", + "DoCkKvbdRjxetfkT", + "EPCjjvbdEuyQQNKF", + "EPCjjvbdDoDKkXDE", + "DoCjjvbdsQWPJbuf", + "DoDKjvbdhuZdvqtb", + "EPDLKvbdiHKCyWJu", + "EPDLKvbdLFegaaQu", + "DoCjjvbdqZPHgRDx", + "DncKjvbdUWMPjUAq", + "DoDLKvbdTYKkmzjx", + "DoDKjvbdegjvSOQg", + "DnbkKvbdUtNTekvK", + "EObkKvbdNsTvGeVQ", + "DoDLKvbdfNFvgMjL", + "EOcLKvbdZQmEiNEq", + "EPDKjvbdBraDTfWr", + "EPDKjvbdNGcQNQVL", + "EPDLKvbdZyEKODMS", + "EOcKjvbdBvzdIdpW", + "EPCjjvbdACqwiyiQ", + "DoCjjvbddePRawCj", + "EPDKjvbdWWiXucdg", + "DoDKjvbdWexzUAPT", + "DnbjjvbdwXMBWBWV", + "EOcLKvbdUyHszLOn", + "EPCkKvbdOYOuzcnU", + "EPCkKvbdhancEwQq", + "DnbkKvbdjggLefOL", + "EPCkKvbdFjdsDIMu", + "DoDKjvbdrSUjmkBN", + "DoDLKvbdZjTIQGaf", + "DoDKjvbdMgDPmPtk", + "EPDLKvbdWRmwbFMD", + "DoCkKvbdzROmJKXA", + "DnbkKvbdrDdiQNvB", + "DnbjjvbduDCtwVoP", + "EOcLKvbdCIjbLJFj", + "EPDKjvbdXrkaMsnx", + "EPDKjvbdVhXvXfxz", + "DncKjvbdhbPDEwRR", + "DoCkKvbdpxoHgQcx", + "DoCkKvbduMXwBUBX", + "EObjjvbdNeEThhjd", + "DoCjjvbdirzhrkJz", + "DoDLKvbdaMkCTUlg", + "DncLKvbdWRnYBeLc", + "DnbjjvbdGBPRZJzm", + "EOcLKvbdeOeSjstS", + "DoDLKvbdmIctRVSB", + "DoCjjvbdZxdJnDMS", + "DoCkKvbdRpTgKFcw", + "DncLKvbdTukojTaR", + "DnbjjvbdKRZdoFme", + "DnbkKvbdURQoVUhN", + "DoDLKvbdyYJKBozL", + "EObkKvbdfNFwHMjL", + "DoDLKvbdZisIQHBf", + "EObkKvbdqFcdsuaI", + "DncLKvbdzoPqFDLx", + "DoDKjvbdSKxeuHLT", + "EPDKjvbdsBemLfjy", + "DoCjjvbdJbjCqJcY", + "DoCjjvbdNPxRVnGs", + "DncLKvbdGcjvJbKK", + "EOcKjvbdrWpMDIxq", + "EOcLKvbdQdDApQcr", + "DoDKjvbdZMRdTnLm", + "EOcLKvbddxZssrFz", + "EObjjvbdUtNTfLuj", + "EPCjjvbdLLBIWAKZ", + "DoCkKvbdgFlZmfgA", + "EPCjjvbdUVkoitAq", + "DoDKjvbdDncKjvcE", + "DoDLKvbdRpUHJfEX", + "EPDKjvbdLqvlzVQz", + "EPDKjvbdZMRdUOLm", + "EOcLKvbdCJLBkIfK", + "DncKjvbdaSFbhUFk", + "EPDLKvbdZoNheEzK", + "DncKjvbdUVlPjUAq", + "DnbkKvbdKNADyfuB", + "EObkKvbdZdwfzghb", + "EPDLKvbdZtIhxcrn", + "EObkKvbdGckViajK", + "DncLKvbdFfJqmiUR", + "DncKjvbdKWUfDdgJ", + "DoDKjvbdMtrqjmAX", + "EOcLKvbdsQWPKDVf", + "DoCjjvbdwtleRZMO", + "EObjjvbduaDxsPEh", + "EPDLKvbdKxqJrzuG", + "EOcKjvbdVAaprprZ", + "EObjjvbdEuxopMjF", + "DnbjjvbdyOTHwriD", + "EPDLKvbdrpVnibvG", + "EPDKjvbdkWWnDaww", + "DncLKvbdrXPkbiYq", + "DoDLKvbddxZssqez", + "EOcLKvbdHDkWJbJj", + "DncLKvbdEPCkLWcE", + "DnbkKvbdEXwkstTl", + "EObjjvbdqiAKEmOe", + "DncLKvbdjAQGaQGj", + "EPCjjvbdNeDtJJKd", + "EPCjjvbdvwMBWBVu", + "EPDKjvbdFejSOItR", + "EOcLKvbdNPwqWOHT", + "EPDKjvbdbsCjscia", + "EObkKvbdyYIiaoyk", + "DoDKjvbdLZQirzuG", + "EObjjvbdSLZGVGjs", + "DoCjjvbdAMgxsWzY", + "DoDLKvbdEObjjwCd", + "DnbkKvbdsPvOicWG", + "EPCkKvbdrJAKElne", + "EPCkKvbdauCGwjsh", + "DncLKvbdegkWRnQg", + "EPCkKvbdYpmEiNFR", + "DoDKjvbduaDxsPFI", + "DoCjjvbdcyxoxYqC", + "DoCkKvbdkMakzFHP", + "DnbjjvbdJbibqJbx", + "DnbkKvbdWWhxWDeH", + "DoCjjvbdssRsYzFD", + "DoDKjvbdpyPIHRDx", + "DncLKvbdwNWANDeN", + "DoDKjvbdJYUBglRQ", + "EObkKvbdXnRAYVVt", + "DoCjjvbdUWLpKTaR", + "DoDKjvbdTqROttgm", + "EPCkKvbdVqnXaeMD", + "EObjjvbdADRwiyiQ", + "DoDKjvbdlrZUyrci", + "EPDKjvbdvAdZSndh", + "DoCkKvbdzoQQeDLx", + "DnbkKvbdSQUGjFdX", + "EOcLKvbdqBJFAXIE", + "EObkKvbdSCEFLiZL", + "DnbjjvbdzoQQdcMY", + "DnbkKvbdpxngfqEY", + "DncLKvbdbsDLUEKB", + "DoCjjvbdXrlBMtOx", + "EObjjvbdKCjDQicY", + "DncLKvbdLrWlzUpz", + "EObjjvbdaaWEfQQX", + "EObjjvbdtlYWaTaX", + "DnbkKvbdMowpunGs", + "EObkKvbdSLYeuHKs", + "EObkKvbdTAEhhCOd", + "EPCkKvbdmSYtyrci", + "DncLKvbdYkqcsnLm", + "DoDLKvbdrylQTAgn", + "DncLKvbdJXtCIMRQ", + "EObkKvbdSBdElIyL", + "DoDLKvbdwygefYFS", + "DncKjvbdyXhibPzL", + "EPCjjvbduaDxsPFI", + "EObjjvbdZoNiFEzK", + "EPCjjvbdkNBkyeHP", + "EPCkKvbdWRnXadlD", + "DncLKvbdRWmdDLhD", + "DnbkKvbdmSYtzTDi", + "EOcKjvbdkVwODbXw", + "DncLKvbdQlxCZOUz", + "EObjjvbdbhlijfXY", + "EOcLKvbdXmqAXtut", + "EOcLKvbdmbKXXnnV", + "DoDKjvbdkHgMFfOL", + "EPCkKvbdfekymgHA", + "DoCjjvbdeKKRvUzn", + "DoDKjvbdkHfkefNk", + "DoCjjvbdyqPMiKXA", + "DnbjjvbdUQqOtuIN", + "EOcKjvbdEPCkKwDE", + "DoDLKvbdZRNFIleR", + "DnbjjvbdRacdlJZL", + "EOcLKvbdTukoitAq", + "EOcLKvbdZLrDtOMN", + "EOcLKvbdgKfzcGAE", + "EObjjvbdzjVQQESt", + "EOcLKvbdcIlijevx", + "EOcKjvbdGKdsDHmV", + "DncLKvbdKkBHvAJy", + "EOcKjvbdZMRctOLm", + "EPCkKvbdADRxKZiQ", + "EObjjvbdDwxLsssl", + "EPDLKvbdUxgszLPO", + "EPCkKvbdSQTfiedX", + "EPCjjvbdNeEUJIkE", + "DoDLKvbdpyPHfqDx", + "DnbkKvbdyOShXsJD", + "DncLKvbdLiBkpxAS", + "DoDKjvbdaaWEepQX", + "DoCjjvbdWSOYBeLc", + "EOcKjvbdLFegbAqV", + "EPDKjvbdffLzOGgA", + "EObkKvbdFkErbglu", + "DncLKvbdiZuFlROG", + "DncKjvbdegkWRnQg", + "DoDLKvbdQdDApRDr", + "EOcLKvbdeYZtURez", + "EObjjvbdrXQLcIxq", + "DoDLKvbdxZhGGXeS", + "DoDLKvbdGGKSOItR", + "EObjjvbdjhHLfFnL", + "EOcLKvbdUQpoUuHm", + "DoCkKvbdXrlBNUPY", + "DoDKjvbdJXtCIMRQ", + "DnbkKvbdZMSDsnLm", + "DncKjvbdCTBDUGWr", + "DncKjvbdbhlikGXY", + "DoDKjvbdXmqAYVWU", + "DnbjjvbdliDsqVRa", + "DnbkKvbdmajXYOnV", + "EObjjvbdJpyePGNe", + "DnbkKvbdCTAcUGXS", + "DoDLKvbdCDpBVjNG", + "EOcLKvbdxwhiaoyk", + "DoDKjvbdxVNFQyMO", + "EPCkKvbdVvhwvEEg", + "DnbkKvbdFWYoomJe", + "EOcKjvbdlrZUysEJ", + "EPDKjvbdqquKnKaN", + "DoCkKvbdTkunaVoJ", + "EOcLKvbdfHkVrOQg", + "EPDLKvbdiUzFWrUb", + "DoDLKvbdtAGqIABS", + "DoCkKvbdZRMdhmEq", + "DnbkKvbdNsUVfeVQ", + "EPDLKvbdqwPkbiZR", + "DoCkKvbdNUsSLNAX", + "DncKjvbdmpZxvKyC", + "EPCkKvbdLYqKSztf", + "EPDKjvbdZyEKODMS", + "EPDKjvbdNGbomPuL", + "DncKjvbdZMSDtNlN", + "EPCjjvbdTXjkmzjx", + "EObkKvbdBdQAvKMf", + "EOcLKvbdkySrTYgU", + "DnbkKvbdZoOIddzK", + "DoCkKvbdZMSDsmkm", + "EPCkKvbdCWzdIdpW", + "DncLKvbdBvzdIdov", + "DoCjjvbdaRfDHtFk", + "DnbkKvbdWeyZtAOs", + "DoDLKvbdnCJwYPOV", + "DoCjjvbdEYYLstUM", + "EOcLKvbdwtldqZMO", + "EPCjjvbdFVxoomKF", + "EObkKvbdyqPMhiwA", + "DoDLKvbdkxrrSxgU", + "DoCjjvbdeATqNYKG", + "DncLKvbdJKEAJpHE", + "DoCkKvbddndsLUTr", + "DnbjjvbdqFceUWBI", + "DoDLKvbdhkddOUby", + "DncKjvbdGKdrcIMu", + "EPCkKvbdelevflik", + "DoDKjvbdhaoDFWqR", + "DoCjjvbdYlSDsmlN", + "EPCjjvbdiZuGLpmf", + "EObkKvbdnCJvxPNu", + "DnbkKvbdhzUelRNf", + "DnbkKvbdZeYGzgiC", + "DoCkKvbdDnbkLWbd", + "DnbkKvbdnHFYMmfy", + "DoCjjvbdePEsKtTr", + "DnbjjvbdZQmEhleR", + "DnbkKvbdTkunaVoJ", + "DnbkKvbdFWZPpMjF", + "DoDKjvbdSwkMNzkY", + "EOcLKvbdwtldpyMO", + "EOcKjvbdhkdcmtby", + "DoCjjvbdNQXqWNfs", + "EPDKjvbdzjUpPdTU", + "DnbjjvbdqceJPnWB", + "EPDKjvbdUyHsyjoO", + "EPCkKvbdZshhxcsO", + "DncKjvbdqAiFAWgd", + "EObkKvbdgFkzOGgA", + "DncKjvbdmgFYNNgZ", + "DoDLKvbdDjHjWYKA", + "DnbjjvbdJbicRKCx", + "DnbkKvbdfNFwHMjL", + "EPCkKvbdWSNxBdlD", + "EPDLKvbdCJKbLJFj", + "EPDKjvbdEOcKkXDE", + "EPCkKvbdVrOYCElD", + "DnbjjvbdCIkBjhej", + "DoDLKvbddoFTKstS", + "DnbjjvbduDDVXVoP", + "EObkKvbdxwiKCPzL", + "DnbkKvbdZGvdAPTJ", + "DoDLKvbdBdPaVjNG", + "EOcKjvbdIHGzYwxH", + "DoCjjvbdGFjSNhsq", + "DnbjjvbdlYsSSxgU", + "EPCjjvbdqrUjnKaN", + "EOcLKvbdtvOXipsA", + "DoDLKvbdrounjCuf", + "DoCkKvbdFVyPomKF", + "EOcKjvbdNHCpNPtk", + "EPDLKvbdWeyZtAPT", + "EPDKjvbdjcLkQfuH", + "EOcLKvbdzHZMAMeX", + "DoCjjvbdUMWPBVni", + "EOcKjvbdHELWKBjK", + "DoDKjvbdMgComQUk", + "DnbkKvbdiGjDZWJu", + "DncKjvbdyqOmJKXA", + "DoDKjvbdVZITyjoO", + "DoCjjvbdzQoNJJwA", + "EOcLKvbdGAoQxizm", + "DoDKjvbdatagYKsh", + "EPDKjvbdSBceMJYk", + "DoDLKvbdMpYQvOHT", + "DncKjvbdiCOcFWpq", + "DoCjjvbdUGznLvvF", + "EPDLKvbdANIYrvyx", + "EPCjjvbdIwtCHkpp", + "EObkKvbdJSyBSmYM", + "EObkKvbdwuMdqYlO", + "EObjjvbdmuVZkKSG", + "DncLKvbdSPsfjFdX", + "DoDLKvbdSQUHJedX", + "DoDKjvbdiVZdwSUb", + "EPDLKvbdRjxfVGkT", + "EObjjvbdmpZyVkZC", + "DncLKvbdhzUelROG", + "EPCkKvbdxVMeRZMO", + "EOcKjvbdxxIiapZk", + "EOcKjvbdJSyBTNYM", + "EPDKjvbdMSXMzUpz", + "EObkKvbdJmADzHVB" }; + + public static void main(java.lang.String[] unused) { + try { + BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("bad.out")); + for (int i = 0; i < strings.length; i++) { + out.write(strings[i].getBytes()); + out.write("\n".getBytes()); + } + out.close(); + } catch (Exception e) { + System.out.println("Some exception occurred"); + } + } +} diff --git a/hotspot/test/runtime/7158800/InternTest.java b/hotspot/test/runtime/7158800/InternTest.java new file mode 100644 index 00000000000..d0cd1c024f2 --- /dev/null +++ b/hotspot/test/runtime/7158800/InternTest.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7158800 + * @run shell/timeout=400 Test7158800.sh + * @summary This test performs poorly if alternate hashing isn't used for + * string table. + * The timeout is handled by the shell file (which kills the process) + */ +import java.util.*; +import java.io.*; + +public class InternTest { + public static void main (String args[]) throws Exception { + final String badStringsFilename = "badstrings.txt"; + + if (args.length == 0 || (!args[0].equals("bad") && !args[0].equals("normal"))) { + System.out.println("Usage: java InternTest [normal|bad]"); + System.exit(1); + } + + FileInputStream fstream = new FileInputStream(badStringsFilename); + DataInputStream in = new DataInputStream(fstream); + BufferedReader br = new BufferedReader(new InputStreamReader(in)); + String toIntern, toDiscard; + int count = 0; + long current = 0L; + long last = System.currentTimeMillis(); + + if (args[0].equals("bad")) { + while ((toIntern = br.readLine()) != null) { + toDiscard = new String((new Integer((int)(Math.random() * Integer.MAX_VALUE))).toString()); + toIntern.intern(); + count++; + if (count % 10000 == 0 && count != 0) { + current = System.currentTimeMillis(); + System.out.println(new Date(current) + ": interned " + count + " 0-hash strings - last 10000 took " + ((float)(current - last))/1000 + "s (" + ((float)(current - last))/10000000 + "s per String)"); + last = current; + } + } + } + if (args[0].equals("normal")) { + while ((toDiscard = br.readLine()) != null) { // do the same read from the file to try and make the test fair + toIntern = new String((new Integer((int)(Math.random() * Integer.MAX_VALUE))).toString()); + toIntern.intern(); + count++; + if (count % 10000 == 0 && count != 0) { + current = System.currentTimeMillis(); + System.out.println(new Date(current) + ": interned " + count + " normal strings - last 10000 took " + ((float)(current - last))/1000 + "s (" + ((float)(current - last))/10000000 + "s per String)"); + last = current; + } + } + } + in.close(); + } +} + + diff --git a/hotspot/test/runtime/7158800/badstrings.txt b/hotspot/test/runtime/7158800/badstrings.txt new file mode 100644 index 00000000000..d7f76fb838e --- /dev/null +++ b/hotspot/test/runtime/7158800/badstrings.txt @@ -0,0 +1,30001 @@ +EOcLKvbddZyPxYpb +DncLKvbdPxmAGrqj +DoCjjvbdpxoIHQdY +EPCkKvbdqYoHfqEY +DnbkKvbdezvYdiUX +DnbjjvbdeEoRbXCj +EObkKvbdbsCkUEKB +EOcLKvbdnUtyjiqf +DncLKvbdRWnDcMHc +DoCkKvbdrSUkOLAm +DncLKvbdfNFwGmJk +EPDLKvbdvAdYroFI +DoDLKvbdiGibyViu +DncLKvbdYqNEhmFR +DoCkKvbdEARhlzXX +DncLKvbdSZjHsCvA +DncKjvbdqTsgRqkU +DnbjjvbdqAiFAXHd +EPDKjvbdGcjvJaij +DnbkKvbdwtldpxkn +DoDKjvbdYkrETnMN +EPCjjvbdbBWEfQQX +EPCjjvbduMXwAtBX +DncLKvbdbsCkTcia +DoCjjvbdczYpYZRC +EOcKjvbdFeiqmhsq +DoCkKvbdKCicQibx +EOcKjvbdZLrEUOLm +DoCjjvbdaNKbStmH +DoDKjvbdJbjDQjDY +EPCkKvbdemFwGmKL +EPDKjvbdZQleImEq +DncKjvbdZjShPfbG +DnbjjvbdqYnhHREY +DoCkKvbdaRfDIUGL +DoDKjvbdLrWlyuQz +DnbjjvbdZisHofaf +EObjjvbdhtydvrUb +DnbjjvbdRotHKGEX +EObjjvbdNeEThhkE +EPCjjvbdZtJJZESn +DoDKjvbdnPyxvLYb +EPDKjvbdeEoRbWbj +EOcLKvbdFxttaEXb +EObjjvbddwystRez +EPCjjvbdJpzEnenF +DnbkKvbdTppntuIN +EPCkKvbdTukpKUBR +DnbkKvbdhlFEOUcZ +EObkKvbdlhdUQuRa +DnbjjvbdkClKqHUg +EOcKjvbdqTtGqqkU +DncKjvbdtkwvaUBX +DoDKjvbdsQWOjCuf +DncLKvbdEKIJuwjA +DncKjvbdGLErcIMu +EOcLKvbdNPwpumfs +EObkKvbdnVUzLJrG +DoCkKvbdcTDKsdKB +DncKjvbdKRZdoFme +EOcLKvbdemFvgNKL +EPCkKvbdznopdblY +EPDLKvbdOYPVzdOU +DnbjjvbdsZlPsAhO +DoDLKvbdKCjDRKDY +DoCkKvbdhuZeXSVC +EPDKjvbdOStVgEtp +DncLKvbdvwMAvBWV +EPDKjvbdBcoaWJlf +EOcKjvbdZxdKODMS +DoCjjvbdbsCkTcjB +EOcLKvbdwWlAuaWV +DnbjjvbdFejRnJUR +DnbjjvbdmIdTqVSB +DnbkKvbdqBIeAWhE +DncKjvbdrMzJyMIJ +DoCkKvbdZGvdAOsJ +DncLKvbdjggLfFnL +DoCjjvbdYqNFJMdq +DoCkKvbdqZPHfqDx +DncLKvbdOEdThiLE +DoCkKvbdZirgpGaf +EPDLKvbdziuQPdSt +EObkKvbdKQyeOenF +DoDLKvbduaDySndh +DoCjjvbdVUNUGLvK +DncKjvbdAMhYrvzY +DnbkKvbdnQZxvKxb +EPCjjvbdBhjakJFj +DncLKvbdmfeYNNfy +DoDLKvbdjlbLydfo +DoDLKvbdpyPIGpcx +EOcLKvbdnVUzLJqf +DoCjjvbdmJETqVSB +DoDLKvbdJTZAsMxM +DoCkKvbdnQZxvLZC +DoDKjvbdACqwizJQ +DncKjvbdvBEZSoFI +DncKjvbdGckVjCJj +DncLKvbdiMFENtcZ +Dnbjjvbdjuvmcaww +DnbkKvbdZyEKNblS +DoCjjvbduMYXBUBX +DnbjjvbdFWYopNJe +DoDKjvbdelfXGljL +DnbjjvbdakLenmcA +EPDKjvbdfILWRmpg +EObjjvbdSLYeuHLT +DoCjjvbdMfbolotk +EPDLKvbdrRuKnKaN +EOcKjvbdyzdnRhIh +DoDLKvbdGAoRZJzm +DoCjjvbdhlFDnUcZ +EPDLKvbdmpZyVkYb +DncKjvbdTpqPUuIN +DncLKvbdHDjvJaij +EPDLKvbdYlRcsmkm +EPDLKvbdvlvAMdFN +DncKjvbdIsZArmYM +EOcLKvbdegjuqnQg +EOcLKvbdZQmFJNFR +DoCjjvbdZxdJmcMS +EPCkKvbdlZTSTYgU +DoDKjvbdqceJPnWB +DncLKvbdVgwuxGxz +DncKjvbdDnbkLXDE +EPDLKvbdatbHYKsh +DncKjvbdEzsqFLbi +EPDLKvbdnVVZkKRf +EOcKjvbdKeegbBQu +EPCkKvbdKfGHaaRV +EPDKjvbdmIctRVRa +EPCjjvbdRMxBxnUz +DnbjjvbdJYTbILpp +EPCkKvbdTAEiHbPE +EOcLKvbdfelZnGgA +DoCjjvbdOStWGeUp +EOcLKvbdemGXHNJk +DoDKjvbdYTMAmUOx +EPCkKvbdpyOhGpcx +EPCkKvbdAMgxsWzY +DnbjjvbdYkrETnMN +EPDLKvbdUQqPUtgm +DncKjvbdehKurNqH +DoCjjvbdZMSETnLm +DoDKjvbdIHGyyXwg +EObjjvbdXGYzUAPT +DoCjjvbdhbPCeWqR +DoCkKvbdKNADzGuB +DnbjjvbdFeirOJTq +DncLKvbdaRecHtFk +DnbkKvbdzoPpeClY +EObkKvbdZRMeJMeR +DnbjjvbdYfvdAPSi +DncLKvbdJcKCqJcY +EOcLKvbdqvokbhyR +DoDLKvbdrRuLNjaN +DoCjjvbdTlWPBWOi +DoCkKvbdjvWnEBxX +DoDLKvbdTkunaVoJ +DoCkKvbdQZNAHTSK +EObjjvbdqwPkbhyR +EOcLKvbdNHDPlpUk +DncLKvbdIHHZxxYH +DncLKvbdtkxXAtAw +DncLKvbdSCEFMJZL +DnbjjvbdZQmEhldq +DoCjjvbdNGbolotk +DnbjjvbdnCKWwnmu +DncLKvbdzHZMANEw +DoDKjvbdmttykJrG +DnbkKvbdlrZUzSci +EPDKjvbdSKyGVHKs +DoCjjvbdKVuGEFGi +EPCjjvbdCIkBkIej +DncLKvbdzHZMAMeX +DnbkKvbdaSFbgsek +DncLKvbdHDjujBij +DoDKjvbdGZVUaDwb +DnbjjvbdZnnJFEzK +DoCkKvbdtcDUwWOo +DoCkKvbdlBMoNALA +EOcKjvbdNsUWHFUp +DoDLKvbdVUNUFlVj +DnbkKvbdhkdcnUcZ +DncLKvbdLiBkqYAS +EOcKjvbdzoPpdcLx +EPDKjvbdijGIJmXr +EOcKjvbdZisHofaf +DoDLKvbdeOdrkUUS +DoDLKvbdnPyxvKxb +EPDKjvbdIxUBhMRQ +DncLKvbdlhctRUqa +DoDLKvbdmgFXlnGy +DncKjvbdCJKbKiGK +EOcLKvbddndrjtUS +DnbjjvbdkDLjqGuH +DncKjvbdmIcsptqa +DoCkKvbdvvlAvBWV +EObjjvbdjblLQftg +DnbjjvbdCEQBWKMf +DnbjjvbdBdPaVilf +DoCkKvbdZxcjODLr +DoCkKvbdEObjjwCd +EPDKjvbdyTNhlqbH +EPCkKvbdUMVoAvPJ +DncKjvbdUxhUZjoO +DncKjvbdqqtjmkAm +DncKjvbdKfGICBRV +EPCjjvbdVrOXaeLc +EPDLKvbdwXLaWBWV +EPCkKvbdjblKqHUg +DnbjjvbduDCuWuoP +EPDKjvbdNGbpMouL +EObjjvbdBcoaVjNG +DncLKvbdrWpMDIxq +DncLKvbdhaoCdwRR +DnbkKvbdFxtuBDwb +DncKjvbdIjEAKPgE +EOcLKvbduCbuXVoP +DoDKjvbdZtIiZDsO +DnbjjvbdEztRElCi +DncLKvbdxmsHwsJD +DnbjjvbdRbEElIxk +DoDKjvbdWHwvXgYz +EOcKjvbdQlwbYnUz +EOcLKvbdVTltFkuj +DncKjvbdliETptqa +DnbkKvbddoErjtTr +DoCkKvbdgPazvdXh +DncKjvbdySmhlqag +DoCjjvbdbPgHDkzd +DoCkKvbdFWZPomKF +EObjjvbdssSSxydc +EObjjvbdzQnliJwA +EObkKvbdKCjCpibx +EPCjjvbdpyOhHREY +DncLKvbddjJqutzn +EObkKvbdBdQAujMf +EPCkKvbdLAjflbXq +DncLKvbdLBLGlaxR +DoDLKvbdrpWPJbuf +DoCjjvbdEKHiuxKA +DoCjjvbdXsMAlsnx +EObkKvbdptTgSSLU +DoDKjvbdnHFXmNfy +DncKjvbdCJKbKhej +EPCjjvbdhlEdOUby +EOcKjvbdKWUfEFGi +DoDKjvbdZQmFJMdq +EPCjjvbdiGjDZWKV +EObkKvbdVAbQrprZ +DoDKjvbdfekzNgHA +DoDLKvbdnHEwlmgZ +DncKjvbdwzHeexEr +DoCjjvbdmpZxujyC +EPDKjvbdwMvAMcdm +DoCjjvbdfHkVrNqH +EPCkKvbdYzbfRiuy +EPCkKvbdZtIiZDrn +DnbjjvbdjvWnDbYX +DoCjjvbdOStVgEtp +EPDLKvbdZMSETmlN +EPDKjvbdBhjajhej +EPCjjvbddoFTLUUS +DnbkKvbdsQVoJcWG +EPCjjvbdrEFJQNvB +DoCjjvbdMpYRWOGs +EOcLKvbdZirgpHBf +EPDLKvbdyOTIXsJD +DoCkKvbdKRZdnfNe +DnbjjvbdbBWFFoow +EPCjjvbdgFlZnHHA +DnbkKvbdGGJrOIsq +DoDLKvbduDCtwWPP +EObjjvbdNddUIhjd +DnbjjvbdxsNiMqag +EObjjvbddeOrCWbj +EObjjvbdPxmAGsRj +EOcLKvbddeOrCXDK +DoDLKvbddeOrBwCj +DoCjjvbdVqnYCElD +DnbkKvbdUyIUZjoO +EObjjvbdeFOrCXDK +EObkKvbdVrNxCFLc +EObjjvbdTfzmkwWF +EOcKjvbdIHGzZYYH +EPDKjvbdtbbuXWPP +DoCjjvbdZisIQHBf +EObjjvbdbsCkUDjB +EPCkKvbdVwJXudFH +EPDKjvbdrouoKDVf +EPCkKvbdFyVVBEYC +DncLKvbdZnnIeEzK +EPDLKvbdxVNFQxkn +DoDKjvbdpxnggRDx +DoDLKvbdqZOgfpcx +DncKjvbdCIjakJGK +EPCkKvbdCJLBjhej +DoDLKvbdnPzYvKxb +EOcKjvbdqTsgSRkU +EOcLKvbdLBLGlaxR +DoDLKvbdcbTMrAUN +DncLKvbdzitoodSt +DoDKjvbdJvUfDdfi +EOcLKvbdHDjvKCJj +EPCkKvbdeOeTKssr +DnbkKvbdlYrqsYft +DncLKvbdiiehKMxS +DncKjvbdURQoVUhN +DnbkKvbduMYXBUAw +DoDLKvbdSPtHJfEX +EObkKvbdqBJFAWgd +EOcKjvbdFpATWgFy +DoDLKvbdBsBDTfXS +DncKjvbdjhHLfFmk +DoCjjvbdCJKakIfK +DnbkKvbddoFSjtTr +EObkKvbdANIYsWzY +EObjjvbdCTAbtFvr +EObjjvbdrRtkOLAm +DnbkKvbdkxsSTYgU +DoCjjvbdnBiwXnmu +EObjjvbdwtmEqYlO +EPDKjvbdrylQTAhO +DoDLKvbdtbbtvvOo +EPCjjvbdZLrETmlN +EPDLKvbdWXJYWDdg +DoCkKvbdKQzFOfOF +EPCjjvbdwzIFfXeS +DncKjvbdRjyFuHLT +EPDLKvbdULunaWPJ +DncKjvbdUxhTykOn +DnbkKvbdJcKCqKDY +EPDLKvbdcbSmSATm +DnbkKvbdegjurNqH +EPDKjvbdZjTIQGbG +EPCjjvbdiLddNuCy +DoCjjvbdZQldiNEq +EOcLKvbdakMGPODA +EObjjvbdnHEwlmgZ +EOcLKvbdBsAcUGXS +EPCkKvbdiVZdwSUb +EOcLKvbddCTNSAUN +DnbkKvbdEXxMUUUM +DncKjvbdYpldiMeR +DoDKjvbdNddTiIjd +DoDLKvbdZLqdUNlN +EPCkKvbdiBncFWpq +DncLKvbdiCPDEvqR +EOcKjvbdUyHszKoO +DncKjvbdhtydvqtb +EPCjjvbdpxoHgQcx +EObkKvbdkWWnDaxX +DnbjjvbdBhkBkJFj +DoCkKvbdRacdkhyL +EOcLKvbdZjTHpHCG +EPCkKvbdMowqWOGs +DncLKvbdegjurNpg +EObjjvbdfMfWfmKL +EPDLKvbdZirgpGaf +DoDLKvbdiZuFlQnG +DncLKvbdFxuVAcxC +EObkKvbdZisHofaf +EOcKjvbdJSyBSmYM +EPDLKvbdVYgtZkPO +EOcKjvbdRbEFMJYk +DncLKvbdrEFIonWB +DncKjvbdKDJbqJcY +EOcLKvbdhfjCxuiu +EObjjvbdLLAhWAKZ +DoCkKvbdRXNcblID +DoDLKvbdcbSmSATm +EOcLKvbdwWlAvAuu +EObkKvbdiBnbdvpq +DoCkKvbdNQXpumgT +DncLKvbdkVwOECYX +DnbkKvbdfoazwDxI +DoDLKvbdbBWFFpPw +DoDLKvbdvBDxsPEh +EPDKjvbdJqZdoFme +DoDLKvbdIryArmXl +EPCjjvbdANIZSwZx +EPCkKvbdVhYVxGxz +DncKjvbdLAjgNCYR +DncKjvbdxxIjCQZk +DncKjvbdbiNKKewY +EPCjjvbdlrZVZsEJ +EPDKjvbdIryAsMwl +DoCkKvbdtAHRIAAr +EPDKjvbdJmAEZfuB +EPCkKvbdZjSgogBf +DoDLKvbdOXnuzcnU +DnbkKvbdehKvRnQg +EObjjvbdZyDimbkr +DoDKjvbdmajWwoOV +EOcKjvbdkMalZeHP +EOcKjvbdIjEAJpHE +EPCkKvbdDihKVxKA +DncKjvbdNddUIiKd +EObjjvbdqdFIpOWB +DoCkKvbdxnShXsJD +DoDLKvbdjmBkzEfo +EOcLKvbdatagYLTh +DoCjjvbdVhYVxHYz +DnbjjvbdJbjDRKDY +EPCjjvbdLBLHNCYR +DnbjjvbdnGeYNOGy +EOcLKvbdUsmTekvK +EPCjjvbdtkxXBTaX +EPCjjvbdzoPqFCkx +DncKjvbdCIjbKhej +DncKjvbdZLqdTmkm +DoDKjvbdsPunicVf +EOcKjvbdmgFXmNgZ +EObkKvbdiMFENuCy +DoDKjvbdhanbeXRR +EObkKvbdACqwiyhp +DncKjvbdZisIQHBf +EPCjjvbdgQBzwDwh +DnbjjvbdyYJJaoyk +DoDKjvbdxUldqZMO +EObkKvbdkClLQgVH +EPCjjvbdZQldiMeR +EPDLKvbdZyEKOClS +EPDLKvbdcIlikFvx +DoDKjvbdrzMQTBHn +DnbjjvbdVYgtZkPO +DoDLKvbdHEKuiajK +EPCkKvbdczZQXxqC +DoDKjvbdrDdiQNua +DncLKvbdcImKLGWx +DoCjjvbdVYgtZkPO +EPDLKvbdZnnIeFZj +EPDKjvbdMIakqYAS +DoCkKvbdSLYfUgLT +EPDLKvbdiCObdvpq +DnbjjvbdRpUHKFcw +DoDLKvbdIHHZyYXg +EPCjjvbdypoMhiwA +DnbkKvbdCEPaVjMf +DnbkKvbderAvzlDP +DnbkKvbdZQleImFR +EOcKjvbdKRZdneme +DoDLKvbdiBnbeXQq +DncLKvbdEPDKjvcE +EOcLKvbdauCGwkTh +DncLKvbdEvZQPmJe +EPCkKvbdURQnuVIN +DncLKvbdegjvSOQg +EPCjjvbdKaKgMawq +DnbkKvbdRzKISbvA +DncLKvbdiLdcnUcZ +EPDLKvbdkDMKpfuH +DoDLKvbdRbDdkhyL +DnbjjvbdDwxMUUTl +DnbkKvbdrpWPKCuf +DnbkKvbdNVSqjmAX +DoDKjvbdRbDeMIxk +EOcLKvbdcyxpXyRC +DncLKvbdRMwbYnUz +EObjjvbdqlzJxlHi +DoCkKvbdJYUCIMQp +DncLKvbdLZQjSzuG +EOcKjvbdxVNEqYkn +DnbkKvbdZoOIeFZj +DoCjjvbdBraCtFwS +EOcLKvbdliDsqVSB +EPCkKvbdeATqNXif +DncLKvbdkMbLydgP +EObjjvbdZxdJmbkr +DoCjjvbdraellHLZ +EObkKvbduDCuWvPP +DoCkKvbdpstGrSLU +DoCjjvbdLGFgbBQu +DnbkKvbdhtzFWquC +EObjjvbdoAKztHdO +EPDLKvbdatafxKtI +EPDKjvbdkWXNcaww +DoCkKvbdwkXEHzzG +EObkKvbdmgEwmNgZ +DncKjvbdBiLCLJFj +DoCjjvbdeOdsKssr +EOcLKvbdfILWSORH +EObkKvbdCDpAujMf +EPDKjvbdKDKDQibx +DoDKjvbdVUMtGLuj +EObkKvbdrXQMCiYq +DncKjvbdePEsLTtS +DncLKvbdDxYLtUTl +EPCkKvbdGYuVBEYC +DncLKvbdNeEUIiKd +EPCkKvbdpxoIHRDx +EObjjvbdFkEsDHlu +EObjjvbdssSSxzFD +DoCkKvbdUtNTfMVj +DnbjjvbdJcKDRKDY +DncKjvbdqiAKEmOe +DoDKjvbdtlXwAtBX +DnbkKvbdxmsIYTIc +EObkKvbdLrXMzUpz +DoCjjvbdkxsSSxft +DncKjvbdQlwaxnUz +EObkKvbdjhGlFfNk +EPCkKvbdxsNhmRag +DoDLKvbdMfcPmQUk +DoDKjvbdQvnEDLhD +EObjjvbdVgxVxHYz +DoDLKvbdlrYtyrdJ +DoCjjvbdezvYeIsw +DncLKvbdNddTiIjd +EPDLKvbdGGJrNiUR +EPDLKvbdRzJhTDWA +EPCjjvbdvvkaWBVu +EOcKjvbdRXNdCkgc +EOcKjvbdQZNAHTSK +EPCkKvbdsCGNLfkZ +EOcLKvbdDwwktTsl +EOcLKvbdqlzJyLgi +EOcLKvbdxsNiMqag +EOcLKvbdhzVFlROG +EOcKjvbdEztRFMCi +DnbkKvbdqiAJdmPF +EPDLKvbdjcMKqGtg +EObkKvbdTlWOaWOi +EPDLKvbdURRPUuHm +DoDKjvbdelfWgNKL +EOcLKvbdGAnqZJzm +EObjjvbdGZUuAdXb +DoDLKvbduLwwAtAw +DoCjjvbdZjTIQGbG +EPCjjvbdRNXbYnUz +EPDLKvbdiLeENtby +EObjjvbdMowpunGs +EOcKjvbdbiNJjevx +DoDKjvbdEYYLstTl +DoDLKvbdqUTfrRjt +DoDKjvbdbsCkUEJa +DoDKjvbdXsMBNUPY +EPCjjvbdRNXaxnUz +DoDLKvbdNGcQNQUk +DnbjjvbdEARiMywX +EPDKjvbdSKxfUfkT +DncKjvbdhtyeXRtb +DncKjvbdZLqcsnLm +EObkKvbdZnmheEzK +EObjjvbdtbcUvuno +DnbjjvbdrzMQTBHn +DnbjjvbdDwwktTsl +EPDKjvbdkxsSTYgU +DoDKjvbdIryArlxM +DoDKjvbdnBivxOnV +DoDKjvbdeATplwif +EOcLKvbdKeegbApu +EPCjjvbdMgDQMotk +DoCjjvbduCbtwWOo +DnbkKvbdyNsHwrhc +DnbkKvbdtvNxJpsA +EOcLKvbdqAheAWgd +DoCkKvbdURQoUtgm +EOcKjvbdqceIpOWB +DoCkKvbdVwIwudFH +DnbkKvbdbLMFnmcA +EOcLKvbdZjTHpHBf +EOcKjvbdRXNdCkhD +EPDLKvbdiHJcZViu +DoCjjvbdxxIjCPzL +DnbkKvbdBcpBWJmG +EPCkKvbdZyEKOCkr +EPDKjvbdOTUWHFVQ +DoCjjvbdIGgZxwwg +EPDLKvbdFjeSbhMu +EPDLKvbdhgKCxvJu +EOcLKvbdNsUWGdtp +EPDKjvbduVnXipsA +DncLKvbdGYuVBEXb +EPDLKvbdZtIhyESn +DoDKjvbdZxdJmcLr +DoCjjvbdUsltGLuj +DoDKjvbdDoDLKvbd +DncLKvbdrDdhpNvB +EPDLKvbdKCjDRJbx +DoDLKvbdxLWdHzyf +EObkKvbdrzMQTAhO +EOcLKvbdOFDtJJKd +EPCkKvbdrSVKmjaN +EOcKjvbdWWiYVdEg +EOcKjvbdWWhwvDdg +DncKjvbdpstHRqjt +EPCkKvbdKWVFceGi +DoCkKvbdZjShPfbG +DoCkKvbdSxKlNzkY +EPDLKvbdIwtCHkqQ +EOcKjvbdsCGNLgLZ +DncKjvbdzaAOfgCM +DoDLKvbdxmrhYSiD +DncLKvbdfMfWgMjL +EPDKjvbdqFdEsuaI +EOcLKvbdiLeDnUcZ +DoCjjvbdKVuFceHJ +DoCjjvbdfekzNgHA +EOcKjvbdOFEThiLE +EPDLKvbdqceJPnWB +DoDLKvbduCbtwWOo +DncKjvbdTqROtuIN +DncKjvbdpedFUWBI +DoDLKvbdrEFJQNua +DoDLKvbdyXhjCPyk +EPCkKvbdJYUBhLqQ +EPCkKvbdtcCuXVno +DoDLKvbdZLrEUOLm +EPCkKvbdpstGrRjt +DncLKvbddePSCXCj +EObkKvbdauCHXjsh +DoDLKvbdkHfkefNk +EObjjvbdMRwMzUpz +EObjjvbdaMkCTVNH +DoCkKvbdGGJrNhtR +EPDLKvbdvBDxrneI +EPDLKvbdIHHZxwxH +EOcLKvbdrJAJdmPF +EOcKjvbdGZUuAdXb +EOcLKvbdbUbHYLUI +DnbjjvbdJzofYEAN +EPDKjvbdFxtuBDxC +DnbkKvbdQvnDbkgc +EPDKjvbdJmADzGta +DoDKjvbdZRMdhleR +DnbkKvbdsrqsZZeD +EObkKvbdrovPJbuf +EPCjjvbddeOqbXCj +EObjjvbdtcDVXVoP +DncKjvbdMfbpNQVL +DoCkKvbdhbPCeXQq +DoCkKvbdNHComQVL +EObjjvbdvBDxroFI +EPCjjvbdnBivwoNu +EObjjvbdbhljKewY +EPDKjvbdZyDimcMS +EObkKvbdWSOXbElD +EOcKjvbdTfznMXVe +EPCjjvbdZtJJYcsO +DoCjjvbdRjxfVHLT +DoCkKvbdVTltGMVj +DncKjvbdYfwEAOri +DncKjvbdYkrEUOMN +EObkKvbdqGEEsuaI +DncLKvbdjJfHimXr +EPDLKvbddndsLUTr +DnbkKvbdqBJFAWhE +EPDLKvbdEOcKjwDE +EPCkKvbdtvOYJqTA +DncLKvbdkyTRsZHU +DoCjjvbdTppnuVIN +DncLKvbdwyhFeweS +DncKjvbdsBelkgKy +DoCjjvbdKDKCqJcY +DoCjjvbdkClKqHVH +DoCjjvbdcTCjtDia +EPDLKvbdUVkpJtAq +EPDLKvbdRyjITCvA +DnbjjvbdJuuFcdgJ +DoDKjvbdrJAJdmOe +DncKjvbdJcJbqKCx +DoDLKvbdJcJbqJcY +DoDKjvbdeEoSCXDK +DoDLKvbdSwjlNzkY +EObjjvbdzitopDrt +DoCkKvbdKWVGEEgJ +DncKjvbdpssfqrKt +EOcLKvbdUMWPBVoJ +DncKjvbdyzdmrIIh +EPCjjvbdxUldqZLn +DoDLKvbdySnImRbH +DoCjjvbdGdKvJaij +DoCkKvbdxZgeewdr +EObkKvbdiLddNuDZ +DnbjjvbdSCDdkiZL +DncKjvbdznpREcMY +EOcLKvbdaRebhTfL +DnbjjvbdZQldiMdq +EPCjjvbdbrbjtEKB +EOcKjvbdEARiMzXX +DoDLKvbdXrkaNTnx +EPCkKvbdQZNAHTRj +DoDLKvbdEzspeLcJ +EPCjjvbduVnYKRTA +EObjjvbdJXtBhMQp +EPDKjvbdeOdrjssr +EPCjjvbdLqwMytpz +EPDKjvbdUMVoBVoJ +DncKjvbdRpUGifDw +EPDLKvbdZyDinDLr +DnbkKvbdNrsufeVQ +EPCkKvbdZMSDtNlN +EPCkKvbdySnJNSCH +EPCjjvbdfMevfljL +DncLKvbdXsMBNTnx +DnbkKvbdpxoHfqDx +DncLKvbdUQpntthN +DncKjvbdIsZArlwl +DoDLKvbdZGwEAOsJ +EOcKjvbdVvhwvDdg +EOcLKvbduWNxJqTA +EPCjjvbdHEKvJaij +DoDKjvbdrpWOjCuf +DncLKvbdrpWOjDVf +DoCjjvbdIHGzYwwg +DoDLKvbdpxoIGqEY +DoDLKvbdJcJbqKDY +DoCjjvbdRWmdClHc +EPCjjvbdFWYopNJe +DncKjvbdmfdwlmfy +DoCkKvbdxUleQxlO +EObjjvbdnGdxMnGy +EPCjjvbdvvlAvBVu +DncLKvbddndsKssr +EObjjvbdZMRcsnLm +EOcKjvbdFxttaEXb +DncKjvbdVUNTfMVj +EOcLKvbdNrtWHFUp +DoDKjvbdwuMdqYlO +EPDLKvbdrXPkbhxq +EObjjvbdrEFIpNua +EObjjvbdziuQQDrt +EOcLKvbdqYoIGpcx +DnbjjvbdsQVoJcVf +EObkKvbdkDMKpgUg +EObjjvbdvBDyTPFI +DncKjvbduCbuWvOo +EPCjjvbdkVvnECYX +DncLKvbdZGvdAOri +DoCkKvbdrXPlDJZR +EOcLKvbduCcVWvOo +DoDKjvbdCEPaWJlf +EPDKjvbddoErjssr +DncKjvbdACqxKZiQ +EPCjjvbdUVlPitAq +EPDKjvbdjJfHjMxS +EObkKvbdAMhYsWzY +DoDKjvbdnBivxOmu +EOcLKvbdbiNKKfXY +EPDKjvbdYqMeIleR +EObkKvbdJmADygUa +EObjjvbdEPDLLWcE +EPCjjvbdrXPkcIxq +EOcLKvbdliDtQtqa +DoCjjvbdmoyxujyC +EPDLKvbddoFTLTsr +EOcLKvbdCWzdJEpW +DnbjjvbdrEEhpOWB +DoDKjvbdZLrDtNkm +EOcLKvbdLFfHbAqV +EOcKjvbdmttzLKSG +EOcLKvbdmbJvwoOV +EOcKjvbdUaCQrqSZ +DnbjjvbdmgExMnGy +EPDKjvbddndrkUUS +EObkKvbdDwwkstTl +DoCkKvbdcJMjLFwY +DnbjjvbdaNLBruMg +DoDLKvbdQYmAHTRj +DnbkKvbdsQWOicWG +EObkKvbdMRwMzUpz +DoDLKvbdZshiZDrn +EPDLKvbdnPzYujxb +EOcKjvbdCEQAujMf +EPDLKvbdKefHbApu +DoDLKvbdYpldiNFR +DoCkKvbdFWZQQNJe +DncLKvbdznpQeCkx +EOcKjvbdnQZxvKxb +DoCkKvbdVBBprpqy +DnbkKvbdZirhPfaf +DnbkKvbdegjvSNqH +EOcLKvbdqdEiPnWB +EObjjvbdBhkCKiGK +EObjjvbdxZgfGYFS +DnbjjvbdNQYQumgT +EPCjjvbdxsNhlrBg +DoCkKvbdQdDApRDr +DoCkKvbdxxIiaoyk +EPDKjvbdFeirNhtR +DoCjjvbdegjvSOQg +EObkKvbdqcdiQNvB +DncLKvbdiMEdNtcZ +DncLKvbdTqRPUthN +EPCkKvbdwygeexFS +DoDKjvbdyTOJMrBg +DncLKvbdeEoRavbj +EPCjjvbdtbcUvvOo +EObjjvbdKCicRJcY +EObjjvbdZyEKODMS +DnbjjvbdmJDtQtrB +DncLKvbdEARhlyvw +DnbjjvbdIxTbILqQ +EOcLKvbdwygefYFS +DoCjjvbdznoqFCkx +DoCjjvbdRpUGjGDw +DncKjvbdhzVGMQnG +EPCjjvbdhkeDnVCy +EObkKvbdOEdUIiKd +DncKjvbdrDeIomua +DncLKvbdiHJbxuiu +EPDKjvbddxZstRez +EPDLKvbdmSYuZrdJ +EObkKvbdVUNUFkvK +EPDLKvbdNeEUJIjd +DoCkKvbdiMEdNuCy +DoDLKvbdRDcApQcr +EPCjjvbdTlVoBVoJ +EObjjvbdLBKgNBwq +EPCkKvbdsCFllHKy +EObjjvbdnVUzLJqf +DoDKjvbdqrVLNkBN +DoCkKvbdqFcdtWBI +DncLKvbdbVCGxLTh +EOcLKvbdeFPSCXCj +EOcLKvbdRpTgKFdX +EObjjvbdznpQeDLx +EOcKjvbdjvXNcaxX +DnbjjvbdHDkWJbJj +DncKjvbdhkeENuDZ +DnbkKvbdnUtyjjSG +DoDKjvbdSQUHJfDw +DncKjvbdbUbHYLUI +EOcLKvbdNsTvGduQ +EPDLKvbdSZigsCvA +DncKjvbdMfcPlpUk +DoDLKvbdxrnIlrBg +DncKjvbdiLdcnVCy +EPCjjvbdmfeYNOHZ +DoCkKvbdjvWmcaxX +DoDKjvbdbUbHXkUI +DncKjvbdBhkBjiFj +DoDLKvbdNHColpVL +EOcKjvbdrykosAhO +DncLKvbdqGDeUVaI +DnbkKvbdhgJcZViu +DnbjjvbduLxXAtBX +EPCjjvbdYpleJNFR +EPDLKvbdQvmdClHc +DnbjjvbdJYTbIMRQ +DncLKvbdznpRFDMY +EOcLKvbdZnmiFEyj +DnbkKvbdrRuLOLAm +EObkKvbdhkeEOUby +DncLKvbdYlSEUOLm +DoCjjvbdhkdcmtby +DncLKvbdddnrCXDK +DoDLKvbdKaLHNCYR +EOcKjvbdcyxpYZQb +EPDLKvbdACqwjZhp +DoCkKvbdBsBDTevr +EObkKvbdeKJqvUzn +EObkKvbdcImJkGWx +DncLKvbdYSlAltOx +DncLKvbdlrYtyrdJ +EObkKvbdKxqJrztf +EOcKjvbdsQWPJcVf +DoDKjvbdkySqrxgU +EObjjvbdeEoRbXCj +EOcKjvbdHDkVjBij +DoDLKvbdCTBCsfXS +DoCjjvbdKCjDQibx +DoCjjvbdlhdTqUrB +DoDKjvbdTulQKTaR +DoCkKvbdRjxetfkT +EPCjjvbdEuyQQNKF +EPCjjvbdDoDKkXDE +DoCjjvbdsQWPJbuf +DoDKjvbdhuZdvqtb +EPDLKvbdiHKCyWJu +EPDLKvbdLFegaaQu +DoCjjvbdqZPHgRDx +DncKjvbdUWMPjUAq +DoDLKvbdTYKkmzjx +DoDKjvbdegjvSOQg +DnbkKvbdUtNTekvK +EObkKvbdNsTvGeVQ +DoDLKvbdfNFvgMjL +EOcLKvbdZQmEiNEq +EPDKjvbdBraDTfWr +EPDKjvbdNGcQNQVL +EPDLKvbdZyEKODMS +EOcKjvbdBvzdIdpW +EPCjjvbdACqwiyiQ +DoCjjvbddePRawCj +EPDKjvbdWWiXucdg +DoDKjvbdWexzUAPT +DnbjjvbdwXMBWBWV +EOcLKvbdUyHszLOn +EPCkKvbdOYOuzcnU +EPCkKvbdhancEwQq +DnbkKvbdjggLefOL +EPCkKvbdFjdsDIMu +DoDKjvbdrSUjmkBN +DoDLKvbdZjTIQGaf +DoDKjvbdMgDPmPtk +EPDLKvbdWRmwbFMD +DoCkKvbdzROmJKXA +DnbkKvbdrDdiQNvB +DnbjjvbduDCtwVoP +EOcLKvbdCIjbLJFj +EPDKjvbdXrkaMsnx +EPDKjvbdVhXvXfxz +DncKjvbdhbPDEwRR +DoCkKvbdpxoHgQcx +DoCkKvbduMXwBUBX +EObjjvbdNeEThhjd +DoCjjvbdirzhrkJz +DoDLKvbdaMkCTUlg +DncLKvbdWRnYBeLc +DnbjjvbdGBPRZJzm +EOcLKvbdeOeSjstS +DoDLKvbdmIctRVSB +DoCjjvbdZxdJnDMS +DoCkKvbdRpTgKFcw +DncLKvbdTukojTaR +DnbjjvbdKRZdoFme +DnbkKvbdURQoVUhN +DoDLKvbdyYJKBozL +EObkKvbdfNFwHMjL +DoDLKvbdZisIQHBf +EObkKvbdqFcdsuaI +DncLKvbdzoPqFDLx +DoDKjvbdSKxeuHLT +EPDKjvbdsBemLfjy +DoCjjvbdJbjCqJcY +DoCjjvbdNPxRVnGs +DncLKvbdGcjvJbKK +EOcKjvbdrWpMDIxq +EOcLKvbdQdDApQcr +DoDKjvbdZMRdTnLm +EOcLKvbddxZssrFz +EObjjvbdUtNTfLuj +EPCjjvbdLLBIWAKZ +DoCkKvbdgFlZmfgA +EPCjjvbdUVkoitAq +DoDKjvbdDncKjvcE +DoDLKvbdRpUHJfEX +EPDKjvbdLqvlzVQz +EPDKjvbdZMRdUOLm +EOcLKvbdCJLBkIfK +DncKjvbdaSFbhUFk +EPDLKvbdZoNheEzK +DncKjvbdUVlPjUAq +DnbkKvbdKNADyfuB +EObkKvbdZdwfzghb +EPDLKvbdZtIhxcrn +EObkKvbdGckViajK +DncLKvbdFfJqmiUR +DncKjvbdKWUfDdgJ +DoDKjvbdMtrqjmAX +EOcLKvbdsQWPKDVf +DoCjjvbdwtleRZMO +EObjjvbduaDxsPEh +EPDLKvbdKxqJrzuG +EOcKjvbdVAaprprZ +EObjjvbdEuxopMjF +DnbjjvbdyOTHwriD +EPDLKvbdrpVnibvG +EPDKjvbdkWWnDaww +DncLKvbdrXPkbiYq +DoDLKvbddxZssqez +EOcLKvbdHDkWJbJj +DncLKvbdEPCkLWcE +DnbkKvbdEXwkstTl +EObjjvbdqiAKEmOe +DncLKvbdjAQGaQGj +EPCjjvbdNeDtJJKd +EPCjjvbdvwMBWBVu +EPDKjvbdFejSOItR +EOcLKvbdNPwqWOHT +EPDKjvbdbsCjscia +EObkKvbdyYIiaoyk +DoDKjvbdLZQirzuG +EObjjvbdSLZGVGjs +DoCjjvbdAMgxsWzY +DoDLKvbdEObjjwCd +DnbkKvbdsPvOicWG +EPCkKvbdrJAKElne +EPCkKvbdauCGwjsh +DncLKvbdegkWRnQg +EPCkKvbdYpmEiNFR +DoDKjvbduaDxsPFI +DoCjjvbdcyxoxYqC +DoCkKvbdkMakzFHP +DnbjjvbdJbibqJbx +DnbkKvbdWWhxWDeH +DoCjjvbdssRsYzFD +DoDKjvbdpyPIHRDx +DncLKvbdwNWANDeN +DoDKjvbdJYUBglRQ +EObkKvbdXnRAYVVt +DoCjjvbdUWLpKTaR +DoDKjvbdTqROttgm +EPCkKvbdVqnXaeMD +EObjjvbdADRwiyiQ +DoDKjvbdlrZUyrci +EPDKjvbdvAdZSndh +DoCkKvbdzoQQeDLx +DnbkKvbdSQUGjFdX +EOcLKvbdqBJFAXIE +EObkKvbdSCEFLiZL +DnbjjvbdzoQQdcMY +DnbkKvbdpxngfqEY +DncLKvbdbsDLUEKB +DoCjjvbdXrlBMtOx +EObjjvbdKCjDQicY +DncLKvbdLrWlzUpz +EObjjvbdaaWEfQQX +EObjjvbdtlYWaTaX +DnbkKvbdMowpunGs +EObkKvbdSLYeuHKs +EObkKvbdTAEhhCOd +EPCkKvbdmSYtyrci +DncLKvbdYkqcsnLm +DoDLKvbdrylQTAgn +DncLKvbdJXtCIMRQ +EObkKvbdSBdElIyL +DoDLKvbdwygefYFS +DncKjvbdyXhibPzL +EPCjjvbduaDxsPFI +EObjjvbdZoNiFEzK +EPCjjvbdkNBkyeHP +EPCkKvbdWRnXadlD +DncLKvbdRWmdDLhD +DnbkKvbdmSYtzTDi +EOcKjvbdkVwODbXw +DncLKvbdQlxCZOUz +EObjjvbdbhlijfXY +EOcLKvbdXmqAXtut +EOcLKvbdmbKXXnnV +DoDKjvbdkHgMFfOL +EPCkKvbdfekymgHA +DoCjjvbdeKKRvUzn +DoDKjvbdkHfkefNk +DoCjjvbdyqPMiKXA +DnbjjvbdUQqOtuIN +EOcKjvbdEPCkKwDE +DoDLKvbdZRNFIleR +DnbjjvbdRacdlJZL +EOcLKvbdTukoitAq +EOcLKvbdZLrDtOMN +EOcLKvbdgKfzcGAE +EObjjvbdzjVQQESt +EOcLKvbdcIlijevx +EOcKjvbdGKdsDHmV +DncLKvbdKkBHvAJy +EOcKjvbdZMRctOLm +EPCkKvbdADRxKZiQ +EObjjvbdDwxLsssl +EPDLKvbdUxgszLPO +EPCkKvbdSQTfiedX +EPCjjvbdNeEUJIkE +DoDLKvbdpyPHfqDx +DnbkKvbdyOShXsJD +DncLKvbdLiBkpxAS +DoDKjvbdaaWEepQX +DoCjjvbdWSOYBeLc +EOcKjvbdLFegbAqV +EPDKjvbdffLzOGgA +EObkKvbdFkErbglu +DncLKvbdiZuFlROG +DncKjvbdegkWRnQg +DoDLKvbdQdDApRDr +EOcLKvbdeYZtURez +EObjjvbdrXQLcIxq +DoDLKvbdxZhGGXeS +DoDLKvbdGGKSOItR +EObjjvbdjhHLfFnL +EOcLKvbdUQpoUuHm +DoCkKvbdXrlBNUPY +DoDKjvbdJXtCIMRQ +DnbkKvbdZMSDsnLm +DncKjvbdCTBDUGWr +DncKjvbdbhlikGXY +DoDKjvbdXmqAYVWU +DnbjjvbdliDsqVRa +DnbkKvbdmajXYOnV +EObjjvbdJpyePGNe +DnbkKvbdCTAcUGXS +DoDLKvbdCDpBVjNG +EOcLKvbdxwhiaoyk +DoDKjvbdxVNFQyMO +EPCkKvbdVvhwvEEg +DnbkKvbdFWYoomJe +EOcKjvbdlrZUysEJ +EPDKjvbdqquKnKaN +DoCkKvbdTkunaVoJ +EOcLKvbdfHkVrOQg +EPDLKvbdiUzFWrUb +DoDLKvbdtAGqIABS +DoCkKvbdZRMdhmEq +DnbkKvbdNsUVfeVQ +EPDLKvbdqwPkbiZR +DoCkKvbdNUsSLNAX +DncKjvbdmpZxvKyC +EPCkKvbdLYqKSztf +EPDKjvbdZyEKODMS +EPDKjvbdNGbomPuL +DncKjvbdZMSDtNlN +EPCjjvbdTXjkmzjx +EObkKvbdBdQAvKMf +EOcLKvbdkySrTYgU +DnbkKvbdZoOIddzK +DoCkKvbdZMSDsmkm +EPCkKvbdCWzdIdpW +DncLKvbdBvzdIdov +DoCjjvbdaRfDHtFk +DnbkKvbdWeyZtAOs +DoDLKvbdnCJwYPOV +DoCjjvbdEYYLstUM +EOcLKvbdwtldqZMO +EPCjjvbdFVxoomKF +EObkKvbdyqPMhiwA +DoDLKvbdkxrrSxgU +DoCjjvbdeATqNYKG +DncLKvbdJKEAJpHE +DoCkKvbddndsLUTr +DnbjjvbdqFceUWBI +DoDLKvbdhkddOUby +DncKjvbdGKdrcIMu +EPCkKvbdelevflik +DoDKjvbdhaoDFWqR +DoCjjvbdYlSDsmlN +EPCjjvbdiZuGLpmf +EObkKvbdnCJvxPNu +DnbkKvbdhzUelRNf +DnbkKvbdZeYGzgiC +DoCkKvbdDnbkLWbd +DnbkKvbdnHFYMmfy +DoCjjvbdePEsKtTr +DnbjjvbdZQmEhleR +DnbkKvbdTkunaVoJ +DnbkKvbdFWZPpMjF +DoDKjvbdSwkMNzkY +EOcLKvbdwtldpyMO +EOcKjvbdhkdcmtby +DoCjjvbdNQXqWNfs +EPDKjvbdzjUpPdTU +DnbjjvbdqceJPnWB +EPDKjvbdUyHsyjoO +EPCkKvbdZshhxcsO +DncKjvbdqAiFAWgd +EObkKvbdgFkzOGgA +DncKjvbdmgFYNNgZ +DoDLKvbdDjHjWYKA +DnbjjvbdJbicRKCx +DnbkKvbdfNFwHMjL +EPCkKvbdWSNxBdlD +EPDLKvbdCJKbLJFj +EPDKjvbdEOcKkXDE +EPCkKvbdVrOYCElD +DnbjjvbdCIkBjhej +DoDLKvbddoFTKstS +DnbjjvbduDDVXVoP +EObkKvbdxwiKCPzL +DnbkKvbdZGvdAPTJ +DoDLKvbdBdPaVjNG +EOcKjvbdIHGzYwxH +DoCjjvbdGFjSNhsq +DnbjjvbdlYsSSxgU +EPCjjvbdqrUjnKaN +EOcLKvbdtvOXipsA +DoDLKvbdrounjCuf +DoCkKvbdFVyPomKF +EOcKjvbdNHCpNPtk +EPDLKvbdWeyZtAPT +EPDKjvbdjcLkQfuH +EOcLKvbdzHZMAMeX +DoCjjvbdUMWPBVni +EOcKjvbdHELWKBjK +DoDKjvbdMgComQUk +DnbkKvbdiGjDZWJu +DncKjvbdyqOmJKXA +DoDKjvbdVZITyjoO +DoCjjvbdzQoNJJwA +EOcLKvbdGAoQxizm +DoDKjvbdatagYKsh +EPDKjvbdSBceMJYk +DoDLKvbdMpYQvOHT +DncKjvbdiCOcFWpq +DoCjjvbdUGznLvvF +EPDLKvbdANIYrvyx +EPCjjvbdIwtCHkpp +EObkKvbdJSyBSmYM +EObkKvbdwuMdqYlO +EObjjvbdmuVZkKSG +DncLKvbdSPsfjFdX +DoDLKvbdSQUHJedX +DoDKjvbdiVZdwSUb +EPDLKvbdRjxfVGkT +EObjjvbdmpZyVkZC +DncLKvbdhzUelROG +EPCkKvbdxVMeRZMO +EOcKjvbdxxIiapZk +EOcKjvbdJSyBTNYM +EPDKjvbdMSXMzUpz +EPCkKvbdNddThhjd +DoDKjvbdznpREcLx +DncLKvbdqYoHgREY +DnbjjvbdiCPCdvqR +DoCjjvbdsQVoKDVf +DoCjjvbdqFcdtWBI +EPCkKvbdFkFTDIMu +DnbkKvbdQvmdCkgc +DnbjjvbduCbtwWOo +DoCjjvbdaNKaruNH +EOcLKvbdrpWPKCvG +DoCjjvbdEKHiuwjA +DoDLKvbdsBfMlHKy +EObjjvbduCcVWuno +DoCkKvbdNddUIiLE +DoDLKvbdVrNwbElD +EPCkKvbdTqQoUuHm +DoCjjvbdcJMikFvx +EOcKjvbdijGIJmYS +DncKjvbdtvNwipsA +EPDKjvbdGQASwGey +DoCkKvbdmJEUQtqa +DncKjvbdpxnggQcx +EOcLKvbdDnbjjwDE +DnbjjvbdxVMdqZLn +EPCkKvbdTkvPAvOi +DnbkKvbddijRvUzn +DnbjjvbdJuuFceGi +DoDLKvbdeATplxJf +EObjjvbdiLeDmuDZ +EObkKvbdzHYlANFX +EObkKvbdSBdFLiYk +DncLKvbdMgCpNPuL +DncLKvbdNsTufeVQ +EPCjjvbdUQqOtuIN +EPCkKvbdKDJcQicY +DnbkKvbdsCFmLfjy +DnbjjvbdNdctJIjd +DoDLKvbdzjUpPdSt +EPDLKvbdMoxRVmgT +EOcKjvbdbsCjscia +DoCjjvbdrDeIpOWB +EPDKjvbdOTUVgFVQ +EOcLKvbduWNwipsA +DoDKjvbdJcJcRKCx +DncKjvbdGZUtaDwb +EPCjjvbdZtJJYdSn +DoDLKvbdtcDVWuoP +EObjjvbdKaLGmCXq +DoCjjvbddZxoxYpb +DnbkKvbdWRmxCEkc +EOcLKvbdNrsufduQ +DoDLKvbdqlzJxlIJ +DoCkKvbdFVyPoljF +DnbkKvbdjggMGGOL +DoDLKvbdLAkHMawq +DncLKvbdwuMdpxlO +DoDKjvbdtSqrxydc +DoCjjvbdSLZGVHKs +DnbjjvbdrMzKYlIJ +DnbjjvbdTAFIhBnd +EPDLKvbdIxTbIMRQ +DoDLKvbdbBVeGQPw +DnbkKvbdvlvANEEm +EPDLKvbdEOcKkXCd +DoCkKvbdYqMdhmFR +EObjjvbdnUtzKiqf +EPCkKvbdtunXjQsA +DnbkKvbdddoSBwDK +DnbjjvbdTqROttgm +EPCkKvbdzQnmJJwA +EObjjvbdfpBzwDwh +DncKjvbdRotHJecw +EPCjjvbdhtzFWrVC +DncLKvbdqdEhpNvB +DnbjjvbdkWWmcbYX +EOcLKvbdYSkaMsoY +EObjjvbdDjIKVxKA +DnbkKvbdrounjDVf +EObkKvbdJzpFwdAN +DoDLKvbdsBelkgLZ +DoDLKvbdwtmEqZMO +DncKjvbdxmrgwriD +EOcKjvbdDoDLLWbd +EPDKjvbdIwtBhLpp +EPDLKvbdUaBqTRRy +DoCjjvbdjKFhJlwr +DoCkKvbdGLFTDIMu +EPCjjvbdrbFmMHKy +DoDLKvbdehKurOQg +DncKjvbdijFhJlwr +DoCjjvbdjvXOEBww +EPCjjvbdTXjkmzkY +EOcKjvbdaSFcHtGL +EPDLKvbdpyPIHQcx +EOcKjvbdmaiwXoNu +DoDKjvbdSBdFMJZL +DoDKjvbdjKGIKMwr +DncLKvbdyXiKBozL +DoCkKvbdqlzJxkhJ +EObkKvbdrNZiyLhJ +DoCkKvbdrpWPKCvG +DncLKvbdVrOXbEkc +DnbkKvbdOAIrtJrA +DnbkKvbdrXQMChyR +EOcLKvbdDnbjjwCd +EPCjjvbdjvXOECXw +EPCkKvbdMgDPmPtk +DoDLKvbdYfwEAPSi +EPCjjvbdzGxlANEw +DoDKjvbdmbKWwoNu +EOcLKvbddZxpXxqC +DoDLKvbdLGGHbApu +DoCjjvbdVTltGLuj +EPCjjvbdOEdThiKd +DoCjjvbdUyHtZkPO +DncLKvbdHELWJajK +EOcKjvbdcarmSAUN +EObjjvbdqiAJdmOe +EObkKvbdZQleImFR +EObkKvbdQccBQRDr +DoCkKvbdLAjfmBwq +DncKjvbdSKxeuHKs +DncLKvbdmJDsqUrB +EOcLKvbdGFirNhtR +DncLKvbdEARiMywX +DnbjjvbdZxcjNblS +DncLKvbdWXIwudEg +DoDLKvbdhkeDmuCy +EObkKvbdUslselWK +DoCkKvbdLhakqYAS +DoCjjvbdIMBzmvpk +EPCjjvbdKaKgMbXq +EPCjjvbdiLeDmtcZ +DnbjjvbdsPvPKCvG +DncLKvbdnVUzLKRf +DoDLKvbdiUyeWrVC +EOcLKvbdjblLRGuH +DnbkKvbdhtydvqtb +EOcKjvbdTqQnuVIN +DoCjjvbdMtsRkNAX +EPCjjvbdGKdrbglu +DncKjvbdMoxQvOGs +DoDKjvbdiHKDZWKV +DoDKjvbdULvPAvPJ +DnbkKvbdEvZQPmKF +EObjjvbdkxrrTZGt +EObjjvbdKCicQibx +DoCjjvbdKkAgvAKZ +EOcKjvbdNxOuzcmt +EPDLKvbdbsCjsdJa +EObjjvbdHDkVjBjK +EPCjjvbdYqMdiMeR +EPCkKvbdczYoxZRC +DncKjvbdnPzYujxb +DnbjjvbdMpYRWOHT +DncLKvbdLFegbBRV +DncKjvbdxVMdqYlO +DoDKjvbdFkErbhNV +DncKjvbdLLBHvAJy +DoDKjvbdTfzmkwWF +EPCjjvbdyXiKCQZk +DoDKjvbdqUUGrSLU +EObjjvbdGcjuiaij +EOcLKvbdZRMdhmFR +DoCjjvbdZoNiEdzK +DoCjjvbdEARiNZwX +DoCkKvbdwXMBVaWV +EPCjjvbdVZHsyjoO +DoDKjvbdyXhjBpZk +EObkKvbdtkxWaUAw +DnbkKvbdLrWmZuQz +DncLKvbdySnJNRbH +EPCjjvbdezvYdhsw +DoDLKvbdhancFWqR +EObjjvbdyzeORgiI +EPCjjvbdyXiJbPyk +EObjjvbduVnXiqTA +DnbjjvbdZjTHofaf +EPDLKvbdLrXMyuQz +DnbjjvbdHffyxxXg +DoDLKvbdOStWGdtp +DnbjjvbddijRvUzn +DoCjjvbdYNqAXtut +EPCjjvbdUQpntuHm +DoDKjvbduWOXjQsA +DoDLKvbdtTRsYydc +DncKjvbdpfDeUVaI +DoDLKvbdULuoAvOi +DnbjjvbdqmZjYkhJ +EPDKjvbdZMSETmkm +DoDLKvbdZshhyETO +DncLKvbdQdCaQQcr +DncKjvbdQccBQRES +EOcKjvbdrNZjYlIJ +EPDKjvbdjAQHBPgK +DoCjjvbdnUuZkJqf +DoDKjvbdLAjfmBxR +EObjjvbdUsltFkuj +DoDLKvbdZQleJMeR +DnbjjvbdBraCtGXS +DoDLKvbdaSFbhUGL +EObjjvbdrbGMkgLZ +EPCkKvbdJYUCHlRQ +EOcKjvbdgFkzNfgA +DoCjjvbdaRecHtFk +EPDKjvbdnUuZkKSG +EPDLKvbdkWWmdBww +EObkKvbdypoNJKXA +EOcKjvbdZxdJmblS +DncLKvbdZirhPgCG +DoDLKvbddeOrCXCj +DoCjjvbdOXoVzcnU +DncLKvbdSBdFMJZL +DncKjvbdrzMPraHn +DncLKvbdqZPHfpcx +DncKjvbdVAbQsQqy +DoDKjvbdySnJNSCH +EPDLKvbdtSqsZZeD +DncLKvbdtvOYKRTA +DncLKvbdLGGICBQu +DoDLKvbdDncLKwDE +EObjjvbdNrtVgEtp +EOcKjvbdUQqOtthN +EObjjvbdZtIiYcrn +EOcKjvbdmuVZjjRf +DnbjjvbdcJNKKevx +DoCkKvbdDxXlTtUM +DncLKvbdqZOhHQcx +EPDKjvbdIsZBSlwl +EOcKjvbdNUsRkNAX +DoDLKvbdRbEFMJYk +DnbjjvbdiBncFWqR +EOcLKvbdRzKIScWA +EOcKjvbdRbEFMIyL +EPDKjvbdsPunjDVf +DoCjjvbdhzVFkpmf +EOcKjvbddxZtUSFz +DncKjvbdnVUykJrG +EOcLKvbdEPCkKvbd +EPCjjvbdnUuZkKSG +DnbjjvbdnCKWxOmu +DnbkKvbdYzcFrKVy +DoDKjvbdvmWAMcdm +EObkKvbdhkdcmuDZ +DncKjvbdNsUVgFVQ +EPDLKvbdYzbeqiuy +EOcLKvbdUxgszLOn +DnbjjvbdZQmEiMeR +DoCjjvbdkHflFemk +EPDLKvbdhbPCdwRR +DoDLKvbdWXIwucdg +DoCjjvbdOYOuzcnU +DoDLKvbdcSbkTdJa +EOcKjvbdEvYpQMjF +EPDLKvbdrykosAhO +EObkKvbdrovPJbvG +DoDLKvbdkHflGGNk +DoCjjvbdZtIiYcsO +DoDLKvbdZnmiEdzK +EObjjvbdZMSDsnLm +EPCjjvbdLAjfmBxR +DncLKvbdptUGrRjt +EOcLKvbdNQXqVmgT +DoDLKvbdCIkCLIfK +EPDLKvbduVmxKRTA +EPDKjvbdHbLzEzAD +EPCjjvbdbUbGxKsh +DoCkKvbdjlbLzEgP +EPCkKvbdXGYzUAPT +DnbkKvbduLxXAsaX +EObkKvbdJvUfEFHJ +EOcKjvbdmbKXXoNu +EPDKjvbdQvnDbkgc +DoDLKvbdiUzFWrVC +EObkKvbdZyEKNcLr +DoDKjvbdrEEhpNua +DnbkKvbdzitoocsU +EPCjjvbdmbJvxOnV +EOcLKvbdNddTiIjd +DncKjvbdfpBzvdYI +EObkKvbdBhjbLIfK +DoCjjvbdFjeTDHmV +EOcKjvbdRjyGVGkT +DoCkKvbdZQldhmFR +EPDKjvbdqlzKZLhJ +DnbkKvbdZoOIeEyj +DncKjvbdBdPaVjNG +EPCkKvbdTulPjUBR +EPDLKvbdGGJqmiTq +DoDLKvbdGGJqmhsq +EOcKjvbdIryBTNXl +EPDLKvbdIsYaSmXl +DoCjjvbdVwJXudEg +EPCkKvbduDCtvuoP +EOcLKvbddBsMrAUN +DncLKvbdrouoJcWG +DoDKjvbdCgLfHAzc +DncLKvbdhtzEvqtb +DoDKjvbdZtIiYcsO +DncKjvbdMfbomPtk +DncKjvbdYqNEiMdq +DnbkKvbdCTBCtFvr +DncLKvbdhtzEvquC +DoCjjvbdAMhZSvyx +DoDKjvbdjlbLzEfo +EOcKjvbdZLrETmkm +DncKjvbdULvPAuni +DoCjjvbdtcCtvuoP +EPCkKvbdOTTugEtp +EObjjvbdhtzEvquC +DoCjjvbdkHgLfFmk +DncKjvbdmoyyVkZC +DnbkKvbdsBemLgKy +DoDKjvbddCTMrAUN +DoCjjvbdmuUykJqf +DnbjjvbdbQHGckzd +DoDLKvbdyOShXriD +EPDLKvbdZRNFImFR +EOcLKvbdDoDKkWcE +EPCkKvbdwMvAMcdm +DnbjjvbdbKlFoNcA +DoCkKvbdMfbpMpVL +DncLKvbdhkeDnUby +DoDKjvbdMSWmZtpz +EPCjjvbdmfeYMmgZ +DnbjjvbdqiAKFMoF +DoCkKvbdSBdElIxk +EOcLKvbduoTzpkPU +DncLKvbdDoCjjwCd +EObjjvbdLGGHbBQu +DnbkKvbdQcbaQRDr +EPDLKvbdyNrgxTJD +EObjjvbdtSqryZdc +DoDLKvbdegkWSNpg +EOcKjvbdZLrDsnLm +EObjjvbdFkEsCgmV +DoDKjvbdatagXjtI +DncLKvbdGZUuBDwb +DoDLKvbduDDUvuno +EObjjvbdURROtuIN +DnbkKvbdyXhjBpZk +DoDLKvbdKaLGlaxR +DoCkKvbdlZTRrxgU +EPDLKvbdUsltFlWK +DncLKvbdGGKRnIsq +DnbkKvbdijFhKNXr +DoDKjvbdrWokbiYq +EObjjvbdUaCRSqRy +EObjjvbdRkYfVHKs +DnbkKvbdQvnDcMID +EObjjvbdvBEYrneI +DnbkKvbdySmiNRbH +EPDKjvbdjuvmcaxX +DoCjjvbdVTmUGLuj +EPDLKvbdxVMeRYlO +DnbjjvbdNPwpvNgT +DoDKjvbdJTZArlxM +EPDLKvbdjbkkRHUg +DnbkKvbdSBdFMIyL +EPDKjvbdMgColpUk +DncLKvbdVAbQsQrZ +DncLKvbdyTOJNRag +DnbjjvbdmgFYMmgZ +EPDKjvbdTAFIgbOd +EObkKvbdFWYoomJe +DoDKjvbdIxUBhMRQ +DoCjjvbdFWYopNKF +DoDKjvbdNdcshiLE +EOcLKvbdwWlBWAuu +EPCkKvbdYpldiNFR +EPDLKvbdQwODbkgc +EPCkKvbdqZOhHQcx +EObjjvbdHDjujCKK +DoDLKvbdnBjWwnmu +EPDLKvbdUQqPUuHm +DnbkKvbdIryBSlxM +DnbkKvbdjhGlFfNk +DnbkKvbdqlyiyMHi +EPDLKvbdxmsIYTIc +EPCjjvbdNrsufduQ +DncLKvbdaaWEepPw +DnbjjvbdkVvnDaxX +EOcKjvbdUQpntuIN +EOcKjvbdQdDAopcr +DoCkKvbduMXvaUAw +DnbkKvbdMRwNZuQz +DoCkKvbdNGcQMotk +EPDLKvbduWOYJpsA +DncKjvbdZtJIxcrn +DnbjjvbdwyhFfXeS +EOcLKvbdIryAsNYM +EObjjvbdyTNiNRag +EPCkKvbdiZuGLqOG +DncKjvbdHELWJbKK +DoDKjvbdIGfyxwxH +EPCkKvbdeOdrkTsr +DoDKjvbdpstGrRjt +EOcKjvbdZtJIxdSn +EObjjvbdZtIiZDrn +DnbjjvbdOEctIhkE +DncLKvbdKDJbqJbx +DncKjvbdEOcLKvcE +EOcLKvbdgLGzcGAE +DoCjjvbdGBPQxizm +EPCjjvbdeFOqbXDK +EObkKvbdehKuqnQg +DncKjvbdRosgKFcw +EOcLKvbdUsmUGLuj +EOcLKvbdrXQMCiZR +DoDKjvbdjcMLQftg +EPDLKvbdHEKvKBjK +EPDKjvbdbVCHYLUI +DncKjvbdFfKSOItR +DncKjvbdYSkaNToY +DncLKvbdQvmccLhD +EOcKjvbdnVUykKSG +DoCkKvbdbsDKsdJa +EObkKvbdGLFTChMu +DoCkKvbdqGEFTuaI +EPCkKvbdddoRbXCj +EPCjjvbdMfbpNQVL +DoDKjvbdFjdrbgmV +EPCkKvbdmRxuZsDi +DncKjvbdaRfChUGL +DncLKvbdMJBkqYAS +EObkKvbdxUmEqYlO +EPDLKvbdtbbtvuoP +DoDKjvbdxsOJNSBg +EPDKjvbdZtIhyDrn +DncLKvbdKCicRKDY +EPDLKvbdUtNUFlVj +EPCjjvbdeATqMxJf +EOcLKvbdaNLBsUmH +DoDKjvbdJcJcQjDY +EPCkKvbdiMEdNtby +DoCjjvbdiGibyWJu +DncKjvbdeEnrCXDK +EPCjjvbdUVlPisaR +DncLKvbdXGZZtAPT +DoDKjvbdddoRbXDK +DoDLKvbdSBdElIyL +DoCjjvbdRNXbZOUz +DnbjjvbdTAEhhCPE +EObjjvbdUMVoBWOi +DnbkKvbdFjdrcHmV +DoCjjvbdfIKurORH +DoDLKvbdVBCRTQrZ +EOcLKvbdZoNhddzK +DoCkKvbdULvOaVoJ +DnbjjvbdZirhPgCG +EOcKjvbdVBBprqSZ +DoDLKvbdaSFcIUGL +DoDLKvbdfIKuqnRH +DncKjvbdijGIKNXr +EPDLKvbdrzMPsAgn +EPDKjvbdNUsSKmAX +EPCkKvbdLLAhWAKZ +DncKjvbdkWWnDaww +DnbkKvbdJYUCHlQp +EPDLKvbdNwoVzdNt +DoCjjvbdSLYetfjs +DoDLKvbdptTgSSLU +DncKjvbdxVMdqZLn +DncKjvbdZyDinDMS +DnbkKvbdnPyxujxb +EPCkKvbdSiZjRABM +EPDKjvbdPyNAHSqj +DncLKvbdqwPlChyR +EPDKjvbdGckWJbKK +DoDLKvbdbBWFFoow +DoCkKvbdkCkkRGuH +DncLKvbdmJDtQuSB +EObkKvbdQdCaQQdS +DncKjvbdKfFhBaQu +DncKjvbdaNKaruMg +EOcKjvbdnPzZWLYb +EObjjvbdxUldqZMO +DnbkKvbdGckWJaij +DncKjvbdkVwODaww +EObjjvbdGKdsDHlu +EObkKvbdKQyeOfOF +EPCkKvbdGdKvKCJj +DnbkKvbdGdKuibKK +DoDKjvbdOFDtJJKd +DoCkKvbdwuMdpxkn +EObjjvbdZjShPgBf +DoDKjvbdcyxpYZQb +DnbjjvbdrbGMkgLZ +DnbjjvbdxsNiMqbH +DoDKjvbdWSOXbFLc +EPCjjvbdrDeIomvB +EOcKjvbdEuxopNJe +DoDKjvbdKDKCqKCx +DoCkKvbdkIHLfGNk +EOcKjvbdnUuZjirG +DncKjvbdIryArmXl +DoDKjvbdraemMGkZ +DncKjvbdEJgivYKA +DoDLKvbdbhmJkGWx +DnbjjvbdZyDimcMS +EOcKjvbdhuZeWrVC +DnbkKvbdRbEFMJZL +EPCkKvbdeOdrkUTr +DoCkKvbdlhdUQuRa +DnbjjvbdZtIiZDsO +EPCjjvbdZyEJmcMS +DnbjjvbdFpATWgGZ +EOcLKvbduaDxroEh +DnbkKvbdpeceUWBI +EOcKjvbdjcMLQftg +DncLKvbdnPzZWLZC +DnbjjvbdZyEKNcMS +DoDKjvbdZMSDsnLm +DnbjjvbdOAIsTjSA +DoCjjvbdWSNxCFLc +DoDKjvbdkClLRHVH +DncKjvbdZxdJmcLr +EPCjjvbdOYOuzdOU +DncKjvbdWHxVxHYz +DoDLKvbdwXMBWBVu +EObjjvbdZxdJmcMS +EOcKjvbdrEFJPmvB +EOcKjvbdQcbaQQcr +EPCkKvbdfHkWRnRH +EOcKjvbdrEEiQNvB +EObkKvbdcTCjtDia +DoCkKvbdnCJvwoOV +DoDLKvbdxnTIYSiD +EOcKjvbdGQASvfey +DoDKjvbdUtNTekvK +DoDLKvbdbUbHXkTh +DncKjvbdaNLBsVNH +EPCkKvbdmtuZjirG +EPDKjvbdvlvANEEm +DnbkKvbdcIljLGWx +EOcKjvbdJSyArmYM +EObjjvbdVTltFlVj +DncKjvbdTAFIgbOd +EOcLKvbdUsltGLuj +EObjjvbdZRNEhmFR +EOcKjvbdUGznMXVe +DnbjjvbdTqQoUthN +DncLKvbdZRNEhmEq +EObkKvbdKxpirzuG +EOcKjvbdiVZdvqtb +EOcLKvbdatbGxKtI +DnbkKvbdpfDdsvBI +DnbjjvbdpyPIGqDx +DoCkKvbdqUUGrRjt +DoCjjvbdfHjuqmqH +EPDKjvbdqlzJyLgi +DoCjjvbdznpREcMY +EObjjvbdjuvnEBww +DoCkKvbdQwNdCkgc +DoCjjvbdxsNhlqag +EOcKjvbdbsDKtEJa +EPDLKvbdfIKuqnQg +DncLKvbdJXsbILqQ +DoDLKvbdiUydwRuC +EOcLKvbdUtMsfMVj +DnbkKvbdfNGWflik +DoDLKvbdqwQLcJZR +DncLKvbdYqMeIleR +DoCjjvbdzaAPGgBl +EPCkKvbdauBgYLUI +EPDLKvbdiUydvqtb +DnbjjvbdRyjITCvA +DncLKvbdIwsahLqQ +EPCjjvbdRacdkiYk +EOcKjvbdRbEFMJZL +DoCjjvbdrzLoraHn +EObkKvbdxxIiaozL +EOcLKvbdJcJbqJbx +EPCjjvbdZisHogBf +EOcKjvbdVTmUGMWK +EPDKjvbdrylQSaIO +DncLKvbdSCEEkiYk +DoDLKvbdhtyeXRuC +EObjjvbdQvmcblID +DoDKjvbdauCGwjtI +DnbkKvbdGYtuBEYC +DoCkKvbdkyTSSxft +EPDLKvbdIGfyyYYH +EObjjvbdjlbLzEgP +EPCjjvbdIwsbHkpp +EPDKjvbdmuUyjjSG +DoCkKvbdUQpoUtgm +EObkKvbdUQqPVVIN +DncLKvbdXrkaMsnx +DncLKvbdaMjbTUlg +DncLKvbdhgJbyVjV +DnbkKvbdURQoUuIN +DnbjjvbdFWZQQMie +EPCjjvbdnCJwYPNu +EOcLKvbdBcpBVimG +DoCkKvbdyqPMiKXA +EObkKvbdnVUzKjRf +DnbkKvbdVgwvXgYz +EObkKvbdZsiJZDsO +EPDKjvbdiCPCdwRR +EObkKvbdGYuUaEYC +DnbkKvbdpyPIHREY +DnbjjvbdiZtfLpnG +EPCkKvbdVUNTelWK +DnbkKvbdTppoVUhN +DnbjjvbdxrnIlrBg +EPDKjvbdmIdUQtrB +EObjjvbdkNBkzFGo +DncKjvbdhbOcFXQq +DoDLKvbdNGcPmQVL +EPDKjvbdZoNheEyj +DnbkKvbdjlbLzEfo +DoCjjvbdZRMdiNEq +EObjjvbdczYoxYqC +EPDKjvbdLAkHMaxR +DoDLKvbdsPunibuf +DoDLKvbdNdcshhkE +EPDKjvbdhkdcnVCy +EPCkKvbdVZHtZkOn +DnbjjvbdsrrTYzFD +DoCjjvbdatbGxKtI +EOcLKvbdnGdxMnHZ +EPDLKvbdmaivwoOV +EObkKvbdjJegjMwr +EPDKjvbdYfwEAOri +EOcKjvbdpxngfpcx +DnbjjvbdEPCjkXCd +EPDKjvbdxsOImRag +EObjjvbdEPDKjwDE +DnbjjvbdYlSETnLm +DncLKvbdBiLBjhej +DoDKjvbdrpWPJcVf +DncKjvbdRpTfiedX +DoDKjvbdakMGOnDA +DnbjjvbduVmxKQsA +DncKjvbdKfFhCBRV +DnbkKvbdpfEFTvBI +DncLKvbdqwQLcIyR +EOcKjvbdlhdTpuSB +DncKjvbdqwQLbhxq +DnbkKvbdnHEwlmgZ +EPDKjvbdDoCjkWbd +EObkKvbdANIYsWyx +EObjjvbdpfEEsvBI +EPDKjvbdCJLCKiFj +DoDKjvbdqcdhonVa +EPCjjvbdzjUpQESt +DncLKvbdZQleImEq +EPCjjvbdEPCkLXCd +EPDKjvbdYlRdUNlN +EObkKvbdxwiKBozL +DnbjjvbdFjdsChNV +EObjjvbdwtleRYlO +DoDLKvbdeOdsLUUS +EPDKjvbdZLqctOLm +DoDLKvbdjlbLyeHP +DoCkKvbdaNLCTVMg +DnbkKvbdEKHjWXjA +DnbkKvbdZshhyDsO +DnbjjvbdsPunibuf +EPCkKvbdwWkaWBVu +EPDLKvbdFpATWfey +EObjjvbdzoQQdcMY +EPDLKvbdpxngfpcx +DnbjjvbdgPazwDwh +EPDKjvbdKVtfEEfi +EOcLKvbdhkeENuDZ +EObkKvbdIwtCILqQ +EPCjjvbdyNrhXsJD +DnbkKvbdMSWmZuQz +EOcLKvbdsPunicWG +DncLKvbdULvPBWPJ +DoCkKvbdKfFhCApu +EOcLKvbdTAEhhCOd +DnbkKvbdSKxetfjs +DoCjjvbdUtNTfLuj +EObjjvbdhzVGMROG +DoCkKvbdxsNhmRag +DnbjjvbddZyPwxpb +EObjjvbdEuxooljF +DncLKvbdVTlsfLuj +DoCkKvbdZjShQGaf +EPDKjvbdrSVKnKaN +DnbkKvbdFxuVBDwb +DoCkKvbdJXtBhLpp +EPCjjvbdHffzZXxH +DoCjjvbdqZOgfqDx +DncLKvbdqwQMChyR +EObjjvbdaSGDIUFk +EPDLKvbdZxdKNcMS +EObjjvbdhuZdwSUb +EPDLKvbdfMfWgMik +DncLKvbdZRNFJMdq +EOcKjvbdJKEAKPfd +EPCkKvbdcyxoxYqC +EOcKjvbdCSaCsevr +DoDLKvbdKQzEoGNe +DoDLKvbdjhHLefOL +DoCjjvbdRjxeuGjs +DncKjvbdyOTIXsIc +DnbkKvbdBdQBWKMf +EOcKjvbduLxXBUBX +EObkKvbdrSUkNkAm +DoDKjvbdKfFhBaRV +EPCjjvbdddoSBvcK +DncKjvbdyOTHxTJD +EOcLKvbdiLeENuDZ +DoCjjvbdJbjDRKCx +EPDKjvbddoErkUUS +DoCkKvbdBiKakJGK +DnbkKvbdCIjbKiFj +DoCjjvbdIsZBSmXl +EOcLKvbdBhjajiFj +DnbjjvbdrzMQTBIO +EObjjvbdrWolChyR +EPCkKvbdEARiMzXX +DoDLKvbdrWpMDJYq +EOcLKvbdKRZdoGOF +DoCjjvbdBsAcUFvr +DoCjjvbdBraDUGXS +DoCkKvbdIwtBhMQp +EObjjvbdeATqMxKG +EPDKjvbdYzbfRjWZ +EOcLKvbdsCGNLgKy +DoDKjvbdhficZWKV +EObjjvbdZQldhldq +EPDKjvbdsQVoJbvG +EPDKjvbdsQVnicWG +DoDLKvbdVZITyjoO +EPCjjvbdILazmvpk +EPCkKvbdZMSDsmlN +DoCjjvbdZGvdAOri +DoDKjvbdwuMeRYkn +DnbjjvbdZyEJmblS +EPDKjvbdhkeENuDZ +EPDLKvbdGdKvKCKK +EPCjjvbdjuwOECXw +EObkKvbdZeXfzghb +EObjjvbdJmAEZgUa +EOcLKvbdtcCuWvOo +EPCkKvbdiiehJlwr +DoDLKvbdwtldpyMO +DoCjjvbdjblLQfuH +DncKjvbdNPwpunGs +DnbjjvbdSLZFtgLT +EPDKjvbdyXhjCPyk +EObjjvbdliETpuSB +Dnbjjvbdqlyixkgi +DoDLKvbdmbJvxOnV +DoCjjvbdZjSgpGaf +DoCjjvbdqdEhpNua +DoDLKvbdelfXGmKL +EPDKjvbdIGgZyYYH +DncLKvbdfMfXHMik +DoCjjvbdZoNheEyj +EPCkKvbdsZlPsBIO +EOcKjvbdLAjgMbXq +DncKjvbdVZITykOn +DnbjjvbdpyOgfqEY +EPDKjvbdbUagYKtI +EObkKvbdrSUjnLBN +DncKjvbdQwNdDLhD +EOcLKvbdrykosBIO +EPDKjvbdsPunicWG +EPCjjvbdliDtQuRa +EOcKjvbdcSbkTdKB +EOcLKvbdKaKgNCXq +DnbjjvbdZshhxcrn +DnbkKvbdcbTMrAUN +EPCkKvbdsQWPKDVf +DncKjvbdijGHjMwr +EOcLKvbdULvPBVni +EPCjjvbdffLynHHA +DoCjjvbdTqQntuHm +DoDLKvbdjuwNdCXw +DoCkKvbdVZITzLOn +EPDLKvbdqrUkOLAm +EPDLKvbdZQmEhmFR +DoDKjvbdwjvdHzyf +EPDKjvbdePErjtTr +EObjjvbdmozYvLZC +DnbjjvbdACrXizIp +EOcLKvbdTvMQJtAq +DncLKvbdssSTZZeD +DnbjjvbdmozZVjxb +EOcLKvbdtSrSxzFD +EPDLKvbdZyDjOCkr +DnbkKvbdbBWEeopX +EOcLKvbdkWWmcbXw +DoCkKvbdkVwNdBww +DncKjvbdEzsqFMCi +DncLKvbdACqxJyhp +DoDKjvbdYpmFIleR +DncKjvbdGKdsCglu +DoCkKvbdZnnJFEzK +DoDKjvbdBsBCtGWr +EPDKjvbdBcpAuimG +DnbjjvbdIGfzYxXg +DnbkKvbdGLEsCgmV +EPCkKvbdySnJNSBg +DoCkKvbdPyNAGrqj +EPDKjvbdmaivxPNu +DnbjjvbddoFSkUUS +DoCkKvbdySmiNRag +DoDLKvbdEYXlUUUM +EObkKvbdCTBCtFwS +DoDLKvbdoznDkXoA +EOcLKvbdBvzciEov +DoCjjvbdSPtHJfEX +EPDLKvbdtvOYJqTA +EPDKjvbdZisHpHBf +EPDKjvbdILazmvqL +EOcKjvbdRpUHKGDw +DncKjvbdWXJYWDdg +EPDLKvbdIwtCHlQp +EPDKjvbdUtNTfLvK +DncLKvbddZxpXxqC +EOcLKvbdkNBlZdgP +EObkKvbdqYnhGqEY +EPDLKvbdfpBzwDwh +DncLKvbdTkuoBVoJ +DnbkKvbdvvlBWAvV +DoCjjvbdrXQMCiYq +EPCjjvbdFeiqmiUR +DncLKvbdzjUopDsU +DncKjvbdhkeDmuCy +EPCjjvbdVqnYBdlD +EOcLKvbdSCDeLiYk +DoCjjvbdJvUeceHJ +EPCjjvbdjgfkfFnL +DnbjjvbdkVwNdBww +EObkKvbdczYowyRC +EPCjjvbdZoNhddyj +EPCjjvbdOSsugEuQ +EObkKvbdZMRcsnLm +EObjjvbdrMzJyLgi +EPDKjvbdrSUjnKaN +EPDKjvbdSLYfUfkT +EPDKjvbdUVlQKUAq +DoDLKvbdJcKCqJbx +DnbjjvbdeFPRbWcK +DoCkKvbdVAbQsQqy +DncLKvbdpeceTvBI +DoDLKvbdcIlikFwY +DoDLKvbdbsDLTdJa +EPCkKvbdRXOEClHc +DnbjjvbdbKkennDA +DncLKvbdEzsqEkcJ +EPCjjvbdJvUedEgJ +EOcLKvbdzitpQDsU +DncLKvbdQvnDblHc +EOcKjvbdbQGgDkzd +DnbkKvbddZyPxYpb +EPDLKvbdLrXNZuQz +DoDKjvbdDjIJvYKA +EPCjjvbdbVCHXjsh +EOcLKvbdsPunicVf +EOcLKvbdEzspdlCi +DoDLKvbdmRxtzSdJ +DnbjjvbdsBfNLfjy +DoCjjvbdcTDLUDia +EPDLKvbdidjgVPAO +DoCkKvbduVmxKQsA +EObjjvbdxLXDgzzG +EPCkKvbduaEZSoFI +EOcLKvbddneSjssr +DoCkKvbdWXJYVdFH +DncLKvbdHkaznWqL +DncKjvbdbVCGxKsh +DnbjjvbdiMEcmtcZ +DoDKjvbdqAheAXHd +EPCkKvbdMIalQxAS +DnbjjvbdVviXucdg +DnbjjvbdMpXpumgT +EObkKvbdMJCLqYAS +EObjjvbdczZQYYqC +DncLKvbdUxgtZjoO +EOcLKvbdjuwNdCYX +DncKjvbdSwjlNzkY +EPDLKvbdrWpLbhxq +DoDKjvbdnBjWwoOV +EPCjjvbdmSYtyrdJ +DoDLKvbdzeZnzdzQ +DncLKvbdMowqWOGs +EPCkKvbdqTsfqrLU +EObkKvbdraemMHKy +EOcLKvbdJcJbpjCx +DnbjjvbdmuUzKjRf +DncKjvbdNeEThhkE +DoDKjvbdHakydzAD +EOcKjvbdXsLaNUPY +EObjjvbdLFfHbBQu +DncLKvbdbKlFoODA +DoCjjvbdRpTfiecw +DnbkKvbdRkYetgLT +DoCjjvbdegkVrOQg +DoDLKvbdhlFEOUby +DoCkKvbdFyUtaEXb +DnbjjvbdAMgxsXZx +EOcLKvbdUQqOtuHm +EPDKjvbdxrmiMrCH +EOcLKvbdREDApQdS +DoDLKvbdWRmxBdlD +DnbjjvbdiHKCyVjV +EPCkKvbdxwhjCPyk +EObjjvbdLKaHvAJy +EPDLKvbdZtJJYcsO +DoCjjvbdbPfgDkzd +EObkKvbdUaBqTRRy +EPDKjvbdGYtuAcwb +DnbjjvbdQcbaQRDr +EPCjjvbdsBfNMHKy +EPDKjvbdZyDimblS +DoDKjvbdJXtBglRQ +EObkKvbdpssfrSLU +EOcLKvbdMRwMytpz +DoCjjvbdEYYMUTtM +DoCkKvbdeAUQmXif +DncLKvbdUaBqSpqy +EObkKvbdVAbQrqRy +EObkKvbdwXMAuaWV +DncLKvbdCIjakIfK +DncLKvbdjmBkzEfo +EOcLKvbdKVtfDeGi +EObkKvbdnQZyVjxb +DncLKvbdzRPMhiwA +DncKjvbdJpydnfOF +EPDKjvbdqTsfrRkU +EPDLKvbdEuyQPlie +DnbjjvbdfSBWzlCo +DnbkKvbdqiAKFMne +EPCjjvbdatbHYLUI +EOcKjvbdNsTugEtp +EPCkKvbdmgFXmNgZ +EPDLKvbdMSXNZtpz +DoDKjvbdUaBprqRy +DnbjjvbdXmqAXtvU +EOcKjvbdHlBznWpk +EOcKjvbdVqmwbElD +DoCkKvbdqrVLOLAm +DnbkKvbdZshiYcrn +DoCkKvbdZoNhddyj +EOcLKvbdEuxooljF +DnbkKvbduCcVXVoP +EPCkKvbdmuVZjirG +DncKjvbdRzKHrbvA +EObkKvbdeKJqutzn +EObkKvbdyOShXsIc +EPCjjvbdRbDdlJZL +DoDKjvbdSBdFMIxk +DncLKvbdKaKgMawq +EObkKvbdCDpAuilf +DnbkKvbdRWnDcLgc +DncLKvbdqlzJxkhJ +EPCjjvbdNHDQMpUk +EOcLKvbdRMwbZNtz +EPDKjvbdOEdThiLE +DoDLKvbdUyHszKoO +DnbkKvbdZisIPgCG +DncKjvbdwzHeeweS +DncKjvbdQwODcLhD +DoDLKvbdqdFJPmua +EOcLKvbdvwMAvBVu +EPDLKvbdbVBfwjsh +DoCkKvbdRyjHrcWA +DoDLKvbdWIYVxGxz +DnbkKvbdbiMjLGXY +EOcLKvbdBhjbKiFj +EObjjvbdCDpAvJmG +EPDKjvbdLBKfmCYR +DoCkKvbdbiMijevx +DnbkKvbdyOSgwriD +EPDLKvbdlYrqsZHU +EOcLKvbdwyhGFxFS +EPDLKvbdRyjHsCvA +EPCkKvbdHgGzYxYH +DoDLKvbdGFjRmhtR +EPDKjvbdFyUtaEYC +DncLKvbdeFOrCWbj +DoDLKvbdJSyArlwl +EOcKjvbdZyEKODLr +EOcLKvbdemGXGmJk +DnbjjvbdSCDeLhyL +DoDLKvbdYTLaMsnx +DoCjjvbdxKwEHzyf +EOcLKvbdiVZdvquC +DnbkKvbdUaBqTQqy +EPCjjvbdGZVVBEXb +DoDLKvbdCEQAvKMf +DoDLKvbdRWmdCkhD +EPDKjvbdRotHJecw +DoCjjvbdZxcimblS +EOcLKvbdtbcUvvOo +DnbjjvbdZsiJZDsO +EOcKjvbdRyjHsCvA +EOcKjvbdxLWdHzzG +DoCjjvbdFjdrbhMu +EPCkKvbdxVNFRYlO +DoCkKvbdmIcsqUqa +EPDLKvbdfMfWgMjL +EPDKjvbdTqQoUthN +EOcKjvbdtkwvaUAw +DoDKjvbdBdPaVilf +DoDLKvbdZMRdTmkm +EPDLKvbdelewGlik +DoCkKvbdwzHfFxEr +EPCkKvbdvAcyTPFI +EObjjvbdQdDBPqES +DoDKjvbdZtIiYcrn +EOcKjvbdypnlhiwA +DoCkKvbdNrtWGduQ +DncKjvbdxsOIlqbH +EPCjjvbdANIYrvyx +DnbjjvbdNwnuzdOU +EPCkKvbdFyUuBEXb +EOcLKvbdaaWFGQQX +DncLKvbdraelkfkZ +EPCjjvbdTpqPVUhN +DncKjvbdySmiNSBg +EPDKjvbdrpWPJbvG +EObjjvbdwNWANEFN +EObjjvbdZeYGzhJC +DoCjjvbddndsKstS +EPDLKvbdegkWSORH +EPCjjvbdvwMAvBVu +EPCjjvbdkySqrxgU +EPCkKvbdHkaznWqL +EPCjjvbdqlzKYkhJ +DncLKvbdZxdJmcMS +EPCjjvbdqGEFTvAh +EObjjvbdTYKkmzkY +EPCkKvbdZisHofbG +EOcLKvbdzoPpdcLx +EPDKjvbdZjTHpHCG +EOcKjvbdKWVGEFHJ +EPCjjvbdhyuFlROG +EPCkKvbdFjeTDIMu +DncLKvbdOYPVzcnU +DoCjjvbdSZjISbvA +DoCkKvbdZoNiEdyj +EPCjjvbdrWpMDJZR +EObkKvbdkVvnDaxX +EObjjvbdcSbjtDia +DnbjjvbdLGGICBRV +EPDLKvbdkWWmcbXw +EObjjvbdnHExNOHZ +DncKjvbdUtNUFlVj +EObkKvbdEvZPomKF +DoCkKvbduoTzpjnt +EOcLKvbdURQoVVHm +DnbkKvbdTAEiIBnd +DncKjvbdQwOECkgc +DnbjjvbdRbDdkiZL +DoCjjvbdEPCkLWcE +EPDKjvbdzjUpPdSt +EPDKjvbdZMSDsmkm +DoDLKvbdBdPaWJmG +EPCkKvbdwjwEHzyf +DnbjjvbdhuZeXSUb +DoCkKvbdlYrqsYft +DoCjjvbdEXxMTssl +DoDKjvbdzoPpdbkx +DncKjvbdWRnXbFMD +DoDLKvbddijRutzn +DncKjvbdnCKWwnmu +EOcLKvbdZMSDsmkm +EOcLKvbdUaCRTRSZ +EObkKvbdkCkjpgVH +DnbkKvbdirziTKiz +DoDLKvbdJpyeOenF +EObkKvbdGKdsDHmV +EObjjvbdoAKzshDn +EPDLKvbdlrZVZrci +DncLKvbdRzKHsDWA +EObkKvbdKkAhWAKZ +EPDLKvbdVAaqSqRy +DoCkKvbdjAPgApHK +EPCkKvbdBcpBWJmG +DncKjvbduCbuXWOo +EOcLKvbdqiAKEmOe +EPDKjvbdYpldhleR +DnbjjvbdEPCjjwCd +DnbjjvbdbsDKtEJa +EObjjvbdKfGICBRV +DoDLKvbdRadFMIxk +DoDKjvbdGGJqmhsq +EPCjjvbdJbicQjDY +DncKjvbdbiNKKfWx +EOcLKvbduLxXAsaX +EPCjjvbdEKIJuwjA +EPCjjvbdWRmwadlD +DnbjjvbdfMewGmJk +EOcLKvbdNxOuzdOU +DnbkKvbdfIKvSOQg +DncLKvbdQZNAHSqj +DnbjjvbdZLqdUNlN +EPCjjvbdSLYetgLT +DncKjvbdeEoSCWbj +EPDLKvbdsCFmMGjy +EPDLKvbdLGGHaaRV +DncLKvbdEuxpQMjF +EObjjvbdVYhTzLPO +EPCkKvbdaSFbhTek +DnbkKvbdDihJuwjA +EObjjvbdFjeTDIMu +EObjjvbdhkeDnUby +DoDKjvbdxUmEpyLn +DncLKvbdiVZdvqtb +DoCkKvbdunszqLPU +DnbkKvbdSBcdkiYk +EObjjvbdbhmKKevx +DnbjjvbdVZHtZkOn +DoDLKvbdZirgogCG +DoDLKvbdqBIeAWhE +EPCjjvbdwtmEqYkn +DncKjvbdKCjDRJbx +EOcKjvbdTvLpJsaR +DoDKjvbdyXhjBozL +DnbjjvbduDDUwVoP +DoDKjvbdzaAOfgBl +DoCjjvbdWSOYCElD +EOcLKvbdqwQMDJYq +DoCkKvbdNHColpUk +EPCkKvbdCEPaVimG +EOcKjvbdjKFhJlxS +EOcLKvbdxUleRYkn +DnbkKvbdrNZjZMHi +DoDKjvbdmuUzLKSG +EObjjvbdfIKurOQg +EPDKjvbdQlwbZNtz +DncKjvbdhkeDnUby +EObjjvbdwuMdqZMO +DncKjvbdliDtQtrB +EPCjjvbdNPwqWNgT +DncKjvbdjAPgApGj +EObkKvbdMpYRVmfs +DnbkKvbdGKeTChNV +DoDLKvbdHbMZdzAD +EObjjvbdQlwayOUz +EPDKjvbdVqnYCFLc +DoCkKvbdmpZyVjyC +EObkKvbdUslsfLuj +DoDLKvbdlhdURVSB +EOcLKvbdmSZVZrci +DoCjjvbdYzberJuy +EPDLKvbdhzVGLpnG +EPCjjvbdsPvOicVf +EObkKvbdeOeTLUUS +DncLKvbdmfdxMnHZ +EPDKjvbdHffzYwxH +EPDLKvbdrylPsAgn +EOcKjvbdwWlBWAvV +EPDKjvbdVAbQsQqy +DnbkKvbdsZlPsBIO +DncLKvbdEzspdkbi +DncLKvbdhyuGMROG +DoCkKvbdFaOpxizm +DoCkKvbdZsiIxcrn +DoCkKvbdijGHjMwr +DnbkKvbdcyxpYZQb +DnbjjvbdEzspdkbi +DncLKvbdNQYRVnGs +EObkKvbdkClKpgVH +EOcLKvbdkClKqHVH +EOcKjvbdhanbdvqR +EPCkKvbdmfdwmNfy +EObkKvbdYTMAmUPY +DoCkKvbdIGgZxxXg +EOcKjvbdnHEwlnHZ +DncLKvbdCDpAuilf +EPCjjvbdmbKXXoOV +EObkKvbdapGfdLzd +EPCkKvbdRjyGVHLT +DoCkKvbddoFTLTtS +EPCjjvbdGLFTCglu +DoCjjvbdiLeENtcZ +DoCkKvbdKCicQjCx +EPCkKvbduoTzqLPU +EPCjjvbduVmwiqTA +EPCjjvbdWIXuxGxz +EPCjjvbdpxngfqDx +EOcKjvbdeOdrkTsr +DoDLKvbdNrsufduQ +EOcKjvbdIHHZyXwg +DoCjjvbdpfEEsvBI +EOcKjvbdhgKDYvKV +DnbjjvbdmbJvxOmu +EPDKjvbdGdKujCKK +DoDLKvbdfkGzcGAE +EPCkKvbdZoNiEeZj +EPDLKvbdaMjbTUlg +EPCkKvbdSPsgJfEX +EPDKjvbdDxYLstUM +EPCjjvbdKVtfDeGi +EOcLKvbdpeceTvAh +EObjjvbdHffzYwxH +DnbjjvbdffMZnHHA +EOcLKvbdsQVnibvG +EOcKjvbdZirgpGbG +EObjjvbdJSxaTMxM +EOcLKvbdbrcLUEKB +EPCjjvbdGZUuAcwb +DnbkKvbdpssgRrLU +DnbkKvbdKVteceHJ +EPDKjvbdmajXYOmu +EPDKjvbdNwoVzdOU +DnbjjvbdrpVnicWG +DoDKjvbdjhGlFfNk +EObjjvbdEXwlTtTl +DoDLKvbdkCkkQftg +DncKjvbdDxYLtUTl +DncKjvbdNQYQunGs +DoDLKvbdZQleImFR +DoDKjvbduVmxKRTA +DoDLKvbdsrqsZZdc +DoDLKvbdZLqctNlN +EPDLKvbdNsUVfeVQ +DncLKvbdhuZeXRuC +EPCkKvbdiCObdwRR +DoDKjvbdIwsbIMQp +EObjjvbdtcCtvvPP +EOcLKvbdpyOhHRDx +EObjjvbdmgEwmOHZ +DoCkKvbdelevgNJk +DoCjjvbduLwwBTaX +DoCkKvbdXrlBNTnx +EPDLKvbduCcUvuoP +EPDKjvbdURRPVUgm +EObkKvbdBsBCsfXS +DoDLKvbdZjSgogCG +EObkKvbdhgKDZViu +EPCkKvbdEYXkstUM +DncLKvbdrMzJyLgi +DnbjjvbdaSFcIUFk +EPDLKvbdnBjWxOnV +EPDLKvbdssRryZeD +EOcKjvbderAvzkbo +DoCjjvbdZirhQHCG +DnbkKvbdBraCtFvr +EOcLKvbdxZgfFxFS +DoDKjvbdJuuFdFGi +EPDKjvbdUQqPUtgm +EPDLKvbdNHCpMpUk +EPDKjvbdnCKXYOnV +DoCkKvbddZyQXyQb +DnbjjvbdpxoHgREY +EPCkKvbdfNFwHNJk +DncLKvbdVBCQsQqy +EPCkKvbdUxhTzLOn +EObjjvbdSQTgJfEX +DoCkKvbdrWpLbiZR +DoDLKvbdtcDUwWOo +DoCkKvbdwzHfGXeS +EPDLKvbdrzMPraHn +EPCkKvbdDoCjjvcE +DoDLKvbdbhlijewY +EObkKvbdUxgsyjoO +DoDLKvbdbUafxKsh +DoCjjvbdULuoBWOi +EPCkKvbdVBBqSqRy +DoCjjvbdhkeENtcZ +EPCjjvbdqYnggRDx +DncLKvbdjhHMFfOL +EOcKjvbdZxcinDMS +DoDLKvbdvBDySndh +DncKjvbdirziTKiz +DncKjvbdJXsaglRQ +DncKjvbdhfjDYvJu +DncLKvbdjuvnDbYX +EOcKjvbdKaLHMaxR +DoCjjvbdiGjDZWKV +DnbjjvbdEObjkWbd +DnbkKvbdJmADygVB +EPDKjvbdJvVFdEfi +EPDLKvbdnGeXmOGy +DoCjjvbdpssgSSKt +EPDKjvbdwtldqYlO +EPDKjvbdmfeXmNgZ +DoCjjvbdqvokbiZR +DoDLKvbdqUUHSRjt +EObkKvbdmbKXYOnV +EOcKjvbdaSGChTfL +EPCkKvbdWWiYWDdg +DoCjjvbduoTzqKnt +DnbjjvbdHDkVjBjK +EOcKjvbdbVBfwjtI +EOcKjvbdjvXOEBxX +DncKjvbdZLrETnMN +EObkKvbdfNGXHMjL +EPCkKvbdkDLkRHUg +EObjjvbdZjTIQGbG +DoDKjvbdZsiIyDsO +DnbkKvbdbrbjscjB +EPCjjvbdmbJwYPOV +DoCkKvbdKDJcQicY +DoDLKvbdZxcinCkr +DoDKjvbduoTzqLPU +EOcKjvbddndsKstS +DnbjjvbdNQXqWNfs +EOcKjvbdIidAKQGd +DoDLKvbdTkvOaVni +DoCjjvbdsPvPJcVf +DoDKjvbdVqnXbElD +EOcKjvbdIHGyyXxH +DnbkKvbdUxgszLOn +EPDLKvbdwuMdpxkn +DnbkKvbdqrVLNkBN +DncKjvbdijFgjMwr +EPCkKvbdSQUGjFcw +EObjjvbdRWmdCkgc +DnbkKvbdVTltFkvK +EOcLKvbdJbjCqKDY +EObkKvbdfMfXGmKL +EObjjvbdzRPNJKXA +EPCjjvbdBsAbtGWr +DoDKjvbdJXsahLqQ +DnbkKvbdlBNOmALA +DoDLKvbdlrYtzTDi +EPDLKvbdZtJIxdTO +DncKjvbdmbJvxPOV +EPDLKvbdaMkBsUmH +EPCkKvbdNsUVgFUp +DoCjjvbdWfYytAPT +EObjjvbdNHCpMpVL +EPCjjvbdMgComPtk +EOcLKvbdeqaWzlDP +DoCkKvbdFVxopNKF +EOcKjvbdYkrDsmlN +DncKjvbdWWiYWEFH +DoDKjvbdSLYfUfkT +DnbjjvbdhkeEOVCy +DoDKjvbdJXsagkpp +DoDLKvbdZoOIdeZj +DncLKvbdLiCMRYAS +DncKjvbdyOTHwsJD +DncKjvbdvmWANDeN +DoDLKvbdtTSTYydc +DoCkKvbddneSjtTr +EObkKvbdkDMKpftg +DnbjjvbdbhljKewY +EPCkKvbdIsZBSlwl +EPCjjvbdlqxuZsDi +DnbjjvbdNrtWGeVQ +EOcLKvbdvBEZSndh +EOcKjvbdrJAJdmOe +DoCjjvbdyOTHxTIc +DoCjjvbdmfdwlnGy +EOcLKvbdkDMKpgVH +DoCkKvbdRECaQQdS +DncKjvbdaMjartlg +EPCjjvbdVviXuceH +DnbkKvbdNsUVgFVQ +DoDKjvbdFkEsDIMu +EOcKjvbddZyPwyQb +DoDKjvbdqmZixlIJ +DoDKjvbdrEEhomvB +EOcLKvbdlZSqsZHU +EPCkKvbdehKuqmqH +DoDLKvbdFxtuBDwb +EPCjjvbdKjaHvAJy +DncLKvbdBcpAujMf +DoCjjvbdNQYRWOHT +DoCjjvbdHakzEzAD +EPCkKvbdJTYaSlwl +DoCjjvbdzitpQETU +DoDKjvbdvBEZSoFI +DncLKvbdnBjXXoOV +DoDLKvbdiZuGMROG +DoDKjvbdKVtecdfi +DnbjjvbddjJqvUzn +EPCkKvbdaMjbStlg +EOcKjvbdSZjHsDWA +DnbkKvbdUaCRSqSZ +DoDLKvbdxZgefXeS +DncKjvbdjhGkfFnL +DncKjvbdIjEAJogE +EPCkKvbdNGcPlpVL +DncKjvbdUMWPAvOi +DnbkKvbdatafxKsh +EObkKvbdjcMLQgUg +DoDKjvbddeOqavcK +EOcLKvbdoznELXoA +EPDLKvbdeOdrjtUS +DnbkKvbdjKFhJmXr +EPCkKvbdpxoHfpdY +DoCjjvbdZLrDsnMN +EPCkKvbdwyhFexFS +EOcKjvbdkClKpftg +DoDKjvbdxnTIYSiD +DncKjvbdxnShYSiD +DoCkKvbdFxtuBDwb +EObjjvbdYkrEUNkm +DnbjjvbdNQYQvNfs +EPCkKvbdhlFDnUby +EOcLKvbdiCObdwRR +DoCjjvbdVwJXvEFH +DnbkKvbdBvzchePv +EObkKvbdZHWdAPSi +DncKjvbdHgGzYxXg +DoCkKvbdMJCMQxAS +EPCkKvbdZLqdTmkm +DoDLKvbdnCJwYPNu +EPCjjvbdOSsvGdtp +DncKjvbdlYrqsZGt +EOcLKvbdJYUBhLqQ +DoCjjvbdZisHpGaf +DnbjjvbdVgxWXfxz +EPDKjvbdkWXNdBxX +DoCkKvbdlZTSSyHU +DncKjvbdjggLeenL +DnbjjvbdKNAEZfuB +DoCjjvbdLAkHMaxR +EOcLKvbdZRNFJNFR +DoDLKvbdjAQGaPfj +EObjjvbdjggMGFmk +DoDLKvbdyfyMAMeX +DncLKvbdjbkkRHVH +EOcLKvbdOTTugFVQ +EOcKjvbdWHxWXfxz +EPCkKvbdvwMBWBVu +EPCjjvbdnHEwlnHZ +DoDKjvbdHEKuiaij +DoCjjvbdVwIwvEEg +EPDLKvbdehKvRnRH +DncLKvbdnVUyjirG +EObjjvbdfMevgNJk +EPDKjvbdjbkjqHVH +DncLKvbdrJAKEloF +DoCkKvbdGckWJaij +DnbjjvbdTvMQJtAq +EPCkKvbdhkddNtcZ +DnbkKvbdrzMQTBIO +DncKjvbdsZlQTAgn +EPDLKvbdOFDtJIjd +EOcLKvbdnBivwoOV +DncKjvbdJXtBhLpp +EPCkKvbdJTYaSmXl +EOcLKvbdLGFgbBQu +DncKjvbdnHEwlmgZ +DoCjjvbdACrYJzJQ +EPCkKvbdiZuGLqNf +DnbjjvbdnGdxMmfy +DnbkKvbdRkZGUgKs +DoDLKvbdZisHofaf +EPDLKvbdJKEAJpGd +DnbkKvbdBsBDUFwS +EObjjvbdtcDVWuno +EOcKjvbdBsAbsfWr +EPDKjvbdrWpMChyR +DoDLKvbdVTltFkuj +EPDKjvbdGFjSOJUR +EOcKjvbdBsAcUGXS +EPCkKvbdcJNKKfWx +EPDLKvbdnQZyWKxb +EPCkKvbdqTtGrSKt +EObkKvbdjJfIKNXr +EOcLKvbdVqmxBdkc +EOcKjvbdFWYopMjF +DnbjjvbdqdFJPnWB +DoCjjvbdehKvRnRH +EPDKjvbdkyTRsZGt +EObjjvbdozmckYPA +DnbjjvbdbrcLUDjB +DoDLKvbdrMyixkhJ +DoDLKvbdrpWOjCvG +DoDKjvbdLFehCAqV +DncKjvbdrWpMCiYq +EOcKjvbdVTmUFkvK +EObkKvbdhficZVjV +EPCkKvbdIsZAsNXl +DoCjjvbdmfdxNOHZ +EPDKjvbdznopdblY +DnbjjvbdLiCMRYAS +DncLKvbdePEsKstS +DoDLKvbdUMVoBVni +DncKjvbdWRnXaeLc +EObjjvbdrDdiPmvB +DoDKjvbdDoDKkXDE +DncKjvbdOAIrtJrA +EPCkKvbdwzIGGXdr +EOcLKvbdUQqPUtgm +EPDLKvbdhlFEOUby +DncKjvbdZirhPfbG +EOcLKvbdKVuGEEgJ +DoDKjvbddePSBvbj +EPDLKvbdfHjuqmqH +EPDKjvbdZjSgpHBf +DncLKvbdunszpjoU +EPCkKvbdqTtHRrKt +EObjjvbdfNGXGljL +EObjjvbdUGznMWue +DnbkKvbdsPuoJbvG +EObjjvbdnQZxujxb +EPDLKvbdczZPwyQb +DoCkKvbdWXIwvDdg +EOcKjvbdQvmdDLhD +DncLKvbdCIkBjiFj +EObjjvbdjJegjNXr +DncLKvbdcIlikFvx +EPDLKvbdRkZFtfjs +DoCjjvbdczYoxZRC +EOcLKvbdatagXjsh +DncLKvbdjcLjqGuH +DoCjjvbdMSWlyuQz +DoCkKvbdjuvnDbYX +DnbjjvbdiMEdOUcZ +EPCjjvbdcTDKtEKB +DnbjjvbdwzHeexEr +EPDLKvbdemGWgNJk +EObjjvbdakLfOnDA +EPDLKvbdTfznLvvF +DoDKjvbdaNLBsUmH +EOcLKvbdhzVFkqNf +DoDKjvbdZRNFIldq +DoDKjvbdlrZVZsEJ +EObkKvbdbUagXjtI +DoDLKvbdUyHsykPO +EObjjvbdkVwNdCYX +EPDLKvbdUVkpJtBR +EPDKjvbdrMzJxkgi +EOcKjvbdSLYfUgLT +DoCjjvbdMRwNZtpz +EPDLKvbdIxTaglRQ +EPDLKvbdJqZdnenF +DoDLKvbdZMRdTmkm +DnbkKvbdANHxrvyx +EPCjjvbdFkErbhNV +EOcLKvbdWSNxCEkc +EPCjjvbdiCPCdwQq +DnbkKvbdbAvEeoow +EOcKjvbdeFOrBvcK +DnbkKvbdaRecHtGL +DnbkKvbdZshhxcrn +EOcKjvbdqTtHRrKt +EObjjvbdauBgXjtI +EOcKjvbdQdCaQRDr +DoCjjvbdFVxopMjF +EPDLKvbdIGgZyXwg +DoDLKvbdRpTfjFdX +DnbkKvbdSQUGifEX +DnbjjvbdpxoIHREY +DoDLKvbdqiAJeMne +EOcLKvbdCIkBkJFj +DncLKvbdFfKSNhsq +DoDKjvbdwWkaVaVu +EPDLKvbdNeETiJKd +DnbjjvbdhbOcEvpq +DoCkKvbdrbGMlHLZ +DnbjjvbdLAjgMawq +DncLKvbdlqyUzSdJ +DncLKvbdYkqdTnLm +EOcKjvbdYkrDsnMN +EOcLKvbdnCKXXnnV +DoCjjvbdDncLLWbd +DoDKjvbdYpmFJMdq +EPDLKvbdFpATXHFy +DoDKjvbdJvUfEEfi +EPDLKvbdmJEURVSB +DncLKvbdtbcVWuno +EOcLKvbdbUagYKtI +EObkKvbdcJMjKevx +DnbjjvbdKVuGEFGi +DoCkKvbdZMRctNkm +EOcLKvbdYpmEiMdq +DoDKjvbdYpmEhmEq +DncKjvbdzjVQQDrt +EPCjjvbdzHYlAMdw +EPDLKvbdYkqcsnMN +EObkKvbdiiehJmYS +DnbjjvbdDwwktUUM +EObkKvbdrounjCuf +DnbjjvbdGGKRmiUR +EOcLKvbdwzIGFxEr +EPDKjvbdOEdUJJLE +DoCkKvbdfNFvgMjL +DoDLKvbdOEdThhjd +DnbkKvbdyTOImSCH +EOcLKvbdzitpQESt +DoDKjvbduDCuWvPP +DoCjjvbdTppnuUhN +DoCkKvbdIBlZdzAD +DoCjjvbdZQmFJMeR +DnbkKvbdJXsaglQp +DoCkKvbdSZigrcWA +EObjjvbdZsiIyETO +EPDKjvbdZLqctOLm +DncKjvbdwyhGFxFS +DncLKvbdqwPkcIyR +EPDKjvbdRkYfUgLT +DoCkKvbdxxIjBpZk +DncLKvbdqlyjYlIJ +EPCjjvbdRaceLiYk +EPDKjvbdjlbLyeHP +EPDKjvbdrbFmLfkZ +EPCkKvbdvBEYsPFI +DncKjvbdSBdElJYk +EPDKjvbdpxoIHREY +EPCkKvbdjhHMFfNk +EPCkKvbdANIYsXZx +EObjjvbdnGdxNOHZ +EObjjvbdKQzFPGOF +DoCjjvbdtunYKRTA +DnbjjvbdLFfHbBRV +EOcKjvbdpedEsuaI +DnbjjvbdYkqcsmkm +EPCkKvbdbrcLUEKB +DnbkKvbdNQYQunGs +DoDLKvbdJcJbqKCx +EPDLKvbdIxTbHlRQ +DnbkKvbdvwMAvBWV +EOcKjvbdfHkVqnQg +EOcLKvbdbKkfPNcA +EPDLKvbdVAbQrpqy +DncLKvbdWRnXaeLc +EPCkKvbdFpATXGey +DoDLKvbdyfxlANFX +DoCkKvbdFVyQQMjF +EOcLKvbdxnShXrhc +DoCjjvbdmaivwoOV +DnbkKvbdbsDLTdJa +DoCkKvbdUtMtGMVj +DnbjjvbdNVSqkNAX +EPDLKvbdWfYytAOs +EPCkKvbdZyEJnDLr +EObkKvbdyXhjCQZk +EObkKvbddoFSkUTr +EOcKjvbdeATqMxKG +DnbkKvbdnPyyWKyC +DncKjvbdkySrTZHU +DnbjjvbdmfdxNNfy +EPCkKvbdHlBznXQk +EPDKjvbdZisIPgCG +DncLKvbdrEEhonVa +DoDLKvbdrykosBHn +EObkKvbdqvpLbiZR +DoCjjvbdhkeDnUcZ +DoCkKvbdVwIwudEg +DncLKvbdyXiJaozL +DoCkKvbdyzeOSIIh +EPCjjvbdkVwNcbYX +DncLKvbdTkuoAuoJ +EPCjjvbdijFgimYS +DncLKvbdliEURUrB +DoDKjvbdURQoUuIN +DoDKjvbdrMzJxkhJ +EPCkKvbdqYngfqEY +EPDLKvbddwzUTrFz +DoCkKvbdyYIjBpZk +EPCjjvbdssSSxzEc +EObkKvbdFejSNiUR +EPCkKvbdrEFJPmua +DnbkKvbdiifIJmXr +EPDLKvbdZLrEUOLm +EObjjvbdGFiqnItR +DoCkKvbdjuwNcaww +DncKjvbdmpZxukYb +DoDLKvbdqdFJQNua +EPDKjvbdNQYRWOGs +DoCjjvbdZeYGzhIb +EObjjvbdZjSgpHCG +EObjjvbdhfjDYvKV +EPCkKvbdJpzFOeme +DnbkKvbdlhcsptrB +DncLKvbdFeiqnJTq +EObjjvbdZxcinCkr +EPDLKvbdFVyQPmKF +EObkKvbdelfWfljL +EOcKjvbdJpydnenF +DnbkKvbdbVCGwkUI +EObkKvbdemFwGmJk +DoCkKvbdBsAbsfWr +EPDLKvbdJYTbHkqQ +DncKjvbdyNrgxTIc +DoDKjvbdGQASvfey +EOcLKvbdRNYCZOUz +EOcKjvbdyzeORgiI +EOcLKvbdZQmEhleR +EPCjjvbdmttyjjRf +DnbjjvbdLBLGmBwq +EOcLKvbdKVuFdFGi +EPCkKvbdxmsHwsJD +DoDLKvbdyOTIXriD +EPDLKvbdZsiJYcsO +EPCjjvbdjvXOEBxX +DoCkKvbdlZSqsZGt +DoDKjvbdADRxKZiQ +EOcKjvbdzoQREcMY +EObkKvbdGGKRmhsq +EObjjvbdJutfDdgJ +DoDLKvbdUsltFkvK +EObkKvbdHDkWKBjK +DncKjvbdLqwMzVQz +EObjjvbdaRecITfL +DoDKjvbdakMGPNcA +DnbjjvbdwXMBWAvV +EOcKjvbdQwOEDLhD +EOcKjvbdAMgxrwZx +DnbjjvbdqqtkNkAm +DoDLKvbdbhmKKewY +DoCjjvbdQmYBxnUz +DnbkKvbdvPTzqKnt +EPCkKvbdJqZePGOF +DoDLKvbdTfznMXVe +DoCkKvbdFyVUaDwb +DncLKvbdFxuUaDwb +EObkKvbdhlEcnUby +DnbjjvbdCJLCKhfK +DoCkKvbdPyNAGrrK +EOcKjvbdVgxVxGxz +EObkKvbdSxKkmzjx +EOcLKvbdemFwHMjL +EObjjvbdrEEiPnVa +DoCkKvbdDjIJvXjA +EPCjjvbdYTMAmToY +DoCjjvbdbLMFnmcA +DoCkKvbdrounjCuf +EPDKjvbdrJAJeNOe +DncLKvbdJbicQjDY +EPCjjvbdmpZxvLZC +DncLKvbdVrNxCElD +DnbkKvbdDoDLKwCd +DoDKjvbdsZkpSaIO +EPCjjvbdNQYRVnGs +DoCkKvbdVrOXbFMD +DoCjjvbdlYrqryHU +DoDLKvbdVTltGMVj +DncLKvbdwzHfGXeS +EPCkKvbdmajXYOnV +EOcLKvbdZLqdTmlN +DoDLKvbdqdFJQOWB +EObkKvbdVgwvXgYz +EPDKjvbdkMakzFHP +DoDKjvbdakLfPNcA +EObjjvbdyYJJbQZk +DoDLKvbdDigivXjA +DoDLKvbdHELWJajK +EObjjvbdZGvdAPTJ +EOcKjvbdUGzmkvue +DncLKvbdSZigsCvA +DoDLKvbddBsMrATm +EObkKvbdmSZUzSdJ +DncKjvbdjAPfaQGj +DoDKjvbdlBMoNALA +DnbkKvbdJTZArlxM +EObjjvbdHgHZyXwg +EPDLKvbdhzUekpnG +EPDKjvbdEOcKjvbd +DoCkKvbdjcLkRHUg +EObjjvbdBiLBkIej +DnbjjvbdZMSEUNkm +DoCkKvbdzRPNJJwA +EPCjjvbdGdKuiajK +EPDLKvbdrEFIpOVa +EPCkKvbdKfGHbApu +EPDKjvbdUtMsfMVj +DoDLKvbdbVCHYKsh +EPDLKvbdEztRFMCi +EOcLKvbdJmADzGta +DnbjjvbdtSrSxydc +DoCjjvbdACrYKZiQ +EPDKjvbdsrqsYzEc +DoCjjvbduLxXAtAw +DoCjjvbdEztQdkbi +DoDLKvbdkClKpgVH +DoDLKvbdSCDeMJYk +DoDLKvbdpxoIGqDx +DoCkKvbdDigjVxKA +EPDKjvbdGGKSOJUR +EOcLKvbdiLeDnVDZ +DnbjjvbdyOSgxShc +EPDLKvbdNsUWHEuQ +EOcLKvbdYpmFImEq +DoDKjvbdZLrDtOLm +DncKjvbdJvVGEFHJ +EOcKjvbdZirgogCG +EPCkKvbdKCjCqJbx +EObjjvbdgKfzcGAE +DncKjvbdZjTIQHBf +DoDKjvbdRDcBQQcr +DnbkKvbdZQmEiNFR +EObkKvbdSiZjRABM +EObkKvbdURROttgm +EObjjvbdlZSrSxft +DoCjjvbdNxPVzdOU +EPCjjvbdqAheAWhE +EPCkKvbdwXLaWBWV +DoCkKvbdKDKDQjCx +EOcKjvbdehLVqnQg +DoCkKvbdZxdJmcMS +DncLKvbdDjHjVxKA +EObkKvbdXrlAmToY +EOcLKvbdwtleRYlO +EPCjjvbdtlYWaUBX +EPCkKvbdiUzFXSVC +DoCjjvbdcJNJkFwY +EObkKvbdaRebhUGL +EOcKjvbdNHDQMotk +DoDLKvbdyTNhlqbH +EOcLKvbdKfGIBaRV +EObkKvbdKaLHMawq +DoCkKvbdnCKWwoNu +EPDLKvbdHffzYwxH +DncKjvbdnGdxMmgZ +EPCjjvbdNPwpvNgT +DoDLKvbdYkrEUOMN +DoDKjvbdTqROuUgm +DoDKjvbdvBDyTPEh +DnbkKvbdJKEAKQHE +EObjjvbdiBoCeWqR +DnbkKvbdmRyUyrci +DnbkKvbdJuuGEFGi +EOcLKvbdFyVVBEXb +EObkKvbdwyhGFwdr +EObkKvbdCTBDTevr +DoDKjvbdjbkkQftg +EOcKjvbdVAbQrqRy +EObjjvbdLAkHMawq +EObjjvbdEztQeLcJ +EPCjjvbdcIlikFvx +DncKjvbdZyEJmcLr +EObjjvbdqceJPmua +DncKjvbdZnmiEdyj +EOcLKvbdiGicYujV +DoCkKvbdFeirNhtR +DoCkKvbdDjHjVxKA +DnbkKvbdqFdEsvBI +EOcKjvbdcImKKevx +EPDLKvbdQmXbZOUz +DncKjvbdqcdhpNvB +EObkKvbdsPvOjCvG +DoDKjvbdFVyQPmKF +EOcKjvbdqYnhGpcx +EPDKjvbdKfGIBaRV +EPCkKvbdnGeXmNgZ +DncKjvbdKVtedEgJ +EObjjvbdCTAbsewS +DnbjjvbdeEoRavcK +EPCkKvbdNsUVfeVQ +EPDLKvbdGdLWKCKK +DnbjjvbdKfFhCBRV +DoCjjvbdZLrDtOLm +EPDLKvbdhtydvrVC +DoDLKvbdZjTIPfaf +DoCjjvbdbrcLTdKB +DncKjvbdzoQRFClY +DnbjjvbdSKyFuHKs +EOcKjvbdZQldiMeR +DncLKvbdkySrTYft +DnbkKvbdSLZGUgKs +EPCkKvbduCbuWvOo +DoDKjvbdsCFlkgLZ +DoCjjvbdrDdiPmvB +EPDLKvbdySnJNRbH +EPDLKvbdDoDKkXDE +EPCjjvbdijGHjMwr +EOcLKvbdeJjSWUzn +EPCkKvbdKWVFdEgJ +DoDLKvbdVYhTykPO +EObkKvbdeJiqutzn +DoCjjvbdRjyFuGkT +DoDKjvbdHDkWJajK +EPCkKvbdbKlFnnDA +EPDKjvbdQwOEDMHc +DoDLKvbdZshiZESn +EObjjvbdkyTSSyGt +DoCkKvbdxUmEpyLn +EObjjvbdMuSqkNAX +DncLKvbdbiNJkGWx +DoCjjvbdWIYVwfxz +DncLKvbdkVwNcaww +DoDLKvbdOFEThhjd +DoDLKvbddndrkUTr +DnbkKvbdyzeNrHiI +EPCjjvbdZRNEhldq +DncKjvbdhlEdNuDZ +DoCjjvbdqquKmkAm +DoDKjvbdFyVVBDxC +EPCkKvbdJuteceHJ +DnbkKvbdiBoDEvqR +DoDLKvbdLqvlzUpz +EPCjjvbdrRuKnLBN +DnbkKvbdZjShQHCG +DnbkKvbdcScLTcjB +EOcKjvbdyNrgxSiD +EOcKjvbdZirhPfbG +DoDLKvbdkIGkefOL +EPDLKvbdkCkkRGtg +EPDKjvbdbUafxLTh +EObkKvbdhfjDYvKV +DoCjjvbdpecdsvAh +EOcKjvbdpfDeUWAh +DnbkKvbdPxmAGsRj +DnbjjvbdZMSEUNlN +EOcLKvbdqFdFTvAh +DoCjjvbdWXJXvDeH +DoCjjvbdqUTfqrLU +EPCjjvbdvOszqLPU +EObkKvbdmtuZkJqf +EOcLKvbdjgfkefNk +DoCjjvbdhaoCeWqR +EObjjvbdKaLHMbXq +DoCjjvbdSLZFtfjs +DoCjjvbdFfKSOItR +DnbkKvbdqUUHSSKt +EPCkKvbdHEKujBjK +EObkKvbdIsZBSmXl +EOcKjvbdRDcApQcr +DoDKjvbduDDVWvPP +EOcKjvbdLBLGlaxR +DoDLKvbdIxTbHlQp +EPDLKvbdrRtkOKaN +DoCjjvbdRjyFtfkT +EPDKjvbdGQASwHGZ +EPDKjvbdMgDPlouL +EObkKvbdJXtCILqQ +EObkKvbdrEFJQNvB +DoCkKvbdeOeTKtUS +EObkKvbdSQTgJfDw +EPCjjvbdSQUGiedX +DoCjjvbdqUUGrRjt +EPDKjvbdTqRPVUgm +EPCkKvbdIMBznWqL +EObkKvbdhancEwRR +EOcKjvbdrMzJxkgi +EPCjjvbdhbPDEvqR +EPDKjvbdZHXEAOsJ +EPDLKvbdxnShXriD +DoCkKvbdLLAgvAKZ +DoCkKvbdhficYvJu +EObjjvbdZRMeIleR +DncLKvbdYfwEAOri +DoDLKvbdDwxMTtUM +DoCkKvbdWRmwbFLc +DnbkKvbdNQYRVnHT +DnbjjvbdjmCMZeHP +EPDKjvbdaNKbTUlg +EPCkKvbdidkHVPAO +DoCjjvbdHfgZxwxH +EObjjvbdxwhibPyk +EPDKjvbdFjeTDHmV +DoDKjvbdiCOcFWqR +DoCkKvbdJmADyfuB +EOcLKvbdhficYujV +DncLKvbdYzbfSJuy +DoCjjvbdbUagXjtI +DoDKjvbdjKFhKNYS +EOcLKvbdCIkCLJGK +DoDKjvbdZshiZESn +EPCkKvbdSQTfjFcw +EObkKvbdiMEcnUcZ +EPDLKvbdyOTHxSiD +EPCjjvbdFjeTDHmV +DnbjjvbdJuuGEFGi +EPDKjvbdhkeDnVCy +EPCkKvbdVAaqSprZ +DncLKvbdVUNTelVj +DoCkKvbdfILVrNpg +DncKjvbdNHDQNPuL +EOcLKvbdLZQirztf +EObjjvbdGckWKCJj +EObkKvbdIHGyyXwg +DncLKvbdiUydwSVC +DoDLKvbdpecdtWBI +EOcLKvbdLGFgaaRV +EOcLKvbdezuxeJUX +EObkKvbdgGLymgHA +DnbjjvbdEvZQQNJe +DncKjvbdJcJbpjDY +DoDKjvbdIxTahLqQ +DncKjvbdBcpAvJlf +EObjjvbdnPyyVkYb +EObjjvbdfNGWfljL +DnbjjvbdieLHVPAO +EOcKjvbdRNYCYmtz +EPDKjvbdiHJcYuiu +EObkKvbdMowqVnHT +DoCjjvbdiUydvrUb +EObjjvbdZMRcsnLm +DnbkKvbdaSFcIUFk +DnbjjvbdZyEKNcLr +DnbkKvbdZnnJFEzK +DncLKvbdJSyBSlxM +DoCkKvbdXsMAmUOx +EPCjjvbddneSkTtS +EOcLKvbdVwIxWEEg +EPCjjvbdxsOJMrBg +DncKjvbdkIHMGGOL +DncLKvbdGFjRmhsq +DnbkKvbdySmiNRag +EPDKjvbdpyPHgREY +DnbjjvbdGZUuAcxC +DnbjjvbdiHKDYvJu +DoCjjvbdtlXwBUBX +EObkKvbdTkvPAvPJ +EOcKjvbdSxLLmzkY +DncKjvbdhgJcZVjV +EOcLKvbdZirgogBf +EOcKjvbdTukpKUBR +EPDLKvbdQlwaxmtz +DoCkKvbdNxOuzdNt +EPDLKvbduCbuXWPP +EPCkKvbdmbJvwoNu +EObkKvbdKDKCqJbx +EPCjjvbdyNsIXrhc +EPCkKvbdSCEEkiYk +EObkKvbdOFDshiLE +DoDKjvbdZnmiFEzK +EObkKvbdJbjDRKDY +EObkKvbdYfvdAOri +DncKjvbdkDLjpfuH +DoCkKvbdsrqsZZdc +DoDKjvbdLBLHNBwq +DncLKvbdDjHjWYKA +DoDKjvbdZQleIldq +DoDKjvbdatbGxKtI +EObjjvbdUWMQKUAq +EOcLKvbdlhdUQtrB +EPCjjvbdAMhZTWyx +DoCjjvbdjhGlGFmk +DoDLKvbdHgGzZXxH +EOcKjvbdrykoraIO +DoDKjvbdjJehJlwr +EObkKvbdrEEhonWB +EPCjjvbdiUyeWrUb +DnbkKvbdNQYRVmgT +EPCjjvbdVUNUFkuj +DnbjjvbdEYYMTtUM +DoDKjvbdYpldhldq +EPCjjvbdtlYWaTaX +DoCjjvbdozmdLXoA +DnbjjvbdZnnJFFZj +EObjjvbdZshiZDrn +EPDLKvbdZjShPfaf +DoCkKvbdrpVnibvG +DoCkKvbdQwNcblHc +EObkKvbdxZgefXdr +DoDKjvbdNddUIhkE +DncKjvbdcImJkFwY +DoDKjvbdZirhQGaf +DoDKjvbdqwPkcJZR +EPDLKvbdkHgLfFnL +DncKjvbdlqxuZrci +DncKjvbdRadFLiYk +EPDKjvbdIHGyxxXg +EObkKvbdmpZyVjyC +EPCkKvbdUaBqSpqy +EOcKjvbdqZOgfqDx +EObkKvbdkNBlZeGo +EObjjvbdOAIrsjSA +EPDLKvbdEvZPpNKF +DnbjjvbdczYoxZRC +DoDKjvbdvAdZTPEh +DncKjvbdqUTfqrKt +EPCkKvbdZGwEAPTJ +EPDLKvbdZMSEUNkm +EPCjjvbdYkqctNlN +DnbkKvbdeEnqawDK +DoCjjvbdKVuGEFHJ +EOcKjvbdzitopDsU +DnbjjvbdsBfNLgLZ +DnbjjvbdcImJkFvx +EPCkKvbdMgCpNQUk +EOcLKvbdZQmEhleR +EPDLKvbdtTRrxzEc +DncLKvbdKVuFceHJ +EPCkKvbdyfxlAMdw +DnbkKvbdsZkosBHn +EPDLKvbdwWlAvBVu +DoDLKvbdlqxuZrdJ +EPDLKvbdMRwMzUpz +EObjjvbdFkFTCgmV +EObkKvbdHEKvJbKK +DncLKvbdkNCMZdfo +DoCjjvbddoFSkTtS +EPCkKvbdRpTfjFdX +DoDKjvbdIGgZyYXg +EPCkKvbdBiLCLIfK +DoCjjvbdKQydnfNe +EPCjjvbdHgGzZYYH +DnbjjvbdYNqAYUvU +DncKjvbdGckVjBjK +DoCjjvbdjhHMFemk +DnbkKvbdkIGkeenL +DncLKvbdmaivwnmu +EPDLKvbdmuVZkJqf +EPDKjvbdNddUIhjd +DoCkKvbdRDbaQRES +DncLKvbdTvLojUBR +DncLKvbdtSrSxyeD +DncKjvbdjgflGFmk +DoCkKvbdQwNdDLgc +DoCkKvbdEXwksssl +DoDKjvbdtAHRIAAr +DoDLKvbdSPsgJecw +EObkKvbdjggLfGOL +DoCjjvbdSBdFLhxk +DoCkKvbdiMEdNuDZ +DoCjjvbdhtzFWrUb +EPCjjvbdSKxetgKs +DoDLKvbddndsLTtS +DncKjvbdtcCtwVno +DoDLKvbdACrYJzJQ +EOcLKvbdyOShXrhc +EObjjvbdqquKnKaN +DoCkKvbdnCJvxOnV +EPDLKvbdFWYpQMjF +DnbjjvbdnCJvwoNu +EObkKvbdhfjCyWKV +DoDKjvbdrNZjZLhJ +DnbkKvbdyNrgwsIc +EPCkKvbdSZjITDWA +DncLKvbdqiAJeNOe +DoCkKvbdhaoDEvpq +EOcLKvbdtkwwAtAw +DncKjvbdsPvOicWG +DoCjjvbdWXJYVcdg +DoDLKvbdmIdUQuSB +DnbkKvbdauBgYKtI +EOcLKvbdJbicRKCx +DoDLKvbdsPuoJcVf +EPCkKvbdfILWRnRH +EPCkKvbdAMhYrvzY +DoCjjvbdKWUedEfi +EPCkKvbdhaoDEvqR +EObjjvbdxVMeRZMO +DncKjvbdFaOqZJzm +DncKjvbdIryArlwl +EObkKvbdRWmccLgc +EPCkKvbdsPunibvG +EOcKjvbdQccBPpcr +EPDKjvbdssRsYzFD +DncLKvbdySmiMqbH +EObkKvbdZLqdTmlN +EPDLKvbdVAaqTQqy +DncLKvbdFWZPomJe +DoDKjvbdUVkojTaR +DncKjvbdULvPBWPJ +EObjjvbdUslsfLuj +DoDKjvbdsBfMlHKy +DoCjjvbdkySrTYgU +EPDKjvbdYgXEAPTJ +EOcLKvbdrzMPsAhO +DoCkKvbdcyxpXyRC +DncLKvbdkIGkeemk +EObkKvbdVqnXbElD +EObkKvbdMuSqkNAX +DncLKvbdkNCLydfo +EOcLKvbdUVlQJsaR +EOcKjvbdczZPxYqC +EObkKvbdWIXvXfxz +DoCkKvbddndsLTtS +DnbkKvbdFfJqmiUR +DncKjvbdURROuVIN +EObkKvbdddnrCXDK +DncLKvbdZyEJmcLr +EPCkKvbdVgxVxHYz +DoDKjvbdFfKRmiTq +EPDKjvbddCTNSAUN +DoDLKvbdUxgsykOn +DoDLKvbdBhjbLIfK +DoCkKvbdFejRmiTq +EPDLKvbdmuUykJqf +DoCkKvbdVTmTfLuj +DoCjjvbdkNCLydgP +DnbjjvbdHffzYxYH +EObkKvbdpxngfpcx +EPCjjvbdKQzFOfOF +DncLKvbdOEdThiKd +EOcKjvbdJSyBTNXl +DncLKvbdyNsIXriD +EOcLKvbdJYTagkpp +DoCjjvbdkMakzEfo +DoDLKvbdZjSgpGbG +DnbjjvbdSQUHJfDw +DncKjvbdRpTgJedX +DncKjvbdrykosBIO +EObkKvbdGYttaEYC +DoCkKvbdZxcjNcMS +DoCjjvbdRadElIyL +DoDKjvbdkySqryGt +EPDKjvbdiHJbyWJu +EPCjjvbdwzHeewdr +EPDKjvbdQwNccLhD +DoCjjvbdbBVeGPow +EOcKjvbdddnrCWcK +EPCjjvbdJXtCHkqQ +EObkKvbdrbFllHLZ +DncKjvbdACqxKZhp +DoCkKvbdJXtCILpp +DncKjvbdEYYMTssl +EOcKjvbdwjvdHzzG +EPDLKvbdemGWgMik +EPCjjvbdqvokcIyR +DnbkKvbdUaCQrprZ +DoCjjvbdKCjCqKDY +EPDKjvbdYSlBMtOx +EPDLKvbdyXiKBozL +EObkKvbdZxdKNcMS +EObkKvbdCDpBVjNG +DncKjvbdmgExMmgZ +EObjjvbdHkaznWqL +EObjjvbdkNCLzEfo +EPDLKvbdyNrgwsIc +DncKjvbdnHFYNNfy +DoCkKvbdDwwktTsl +EPDLKvbdTlWOaWPJ +DoDKjvbdmIctRVRa +EPCkKvbdeEnqbWbj +EPDKjvbdTYLMNzkY +DncKjvbdkHgLfGNk +DncLKvbdnPyxvLZC +EOcLKvbdjKGHjMxS +DoCjjvbdiZtfMROG +EPDKjvbdFeiqmhsq +EPDKjvbdDoDKjvbd +EOcLKvbdKRZeOfOF +DoDKjvbdzoQQeCkx +EObjjvbdEOcLKwDE +DoCkKvbdrafNLgLZ +EObjjvbdMfbomPuL +DncKjvbdUQqPUthN +EOcLKvbddjJrWUzn +DoDLKvbdvBDySoEh +DnbjjvbdVUMselVj +DoCkKvbddndrkUUS +EObkKvbdmpZxvKxb +EPCkKvbdmbJvxPNu +EPCkKvbdmfdwlnHZ +DnbkKvbdZRMdhmFR +DnbjjvbdYSlBNToY +DncLKvbdzoQRFClY +EPCkKvbdVZITzLOn +DncKjvbdZtIiZDrn +DncKjvbdFVxopNKF +EOcKjvbdtTSSxydc +EObjjvbdUVlQKTaR +EPDLKvbdkMbLzEgP +DoDLKvbdKDJcQicY +DoDLKvbdJmAEZgVB +EOcKjvbdCWzdJFPv +DncLKvbddneTLUUS +EObjjvbdBcoaWJlf +EPDKjvbdGcjvJbJj +DoCjjvbdddoRavcK +EOcLKvbdAMhZSvyx +DnbjjvbdajlGOmcA +DoCkKvbdCIkCLJFj +DnbjjvbdMSWmZtpz +EOcKjvbdNGcQMpUk +EOcKjvbdTqROuUhN +DoCkKvbdFVxoolie +DoDKjvbdUQpnuUgm +EPDKjvbdnBiwXnmu +DnbjjvbdJuuGDdgJ +EPCjjvbdZLqcsnLm +EObkKvbdZnmheEzK +DoDKjvbdXsMAltOx +EObkKvbdiMEdOUcZ +DoDKjvbdZRNEhleR +DoDLKvbdMIbLpxAS +DoDLKvbdVwIwucdg +DoCjjvbdRbDeLiZL +DncLKvbdZMRctNlN +DoCkKvbdGcjvJbJj +DnbjjvbdSZihScWA +EPDLKvbdkDLjqHUg +DnbjjvbdZisIPfaf +EObjjvbdmpZyWLZC +EOcLKvbdrbGNLgLZ +DnbkKvbdkVvmdBww +EObjjvbddoFSjstS +EObjjvbdxwiJbPyk +EPDKjvbdTvLoitAq +DoCkKvbdZLrDsnMN +DoDKjvbdOAJTUJrA +EObkKvbdURQntuHm +EObkKvbdkIGkefOL +DncLKvbdsCFllHKy +EPCkKvbdatafxKtI +DoCjjvbdiifHjMxS +DnbkKvbdZsiIyDsO +DncKjvbdieKgUoAO +EPCjjvbdBhkCLIej +DnbjjvbdDxXktTsl +EObkKvbdKCjCqKCx +EOcLKvbdIwsahLqQ +EPDLKvbdhzUfLpnG +EObjjvbdbAvEepPw +EOcLKvbdSLZFuHKs +DnbkKvbdIidAJogE +DnbjjvbdJbjDQicY +EPDLKvbdQwODblID +EObkKvbdqZOgfqEY +EObjjvbdkWWnDbXw +DncLKvbdEvZPpMjF +EPDLKvbdKQydnfNe +EObjjvbdUWMQJtAq +EOcLKvbdqrUjmkBN +DoDLKvbdJmAEZfuB +DoCkKvbdhtydvqtb +DoCkKvbdtAHQhABS +EPDLKvbdxZhGGXdr +EPDKjvbdmSZVZrci +DnbkKvbdZjTHogCG +EObkKvbdYqMdiMeR +DoDKjvbddwzUURez +DoDLKvbdbKlFnnDA +EPCkKvbdGGKSOJTq +EObkKvbdLGFgbBRV +DoCkKvbdKyQjSzuG +DncKjvbdJcJcRJcY +EOcLKvbdnBiwYPOV +EOcLKvbdLGGHaaRV +EObjjvbddneSkTtS +DoDKjvbdiLddOUcZ +EObkKvbdsPvOjCuf +DnbkKvbdZyEKOClS +DoCjjvbdyzeORhIh +DnbkKvbdhkeDmuCy +EObkKvbdvvkaWAvV +EOcKjvbdzeZnzdzQ +DoCjjvbdVAaprqSZ +EObjjvbdjhGkefNk +DncLKvbdSKxfVHLT +EPCjjvbdZRMeImFR +DncLKvbdFeirOJTq +DncLKvbdFfJrOItR +DoDLKvbdmoyyVkYb +DncLKvbdddoRavcK +DoDLKvbdauBfxKtI +EObjjvbdSPtHJfDw +EPCjjvbdCEQBWJmG +DoCjjvbdDnbkLWcE +EPDLKvbdVUNUGMVj +DnbkKvbdnQZyVjyC +DnbkKvbdgFkymfgA +DoDKjvbdRDcBQQdS +EOcKjvbdtcCuWvOo +EObkKvbdlrYuZrdJ +DoCjjvbdZirgogBf +DoDLKvbdMfcPmPuL +EOcKjvbdDwwlTtTl +DncLKvbdwXLaWAuu +EPDKjvbdUaBqSpqy +EObkKvbdHlBznXRL +EPCkKvbdkMakzFHP +DnbkKvbdqZOgfpcx +DnbkKvbdUMWOaWPJ +DncLKvbdMfbolpVL +EObjjvbdfekynGgA +EPCkKvbdWWiXvEFH +DoCjjvbdpxnhGqDx +DoDKjvbdsQVnjDWG +EObkKvbdYNqAXtut +DncLKvbdDnbkLXCd +EObkKvbdKaLGmBwq +DoCkKvbdBvzciFPv +DoDLKvbdjKFgilwr +EPCkKvbdUaBqTQqy +DoDLKvbdVgwvYHYz +EPDKjvbdIHGyyXwg +EPDKjvbdEXxMTstM +DnbkKvbdQccBPpcr +DnbkKvbdMgCpNPuL +EPDKjvbdSPtHKFcw +DoDKjvbdkIHMGFnL +DncLKvbdnGeXmNgZ +DoDLKvbdhtyeWquC +EObjjvbdqGEFUVaI +EOcLKvbdNPwpumgT +DnbkKvbdZshiYdTO +DoDKjvbdZMSETmkm +DncLKvbdRbDdkhyL +EPCjjvbdTvMQJtBR +EObkKvbdjvXOEBww +DncLKvbdrXPkbiZR +EOcLKvbdFejSOJTq +EOcKjvbdegjvRnRH +EPDLKvbdJvVGDeHJ +EObjjvbdXrlBMtOx +DncKjvbdFejSNhsq +EPDKjvbdBiLBjiGK +EOcKjvbddiirVtzn +EPDLKvbdVBBqTRRy +DoCkKvbdeqaWzkcP +EObjjvbdqYnggREY +EPDKjvbdEARiNZwX +EObjjvbdSQTfifEX +EObjjvbdLBLHNBxR +EPCkKvbdNHCpMpUk +EPCkKvbdKVuGDdfi +EPCkKvbdxrnImRbH +EOcLKvbdZRNEiNFR +EOcLKvbdtbcUvuno +EPCjjvbdJTZAsNXl +EPDLKvbdFVyQPljF +DoCkKvbdieKftoAO +EObkKvbdZMSETnMN +DoCjjvbddePSBvcK +DncLKvbdqUUHSSLU +DoDLKvbdZQldhmEq +DoDKjvbdOTTugFUp +DncLKvbdZsiJZESn +DnbjjvbdtbcUwWPP +EPDLKvbddwzTtRez +DnbjjvbdZoNheFZj +EPCkKvbdKfFgbApu +DoDLKvbdhytfMQmf +DnbkKvbdnGeXlnGy +EPCjjvbdSBcdlIyL +DncKjvbdbAvFFpPw +EObjjvbdzoPpeClY +EOcLKvbdqwQMDIyR +EPCjjvbdmaivxOmu +EPCjjvbdIwsahLqQ +DncLKvbdddoSBwCj +EOcLKvbdrEEhpNvB +DoCjjvbdEPCkKvcE +DncKjvbdePEsLTsr +DncKjvbdmRyVZsEJ +DnbjjvbdZLqdTnMN +EPDKjvbdRbEFMIxk +EObjjvbdJXsbHlRQ +DncKjvbdkDMLQftg +EOcKjvbdOEctJIjd +DnbkKvbdqTsfrRkU +EPDKjvbdkIGkeenL +DoDLKvbdUxhUZjnn +DncLKvbdwyhFexFS +EPDKjvbdbLLfOmcA +DnbkKvbdtbbuXWPP +EOcLKvbdYpmEhmFR +DnbkKvbdxmsHxTIc +DoDKjvbdznoqFDLx +EObjjvbdmfdxMnHZ +EObjjvbdYTMBNUOx +EObjjvbdADRwizJQ +EOcLKvbdMoxQvOGs +EOcLKvbdrWolDJYq +EPCjjvbdeFPRbXDK +DoDKjvbdrDdhpNvB +EPDKjvbdZxdKODLr +EOcLKvbdWSNwadlD +EOcKjvbdxrmhlqbH +DoDLKvbdzoPqEblY +DncKjvbdTkuoBWPJ +DnbjjvbdrykpSaHn +EOcKjvbdKWUfDdgJ +DnbkKvbdZMSEUOMN +EObkKvbdSBcdkhxk +DnbjjvbdIGfyyYXg +EPCkKvbdnBjWwoOV +EOcKjvbdzaAPGgBl +DnbjjvbdkVvmdCXw +DoDLKvbdkDLkQfuH +DoCkKvbdVqnXbFMD +DncKjvbdWWiXuceH +DoCjjvbdBvzdIePv +DncKjvbdLFfICBQu +DncLKvbdeFPRawDK +DncKjvbdjmBkydgP +EObjjvbdVUMtFkuj +EPDLKvbdrSUjmkBN +DoDLKvbdSPsgKFdX +DoDKjvbduDDVXVno +DoCjjvbdMuSqjmAX +EPCkKvbdZyEJmcLr +DnbkKvbdMfcQMouL +DoDLKvbdUMWPAuni +DnbjjvbddZxpYZRC +EPDKjvbdbAvEeopX +DnbkKvbddoErkUUS +DoCjjvbdePErjstS +EOcKjvbdGKeTDHlu +EObjjvbdfIKvSORH +EPCjjvbdUsmTelWK +EObkKvbdaMkBsVMg +DoCkKvbdRjxfVHKs +DnbkKvbdMpYQumgT +DncLKvbdVwIxWEFH +DncKjvbdaMkCTUmH +DoDLKvbdhlFENuDZ +EPCjjvbdZisIPgCG +EPCjjvbdZnnJEdzK +EPDKjvbdGLEsDINV +EObjjvbdYzcFrKVy +EPDKjvbdZirhPgBf +EPDLKvbdKaLGmCXq +EObkKvbddoErkTsr +DoCkKvbdRXNdCkgc +DoDLKvbdEvZQQNKF +DoCkKvbdZoNhdeZj +EPCkKvbdhkddNtby +EPDLKvbdZLrDtNlN +DncKjvbdRbDdlIxk +EPCkKvbdEOcKjwCd +DncKjvbdlqyUyrdJ +DoDLKvbdNddThhkE +EOcKjvbdwyhFewdr +EPDLKvbdiUydwSVC +DnbkKvbdYzcFqjWZ +DnbkKvbdiBoCdwRR +EOcLKvbdpecdsuaI +EPCkKvbdQlxCYnUz +EPDLKvbdVvhxWEEg +EOcLKvbdlZSqryGt +EPCkKvbdUaCQsQqy +DoCkKvbdvAdZSndh +DnbjjvbdmttykKRf +EPCkKvbdYgWdAPTJ +DoCkKvbdlYrqsZGt +DnbkKvbdZsiIxcrn +DoCjjvbddeOqavbj +EObkKvbdbVBfwjsh +EObjjvbdMoxQvOHT +EPCkKvbdRbEFLiYk +DoCkKvbdlhdTqUqa +EOcLKvbdMIbMRYAS +EObkKvbdDncKkWbd +DncLKvbdfSAvzkcP +DnbkKvbdxsOIlqbH +DoCkKvbdADSYKZhp +EPCjjvbdZshiZESn +DoCjjvbdieLGuPAO +EPCjjvbdkHgMFenL +EPDKjvbddBrlrAUN +DncKjvbdddoSCXCj +EPCjjvbdsQWOibvG +EObkKvbdKkBHvAKZ +EObjjvbdkWWmdBww +EObjjvbdnGeXmNgZ +EOcLKvbdyNrgwrhc +DnbkKvbdNddThiLE +DncKjvbdDjHivYKA +EObjjvbdWXIxWDdg +EObjjvbdrMyixlIJ +EOcKjvbdcyyPxYpb +DncKjvbdcyxowxpb +EOcLKvbdhbOcFXQq +EOcKjvbdHDjuibKK +DoDKjvbdiVZeXRuC +EOcKjvbdnBjXYOnV +DnbkKvbdOTTufdtp +DoDKjvbdVAbRTRSZ +DnbjjvbdRXOEDLgc +EOcLKvbdznopdcLx +DncLKvbdRNXayOUz +DncLKvbdSPtHKFdX +EPDKjvbdxUldqYkn +DoCkKvbdZRNEiNEq +EPDKjvbdrbFllGjy +EPCjjvbdUyHszLPO +DncLKvbdxwhibQZk +EOcKjvbdFWYopMie +EOcKjvbdaNKbTVMg +DnbjjvbdliETqUrB +EObjjvbdRXODbkgc +DnbkKvbdTlWPBWPJ +EOcKjvbdOFEThiKd +EObjjvbdMSXMzVQz +EObjjvbdHDkVjCKK +EPDLKvbdqFceTuaI +EOcKjvbdFyUtaDxC +EOcLKvbdmgExMnGy +DncKjvbdtlYWaUBX +DoDKjvbdCDoaWJlf +EPDKjvbdkyTSTYgU +DoCjjvbdqqtjnLAm +DnbjjvbdGYtuAdXb +DoCkKvbdBhjbLIfK +EPDKjvbdNPwqVmfs +DoCjjvbdsrqsYzFD +EPDKjvbdSPsfjFdX +EPCjjvbdZyDjNbkr +EPDKjvbdqZOgfpcx +EPCkKvbdqGDeUVaI +DoDKjvbdUVkpKUAq +DoCjjvbdRpUGjGEX +DoDLKvbdmgFYMmfy +EPDLKvbdRpUHKFcw +DoDLKvbdEvZQPmKF +DoDKjvbdZshhxdTO +DoCjjvbdiZuGMROG +DoDKjvbdfpBzvdYI +EPCjjvbdmgFYNOGy +EOcKjvbdNrtWGdtp +DnbjjvbdWHxVwgYz +EPCkKvbdJbjDRKDY +EPCjjvbduWOYJpsA +DncKjvbdehLVrORH +DoCjjvbdGFjSOItR +DoCkKvbdjuwODbYX +EObjjvbdJTZBSmXl +DnbkKvbdzQoNIiwA +EObjjvbdjJfHilwr +EOcKjvbdJpyeOfOF +DnbjjvbdqFdEsuaI +EPDLKvbdUxhTzKoO +EPDKjvbdBraCsfXS +DoCjjvbdLAjgNBxR +EObkKvbdlhdTqUrB +EPCjjvbdZoOIeFZj +DnbjjvbdrDdhpNua +EPCjjvbdIHHZxxYH +EPCkKvbdiMEdOVCy +DoDKjvbdhgJbxvKV +DoDLKvbdUyHsyjoO +DoDKjvbdGQATXGfZ +DnbjjvbdvAdYroEh +EPCkKvbdhtydvrUb +DoCjjvbdsQWOicWG +DncLKvbdcJMjLGWx +DoCkKvbdIwsaglQp +DoCkKvbdYkrEUOLm +EObkKvbdVvhxWDeH +EPDLKvbdZMRdTnLm +DoCjjvbdADRwizJQ +DoDKjvbdSwjkmzjx +DnbkKvbdBiKbLIfK +EPCjjvbdRyigsDWA +EPDKjvbdRXOECkhD +EObjjvbddxZtTqez +EObjjvbdbBVdfPow +DncLKvbdMfcQNQVL +EPDKjvbdVBBqTQrZ +DncKjvbdZMRctOLm +DncKjvbdGGJrOIsq +EPCjjvbdZMSETmlN +DoDLKvbdhlEdOVDZ +EOcLKvbdOhAXyAZB +DoCkKvbdyOTIYSiD +DoCjjvbdUtNUGMVj +EObkKvbdWXJYWDdg +EOcLKvbdBhjbKhej +EObkKvbdVwIwvDdg +EPDLKvbdzjUpQDsU +EOcKjvbdqAiFAXHd +DoDLKvbdqrUkNjaN +EOcKjvbdYORAYUvU +EOcLKvbdcIljLFwY +DnbkKvbdVwJXvDdg +DoDKjvbdVBCQsRSZ +DoDLKvbdmuUzKiqf +EObkKvbdJYUCILpp +EPDKjvbdsQVoKCvG +EPDLKvbdmoyyVkZC +EPDLKvbdsCGNLfjy +EOcKjvbdbiNKLGWx +DoCjjvbdrpVnjDWG +EObkKvbdfVzxPizs +DnbkKvbdRXODcLgc +EPCjjvbdjJfIJlxS +DoCjjvbdZLqcsnLm +DncKjvbdjuvnECXw +DoDLKvbdEPDKkXCd +DnbjjvbdOSsvGduQ +DoDKjvbdIMBzmvpk +EPCjjvbdqrUkOLAm +EPCjjvbdTkvOaVoJ +EObjjvbdozmdKwoA +DncLKvbdDxXkstTl +EOcKjvbdfMewHMik +DoDLKvbdGKeTCgmV +EObjjvbdxnSgwsIc +EPCkKvbdaaVdepPw +EObkKvbdqGEFUVaI +DncLKvbdjblKpgUg +DoDLKvbdRWnEDLhD +DnbjjvbdFxuVAcxC +DncKjvbdqZOhGpcx +DoCkKvbdfHjvRnQg +DnbkKvbdwMvANDeN +EObkKvbdFfKSOIsq +DoCjjvbdmajXYPNu +EObkKvbdANHyTXZx +EPCjjvbdLFfHbAqV +DoCjjvbdVgwuxHYz +EPCjjvbdQvmcblHc +DoDKjvbdaSFbhUGL +DncLKvbdzHZMANFX +DncKjvbdySnJNRbH +DoCjjvbdMpYRVnHT +EObkKvbddePSBwDK +EPCkKvbdMfcPmQUk +EObjjvbdMgCpNQVL +DoDKjvbdrEFIonWB +DoDLKvbdFjdsCgmV +EObjjvbdwtmFRYlO +DnbjjvbdIwtBgkqQ +EPCjjvbduaDxrndh +EPDLKvbdShzKRABM +DnbjjvbdfHjvRnRH +EOcKjvbdBiLBjiGK +EPCjjvbdCEPaWKNG +DoDKjvbdtbbuWuoP +DoDKjvbdegkWRmqH +DnbjjvbdNeETiJLE +EPCkKvbdjcLkRHUg +DnbjjvbdjvXOEBww +EOcLKvbdTlWPAvOi +DoCjjvbdrMyixkhJ +EObkKvbdqGEEtWAh +DncKjvbdbBVeGQPw +DoDLKvbdpssfqqjt +DnbkKvbdFWZPomJe +DoDKjvbdSBcdkiYk +DoCkKvbdvBEZSoFI +EOcKjvbdRaceLhxk +EOcKjvbdJKEAKQHE +DoDLKvbddZyQYYpb +EObjjvbdeXzTsqez +DncLKvbdCSaCtGXS +EPCkKvbdlZSrSyHU +EOcLKvbdTJZiqABM +DncLKvbdvAdYsOdh +DnbkKvbdcyxoxZQb +DnbkKvbdhanbdwRR +EPCjjvbdbBVeFopX +DncKjvbdGLFTDHmV +DoCjjvbdiZuGLpmf +EOcLKvbdJbjCqJbx +EObkKvbdGdLWJbKK +DoCjjvbdRkZGVHKs +DoCjjvbdGckWJajK +DncKjvbdAMgxrvyx +EPCjjvbdEPDKjvbd +EOcLKvbdkDLjqGtg +DoDLKvbdNPxRVnGs +DoDKjvbdySmhmRag +EPCjjvbdVqnXadkc +EPDKjvbdTulPitAq +EObjjvbdGLErcHlu +DoDLKvbdHELWKCJj +EObjjvbdbVCHYLUI +DncKjvbdqvpLbiZR +EPCjjvbdvAdZSoFI +EOcLKvbdfjfzcGAE +DnbjjvbdaNKartmH +EOcLKvbdcTDKsdJa +DncLKvbdOSsufduQ +DnbkKvbdyYIiapZk +DoCjjvbdunszqKoU +DoCkKvbddndsLTsr +DoDKjvbdxxJKBoyk +DoDLKvbdrovOibvG +EPCkKvbdiLddOVDZ +EPCkKvbdiBncFWqR +EOcLKvbdZQldiNFR +DoCkKvbdOEctJJKd +DoCkKvbdrMzKZMIJ +DnbkKvbdVhYVwgYz +EOcLKvbdQvnDblHc +DoDLKvbdmJEURVRa +DoDLKvbdCTBDUFwS +EPCkKvbdNrsvHEuQ +DnbkKvbdegkVqnRH +DoCjjvbddBrlrATm +DoCkKvbdCJLCLJFj +EOcKjvbdxZgefXeS +EPDKjvbdZtJJZDsO +DoCkKvbdQvmdDMID +DoDLKvbdRaceLhxk +DnbkKvbdSBdFLhxk +DoDKjvbdOTTufdtp +DoDLKvbdnQZxujyC +DnbjjvbdZshhyETO +DoCjjvbdtvOYJqTA +DncLKvbdRMxBxmtz +DnbjjvbdEzsqElCi +EObjjvbdKefHbAqV +DnbkKvbdmpZyWKyC +DncLKvbdNQXqWOGs +EPDLKvbdVTlsekuj +EPCkKvbdGcjvJajK +EPDLKvbdIryArlxM +DoDLKvbdwyhGFwdr +EPCkKvbdzaAOgGal +DncLKvbdiHKCxvJu +EOcKjvbdLBKgMbXq +DoCjjvbdTppoVVIN +EPDKjvbdNPxQvOHT +DnbjjvbdTvLpJsaR +DncKjvbdnVUyjiqf +EPCjjvbdVUNTfLvK +EOcLKvbdDxYLtTtM +DnbkKvbddePSCXCj +EPDLKvbdgGLzOHHA +DoCkKvbdTukpKTaR +DncLKvbdVUMtGMWK +EObkKvbdXnRAYVWU +DncLKvbdyqOmJJwA +DoDKjvbdFVyQQNKF +DncKjvbdvOszqLOt +EPCkKvbdZRMdhmFR +EPDLKvbdhlFDmuCy +EOcKjvbdkIHLeenL +DnbjjvbdqceJQOWB +DoCkKvbdzitpPdSt +EPCjjvbdFeiqmhtR +DoDLKvbdsQVoJcVf +EPDLKvbdUQpnuVIN +DoDLKvbdWSNxBdlD +EPCjjvbdpyPHgQcx +EOcKjvbdUyHsyjoO +DoCjjvbdxrnJNSCH +DoCjjvbdKDKCpjCx +EPDLKvbdxsOIlrBg +DoCkKvbdnGdxMnHZ +EPDLKvbdfHkWSNpg +DnbjjvbdkHgMGFnL +EOcLKvbdxmsIYSiD +DoDLKvbdEXxLsssl +DoDKjvbdjFLGuPAO +EOcLKvbdeEoRawCj +DoDKjvbdyOTIYSiD +DnbjjvbdIHGyyXxH +DncKjvbdTqQoUuHm +EOcKjvbdMfcQNPuL +DnbkKvbdatbGxKsh +DoDKjvbdOTUWHEtp +EPCkKvbdGLFTCgmV +DoDKjvbdkHfkfGNk +EObjjvbdJXtBhMRQ +EObkKvbdRpUHKGEX +DnbjjvbdiUzFWrVC +EPCkKvbdliETqUrB +DnbkKvbdZjTIQHBf +DoCjjvbdZMSETnLm +EPDLKvbdFWYoomKF +EPDLKvbdRaceLhxk +DoDLKvbdEASJNZwX +EPDLKvbdGZUtaEXb +DncLKvbdyNrgxSiD +EOcKjvbdbVBgXkTh +EPCkKvbdvOszpkOt +EObkKvbdKfGHbBRV +DncLKvbdjvXOEBxX +EPDLKvbdvAcyTPFI +EObjjvbdNsUWGeUp +EPCjjvbdZtIiZDrn +DoDLKvbdrRtkOLBN +DncKjvbdptUHSSLU +DncLKvbdWSOXaeLc +EPCkKvbdiLeDmuCy +DoCjjvbdhyuFkqNf +DnbkKvbdzoPqFDMY +DoCkKvbdGFirOItR +DoCjjvbdEObjkXCd +DnbkKvbdjKFgilwr +EPDLKvbdVwIwvEFH +DoDKjvbdfIKvRmpg +EPDLKvbdOFDsiIkE +EPDLKvbdGKdrcIMu +EPDKjvbdZnmiEeZj +DoDKjvbdKWVFceHJ +DncKjvbdvBDySneI +DncKjvbddeOqawCj +DoCkKvbdEztRFLbi +EPDKjvbdMpXpumgT +EPDKjvbdtunYJqTA +EPCjjvbdegkVqmpg +EObjjvbdlYsRsZHU +EOcKjvbdbUagXkUI +EPDLKvbdANHySvyx +DnbkKvbdmJEUQtqa +EPDKjvbdVUNUFlVj +EPCkKvbdvvlBVaVu +DoCjjvbdmozZWLYb +DoDKjvbdwzIFfXeS +DoDLKvbdNQXpvOGs +DncLKvbdEYXlTstM +EPCkKvbdbUbGwkUI +EOcLKvbdLBLHNBxR +DnbkKvbdePErkUUS +EObjjvbdyXiJaoyk +DncLKvbdVrNxBeLc +DoCjjvbdaRebhUGL +EOcKjvbdxsNhmSBg +EOcKjvbdXrkaMsoY +EObjjvbdhuZdwSVC +DoCkKvbdqGEFUWAh +DoDKjvbdegkVrNpg +DoCkKvbdtcCtvuoP +EOcKjvbdmJEUQtrB +EOcKjvbdWXIwucdg +DoDLKvbdhgKCyWJu +EPCjjvbdcSbkUDjB +EPDKjvbdLrWmZuQz +EPDLKvbdXrlAlsnx +DnbkKvbdKNADygUa +EPDKjvbdyNrhXsJD +EOcLKvbdIsZBSlxM +EPCkKvbddndrkTsr +DnbjjvbdFyUuBEYC +EPCkKvbdJcKCpjCx +EObkKvbdbBWFGQPw +EOcLKvbdFjdrbhNV +EPDLKvbdrDdiQNvB +EObkKvbdkHgMGGOL +EPCkKvbdkySrSyHU +DncLKvbdaaWEfQQX +EObkKvbdehKvRmpg +DnbkKvbdmIdURVRa +DoDLKvbdvBEZSneI +DoCkKvbdNdcshhjd +DncLKvbdZyEKOCkr +DoCkKvbdVrNwbFMD +DnbkKvbdnCKXXoNu +EPDKjvbdSQTgKGDw +EObkKvbdaRfCgtFk +EObjjvbdkWXNcaww +EObkKvbdDihJuxKA +DncLKvbdnVVZkKSG +EPCkKvbdVBBqSpqy +DncLKvbdqGEFUWAh +DoCkKvbdsPvOjDWG +DncKjvbdySmiNRbH +DoDKjvbdraemLfjy +DoDLKvbdnPzZWKxb +DnbjjvbdRjxfVGkT +DoDKjvbdGLEsDHlu +DnbjjvbdRotHKFdX +DoCkKvbdRpUGiecw +DnbjjvbdZjTHogBf +EPDKjvbdcTCjtDia +EOcKjvbdrounibuf +EOcKjvbdVBCRSqRy +EPDKjvbdEvZPolie +DnbkKvbdzRPNJKXA +DncLKvbdBhjbKiGK +DnbkKvbdqrVKmkBN +DnbjjvbdBraDTewS +DnbkKvbdJcKDRJbx +DoCjjvbdbUbHYLUI +DoDKjvbdUyITykOn +DoCkKvbdYlSEUOMN +EPCkKvbdRpUHKGEX +EObkKvbdTAFJICPE +EPDKjvbdrpWPJcVf +DoCkKvbdZnnJFFZj +EPCkKvbdkVvmcaxX +EOcKjvbdyzdnRgiI +EObjjvbdqAiFAXIE +DncLKvbdWWiYWDeH +EPCjjvbdqlzKZLgi +EObjjvbdauCGwkUI +DoDLKvbdtTSSxydc +EObkKvbdbVCGxLTh +EObkKvbdkWWmdBxX +EObjjvbdRNXaxnUz +EOcKjvbdwXLaVaVu +DncKjvbdqTtGqrKt +DncKjvbdIjEAJpGd +EPDKjvbdHffyyXwg +EObkKvbdSCEFLiYk +DncKjvbdiVZeXRuC +DoDLKvbdWWhwudFH +EPDLKvbdrRuKmkAm +EObjjvbdxsNhlqag +EPDKjvbdcJMikFwY +DoDKjvbdpyPHfpdY +DncKjvbdwyhGGXdr +DoCkKvbdkVwODbXw +DncLKvbdJcJbpibx +EPCkKvbdsQWPJcVf +EOcKjvbdZRNEiMdq +EObkKvbdjvXOECXw +EObjjvbdZxcjODLr +DncKjvbdRWmdDMID +DncKjvbdjvWmcbYX +DoCjjvbdnBjXXoOV +DncKjvbdiBnbdwQq +EPDKjvbdDoDKjwCd +EPCkKvbdFxuVBEYC +DncKjvbdFVxopMie +EOcLKvbdKWUfEEfi +EPCkKvbdNrtVgEtp +DoDLKvbdfoazwDxI +DoDKjvbdqquKmkAm +EPDKjvbdhbPCeXRR +DncKjvbdZtIhyETO +EPCkKvbdQwNdCkhD +EPDKjvbdhzUfMROG +DnbjjvbdrpVoKCuf +EPDLKvbdtlYWaUAw +EOcLKvbddoErjstS +DnbkKvbdyzeORghh +EPDLKvbdZnmhdeZj +DoCjjvbdcIlikGXY +EOcLKvbdLAkHNBxR +DoCjjvbdtkwwBUAw +DoCjjvbdgGMZnHHA +DnbkKvbdUsmTfLuj +EOcLKvbdqZPHgQcx +EPDLKvbdLqvlytpz +DoDLKvbdqdFIomvB +EObjjvbdBhjbKhfK +EOcLKvbdrMyjYlIJ +DncKjvbdDncKkXCd +DnbkKvbdNQXpunHT +EPDKjvbdZjSgofbG +DnbjjvbdBiKbLIej +DoCjjvbdGAoQxizm +EOcLKvbdwtldqZLn +DoDLKvbdIrxaSmXl +DoCjjvbdNHDQMpUk +EOcLKvbdTkunaWOi +DncLKvbdNHCpMpVL +DoDKjvbdelfXHNKL +EObjjvbdcyxpYYqC +DoDLKvbdZGwEAOri +DoDLKvbdIxUCHkqQ +DoCjjvbdoznEKxPA +EOcKjvbdbLMGPNcA +EObjjvbdiiegilxS +DoDKjvbdZRNFImFR +DncLKvbdRbDeLhxk +EPCkKvbdqlzJxlHi +EOcLKvbdhkeDnUby +EPCjjvbdhaoDEwQq +EPCkKvbdFkFScHlu +EPCjjvbdJKEAKQGd +DoCkKvbdpxngfqDx +EObjjvbdUGznLwWF +EObjjvbdVZHsykPO +DncLKvbdYlRdUNlN +EPCkKvbdHDkWKBjK +DncLKvbdjKFhKMxS +DnbjjvbdnBjWxPOV +EObkKvbdtcCtvvOo +DnbjjvbdTpqPUthN +DncLKvbdMoxQvOGs +DnbjjvbdfNGXHMjL +EPDKjvbdhgJcZVjV +DoDLKvbdNGbolpVL +EPDKjvbdatbHYLUI +DncLKvbdczZPwxqC +DnbjjvbdZxcimblS +EPDLKvbdKaKgMbXq +EOcLKvbdtbcUwWOo +DnbkKvbdJutfEEfi +DoCjjvbdmIdURUqa +EPCjjvbddBrmSATm +EPCkKvbdXsLaNUPY +DnbkKvbdNPwpvOGs +EOcKjvbdIwsaglQp +DoCkKvbdlhdUQtrB +DoDLKvbdGdLWJaij +DoCjjvbdwXMAvAvV +DnbkKvbdbrbkTdJa +EPDKjvbdFVxpQNJe +DoCjjvbdHDkWJbKK +DnbkKvbdjvXODbYX +DoCjjvbdemFwGmJk +DoCjjvbdQdCaPpcr +EOcKjvbdqcdiQNvB +DncLKvbdbBWFFoow +EOcKjvbdKaKgMawq +EObkKvbdLBKgMawq +DncKjvbdcbSmSAUN +DoCjjvbdyOTHwsJD +EOcLKvbdOStVfeUp +EObkKvbdHffyyYXg +EPCjjvbdmuUykJrG +DoDLKvbdJYTbILpp +DncKjvbdnGdwlmgZ +EPDKjvbdZQldhldq +EObjjvbdUaBpsRSZ +EOcKjvbdrzLpSaIO +DnbjjvbdLGFgbAqV +EPDKjvbdXrlAmUOx +EPDLKvbdtSqryZeD +DoDKjvbdtlXwAtAw +DoDKjvbdaRebgsfL +EObjjvbdUWLpKUAq +EObjjvbdQvmccLgc +EOcLKvbdznopeDMY +EOcLKvbdIwsbHkpp +EPDLKvbdziuQPcsU +EPDLKvbdelevgMik +DoDKjvbdTAFIgbOd +DoDLKvbdbBWFGPow +DoDKjvbdYqNEiMeR +EOcLKvbdhficYuiu +EOcKjvbdyTOImRbH +DncKjvbdiLeDmtby +EPDLKvbdUsmTekvK +DoCkKvbdkCkkQftg +DoCkKvbdVTmUFlVj +DoCkKvbdTIyjRAAl +EOcKjvbdbUafxKtI +EOcKjvbdZsiIxdSn +DoDKjvbdSCEElIyL +DnbjjvbdBsAbsfXS +DoCkKvbdBcpAuimG +DoCkKvbdVwIwvEEg +DnbjjvbdajlFoNcA +EPCkKvbdtSrTYzFD +DnbkKvbdGFirNhsq +EOcKjvbdapHHELzd +DoDLKvbdiUyeXSUb +DnbjjvbdtAGqIABS +DnbkKvbdXsLaMsnx +DoCkKvbdeEnqawDK +EOcKjvbdDxXkstUM +DnbjjvbdcyxoxZQb +DoDLKvbdlrZVZrci +DoCkKvbdTAEiICPE +EOcLKvbdpyPHfpcx +EPDLKvbdVBCRTQqy +DnbjjvbdmJEUQtqa +DnbjjvbdkClKqHVH +EObkKvbdCJKajiGK +EObkKvbdeAURMxJf +EPDLKvbdcSbkUDjB +DncLKvbdsCFmLfjy +EPCkKvbdIwsahLqQ +DoCkKvbdrJAJeMne +DoDLKvbdIHGzYwxH +DoCjjvbdGckVjBjK +EObjjvbdegkVqmqH +DoDLKvbdLKaIWAKZ +EPDLKvbdaRfChUGL +DoDLKvbdyYJJaozL +DoCkKvbdrWpLbhyR +DoCkKvbdLGGIBaRV +DoDKjvbdKyRJrztf +DoCkKvbdjuvnEBxX +EObkKvbdNeEThhkE +EPCjjvbdQwNcbkhD +DoCkKvbdJqZePGOF +EObjjvbdNGbomQUk +EObkKvbdkxrqsZHU +EOcLKvbdrounjDVf +DoDLKvbdkClLRGtg +EOcLKvbdbKkfOnDA +EPCkKvbdRDbaPpcr +EPDLKvbdkHgLefNk +EOcLKvbdFVxpPmKF +EObkKvbdsrrSxzEc +DnbkKvbdFeirOIsq +DncLKvbdzitopDrt +DoCjjvbduWOXjQsA +EPCkKvbdyXhjCPyk +DoDKjvbdaaWEfPow +DncLKvbdvAcySneI +EObjjvbdADRwjZhp +EObkKvbdnPyxvLYb +DncKjvbdijGIJlwr +EPCjjvbdJcJbqJcY +DnbkKvbdkMbLydgP +DoCkKvbdRDbaQQcr +DoCjjvbdxsOIlrCH +DnbjjvbdKQydnfOF +EPDKjvbdcImKKfWx +DnbjjvbdcImKKewY +EObkKvbdqdFJPmua +EObjjvbdajkennDA +DnbjjvbdZyEKNcLr +DoCjjvbdKWVFdEgJ +EPDKjvbdWXIwuceH +DnbjjvbdqiAJdlne +EOcLKvbdkyTRryGt +EPCjjvbdpaJFAWgd +EPCjjvbdmJDsqVSB +EPCjjvbdREDAopdS +DoCjjvbdRpUHKFdX +DncKjvbdptUHSSKt +EPCjjvbdiCObdvpq +DncLKvbdNwnuzcmt +DncKjvbdqdFIpOWB +DoDKjvbdjggLefNk +EObkKvbdrNZiyLgi +EPCkKvbdaSFcITfL +DnbjjvbdGLFTDINV +EPCkKvbdiLeENuDZ +DncLKvbdZyEJmcLr +EObjjvbduDCuWvOo +DoDKjvbdNQXqWNgT +DncKjvbdVBCRTRRy +EPCjjvbdSQUGifEX +EOcLKvbdANIZSvyx +DoDKjvbdvBDyTPFI +DnbkKvbdEPCkLWbd +DoCkKvbdyYIjCPyk +DnbkKvbdelewGmKL +EPDLKvbdatbGxLUI +EPDLKvbdTvLojTaR +DoCjjvbdhtyeWrVC +DoDKjvbdzeZnzdzQ +DnbjjvbdyzdnRhJI +EPCjjvbduLxWaUBX +EOcLKvbdkyTRsYgU +DnbjjvbdCTBCsewS +EObjjvbdjAPgApHK +EPDLKvbdwkWdHzyf +EObjjvbdsPvOicWG +DoCkKvbdTulPisaR +DnbkKvbduCcUvuoP +EObkKvbdZRMdiMeR +DoCkKvbdSPtHJfDw +DncLKvbdKaLGlaxR +DnbkKvbdRpTgKGDw +DoCjjvbdWXJYWEEg +EObjjvbdWXJYWDdg +EOcKjvbdKCjCqKCx +DnbkKvbdakMGPNcA +DoDKjvbdwkXDgzzG +EObkKvbdNHDPlotk +DncLKvbdyzdmrIJI +EObkKvbdFkErbhMu +EPCkKvbdNeDsiIjd +DoDKjvbdIGfyyXxH +DoCjjvbdZyDinDLr +EPCjjvbdemFvfmJk +EObjjvbdJYTbILqQ +DnbjjvbdWXIwucdg +DoCjjvbdiHKCxvJu +EPDKjvbdfpBzwDxI +DoCjjvbdaNLCStlg +EPCkKvbdnVUykJqf +DoCjjvbdyYIjBozL +EPCjjvbdzjUpQDsU +DoDLKvbdZxcjOCkr +EPCkKvbdeFOrBvcK +EPDKjvbdKaKflaxR +EOcLKvbdfMevgMjL +EPDKjvbdGckWKCKK +DoCjjvbdKVuFdEgJ +EObjjvbdfMfWfmJk +DoDLKvbdMfbomQVL +EPDLKvbdRkYeuGjs +EOcLKvbdKfGHaaQu +EObkKvbdoznDjwoA +EOcKjvbdUMWPBVoJ +DoCkKvbdFjeSbgmV +EPCjjvbdrEFJQOWB +EOcLKvbdvAcyTOdh +DnbjjvbdWfYzUAOs +EObkKvbdTkuoBWPJ +DnbkKvbdFpASvgFy +DoCjjvbdczZQXyRC +DoCjjvbdRDcBQQdS +DoDKjvbdqYngfqDx +EObkKvbdWRmwbElD +EPCjjvbdFyVVBDwb +EObjjvbdBhjbKhej +DncLKvbdzaAPGgBl +EObkKvbdTppoVUgm +DoCjjvbdbrcLTcjB +EPCkKvbdGLFTCglu +DoDLKvbdDwxMUUUM +EPCjjvbdNQYQumgT +DncKjvbdmfeXmOGy +EPCjjvbdwtmFRYkn +DoCkKvbdsBfMlGjy +DncLKvbdRpUHKGDw +EObjjvbdjblLQfuH +EObjjvbdJYTbHlRQ +DoCkKvbdmttyjiqf +DoCkKvbdZQldiMdq +EPDKjvbdFejSNiUR +EOcLKvbdjgfkfFnL +DnbjjvbdMpYQvNgT +DnbkKvbdUyIUZjnn +DnbkKvbdJbjDRKDY +EPCjjvbdeEnrBvcK +EOcKjvbdyzdnSIIh +DoDKjvbdDoDKjwCd +DoDLKvbdCSaDUFwS +DoDLKvbdIrxaTMwl +DnbkKvbdRNXayNtz +DoCkKvbdxxJKBoyk +DncLKvbdnGdxNOGy +DnbjjvbdySmhlqbH +DoCkKvbdxwhjBoyk +EPCjjvbdZQleIleR +EPCjjvbdaRfChTek +EOcKjvbdYTMBNUPY +DoCjjvbdegkWSNpg +EObkKvbdziuQPdTU +EOcKjvbdnCKXYOmu +DoCkKvbdZnmhddzK +EObjjvbdzaAPGgBl +DoDLKvbdePFSjtTr +EPCkKvbdNrtWGeVQ +EPCjjvbdelfWfmKL +DoDKjvbdKxpjSztf +EPDKjvbdxmsIXsIc +EPCjjvbddZyPxYqC +DoDKjvbdvOszqLOt +DncKjvbdatbGxLTh +EObjjvbdzoQQdbkx +DoCjjvbdZRMeImEq +EOcKjvbdqTtGqqjt +EOcKjvbdqAheAWgd +DnbjjvbdySmhmRag +DncKjvbdjKFhJlwr +EPDKjvbdqFceUWBI +DoDKjvbdsBemLgLZ +EPDLKvbdKQzEoFnF +EOcKjvbdFjdsCgmV +EObjjvbdpfEEtWBI +EPDKjvbdZxcjOClS +EPDKjvbdnBivwoOV +EPCjjvbdrylQTAhO +EPDKjvbdKaLGmBxR +EPDKjvbdHgGzYwxH +EObjjvbdkHflGFmk +DnbjjvbdqGDeUVaI +EPDKjvbdMgDQNQUk +DncLKvbdSKyGVHKs +EOcKjvbdqFdEsvAh +EOcKjvbdYkrETnLm +DnbkKvbdqBIeAXHd +DncLKvbdZQldhmFR +DncLKvbdFjeSbhMu +EPCkKvbddePRavcK +EPCkKvbdssRsYzEc +EPCkKvbdRadFLhxk +DnbkKvbdVvhxWEEg +EOcLKvbdIryArmYM +EPCkKvbdKfGHbAqV +DncKjvbdEKIJuxKA +EPDKjvbdIwsbIMRQ +EObkKvbdzaAOfgBl +DncLKvbdeUAUASlv +DnbjjvbdlqxuZsDi +DnbjjvbdUWMQKTaR +EOcLKvbdNGbpNPtk +EPDKjvbdWSOYCEkc +DoCkKvbdjggMGGOL +DoCjjvbdSQUHJecw +DncLKvbdZyDjODMS +EObjjvbdfpBzvcxI +EOcLKvbdTlVoAvPJ +DnbjjvbdVviYWEFH +EPCkKvbdZnmiFFZj +EObjjvbdNGbpNQUk +DoDLKvbdrbGMkfjy +DoDLKvbdxnShYSiD +EObkKvbdJYTahMRQ +DoDLKvbdoAKzshEO +DoCkKvbdZxcjOCkr +EPDLKvbdRWmdCkgc +EPCkKvbdGFiqnJUR +DoDKjvbdRzJgsDWA +DncLKvbdptTfqqjt +EPDKjvbdmIctRUqa +EObkKvbdnBiwXoOV +DnbjjvbdfMevfljL +EObkKvbdBraDUGWr +DncKjvbdUxhTzKnn +DoCjjvbdmfdxMmfy +DnbjjvbdhuZeWrVC +DnbkKvbdLiCLpxAS +DnbjjvbdKfFgbApu +DnbjjvbdziuPpETU +DoCjjvbdwuNEqZLn +EPCkKvbdEXwksssl +EPCjjvbdhgKCxujV +DoDKjvbdhlEdOVDZ +DncKjvbdLAjgMbXq +DncKjvbdOFEThhkE +DoCkKvbdANHxrvzY +EPCjjvbdZtIiZDrn +DoCjjvbdYpldhmEq +DncLKvbdqwPlDIyR +DncLKvbdUtNUFlWK +EObkKvbdkWXODbYX +DnbjjvbdRzJhSbvA +DoCkKvbdEJgjVxKA +DncKjvbdxnSgxShc +EObjjvbdbUbHYKsh +DncLKvbdZoNiFEzK +EPDKjvbdbiMjKevx +DnbkKvbdIwsbHlRQ +EObjjvbdhWyAzzAJ +EObkKvbdqvpLcIyR +EObjjvbdGGKSOIsq +EObkKvbdTpqPUthN +DncKjvbduaEZTOdh +EObkKvbdJJdAJofd +DoCkKvbdEKIJuwjA +DncLKvbdDnbjkXDE +DnbjjvbdhbObdwQq +EObjjvbdunszpkPU +EPCjjvbdwNWANDdm +EPDLKvbdozmcjxPA +EObjjvbdZnmiFFZj +DnbjjvbduDDUwVno +EOcKjvbdZjShPfbG +DncLKvbdADSXiyhp +DoCjjvbduCcVXWPP +DnbkKvbdffLzOHHA +DncLKvbdBdPaWJlf +EPDLKvbdJvVGEFGi +EPCkKvbdvwMBWBWV +EObjjvbdijGHjMxS +EPCkKvbdaNLCTVNH +EPCjjvbdbAudeopX +DoDKjvbdozmcjwoA +EPCjjvbdYlRctOMN +DoCjjvbdDoDLKvcE +EObkKvbdVqmwaeMD +DnbjjvbdqvolChyR +EPCkKvbdRkZGVGjs +DoDKjvbdjvXOEBxX +DoCjjvbdIHHZyXwg +DnbkKvbdLBKgNCYR +EPDKjvbdyNsHxShc +EOcKjvbdyzdmqhJI +DnbjjvbdqFcdtVaI +EObjjvbdrJAKElne +DncKjvbdTvLpJtAq +EObkKvbdDoDKjvbd +EPCjjvbdYlRcsnLm +DoDKjvbdegkVqmqH +EPDLKvbdZHXEAPSi +DoDKjvbdakLennDA +DncLKvbdrDdiPmua +DoCjjvbdhbPDEwRR +EPDLKvbdtcDUvuno +DnbjjvbdEKHjVxKA +EOcLKvbdYqMdhmFR +EPDLKvbdmttzKiqf +EPDLKvbdTkvPAuoJ +DncLKvbdVAbRTQqy +DncLKvbdLBKflbYR +DoCjjvbdZyDimcMS +EOcKjvbdFpATXHFy +EObkKvbdnCJwYOmu +EPCkKvbdVZHszLPO +EPCkKvbdCSaDTfXS +DncKjvbdNVSqjmAX +EPCkKvbdFjdrbhMu +EPCkKvbdbsCkUDjB +EObjjvbdMowpumfs +DoDLKvbdRotHJecw +DnbjjvbdTfzmkwWF +EObjjvbdBcpAvKNG +DoDLKvbdWHxWXfxz +EPCjjvbdqUUGrSKt +DncLKvbdliDsqVSB +DnbkKvbdBdQAujMf +DnbkKvbdWXIxVcdg +DoCkKvbddePSCXCj +DnbjjvbdZirhPfbG +DnbjjvbdyXiKBozL +DnbjjvbdznpREcMY +DncKjvbdJcKCqKCx +EPCkKvbdJbibpjDY +EPDLKvbdkClLRHVH +EPDKjvbdTvLoisaR +EOcKjvbdZGwEAPSi +EPCkKvbdKRZdnenF +DncKjvbdfMfXGmJk +EPCkKvbdhfibyWJu +EOcKjvbdMIbLqYAS +EPDLKvbdbUbHXjtI +EObkKvbdCSaDUFwS +EPDLKvbdGGJqnJUR +EOcLKvbdDoDKjvbd +DnbjjvbdFkFTDIMu +DnbjjvbdgFlZnGgA +DoCkKvbdakLfPODA +EPDLKvbdDwwlTstM +DoCjjvbdMJBkqYAS +DnbjjvbdiGjCxujV +EPDLKvbdVwIwuceH +EPDLKvbdZyEKOCkr +EPDKjvbddoFTLTtS +DoCkKvbdXrlAlsnx +EOcLKvbdZoOIeEzK +DnbjjvbdaMjbTVMg +EPDKjvbdeOeTKssr +DncKjvbdSKxetfjs +DoCjjvbdpxnhGpcx +EPDLKvbdmtuZkJrG +DoCjjvbdYkqdTmlN +EOcLKvbdJuuGEEfi +DoCjjvbdhzUfMROG +DncLKvbdddnrBvbj +EOcLKvbdWSNwbFMD +DoDLKvbdtSrTYydc +EPCjjvbdRjxetgKs +DncKjvbdFxttaEYC +EPDLKvbdiBncFWpq +DnbjjvbdyTOImSCH +DoDKjvbdcyyQXyRC +EOcLKvbdZLrEUOLm +DoCjjvbdXmqAYVWU +EPCjjvbdUsltFkvK +DncKjvbdLqvmZuQz +DnbjjvbdZjTIQGaf +DoDKjvbdzoPpeCkx +EPDKjvbdGGKSNhsq +DncKjvbdtSrSxzFD +EPCkKvbdyOTHxShc +DnbkKvbdehKvSORH +DoDLKvbdWIXvYHYz +EObkKvbdDoCkLXCd +DoDLKvbdLBKflaxR +EPDLKvbdKQzFOenF +EObjjvbdjFLHVPAO +EObkKvbdFeiqmhsq +DoDKjvbdRotHKFdX +DnbkKvbddZxpYZQb +DncKjvbdqqtkNkBN +EPDKjvbdZjShPgBf +DoCkKvbdNHCpMouL +EObjjvbdxZgefYFS +DoCjjvbdNrsvHEuQ +DoCjjvbdwzHeewdr +EObjjvbdvPTzpkPU +EPDKjvbdrounibvG +DnbkKvbdpstGqqjt +EPDLKvbdeFOrCXDK +EOcLKvbdGBPRYizm +DoDLKvbdNwnuzdOU +DnbkKvbdRMwaxnUz +EOcLKvbdDihKWXjA +EObkKvbdFeirOJTq +DoDLKvbdSKxeuGjs +EOcLKvbddndsKssr +DnbjjvbdiCPDEvpq +EOcKjvbdMoxQumfs +DnbkKvbdfNGWfljL +DnbkKvbdIHGzZXwg +EObjjvbdTlWPAvOi +DoDLKvbdnPyyVkZC +EOcKjvbdkWWmdBxX +EObkKvbdEJgjWXjA +DnbjjvbdkMalZdgP +DnbkKvbdsCGNLfjy +DnbjjvbdYqMeIleR +DncLKvbdMgComPtk +DoCkKvbdMfbolouL +DncKjvbderAvzlDP +DnbjjvbdqwQLcIyR +EObjjvbdcImJkFwY +EPCjjvbdYzberKVy +DoCjjvbdEzsqElCi +EObkKvbdRotGiecw +EPCkKvbdGLErcINV +DoCkKvbdYpmEiMdq +DoDKjvbdJXsaglRQ +DnbkKvbdFVxpPmJe +DnbkKvbdxUmEpyLn +EPCjjvbdLrXMytpz +DnbkKvbdhtzEvqtb +EPDKjvbdDxYLstTl +EPCkKvbdiBoDFXQq +EPCkKvbdZoOJEeZj +DoCjjvbduDCuWuoP +EObkKvbdjcLkQfuH +DoCkKvbdcImKLGWx +EPDLKvbdEYXlUUTl +EOcLKvbdZLqdTnMN +EOcKjvbdmozYujyC +DncLKvbdJpzEnfOF +EOcLKvbdiCPCdvpq +DncKjvbdADRxKZhp +DoDLKvbdmJDsqVSB +EObkKvbdnBiwYPOV +EObkKvbdqwQMDIxq +DncKjvbdeFOqbWbj +EPDKjvbdmfeYMmfy +DnbkKvbdGLFSbhNV +DoDLKvbdwkXDgzzG +EObkKvbdbAvFFpQX +EPDLKvbdyXhjBoyk +DoCjjvbdMfbpMouL +DoCjjvbdREDApRES +DncLKvbdmajWwnmu +DoDLKvbdIidAJofd +DoCjjvbdSZihTCvA +DoCkKvbduLwvaUBX +EPCkKvbdiHJbyVjV +EObkKvbdGYtuAdXb +DoDLKvbdCTBCtFwS +EOcLKvbdhlFENtby +DoCkKvbdySnIlrBg +EPDLKvbdwuNFQyMO +DncKjvbdlqxtzTDi +DoDKjvbdWWhxWEFH +DoCkKvbdiHJcZVjV +EPDKjvbdCflGHAzc +DncLKvbdzROmJKXA +EPDLKvbdCJLBjhej +EOcKjvbdVrNwbEkc +DnbkKvbdUtNUFlWK +DoDKjvbdLBKflbYR +EPCjjvbdauBfwkTh +EPCkKvbdrXQMDJZR +DnbjjvbdnVUyjjSG +DncKjvbdiMEdOUby +DoDKjvbdqiAKFNPF +EOcLKvbdQdDBQQcr +DoDKjvbdpxnggQdY +DncKjvbdtSrTYydc +DnbjjvbdwzHefXeS +DoCjjvbdRosfjGEX +EPCkKvbdnPyxujyC +EObjjvbdZyEJnCkr +DnbkKvbdhytelRNf +EPDLKvbdeYZstSFz +EObjjvbdTfzmlXVe +EOcKjvbdbKkenmcA +DncLKvbdvwMAuaVu +EObkKvbdwMvAMdEm +EOcLKvbdkHflFfNk +EPCjjvbdzoPpeDMY +DoCjjvbdiLeDmuCy +EOcKjvbdRpUGjGDw +DnbkKvbdUslsekuj +EPCjjvbdmJEURVRa +DncLKvbdZjSgofaf +EOcLKvbdaMjasUlg +DoCjjvbdREDBPpdS +DnbjjvbdIwsaglQp +DoCkKvbdkNCLzFHP +DoDLKvbdaRfChUFk +EPCjjvbdrRtjnKaN +EPCkKvbduoTzpkOt +EOcKjvbdnHFYMmfy +EOcKjvbdHDkVjBjK +EObjjvbdEXxMTssl +DnbjjvbdNPxRWOHT +EObjjvbdiZtfLpmf +EObjjvbdTvLojTaR +DoDKjvbdKkBIWAKZ +DoDLKvbduCbtwVno +DncLKvbdmttzKjSG +DncLKvbdbBVdfQQX +EObkKvbdyXiKBpZk +DncLKvbdzGxlAMdw +DoCkKvbdMpXpvNfs +DoCkKvbdKQydoGOF +EPDLKvbdTfzmlXVe +EPDKjvbdQccBPqES +EPCjjvbdZtJIyESn +DoCjjvbdVrOXbElD +DnbjjvbdbLMGOmcA +DnbkKvbdnPzZWKyC +EPDLKvbdmajWwoOV +EObjjvbdQwOEDMHc +EPCkKvbdTvMQKUBR +DoCjjvbdOTUVgEtp +DoCkKvbdIHHZyXxH +EPDLKvbdDoDLKwDE +EObjjvbdiZtfMQmf +EObjjvbdijGHimXr +DoDKjvbdVrNxCElD +EPDLKvbdJutedFGi +DnbjjvbdmSZVZsEJ +DncKjvbdqlzKYlIJ +EOcKjvbdfelZnGgA +EOcKjvbdYlRctOLm +DoDKjvbdPxmAHSrK +EPCjjvbdWWiYWEEg +DoCjjvbdbAvFFoow +EOcKjvbdFjeSbglu +EPDLKvbdlqyVZsEJ +EOcKjvbdddoRbXDK +EPCkKvbdaRecHtFk +DncLKvbdSKyGUgKs +DoDLKvbdcyyPwyQb +DoDLKvbdnVUzKjRf +EObjjvbdYkqdUOLm +EObkKvbdRbEEkhyL +DncKjvbdtAHQhAAr +DnbkKvbdVqmwbFMD +EOcLKvbdznoqFDLx +EOcLKvbdEXxLtTsl +DnbkKvbdtumwipsA +EObjjvbdmJEUQtqa +DncKjvbdxwhjCPyk +DnbkKvbdyfyMANFX +DncLKvbdiVZeXRtb +EObkKvbddtAUATMv +EOcKjvbdxnSgwriD +EObjjvbdlrZVZrdJ +EPCkKvbdsBelkfkZ +DoDKjvbdFVyPomJe +EPCkKvbdQmYBxnUz +EOcKjvbdSBdFLhyL +DncLKvbdmJETpuSB +DoDLKvbdRECaPpcr +DncLKvbdIxUBglRQ +DoCjjvbdpssfrSLU +DnbkKvbdSQUHJedX +EObjjvbdkySrTZHU +EObkKvbdZtIiZETO +DoCjjvbdtumwipsA +DoCjjvbddBrlrAUN +EPCjjvbdKCjDQibx +DoCjjvbdQccAopdS +DoDLKvbdSBceLiYk +EPDKjvbdREDAoqDr +EOcKjvbdZQleJMeR +DoCkKvbdEARiMywX +EPDKjvbdkDLkQgUg +DncLKvbdFjdsDIMu +EPCjjvbdlrYtysDi +EPCkKvbdezuxeIsw +EObkKvbdyNsHxTJD +DnbkKvbdemGWgMik +DoDLKvbdBhkCKhej +EOcLKvbdjvWmcaww +EPDLKvbdqTsgRrLU +EObkKvbdZyDimcLr +EPCjjvbdlrYtzTEJ +DoCkKvbdHgGyyYXg +DoCkKvbdZoNhddyj +EPDKjvbdhtzFWquC +EPCkKvbdDoCkKwDE +DoDLKvbdsrqsZZeD +EPCkKvbdiHJbxuiu +DoCjjvbdhlFEOUcZ +EPDKjvbdDigiuwjA +EPDKjvbdQdDBPqES +DoCjjvbdcTCjsdKB +DncLKvbdUsmUFkuj +EPDLKvbdnHEwlnGy +EOcLKvbdxVNEqYkn +DoDKjvbdEuxopNJe +EObkKvbdkClLQfuH +EPCjjvbdcTDLUEKB +EOcKjvbdEPDKkXDE +EPCjjvbdXsLaNUOx +DoDKjvbdFWZQQNKF +EPDLKvbdUtMtFlVj +EOcKjvbdzaAPGfal +DnbkKvbdHlBznXRL +DoDLKvbdTlVoBWPJ +EPCkKvbdDoCjkXDE +EOcKjvbdrzMQTAhO +EOcLKvbdozmdLXoA +DoDLKvbdzQnmIjXA +DoCkKvbdmgExMmgZ +EPCkKvbdzjUoocrt +EOcLKvbdwyhGFweS +EOcLKvbdWWhxVceH +DncLKvbdqqtkOKaN +DoCkKvbdOTTvHEuQ +DoDLKvbdjJehKMwr +DoCjjvbduDCtvuoP +DnbjjvbdqdEiPmvB +DnbjjvbdhtzEwRuC +DnbkKvbdRkYetfkT +DoDKjvbdCDpBVjNG +DoCkKvbdcSbjscjB +EPDLKvbdYpldiMdq +DoCjjvbdaaWEfPow +EOcKjvbdqZPHgQdY +DoCkKvbdeOdrjtUS +DoDLKvbdFaPRZJzm +DnbjjvbdRECaPqES +DncKjvbdaMjaruMg +EObjjvbduVnYJpsA +DnbkKvbdqTsfrSLU +DncKjvbdYqMeJMdq +EOcKjvbdvvlBWAuu +DnbjjvbdUxgtZkOn +EOcKjvbdOSsufduQ +EOcLKvbdtumxJqTA +DncKjvbdIryAsNXl +DoDKjvbdMuTRkNAX +DoDLKvbdxnSgwrhc +EOcKjvbdiHKCxujV +EObkKvbdeKJrVtzn +EPDLKvbdjhHMGGNk +EOcLKvbdkVwNdBww +EOcLKvbdygZMANEw +EPDLKvbdRXODcLhD +EPCjjvbdSPsfjFcw +DoDKjvbdYpleIldq +DoDLKvbdOEcsiIjd +DnbjjvbdddoRavbj +DncLKvbdHDkWKBjK +DoCjjvbdxxJKBoyk +EPDKjvbdYkqdUNkm +DoDLKvbdDnbjjvcE +DoCkKvbdVvhxVceH +EPDLKvbdWRnXbFMD +EObkKvbdliEUQtqa +EPCkKvbdNQXqVmfs +EOcLKvbdIGfyyYYH +DncKjvbdxUldpxlO +DoDKjvbdznopdcLx +DncKjvbdHDkVibKK +EPDLKvbdjlbLydgP +DoDKjvbdYTMAltOx +DoDKjvbdcSbkUEKB +EPCjjvbdzoQREblY +EOcKjvbdZxcinDMS +DoDKjvbdZyDjODMS +DoCjjvbdxZgfFwdr +EPDLKvbdaMkBsVMg +EPCkKvbduDDUvuno +DncKjvbdsCFmLgKy +DoDLKvbddeOrCWcK +DncLKvbdNddThhjd +EOcKjvbdBvzcheQW +EPDLKvbdeEnqbXCj +DoCjjvbdNrtVfduQ +EOcKjvbdZQmEiNFR +EPCkKvbdGFjSNiTq +EPDKjvbdZxcinCkr +DoCjjvbdkNBlZdgP +DoCkKvbdEYXkstTl +DncLKvbdYpmEhmEq +EOcLKvbdePFSkTsr +DoCjjvbdemFvfmKL +DnbkKvbdemFwGljL +EPDLKvbdmbJvxOnV +EPCjjvbdtbcVXVoP +EOcKjvbdFkErcHmV +DoDKjvbdVUMtFlWK +EOcLKvbdkMakydfo +DnbjjvbdIMBznWqL +EObkKvbdptUHRrLU +DnbkKvbdjJfHilwr +EPCjjvbdGYuUaDxC +EObjjvbdmtuZjjRf +DncLKvbdkCkkQfuH +DoDLKvbdtlXwBUBX +DncLKvbdCWzchePv +EObkKvbdrEEiPmua +EOcLKvbdYqNFIldq +DoDLKvbdfILWRnQg +DoDLKvbdqUUGrRkU +DoCjjvbdfMfWflik +EOcLKvbdOTTugEuQ +DncLKvbdjvWnDaww +EOcLKvbdsPuoKDVf +EPDLKvbdZirhPfaf +DoCjjvbdDwxLsstM +DnbjjvbdfHkWRmpg +DncLKvbdrpWOibuf +EPDLKvbdZtIhyESn +DncLKvbdwygfGYEr +EPCjjvbdeEoSCWcK +EPCjjvbdjuvmdBww +EObjjvbdqUTfqqjt +EOcLKvbdZjSgogBf +DoDKjvbdYqMdiMeR +DoCjjvbdKefICApu +DoDLKvbdMfcQNQVL +EPCkKvbdjggMGGNk +EObkKvbdCDoaVjMf +EObkKvbdWWiXuceH +EOcLKvbdURROuVHm +DnbjjvbdpssfrSLU +DncKjvbdgFkzNgHA +DnbjjvbdaSFbgtFk +DncLKvbdIxTahMQp +EPDLKvbdKWVFceGi +DncKjvbdFVyPomKF +DoDKjvbdZirgpHBf +EObjjvbdVqmwadkc +EPCkKvbdieLHVPAO +DncKjvbdZLqdUOMN +DoDKjvbdWWiYWDeH +EObkKvbdQwNdClID +DnbjjvbdMoxRVnGs +DncLKvbdrDdiPmvB +DnbjjvbdZQleJNFR +EOcLKvbdrDdhpOVa +EPDLKvbdYqNFImFR +DoDKjvbdEYXlTtUM +DoCjjvbdhuZeWqtb +EPDKjvbdMfcPlpVL +EOcKjvbdNQYQvNfs +DoDKjvbdiUzFXSVC +DoCkKvbdmRxtzSci +DnbjjvbdbiMikGXY +DoCjjvbdQdDBQQdS +EObjjvbdqZPIGqDx +DoCkKvbdkWWmdBxX +DoDKjvbdKxpirzuG +DoCjjvbdlBNPNALA +DoCjjvbdhzVGMROG +DoCjjvbdzoQREcMY +EPDKjvbdlAlnmALA +EPDLKvbdwuMeRZLn +EOcLKvbdYqMdiNFR +EObkKvbdOTTugEuQ +EOcKjvbdYTMAmUOx +DnbjjvbdRDcBQRES +DoDLKvbdidkHVPAO +EPCkKvbdSKyFtfjs +DoCjjvbdhytelQmf +DncLKvbdEztRElCi +EPDLKvbdRWnEDLgc +DoDKjvbdwuNFQyLn +EObkKvbdGLFTDHmV +DnbkKvbdShyiqABM +EObkKvbdUaCQsRSZ +EOcKjvbdjuwNcbXw +DnbkKvbdmfeXlnHZ +DncKjvbdsPuoKDVf +EOcKjvbdNGbomPtk +DoDKjvbdvPTzpkOt +EPDKjvbdJqZdneme +DncKjvbdqTtGqqkU +DnbkKvbdjggLeemk +DoCjjvbdVZIUZkOn +EPCkKvbdzjVPodTU +DncKjvbdnBjXYOnV +DoDKjvbdHgGzYxYH +EPCkKvbdSZigsCvA +EPCjjvbdtbbtvuno +DoDKjvbdPIAXyAZB +EObjjvbdRNXaxmtz +DoCkKvbdUyITykPO +EPCkKvbdssRryZeD +EObkKvbdJuuGEFGi +DoDLKvbdxZgfGXeS +EObjjvbduoTzqLOt +DoDKjvbdbrbkTcjB +DncLKvbdxxIiaoyk +DoCjjvbdFxtuBDxC +EPDLKvbdzaAPGgBl +EPDLKvbdpxnhGqDx +EOcKjvbdtSqsZZeD +EOcLKvbdMowpvOGs +EObkKvbdVBCRSpqy +DoCkKvbdZRNEiMeR +EPCjjvbdczYowyQb +DncKjvbdjgfkfGNk +DnbkKvbdssSTYzFD +EOcLKvbdVhYWYGxz +DncKjvbdKDJcQibx +DncKjvbdZHWdAPTJ +EPCkKvbdFjdsChNV +DoDLKvbdJcJcRJcY +EPCjjvbdRjyGVHLT +DnbkKvbdBcpBWKMf +DoCjjvbdxUmEpyMO +EPDKjvbdZoNiFEzK +DoCjjvbdPIAYZAZB +EOcLKvbdFejSOIsq +DoDKjvbdjggMGFmk +EObkKvbdWRnXadlD +EObkKvbdnGdxMmfy +DoDLKvbdLBKgNBxR +DoCjjvbdaSGChTek +EPCkKvbdSCEElIxk +EObjjvbdIxTbHlQp +EPCkKvbdOEcshhkE +EOcLKvbdbsCjsdKB +DncLKvbdCSaDUGXS +EPCjjvbdRzJgsDWA +EPDLKvbduCbuXVno +EOcLKvbdGdLViajK +DncKjvbdCWzdJEpW +DncKjvbdjuwODbXw +DncLKvbdqUTfqqjt +EOcKjvbdxUmFRYkn +DoCjjvbdVAaqSqRy +EPDLKvbdaMkBsUlg +EOcKjvbdGLFTCgmV +EPCkKvbdZeYGzgiC +DoCjjvbdwXLaWBVu +DoCjjvbdelevgMik +EPDKjvbdkHgMGGOL +DoCjjvbdcJMjKewY +EOcLKvbdwzHfGYEr +DncLKvbdlZTRryGt +EOcLKvbdfVzwoizs +EPDKjvbdhzUelRNf +EPCkKvbdiHKCxvKV +EOcKjvbdGFjRmhtR +EPDLKvbdGLEsChNV +DoDKjvbdYORAXuWU +DnbjjvbdpstHSSKt +EObkKvbdegkVqmpg +EPDLKvbdhyuGMQmf +EObkKvbdliDtQtqa +DoCkKvbdfNGXGlik +DoCkKvbdHfgZyXwg +DoCjjvbddndsKssr +EPCjjvbdZMSDsnLm +EObkKvbdEXxMTstM +EPDKjvbdJvUecdfi +DnbkKvbdVUMsekuj +EPCjjvbdPyNAGsSK +DoCjjvbdMSWmZuQz +EObkKvbdBcpBVjNG +DnbjjvbdezuxdiUX +EPCjjvbdBdQAvJlf +DncKjvbdOTUWHFVQ +DoDKjvbdaSGDIUFk +EOcKjvbdUGzmlWvF +EOcLKvbdjlakydfo +DoCkKvbdWSOXaeLc +DoDKjvbdznpRFDLx +DoCkKvbdwtldpxlO +DoDLKvbdGdLVjBjK +EObjjvbdmttykKSG +DoDKjvbdZjShQGaf +DoDKjvbdrDdhomvB +EPDLKvbdiUyeXSVC +DncKjvbdIsYaSmXl +DnbjjvbdVhXvYHYz +EPDKjvbdwzHfGXdr +EOcKjvbdxsOJMqbH +DoCjjvbdehKuqmqH +EPCjjvbdZdxGzhJC +EOcKjvbdsCGMlHLZ +DoCjjvbdOEcshhkE +DoCjjvbdEzsqElDJ +DncLKvbdURRPVVIN +EPCkKvbdZoOJFEzK +DnbjjvbdBiKajhfK +EOcLKvbdbUafwkTh +EOcLKvbdVZHszKoO +DnbkKvbdGKdsDIMu +DnbkKvbddoFSkUUS +DnbjjvbdPxmAGrqj +EPCjjvbdKNADzHVB +EPCjjvbdcyxpXxqC +DnbkKvbdLBLGmBxR +EPDKjvbdFWYopNJe +EPCkKvbdcJNKKewY +DoCjjvbdGLErcHmV +EPCjjvbdWXIxWDdg +DnbkKvbdQvmcbkhD +EOcLKvbdbVCGwjtI +DoCjjvbdmgFYMmfy +EPDLKvbdQdDApRES +DnbkKvbdWWhwvEFH +DnbjjvbdxZhFexFS +EPCkKvbdCIjakJGK +EPCkKvbdKQyeOfOF +DncKjvbdEObjkXDE +DnbjjvbdNGcPlotk +DoCjjvbdVUMtGMVj +EPDLKvbdelfWgNKL +DnbkKvbdqwPlDJZR +DncLKvbdbiMikFwY +EObkKvbdkNBkzEgP +DoCkKvbdmuUyjiqf +DncKjvbddneSjtTr +EPCkKvbdRkZFtgLT +EObkKvbdRjyGUgLT +EPCkKvbdKaKgMaxR +DnbkKvbdZMRdTnMN +EPCkKvbdqZOhGpcx +EPCkKvbdxwhjBozL +DncKjvbdGckViajK +EPCkKvbdiifHilxS +EOcLKvbdqUUGrRjt +EPCjjvbdbhljLGWx +DnbkKvbdhgKCxujV +DoDLKvbdJSyAsNXl +DoDLKvbdjgflFenL +EPCkKvbdMJBlQxAS +DncLKvbdUMVoAvPJ +DoCkKvbdkCkjpgVH +EPDKjvbdqGEEsvAh +EObkKvbdmRxuZrci +EObjjvbdNdctIhjd +EPCkKvbdCSaDTevr +EPCjjvbdRDcAopcr +EObkKvbdwtmEpyMO +EOcKjvbdqZPHfqDx +EOcLKvbdaNKbStmH +EOcLKvbdaSFcHsfL +DnbkKvbdRosgJecw +EObkKvbdkySrSyGt +EOcLKvbdwuMdqYkn +EPCjjvbdrDdhonWB +EPCkKvbdiBoDEwRR +EPCkKvbdEztQdlCi +EObkKvbdFyUuBEXb +EPDKjvbdOAIsUJrA +EPDKjvbdKCicRKCx +EObjjvbdSZihSbvA +DncLKvbdvAdYsPEh +DncKjvbdySnImSCH +EObkKvbdiVZeXRtb +EOcKjvbdsCFllHLZ +EPDKjvbdZeXfzgiC +DnbjjvbdMpXpvNgT +DoDLKvbdsCFllHKy +DoCkKvbdqYoHfpdY +DnbjjvbdRzKHrbvA +EOcKjvbdNHComPtk +EOcLKvbdCJLBjiGK +EPDLKvbdsZlPsAhO +DnbkKvbdemFvgMik +DoCjjvbdFyUuBDwb +DnbjjvbdrafMlGkZ +DncKjvbddZyPxYpb +EObjjvbdxZhGFwdr +EPCkKvbdEXwlTssl +DnbkKvbdANIYrvyx +EObjjvbddePRawCj +EPDKjvbdyNsIXrhc +EPCkKvbdhkeEOVDZ +DoDLKvbdAMgxrwZx +EPDLKvbdsQWPJbvG +DoCkKvbdkVvmcbXw +EPDKjvbdJYTbIMQp +DncLKvbdBsAcTewS +DncLKvbdxrnJNRag +EOcLKvbdmSYtzSdJ +EObkKvbdqdFJQNua +DoCjjvbdZyEKOCkr +DoCkKvbdZLrEUOLm +EPCkKvbdRNXaxnUz +EPDLKvbdnUuZjjRf +EObkKvbdmbKXYOmu +DnbkKvbdlZTSTYgU +EPDKjvbdGYuUaDxC +DncLKvbdFyVVAcxC +DoDKjvbdEvZPpMjF +EPDLKvbdSwjlNzjx +EPCjjvbdbKkeoNcA +DoCkKvbdMfcQMotk +DnbkKvbdyTNiNRbH +DncLKvbdFWYpQMjF +EPCkKvbdEvYopMjF +DncKjvbdeKJrWUzn +EOcKjvbdpssfrSLU +EObjjvbdKCjDRJbx +DnbkKvbdeUAUATMv +EPDLKvbdjKGIJlxS +DnbkKvbdpssfqrLU +EPDKjvbdqZPHgQdY +EPDLKvbdeAURNXif +DoCjjvbdypoMhiwA +EPDLKvbdGYtuAdXb +EObkKvbdRaceLiYk +DoCjjvbdXsMBNTnx +EOcLKvbdKCjCqKCx +DoCjjvbdYSlAmUPY +EPDLKvbdpstGrSKt +EPDKjvbdhtyeXRuC +EObjjvbdtlYXBUBX +EObjjvbdRMxByNtz +EObjjvbdhanbeWqR +EOcKjvbdpyPIHQcx +EPDLKvbdrRtjnLBN +DoDKjvbdNQYQvNgT +DnbjjvbdbsDKsdJa +DnbjjvbdDxYMTssl +EPDLKvbdnCKWxOmu +DncKjvbdILazmwQk +DoDKjvbdhgJcYuiu +DoCjjvbdlYrrSyHU +EOcKjvbdVUNUFkvK +EObjjvbdRyjHrbvA +DoDLKvbdDnbkKvbd +EOcKjvbdaNKbStmH +DnbkKvbdjblLRGtg +DncKjvbdxUleQyLn +EPDKjvbdLGFhBaQu +EObkKvbdqmZiyLgi +DoCjjvbdJuuGEFGi +EPDKjvbdqmZixlIJ +DoCjjvbdXnRAYVVt +EOcLKvbdWIYVxGxz +EPCkKvbdxZgfGYEr +EPDKjvbdfNGWfmKL +EPDKjvbdbrbjscjB +DoDKjvbdsPunjCvG +DoDKjvbdziuQQDsU +DoDLKvbdbhlijfWx +EPCkKvbdhgKCyWKV +EPDLKvbdGLEsCgmV +EOcKjvbdmIcspuSB +EPDKjvbdIwsbILqQ +DoDLKvbdpedEsvBI +DncLKvbdsPunjDVf +DncLKvbdIxTbHkqQ +DncLKvbdcSbkTdJa +DncKjvbdUWLpJsaR +DnbkKvbdsQVnjCvG +EPDKjvbdyXiJapZk +EPCkKvbdrzLosAgn +DncLKvbdNsTugEuQ +DoDLKvbdrykoraHn +EObjjvbduaDySoFI +DncKjvbdZHWdAOri +EPCjjvbdlqxtysEJ +DnbkKvbdOSsvHEtp +DoDKjvbdRotGjGDw +DoDKjvbdYfvdAOsJ +DoCkKvbdBhjajiGK +EObjjvbdCgLegAzc +DoDLKvbdhtyeWrVC +EOcKjvbdzitoocrt +EOcKjvbdNVTSKmAX +EPCjjvbdVYgsyjnn +EObkKvbdliEUQuRa +DoCkKvbdqFceUWAh +EPDKjvbdIsZAsMxM +DnbkKvbdUVlPjUBR +DoDKjvbdbUafwjsh +EObjjvbdQlxCZOUz +DoCkKvbdQvnEDLhD +EOcKjvbdUVlQKUBR +EPDKjvbdehKvRnQg +DoDLKvbdxmsIYTIc +EObjjvbdsCGNLfkZ +EObjjvbdmSYtzSdJ +DoCjjvbdiMEcnVDZ +EPCjjvbdypnlhiwA +DoCjjvbdRyihTDWA +DoCjjvbdZoOJEdzK +DoCjjvbdJpzEoGOF +DoCkKvbdYpmEiMeR +EPCkKvbdbhljKfWx +EPDLKvbdqYnggQcx +EOcLKvbdwjwEHzyf +EPCjjvbdLFegbAqV +DoCjjvbdMoxQvNgT +EPCjjvbdZsiIyETO +DoDLKvbdZQmFImEq +DnbjjvbdYkrDtOMN +EPCjjvbdjggMGGOL +DncLKvbdDwwlTstM +EOcKjvbdCWzciFQW +DoCkKvbdyYIiaozL +DnbkKvbdNsTufeVQ +DoDKjvbdjlakydfo +EObjjvbdUGznLvue +DoCjjvbdeFOqawDK +DoCjjvbdZnmiFEyj +EOcKjvbdVBCQrprZ +EOcLKvbdrovOjCvG +DncKjvbdrovPKCuf +EOcLKvbdlYrqryHU +EObkKvbdcyyPxZQb +EObjjvbdnBivwnnV +EObjjvbdjJehJlwr +DnbkKvbdOFDtJIjd +DnbjjvbdVAaqSqSZ +EObkKvbdrXPkbiZR +DoCjjvbdzaAPGfal +DncKjvbdZQldhmEq +EObjjvbdmoyxvLZC +DnbkKvbdmpZxujyC +DoCjjvbdvwLaWBWV +DncLKvbdiVZdvquC +DnbjjvbderBWzlDP +EPCjjvbdjbkjpfuH +DncLKvbdrafNLfkZ +DncKjvbdrWokbhxq +EPCkKvbdsZkosBHn +EOcKjvbdidjfuPAO +DnbjjvbdNGcPmQUk +EPCjjvbdrJAKFNOe +DnbjjvbdTukoitBR +DnbkKvbdySmhlrCH +EObkKvbdrXPkcIxq +EOcLKvbdFejSOItR +EObkKvbdmgExMnGy +EPDKjvbdqrVLOLBN +DoDKjvbdLAkHNCYR +EObkKvbdVrOXbEkc +DnbjjvbdEXwlUTsl +EPCkKvbdyXhjBpZk +EObkKvbdiifHjMxS +EOcKjvbdEKHiuxKA +EObkKvbdZLqdTmlN +EObkKvbdWRnXaeLc +DnbjjvbdWSNwaeMD +DnbjjvbdfNGWgNKL +DoDKjvbdoAKztIDn +DncLKvbdmaivxOmu +DnbjjvbdZLqcsnMN +EObjjvbdcTDKscia +EPCjjvbdOTTufeUp +DoDKjvbdGdLVjBjK +DncKjvbdcJNKLFvx +EOcLKvbdTYKkmzjx +EOcKjvbdZRMeImEq +DoDLKvbdKQyePFnF +DnbkKvbdNrtWGduQ +EPCjjvbdatbHXjtI +EPCjjvbdvwMAuaVu +EPDLKvbdnQZxvLZC +EObjjvbdtlYXAsaX +DnbkKvbduDDVWvPP +EPDLKvbdqTtGrSKt +EObjjvbdxnSgwsJD +EObjjvbdbKkenmcA +EPCkKvbdFaOqYizm +EOcKjvbdLGGHbBRV +DoDLKvbdRzJhTCvA +EPCjjvbdiMFDmtcZ +DnbjjvbdWWhwvEEg +EPCjjvbdJmAEZgVB +DoCjjvbdmuVZjirG +DoCjjvbdliEURUqa +DoDLKvbdnCKWwnnV +EPDLKvbdhgJbyViu +DnbkKvbdjggMFfNk +EObkKvbdEuxopMie +EPDKjvbdssRsYydc +DncLKvbdliDsqVRa +EOcLKvbdLBKflbYR +DncKjvbdzoPpeClY +DncKjvbdqFdEsvBI +DoCjjvbdZMRctOMN +DncKjvbdDnbkLWcE +EObkKvbdMfcQNPuL +DoDKjvbdUWMPjTaR +DnbjjvbdxmsHwsIc +EObkKvbdrDdhonWB +EPCkKvbdhgJcYvJu +DoCkKvbdlYsSSyHU +EPCjjvbdNdcsiJLE +DoDKjvbdhlEcmuCy +EObjjvbdJTZAsNXl +EPCjjvbdznpQeClY +DncLKvbdDxYMTssl +DoCjjvbdkVwNcbXw +EOcLKvbdMgDPlpUk +EObkKvbdXsMAlsnx +DnbkKvbdiBncEvqR +EPCjjvbdeFPSCWcK +DoDKjvbdmuUzKjSG +EPDKjvbdqrUkNjaN +DoDKjvbdhyuFlQnG +EOcKjvbdDigivYKA +DoDLKvbdJYUCHkqQ +DncKjvbdACqwiyiQ +EPDKjvbdEYXkstUM +DoDLKvbdKDKCpicY +DncLKvbdCDoaVjNG +EObkKvbdxZhFexFS +EPCkKvbdKDJcQjCx +DoDLKvbdEPCkKwCd +EPCkKvbdTfzmkwVe +DnbjjvbduWOYJqTA +DoCjjvbdcJMijfXY +EPCkKvbdmaiwYPOV +EOcKjvbddjJrVtzn +EObkKvbdpstHSRjt +EOcKjvbdyXiKCQZk +DnbkKvbdIsYaSmYM +DnbjjvbdwtmFQxlO +DnbkKvbdYpleJMdq +DoCjjvbdkNBkzFGo +EOcKjvbdbsCkUEKB +DoDKjvbdYlRctOMN +DnbkKvbdjuwOECXw +EPDKjvbdWRnXaeMD +DncLKvbdkDLkQgVH +DoDLKvbdFeiqnJTq +EOcKjvbdzHYlAMeX +EPCjjvbdJbjCpjDY +EPDLKvbdzitopDsU +DnbkKvbdziuPpDrt +DncLKvbdySnImSCH +DnbjjvbdySnImRbH +DoCjjvbdKjaIWAJy +DnbjjvbdTqRPUthN +DoCjjvbdURQntuIN +EObjjvbdQlxCYmtz +EPDKjvbdMtsSLNAX +EObjjvbdJbjDQicY +DoDKjvbdEPCkKwDE +EObkKvbdKQydoGNe +DoDLKvbdVwJXuceH +EObjjvbdnUtykJrG +DncLKvbdwMvANEEm +EPDKjvbdpyPHgQdY +DnbjjvbdUVkpKUBR +EOcLKvbdhfjCyVjV +EPDKjvbddoFTKstS +EPCkKvbdANHyTXZx +EPCkKvbdUxhTyjoO +EObjjvbdkVwNdBxX +EPDKjvbdDoCjjvbd +DnbkKvbdWWhwudEg +DnbkKvbdyTNiMrCH +DoDLKvbdelewGljL +DncLKvbdUGznMWue +DncKjvbdwygfFwdr +EPCkKvbdJqZePFnF +DnbjjvbdNsTugEuQ +DoDKjvbdQcbaPqDr +DncLKvbdfMevgNJk +DncLKvbdlrZVZrdJ +DoCjjvbdFjeTCglu +DnbjjvbdYqNFImEq +DoCjjvbdsCGMkfkZ +DncLKvbdhuZdwSUb +DoCkKvbdrXPkbiZR +DoCjjvbdZRMdiMdq +DoDKjvbdemFvgMjL +DoCjjvbdygZMANEw +EOcKjvbdZRMeIldq +EObkKvbdiHJcZWKV +DncKjvbdCJKbKiFj +EObjjvbdzROlhjXA +DnbjjvbdDoDLKvbd +EPDLKvbdVYgtZjnn +EObkKvbdDoCjjwDE +DnbkKvbdrouoJbuf +DoCkKvbdyTOImRag +EPDKjvbdBcpBVilf +DoCjjvbdCWzdJFQW +EPCkKvbdbrbjscjB +EOcLKvbdwkWdHzzG +EPDKjvbdnGeXlnGy +EPCkKvbdznpREcLx +EPCkKvbdZMRcsnLm +EOcKjvbdJSyArmXl +DnbkKvbdZMSDtNkm +EPDKjvbdAMgySvzY +DoDLKvbdyYJJbPzL +DoCkKvbdLAjgMaxR +DoDLKvbdWIXuxGxz +DoCjjvbdqwQLbiYq +DnbkKvbdpyPIHQcx +EOcKjvbdfNGXHNJk +DncKjvbdqYnhHQdY +DncKjvbdeEnrBvcK +EPDKjvbdZjTHpGaf +DoDLKvbduoTzqLPU +DnbkKvbdIjEAJofd +DnbkKvbdxnSgxTJD +DoDLKvbdXsLaMsnx +DnbjjvbdaRfDHsek +DoCkKvbduLwwAtBX +DnbkKvbdrpWPJcVf +DoDKjvbdrbFlkgLZ +DoCkKvbdlqxtyrdJ +EObkKvbdRyihSbvA +EObkKvbdWRnYCFLc +DoCkKvbdOEcshhjd +DnbkKvbdZjTHpHBf +DnbjjvbdcyyPwxpb +DncLKvbdkVvmdCXw +DncLKvbdcScKtEJa +DnbjjvbdrSVLOLBN +EObkKvbdiGjDYvKV +EPCkKvbdEJgjVwjA +DnbkKvbdRosgKFdX +EPDLKvbdcScKtDia +DoCjjvbdtbcVXVno +DncKjvbdhgJbyViu +EPCjjvbdjJehKNYS +EObkKvbdyOTIYTJD +DnbkKvbdRaceMJYk +DoCkKvbdqiAKEmOe +DoDLKvbdEKHiuwjA +EObkKvbdxUldpxkn +EObkKvbdFejRmhtR +DncLKvbdSBcdlIyL +EPCkKvbdxZhFexFS +EObjjvbdwjwEHzzG +EPCjjvbdmRxtzSdJ +EPDLKvbdEvYooljF +DoCkKvbdmgFXlmfy +DoCjjvbdtkxXBTaX +EObkKvbdmgExMnHZ +DncLKvbdjvXODaww +DoCkKvbdSCEFMIyL +EPDKjvbdVYhTykOn +DoDLKvbdNsUVgFUp +DncKjvbdRXOEClID +DoDKjvbdnVVZkKSG +DoDKjvbdWWhxVcdg +EPCkKvbdwuNFQxlO +DncLKvbdKeegbBRV +DncLKvbdUWLpJsaR +EOcLKvbdNxOuzcmt +EObjjvbddwzUUSFz +DoCjjvbdJXtBhMQp +DoCkKvbdLGFgbBRV +EOcLKvbdcJMjKewY +DnbjjvbdxUmEqYkn +DnbkKvbdjbkjqGtg +EPCkKvbdIHGzYwwg +DnbjjvbdrpWOjCvG +DoDKjvbdZMRctNkm +DnbkKvbddZyPwxqC +DoCjjvbdtcDVWuno +DoCkKvbdJcKDRJcY +EOcLKvbdmbKWwnnV +EPDKjvbdcasNSAUN +EPCkKvbdUaBpsQqy +EObkKvbdJutedFHJ +DoDLKvbdBhjakJFj +DnbkKvbdnUuZjiqf +EPDKjvbdpxoHgQcx +DnbjjvbdZjTHofbG +EObkKvbdkxsSSxgU +DnbjjvbdWRmwbElD +DoCkKvbdRkZFuGjs +EPCkKvbdwNWANDdm +EObjjvbdTkvPBVni +DoDKjvbddndrkTtS +DncLKvbdZtJIxdSn +EOcLKvbduaDyTOeI +EOcKjvbdxZgfGXdr +EOcLKvbdkySrTZGt +EPDKjvbdVwJXucdg +EPDLKvbdatagYLUI +DoCjjvbddZxpYZQb +EPDKjvbdtunXjRTA +DoDLKvbdWSOYBeMD +DoCjjvbdHlBznXRL +EPDLKvbdcyxpXxpb +DnbjjvbdAMhYsWzY +EObjjvbdraemLgKy +EPDKjvbdJpzFOenF +DoCjjvbdZnnIeEyj +DoCjjvbdrWpLbiZR +EOcKjvbdLqwMytpz +DncKjvbdKQzEoFme +EPDKjvbdZRMeJMeR +DncKjvbdEuxpPlie +EOcLKvbdFWYpPlie +EOcLKvbdjblKpgUg +EOcLKvbdiBnbdwQq +DoDLKvbdOTTufeVQ +EPDKjvbdpyOggQdY +DnbkKvbdGBOqYizm +EObjjvbdRjxfUfkT +EPCjjvbdUMVoAuoJ +DoDLKvbdVwJXvEEg +EObkKvbdnCKXXoOV +DoDKjvbdNPxRVmgT +DncLKvbdZsiIxdSn +EPDKjvbdjlalZeHP +DoDLKvbdeFPSBvbj +DoDKjvbdVqnXbFMD +DncKjvbdHffyyYYH +EOcLKvbdBhjbLJFj +EPDKjvbdJvVGEFHJ +EOcKjvbdgQBzvdYI +EPDLKvbdpyOggRDx +EObjjvbdKQyeOfNe +EPCjjvbdtcCtwVno +EPCjjvbdQvmdClHc +DnbkKvbdyXiKBoyk +DncKjvbdqTsgSSLU +EObjjvbdyNrgxShc +DnbjjvbdRkZFuGjs +EObjjvbdYfvdAOri +DoDKjvbdkMbMZeGo +EPDLKvbdCIjbLIej +DoDKjvbdHffyxwwg +EPCkKvbdGdLVibJj +DoCkKvbdaaVdepQX +DnbkKvbdSQUGifDw +EPCkKvbdqYngfpdY +DnbkKvbdxUleQyLn +DoCjjvbdqlyixkgi +EPCkKvbdjgfkfGNk +EObjjvbdeFOqavbj +DoDLKvbdYkrDtNlN +DoCkKvbdjhGlFenL +EPCjjvbdijFhJmXr +EObjjvbdnGeYMmfy +EOcLKvbdbhmJjfXY +EOcLKvbdLBKfmCYR +DncLKvbdJSxaSmXl +EPCjjvbdsQVnicWG +DoDKjvbdjhHLfFnL +EObkKvbdjuwOEBww +DoCjjvbdiBncEvpq +EOcLKvbduLxWaUAw +DncLKvbdhuZdwRtb +EOcKjvbdjvWnECXw +EObkKvbdZeYGzghb +DoDLKvbdNQYQumgT +DoDKjvbdJpydoFnF +EPCkKvbdRjyFuGkT +DnbjjvbdraelkgKy +EObjjvbdfNGXHMjL +DoDLKvbduWNwiqTA +DncKjvbdnVUzLJrG +DoDLKvbdehKvSOQg +EPDLKvbdwtmFRYkn +DoDKjvbdKfFgaaQu +DncKjvbdCTBDTfXS +EObjjvbdDoCjjwCd +EPCjjvbdYTMAmUOx +EOcKjvbdiMFDnVCy +EObkKvbdjlalZeHP +DnbjjvbdCJLCLIfK +DoDLKvbdZMRdUNkm +DnbjjvbdURRPVUgm +EObjjvbdJcJbpibx +EObkKvbdrWpMDJZR +EObjjvbdjuwNdBxX +EPCjjvbdbBVdfQQX +EPCjjvbdKRZeOfOF +DoCkKvbdKDKCqKCx +DoCjjvbdkVvmdBxX +EPDKjvbdvAdYroEh +EOcLKvbdtcCuXWPP +EPCjjvbdczZQXxpb +DncKjvbdUxhUZkPO +EObjjvbdlrYtysEJ +DncLKvbdcScLUDia +EPDKjvbdBsAbsevr +DoDLKvbdqTtGqrLU +DoDKjvbdSCEFLiYk +EPCjjvbdRWmccLgc +DncLKvbdNQYQunGs +EObkKvbdmbKXYPNu +EPCjjvbdfMewGmKL +EObjjvbdzROmIiwA +DnbkKvbdliETptqa +EPDKjvbdHlBznWpk +DoCkKvbdUaBpsQqy +DoCkKvbdWSOYCFMD +DoDLKvbdxmrhYTIc +DncLKvbdLAkGlbYR +DncKjvbdlhctRUqa +DoCjjvbduDCtwVno +DnbkKvbdIjEAKQHE +DnbjjvbdiLddNuCy +EPDKjvbdEXwktUTl +EPCjjvbdyNrgwsJD +EObkKvbdnPzYujxb +EPDKjvbdznoqEcMY +EPDKjvbdZRNEhleR +DoCjjvbdGQATXHFy +EPCjjvbdyqPNIiwA +EOcKjvbdkxrrTYgU +EOcKjvbdcImKLFvx +DoCkKvbduoTzpkPU +EPCjjvbdJXtCIMQp +EOcKjvbdrpVoJbvG +DncLKvbdqZPIHRDx +DnbjjvbdTAFJHand +EOcKjvbdtcCuWuno +DncLKvbdfIKurNqH +DncKjvbdLrWmZtpz +DoDLKvbdMtsRjmAX +EObjjvbdLGGHbBRV +EObkKvbdCWzchePv +EOcKjvbdZxcjODMS +EObkKvbdzaAPGgBl +DoDLKvbdKVtecdgJ +DnbjjvbdHDjvJbJj +EPCjjvbdLiCLqYAS +EPDLKvbdFVxpPmKF +DoDLKvbdZisIPgBf +DncLKvbdTppoUtgm +DnbjjvbdpyPIGpdY +DoDLKvbdEztRElCi +DncLKvbdHgGzZYYH +DnbjjvbdZLqctOMN +DnbkKvbdqTtGqqkU +DnbjjvbdiMEcnVCy +EPDKjvbdvBDxrneI +DoDKjvbdemGXHNJk +DoDKjvbdhficYvKV +EObjjvbdegkWSOQg +DoDLKvbdOFDtIiKd +EPCjjvbdBdQAuimG +DoCjjvbdpyPHgREY +DncKjvbdJXsbHkpp +DoDKjvbdRbEElIxk +DoDKjvbdsQWPJcWG +EObkKvbdsCGNLfkZ +EOcLKvbdzaAPGgCM +EObkKvbdzjUoodSt +DnbkKvbdemFvgMjL +DnbkKvbdWWhxVcdg +DncLKvbdxrmiMqag +EPCkKvbdMSWlytpz +EObjjvbdwNWAMdFN +EPDLKvbdlrYtzTEJ +DnbjjvbdVqnYBeLc +DncKjvbdnHEwmOGy +DnbjjvbdtbbuWvPP +DncKjvbdmIcspuSB +EObkKvbdEOcKkXCd +EOcKjvbdDncKkXCd +EPDLKvbduaDxrndh +DoCjjvbdOFDshhkE +DnbkKvbdRaceLhyL +EPCkKvbdZshhyDrn +DoCjjvbdCSaDTfWr +EOcKjvbdqUTfrSLU +EPDLKvbdtTRryZdc +DoDLKvbdkyTRsZGt +EPDKjvbdyqPNIjXA +DoCkKvbdNUrrKmAX +DoCjjvbdSCDeMIxk +EObkKvbdkMbLzEgP +DncKjvbdEvZPpMie +DoCkKvbdyYIibQZk +EObkKvbdNPxQumfs +EOcLKvbdDncKjvbd +EPCkKvbdozmcjxPA +EPDKjvbdCIkCLIfK +DncKjvbdcyxoxZRC +DoCkKvbdeOdrkUUS +DoCjjvbdhzVFlQnG +EObjjvbdOFETiJLE +DncKjvbdhyuGLqNf +EObkKvbdRWmdClID +DoCjjvbdFpATWgFy +DnbkKvbdlqxtysDi +EObjjvbdqmZjYkhJ +DoDKjvbdZyDjODMS +DoCjjvbdEJhJvYKA +EOcKjvbdqTsgRrLU +EOcKjvbdZsiIxcrn +EObkKvbdIHGzZYYH +EPDKjvbdHgGyxxXg +EObkKvbdxmrgwriD +EPCkKvbdxrnJNSBg +DnbkKvbdjhGkefOL +EPCjjvbdKQydoGNe +EOcKjvbdqvpMDJZR +EObjjvbdQdDBQQdS +DoDKjvbdSKxfVHKs +DoDKjvbdbLLeoODA +DoDLKvbdBsAcUGWr +DoCjjvbdRzKHrbvA +EObjjvbdfMfXGljL +EObkKvbddeOrCWbj +DoDKjvbddjJrVtzn +DoDLKvbdhtydvqtb +DnbjjvbdRNXayOUz +EPDLKvbdRjyFtgKs +EObkKvbdsPuoKCvG +EPCkKvbdYqNEiNFR +DncKjvbdUxgsyjnn +EPCjjvbdZRMdhldq +DoDLKvbdEJhKWXjA +DoCkKvbdQwODblID +EPCkKvbdssRrxzFD +DnbjjvbdZxdKOCkr +EObjjvbduCcUwVno +EOcKjvbdmuUzLKRf +EPCjjvbdfpBzvcwh +DnbjjvbdMowpvNfs +EPDKjvbdGLErcHmV +EPDLKvbdZoOIeEyj +DncLKvbdSLZGUgKs +DncLKvbdlqyUzTEJ +EPCjjvbddePRawDK +DncKjvbdHEKvKCJj +DoDKjvbdeEnqavcK +DoDLKvbdtSrTYzFD +EPDLKvbdxUmFQxlO +DnbjjvbdLLBIWAJy +EOcLKvbdMowqWNfs +EPDKjvbdptUGrSKt +DoDLKvbdHEKvKCKK +EPCjjvbdJcJbpjDY +DnbjjvbdMuTRkNAX +DnbkKvbdEzspdlDJ +DncLKvbdVUMsekvK +EPDKjvbdOTUVgEtp +DncKjvbdAMgySwZx +DoCkKvbdwtmFRYkn +EObjjvbdIjEAKPgE +EPDKjvbdRpTfjGEX +DncKjvbdFjeSbglu +EObkKvbdjFLGtoAO +DoCkKvbduWOYJqTA +EPCkKvbdVAapsQrZ +DnbjjvbdVwJXudEg +DoDLKvbdUtMsfLvK +EPCjjvbdHELVjBij +DncKjvbdRWnECkhD +EPDLKvbdZsiJZDsO +DncLKvbdnPzZWLYb +EPCjjvbdznoqEcMY +EOcKjvbdzoQQeDMY +DnbjjvbdznpQdbkx +EPDKjvbdeYZtTrFz +DoCkKvbdkySrTZHU +DncKjvbdCSaDUGXS +DoCkKvbdcJNJjfXY +EOcLKvbdCEQAvJlf +EPDKjvbdyzdmqhJI +DncLKvbdNPwpvNgT +DoDKjvbdqmZixkgi +EOcKjvbdVYhUZkPO +EObkKvbdhgJbxvJu +DoDKjvbdUQqPUuHm +DncLKvbdqvolChyR +EPCkKvbdEXxMTssl +DnbkKvbdHgGzYwxH +DoDLKvbdIidAJpGd +DnbkKvbdZLqdUOMN +DnbkKvbdGckViaij +DoCkKvbdFVxopNJe +EOcLKvbdRbEFMIyL +EObkKvbdLAjflawq +EObjjvbdziuPodTU +EPDLKvbdQwNdCkhD +EPCjjvbdZxdJmcLr +EPDLKvbdxrmhlqag +DoCkKvbdSPsgJfDw +EPCjjvbdkDLjpgUg +DnbjjvbdtbcUwWOo +DnbkKvbdWIXuxHYz +EObjjvbdEvYpQMie +DoDLKvbdIHGzZXxH +EPDLKvbdVYgszKoO +DncKjvbdhancEvpq +EPCjjvbdcJNKKewY +EPDKjvbdWWhwvEEg +EOcLKvbdvAdYsOdh +EObkKvbdcyyPwxqC +EObjjvbdSPtGifDw +EOcLKvbdkMalZeHP +EPDKjvbdYlRctNlN +DoDLKvbdKWVGEFGi +DncLKvbdMgColouL +DncLKvbdhbPCeXRR +DncLKvbdDwxMTstM +DoDKjvbdvAcySndh +EObkKvbdXGYytAPT +DoCjjvbdmuVZjjRf +EOcLKvbdDGlFgAzc +DoDKjvbdiBncFXRR +DoDKjvbdkaMnmALA +DncKjvbdVBCQrqSZ +DoCkKvbdVviYWEFH +EObkKvbdAMhZSwZx +DoDLKvbdeAUQlwjG +DoDLKvbdZxcjODMS +EOcLKvbdrpWPKDVf +EPCkKvbdWRnYCFLc +DnbkKvbdKeehBaRV +DoDKjvbdMSXMzUpz +EOcKjvbdRkZGVGjs +DoDLKvbdFkFScIMu +DoCjjvbdZjTHogBf +DnbkKvbdnBivwnmu +EOcKjvbdCTAcTevr +EOcKjvbdVviXvDeH +DoDLKvbdliDsptqa +EPDLKvbdZirgpGaf +EPCjjvbdaRfChUFk +EPCjjvbdkClKqGtg +DoCjjvbdKQyeOfOF +EPCkKvbdqvpLbiYq +DnbjjvbdCTBDTfXS +DoCjjvbdOEctIhkE +EObjjvbdbVCHXkUI +DncKjvbdxnTIXrhc +DnbjjvbdezvYdhsw +EPCjjvbdDwwkstUM +EPCkKvbdaaVdepQX +DoDLKvbdjlbMZeHP +DoDLKvbdqAiFAXHd +EPDLKvbdGLEsCglu +EPCjjvbdZyDinClS +EPCkKvbdSLYeuGkT +EPDKjvbdwyhGFweS +EOcLKvbdjJfIKNYS +DoCjjvbddeOrCXCj +DoDKjvbdkxrqsZHU +EOcKjvbdGYuVBEYC +DncKjvbdHkazmvqL +DnbkKvbdZsiIxdSn +EObkKvbdhanbeXQq +EOcLKvbdMpXqWNfs +DnbkKvbdEztQdkcJ +EPCjjvbdDjHjWXjA +EOcKjvbdNQYQvNgT +EPCkKvbdNHCpNPtk +DoCjjvbdbsCkUDjB +EObkKvbdOStWGeUp +EOcKjvbdVqnYBdlD +DoCkKvbdvlvANDeN +DoDKjvbdnQZyWKyC +EOcLKvbdkyTRsYft +EOcKjvbdnVUyjiqf +EPCjjvbdXnRAXtut +EPDKjvbddZxpXxpb +EPDLKvbdfHjvSOQg +DncKjvbdXsMBNTnx +DncKjvbdEARiMzXX +EPCjjvbdOStVgEuQ +DnbjjvbdHELWKCKK +EOcLKvbdehLWSOQg +DncLKvbdYkqctOLm +DoDLKvbdxsOJMqbH +DoCjjvbdzGyMANFX +DoCjjvbdSCEElJZL +DoDKjvbdRkYeuHLT +EOcKjvbdXsLaMsnx +DnbjjvbdePFSkUUS +DncKjvbdGZUuAdXb +EOcLKvbdlZSqsZGt +DncKjvbdiCPCdwRR +EObjjvbdjvXOEBxX +EPDLKvbdRXOEDMHc +EPCkKvbdZisIQHCG +EPDKjvbdjKGIKNYS +DncLKvbdWWiYVdEg +DnbjjvbdaMkBruNH +EOcLKvbdOFEThiKd +DoCkKvbdVZHszLPO +DoDKjvbdiHJcYvJu +EPCkKvbdwuNFRZLn +EObkKvbdJqZdoGNe +EOcKjvbddndsLUUS +EOcLKvbdBraCtGWr +DncLKvbdxrnJNRbH +DoDLKvbdCWzciFPv +EPCkKvbdtlXvaUAw +DoCjjvbdMfbomQUk +DoCjjvbdfoazwDxI +DoCkKvbdauCHXkUI +DnbjjvbdaogHELzd +EPCjjvbdTulPisaR +EPCkKvbdOSsvHEtp +DoDLKvbdTkuoBVni +EPDKjvbdVBBqTRSZ +DnbjjvbdEJgivYKA +DncKjvbdJXtBgkqQ +DnbkKvbdbsCjsdJa +EPCjjvbdhlEcnUby +EObjjvbdssSSyZdc +EObkKvbdhgKCyWJu +EObkKvbddeOqbWcK +DoCkKvbdqvpLcJYq +EPDKjvbdxZgefXeS +EOcLKvbdkVwOEBww +EPDKjvbdemFvfljL +EPCjjvbdFkErcIMu +EOcKjvbdZyEKNcMS +EPDKjvbdqlzJxlHi +EPCjjvbdmbJwXnmu +EOcLKvbdcTDLTcia +DoCkKvbdyzdmqhJI +DnbjjvbdGdLWKBij +DoDKjvbduaDxsPEh +DoDKjvbdZshhxdTO +DncKjvbdptUGqrKt +EPCjjvbdJvVFceGi +EOcKjvbdddoRawDK +DoCkKvbdfMfXHMik +EObjjvbdVAbRSpqy +EObkKvbddZyPxYpb +DnbkKvbdVYgszKnn +DoCkKvbdZMRdUNkm +EObjjvbdTvMPitBR +EObkKvbdIxTaglQp +EObkKvbdGGKSNiUR +DoCkKvbdGBOpyJzm +EPCjjvbdqrUjmjaN +DncKjvbdIMBzmvpk +EPCjjvbdcyxoxYpb +EOcKjvbdmIcsqUrB +DoCkKvbdqvolChyR +EPCjjvbdkHgMGGOL +EPDLKvbdpaIeAWgd +DncLKvbdqvokcIxq +EOcKjvbdZsiJYcrn +EObkKvbdyYJKBpZk +DoCkKvbdKDKDQicY +EObkKvbdlhdTptqa +EObkKvbdyXhjBpZk +EObkKvbdKNAEZfta +EOcLKvbdRyihTCvA +DncLKvbdtcCtwVno +DnbjjvbdVZITykOn +DoCjjvbdJSyArlwl +EPDKjvbdDxYLtUUM +EPDKjvbdvlvANEFN +DoDKjvbdrykpTAgn +DnbjjvbdeYZtUSFz +DoDKjvbdzjVQQETU +EObjjvbdiHJbyVjV +DoCjjvbdcScLTcjB +DncLKvbdhaoDEwQq +DnbkKvbdQlwbZNtz +EPCjjvbdEARiMzXX +EPCjjvbdGFjSOIsq +DoDKjvbdrXPlChxq +DoDLKvbdYqMeImEq +DoDKjvbdOFETiJKd +EPCjjvbdCTBDUFvr +DoCkKvbdZoOIdeZj +DncLKvbdHgHZyYXg +EOcLKvbdCSaCsevr +DoCjjvbdsQWOjCuf +DoDKjvbdKWUfDeGi +EOcKjvbdzitpPcrt +EPDKjvbdZyDimcMS +EPCjjvbdBcpAuilf +EOcKjvbdqwQMCiYq +EOcLKvbdsrrTZZdc +EObjjvbdSQUHKGEX +DoDLKvbdcyxoxZRC +EObkKvbdWXJYWEFH +DnbkKvbdhgKDYuiu +DoDKjvbdrSVLOKaN +EPCjjvbdMoxQumgT +EPDKjvbdcbTMrATm +EPDKjvbdznopdcMY +DnbjjvbdzdzOzdyp +EObjjvbdGYuVBEXb +EPDKjvbdiZtekpnG +DoDLKvbdvvlAuaVu +DoDKjvbdEYXkstTl +EPCjjvbdauCHYKsh +DoCjjvbdDjIJuwjA +EObjjvbdkNCLzFGo +EPDLKvbdiGicZWKV +EPCkKvbdtlXvaTaX +DoCkKvbdpyOggQcx +EObjjvbdtTSSyZdc +DoDLKvbdiZtelROG +EOcLKvbdWRnYCFMD +EPDLKvbdNddUIhjd +DncLKvbdEObjjvbd +EPDLKvbdVUNTelVj +EPCjjvbdVhXvYGxz +DoCkKvbdfRaWzkbo +DoCjjvbdRjyGVHKs +DoCjjvbdSKxfUfkT +EOcKjvbdaRecITek +DoCkKvbdEJhKVwjA +DoDLKvbdwXLaWBVu +EPDLKvbdLYqJrztf +DncKjvbdUMVoAuoJ +DnbjjvbdvmWAMcdm +EObjjvbdpssfqrKt +DnbjjvbdhlEcnVDZ +EOcKjvbdNsUWGeVQ +EObjjvbdVUNTekuj +DnbkKvbdVYgsykOn +EObkKvbdpssgSRjt +DncKjvbdVZITzLOn +DoDKjvbdGGJrNiTq +DoDLKvbdACqwizJQ +DoDKjvbdIryArmXl +DoCkKvbdZMRdTmlN +DnbkKvbdrovPKDVf +EObkKvbdrounjDWG +DnbjjvbdCSaDTevr +DnbjjvbdUyITyjnn +DnbkKvbdKRZeOfOF +DoCkKvbdDigiuxKA +EOcKjvbdxsNhlrCH +EOcLKvbdDjHiuxKA +DncKjvbdXmqAXtvU +DnbjjvbdqFdFTvAh +EObkKvbdxrmhmSBg +DoCjjvbdIidAKPfd +EOcKjvbdKQydoGOF +DnbjjvbdlqyUzSdJ +EPDKjvbdtvOYKQsA +EPCkKvbdcIljLFvx +DoCjjvbdYqNEhldq +EPDKjvbdczYpYZRC +DoDLKvbdiBoCeXQq +EOcLKvbdiCPDFXRR +EPDLKvbdZisHofaf +EPDKjvbdmIdURVSB +EPDKjvbdZRNFIldq +DoDKjvbdJpydoFme +DoDLKvbdWWhwudEg +DncLKvbdDnbjjwDE +DncKjvbdqTsfqqkU +DncKjvbdKDKDRKDY +DoDKjvbdTulQJsaR +DoCjjvbdSBdFMIyL +DncLKvbdqTtHSSKt +EOcKjvbdBcoaVjMf +EObjjvbdiiehKNXr +EObjjvbdCWzciFQW +EPDLKvbdWSNwadlD +EPDKjvbdKVuGEFHJ +DoCkKvbdZMRdUNlN +EPDKjvbdZRMdiMdq +EPCkKvbdxUmEpyMO +DoDLKvbdRkYfVHKs +EObjjvbdIwtCIMQp +EPDKjvbdmJDsqUqa +EPDKjvbdrDeJPmvB +EOcKjvbdTvMPisaR +DncKjvbdMtsRjmAX +DnbjjvbdlqyUysDi +EPDKjvbdQwNdClID +DncLKvbdRjxfVGjs +EObkKvbdauBfxKtI +DoDLKvbdiZtfLpnG +DoDKjvbdhancFXRR +DoDKjvbdREDBQQdS +EObjjvbdrzMQTBIO +EOcKjvbdcImKKfXY +DoDLKvbdijGIKNXr +DncLKvbdgGMZmfgA +EPCjjvbdZnmheFZj +EPDKjvbdmuVZjiqf +EObjjvbdeFPRawDK +EPDLKvbdrNZiyLhJ +EOcKjvbdlhdURUrB +EPDLKvbdGGJrNhtR +EOcKjvbdiGibyWKV +EOcKjvbdQlwbZNtz +DncLKvbdnVUzKiqf +EOcKjvbdbsDKscjB +EPDLKvbdDnbjjvcE +DoCkKvbdySmhmRag +DncKjvbdkyTSTYft +DoDLKvbdEYXkstUM +EOcKjvbdiHJbyVjV +EOcKjvbdsQVnicWG +DoCkKvbdoznDkYPA +EObkKvbdURQoVVHm +EPDLKvbdFfKSNiTq +DnbjjvbdVgxVwgYz +DnbkKvbdmfeYNOHZ +DoDKjvbdyqPNIiwA +EObjjvbdFVyQPlie +EOcLKvbdGdKvKBij +EPCjjvbdDwxMUTtM +DoCkKvbdKVtfEEfi +DoCkKvbddjKRvUzn +EObkKvbdliEURVSB +EPDLKvbdWSNwaeMD +EOcLKvbdJqZdoFnF +DnbjjvbdKxqJrzuG +DnbjjvbdmuUyjjSG +EPDLKvbdADRxKZhp +EPCkKvbdiCPDEwRR +EObjjvbdTXkMNzkY +DnbjjvbdMgDPlouL +EPCjjvbdyzeNqghh +EOcKjvbdmuUyjjSG +EPDKjvbdDoDLKvcE +EPDLKvbdNxPVzdNt +DoDKjvbdBhjbKhfK +DnbjjvbdZLrETmlN +DoCkKvbdHffyxwwg +EOcKjvbdYSlAmUPY +EPCjjvbdtTSTYzFD +DoCjjvbdFjeTCgmV +EObjjvbdNwnuzcnU +DoDLKvbdSPsfiecw +DoDKjvbdKVtedFGi +EObjjvbdUaCQsRRy +EObkKvbdbsDLUDjB +EObkKvbdEOcKjvcE +EPCjjvbdyNsIYShc +EOcLKvbdbVCGxKsh +DoDKjvbdlZSqsYft +DoCjjvbdUslselWK +DncLKvbdbUbHXkUI +DnbkKvbdYkqcsmkm +DncKjvbdXsMAmUOx +DoDKjvbdJuuFcdgJ +EOcLKvbdGLFTChNV +DoCkKvbdaaWEfQQX +DncKjvbdVqnXbFMD +EOcKjvbdZyEJnClS +DoCkKvbdNdctJIjd +DoDLKvbdmaiwYOmu +EPCkKvbdmbJvxPOV +DncLKvbdTqRPUuIN +EPDLKvbdGGKSNiUR +EPCjjvbdIwtCIMQp +EOcKjvbdHDjvJajK +EOcLKvbdZyEJnDMS +DnbkKvbdrWpMDJZR +EOcLKvbdbUagXjtI +EOcLKvbdLGFgbBRV +EOcKjvbdqvpMDIxq +EPDKjvbdOAJSsjSA +DncKjvbdsrqsYyeD +DnbjjvbdtkwvaUBX +DnbjjvbdGQASwGfZ +EObkKvbdURROtuIN +EObkKvbdiUydwRtb +EOcLKvbdqlyixkhJ +EPCkKvbduaEYroFI +DoCkKvbdnUtyjiqf +DoCkKvbdssSTYzFD +DncLKvbdeATqMwjG +DnbkKvbdqlyjYlHi +DncLKvbdTAEhhCOd +EOcLKvbdpxoIHQdY +EPDKjvbdEXxLsstM +DncLKvbdbLLfPNcA +DoDLKvbdCWzdIeQW +DnbjjvbdWSNwbElD +DoDKjvbdGFjSOJUR +DoCjjvbdmttzKjRf +EPCjjvbdqmZjZMHi +DncLKvbddwzUTqez +EObkKvbdrEFIpOVa +DnbjjvbduMYWaTaX +EPDKjvbdTAEiIBoE +EOcKjvbdVrNwaeMD +DoCjjvbdSwkMNzjx +DoDKjvbdZoNheEyj +EObjjvbdFpASvgGZ +DnbkKvbdvBDxsPEh +DoDKjvbdIHGzYxYH +EOcLKvbdhanbeXQq +EObkKvbdACqxJyhp +DoDLKvbdgQBzwDxI +EObjjvbdOYOuzdNt +DnbjjvbdRWmdDMHc +EPCkKvbdePFTLUUS +DnbkKvbdHlBznWpk +EPCkKvbdqlyixlIJ +DnbjjvbdIHHZyYXg +EObjjvbdBcoaVimG +EOcLKvbdZnnIddzK +DnbjjvbdBiLBjhfK +EPDLKvbdeOeTKtTr +EObkKvbdYlRcsnLm +DoDKjvbdnHExNOGy +DoCkKvbdnCJwXoNu +EOcKjvbdwWlBWBWV +DnbjjvbdGYuVAdXb +EObkKvbdLGGHbBQu +EPCkKvbdEJgjVxKA +EObkKvbdlqyVZrdJ +EObkKvbdaNLBsUmH +EPCkKvbdGQASwHGZ +DncLKvbdnBjWwnnV +DnbjjvbdUslsekuj +DncLKvbdeATqNYJf +EOcLKvbdIwtCHlQp +EOcLKvbdGLErcIMu +DnbkKvbdjvXOECXw +EPCkKvbdfSAvzkbo +DnbjjvbdsCGNMHKy +DoDLKvbdURQnuVHm +EObjjvbdQvmdCkgc +EPCjjvbdSPsgKFcw +EPDLKvbdYpmEhleR +EPCjjvbdFjdsDHlu +EPDLKvbdqdFIpOWB +EObjjvbdnQZyVkZC +EPCjjvbdQdCaQRES +DnbjjvbdADRwiyiQ +DnbjjvbdiiehKNYS +DoCkKvbdHkaznWqL +EObjjvbdmoyxujxb +EOcLKvbdxxIibQZk +EObjjvbdsPuoKCvG +EObjjvbdjcMKpftg +EOcKjvbdZisHofbG +DncLKvbdUGznLwWF +DoDLKvbdFfJqnJUR +DnbjjvbdsBelkgLZ +DoCkKvbdrbGNLfkZ +DncKjvbdeYZssqez +EPCkKvbdyNsHwsIc +DnbkKvbdrafMkfjy +EPCjjvbdZyEJnDMS +DnbjjvbdFpASwGey +DnbkKvbdLGGIBaQu +DncLKvbddiiqutzn +DncKjvbdWIXuwfxz +DoCjjvbdNPxRVnHT +DncKjvbdwygefXeS +EPDLKvbdmJEUQtrB +EPCjjvbdQwOECkhD +DoDLKvbdNGbpMotk +DncLKvbdRyjIScWA +DncLKvbdVrOXaeMD +DncLKvbdQmYBxnUz +DnbjjvbdVBCRSqSZ +EPCkKvbdRosfifEX +EPDLKvbdlYrqrxgU +EPDLKvbdKVuGDeHJ +DncLKvbdDncLLWcE +EOcLKvbdfNGXGmKL +EOcLKvbdQvmdDMHc +EOcLKvbdEARiMyvw +DoCjjvbdnHFXlnGy +EOcKjvbdhtyeXRtb +DncKjvbdMgDQNQVL +EObjjvbdpedFUWBI +EPDKjvbdkHfkfFnL +DoDKjvbdrXQMChyR +EObkKvbdREDAoqES +DoDKjvbdBdQAvKMf +DoCkKvbdjvWnDaxX +DnbkKvbdePEsKstS +EPDKjvbdyOTHwsJD +DnbkKvbdrSVKnKaN +EPCkKvbdZirgpHBf +DoCkKvbdsQVnjDVf +DnbjjvbdGLEsCgmV +EPDLKvbdelewHMjL +EObjjvbdjlbMZeGo +DoDLKvbdxrmhlrCH +DoCkKvbdczZQXyQb +EObjjvbdRDcBQRDr +DoCjjvbdxLXEHzyf +DoCkKvbdkySrTZGt +DoCjjvbdDoDKjwCd +EObkKvbdKWVGEEfi +DoDKjvbdTqQoUuIN +EObjjvbdZRNEiMeR +DoDKjvbdxUmEpyMO +EPDLKvbdxxJJaozL +EObkKvbdraemLfkZ +EPCjjvbdbiNKLFvx +DnbjjvbdZjSgpHCG +EObjjvbdqBIeAXHd +EObjjvbdVUNUGMWK +EPDKjvbdliDsqUqa +EOcLKvbdxZgfGYFS +DnbjjvbdYpmFJMdq +EPCkKvbdcTCjtEKB +DncLKvbdVUMtFlVj +EPDKjvbdcIlijevx +DoCjjvbdpstHSSKt +EOcKjvbdLAjgMaxR +DoDKjvbdHkaznXQk +EPDLKvbdrovPJcVf +EObjjvbdjblLRHVH +EPCkKvbdfSAvzlCo +EPDLKvbdkHfkefOL +DoCjjvbdbiNKKfXY +EPDLKvbdjJfHilwr +EOcKjvbdxVMeQxkn +DncKjvbdqlzJyMIJ +DoDLKvbdffMZnGgA +EPDLKvbdrpWPJcVf +DnbkKvbdNsTvGeVQ +DncKjvbdZshiZETO +DoCjjvbdWRnXaeLc +EPDLKvbdUaCRTQqy +EOcKjvbdKDKDQjCx +EPCkKvbdLKaIWAJy +DoDKjvbdjblKpftg +EPDKjvbdfHkWSNqH +EObjjvbdSCEEkiZL +EPDKjvbdcyxpYZQb +EPDLKvbdVUMtFkuj +DnbjjvbdVBCQrprZ +EObjjvbddoEsLUUS +DnbkKvbdiHKDZVjV +EOcKjvbdpyPHgRDx +EObjjvbdYpleJNFR +DncLKvbdrDdhpOWB +DncLKvbdcbSmSAUN +DncLKvbdQwODcLgc +EPCjjvbdKVuFcdgJ +EPDLKvbdJvUecdfi +EObkKvbddjJqvUzn +EPCkKvbdLrXNZuQz +DnbkKvbdDihJuxKA +DoCjjvbdegkWSORH +DncKjvbdFyVUaEYC +DoDLKvbdNHDPlpVL +DoDLKvbddneTKtUS +DoCjjvbdEARhlywX +DncKjvbdmbJwYPOV +DnbjjvbddeOrBvbj +EPDKjvbdAMhZTXZx +DnbjjvbdULuoBVoJ +DoCkKvbdMfbomQVL +EObjjvbdyTNhlqbH +EPDLKvbdcyxowxpb +DoCkKvbdEPDLLXCd +DncLKvbdSCEFLiZL +DnbjjvbdBiLCKiFj +EPCjjvbdmgExNNgZ +EOcLKvbdsPvPKDVf +DoCkKvbdbKkfOmcA +DncLKvbdIxTaglRQ +DnbkKvbdFVyQQNJe +EPDLKvbdbsCjtEKB +EPDKjvbdakMFnnDA +EObjjvbdWWiYVcdg +DnbkKvbdfSAvzkcP +EOcLKvbdbKkennDA +EPCjjvbdTppoVUhN +EPDLKvbdemGWgMjL +DnbjjvbdJvUedFHJ +DoDLKvbdqvokbiZR +EPCjjvbdZMRctOMN +DoCjjvbdNPwpunGs +DoCkKvbdZtJIyDrn +EPCjjvbdFejRnIsq +EPDLKvbdZshhxdTO +DncLKvbdxZhGGXeS +DoDLKvbdKyRKSztf +EPDKjvbdCflFgAzc +EPDKjvbdOEdThiKd +DoDLKvbdTAFIgaoE +EObjjvbdEARiNZvw +EOcLKvbdjhHLefOL +DncKjvbdbVCHXjtI +EPDKjvbdeFPRawCj +DoDLKvbdtcCuWuoP +DoDLKvbdUVkpJtAq +EPCjjvbdaSFcHsfL +EPDKjvbdPxmAGrrK +EPCkKvbdDjHjWXjA +DnbkKvbdpssfqrKt +DoDKjvbdePEsKtTr +EObkKvbdDwxMUTtM +DnbkKvbdZRMdiNEq +EPCjjvbdhuZdvquC +DoCjjvbdGLEsChMu +EPDKjvbdRDbaQQdS +EOcKjvbdEJhJvYKA +DncKjvbdkxsSSxft +EObjjvbdKRZdnfOF +EOcLKvbdZQmFIleR +DnbkKvbdjcLjpfuH +DnbkKvbdYzbfSKWZ +EPDLKvbdbUafxLTh +EPCjjvbdJuuFcdgJ +DoCkKvbdJcKCqJcY +DoCjjvbdSKyGVGkT +DoCjjvbdemFvflik +DoCjjvbdvBEYsPEh +EOcKjvbdCWzdJEov +DncLKvbdqTsgSSKt +DnbkKvbdUMVoBWOi +EPCkKvbdOEcsiIjd +DncLKvbdaSFbhUFk +DoCkKvbdhtzEwRuC +DoCkKvbdiCOcEvqR +DoCkKvbdfILVqnRH +DnbkKvbdCJLCKhej +EPCkKvbdakLeoODA +DnbkKvbdUaCRTQrZ +DoDKjvbdRacdkhyL +EPCjjvbdYNqAXtut +DncKjvbdwzHfFwdr +DncLKvbdNrsvGeUp +EPDKjvbdDoCkKvbd +EPCjjvbdrafNLfkZ +EObjjvbdmajXXoOV +DncLKvbdVAbRTQrZ +EObkKvbdkySrTZHU +DoDKjvbdZeXfzghb +EPDLKvbdiCOcFWpq +EOcKjvbdUQpnuUhN +DncLKvbdijGIKMwr +DncKjvbdHgHZxwwg +DncLKvbdVTmUFlWK +DoDKjvbdeYZtUSFz +EPDKjvbdHffyyYXg +DncKjvbdXsLaMtOx +DncKjvbdzitoocrt +DoDKjvbdhtyeWquC +EPDKjvbdEuyPpNKF +DnbkKvbdtvOYKRTA +DncKjvbdZnnJFEzK +EPCkKvbdqZPIGpcx +DnbkKvbdVgxWYGxz +EPCjjvbdOStWHEuQ +EObkKvbdNddTiIjd +DoDKjvbdwXMBWAuu +EPDLKvbdsPvPKDVf +DncLKvbdQvnDbkhD +DncKjvbdEKHjWYKA +EPCkKvbdCgMFgAzc +EOcLKvbdQvnDbkgc +EPCjjvbdDoCkLWbd +DnbkKvbdKCibpicY +EOcLKvbdhfibyViu +EOcLKvbdzQnliJwA +DncKjvbdEASImZwX +EPDLKvbdFkFTChNV +DnbjjvbdEuxoomKF +EOcKjvbdYqMeJMeR +DnbjjvbdgQBzvdYI +DoCjjvbdkxrrSxft +DnbjjvbdjuwNdCYX +EOcLKvbdfpBzwEXh +DoCkKvbdnHFYMmgZ +EOcKjvbdjlbMZeHP +DoCkKvbdmttzKjSG +EPDLKvbdzjUopDsU +EPDLKvbdsZlPraIO +EOcLKvbdLBLHMbYR +EPDLKvbdtbcVXVno +DoDLKvbdaaVeGQQX +EPCjjvbdWSOYCEkc +EObjjvbdxUmFQyMO +DoDLKvbdRbDdkiZL +DoCjjvbdhlFDnVCy +EPDKjvbdcTDKscia +EPCkKvbdjlbMZeGo +DncLKvbdCIkCKiGK +DoCjjvbdrbFmMGkZ +EObkKvbdQccAoqDr +DnbjjvbdTqRPVUgm +EPCkKvbdNrsufeUp +EOcLKvbdrMyjZLhJ +EPDLKvbdiifHimXr +DnbkKvbdpstHSRjt +EOcKjvbdZtIhxdSn +DnbkKvbdbhmKLGXY +DnbkKvbdkxsSSxft +DoCjjvbdTAFIhBnd +EObkKvbdUtMtGLvK +EPCjjvbdpstGrSLU +DncKjvbdxLXDgzyf +EOcKjvbdSCDdlIxk +EObkKvbdOFEUIiLE +DnbkKvbdjggLefNk +DncKjvbdliEUQtqa +EOcLKvbdFjdsDHlu +DncLKvbdeEnqavcK +EOcLKvbdnPyyVjyC +DoDKjvbdliDsptrB +DoCkKvbdrXQLbiZR +DncLKvbdFkErbhNV +DoDKjvbdTqROtthN +DoCkKvbdYSlAmUOx +DnbkKvbdKVuGDdgJ +EOcKjvbdvwLaWAvV +DoDLKvbdEObjjvbd +DnbkKvbdwXLaWBVu +DnbkKvbdmtuZjiqf +DoDKjvbdegkWRnRH +DoCkKvbdeXzUUSFz +DncLKvbdfNGXGmJk +DoCjjvbdEztQdlCi +EPCkKvbdEuyQPljF +EPCjjvbdrEEiQNvB +DnbkKvbdLqwNZtpz +EObkKvbdKeegbBQu +EObkKvbdvBEZSoFI +DoDLKvbdrXQLbhyR +DnbkKvbdbKlGPODA +DncLKvbdnCKXYOnV +EOcKjvbdjcMKpfuH +DoCkKvbdQdCaQRES +EPCkKvbdDncKjwCd +DoDLKvbdYlSDtNkm +EObkKvbdmbKXXnmu +EPCkKvbdjgfkfGOL +DnbkKvbdZyDjNcMS +EOcLKvbdkNCLyeHP +DncLKvbdVUMtGLuj +EOcKjvbdKVtedFGi +EPCjjvbdKRZeOenF +DoCjjvbdUQqPUthN +EPDKjvbdkMbLydgP +EObjjvbdVqmxBdlD +EPDKjvbdjAQGaPgK +DoCkKvbdTlVnaWPJ +EPCjjvbdwjvdHzzG +EObjjvbdBsBCtGWr +EPCjjvbdwuNEqZMO +DncLKvbdbrcKtEKB +EPCkKvbdFyVVAcxC +EPCkKvbdaSGCgsfL +EPDKjvbdrylQTBIO +DncKjvbdfSBWzlCo +EObjjvbdfRaWzlCo +DnbkKvbdsPvOjDWG +EPCjjvbdcbSlrAUN +EObkKvbdrWpLbhxq +EPCjjvbdhgKDZVjV +EOcKjvbdhlFDnUby +DoCkKvbdddoSBvcK +DoCkKvbdpssfrRkU +DoDLKvbdJutfEFGi +EObkKvbdEPDKkWcE +EOcKjvbdcJNJjevx +EPCjjvbdcTDKscia +DncKjvbdYlRcsmlN +EPDLKvbdkHgMFfNk +DoCkKvbdjbkjqGuH +EPDKjvbdTvMPjUAq +DnbkKvbdQYmAGsRj +EPCkKvbdKeegbApu +EPDKjvbdiLdcmtcZ +DoCkKvbdNeDshhjd +EOcLKvbdxnShXsIc +EPDLKvbdyOShXrhc +EObkKvbdbPgHELzd +DoCjjvbdDoCkKwDE +EOcLKvbdmbJvxPOV +DnbjjvbdkNBlZeHP +DnbkKvbdRXNdDMID +DncLKvbdXnRAYUvU +EObkKvbdBcpAuilf +EPDKjvbdSLYeuGkT +DoCjjvbdRaceLiYk +DncLKvbdZoNiFEzK +EOcLKvbdGLEsDIMu +DnbjjvbdnUuZkJqf +DoCkKvbdlqyUyrci +DoCkKvbdLGGHaaRV +DnbkKvbdmoyyWLYb +DncKjvbdMpYRWOGs +DnbjjvbdkyTRsYft +EObkKvbdjKFhJmXr +DnbjjvbdxLWcgzzG +DoCkKvbdxnShXrhc +DnbjjvbdRbEEkiZL +EOcLKvbdWWiXudEg +DoDLKvbdDjIKVxKA +DoDKjvbdgFkzNgHA +EPDLKvbdvvlAuaVu +EPDLKvbdauBfwkTh +DncLKvbdmIctQtrB +EPDKjvbdCDpBWJmG +DoDKjvbdvAcxsPEh +EOcKjvbdrJAKFNOe +EOcLKvbdbsDKscia +DncLKvbdAMhYsWzY +DncKjvbdddnrCXDK +EOcLKvbdkHflGGOL +DoDKjvbdbUafxKsh +DnbkKvbdNdctIiLE +EOcLKvbdvBDyTPEh +DoCjjvbdFejSOJUR +DnbkKvbdUQpntuHm +EObjjvbdTpqOttgm +DoDLKvbdddoSCXCj +DncLKvbdbVCHXkUI +EPCjjvbdKNAEZgVB +EPDKjvbdFjdsDIMu +DnbjjvbdpaIeAXHd +EOcLKvbdrDdhpOWB +EPDKjvbdIxUBhLpp +EPDKjvbdhkddOVCy +EPCkKvbdTkuoAuni +EPDLKvbdnPyxujxb +EObjjvbdfSBWzlCo +EPDKjvbdMuSrKmAX +EPDLKvbdmozYvKyC +DnbkKvbdZirhPfaf +EPCjjvbdNQXqWOHT +DncKjvbdZsiIyESn +DnbkKvbdURQnuUgm +DoCjjvbdkIHMFfOL +EPDKjvbdKfGHaaRV +DncLKvbdtcDUwVoP +EOcLKvbdxrnImRbH +EPDLKvbdozmdLYPA +DoDKjvbdUVkojUBR +DnbjjvbdqUUHRrLU +DoDLKvbdEARhmZvw +EOcLKvbdZHWdAOri +DoCjjvbdVUMtGLuj +EOcLKvbdmfeYNNfy +EPDKjvbdZirgogCG +DnbjjvbdEJhKVwjA +DnbkKvbdkVvmdBxX +DnbjjvbdvBEYsOeI +EPCkKvbdDoCjjwDE +DoCjjvbdRXNdClID +EPDKjvbdkxrrTZGt +EOcLKvbdZdxGzhJC +DoDLKvbdxnSgxSiD +DoDKjvbdIryAsMxM +DnbkKvbdTYKlNzjx +DncLKvbdIGfzZYXg +DncLKvbdQvnEClHc +DnbkKvbdqUTfrRkU +DoDKjvbdRDcAopdS +DoDKjvbdTfznMXWF +EOcLKvbdauCHYKtI +EObkKvbdNrsvHEtp +DoDLKvbdDihJvXjA +DnbjjvbdliDtRVRa +DncKjvbdgFlZmfgA +DncLKvbdmJDsptqa +DncKjvbdfoazvdXh +EOcKjvbdJXtBgkpp +EPCkKvbdqUUGrSKt +EPDKjvbdrMzJyLgi +EPCjjvbdiGjDYuiu +EOcLKvbdkWXNcaww +EOcLKvbdxxIjBoyk +DnbkKvbdePErjssr +DnbjjvbdIryArmYM +EOcLKvbdRMwayNtz +EOcLKvbdRkZGUgKs +DoDKjvbdZLrEUOMN +DnbkKvbdDHMFgAzc +DnbkKvbdwXMBVaVu +DnbjjvbddeOrCXDK +EPDLKvbdwuMeQyLn +EPCjjvbdBhjbLIej +EPDKjvbdaNLCSuMg +EPCjjvbdBhkCKhej +EPCkKvbdptUGrSKt +EObkKvbdVTmTfLvK +DoCkKvbdDoDKkXDE +DnbjjvbdfoazvdYI +DnbkKvbdatbHYKtI +DnbkKvbdVUMtGLuj +EPDKjvbdeEoRavbj +DoCkKvbdJpzFPGNe +DnbjjvbdNHDQNQUk +DncKjvbdYNqAXuWU +EPCkKvbdZnnIddzK +EObkKvbdYlRdTnMN +EPDKjvbdEzspdkcJ +DoDLKvbdCIkBjhfK +EObjjvbdTkuoAvOi +DoCkKvbdhkdcnUby +EPCjjvbdHfgZyYXg +DncLKvbdbsCkTdKB +DoCjjvbdLqwMzVQz +DoDLKvbdRkYfUgLT +EOcLKvbdbQHHELzd +EPCkKvbdbVCGxLTh +EObjjvbdmSYuZsEJ +DoDKjvbdssRsYyeD +EPDKjvbdLrWlytpz +DncKjvbdJTZBSlxM +DnbkKvbdxrnJMrBg +EPCjjvbdxZgfFxFS +EObkKvbdUQpnuVIN +EObkKvbdzjUpQESt +EObjjvbduaDxsPFI +DoDLKvbdkyTRsYft +DoDKjvbdyTOImRbH +EObkKvbdegkWRnQg +DoCjjvbdaSFbgsek +DoDKjvbdrylPsAhO +DoCjjvbdgGMZnGgA +EPCkKvbdlqyUzSdJ +DncKjvbdwNWAMdFN +EPDKjvbdTlWPAuoJ +EOcLKvbdUMWPAuoJ +DnbjjvbddZxowxqC +EPCkKvbdEuyQPlie +DoDKjvbdVAaqSqSZ +EPDLKvbdwtldpxlO +EOcLKvbdrRtkNkBN +DncKjvbdJqZeOenF +DncKjvbdfHkWSNqH +DoCkKvbdnUuZjirG +EOcKjvbdsCFmMGkZ +DoDLKvbdwzIFfYEr +EOcLKvbdqqtjmjaN +DoCjjvbdrbGNLgKy +EPDKjvbdNHComQUk +DnbkKvbdIMBznWqL +EPCjjvbdEKHivXjA +EPDLKvbdVhYWYGxz +EPDLKvbdZxcjNblS +DnbjjvbdJpzEoFme +EPDKjvbderBWzkcP +DoDLKvbdpssgRrKt +EObkKvbdtbbtvuoP +EOcLKvbdqGDeUWAh +DoDKjvbdlZSrTYft +EOcKjvbdFfKRmhtR +DnbkKvbdNPxRVnGs +EPDLKvbdZshhxcsO +EPCjjvbdMoxQvNgT +EPCjjvbdKaKfmBxR +EPDLKvbdSwjkmzjx +DoCkKvbdjbkkRGtg +DoDKjvbdfoazwDxI +DoDKjvbdqwQLbhxq +EPCkKvbdZtIhyETO +DncLKvbdmpZxukYb +EOcKjvbdMoxQumgT +DoCjjvbdLYqJrzuG +EObjjvbdnGeXlmfy +EPDLKvbdyzeOSHhh +EOcLKvbdiZuGMQmf +EPCkKvbdWSNwadkc +DncKjvbdhfibyVjV +EOcKjvbdQmXbZOUz +DoCjjvbdSKxeuGkT +DnbjjvbdbrbkUDjB +EPDLKvbdJcKCqJbx +DnbjjvbdjSziTLJz +EOcKjvbdZxdKNcMS +DoCkKvbdelfWfmJk +DoCjjvbdFjeScHlu +EPDLKvbdnCJvwnnV +EPDKjvbdNrsufduQ +DnbkKvbdjcLjqGuH +EObjjvbdmbKXYOnV +DoCjjvbdRacdkiYk +EObkKvbdaaVdfQQX +DoCkKvbdJpydnfOF +DoCkKvbduCbtwVoP +DoDKjvbdpxnhHRDx +EOcKjvbdmJEUQtqa +EPDLKvbdRkZGVGjs +EPDKjvbdEObjkXCd +EObjjvbdCTAbtGWr +DoCkKvbdqTsfrSKt +DncLKvbdaMkBsUmH +DncLKvbdqlyixlIJ +EPCkKvbdvwMAuaVu +DncKjvbdiUzEwRuC +DoDKjvbdiUzFWrVC +DnbkKvbdkDMKpfuH +EObkKvbdZnnJFEzK +EObkKvbdWWhwudEg +DoCjjvbdypoNIiwA +DoCjjvbdShyiqABM +DnbjjvbdOFEThhkE +DnbjjvbdRXNcbkgc +DoCkKvbdqUTfrSKt +EPDLKvbdfNGWgMjL +EPDLKvbdGFirOJUR +EOcKjvbdSCEFMJYk +EOcKjvbdmpZxukYb +EPDLKvbdrafNLgKy +DnbkKvbdmJDsqUrB +DnbjjvbdjKFgimXr +EOcLKvbdVYgtZjoO +EObkKvbdTvMPjUBR +EOcLKvbdSxKkmzjx +DoDKjvbdnPzYvKxb +EPCjjvbdaRfDITek +EObkKvbdjKGIJmXr +DoCjjvbdliEURVSB +EObkKvbdFaOqYizm +EOcLKvbdqGEEsuaI +DoCjjvbdZQleJNEq +DoCjjvbdbKlFnnDA +DnbjjvbdWIXuwfxz +EPDLKvbdNGcPmPuL +DoCjjvbdBsBDTevr +DnbkKvbdczYoxYpb +EObjjvbdJutedEfi +DncLKvbdGFirNhsq +EPDKjvbdUaCQrqRy +EPCjjvbdQwNdDMID +EPDLKvbdtSrSyZeD +DnbkKvbdNHDQMpUk +DoDKjvbdZirgofaf +EObkKvbdrpWOibuf +DoCkKvbdwygfFxEr +EPCjjvbdSwjlNzjx +DnbkKvbdjKGHjMxS +DncLKvbdijFhKNXr +EOcKjvbdddoRavbj +EPDLKvbdmIdTpuSB +DncLKvbdiiehJmYS +EObkKvbdjcLkQgUg +DoDKjvbdsQVoJbuf +EObjjvbdhzUfMQmf +DnbkKvbdcImKKfWx +EObkKvbdbQHHELzd +DnbjjvbdWWiXuceH +EPDKjvbdjJegjNXr +EPCjjvbdZyEKNblS +DoDKjvbdLqvlzVQz +EPDLKvbdZRNEhmFR +DnbkKvbdGcjuibJj +EOcLKvbdGAnpxizm +EPCjjvbdkVvnDaww +EOcKjvbdHffzZXwg +DoCkKvbdKeehCAqV +EPCjjvbdHEKuiajK +EOcKjvbdUtMselWK +EPDKjvbdEXwlTstM +EPDKjvbdsrrSxzFD +EOcKjvbdEztQeMDJ +EPCkKvbddoFSjstS +DoCkKvbdSCEElIyL +DncKjvbdFVxpQNJe +DnbjjvbdXmqAYUut +DoCjjvbdiZtfLpmf +DoDKjvbdwygeexEr +EOcLKvbdiUyeXSUb +DncKjvbdsZkoraIO +EOcLKvbdACrYJyhp +EOcLKvbdTlVoBVoJ +EPCkKvbdqZPHfqDx +DnbkKvbdmJDsptqa +DncKjvbdhkeDnUcZ +EPDKjvbdURQoUtgm +EPDKjvbdjAQHAogK +EObjjvbdCIkCKhfK +EOcKjvbdYzbfRjWZ +DnbkKvbdWRnYCEkc +DncKjvbdyzeORgiI +EObjjvbdEPCkLWbd +DoDLKvbdNHComPuL +DnbkKvbdaRebhUFk +DnbkKvbdhlEcmtby +EOcLKvbdliETqUrB +EPDKjvbdIxTbHkqQ +DncLKvbdCEPaVjNG +EOcLKvbdIjEAJogE +DoCkKvbdsZkpSaHn +EPDLKvbdEXxLtTtM +DncKjvbdwXMAvAuu +EPDKjvbdakMGPODA +EPCkKvbdauBfxKsh +EOcKjvbdCJKakJFj +EPCkKvbdyXhjBozL +DoDLKvbdkWWnDbYX +DncKjvbdEPCjkXDE +DoDKjvbdlqxtzTDi +EPCjjvbdyTOJNSBg +DoCkKvbdnGeYMmgZ +EPCkKvbdaSFbhUFk +EObjjvbdnCKWxPNu +DoCjjvbdrWpLbhyR +EPDLKvbdmRxtyrci +DnbjjvbdSBdElJZL +DnbkKvbdrXQLbiYq +DoDLKvbdWHwuwfxz +DoCjjvbdZRNFJNEq +DncKjvbdUVkpJsaR +DoCjjvbdbiMijfXY +EPDKjvbdVTmTekvK +DoCjjvbdeXytTrFz +DoDLKvbdyYJKCQZk +DoDLKvbdczZQYZQb +EObjjvbdRadFMJZL +DncLKvbdkVvnECYX +DncKjvbduaDySneI +DnbjjvbdwuNFQyMO +DncLKvbdsrqrxzEc +DoDLKvbdcSbjtEKB +EPCjjvbdZtJIyETO +DoDLKvbdJvUfDdgJ +DnbjjvbdhbPDFWqR +DncKjvbdcyyQYYpb +DoDKjvbdWSNwbFMD +DoCjjvbdmajXXoNu +EPCkKvbdxZgeexEr +EOcKjvbdxsOIlrBg +DoDKjvbdZyEJmbkr +DncLKvbdTkunaVni +EOcLKvbdUQpoUthN +DoDLKvbdyNsHxTJD +DncKjvbdEztRElCi +DnbkKvbdXnRAYVVt +DnbjjvbdqAheAWgd +DnbkKvbdCJLBkIfK +EPDKjvbdUGzmkwWF +EPCkKvbdSiZiqABM +EPDLKvbdidkGtoAO +EOcLKvbdYlSDsnLm +EPDKjvbdMSWmZtpz +DoDKjvbdlhdURVRa +EOcLKvbdOYOuzdOU +DncLKvbdrafMlGkZ +EObjjvbdrylPraHn +DnbjjvbdDncLKwCd +DoCkKvbdoznELXoA +DoCkKvbdmttykJrG +DoDLKvbdBvzciEov +EPCjjvbdeXzUUSFz +DoDKjvbdtunYKQsA +EObjjvbdqceJQNvB +EOcLKvbdqTtGqqkU +DoCkKvbdiGjDYujV +EPCkKvbdRWnEDLhD +EOcLKvbdcSbjtDia +DncLKvbdTqROuVHm +EOcKjvbdiifIKMxS +EObkKvbdlYrqsZGt +DoDKjvbdSBdFLhxk +DnbkKvbdVUNUFkuj +DoCjjvbdrzLpSaIO +DoDKjvbdzGxlANFX +DoDLKvbdfHjuqmpg +EPDKjvbdZRMeIldq +DncKjvbdMfcPlpVL +DncKjvbdxKwDgzzG +EOcLKvbdYzbfRjVy +EObkKvbdWSNwbElD +DoCkKvbdeFOrCXCj +EObjjvbdbKlGOmcA +EOcKjvbdDxXktUTl +EPCjjvbdvBDySneI +EPDKjvbdLFehCBRV +DoDLKvbdiZuFlROG +EPDKjvbdDoDLKvbd +DoCjjvbdQwNdCkhD +DoCjjvbdCJLBkIfK +DnbjjvbdlqyUzSci +DncLKvbdNHCpMpUk +EOcKjvbdiMFEOVCy +DoCkKvbdnGeYNOGy +DnbkKvbdZoOIddzK +EOcKjvbdFpATWffZ +DoDKjvbdeOeTKtTr +DnbjjvbdGGKSNhsq +EOcKjvbdyXiKCPyk +DoCjjvbdeAURNYKG +DoDKjvbdpssfrRjt +EPDKjvbdnVVZjjRf +EOcKjvbdiZuGMQmf +EOcLKvbdNHDPlotk +DnbjjvbduCbtwVoP +EOcKjvbdxUleQxlO +DoDKjvbdnHFYMnGy +DnbjjvbdUVlPitAq +EPCkKvbdjAPgAofj +DoCkKvbdTlVoAuoJ +EPCkKvbdmSYtyrdJ +EPDKjvbdBsAcTevr +EPCkKvbdUyITzKnn +DnbjjvbdbQHGdLzd +EOcLKvbdezuyFIsw +DoDLKvbdEXwlTtUM +EOcKjvbdKyRJrztf +DnbjjvbdtTSSxzEc +DnbjjvbdHDjujBij +DoCjjvbdsQVnicWG +EObkKvbdZsiJYcrn +EPDLKvbdUtNUFkuj +DoDKjvbdNPwpumfs +EOcKjvbdSBcdlJZL +EPDLKvbdmfeXlmfy +DncKjvbdIsZAsNXl +DncLKvbdmJDsptrB +DncKjvbdGYuUaEXb +DncLKvbdyYJJbPzL +DnbkKvbdrpVnicWG +EPCjjvbdTqQoVUgm +DoDLKvbdFVyPpMjF +EObkKvbdZnnIeEyj +EObkKvbdbUagYKtI +DoCkKvbdqGDdtWBI +EPDLKvbdFVxpQNKF +DncLKvbdkWXNdCYX +EPDKjvbddwystRez +EOcKjvbdaNKasUlg +DnbkKvbdNdctIhjd +EPCkKvbdatagYKsh +DoCkKvbdfNFvgMik +EObjjvbdJYTbIMQp +DoCjjvbdEYYMTtTl +DncKjvbdWRmxCElD +EPCkKvbdbsCjsdKB +EOcLKvbdFVxpQMie +EObkKvbdpaJFAWgd +EPDLKvbdijGHimXr +EPCjjvbdlhctQtqa +EObjjvbdFVxoolie +DncKjvbdrJAKEmOe +DnbkKvbdzQnmIiwA +EPCkKvbdkHfkeemk +DnbjjvbdLGGHaaQu +DnbkKvbdOSsugEtp +DnbkKvbdZtIiYcrn +DoCjjvbdQZNAGsSK +EObjjvbdNPxRWOGs +DoCkKvbdVUMsfLuj +DnbjjvbdmJETqUqa +EPDLKvbdBsAcUFvr +EOcLKvbdIsZArlwl +EPCjjvbdNddTiJKd +DoDKjvbdyXhiaozL +DncLKvbdjmCLzEfo +EOcLKvbdRadElJYk +DncLKvbdjbkkQfuH +EObkKvbdXFxzUAOs +DncLKvbdxZhGFwdr +DoCjjvbdNsTugEuQ +EObjjvbdRbDdlIyL +DoCkKvbdePEsLUUS +DoCjjvbdOStVgFVQ +EPDLKvbdUtMtGLuj +EObjjvbdFjdrbhMu +EOcKjvbddeOrBwCj +DnbjjvbdxUmFRYkn +DnbjjvbdCEQBVimG +EOcLKvbdvAdZTPEh +EPCkKvbdGcjvJaij +EPCjjvbdOFETiIjd +EOcLKvbdemGWgNKL +DoCkKvbdqTsfrRkU +DncLKvbdbrcKsdKB +EPDLKvbdTAFIhBoE +DoCjjvbdKCjCqJbx +DnbjjvbdNsUWHFUp +EPDKjvbdkWWmcaxX +EPDLKvbdbKlFoNcA +DoCjjvbdkIGkefNk +EPCkKvbdXFyZtAPT +EPDKjvbdpxnhGpcx +DoDLKvbdhanbeWqR +EOcKjvbdliEUQtqa +EObjjvbdbBVeFpPw +EObkKvbdQdDApQdS +EPDLKvbdnQZyVkZC +EObjjvbdhbOcEwQq +DnbjjvbdBdPaWKMf +DoCjjvbdCTAbtGWr +EPCjjvbdEvYpQMie +EObjjvbdDxYLtUTl +EObkKvbdCTBDTfXS +EPCjjvbdmpZxvKyC +EPCkKvbdRzKITDWA +EObkKvbdemGXGmJk +EOcLKvbdIryAsNXl +DoDKjvbdkWXNcaww +EObkKvbddCTNSAUN +DncKjvbdvBDxroEh +DncLKvbdiCPDEwRR +EObjjvbdRkZGVHLT +DoCjjvbdFkFSbhNV +EPDLKvbdwjvdHzzG +DoDLKvbdqquKmkBN +EOcKjvbdsQVoJcVf +EPCjjvbdYlSEUOMN +EObkKvbdjKGIKMxS +DncLKvbdRpUGifDw +EObkKvbdEuxooljF +EPDLKvbdzitpQETU +EOcKjvbdTvLpKUAq +DoCjjvbdrSVKmkAm +EOcLKvbdEvZQPmJe +EPCkKvbdfelZnHHA +EOcLKvbdjhGlGGNk +DncKjvbdCEPaWJmG +DncLKvbdrpVnjDWG +DoDLKvbdeOeTKtUS +DoCkKvbdtbbuXVno +EObkKvbdYpleJMeR +DnbjjvbdiCPDEvqR +DoDLKvbdUslsekuj +DnbkKvbdGBPQyJzm +EPCkKvbdtbcUwVoP +DoDKjvbddxZssrFz +DncLKvbdkIGlGFmk +EPCkKvbdhuZdwRtb +EObkKvbdehLWSOQg +DoCkKvbdatafwjsh +DoDKjvbdhfjCyViu +DoCjjvbdFyUuAcxC +EObkKvbdUMWPAvPJ +EPDLKvbdxxIjBoyk +DnbjjvbdMRvlytpz +EPCkKvbdDxYLtUTl +DnbjjvbdiVZeXSUb +DoCjjvbdffMZmgHA +EPDLKvbdnPyyVkYb +EPCkKvbdZtIhyETO +DncKjvbdRECaPqDr +EPDKjvbdVrNxBeMD +DnbkKvbdKVuFdFGi +EOcLKvbdrzLosAgn +EPDKjvbdLLAgvAKZ +EOcLKvbdLYpirztf +DncKjvbdnGeXlnHZ +EOcLKvbdQdDAopdS +DnbkKvbdptTfrRkU +DoCjjvbdqGEFUVaI +DncLKvbdrDeIomvB +DoDLKvbdyOTHxSiD +EOcLKvbdRpTfjGDw +DoDLKvbdzitpPdTU +DnbjjvbdUxhTykOn +EOcKjvbdGFjSNhtR +EObkKvbdidkGuPAO +EObjjvbdVAapsQrZ +EPDLKvbdQccAopdS +EObjjvbdmozYukZC +EOcKjvbdGFjSOIsq +EPCkKvbdyzeNrHiI +DncLKvbdEOcKjvcE +DncLKvbdLFfIBaQu +DoDKjvbdtlXwBUBX +DoCjjvbdeOeTLTsr +DncKjvbdiZuGLpnG +DoCkKvbdWRnYBdkc +DncLKvbduCbtvvOo +DnbkKvbdGGKRnIsq +EOcLKvbdVTmUFkuj +EOcKjvbdFkEsDHlu +DoDKjvbdQwNcbkgc +DncLKvbdWRmwbFLc +DnbjjvbdHlBzmwRL +EPDKjvbdDncKjwCd +EObkKvbdGBPRYizm +EOcKjvbdqrVLNjaN +EObjjvbdqFceUVaI +DoCkKvbdZQmFImFR +EPDLKvbdmIctRVSB +EObkKvbdjAQHBPfj +EObjjvbdrEFIonWB +DnbjjvbdsPuoKCuf +DoDKjvbdtbbuXWPP +EPDLKvbdOStWGduQ +DoCkKvbdUQqPUuIN +EPDLKvbdwyhFewdr +EObkKvbdShyiqAAl +EPDLKvbdGZUuBEXb +EPCkKvbdHffyyXwg +EObjjvbdGBOpyJzm +EObkKvbdZirgpGaf +EObkKvbdRjxfUfkT +EPDKjvbdZHWdAPSi +DnbjjvbdVrOYBdkc +DoCjjvbdGGKSNhsq +EOcKjvbdJqZeOenF +EOcLKvbddBsNSAUN +DncKjvbdZtJJYcsO +EPDKjvbdBraDTevr +DoCkKvbdRDcApQdS +EObjjvbdGGJrNiTq +DoCjjvbdGLFTCgmV +DoCjjvbdtlXwBUAw +DncLKvbdQwNdClHc +DoDLKvbdygYlAMeX +EPDLKvbdTvMQKTaR +EPCjjvbdiMFDnVDZ +DoCjjvbdiBoDFXRR +EObkKvbdUQqOuUgm +EOcKjvbdaMkBsVNH +EObkKvbdwuNEqZMO +EObjjvbdLAkGlbXq +EObkKvbdkCkkQgUg +DncLKvbdVqnYCFLc +EPCkKvbdxVMeRZLn +DncLKvbdRXOEClHc +EObjjvbdvwMAvBWV +EObjjvbdIwsahLpp +EObjjvbdKDKCpicY +DoDKjvbdlrZUzTEJ +EOcLKvbdyYIjBpZk +DncLKvbdxsNhlqag +EPDKjvbdgPazvdXh +EPDLKvbdbKlGPNcA +DoCjjvbdqUUHSRjt +DnbkKvbdNeDsiJKd +DnbjjvbdqGEFTvAh +DoDKjvbdnUtykKRf +EPDKjvbdZtJJZDrn +DoCjjvbdmRxtysEJ +EOcKjvbdQmXbYnUz +EPDKjvbdjmCLzFGo +DncKjvbdsBfMkfkZ +EPCkKvbdFVxpPlie +DnbkKvbdZLrEUOMN +DoCkKvbdEOcKkXDE +EObkKvbdvBEYsPEh +EPDKjvbdcJMjLGXY +EOcLKvbdOYPVzcnU +DnbkKvbdsQWOjDWG +EOcLKvbdfHjvRnRH +DoDLKvbdmbKXYPOV +DncKjvbdrpWPJcVf +EOcKjvbdURROuUgm +DnbkKvbdrovOicWG +EObjjvbdLYpirzuG +DnbjjvbdGQASvgGZ +DnbkKvbdYzcFqjVy +DncKjvbdBsBCtFvr +DoDLKvbdYgXEAOri +EOcLKvbdqTsfqqjt +DncKjvbdPIAYZAYa +EOcLKvbdypnliJwA +DnbkKvbdhyuGLqNf +EOcLKvbdjhGkfGOL +DncKjvbdjblLRGuH +EPCjjvbdxwhibPyk +EOcKjvbdBhkCLIfK +DnbjjvbdJTZArlxM +DoCkKvbdRjxetgKs +EObkKvbdiUyeWrVC +EOcKjvbdwXLaWAuu +EPDLKvbdssSTZZdc +EObkKvbdcSbjtDia +DncKjvbdgGMZnHHA +DoCkKvbdatafwkUI +DncLKvbdnCKWxPNu +EObjjvbdyOShXrhc +EPCjjvbdpyPHfqEY +DoDKjvbdbUbGxKsh +EOcKjvbdypoNJKXA +EObkKvbdyTOJMrBg +DoDLKvbdiZtfLpmf +EPCkKvbdLGFgbBQu +EOcLKvbdCJLBkJFj +DnbkKvbdUxgszLPO +DoDKjvbdUQqPVVHm +EPCjjvbdijGIKNYS +EPDKjvbdCJKajhej +EPDLKvbduoTzqLPU +DnbjjvbdJTZBTMwl +EOcLKvbdLAjfmBwq +DoDLKvbdQwOECkhD +DoCjjvbdQYmAHTSK +DoDKjvbdEuyQQMjF +DoDKjvbdZdwfzhIb +EOcKjvbdyTOJNRag +DoDLKvbdbBVdfQPw +DoCkKvbdbVBfxLUI +DncKjvbdcIljKevx +EOcLKvbdhgKDZViu +EObjjvbdOTUWHEtp +DncKjvbdZRMeIldq +DnbjjvbdkHgMGGNk +EOcLKvbdZMSETmlN +EPCkKvbdjcMKpfuH +EPDLKvbdiBncFXQq +EObjjvbdJcKCqKDY +DoDKjvbdQwOEClID +EPCkKvbdRpUHJecw +DoDKjvbdZjSgogBf +DoCkKvbdEObkKvbd +DoDLKvbdDwwktUTl +DoCkKvbdSKyGVHKs +DnbkKvbdZMSETnMN +DncLKvbdiZuGLpmf +EObjjvbdjcLjpgVH +EOcLKvbdYzcFqjVy +EPCjjvbdQvnDcLhD +DoCkKvbdDihJvYKA +EPDLKvbdJqZeOenF +EOcKjvbdWXJXvDdg +DoCjjvbdznpQeCkx +EPCjjvbdjJehJmXr +DoDKjvbdmSYuZsDi +DoDKjvbdFVyPolie +DnbjjvbdULvPAvOi +DncKjvbdwzIGFwdr +DnbkKvbdOEcsiJKd +EPCkKvbdEJhJuwjA +EObkKvbdYSkaNUOx +EObkKvbddoFSkTtS +DoDLKvbdFkFTDHlu +DoCjjvbddwzTtRez +EOcLKvbdDwwlUTtM +DoDKjvbdHDjvJaij +EObkKvbdyTOIlrBg +EOcLKvbdtSqsYzFD +EObkKvbduVmwjQsA +EPDKjvbdbiMjKfXY +DncLKvbdsQWPKDWG +DncLKvbdRbEElIyL +DnbjjvbdGKeTDHlu +EPCkKvbdrpWOjDWG +EObjjvbdVwJYWEFH +EPCjjvbdvBDySoFI +EPCkKvbdZMSDsmkm +EObkKvbdqYnhHREY +EObjjvbdyqPMiJwA +DncLKvbdCTBCtGXS +EPCkKvbdfekynGgA +EPCkKvbdvvkaWBVu +DoCjjvbdGZUuAdYC +DoDKjvbdpyOgfqDx +EPCjjvbdePFTKstS +EOcLKvbdVviXudFH +EPCkKvbddZyQYZQb +DnbkKvbdUaCQrqRy +EPDLKvbdQwNdDMID +DncKjvbdUaCRTQrZ +DnbjjvbdHDkWJbKK +EOcKjvbdOTTvGduQ +DnbjjvbdssRrxzEc +EObjjvbdezuxdiTw +EOcLKvbdGLFTCgmV +EPDLKvbdUxgtZkOn +EOcLKvbdbrbjscia +DnbjjvbdjJfHimXr +EOcKjvbdjcMLQgUg +DoDKjvbdlYrqrxft +EPDKjvbdGYttaEXb +EOcLKvbdhbPDEwQq +EOcKjvbdvAcxroEh +DoDKjvbdVgxVxHYz +DoCkKvbdTqQnuVIN +DoCjjvbdrXQMCiZR +EOcKjvbdMSWlytpz +DoCjjvbdBiLCLJFj +EObkKvbdUyHtZkPO +DoDLKvbdGcjujCJj +EPCjjvbdfkGzbfAE +DoCjjvbdDoCjjwDE +DnbkKvbdqGDdsvAh +DoDLKvbdjvXNdBww +EOcKjvbdANHySvyx +DoCjjvbdeJjRvUzn +DncKjvbdqUTgRqkU +DncLKvbdEvZQPljF +DnbjjvbdSPsgKFdX +EOcKjvbdGLFScHmV +EPCjjvbdqUTgRqkU +EPCkKvbdNxOuzdOU +DoCkKvbdpfEEtWBI +EOcLKvbdDwwlTtTl +EPCjjvbdSZjITDWA +DncKjvbdQwNcblID +DnbjjvbdijGIKMwr +DnbjjvbdYpldiMdq +DncLKvbdemGXHNKL +EPCkKvbdEKHjWYKA +DoDLKvbdwXMBWAvV +DnbjjvbdQwOEClHc +DnbkKvbdbUbHYKtI +DncLKvbdCSaCtFvr +DncLKvbdEuyPpNJe +EPDKjvbdFVyPolie +DncKjvbddneSkTtS +EOcKjvbdZtJIxcsO +EOcKjvbdiGicZWJu +DncLKvbdOFDtIiLE +DoDLKvbdOSsufduQ +DnbkKvbdMfcPmQVL +EObjjvbdiUzEwSVC +DoCkKvbdCIkBkJFj +DncLKvbdYkrETmlN +EObjjvbdqZOggREY +EPCkKvbdHDkViajK +DnbkKvbdbsDLTdKB +EPDLKvbdlqxtzTDi +DncKjvbdLGFgbAqV +EObjjvbdoAKztHcn +EPDLKvbdRXODblID +DoCjjvbdIHGzYwxH +EObkKvbdNPwqVnHT +EOcKjvbdxrnImRag +EOcLKvbdiLddNuCy +DoCkKvbdkMakzEfo +EObkKvbdnPyxukYb +EPCjjvbdZdwfzgiC +EPCkKvbdnHEwmNfy +EObjjvbdySmiNRag +EOcKjvbdzeZnzdyp +EPCjjvbdJvVFdEgJ +EOcKjvbdZQldiMeR +EOcKjvbdFyVVAdYC +DncKjvbdJXsahMRQ +DnbjjvbdfNGXGljL +EOcLKvbdwWlAvAvV +DncLKvbdkIHLefNk +DncLKvbdliDtQtrB +DoCkKvbdxZgefXdr +DncKjvbdCWzchdpW +EPCkKvbdpyPHfpdY +EOcKjvbdhbOcFWqR +DnbjjvbdzjUpPdSt +DoDLKvbdZMRdUOLm +DncLKvbdVwJXucdg +EPCjjvbdWXIxVcdg +DnbkKvbdMpXpvOHT +DncLKvbdRkZGVHKs +DoDKjvbdmpZyWKxb +DoCjjvbdegkWRmpg +DncLKvbdyzeOSHhh +EPDLKvbdRECaPpdS +EPDKjvbdqvpLcJZR +DoCjjvbdRDbaPqDr +EObjjvbdRECaPqDr +EOcLKvbdsBfNLgLZ +DncKjvbdZyEKOCkr +DnbkKvbdSPsgJfEX +EPDKjvbdZRMdiMeR +EPDLKvbdDwwktTsl +EPDLKvbdLhbLpxAS +EPDKjvbdZirgpHBf +DoCkKvbdmtuZkJqf +DnbjjvbdwWkaWAuu +DnbjjvbdRDcBPqES +DnbkKvbdyzeNqgiI +EObjjvbdYkrEUOLm +DoCkKvbdmtuZkKRf +DoCkKvbdNdctIhkE +DnbjjvbdhytfLqOG +EOcLKvbddZyPwxpb +EPCjjvbdYzbeqivZ +EOcKjvbdwygfGXeS +EOcLKvbdRosfifEX +EPCkKvbdznopdbkx +EObkKvbdVBBqSqSZ +EObjjvbdQlxCZNtz +EPCkKvbdhlFDmtby +DoDLKvbdCDpAvJmG +EPDKjvbddeOrCXDK +EOcLKvbdrovOjDWG +DnbkKvbdIGfyyYYH +EObkKvbdmbKWwnmu +EOcLKvbdkDLjqGuH +EPDLKvbdqrUkNjaN +EPDKjvbduDDVXWPP +EObjjvbdZnnJFEzK +DnbjjvbdaRfCgtGL +DoCkKvbdGKdsDHlu +DncKjvbdqlyiyMHi +DoDLKvbdSLYetgLT +DnbkKvbdZQleJNEq +EOcLKvbdZLrETnMN +DnbjjvbdiUydwRuC +EObjjvbdnPzYvLYb +EPCjjvbdGYuUaEYC +EObjjvbdACqwiyiQ +DncKjvbdIHGzZYXg +DncKjvbdxrnIlqag +DnbjjvbdySmhlqag +DoCjjvbdSCEFMJZL +EObjjvbdSKxfUfjs +DnbjjvbdnUtyjjRf +DncLKvbdkyTRsZGt +DoDLKvbdWRnXbElD +EOcKjvbdjvXNcbYX +EOcKjvbddjKSWUzn +DoDKjvbdvBDxrneI +EOcLKvbddndsKtTr +DoDLKvbdZjTHpGbG +DnbkKvbdpfDdsuaI +EPCkKvbdfMfWgNJk +DoCkKvbdjJegjNXr +DoDKjvbdcTDLTdKB +EPDLKvbdwzHfFxEr +DncKjvbdfMfWgMik +DnbkKvbdrbFllGkZ +EPCkKvbdCIkCLJGK +EObjjvbduDDUvvOo +EOcKjvbdDxYMUTsl +EOcLKvbdsPvOibuf +DncKjvbdUsltGLvK +EPCjjvbdyOShYTIc +DoDKjvbduaEZSoEh +DncKjvbdLrXMzUpz +DoCkKvbdNsTufeUp +EObkKvbdLGGIBaQu +EPCjjvbdmSZVZsEJ +DncLKvbdQdDAoqDr +DoCkKvbdKCicRJbx +EPCkKvbdxwhibQZk +DoDKjvbdTvMQJsaR +DoCkKvbdYzcGSJuy +DnbkKvbdwyhGFwdr +DoCjjvbdEOcLKwDE +DoCkKvbdGGKRmhtR +EOcLKvbdrzMQTAgn +DoDLKvbdJvVFceHJ +DnbkKvbdfMfWfmJk +EPCkKvbdmajWwnmu +EPCjjvbdxrmiMqag +EOcKjvbdqUTfqqkU +EObkKvbdoAKztHcn +EObkKvbdkyTSTZHU +EPCjjvbdiCOcEwRR +DnbkKvbdGZUtaDwb +EPCjjvbdYORAXuWU +DoCkKvbdULvPAuoJ +DnbjjvbdcSbjscjB +DoDKjvbdLrXMytpz +DncKjvbdIryBTNYM +DoCjjvbdZyDinCkr +EPDLKvbdZoOJFEyj +DncLKvbdajkfOmcA +EPDLKvbdRNYCYmtz +DoCkKvbddePRawDK +EOcKjvbdbUbHYKtI +EPCjjvbdbrbjscjB +EPDKjvbdKDJcRKCx +EObjjvbdqcdiQOVa +EPDKjvbdZjTIPgBf +DnbjjvbdrSUjmjaN +DnbjjvbdEXxLsstM +EPCkKvbdFjeSbglu +DnbkKvbdLqwMytpz +DoDKjvbdUGznMXVe +EObkKvbdpstHRrLU +DoDKjvbdYTLaNUPY +DnbkKvbdGKdrbhNV +EObjjvbdRMxCZNtz +DncLKvbdDihJuwjA +EPCjjvbdOFDtJIkE +DnbkKvbdliEUQuSB +DoDKjvbdkCkkQftg +EPCkKvbdGZVVAcwb +EObjjvbdkyTSSxgU +EPDKjvbdIryBSlxM +EOcKjvbdWIXvXfxz +DoDLKvbdhfjCyWKV +DoDKjvbdNQXpumfs +DncKjvbdiMEcnVCy +EPDLKvbdxVMeRZLn +EPCkKvbdDoDKjwDE +DnbkKvbdSCEFLiZL +DoCjjvbdqYoHgQcx +EObjjvbdxZhFexFS +EOcLKvbdkDMLRGuH +EPCkKvbdVwJXvDdg +DoCjjvbdjhHLefOL +EOcLKvbdiCOcFWpq +DnbjjvbdrovOjCvG +DncLKvbdRzKHsCvA +EPCkKvbdDoDLKwDE +EOcKjvbdrNZjZLhJ +EObjjvbdTAFIhBoE +DncKjvbdlqyVZsDi +DncLKvbdjggMFenL +EPDLKvbdUsltGMWK +DoCjjvbdkyTRsZGt +EOcLKvbdrzMPsBHn +EPCkKvbddZxpYYpb +DncLKvbdGKdsCgmV +DnbkKvbdvAdYsPEh +DoDLKvbdqUUGrSKt +EPCjjvbdxnTHxTIc +EOcKjvbdZisIQGaf +DncLKvbdBhjbLJFj +DoCkKvbdJSyBTNYM +DnbjjvbdmfdwlmgZ +EOcLKvbdJcJcRJbx +DncLKvbdmoyyWLYb +EObjjvbdSKxfUfkT +EObjjvbdlAlnmALA +DoDLKvbdTlVnaVoJ +EOcKjvbdnCKWwnnV +EPCjjvbdjbkkRGtg +EPCjjvbdULuoBVoJ +EPDKjvbdwMvAMceN +DnbkKvbdznopdcLx +EPCkKvbdeuzwoizs +EPCjjvbdpssfrRjt +EOcKjvbdiGibyWJu +DnbkKvbdYSlBNToY +EPDKjvbdkVwNcbYX +DoCjjvbdsPuoJcVf +DnbkKvbdrbGNLgLZ +DnbkKvbdRbEFMJYk +EObjjvbdqceIonVa +DnbkKvbdTpqPUuHm +EOcLKvbdVviXvEEg +EOcLKvbdvAcxrndh +DnbjjvbdTYKkmzkY +EOcLKvbduDCuXVno +EPCkKvbdEvYpPlie +DncLKvbdaSGCgtFk +DoCjjvbdpfDdtWBI +DncLKvbdHDkWJbJj +DncLKvbdqZOgfpdY +EPCkKvbdFxuVBEXb +DoDKjvbdnBivwnnV +EPCkKvbdRWmcbkhD +EObjjvbdfIKvSOQg +DnbkKvbdcIlikGWx +EOcKjvbdQdDBQQdS +EPCjjvbdnPzZWKyC +DnbkKvbdZxcimbkr +DncLKvbdLFfHaaRV +DoCjjvbdYSlBNToY +DnbjjvbdKCicRKDY +EPCkKvbddneSjtUS +EObjjvbdmIctRUqa +DncKjvbdYqMdiNFR +DnbjjvbduaDyTPFI +EPCkKvbdePEsLTtS +EPCkKvbdbUagYKsh +DoDLKvbdssSSxzFD +EObkKvbdMuSrLNAX +EPDLKvbdddnqbWbj +DnbkKvbdvAcySneI +EPDKjvbdatbGxLUI +EOcLKvbddePRbWbj +DoDLKvbdijGIKNYS +EPCjjvbdNrsugEtp +EOcLKvbdxZhGGYEr +DnbkKvbdTkvPAvPJ +DoCjjvbdFyUuAcwb +DnbjjvbdJTZBTMxM +EPDLKvbdaMkCStmH +EPDLKvbdjKGHimYS +DnbkKvbdelewGlik +EObjjvbdkHgMGGOL +EObkKvbdURRPUuHm +EOcLKvbdjKFhKNYS +EPDLKvbdhyuFkpnG +EOcLKvbdRosgJecw +DoCjjvbdczYoxYqC +DncLKvbdzaAPGgCM +EPDKjvbdiUzEwSUb +DoCjjvbdKQzEneme +EObjjvbdatagXkTh +DoCjjvbdwtldqYkn +EOcKjvbdUxgszLOn +EPCkKvbdUaBprprZ +EOcLKvbdYNqAYVVt +EObjjvbdbUafwkTh +EPDLKvbdcIljLGWx +DnbjjvbdNHDPlotk +EOcLKvbdkIHMFfOL +EPDKjvbddePSCXDK +EOcLKvbdbUafxLTh +DoDKjvbdQlwaxmtz +DoCkKvbdbQHHELzd +EPDLKvbdhficZWKV +DoDKjvbdqrVLOLAm +DoCjjvbduDDUvvPP +EPCjjvbdCEQAuilf +EOcLKvbdEASIlywX +DncLKvbdRNXayNtz +EOcKjvbdVrOXaeMD +EPCjjvbdFWYopNKF +DnbkKvbdSQTfjFcw +DoDLKvbdJTZAsMwl +DoCjjvbdiCPDEvpq +DncKjvbdVwIwuceH +EPDLKvbdJvVFcdfi +EPCjjvbdcbSlrATm +DnbjjvbdqBJFAXIE +EPCkKvbdTAFJHbOd +EPCjjvbdcTCkUEKB +EPCkKvbdxwhibPzL +EPCkKvbdRpTfifEX +EPDLKvbdvAdYsOeI +DncKjvbdpxngfpdY +EPCjjvbdEXwksstM +DnbkKvbdNrsufeUp +DnbkKvbdJKEAJogE +DoCkKvbdNsUWGduQ +DoCkKvbdbrcLTcjB +EOcKjvbdiHJcZViu +EObkKvbdEztQdkcJ +DoCjjvbdliETptqa +EOcLKvbdOEdUIhjd +DoCkKvbdSKxfVGkT +EPCjjvbdIsZAsMxM +EOcKjvbdZsiIyDsO +DncLKvbduDCtwWOo +DnbkKvbdEztQdlCi +DnbjjvbdLZQjSztf +DoDLKvbdXmqAXuVt +EPCjjvbdxsOJNSCH +DoDLKvbdRadElJZL +EOcLKvbdWRnXbEkc +DncKjvbdSCEFLiYk +EPDLKvbdidkHVPAO +DoCjjvbdkClKqGtg +EPDKjvbduLxXBUAw +DncLKvbdqUTfqqkU +EObjjvbdcImKKevx +DoDLKvbdMgCpMpVL +DnbjjvbdtTRsYydc +DnbkKvbdKefHbBQu +EOcKjvbduoTzpjnt +DoCjjvbdjuwNcaww +DncKjvbdTkvPBVni +EPDLKvbdapGfdLzd +EPDKjvbdvAdZTPEh +EPCkKvbdwXLaVaWV +EOcKjvbdZoNhddyj +DncKjvbdqceIonVa +DnbjjvbdIwsbHkqQ +DoDKjvbdjFKfuPAO +EOcLKvbdbhmJkFvx +DncKjvbdDxYMUUTl +DnbjjvbdMfbpNQVL +DoDLKvbdZeXfzhIb +EOcLKvbdVAbRSpqy +DncLKvbdZxcjOCkr +EOcKjvbdyTNiNSCH +EObkKvbdiLddOUcZ +DoCjjvbddwystRez +DoDKjvbdUsmTelWK +EPDLKvbdEPCjkWcE +DoDKjvbdIwsaglQp +EObkKvbdGcjvJbKK +DoCkKvbdRzJgrbvA +EObkKvbdkxsSSxft +DncLKvbdfHjvSNpg +DnbkKvbdxsNiMqag +DoDLKvbdcImKKevx +EOcLKvbdJutfDdgJ +DoDLKvbdhancEwRR +EObkKvbdnPzYvKyC +DoDKjvbdNHDPlouL +EPCkKvbdKaKgMbXq +EOcLKvbdqUTgSRkU +EPCkKvbdZjSgpHBf +DncLKvbdHffzYxXg +DoCkKvbdFkErbhMu +EObjjvbdhancEwQq +EPDKjvbdJYUCHkpp +EPDKjvbdtkwwBUAw +EOcLKvbdiZuGMRNf +EObkKvbdrJAKElne +DnbjjvbdIHHZxwwg +EPDKjvbdkHgMGGNk +DoCjjvbdeOeSjtUS +DoDLKvbdJbicQjCx +DncKjvbdnGeXlnGy +EPDKjvbdKVtecdfi +EOcKjvbdULuoBVni +DnbkKvbdmJDtRVRa +DncLKvbdJTZAsMxM +EPDKjvbdVgxVxHYz +EPCjjvbdVBCRSqSZ +EPCjjvbdJqZdnfOF +DncKjvbdqdEiQOVa +DnbkKvbdZLqdTnLm +EOcKjvbdzHZMANFX +DncKjvbdVrNxBdkc +DnbjjvbdKkAgvAKZ +DnbjjvbdmbKWxOnV +DoDKjvbdYqMeImEq +EObjjvbdbUagYKtI +DncKjvbdQZNAHSqj +DoDLKvbdfoazvcwh +DnbkKvbdVvhwvDdg +DoDKjvbdURQoUthN +EPDLKvbdvBDyTOeI +DnbjjvbdrRuKmkBN +DnbkKvbdRbDdlIxk +EObjjvbdSCDdkhyL +DoDKjvbdSBceMJYk +DoDLKvbdwyhGGYFS +EPDKjvbdQvmcblID +DoDLKvbdaaWFGQQX +DoDKjvbdEASImZvw +EPDLKvbdnQZyWLYb +EPDKjvbdbrcLUEJa +EOcLKvbdKCicQjDY +EPCjjvbdVBCQsQqy +EPCkKvbdkaNPNALA +DncLKvbdaNKartmH +DoDLKvbdCTAbtFvr +EObjjvbddZxowxpb +EObkKvbdTpqOuUgm +DncLKvbdZQleJNFR +DnbjjvbdUVlPisaR +EObjjvbdBsBCtFvr +EPCjjvbdJutecdgJ +EOcKjvbdfNFvgNKL +DncKjvbddneSjtUS +DoDKjvbdjcMKqGtg +EOcLKvbdGdLWKCKK +EOcKjvbdRDcBPpdS +DoCkKvbdauCGwkTh +EPCjjvbdaNLCStmH +EOcKjvbdelfWgMjL +DoDLKvbdtSrSxyeD +EPCjjvbdemGXGmKL +EOcLKvbduDCuXWOo +DncKjvbdauBfxLUI +DnbjjvbdIHGyyXwg +EPCjjvbdEvYooljF +EObjjvbddneTLUTr +DoCjjvbdySmiNRag +DoDKjvbdqUUHSRjt +EObjjvbdczYpXxpb +EObkKvbdaMkBrtlg +EPDLKvbdnUuZkKRf +DoDKjvbdcScKsdJa +EPCjjvbdsrrTYydc +EObjjvbdZoNiFEyj +EPDLKvbdmttyjirG +EOcLKvbdYqMeIleR +DoDKjvbdKWUfEFGi +EOcLKvbdcyxoxYqC +EObkKvbdNeETiJLE +EPCkKvbdUMWOaVoJ +EPCjjvbdWSOXbElD +EPCkKvbdNHCpNPuL +EObkKvbdEuyQQNJe +DoCkKvbdmgExNOGy +EOcKjvbdZtJJYcsO +EOcLKvbdMpXqVnGs +EObjjvbdbsDLTcjB +EPCjjvbddoFTLUTr +EOcLKvbdaNKbTVNH +DoCjjvbdJcKCpicY +DoDLKvbdsBfMlGjy +EPDKjvbdqiAJdlne +EObkKvbdKefHaaRV +DoDLKvbdbiNJjewY +EPCkKvbdVTltFlWK +DoDLKvbdbBWFGPpX +DncLKvbdVZITzKoO +EPCjjvbdnUtzLKSG +EPCkKvbdBraDTevr +EPDLKvbdTkunaWPJ +EObjjvbdZRNFJNEq +DnbkKvbdxUldqYkn +EPDLKvbdtvOYJpsA +EOcLKvbdJvUfEEgJ +DoDKjvbdlYrqsZGt +DncKjvbdePFSjstS +EPDLKvbdqquLOLAm +DoCkKvbdSPtHKFdX +DoCjjvbdZyDjNcMS +EPDKjvbdTlVnaWPJ +EPCjjvbdZirgpHCG +EObkKvbdNQYQvNfs +DncKjvbdqqtjnLBN +DoDKjvbdjJehJmYS +DncLKvbdrNZixlHi +EPDLKvbdMfcPlpVL +EPCjjvbdUWMQJtBR +DoCkKvbdfMfWfljL +DnbjjvbdaRfDHtFk +DncLKvbdiMFDnVDZ +DoCkKvbdXrkaNToY +DoCjjvbdZLqdUNlN +EObkKvbdRjxetfkT +EOcLKvbdmgFXmOGy +EPDKjvbdUQpntuHm +DoDKjvbdpstHRrKt +DncLKvbdHkazmwRL +EObjjvbdpfEFUWAh +DoDKjvbdZyEJnDMS +EObkKvbdiBoCeXQq +DoCkKvbdeATplxKG +DncLKvbdWRmwadkc +EPDKjvbdUQqPUthN +DoCjjvbdnBjXXnmu +EPDLKvbdZjTIPfbG +EPCkKvbdWHwuxGxz +DncKjvbdYpmFJMdq +DoDKjvbdhbPDFXRR +DnbkKvbdBdQBVimG +DoCjjvbdmIctRUqa +EPDKjvbdZyDjNbkr +EOcLKvbdQYmAHSrK +DnbjjvbdqYoHgQcx +DncKjvbdqiAKFMoF +DncKjvbdOTUWHEuQ +DoCjjvbdVTmTfLuj +DoCkKvbdddoRbWcK +EPDKjvbdIsYaTNYM +EObkKvbdRosfiedX +EOcKjvbdcTDLUEKB +EOcLKvbdmozYujxb +DnbjjvbdZirgogBf +EPCjjvbdKWUeceHJ +DnbjjvbdZoOJEdzK +EPDKjvbdEJhKVwjA +DoCkKvbdfpBzvcxI +DoDKjvbdlrYtysDi +DoDLKvbdZjSgofbG +DoCjjvbdUtMtGMVj +EPCjjvbdGGKRmiTq +EPCkKvbdQvnDcMID +DnbkKvbdKCjCqJbx +EPCkKvbdYpleImEq +DoDLKvbdjKFgjNXr +DoDLKvbdZshhxcrn +EPDLKvbdnVVZjjRf +EOcKjvbdqdFIpNua +DnbjjvbdVwIxVdEg +DoCkKvbduaEZSneI +DnbkKvbdznoqFClY +DoCjjvbdoAKzsgcn +EOcKjvbdSLZGVGkT +DncKjvbdiCObeWqR +EPCjjvbdWRnXbEkc +EObjjvbdRotGiecw +EObkKvbdKDKDQibx +DnbjjvbdlYsRsYft +EOcKjvbdUaBqSprZ +DoCjjvbdhkdcmuDZ +EOcKjvbdjgflFfNk +DoCjjvbdGKdrcINV +EOcLKvbdEJgjVxKA +EObkKvbdSxKkmzkY +DnbjjvbdsZkosBIO +DoCjjvbdBvzchePv +EObkKvbdGYtuBEXb +EPDKjvbdiLeENtby +EPCkKvbdRNXbYnUz +EObjjvbdfHkWRnQg +EObkKvbduDDVXWOo +DoCkKvbdJbjCqJbx +EPDLKvbdpedFTvBI +DncLKvbdjJegjMwr +EPCjjvbdUxgszLPO +EObkKvbdxmrhXsJD +EOcKjvbdJSxaSmXl +EPDLKvbdfNFwGmJk +EPDKjvbdsrrTYydc +DncKjvbdhgKDZVjV +EPCkKvbdZMRctNkm +DoDKjvbdezuyEhtX +EPCkKvbdEXwlUTsl +EPDLKvbdeAUQlxKG +DoDKjvbdZnmiEdyj +EObkKvbdrzMPraIO +EPCjjvbdxxIibPyk +EPCkKvbdKfFgbBRV +DoDKjvbdyzeORhIh +DnbkKvbdbAvFGPpX +DncKjvbdZoOJEdyj +DnbkKvbdrJAJdmOe +DoDKjvbdKVuFdEfi +EOcKjvbdqdFJQNvB +EPDLKvbdOEctIhkE +EPDLKvbdvBEYsOeI +DncKjvbdHELVjBjK +DncLKvbdZshhyDsO +EPDKjvbdGdKuibJj +DoCkKvbdEYXkstUM +DnbjjvbdJpyeOfNe +EPDKjvbdzoPpdbkx +DoCkKvbdMSXMytpz +DncLKvbdqZOggQcx +DoDKjvbdmuUyjirG +DnbkKvbdNVSqkNAX +DncLKvbdRotHJfEX +EOcKjvbdZyEJnCkr +EPDLKvbdyYJKBpZk +DnbkKvbdxmrgxTJD +DnbkKvbdhaoDFWqR +DncKjvbdbhmJjevx +EObjjvbdSKyGVGjs +DnbjjvbdSKxfVHKs +DnbjjvbdqdFIomua +DnbkKvbdkHflGGOL +DoDLKvbdqGDeUVaI +EObjjvbdjmBlZeHP +EPCkKvbdmttykJrG +DncLKvbdRXOEDLgc +DoDLKvbdhaoDFWqR +DoDKjvbdvvkaWAuu +DoCkKvbdbhmKKfWx +EObjjvbdSBdFMJZL +DnbjjvbdnUuZjjSG +EPDLKvbdliDtQuSB +EOcLKvbdsCFmMGjy +DnbjjvbdtunXjQsA +EObkKvbdkCkjqHUg +EObjjvbdDoCkKvbd +DnbkKvbdiZuFlROG +EOcKjvbdRNYCZNtz +EOcLKvbdxUmEpxlO +EPCkKvbddePSBwDK +EOcLKvbdauBfxKsh +DoCjjvbdtkwwBTaX +EObjjvbdmgEwmNfy +DnbjjvbdOStWHEuQ +EPCkKvbdGLFTChNV +EPCkKvbdKDJbpjDY +DoDLKvbdnPzZVjxb +DoCjjvbdFVyPomJe +DncLKvbdACqwizIp +EPCkKvbdZirhQGaf +DncKjvbdtTRsZZeD +EObkKvbdLBLHMbYR +EOcLKvbdrNZjZLgi +EObjjvbdTXkLmzkY +EPCkKvbdBsAbsfXS +EOcKjvbdeATpmXif +DoCkKvbdMSWmZuQz +DncLKvbdVTmTfMVj +DoDLKvbdZxdKODMS +EPDKjvbdZjShPgCG +EPDLKvbdxVMdpxkn +EPDLKvbdcSbjsdKB +EPDLKvbdiifIJlwr +DoDKjvbdKQydoFnF +EObkKvbdegkWRmpg +EObkKvbdiBncFXQq +DoDLKvbdNdctJJLE +EOcKjvbdUyHszKnn +EOcLKvbdSQUHKFcw +EObkKvbdUaBqSprZ +DoCkKvbdSCDeLiZL +EPCkKvbdKDKCpjCx +EPDLKvbdwygfFweS +DoDKjvbdiVZeWqtb +DoCjjvbdMRwMyuQz +DoCjjvbdsCGNLfkZ +DoCkKvbdmRxuZsEJ +EPCkKvbdkDMLRGtg +EObkKvbdGdKuibJj +EPCkKvbdePFTLUTr +EOcKjvbdXrlAlsoY +DoDLKvbdZjTHogBf +DnbjjvbdZirhQGaf +EPCkKvbdFVxooljF +DoCkKvbdbKkeoNcA +DoDKjvbdqYngfqEY +EPDLKvbdrWokcJYq +DoCkKvbdMowqVnHT +EPCkKvbdqqtjnKaN +DoDLKvbdiCPDFWqR +DoDLKvbdeJiqutzn +EObkKvbdqcdiPmvB +EPCjjvbdMgComQUk +DoDLKvbduVnYKQsA +DnbjjvbdjhHLfFmk +EOcKjvbdVvhwvEEg +DnbkKvbdZtIhyESn +DncLKvbdznopeClY +EPCkKvbdwtldqZLn +EOcKjvbdeEnrBwDK +DoCkKvbdkxrqsZHU +DoDKjvbdijGHimYS +DncLKvbdfNGWgMjL +EOcKjvbdmbKWxOnV +EPCkKvbdhtzEvrVC +DoDLKvbdhfibyWJu +DoCkKvbdXrkaMsoY +DoCkKvbdzoPpdbkx +EPDLKvbdSLYeuGjs +EOcLKvbdqlyixlIJ +EObjjvbdnVVZjiqf +EOcLKvbdyNrhXriD +DoCjjvbdRjyFtgLT +EOcLKvbdkyTRryHU +EPCjjvbdrykpTBIO +EObjjvbdlqxtzSdJ +EObjjvbdcarmSATm +EOcKjvbdXsLaNToY +EOcKjvbdlqxtysDi +EOcLKvbdaMkCStmH +DncKjvbdbAvFGPow +EPDLKvbdTulQKTaR +DncKjvbdXGYzUAOs +DncKjvbdezuxeItX +DnbkKvbdrykpTBIO +DoCkKvbdxnShXsIc +DoDLKvbdEPCjkXCd +DnbkKvbdIxUBgkpp +DnbkKvbdBiKbKhfK +DoDKjvbdKNADygVB +EObjjvbdADRxKZiQ +EPCjjvbdMfcQMotk +EObjjvbdSBcdkhxk +EPDKjvbdNrtVgFVQ +EPDKjvbdZMRdTnLm +EObkKvbdehKvRnQg +DoCkKvbdliETptqa +DoDLKvbdEXwktUUM +EObjjvbdBiLBjiFj +EOcLKvbdRkYeuGjs +EOcKjvbdmttzKjRf +EObkKvbdxrmhmRbH +DnbkKvbdyXiJaoyk +EObkKvbdxmrgwsIc +DoDLKvbdiZtfMQmf +DnbkKvbdpxoHfpcx +EObjjvbduaEZTOdh +EObkKvbdqqtkNkAm +DoDKjvbdxmrgxTIc +DncLKvbdMgColpVL +EPCkKvbdZnnJEeZj +EPCjjvbdVYgszKoO +EPCkKvbdBcpAuilf +EObkKvbdlhdUQuSB +EObkKvbdMIbLpxAS +EPCjjvbdnVUyjirG +DoDKjvbdKRZeOenF +DnbjjvbduCbuXWPP +DnbjjvbdssRsYydc +EPCkKvbdlhctQtqa +DoCkKvbdsQVoJcVf +EObjjvbdegkWSNpg +DoDLKvbdOAJTUKSA +DoDLKvbdliEURVSB +DoDKjvbdxsNhlqbH +DnbjjvbdOSsvGdtp +EPDKjvbdaaVeGPow +EObjjvbdNeETiIjd +DnbkKvbdJKEAJpHE +EPCjjvbdANIYsWzY +DoCjjvbdjvWmdCXw +EPDKjvbdrouoJcVf +DnbjjvbdiUzFWquC +DnbjjvbdFxtuBEYC +DnbjjvbdRkYfVHLT +EObjjvbdQwNccMID +DoCjjvbdXsMAmTnx +DoCjjvbdjJfIKMxS +EOcLKvbdbiMikGXY +DoCjjvbdQdDAoqES +EPCkKvbdVwIxVcdg +EOcLKvbdCEQAvKMf +EPDLKvbdzROmJKXA +EPDLKvbdZLrDsnLm +DncKjvbdjggMGFmk +DnbkKvbdddnrBvcK +DnbjjvbdpecdsvBI +EPCkKvbdijFgjNYS +EOcLKvbdUaBqTQqy +DncKjvbdkHgMFfNk +EObkKvbdZGvdAPSi +DnbjjvbdqUTgSRjt +DoDLKvbdqvpLcIyR +DncLKvbdLqvlytpz +DnbkKvbdKDJbpjCx +DoCjjvbdlqyUyrci +DnbkKvbdUQqPUuIN +EObkKvbdTlVnaVni +EOcLKvbdNdcshiLE +EObkKvbdkDMLRHUg +DncKjvbdIxTbILpp +EPCkKvbdePFTKssr +DnbjjvbddeOrCWcK +DnbkKvbdatbGxLTh +EObkKvbdqlzKZLgi +EPCjjvbdOTUVgFUp +EOcLKvbdpfEFTvAh +DncLKvbdZnnIdeZj +EObkKvbdZxdKODLr +DoDKjvbdjggLfGNk +EPCjjvbdRDcAopdS +DncKjvbdlZTRryHU +DncKjvbdZshiYdSn +EPDKjvbdatbHYLTh +EPDKjvbdLAjfmCXq +EPDKjvbdOFEUIiLE +DncKjvbdxVNFQxlO +DoCjjvbdrafNLfkZ +DoCjjvbdGFiqnJTq +EPCkKvbdUsmUFlWK +EObkKvbdLBLHMbXq +EPCkKvbdtlYWaUBX +EPCjjvbdSPsfjGEX +EObjjvbdIjEAJogE +DoDLKvbdNHCpNQUk +DncLKvbdYkqdUNkm +DoCjjvbdqquKmkBN +DnbjjvbdEuyQQMjF +EOcKjvbdURRPUthN +EObjjvbdmoyxvLYb +EObkKvbdGYtuAdYC +DnbjjvbdZeYGzhJC +DoDLKvbdCgLfHAzc +DoDLKvbdhuZeXSUb +DoCkKvbdjlbMZdgP +DoCkKvbdemGWgMjL +EPCkKvbdxxJJaoyk +EPDLKvbdqGEEsuaI +EObkKvbdEKHjVwjA +EOcKjvbdiBoDFWpq +EPCkKvbdffLzNfgA +EObjjvbdDoCjkXDE +EPDKjvbdhficZWJu +DoCjjvbdWWiYVdFH +EPCkKvbdKQzFOenF +DoCkKvbdmbJvxPOV +DnbkKvbdtAHQhAAr +EPDLKvbdmSYtzSci +EPDLKvbddeOqavcK +DoCjjvbdCEQBVjMf +EPDLKvbdlYrqsYft +DnbkKvbdJSyBTNXl +EPCjjvbdcbSmSATm +DoDKjvbdfNFwGmJk +DoCkKvbdGLErbhNV +EObkKvbdiZuFlQnG +DnbjjvbdxUmEpxlO +EPDKjvbdUWMPitBR +EPDKjvbdrafNLfjy +EPDLKvbdrWolDJZR +EObjjvbdhbPDFXQq +DncLKvbdqrUkNjaN +DnbkKvbdBiLCKhej +DoDKjvbdSCEFMIxk +DoDLKvbdffLzNgHA +EPCkKvbdZLqcsmkm +DnbkKvbdZMSEUOMN +DnbjjvbdzaAPHHCM +DnbjjvbdCIkBjhfK +DoCkKvbdZirgpHBf +DnbjjvbdIwtBhLpp +EObkKvbdeOeTLUTr +EObkKvbdUxgszLPO +EObkKvbdhzVGLqOG +DnbjjvbdOTTufdtp +EOcKjvbdZRNEhleR +EPCjjvbdKyRKSzuG +DoCkKvbdZtJJYcsO +EOcLKvbdemGXGmKL +EPDKjvbdJXsahMQp +DoDLKvbdhbObeWqR +EObjjvbdFVxpPljF +EOcKjvbdaNLBruMg +DoCjjvbdpyPIGpcx +EOcLKvbdZMRcsmkm +EOcLKvbdnGeXmNgZ +DoDLKvbdjlalZeGo +DoDLKvbdaSGDHtGL +EPCkKvbdCTAbsewS +EPCjjvbdZjSgofbG +DnbjjvbdJutecdfi +EPCkKvbdIryBSmYM +DoCjjvbdfekzOHHA +DnbkKvbdREDAoqES +EPCjjvbdtTSTYzEc +EPCkKvbdmoyyVkYb +EObkKvbdmfdxMnGy +DoCkKvbdwuNFQxkn +DncKjvbdsBelkfjy +EPDLKvbdQvmdDLhD +EPDKjvbdBhkCLJFj +DoCkKvbdeJiqutzn +EOcLKvbdqTsfrSKt +DoDLKvbdakLfOmcA +DncKjvbdKaLHMawq +EPCkKvbdznopdcMY +DoDKjvbdZtJIyDsO +DoDLKvbdsQVnjCvG +DncKjvbduDDUvuno +DoCkKvbdJYUCHlQp +DnbkKvbdnBiwYPNu +EObjjvbdlYrqryHU +EPCjjvbdqcdiPnWB +DoCjjvbdUQpoUthN +EPDKjvbdsZlQTAhO +EOcKjvbdtbbtwWOo +EPDLKvbdJuuGDdgJ +EOcKjvbdjggMGGOL +EPDLKvbdHffyxwxH +EOcLKvbdSCEElIxk +EObkKvbdIwsbHkqQ +EPDLKvbdjbkjqHUg +DnbjjvbdnQZxujxb +EPDKjvbddePRbWbj +DoCkKvbdhtydwRuC +DoDKjvbdCDoaWKMf +EOcKjvbdRjyGVGjs +EObjjvbddCTNSATm +EOcKjvbdZLrETmlN +EPDKjvbdlrZUysDi +EOcLKvbdwtmFRZMO +EPCjjvbdtTRrxydc +EObjjvbdeFPSBvcK +DoCkKvbdwuNFRZLn +DnbjjvbdhytfLpmf +EPCkKvbdrykpTAgn +EObkKvbdRDcApRDr +DoCjjvbdZnnIeFZj +EOcLKvbdePErkUTr +DoDLKvbdrbGNLgLZ +EObjjvbdVZIUZjoO +DncLKvbdzHYlAMeX +DnbkKvbdbsDLTcia +EPCjjvbdOSsufdtp +DncKjvbdpstHSSLU +DncKjvbduDDVWuoP +EPDKjvbdiMEdNuCy +EOcKjvbdtbcVWuno +DoDKjvbdqUTgRqjt +DncLKvbdZyDjNcLr +DoDLKvbdRWmdDLgc +DncKjvbdZLqdUOMN +DoDKjvbdijGIJlwr +EObjjvbduMYXBUAw +DoCkKvbdHDkWJajK +DoCjjvbdRpTfifEX +DoCjjvbdUyHszKnn +EPDKjvbdqZPIGpdY +EPDKjvbdRWmdCkhD +EObkKvbdsrrSyZdc +EOcKjvbdYlSDtNlN +DncKjvbdbKkennDA +EPCkKvbdiZuGMQmf +EPCkKvbdEztQeLbi +EPCkKvbdaRebgsfL +DoCkKvbdBcpAuilf +EOcKjvbdyNsIYShc +EPCjjvbdcIlijewY +DoCjjvbdmbKXXoOV +DncLKvbduDCtwWPP +EPDKjvbdnCJwXoOV +EPCjjvbdjcLkQgUg +DnbkKvbdtcCtwVno +DncKjvbdGFjRmiUR +DncLKvbdrWpLcJYq +DncLKvbdKWVGDdfi +EPCkKvbdnUuZkJrG +EPCjjvbdiCPCeWqR +DncKjvbdEYYMUUTl +EObjjvbdrpWOicWG +DoDKjvbdFejSOIsq +DnbjjvbdqiAJdmOe +EOcKjvbdUyITzKnn +DoDKjvbdfMfWgMjL +DnbkKvbdXrkaMtOx +DoCkKvbdKefIBaRV +EPCjjvbdyTNhlqbH +EPCjjvbdtlXwBUAw +EOcKjvbdRosfjFdX +DoCjjvbdYpldiMeR +DnbjjvbdwzIFexFS +DncKjvbdSCDeLhyL +DncLKvbdrzLpSaHn +DncKjvbduCcVWuoP +DoDLKvbdatagXkTh +DnbkKvbdsCGMlGkZ +EPCkKvbdkWXNdBww +DncKjvbdJcKCpjCx +EOcKjvbdNxPVzdNt +EPCkKvbdKRZeOfOF +DncLKvbdcIljLGXY +EPDLKvbdVhXuwfxz +DoCjjvbdaoffckzd +EOcKjvbdLhbLpxAS +DnbjjvbdnHExMmgZ +EObjjvbdbhljKfXY +DnbjjvbdkDLkRGuH +EPDLKvbdfHkWSORH +EObjjvbdzoPqFClY +DncKjvbdznopdbkx +EObjjvbdnUtzLKRf +EPCkKvbdZQldiMeR +DoDKjvbdFjeScHmV +EPDKjvbdEOcLKwCd +EPDKjvbdyqOmJKXA +EOcKjvbdSQTfiecw +DoDLKvbdDoDLLXDE +DoDKjvbdhlEcmuDZ +EObjjvbdfHkWRmqH +DnbkKvbdIGfzYwwg +DncLKvbdUWMPjUAq +EPDKjvbdkHflGGOL +DnbkKvbdnPzZVjyC +EPDLKvbdSBceLiYk +DncLKvbdUtMsfLvK +DnbkKvbdbrcLTdJa +EObkKvbdIwtCHkqQ +EPDKjvbdtbcVWvPP +EObkKvbdtbcVWuoP +DoDKjvbdKVtfEFGi +EPCjjvbdMRvlytpz +DoDLKvbdwuMeRYlO +EOcKjvbdlhdTqVRa +EPDKjvbdiGjCyVjV +DnbjjvbdrDeJQNua +DoDKjvbdrbFmMHKy +EOcKjvbdfHjurNpg +DnbkKvbdZRNFJMeR +EOcKjvbdqFdEsvBI +DnbjjvbdZirgogCG +DoDLKvbdDncKjwDE +DoCkKvbdjhGlFfOL +EObjjvbdmaivxOnV +EObkKvbdKkAhWAJy +EOcKjvbdNrtWHEuQ +DnbkKvbdFkFTChMu +EObkKvbdeOdrjstS +EOcKjvbdIwsbHlQp +DoCkKvbdeATpmXif +EOcLKvbdKaKgMaxR +EObkKvbdUGznLvvF +DnbkKvbdbLMGPODA +EObjjvbdTkvOaVoJ +EOcKjvbdsQVoKDVf +EPDKjvbdznopdcLx +DoDLKvbdpfDdsvAh +DncKjvbdrDdhpNua +EOcLKvbdhficZVjV +DncKjvbdFxuVBEYC +EPDKjvbdzjVQQETU +EObkKvbdKRZePGNe +EObjjvbdDncLLXDE +EOcLKvbdYkqctNkm +DoDKjvbdtvOYKRTA +DoCkKvbdmajWxPNu +DncKjvbdIjEAJofd +EPCkKvbdiCPDFWqR +EOcLKvbdIHHZxwwg +EOcKjvbdYpmEiNFR +EOcLKvbdQmYCZNtz +EOcLKvbdVYhTykPO +EPCkKvbdJKEAKPfd +DoCjjvbdRkYfUfjs +EPDLKvbdlZTSTZGt +DoDLKvbdNGbpNQVL +DoCjjvbdvAdZTOdh +EPCjjvbdliDsqUqa +EPDKjvbdSPsfiecw +EOcKjvbdYlRcsmkm +DnbkKvbdwXMAvBVu +EPCkKvbdRjxfVGjs +EOcLKvbdCIkCKiFj +DoCkKvbddxZssrFz +EOcKjvbdREDApRES +EOcLKvbdTpqPVVIN +EObjjvbdaaWEeoow +EOcKjvbddeOrCXCj +EOcLKvbdAMgySvyx +EPDLKvbdNPwqVnHT +EObkKvbdwuMeRYlO +DoCkKvbdTkuoAuoJ +EPDKjvbdmJDspuRa +EPCjjvbdNHCpNQVL +DncKjvbdGcjvKBij +EOcKjvbdbQHHELzd +EPDKjvbdPxmAGrqj +EPCjjvbdRbDdkiYk +EPDLKvbdTAFJHand +DoDKjvbdqmZjZMHi +EObjjvbdtSrTYzFD +DncLKvbdhlEcmtby +EObjjvbdmJEUQuSB +DncKjvbddndsKstS +EPDLKvbdmgFYNOGy +DnbjjvbdSCEElIyL +DncKjvbdmaivxOmu +DoDKjvbdFVyPomKF +DnbkKvbdMpXqWOHT +EObjjvbdKefICBRV +EObjjvbdqGDdtWBI +DnbkKvbdCJLCLIfK +EObkKvbdLqwNZtpz +DoDLKvbdiifHjMwr +DoCkKvbdddoRawDK +DncKjvbdbrcKscjB +DnbjjvbdrSVLNkAm +DnbjjvbdffLynHHA +EObkKvbdTAFJHbPE +DncKjvbdDncKkWcE +EOcLKvbdrouoKDVf +EOcLKvbdZisIPfbG +EOcLKvbdiGicYuiu +DoDLKvbdVgxWXfxz +DoCkKvbdffMZmgHA +EObjjvbdWfZZtAPT +EPDLKvbdEzsqElCi +DoCkKvbdYSlAlsoY +EPDLKvbdFWYpPmKF +DoDKjvbdkNCMZdfo +EPDLKvbdehLWSOQg +DnbjjvbdxxJKCPyk +EOcLKvbdMfcQMpVL +EOcLKvbdnVVZkKRf +EObjjvbdczYoxZQb +EPCkKvbdSQUGiedX +DoDKjvbdeuzwpJzs +DoDLKvbdqZPHfqDx +DoCjjvbdKeehCBQu +DnbkKvbdADSYJyiQ +DoCjjvbdFkFTDHlu +EPDKjvbdZoOJEdzK +EPCjjvbdZjTIQGbG +DncKjvbdZHWdAOri +EPCjjvbdeXystRez +EObkKvbdIxTagkpp +EObjjvbdxZgfFxEr +DoDLKvbdjhHLfGNk +EObkKvbdTfznMWue +DoDLKvbdOSsufeVQ +DncKjvbdVUNTelWK +EPCjjvbdZQmFImEq +DnbjjvbdkClLQftg +DnbjjvbdRXNdDLhD +DncKjvbdTqQoVUgm +EPCjjvbdNQYRVmgT +DoDLKvbdnUuZjiqf +DoDKjvbdbsCjsdJa +EOcKjvbdFkEsDINV +DoDKjvbdyOTHxSiD +EOcKjvbdkMbMZdgP +DnbkKvbdeEnqavcK +DoCkKvbdxZhFfYEr +DncKjvbdNPxQunGs +EOcLKvbdOYOuzdNt +DncKjvbdJbicRKDY +DncKjvbdjAQHAofj +EOcKjvbdWWiYVcdg +DnbjjvbdjFKftoAO +EPCkKvbdTXkLmzjx +EPCkKvbdWSNxBeMD +DoCkKvbduMXwBTaX +DoDLKvbdLBKfmBxR +DoCjjvbdEObjjwDE +EPDKjvbdTlVnaVoJ +DoDLKvbdhgJcZViu +EObjjvbdatbHXjtI +EOcLKvbdZeXfzgiC +EPCkKvbdeFPRbXCj +EPCkKvbdZQleJMdq +DnbjjvbdUWLojUAq +EPCjjvbdFaOpyJzm +DnbkKvbdANIYrwZx +EPCkKvbdbBWEeopX +DoDLKvbdczYpYYpb +EPCkKvbdbVBfxLTh +DoDKjvbdLBKflawq +DoCkKvbdyOSgxSiD +EPDKjvbdkDLkQgVH +EObkKvbdjmBlZdfo +EPDKjvbduoTzqLOt +EOcLKvbdaRebhUFk +EPDKjvbdatbGwjtI +EOcLKvbdCIjbLIfK +DncKjvbdkIGkeemk +DncKjvbdxVMeRZMO +EOcKjvbdRXODcMHc +DnbjjvbdqquLOLAm +DoDKjvbdDHLfHAzc +DoCkKvbdnVVZkKRf +DoDLKvbdGcjvJbKK +DoCjjvbdzoQRFDLx +DoDLKvbdmuUzLKRf +EPDLKvbdtumwiqTA +EOcKjvbdmJDsptrB +EPCjjvbdIGgZxwwg +EPDLKvbdxLXDgzzG +DnbkKvbdQwNdCkhD +DnbjjvbdcasNSAUN +EPCkKvbdTulQKTaR +EOcKjvbdhgJbyVjV +DoDLKvbdKVteceHJ +DnbjjvbdHgGzYwxH +EPCjjvbdxnSgxTJD +EPDKjvbdyYJKCPzL +EOcKjvbdOFDtJJKd +EObkKvbdRadEkhxk +DoCkKvbdiifHjNXr +DoCjjvbdnUtyjirG +EObkKvbdJpydoGNe +DoDKjvbdZLqctOLm +DnbkKvbdsBfMkfkZ +EOcLKvbdOStWGeVQ +EPDLKvbdijGIJmYS +DoDLKvbdxxJJbQZk +DncKjvbdHbLydzAD +EOcLKvbdyTNiMqag +EPDKjvbdMgComQVL +DoDLKvbdzitoocsU +EPDKjvbdsBfMkfjy +DoCkKvbdFyUtaEYC +DoDLKvbdJKEAJpGd +DoCkKvbdygZMAMeX +EPCkKvbdJqZdoFnF +DnbkKvbdiBnbdvqR +EOcLKvbdSQUGjFdX +DnbkKvbdmSYtzTEJ +DoCjjvbdehKvSOQg +EOcLKvbdGckVibJj +DncKjvbdhficYvJu +EPDKjvbdwuMeRYkn +EOcLKvbdFejSNiUR +EPCjjvbdOFEUJJLE +DnbkKvbdXsLaMtOx +EPDKjvbddZyPxYpb +EPCkKvbdhzVFkqNf +DoDKjvbdOEdUIiLE +EPCkKvbdnGeXmOHZ +EObkKvbdiMEdNuCy +DoDLKvbddoFTLTtS +EObkKvbdIxTbHlQp +DncLKvbdZRMdhmEq +DoDLKvbdZnmheEyj +EPDKjvbdKeegbApu +DncLKvbdNVTSLNAX +EOcKjvbdKDJbqKCx +EPCjjvbdFfKSOIsq +EPCjjvbdxnShYSiD +EOcLKvbdOStWHFVQ +DncLKvbdsPvOicWG +DnbjjvbdxnTHwsJD +DoDKjvbdLAkGmBwq +DoCkKvbdwMvAMceN +EOcLKvbdmRyVZsDi +EPCkKvbdmpZyWKyC +DoDLKvbdrykpTBIO +DoCjjvbdVgwvYHYz +EPDLKvbdTvMPjUBR +EOcLKvbdgFkzOGgA +DnbkKvbdVBBpsRRy +DnbjjvbdRzKISbvA +EObjjvbdxnTIXsJD +EObjjvbdZoOJEdyj +EPCjjvbdHDjuibKK +EPCjjvbdezuxdiUX +EOcKjvbdYTMAmToY +EObjjvbdJYTbILpp +DoDKjvbdkClLRHUg +EPDKjvbdTkvPAvPJ +EObkKvbdeAURNXjG +DncLKvbdTukpKUBR +DoCjjvbdcTDKsdJa +DoDKjvbdBsAcUGXS +EObjjvbdDoCjjvcE +EOcKjvbdtlYWaTaX +DnbjjvbdRDbaPpcr +EPCjjvbdrylPsAgn +DoCkKvbdOhAYZAYa +DnbjjvbdiUydwSVC +DoCjjvbdwzIFfYFS +DoCkKvbdZshiZDrn +DoCkKvbdZoOIddyj +DncKjvbdpssgSSKt +EPCjjvbdrSUkNkBN +EPDKjvbdjJfIJlxS +EOcLKvbdxVNFRYkn +DoDKjvbdWWhwvEFH +DncLKvbdRDcBQQcr +DnbkKvbdliETpuRa +EPCjjvbdZRMdiMeR +DnbkKvbdiMEdOVCy +EPCjjvbdznpREbkx +DoCkKvbdwzIFexFS +DnbjjvbdmSYuZrdJ +DoDLKvbdCWzchdov +EPDLKvbdpfEFTvAh +EPDLKvbdyOTIYTIc +DncKjvbdNQXqVnHT +DoDLKvbdCgMFgAzc +EOcKjvbdIwtBgkpp +EPDKjvbdRjyGUfjs +EObjjvbdACqwjZiQ +DoDKjvbdpstGrSKt +DnbkKvbdnGdwmOHZ +DncKjvbdiZtfLpnG +DoDLKvbdaSGCgtFk +DoCkKvbdFfJqnIsq +EPCkKvbdkNCLzEgP +EOcKjvbdFeirOJTq +EOcLKvbdUtNUGMWK +EObkKvbdSQUHJfEX +EPCkKvbdqquKmkBN +DnbjjvbdbhmKKfXY +DoCkKvbdIsYaTNXl +DoCjjvbdZoNheFZj +EOcLKvbdBhjbLIfK +EOcKjvbdatafwjsh +DoCjjvbdkxrrSyHU +EPDLKvbdSCEElIxk +EOcKjvbdfMevfmKL +EPCjjvbdMJBlRYAS +DoCjjvbdSxKkmzkY +DnbkKvbdkNCLydgP +EObkKvbdkxsSTZHU +DoCjjvbdRpUGiedX +EOcKjvbdjblLRGuH +EObkKvbdyTNiMrCH +DnbjjvbdZeXfzhJC +DoDKjvbdZxdJmblS +DncKjvbdOStWHEuQ +DoCkKvbdyNsHwsIc +EPDKjvbdkxrqryHU +EObjjvbdZLqctNlN +DoDLKvbdxnSgxShc +EPDLKvbdnBjWwoNu +DoDKjvbdkIHMGGOL +EObjjvbdqUUGrRkU +DncLKvbdRjyGVHKs +EPDKjvbdhfjCyWJu +EPCkKvbdHELVjBjK +DncKjvbdgQBzvcwh +DoDLKvbdVAaqSpqy +DoCkKvbdySnJNSBg +DoDLKvbdpeceUWAh +DncLKvbdaRebgsfL +EOcKjvbdZLqctNlN +EObjjvbdtbbtvvPP +DoCkKvbdZMSDtNlN +EOcKjvbdsBelkfjy +EPDLKvbdTpqPVVIN +DnbjjvbdBiKbKhfK +DnbjjvbdOFEUIiKd +EPCkKvbdSiZjRAAl +EObkKvbdwjwDgzyf +EPCjjvbdhlEdNtby +EPCjjvbdhtydwSUb +EOcKjvbdnQZyVjyC +DoDKjvbdRzKIScWA +EOcLKvbdLBLHNCXq +DoDLKvbdssSTYzFD +EObjjvbdEvYpPlie +DncLKvbdhficYvKV +EPCjjvbdnUuZkJqf +DnbjjvbdXnRAXtut +EPDKjvbddijRutzn +EOcLKvbdEvYpPljF +DoCjjvbdTulQKUAq +EObkKvbdxmsIYShc +EPDLKvbdkyTRryHU +EObjjvbdCEQAvKNG +EObjjvbdGYuVBEYC +EPDKjvbdvAdYsOeI +EObjjvbdRpUHKGEX +EPCkKvbdKDJcQjDY +DoDLKvbdunszqKoU +DoCjjvbdJvUfEEfi +DncLKvbdrpWPJcWG +DoCkKvbdajkfPNcA +DnbjjvbdFpATXHFy +EObkKvbdFfJrOJTq +DncLKvbdZnnJFEyj +DoCjjvbdOEctIiKd +EPDLKvbdVhXuxGxz +EPDKjvbdySmhlrCH +EOcKjvbdiGjDZWJu +DncKjvbddZyQYZRC +DncLKvbdziuPpETU +DncLKvbdJTYaTNXl +EPCjjvbdNddThiKd +DnbkKvbdbAudepPw +EOcKjvbdMowpunHT +DoDLKvbdmbKXYPNu +DoDLKvbdezvZEiTw +DnbjjvbdrMyixkgi +DnbkKvbdKWVGEFGi +DoCjjvbdkDLjpftg +DnbjjvbdJqZePFme +EObkKvbdDwxLsssl +EPCjjvbdmoyyWLYb +EPCkKvbdFjdrcHmV +DoCkKvbdDwxLtTsl +EOcLKvbdoAKztHdO +EPDLKvbdTkuoAuoJ +DncLKvbdURRPVVHm +EPCkKvbdKCicRJcY +DoCkKvbduDCuXWOo +DoCjjvbdRXNdDMID +DoDKjvbdBcpBWJlf +DoCjjvbdTqROttgm +DncKjvbdRadFMIxk +DoDLKvbdCSaDTewS +EOcKjvbdQlxCYmtz +DncLKvbdeOeSkUTr +DnbkKvbdTqQntthN +DnbjjvbdhbObdvpq +EPDLKvbdMowqVmgT +DncKjvbdANIZTWzY +EPDLKvbdiVZeXRtb +DncLKvbdYNqAXtvU +EOcKjvbdfIKurNpg +DoCkKvbdFpATWfey +EPCjjvbdHkazmwRL +DoDKjvbdJvUfDdgJ +EPCkKvbdSBdElIxk +DoCkKvbdbsCjtEJa +DoDLKvbdvBEYsOdh +EOcLKvbdGGJqmhsq +EOcLKvbdJSyBSlxM +DncLKvbdnQZxukZC +EOcLKvbdySnIlrCH +DoCjjvbdIjEAKPgE +DoDLKvbdhlEcnVDZ +EPDKjvbdZeYGzghb +EPDKjvbdbKlGOnDA +EPDKjvbdkMbMZdgP +EOcLKvbdDoCkKwCd +DnbjjvbdLBLGlbXq +EPDLKvbdZxcinCkr +DoCkKvbdqTsfrRjt +DoCkKvbdADSYJzIp +DoDKjvbdbUagYKsh +EObjjvbdjAQHAofj +EOcKjvbdDoDKkXDE +EPDKjvbdSZigsCvA +EPCkKvbdKRZePGOF +EPCjjvbdKaKgNCXq +EObkKvbdxxJKBoyk +EOcKjvbdxmrgwsIc +DnbkKvbdmozYvKyC +DoCkKvbdqquLOLAm +EObkKvbdDncLLXCd +EPDLKvbdjcMKpftg +EPCjjvbdwkXDgzzG +DoDLKvbdHffyxwwg +DoCkKvbdvAdZSneI +EOcLKvbdrovOjDVf +EOcLKvbdsPuoJbuf +DoDLKvbdySnJNSBg +EObkKvbdXsMAltOx +DncLKvbdFfKSOJTq +EPCkKvbdddnrCWcK +DoCjjvbdySmhlrBg +DnbjjvbdNxPVzcnU +DncKjvbdhtzEvrVC +DoCjjvbdQwODblHc +DoDLKvbdjcLjpgVH +EOcLKvbdbKlGOmcA +EPDKjvbdfMfWflik +DncKjvbdmbJwXnmu +EOcLKvbdTkuoAvOi +DnbjjvbdsZkoraIO +DoDKjvbdZMSEUOLm +EOcLKvbdsCFmLfkZ +DncKjvbdUxhTyjnn +EPDKjvbdRosfjGEX +EOcLKvbdmuUzKirG +EPCkKvbdGGJrOItR +EObjjvbdEXwktUUM +DnbkKvbdiifHimXr +EPDKjvbdmJDspuSB +EObjjvbdwyhGFwdr +DncKjvbdatafwkUI +EPDLKvbdYNqAXtut +DoDLKvbdEPCkLWcE +EOcLKvbdqceJQOWB +EPDKjvbdySnJNSBg +DnbjjvbdyzdnSIIh +DoDKjvbdrDdiQNvB +DoCkKvbdYkqdTnLm +DoCkKvbdlZTSTYgU +EPDKjvbdMpXqWNfs +EObkKvbdJbicQjDY +DoDLKvbdGAoRYizm +DncKjvbdmgExNOHZ +DoCjjvbdznoqFDLx +EOcKjvbdieLGtoAO +DoCjjvbdMfbpMotk +EObkKvbdyzdnSHiI +EObkKvbdcSbjscia +DoDKjvbdNGcQNQUk +EPDKjvbdNGbpMpVL +DoDLKvbdUQqPVUgm +DnbjjvbdVvhwuceH +EPDKjvbdDxXkstTl +EPCjjvbdPyNAHTRj +EPDLKvbdeOdsLTtS +DoDKjvbdTAEiICPE +DoDKjvbdZisIQGaf +EObkKvbdxVMdpxkn +EPCkKvbdnUtzKjRf +EOcKjvbdhtydvrVC +DoDKjvbdbrcLTcia +EPDLKvbdbhlikFvx +EPDKjvbdANIZSwZx +EPDKjvbdtbbuXWOo +EObjjvbdliDtQtqa +DncLKvbdGLFScIMu +DnbkKvbdfMfXGljL +EObkKvbdCTBDTewS +EPDKjvbdSiZiqAAl +EOcKjvbdFfKSNhsq +EPCjjvbdyYJKBpZk +DncKjvbdAMgyTWyx +DnbkKvbdpaJFAXIE +EOcKjvbdEYYMUUTl +EPCjjvbdeFOrBvcK +DoDLKvbdptUHSRkU +DoCkKvbdOYPVzcnU +DnbjjvbdijFhKMxS +DnbkKvbdEKHivXjA +DncLKvbdsPvOicVf +DoCjjvbdmbJvxOmu +EOcKjvbdDxYMUUTl +DoDKjvbdZtIhxdTO +DncKjvbdTlVoAuoJ +DoDKjvbdFyUuBDwb +EObkKvbdQYmAGsSK +DnbkKvbduLwwAsaX +EPDKjvbdegkWRmpg +EPDLKvbdRDcAoqDr +DoCjjvbdFWZPolie +DoCkKvbdbhmJkGWx +DncLKvbdrWpMDJYq +DnbjjvbdaaWEeoow +DoDLKvbdzHYlANFX +DoCkKvbdjFLHUoAO +DnbjjvbdZyEKNbkr +DoDKjvbdLrXMyuQz +EPDLKvbdwNWAMdFN +DoCkKvbdkWXODaxX +EOcKjvbdraelkgKy +EOcLKvbdmSZVZsDi +EPCjjvbdkMbLzEfo +EObjjvbdaSFbgtFk +EObkKvbdmIctRUqa +DncKjvbdhtydvquC +EPDKjvbdZoOJEeZj +DoDLKvbdyXiJaozL +EOcLKvbdVwIxWEFH +DnbkKvbdYpmFJMdq +EPDLKvbdjKGIKMwr +EPCkKvbdFpASwHGZ +DncKjvbdKQzEnfNe +DoDLKvbdkVwODaxX +EPCjjvbdzaAOffal +EObjjvbdnHEwlnGy +DncLKvbdLqwMyuQz +EPCkKvbdWRnXaeMD +DoCkKvbdcbSlrAUN +EPDKjvbdMJBlRYAS +EOcLKvbdZxcimbkr +DncLKvbdCDpBVimG +DoDKjvbdGdKvKBjK +EPDLKvbdziuPodSt +DnbkKvbdbrbjtEKB +EOcLKvbdmIcsptqa +EPDKjvbdMRwMyuQz +DoDLKvbdfHkVrNqH +DnbkKvbdLZRKSzuG +EPDKjvbdTfzmkwWF +EOcLKvbdSKxeuHLT +EPDLKvbdkHgLfGNk +DoDLKvbdVhXuxHYz +EOcKjvbdkHgMGGOL +DoDKjvbdEARhmZvw +EPDLKvbdjKFgimXr +EObkKvbdSQUGiecw +EPCjjvbdjKFhJlxS +DoDKjvbdDxXlTtUM +EPDLKvbdelfWgMik +EOcKjvbdtcDVXWOo +DoDKjvbdiZuFlRNf +DoCkKvbdsBellHKy +EPCkKvbdjlbLyeGo +EOcKjvbdhfibxujV +EObjjvbdhyuGMROG +DoDLKvbdgQBzvdYI +DoDKjvbdeATpmXjG +EPDLKvbdjKFgilxS +DoDKjvbdrpWPJbuf +DncLKvbdDncLKvcE +DoCkKvbdkVvmdCXw +DncLKvbdGcjujCJj +DncLKvbdpxngfpcx +DnbjjvbdiCPCdwQq +EPDLKvbdijFhJlwr +DncKjvbdhgJbxvKV +EPCjjvbdZxcjNbkr +DncKjvbdZQleJMdq +DncLKvbdyfxlAMeX +EPCjjvbdFfJrNiUR +EPDLKvbdzjVQPdSt +DoDLKvbdjAQHBPfj +EObjjvbdZoOJFEzK +EObkKvbdFpATWgGZ +EPDKjvbdvAcxrneI +DoDLKvbdxrnJMrCH +DoCkKvbdjmCLydfo +EPCkKvbdegjuqmqH +DoCkKvbdSBdFLiZL +EObkKvbdbAvFFopX +DncLKvbdGQASwGey +DnbkKvbdQccAopdS +EPCkKvbdZshiYdSn +EPCjjvbdHDjujCKK +EObjjvbduDDVWuno +DoCjjvbdzjVQQDsU +EOcLKvbdeFOqavcK +DoDLKvbdyXhibPzL +DoDLKvbdrzMPsAgn +EObkKvbdUtNTfMWK +EOcLKvbdLqwNZuQz +EPDKjvbdqBJFAXHd +DoCkKvbdnUuZkKSG +DoCjjvbdZHXEAOsJ +DncKjvbdQdDBPpcr +DnbkKvbdCIkBkIej +DnbkKvbdMgDPmQUk +DnbkKvbdxxIjCPyk +DnbjjvbdZsiIxdSn +DoCkKvbdADRxJzJQ +EObjjvbdkxsSTZHU +DncKjvbdWXIxVdEg +DnbjjvbdLrWmZtpz +EPDKjvbdhzUelQnG +DoDLKvbdSBceLhxk +EObjjvbdWIXvYGxz +EPDKjvbdEYXktUUM +EObkKvbdhlFENtby +EPDLKvbdNwnuzcmt +EOcKjvbdaaWEfPpX +DncLKvbdddoSCWcK +EPDKjvbdmaiwXnnV +DoDLKvbdMgDQMpUk +DoDLKvbdjFKfuPAO +DncLKvbdnGeYMmfy +DncLKvbdrSUjmkAm +EOcLKvbdfHkWRnQg +DnbjjvbdnCKWxPNu +DnbjjvbdraemLgKy +EObkKvbdWWiYWDdg +DoCkKvbdKfFgaaQu +EPCkKvbdaSFcIUGL +EOcKjvbdkxrqryHU +DncKjvbdRDbaQQcr +DncLKvbdbVBgXjtI +DoCjjvbdqZPHfqDx +DnbkKvbdcyxowxpb +EPCkKvbdWXIxWDeH +DoCkKvbdyXiKBozL +DnbkKvbdlZSrTYft +EObjjvbdGdKujBij +DnbjjvbdtcDVXWPP +DoDKjvbdZnmhddyj +EObkKvbdTukoisaR +EObkKvbdzoPqFCkx +DncLKvbdLhalQxAS +EPCkKvbdVwIwudFH +DoDKjvbdjKGIKNYS +DoDLKvbdjhHLeenL +EPDKjvbdJTZBSlxM +DoCjjvbdFaOqZJzm +DoDLKvbdnBjXXnnV +DoCjjvbdeFPSCXDK +EPCjjvbdbAvFGPow +DnbkKvbdVwIwvEFH +EObjjvbdqUTfrSLU +DncKjvbdqlyixkhJ +DoDKjvbdSLZFuGjs +DncLKvbdsCGNLfkZ +EPDLKvbdaofgDkzd +DoCkKvbddiirWUzn +EOcKjvbduCcVWuno +DnbkKvbdSPsfjGDw +DoCkKvbdFWYpQMie +DoDLKvbdRECaQRES +EPDLKvbdhfibyVjV +DnbjjvbdqTsgSSLU +EObkKvbdrXQMChyR +DncLKvbdNrtVfduQ +EObjjvbdiUzEvqtb +DncKjvbdUaCQsRRy +EPCjjvbdRbEEkiYk +DncKjvbdUtNUGMVj +EPCjjvbdzHYlAMeX +EPCkKvbdeEoRbXCj +DoDLKvbdcScLUDia +DoDLKvbdtbbuWuno +EOcKjvbdbUafwkTh +DoCjjvbdtcDVXWOo +EOcKjvbdHgGyxxYH +EOcLKvbdWSOXbEkc +DoCkKvbdKeehCBRV +DncLKvbdMgComQVL +DoDKjvbdUMVoBVoJ +DoCjjvbdzoQRFCkx +DoCkKvbdUWMQJsaR +DnbjjvbdkNCLydgP +EOcKjvbdmozYvKyC +DnbkKvbdmgExMnGy +DncKjvbdznpQeDMY +DoDKjvbdZxcjNbkr +EOcKjvbdqdEiQNua +EPDLKvbdfHkVrNpg +DnbkKvbdXsMBMsoY +EObkKvbdcJNKLGXY +EPDLKvbdVqmwbEkc +EPCkKvbdJcJbpibx +EObjjvbdYNqAXtvU +EObkKvbdjAQHApGj +EPDKjvbdrbFmMHLZ +DnbkKvbdPIAXyAYa +DoDKjvbdSLZGVHLT +DoCkKvbdDnbkLWcE +DncKjvbdzoPpeDMY +EPDKjvbdQwNdDLhD +EPDKjvbdhfjCxuiu +DoCjjvbdajkenmcA +EPDKjvbdtTSTYyeD +DoCjjvbdijFhKMwr +DoDLKvbdpfDeTuaI +EPCjjvbdJXtCHlQp +EOcKjvbdjbkkRGuH +EObkKvbdVTlselWK +DoCkKvbdauCHXkTh +DnbjjvbdSLZGVGjs +DoDLKvbdehLWRmqH +DncKjvbdSBdFLhyL +DoDLKvbdmajXYPOV +EOcKjvbdpeceTvAh +EPCjjvbdNdctIhkE +EOcLKvbduWNwjQsA +DoCjjvbdtvOYKRTA +DncKjvbdqiAJeNOe +DnbjjvbdUtNUGLvK +EPDKjvbdMgColotk +EOcKjvbdQlxCZNtz +DoDKjvbdmfdwmNfy +EPDKjvbdrovPKDVf +DnbjjvbdDjIJuwjA +EPCjjvbdsBfNMHLZ +DoCjjvbdJbjDRJcY +EPDLKvbdZRMeJNEq +EPCkKvbdRkYfVGkT +DncLKvbdRbDeLiYk +EPCjjvbdqiAJdloF +DoCjjvbdFyVUaDwb +DoCjjvbdMRvmZtpz +DoDLKvbdGQATWffZ +EPCjjvbdwtmFQyMO +EOcKjvbdTIzKRAAl +DoCkKvbdsQVnicVf +DoDLKvbdFfKRmhtR +EOcKjvbdsCFmLfjy +DoDKjvbdddnqbXDK +DoDKjvbdYgWdAOri +DoCkKvbdmuUyjjSG +EObkKvbdhficYvJu +DoCkKvbdQlxCZNtz +EPCkKvbdGZVUaEXb +DncLKvbdEXxMTtTl +DoDKjvbdGFirNiUR +EPCjjvbdpssgRrLU +EObkKvbdVZHsykOn +DncKjvbdyTOJMrBg +EOcKjvbdRacdlIyL +EObkKvbdiCOcFWqR +DoDLKvbdRjxfVGkT +EOcLKvbdiBncFXQq +DncLKvbdnQZxukYb +DoDKjvbdpaIeAWgd +DncKjvbdVqnYCEkc +DnbjjvbdZRMdhmEq +EPCjjvbdhgKDYuiu +EOcLKvbdCIkBjhfK +EPCkKvbdZnmhdeZj +EOcKjvbdTppnuUhN +EOcLKvbdbVBfxKsh +EPDKjvbdFVxpQNKF +DnbjjvbdjvWnDaxX +EObjjvbdANIYrwZx +EObjjvbdauCHXjtI +EObkKvbdZirgpGaf +EObjjvbduoTzqLPU +DoDLKvbdxZhFeweS +DoCjjvbdILaznWqL +DncLKvbdaMkBrtlg +EObjjvbdNrtVgFUp +DnbkKvbdRzKHsCvA +DoCkKvbdiZuFkpnG +DnbkKvbdEztRElDJ +EPCjjvbdRECaQQdS +EPCjjvbdqqtkNkAm +EObkKvbdyNrhXriD +DoDLKvbdegkWRmqH +DncKjvbdNQXqWNfs +DoDLKvbdRadFLhxk +EPDKjvbdxUmFQyLn +EPCjjvbdxxJKBoyk +EObkKvbdnVUzLJqf +DnbjjvbdSQUGiedX +DncLKvbdrpVnjCvG +DoDKjvbdZirgpGbG +DncKjvbdOAJTUJrA +DnbjjvbdUyHsyjoO +EPDKjvbdfpBzvdXh +EPCjjvbdyTNhlqag +DncKjvbdLBKflaxR +DoCjjvbdVwJXvEEg +EOcKjvbdVqnXadlD +DoDKjvbdyNrgxSiD +EObjjvbdnVVZjjRf +DnbjjvbdFeiqmiTq +EObkKvbdFVxpQMie +DnbkKvbdIBkydzAD +EPCkKvbdZjTHofaf +DncLKvbdnPzYukZC +EObkKvbdLYqKSzuG +Dnbjjvbdxmrgwrhc +EObkKvbdTkuoBWOi +EObkKvbdIrxaSlxM +EOcLKvbdJqZeOfOF +DoCjjvbdBhjbKiFj +EPCkKvbdrDeJPnVa +EPCkKvbdNwoVzcnU +EOcLKvbdXmqAYVWU +EPCkKvbdZeYGzhJC +EOcKjvbdNddUIhjd +DoDKjvbdjggLeemk +EObkKvbdxZgefXeS +EOcKjvbdgFkzOGgA +EObkKvbdNdcsiIkE +EPDKjvbdbiMikFwY +EPDKjvbdelfWfmJk +EOcKjvbdHELWJajK +DoDLKvbdZRMeIldq +EOcLKvbdRXNccMHc +EPCkKvbdQlxCZNtz +DoCkKvbdyTOJMqag +EPDLKvbdCTAcTevr +EOcKjvbdrpVnicWG +DnbkKvbdZLrETmkm +EOcLKvbdRpTfifEX +DnbjjvbdQcbaPqDr +DoCkKvbdEuxpQNKF +EPCjjvbdNeEThiKd +EPDKjvbdVYgtZjoO +DoCjjvbdZRMdhleR +DoCjjvbdZsiIyDrn +EPDLKvbdaSGCgtGL +EPDLKvbdqTtGqrKt +DoCkKvbdnVUzKjSG +EPCjjvbdzQoMiJwA +EPDKjvbdXrlBMtOx +DoCjjvbdNHColpVL +EObkKvbdXnRAXuVt +EObjjvbdMJCMQxAS +EObkKvbdIrxaTMxM +DnbjjvbdbAudfQQX +DnbkKvbdnCKXYOmu +DoDKjvbdEXxMUUTl +EObkKvbdyXhiaozL +EObjjvbdEJhKVwjA +EOcKjvbdpfEFTuaI +EOcKjvbdbVCHYLTh +DncLKvbdyqOliJwA +EOcKjvbdkxrqsZHU +DncKjvbdDjHjVwjA +EPCkKvbdkDMLQfuH +EPCjjvbdUVlPjUBR +DoDLKvbdjJfHimXr +DoCkKvbdEuxooljF +DoDLKvbdYzcGRjWZ +DoDKjvbdwyhGGYFS +DnbkKvbdsrrSxyeD +EPCkKvbdxmrhXrhc +EPDKjvbdDjHivXjA +EObkKvbdfMfXGlik +EPDLKvbdGdKvKBij +DoCkKvbdbLMGOmcA +EPCkKvbdRXNdDLgc +EPCjjvbdZsiIxcrn +DoDKjvbdpyPIGqEY +EPDKjvbdlZTRryHU +DoDKjvbdUslsekvK +DncKjvbdKfFhCBQu +DncLKvbdSCDeMIyL +EPDKjvbdJcJcRJcY +DoDLKvbdraellHLZ +EPCjjvbduDCtwWPP +DnbkKvbdBdPaWJlf +EPCkKvbdqFceUVaI +DnbkKvbdcyxoxYqC +DnbkKvbdlYsSTYft +EObjjvbdZHXEAOsJ +EObjjvbdURROtuHm +EPCjjvbdZLrDsnMN +EPCjjvbdfIKvRmpg +EPDLKvbdwWlBVaVu +EObkKvbdZMSDsmkm +EPDKjvbdKNAEZfuB +DnbjjvbdhyuGMROG +EObjjvbdJuuGDdgJ +EPDLKvbdgQBzwDxI +EObjjvbdjvXNdCXw +EPCjjvbdlZSrSyGt +DoDKjvbdXsLaMsnx +DoDLKvbdTlVoAuoJ +DnbkKvbdptUGrSLU +EObkKvbdEztRFMCi +EOcLKvbdTkvOaVoJ +EObkKvbdDoCjjwCd +EPCkKvbdTfznLwVe +EObkKvbdRjyGUfjs +EPDKjvbdVviXvEFH +DnbjjvbdKkBIWAKZ +EOcLKvbdqFdFUVaI +EOcLKvbdBhjakJFj +DncKjvbdauBgYKsh +DnbjjvbdxKvdHzyf +DoCjjvbdxVMdqYlO +EPCjjvbdEPDLLXDE +EPDLKvbdVvhwucdg +DncKjvbdaRfDITfL +EPDKjvbdfpBzvcxI +DoCkKvbdGLFTDHmV +DoDLKvbdcTDKtDjB +DnbkKvbdZRMeIldq +EObjjvbdRjyGVGkT +EPCjjvbdlhctRVRa +DnbjjvbdyXhibPzL +DnbjjvbdFpASvgFy +DnbjjvbdKCicRJcY +DnbkKvbdPxmAGrrK +EPCjjvbdpstHSSKt +EObkKvbdiZtelQnG +DoDLKvbdKkAgvAJy +EObjjvbdsPvPKCuf +EOcLKvbdhyuGLqOG +EPDLKvbdyOSgxShc +EObkKvbdmJDsptqa +EPCjjvbdbVCHYKtI +DoCkKvbdCJLBkIfK +EPDKjvbdTqQnuUgm +EOcLKvbdypnmIjXA +DoDLKvbdiLddOUby +DoCkKvbdaSFbgtGL +EPDLKvbdraellGjy +EObkKvbdWRmwbEkc +EPCjjvbdDoDLKvcE +DnbjjvbdjEjfuPAO +DnbjjvbdqvokbiYq +DnbkKvbdVZITzLOn +EPDKjvbdUWLpJtAq +EObkKvbdwtmFQyMO +DoDLKvbdFWZQPmKF +EPDKjvbdLBKgMawq +DncLKvbdANIYsWyx +EObkKvbdqvolDJYq +EOcKjvbdQlwbZOUz +EPCkKvbdlqyUzTEJ +EPCkKvbdSLYfUgKs +DoCjjvbdRotHJfEX +EOcKjvbdrXQMCiZR +DncLKvbdaofgELzd +DoDKjvbdehKvSNqH +EPCkKvbdzaAOfgBl +DoCkKvbdVUMsfMVj +DoDLKvbdUGznLwVe +EPDLKvbdDoDKjwDE +DoCjjvbdANHxsXZx +EPCkKvbdJpydnenF +EPCjjvbdtTRsZZeD +DoDLKvbdnQZyWLZC +EPCkKvbdKNADyfta +EPCkKvbdUVlPjTaR +DncLKvbdeOeSjstS +DncKjvbdXrlAmUOx +DoCkKvbdxnTIXrhc +EPDLKvbdZjTIQGaf +DoCjjvbdPxmAGrrK +EPDKjvbdLZQirztf +DoDLKvbdkHflGFnL +DoCjjvbdiMFEOUby +DnbjjvbdhaoDFXQq +EPCkKvbdyzeNqhIh +EPDKjvbdbUbGwkUI +DoCkKvbdEXxLsstM +DoDLKvbdaRebhUGL +EObjjvbdMfbpNQUk +DoDLKvbdCEQAuilf +EObjjvbdMowpunHT +DoDLKvbdzHYlAMeX +DoCkKvbdegkVqnQg +DnbkKvbdwWlAuaVu +DncKjvbdFfJqnItR +EObjjvbdZjTHpHBf +EPCkKvbdbsDKtEJa +EOcLKvbdZtIiZESn +DoDLKvbdpxoIHRDx +EPDLKvbdTpqOtuIN +DnbjjvbdmoyxvKxb +DncKjvbdqGEEtWBI +EPCkKvbdQwNdClHc +DoCkKvbdHELViajK +EPDLKvbdCJLBkIfK +EPDLKvbdvwMBWBVu +EPDKjvbdxrmiNRag +EOcKjvbdxVMeQyLn +DoCkKvbdraelkgLZ +EPCjjvbddndsLUUS +DoCjjvbdhgKDYvKV +EPDKjvbdBiKbKiFj +DncKjvbdKkBIWAKZ +DnbjjvbdjlakzEgP +EObjjvbdNrtWGeUp +EPDKjvbdidkGuPAO +DnbkKvbdjAQHBPgK +DoCkKvbdUxgtZkPO +DoDLKvbdDoCkLXDE +DoDLKvbdkVvmcaxX +EPCkKvbdmfeXmOHZ +DoCjjvbdHDkWJajK +DoDLKvbdkHgMGFnL +EObjjvbdBdQAuilf +EPDKjvbdxUleQxlO +DoDKjvbdJbjDRJcY +EPDKjvbdXsMAltOx +EOcKjvbdIrxaSmXl +DoDLKvbdyYJJbQZk +DoDLKvbdQlwaxnUz +EObkKvbdqvpMDIyR +DoCkKvbdhzVGLpnG +DncKjvbdJKEAJofd +EOcLKvbdZLrETnLm +DncKjvbdQvnDcMID +EPDLKvbdiLddOUby +EOcKjvbdeJiqvUzn +DnbjjvbdsBemMGkZ +EPCkKvbddtAUASmW +EPCjjvbdiLeEOVCy +EPDKjvbdkxrrSyHU +DoCjjvbdURQoVUhN +EOcKjvbdtkwwBUBX +EOcKjvbddeOqawCj +EOcKjvbdbAvEfPow +EPCkKvbdzROmIjXA +EObjjvbdKDKCpibx +EPDKjvbdIGfyyYXg +EOcLKvbdeOdsKssr +EOcKjvbdsBelkgKy +DoDKjvbdJYUCIMRQ +EOcLKvbdjcMLQgVH +EOcLKvbdJTYaSmXl +DoDLKvbdNddUJIkE +DoDLKvbdFjdsChNV +DnbjjvbdmttyjjSG +EPDLKvbdVgwuxHYz +EOcLKvbdsCGMkfjy +EOcKjvbdKWVGDeHJ +EPDLKvbdjJegjMwr +DoCkKvbdNHDQMotk +DoDLKvbdjmBkydgP +DnbkKvbdSLZFtfjs +EPDKjvbdjbkjpfuH +EObjjvbdkVwNdBww +DncKjvbdFxtuBEYC +EPCkKvbdrMzJxkhJ +DoDLKvbdptUGrSKt +EOcKjvbdhzUelQnG +EObkKvbdsQVoKCuf +DoCkKvbdzitpPcsU +DoCkKvbdySnJMqag +DncKjvbdZRMeImFR +EObkKvbdYzcFrKVy +DoDKjvbdrNZjZMIJ +EPCkKvbdEvYoolie +EOcLKvbdLBKgNCXq +DnbkKvbdrpVnjDWG +EObkKvbdLLBHvAJy +DoCkKvbdqmZixkgi +DoCjjvbdhytfLpmf +DnbkKvbdVZHsyjoO +EObkKvbdWWhxWEEg +EObkKvbdhfjDZWJu +DoCjjvbdZoOIddzK +DoCjjvbdCDoaWJmG +DoCkKvbdzitoocrt +EOcLKvbdOSsvGduQ +EOcLKvbdVqnXbElD +EPDKjvbdgFlZnHHA +EOcKjvbdUsltFkvK +EPCkKvbdePFSkTsr +EPCkKvbdssSTYzFD +EOcLKvbdVTlselWK +DncKjvbdZRMeJMdq +EOcKjvbdYSlAlsnx +DncLKvbdSZihTDWA +DnbjjvbdvvlBWAuu +EOcLKvbdEvZPoljF +EPDKjvbdHELWJbJj +DoDKjvbdDjHiuxKA +DncLKvbdrMyjYkgi +EOcLKvbdRbDdlIxk +DoDLKvbdFVyQQMie +EOcLKvbdZxdJmcMS +EPDKjvbdFejRmiUR +EPCjjvbdnPyxujxb +DoCkKvbdjKGIKNXr +DoCjjvbdYSlBNUPY +DoDLKvbdZshiZDsO +EPDLKvbdkyTRsYft +DncKjvbdJbicQicY +DoCkKvbdXGZZtAOs +DnbkKvbdZjSgpGbG +DncKjvbdWSOYBeMD +DoDLKvbdKNADyfta +DoDLKvbdLBKgMbYR +EObjjvbdNddThhkE +EPCjjvbdQdCaPqES +DnbkKvbdvBDySoFI +EPCkKvbdDoDLLWcE +DncLKvbdaSGDHtGL +EObkKvbdKNADzGta +DncLKvbdTAFJHaoE +EOcLKvbdTAFJIBoE +DoDLKvbdUtNTelWK +EPCkKvbdKefICApu +EObkKvbdySmhlqbH +EPDLKvbduaEYroFI +DnbjjvbdSKxfVHLT +EObkKvbdhkdcnVDZ +DnbkKvbdCSaDTevr +DoCkKvbdiBoCeXQq +DncLKvbdZjShQGaf +EPCkKvbdIwsagkqQ +DnbkKvbdnCKWwoNu +DncKjvbdelfWgNJk +EOcLKvbdSPtHKFcw +EObjjvbdZRNEhleR +DoCkKvbdbLMGPNcA +DoCkKvbdRkZFtfjs +EOcLKvbdySmhmSBg +DoCkKvbdWHxVwgYz +EObjjvbdURQntuHm +EPDKjvbdySnJMqbH +EOcLKvbdOStWHEtp +EPCjjvbdeOeTKstS +DncLKvbdssRsZZdc +EObjjvbdrovPKCuf +EPDKjvbdiZuFkqOG +DncLKvbdsBfNLfjy +EOcLKvbdCDpAujNG +EPDKjvbdOSsugFUp +DoDLKvbdNQYRVmfs +EOcLKvbdTAEiHaoE +DoCjjvbdEPDKjwDE +EPCkKvbdqUUGqqkU +EPDKjvbdtbcVXVoP +DnbjjvbdhbOcEvqR +EOcKjvbdCTAcUGWr +EPCkKvbdQdDApQcr +DnbjjvbdTfznLwWF +DnbkKvbdCDoaVjMf +EPCjjvbdBsBDUFvr +EPCkKvbdWWiXuceH +DoCjjvbdJcJcRJbx +DoDLKvbdsCGMlHKy +EPCjjvbdSBceLhyL +DoDKjvbdHffzZYYH +EPCkKvbdvAdZTOeI +DnbkKvbdxwhjBpZk +DncKjvbdOFDtIhjd +DoCjjvbdmpZxujxb +EOcKjvbdIryAsMwl +EPCkKvbdTqQnuUhN +DncKjvbdOSsvHEtp +EPDLKvbdZoOIdeZj +DnbkKvbdKeegbAqV +EPCjjvbdqFceUWAh +DnbkKvbdCWzchdpW +EPCkKvbdzQnlhiwA +DoDLKvbdqdEiQNua +DncKjvbdddoRawCj +EPDLKvbdlYrrSxft +DnbkKvbdRWnECkgc +DncKjvbdGYuUaEYC +EPDLKvbdZsiIxcrn +DoCjjvbdJbibqJbx +EPDKjvbdGYtuBDxC +DnbjjvbdCEQAvKMf +EObjjvbdvAcyTPEh +DoCkKvbdxwhjBozL +DoDKjvbdNsTugFVQ +DoDKjvbdkHgLeemk +EOcLKvbdwWlBVaWV +EOcLKvbdrNZjYkgi +DnbkKvbdJYUBglRQ +DnbkKvbdjvWmdCXw +EObjjvbdmajXYPOV +DncKjvbdDihJuxKA +EPCjjvbdwzIGGYFS +DoDKjvbdMpYQvOHT +DncLKvbdbhljLFwY +EObjjvbdelevgMik +DnbjjvbddePSCWbj +DnbjjvbdKQydnenF +DnbkKvbdZQmEhmFR +DoDKjvbdjKFgimYS +EObjjvbdANIZSvyx +DoCjjvbdfHkWRnRH +EObkKvbddiiqutzn +EOcKjvbdqYnhHQdY +DoDKjvbdKCjDQjCx +DoDLKvbdjgflFfNk +EOcLKvbdtTRrxzEc +DnbkKvbduLwwBUAw +DncLKvbdkWXOEBxX +EPDKjvbdNxPVzcnU +EPCjjvbdUMVnaWOi +EObkKvbdZQmFImEq +DncLKvbdQvmdDMID +EObjjvbdGFjSNhsq +EOcLKvbdbAvFFpQX +DoCjjvbdkCkjqGuH +EPCkKvbdbLLeoNcA +DoDLKvbdemFwGmJk +EOcKjvbdVUMtFlWK +EPDLKvbdWXJXucdg +DncLKvbdqcdhpNua +DncLKvbdGYuUaDxC +EPCkKvbdGZUtaDwb +EOcLKvbdjuwODaxX +EOcKjvbdSKyFuHKs +EOcLKvbdNQYQvOHT +EPCkKvbdNGcQNPuL +EOcLKvbdPIAYZAZB +EObjjvbdMfcPlpVL +EPCjjvbdLAjflbXq +EPCjjvbdySmhmRbH +EPDKjvbdxsNhmSBg +EOcKjvbdZMSDsmkm +DoCjjvbdbAudfQQX +DoCjjvbdePErjtTr +DncKjvbdtkxXBUBX +DoCkKvbdqvokbiYq +DnbjjvbdMfbpMouL +DnbjjvbdijFhKNXr +DoDKjvbdhgJcZVjV +EPDKjvbdIHGzZYYH +DnbjjvbdNsTufeVQ +DnbjjvbdqlyixlIJ +EPDLKvbdmaivxPOV +DnbkKvbdmJDsptrB +DnbjjvbdQYmAGsSK +EOcKjvbdZjTIQHCG +EPDKjvbdqGDeTuaI +EOcLKvbdADSYJzIp +DncLKvbdeuzwoizs +EObjjvbdFyUuBEXb +DncLKvbdnUtykJqf +EPCjjvbdelfXGmKL +EOcKjvbdKCjDQjDY +DncKjvbdaaVeGPow +DncKjvbdqvolDJYq +DoCjjvbdDnbjkWbd +DoCjjvbdjlakyeHP +DoCkKvbdLZRJrztf +DncKjvbdZisIQHCG +EPDLKvbdZyDjNbkr +DnbkKvbdLAjfmBwq +EOcKjvbdtSqryZeD +EOcLKvbdIMBzmvqL +EObjjvbdiVZdvqtb +DoDLKvbdMgDPmQVL +EPDLKvbdMgCpNPtk +EObjjvbdKVuGDeHJ +EOcLKvbdjJehJlxS +EPCkKvbdhlEcmuDZ +DoDKjvbdHfgZyXwg +EPCjjvbdShyiqABM +EPDLKvbdMgColouL +EPDLKvbdVqmwadkc +EPCjjvbdnCKWwnmu +DncKjvbdRpUGjGEX +DoDKjvbdkWWnECYX +DnbjjvbdkMalZeGo +EOcKjvbdxUleRYkn +EObkKvbdFxtuBDxC +EObjjvbdnGdwlnGy +EObkKvbduaEYsOeI +EPCkKvbdyTOJMrBg +EObjjvbdDHMFgAzc +DnbjjvbdEOcKkXCd +EPDLKvbdBhjbLIfK +EPCkKvbdZtJJZETO +EOcLKvbdIwsagkqQ +DoCkKvbdZyDjNbkr +DnbjjvbdBsAbsfWr +DoCjjvbdeOeSjssr +EObkKvbdVUNUGMWK +DncLKvbdfMfWfmKL +DoCjjvbduaEZTOdh +DoCkKvbdZisIPgBf +DnbjjvbdVZHtZjoO +DoCjjvbdCWzchePv +EObjjvbdJmAEZfuB +EObjjvbdvvkaVaWV +DoCjjvbdiiegjNXr +DnbjjvbdcScLUEJa +DncLKvbdJXsbHlQp +EPCjjvbdrpWOjDVf +DoDLKvbdDnbjjwDE +DnbjjvbdxnShYSiD +DoCjjvbdqGEFUWBI +DoDKjvbdtSrTYzEc +EObkKvbdEPDLLWcE +DoDKjvbdKQzEnfOF +EPDLKvbdIwtBhMRQ +DoCjjvbdTvLojUBR +EPDLKvbdZyDimbkr +EPDLKvbdptTfrSKt +DncLKvbdkMbLyeHP +EOcKjvbdKfFhBaQu +EObjjvbdeEoRbXDK +EOcKjvbdHDjvJbJj +EObkKvbdEztQeLcJ +DncKjvbdUtMsfLuj +DnbjjvbdRXOECkgc +DncKjvbdLAjfmBxR +EOcLKvbdsPvPJcVf +EPCjjvbdygYlAMdw +DnbjjvbdmuVZkKRf +EPCkKvbdSZigrcWA +DncLKvbdcJMikGWx +EOcKjvbdGLErcHlu +DoDKjvbdKNADygUa +EPDLKvbdMfbolpUk +DoDLKvbdUxhTyjoO +EPCkKvbdMtrqjmAX +EPDLKvbdLBLGmBxR +DoCjjvbdrzMQTAgn +EPDLKvbdUxhTykPO +DnbkKvbdnVUzLJqf +DoCkKvbdLYpirztf +EPDLKvbdFejSOItR +DncLKvbdvlvANDeN +DncLKvbdwtleRYkn +EObkKvbdcJNKLFvx +EPCjjvbdYSkaNTnx +EOcLKvbdSxKlNzjx +DnbjjvbdHbMZdzAD +EPCjjvbdXnRAXuVt +DoDKjvbdQmYBxnUz +DoCkKvbdWSOYCEkc +DnbkKvbdemGXGlik +EObjjvbdNeDsiJLE +DoCkKvbdbiMijfXY +EPCjjvbdmIdTptrB +DoCjjvbdEztQeMDJ +DncLKvbdCIjbLIfK +EPCjjvbdhkeENuDZ +DoCkKvbdAMgxsWzY +DoCjjvbdiZtelQnG +EOcKjvbdWXJXuceH +EOcLKvbdZRMeJMeR +EPCkKvbdiVZdvquC +DoDLKvbdkVvmdCXw +EObjjvbdnHExMmgZ +EPDKjvbdHgHZyYYH +EPDKjvbdRbEFMJYk +EPCkKvbdvBEZSndh +DnbkKvbdcScLTdJa +DoDLKvbdcJMijfXY +DnbjjvbddndrjstS +EPDLKvbdbiNJjevx +DnbkKvbdOSsvGduQ +DoDKjvbdMowpvNfs +DoCkKvbdZjSgpGaf +DnbkKvbdddnqawDK +DoDLKvbdKaLGmCYR +DoCjjvbdmuVZkKSG +EOcKjvbdZQldiMdq +EObjjvbdRNXayOUz +DncLKvbdeuzxQJzs +DncLKvbdEOcKkXCd +DncKjvbdhtyeXSUb +DnbjjvbdEObjkXDE +DncLKvbdKQyePGNe +EOcLKvbdHgGzZXwg +EObkKvbdrMzJxlIJ +EObkKvbdRXNdClHc +DoDLKvbdwzIFexEr +EPDKjvbdJYUCIMQp +DnbkKvbdhbOcFWqR +EOcKjvbdnGdxMmgZ +EObjjvbddeOqawCj +EPCjjvbdqTsgSSKt +DncKjvbdJXtBhLqQ +DoDLKvbdatagYKsh +EOcKjvbdjEkHUoAO +DncKjvbdLFfICBRV +DnbkKvbdKQydoFme +EPDKjvbdhlFEOVCy +EPCkKvbdZxdJmblS +EPDKjvbdJbjCqKCx +DncKjvbdwNWANDdm +EPDLKvbdpyPHfqDx +EPCjjvbdOTTufeVQ +EPCkKvbdtbbtvvOo +DoCjjvbdbBWEfQQX +EObjjvbdKNAEZgVB +DnbjjvbdJXtBgkqQ +EPCjjvbdGYtuBEXb +DoDLKvbdZjShQGaf +DoDLKvbdQmYCYnUz +EOcLKvbdpedFTvAh +EObjjvbdKQydoGNe +EPCkKvbdKDJcRKDY +EObkKvbdrafMkfkZ +EObkKvbdiCObdwRR +EPCjjvbddBsMrAUN +DoDKjvbdWIXvXgYz +DoDKjvbdkClKpftg +EOcKjvbdkCkjpftg +EOcLKvbdVrOYBeLc +EObkKvbdmoyxukZC +EPCjjvbddZyQXyRC +DoCkKvbdhbPCdvqR +DoCkKvbdJvUeceGi +EOcLKvbdVqnXaeMD +DoCkKvbdWWhxVceH +EPDKjvbdiGjDZVjV +EObjjvbdGAnpxizm +DoCjjvbdiZuFlQnG +EOcKjvbdTqRPVVIN +EPCjjvbdqdEhomvB +DoCkKvbdLAkHMaxR +EPDLKvbdOEdThiKd +DnbkKvbdkxrrTZGt +EOcLKvbdEPDLLXCd +DoDLKvbdTIzKRAAl +EPDLKvbdSCDeLiZL +EPCkKvbdpyOgfpdY +EPCjjvbdtkwwBTaX +EPDKjvbdiBoCeWqR +DoCjjvbdhgJbxujV +DoDLKvbdqdEhpNvB +EOcKjvbdkCkjqGuH +EPCjjvbdhbObeXQq +EOcKjvbdxsOImRbH +DoCjjvbdKWVFceHJ +DoDKjvbdBiKbKiGK +EPDKjvbdnGeXmNgZ +EPDKjvbdiifHjNYS +EOcKjvbdauBgXjsh +DnbkKvbdUtMsfLvK +DncKjvbdNrtVgEuQ +EPDLKvbdUsmUGLvK +EOcLKvbdNGcQMpVL +EPCkKvbdqmZjZLhJ +EObkKvbdFfKSOJUR +DncKjvbdhaoCeXRR +DoCkKvbdmfdwlnGy +EPCjjvbdjbkjqGuH +DoDKjvbdlqyVZsEJ +DnbjjvbdWWiYVcdg +EOcKjvbdeATqMwjG +EOcKjvbdqUTgSSKt +DncKjvbdqwQMDJZR +EPCkKvbdsQVoJbuf +DoCjjvbdVTmUFlVj +DoDKjvbdmajWxPOV +EOcKjvbdUQpoUthN +DoDKjvbdwMvAMdEm +EPDLKvbdDnbkLXDE +DncLKvbdFfKSNiTq +DncKjvbdIryBSlwl +DoDKjvbdmgEwlmfy +DncKjvbdqwPkbhyR +DncLKvbdNeETiJKd +EObjjvbdDoCjkXCd +EObkKvbdjgflFfNk +DncLKvbdxsNhlrCH +DoCjjvbdeFOrCWbj +EObjjvbdkNBkzFHP +DoCjjvbdxrmiNSCH +EOcLKvbdVwJXvDeH +EPCkKvbdZRMdhmEq +EObjjvbdjSzhsKiz +DoCkKvbdqdEiQOVa +EOcLKvbdpaJFAWhE +EPDLKvbdRkYfVGjs +DncKjvbdMpXqWNgT +EOcLKvbdVYhUZkPO +DoCjjvbdUxhTyjnn +DoCkKvbdOYOuzcmt +DoDKjvbdZLqdUNlN +DoDLKvbdJSyBTMxM +DoDLKvbdYORAXtut +DncKjvbdHffzYxXg +DncLKvbdmpZyVjyC +EOcKjvbdmfeXlnGy +DoDLKvbdkHfkeenL +DoDLKvbdJTZBSmYM +EObkKvbdrMzKZMHi +DncLKvbdiLeDmuCy +DoDKjvbdjvXNcbYX +DnbkKvbdrJAJeMne +DoDLKvbdvlvAMdFN +EPCjjvbdZLrDsmlN +DnbjjvbdaaVdfPpX +EObkKvbdrbFlkfjy +DoDKjvbdGLErbhNV +DoCjjvbdCIkCKhfK +DnbjjvbdeEoSBwDK +DncLKvbdirziSjiz +EPDKjvbdwzIGGYEr +DncKjvbdbVCGwkTh +EObkKvbdakMFnmcA +DnbkKvbdRpUHKFdX +DoDLKvbdMSWlytpz +DncLKvbdpssgRrKt +EPCjjvbdZRMeImEq +DoCjjvbdqrVKmjaN +EObjjvbdjAQGaPfj +DoDLKvbdyqOmJJwA +DnbjjvbdQccApRES +DoDLKvbdIsYaSmXl +EPCjjvbdrovPKDWG +EPDLKvbdqdEhpOVa +DoCkKvbdVviYVdEg +DoCjjvbdqZPIGqEY +EPCkKvbdOTTvGeVQ +DoCkKvbdDncLLXCd +EObkKvbdvBEYsOeI +DoCjjvbdYORAYVVt +EOcLKvbdhgKCxuiu +DoDKjvbdddoRbWcK +EObkKvbdmoyyWKyC +EOcLKvbdyYJJbQZk +DnbjjvbdUyIUZkPO +DncKjvbdFyUuBDxC +DoCjjvbdnQZyVjyC +DoDLKvbdatbHYKsh +DoCjjvbdczYowxpb +DncLKvbdIsZAsMxM +EPDKjvbdGKeTChMu +DoCkKvbdptTgSRjt +EPDKjvbdMtrqjmAX +DncLKvbdKQzEoFme +EObjjvbdFxtuAcxC +DncKjvbdkDLkRHVH +EPCkKvbdunszqKnt +DoCkKvbdezuxeJTw +EObkKvbdzjVQQDsU +EPDLKvbdjKGIKMxS +DoCjjvbdcyyQXxqC +EObkKvbdhtydwRtb +DnbjjvbdfNGXHNKL +DoDKjvbdmoyxujxb +DncLKvbdmuVZkJqf +EObkKvbdZyDjNbkr +DnbkKvbdyXhiaozL +EObkKvbdKWUfDeHJ +DoCkKvbddoFTLUUS +DnbjjvbdJvUfEFHJ +EObjjvbdsrqrxzFD +EObjjvbdmgFYMmfy +DnbjjvbdbrcLTcjB +EPDKjvbdZtIiZETO +DncKjvbdSLZGVHLT +EObjjvbdhtzFXSVC +EOcKjvbdvAcxsPEh +EOcKjvbdbrbjsdKB +DoDKjvbdezuxdiTw +DoDKjvbdhkdcnVDZ +DoCkKvbdNddUJIkE +DnbjjvbdsCGMlGjy +EOcKjvbdssSSxydc +DoCjjvbdSPtHJfDw +DoDLKvbdmRyVZrdJ +EOcLKvbdBdQBVjNG +EPCjjvbdtvOXipsA +EOcLKvbdDwwlUUUM +EObkKvbdhkeENuDZ +EOcKjvbdwygfGYEr +DncKjvbdbsCkUEJa +DnbkKvbdvlvAMceN +EPDKjvbdTvMPitAq +EPDLKvbdMowpvOHT +EOcKjvbdNQXpvNgT +DncKjvbdYzcFqiuy +EObjjvbdqUUGrRjt +EOcKjvbdUaBqTRSZ +DnbjjvbdrafMkfjy +DncLKvbdmgFXmNfy +DncKjvbdNrtVfdtp +EOcKjvbdVZITyjoO +EPDKjvbdTukpJtBR +DoDLKvbdyOTHxTIc +DnbjjvbdsBfNLfkZ +EPCjjvbdmJDtRVSB +EObjjvbdmJDtRUrB +DnbjjvbdiVZeWrVC +DncKjvbdBiKajhfK +DnbkKvbdziuQPcsU +EOcKjvbdGFiqnJTq +DoCjjvbdAMhZTXZx +DncLKvbdDjHiuwjA +DnbkKvbdBdQBVjNG +EPCjjvbdqlzKYkgi +DncLKvbdLLBIWAJy +DncLKvbdbhljKfXY +DncKjvbdaogHELzd +DnbkKvbdjEkGtoAO +DnbjjvbdGdKvJbKK +EPDLKvbdqrUjnKaN +EObjjvbdnVUykKSG +EPDKjvbdVrNwbFMD +DoDKjvbdvlvAMdEm +EPCjjvbdaaWEeopX +EPDLKvbdULuoBVoJ +EPDLKvbdzjUpPcsU +EPDKjvbdZnnJEdyj +EPDKjvbdtlXwAsaX +EPCjjvbdjJfHimXr +EPCkKvbdxwiKBpZk +DoCkKvbdLiBlQxAS +EObkKvbdXFxytAOs +EObjjvbdnQZxukYb +DncKjvbdZxcjNcMS +DnbkKvbdQcbaQQcr +EObkKvbdVgxVwgYz +DoDLKvbddoEsLUUS +EOcKjvbdTppnttgm +DoDKjvbdBhkBjhej +EPCkKvbdlhcsqVRa +DoDKjvbdZshiYcsO +DoDKjvbdtcDUvvPP +DnbkKvbdRkZFuGjs +DoCkKvbdaaVeFopX +EObkKvbdYORAXtut +DncLKvbdqwPlDJYq +DoDLKvbdbBWEepPw +DnbkKvbdVvhxWDdg +EObkKvbdfHkVqmpg +DncKjvbdaMjartmH +EPCkKvbdBhjbLIej +DoCjjvbdCIjbKiFj +DoDKjvbdkIHLefOL +EOcKjvbdrbGMlGkZ +DncLKvbdPxmAGsRj +EOcKjvbdZxdKODMS +DncKjvbdkDLjqHUg +EOcLKvbdjEkHUoAO +DoDLKvbdrovOjDVf +DncLKvbdZshiZESn +DncKjvbdUyIUZjnn +EPDLKvbdxmrhYSiD +DoCjjvbdaNKasUlg +DnbkKvbdYqMeJMdq +DncKjvbdZoOIeEyj +EOcKjvbdemGXGlik +EObjjvbdyzdnRhIh +DncKjvbdHEKvJbJj +EObkKvbdSCDdlIxk +EPCjjvbdGAoQxizm +DoCjjvbdaNKasVMg +EObkKvbdePErkTtS +EPCjjvbdlhdUQuSB +EPDKjvbdNQXpvOGs +DoCkKvbdXnRAYUut +EObkKvbdcTCkUEKB +DncLKvbdmRyUzSdJ +EPDLKvbdrSVLNkAm +DoCkKvbdJvUecdgJ +DoDLKvbdRDbaQRDr +EPDKjvbdYlSETmlN +EPCkKvbdbUagYKtI +EPCjjvbdssRrxzFD +EPCjjvbdRMwbYmtz +DnbjjvbdxrmhmRag +DoDKjvbdTvLpJtAq +EPDKjvbdVBBprprZ +DnbkKvbdRkYeuGkT +EOcKjvbdmbKWwoOV +EOcKjvbdZeYGzghb +EPCjjvbdFeirOJUR +DoCkKvbdZsiIxcrn +EPDKjvbdDnbkKvcE +DoDLKvbdsrrTZZeD +DncKjvbdJbjCpicY +DnbjjvbdcyxpXxpb +EPCjjvbdrXQLbhxq +DncKjvbdzROmJJwA +DoDKjvbdqdFIpNvB +EPDKjvbdkHfkfGNk +DoDKjvbdFjdsDINV +DoDKjvbdUyITyjoO +EOcLKvbdiUzEwRtb +EPCkKvbdmfeYMmgZ +DncLKvbdHgGyyXxH +EObkKvbdMuTSLNAX +DncKjvbdtbcUwWOo +DoCjjvbdVwIxWEFH +EOcKjvbdhgJcZWKV +DoCjjvbdsCFllHLZ +EPDKjvbdGcjvJbKK +EOcLKvbdnGeYNNfy +DncKjvbdZnnIeFZj +DoDKjvbdxUldqZLn +EOcKjvbdrovOibvG +DoDKjvbdUWLpKTaR +DncKjvbdePFTKtTr +EPDLKvbdFxtuAdYC +DoDLKvbdfIKvRnQg +EPDLKvbdypnmIjXA +DncKjvbdbUagYLUI +EPDKjvbdnVUyjiqf +EObkKvbdKWVGDeGi +EObkKvbdaNKbSuMg +DoDKjvbdNVSqkNAX +EObkKvbdhbPDFWqR +DoDLKvbdLGFhBaRV +EOcKjvbdbrcLUDjB +EObjjvbdZHXEAPTJ +EPCjjvbdCSaDTevr +DncLKvbdgQBzvcxI +EObjjvbdidjfuPAO +DoDLKvbdzjUoodTU +DncKjvbdGLEsChNV +EPCjjvbdNeDshiLE +EObjjvbdGGKRnIsq +EObkKvbdeYZtTqez +EOcKjvbdQwODblHc +DoCkKvbdkClLRHVH +EPCkKvbdxUldqYkn +EPCkKvbdvBDxsPFI +DnbkKvbdqvpLcIyR +DncKjvbdqmZixkhJ +DoDLKvbdkVwNdCYX +EObkKvbdUxgsykPO +EPCkKvbdjcLjpgUg +DnbjjvbdbUagYKtI +EObjjvbdDjHjWXjA +EObjjvbdrykpSaIO +EObjjvbdrbGMlGjy +DncLKvbdVYhUZjnn +DoDLKvbdjlakydfo +DnbkKvbdVTmUGMVj +EObjjvbdZjTIQHCG +EOcLKvbdZxcjNcLr +DoCkKvbdqTsgSRjt +DnbjjvbdCIkBkJFj +EPCkKvbdaogHELzd +EPCjjvbdNPxQunGs +EObjjvbdxZhFfXeS +DoDKjvbdjblKqHUg +EObkKvbdNPxRWNgT +DoDKjvbdkaNOmALA +EPDLKvbdxsOImSCH +EOcLKvbdZshhyETO +EPDLKvbdIHHZyYYH +DoDKjvbdliEURVRa +EObjjvbdiVZeXRtb +EOcKjvbdiHJcYvJu +EOcKjvbdIsYaTNXl +DoCkKvbdtlXvaTaX +EOcKjvbdNQYRVnHT +DoDKjvbddjJqvUzn +DoDKjvbdULuoBVoJ +DoDLKvbdUslselVj +EPCkKvbddePSCWbj +EPDKjvbdNeDtIiKd +EOcKjvbdiUzFXSUb +DoCkKvbdmRyVZsEJ +EPCjjvbduLwwAtBX +EPDLKvbdxZgfGXdr +DnbkKvbdBcpAujNG +DnbjjvbdZtJIyDrn +EObjjvbdmbJvwnmu +EPCjjvbdXnRAYVWU +EOcLKvbdyOShXsJD +DoCjjvbdptUGqqkU +DnbkKvbdFpASwHGZ +DnbkKvbdwtleRYlO +EPCkKvbdnHFYMmfy +EPDKjvbdKCjDQjDY +EObkKvbdeqaWzlDP +DoCkKvbdbLMGPODA +DoCjjvbdpyPIGqDx +EOcKjvbdbhmKLFwY +DoDLKvbdEOcKjwCd +EPCkKvbdePFTKtUS +EPCkKvbdtvNwipsA +EPCkKvbdzoQQdblY +EOcLKvbdKjaHvAJy +EPDKjvbdvPTzpkOt +EPDKjvbdMJCLpxAS +EObkKvbdWWhwvEEg +DnbkKvbdcJNJjevx +DoCkKvbdNQXpunGs +EPDKjvbdWSNxBdlD +EPDKjvbdwyhFeweS +DncKjvbdddnrCWcK +EObjjvbdeKJrVtzn +EObjjvbdrykosBIO +EPDKjvbdiiehKMxS +DncKjvbdrWpMCiZR +DoCjjvbddoFSjssr +DoCjjvbdbhmKKfWx +EObjjvbdmajWwoNu +EOcLKvbdDxYLstUM +EPCjjvbdddoRawDK +DncKjvbdmuUzKjSG +DoDKjvbdLFegbBRV +EPCkKvbdySnJMqbH +DnbjjvbdLLAgvAKZ +EPCjjvbdraemMHLZ +EObjjvbdnUtzLKSG +EPDKjvbdkDMLQgVH +DoDKjvbdkHgMGGOL +DoCjjvbdxsNiNSCH +EObkKvbdNQXpvOHT +EObkKvbdQwNdDLgc +DnbjjvbdegkWRnRH +DnbkKvbdGZUuAcwb +DncLKvbdiMEcmuCy +DoDLKvbdFfJqnJTq +DoDKjvbdZnnJFEzK +EOcLKvbdTqRPUtgm +EOcLKvbdRjyFuHLT +EOcKjvbdhtzEwRtb +EObjjvbdTXjkmzjx +DoDKjvbdqdFJQOVa +DoCkKvbdGckViajK +DncLKvbdDxXlUTsl +EOcLKvbdeUAUASlv +DnbkKvbdzjUpQETU +DnbkKvbdtcCuWuoP +DncLKvbdauBgXkUI +DoCjjvbdUVlPitBR +DnbkKvbdFfJrOItR +DoDLKvbdxnSgwsJD +EPCkKvbdXsMBNToY +DncLKvbdCTAcUFwS +DoDKjvbdhgJbxvJu +DoDLKvbdhkeDnUby +EObkKvbdEvZPpNKF +EPCjjvbdiHJcZWJu +EObjjvbdIHHZyYXg +DoCkKvbdegkVqmqH +DoCjjvbdxVNFRZMO +DoDLKvbdUQpntuIN +DoDKjvbdEJhJuwjA +DoDKjvbdkHflGGNk +DnbkKvbdmttykKRf +DncLKvbdZxdJmblS +DnbjjvbdZQmEhmEq +DoCjjvbdJcJcQjDY +DoDKjvbdBhkCLIej +DoDLKvbdmIcspuRa +DnbjjvbdqiAKElne +DoCjjvbdJpzEoFnF +EOcKjvbdyOShYTJD +DoCkKvbdmuVZjiqf +DoDLKvbdSCDeLhyL +EOcKjvbdJvUedFGi +EObkKvbdehLWRnRH +EPDKjvbdxmrhXriD +DoDLKvbdOTUWGeVQ +EPCjjvbdzRPMhiwA +EPDKjvbdKRZePGOF +DoCkKvbdrDeIomvB +EPDKjvbdkVvmdBww +DoDKjvbdIGfzYwwg +EPDLKvbdFVyPpNKF +DoDKjvbdhytfLqNf +DnbjjvbdMfbomQUk +EOcLKvbdtcDVXWOo +DoDKjvbdqwPlDJYq +EOcLKvbdZshiZETO +EOcLKvbdeEnrCXCj +EOcKjvbdZLrDsnLm +EPCjjvbdLYqKSzuG +DncLKvbdMtsRjmAX +DoCjjvbdJTZArlxM +EPCkKvbdlZSrTZGt +DncKjvbdRyjITCvA +DoCjjvbdEuxpPmKF +DnbkKvbdTYKkmzjx +DoDLKvbduDDVXWPP +DncLKvbdjAPfaPgK +DncLKvbdrEFJPnVa +EPCjjvbdrXQMChyR +DnbkKvbdznpQeDLx +DoCkKvbdjgflFfOL +EObjjvbdjlalZdgP +DoCjjvbdtbcUvvOo +DoCkKvbdrEFIonWB +EObjjvbdwXMAvAuu +DncLKvbdePFSkUTr +EPCkKvbdTppoUuIN +EPDKjvbdIxUCHlQp +DnbkKvbdBiLBjiGK +DoDKjvbdliDspuRa +EObjjvbdFkFTDIMu +EPCjjvbdsQVnjDVf +EPCjjvbdKefIBaRV +DoDKjvbdIryAsNYM +DoCkKvbdsrqrxzEc +EPCjjvbdLqwNZuQz +EOcLKvbdcIlikGXY +DoCjjvbdADSXizIp +DoCkKvbduaEZTOeI +DncKjvbdvBDyTPEh +EPCkKvbdRkZFuHKs +DoDLKvbdSLZFuGkT +EOcLKvbdfekzOHHA +EOcLKvbdkaMoNALA +DncLKvbdkNCMZeGo +EObjjvbdNsUVfduQ +EPCjjvbdZoNiEeZj +DoDLKvbdLYpirzuG +EPDKjvbdmoyxujyC +DoCkKvbdaMjbSuNH +EPDLKvbdxxIjCPzL +DnbkKvbdVAaqSprZ +DoCjjvbduVmxJqTA +DoCkKvbdRkZGVHLT +DoDKjvbdEuyQPljF +DnbkKvbdptUHSRkU +DncLKvbduLxWaUAw +EObjjvbdaaVdfQQX +EPDLKvbdWWiYVdFH +EOcLKvbdfelZmgHA +DoCjjvbdADRxKZiQ +EOcKjvbdfHkWSORH +EObkKvbdTAEiIBoE +DncKjvbdEKIKVxKA +DoCkKvbdkDMKpgVH +DnbkKvbdCWzciEpW +EObjjvbdxZgefXeS +EOcLKvbdsZkpTBIO +DoDLKvbdrJAKFMne +EPDKjvbdkWXNdBww +DnbkKvbdRbEFLhyL +DncLKvbdWXJYWDeH +EOcLKvbdijFgjMwr +DoDLKvbdnHExMnGy +EObkKvbdZeYGzhJC +DnbjjvbdEvZPpMie +EObjjvbdYpldiMdq +DoCjjvbdfRaWzlCo +EPCjjvbdGYtuBDxC +EOcLKvbdQYmAGrrK +EPCkKvbdlhcspuSB +DoDLKvbdezvZFIsw +EOcKjvbdlYsSTZHU +DnbkKvbdmfeXmOGy +DncLKvbdKDKDQicY +DncKjvbdZjTIQHCG +DnbkKvbdgFkzOHHA +DnbkKvbdaNLBsVNH +DoCjjvbdBsBCtGWr +DncKjvbdqdFIomvB +DnbkKvbdkNBlZdfo +DnbkKvbdSQTgKGDw +DoCkKvbddoFTLTsr +DoDKjvbdEYYLtTtM +EOcKjvbdVwJYWEEg +DoDLKvbdyOSgwrhc +DoCkKvbdZMRdUOLm +DoDLKvbdYSlBMtOx +EPCkKvbdkxsRsYft +DnbkKvbdrzLpTAgn +DncKjvbdRjxfUgKs +DnbkKvbdqquLNkAm +DoDLKvbdRMxCYnUz +EPCjjvbdZoOIdeZj +EObkKvbdrpWOicVf +EPDLKvbdkCkjqHVH +EOcKjvbdmSZUzSci +EObjjvbdRjxfUgLT +EObjjvbdNddThhjd +DoCjjvbdKVuFcdfi +EPDKjvbdzjVPodTU +DncKjvbdJTYaSmXl +DncKjvbddZyQXyQb +EPCjjvbdCIkCKiFj +EPDKjvbdTkunaWOi +EObjjvbdfIKuqnRH +DoCjjvbdZRMdiMeR +DnbjjvbdMpXpunHT +DoDLKvbdZRNEhmFR +EObjjvbdaoffdLzd +DoDLKvbdvAdYsOdh +DnbjjvbdSLZGUgLT +DoCjjvbdSCDdkiZL +DoDLKvbdelewHNKL +DoCjjvbdRXNdDMHc +EObjjvbdkWWnDaww +EObjjvbdcyxoxZRC +DncKjvbdelfWfljL +EObjjvbdZnnJEdzK +EOcKjvbdkHflGFnL +DoCkKvbdhbPCdwRR +EPDLKvbdHDkWKCKK +DnbkKvbdRadEkiYk +EOcLKvbdFWYopNJe +DoDLKvbdqTsfrSKt +EObjjvbdxnSgxTJD +EPDLKvbdxZhFewdr +EPCkKvbdTvLojTaR +EObjjvbdfIKuqnQg +EPCjjvbdDxXlTssl +EObjjvbdQvmccLhD +EObkKvbdRNXayOUz +EPCjjvbdatbGxLTh +EOcKjvbdOSsvGeVQ +EPDKjvbdePFTKstS +DnbjjvbdlYsRsZHU +DnbjjvbdZisIQGaf +DoCkKvbdsrqsYzEc +EObjjvbdfILVqnRH +DnbkKvbdZHWdAPTJ +DoDLKvbdEPCkLXCd +EObjjvbdEXwktTsl +DncLKvbdFVyQPlie +DncKjvbdNsUWHEtp +EOcKjvbdyqOmJKXA +EOcKjvbdADSYJyhp +EPDKjvbdUyIUZjoO +EOcKjvbdmJEURVSB +DnbjjvbdIwtBgkpp +EPCjjvbdZQmEhldq +EPCkKvbdDjHiuxKA +DoDKjvbdrEEiQOVa +DncKjvbdKDKDQjCx +DncKjvbdZRNFJMeR +DncLKvbdwygeeweS +DncLKvbdnUuZkKSG +DoDKjvbdvwMAvBWV +DoCjjvbdBhkCLIfK +DnbjjvbdoznDkXoA +EOcKjvbdjgflFemk +EObkKvbdKVtfDdgJ +DnbjjvbdXrkaNUPY +DncKjvbdhlEdNtby +EPDKjvbdemGWfmJk +DoDLKvbdlhctQtrB +EObjjvbdnVVZkJqf +EObjjvbdwuNEpyMO +DoCjjvbdTpqOuVHm +EObjjvbdbLLennDA +DoDLKvbdiGjDZWKV +EPDLKvbdFjeTDHlu +DoDLKvbdDxYLstUM +EPDLKvbdiUzFXSVC +DncKjvbdJYTbHkpp +DoCkKvbdZshhxdSn +EPDKjvbdxrnIlqag +EOcLKvbdiHJcYvJu +DnbjjvbdkVwNcaxX +EObjjvbdpyPIGpcx +EPCkKvbdauCGxLUI +EObkKvbdWRnXadkc +DnbkKvbdVUNUGLvK +EObkKvbdDxYLsssl +DnbkKvbdCJKbKhfK +DncLKvbdbhmKKfXY +EOcLKvbdZoOIeFZj +DoDLKvbdkNCLzFHP +EObkKvbdpxnggQdY +EObkKvbdYqNFJNEq +EPCjjvbdyzdnSHhh +EOcKjvbdczZQYZQb +DncKjvbdZyDimblS +DncLKvbdyOTIXrhc +EObjjvbdhzUelQnG +EObjjvbdFjeTChNV +DoCjjvbdwMvANEEm +DoDLKvbdRXOEDMID +DncKjvbdiHJcYvJu +EOcLKvbdhtzFWrVC +DncKjvbdVYgsykPO +DoCjjvbdGGKRmiUR +EPDLKvbdQmXbYnUz +DnbkKvbdkIGlFemk +DoCjjvbdSPsgJfDw +DncKjvbdzjVQPcrt +EPDKjvbdmfdxNNfy +EPDKjvbdZyDimblS +DoDKjvbdANIZSvzY +DoCkKvbdJqZdoGOF +EOcKjvbdcJMijewY +DncLKvbdNQXqWNfs +DncLKvbdkNBlZeGo +DoCjjvbdHffzZYXg +DoDKjvbdjhHMGGOL +DnbkKvbdiCObdvpq +DoDLKvbdYlRctNkm +EObkKvbdiUzEwRuC +DncLKvbdMfbomPuL +EPCkKvbdlZSrSyGt +DncLKvbdvAcxroFI +DoCjjvbdNGcQNQUk +DncKjvbdWSNxBeLc +EPCkKvbdqvokcIyR +DncLKvbddZyQXxqC +DoCkKvbdvPTzqLPU +DncLKvbdZxcjNblS +EPCjjvbdkMbLzFHP +EPCkKvbdlYrqsYgU +DnbjjvbdWSOXbFMD +DnbkKvbdWeyZtAPT +EPCkKvbdEKHivYKA +DoCkKvbdkNBkyeGo +DoDLKvbdiBoDEvqR +DoDLKvbdRkYfVGjs +EOcKjvbddneSkUTr +EObjjvbdFejRnItR +DncLKvbdLAjgMbXq +DnbkKvbdUGznLwVe +DoDKjvbdLqwNZtpz +EPDKjvbdUxhTyjnn +EPDLKvbdkNBkyeHP +DoCjjvbdgFkzNgHA +EObjjvbdunszpjnt +EPCkKvbdtAHQhABS +DnbjjvbdbKkfOnDA +DoCjjvbdVviYWEFH +DoCjjvbdGZUuAdXb +EObjjvbdhlFDmuCy +DncLKvbdyfyMAMdw +EObjjvbdFyUtaDxC +DnbkKvbdeEoSCXDK +EOcKjvbdbVCGwjtI +EOcLKvbdTAEhgand +EObkKvbdRpUHJecw +DnbjjvbdZsiJZDrn +DncLKvbdtSqrxyeD +DoDKjvbdJSxaSmYM +EPCkKvbdjuvnECYX +DoDLKvbdrMyjYkgi +DnbkKvbdjJegjNXr +DoDLKvbduaDxsOdh +DoDLKvbdmIcsptrB +EObkKvbdFkFTDHmV +DnbjjvbdYORAYVVt +DncLKvbdddoRbWcK +EPDLKvbdLrWmZuQz +DoDLKvbdliETpuRa +DoCjjvbdbrcKsdKB +DoCkKvbdHkazmvpk +EPCjjvbdUaBpsRRy +EObkKvbdKfFhBaQu +DoCkKvbdKQydnfNe +EOcLKvbdDjIKVxKA +DncKjvbdpeceUWBI +DncLKvbdKaLHNBxR +EPDLKvbdptTfrRkU +EPDKjvbddndsLTtS +EObjjvbdMpXpvOHT +DnbkKvbdaMjaruNH +DoCkKvbdpecdtVaI +DncLKvbdRpTfjGEX +EObkKvbdCSaCsevr +DoCkKvbdnHEwmNgZ +EObjjvbdfHjuqmqH +DoDKjvbdKWVGDeGi +DoDLKvbdWHxVxHYz +DnbjjvbdXsLaMsnx +EPDLKvbdDjHiuwjA +DnbjjvbdaaWFGQQX +DnbjjvbdsrrTZZdc +DoCjjvbddneTKtUS +DoDKjvbdcJMjLFvx +DoDKjvbdaNKbTUlg +DnbjjvbdkHflFfOL +EObjjvbdJpzFOeme +DoCjjvbdrounibuf +DoCjjvbdHgHZxwxH +EOcLKvbdSKxeuGkT +EOcLKvbdzQoNJJwA +EObjjvbdZnnJEdzK +DoDLKvbdJuuFcdfi +DncKjvbdIryBSmYM +EObkKvbdyYJJaozL +EObjjvbdFkEsDHmV +DnbkKvbdfMfXHMjL +DnbkKvbdLGGIBaRV +EOcLKvbdRXNdDMHc +DoDKjvbdegjvRnRH +DnbkKvbdKeegaaQu +DnbjjvbdkMakzEgP +DoDKjvbdcTDKtEKB +DncLKvbdhaoDEvqR +DncLKvbdmgEwmNfy +EPDKjvbdCIjbLIfK +DncLKvbdJvUedEgJ +DoCjjvbdFVxpPljF +EOcLKvbdJYUCIMRQ +EPDKjvbddwyssrFz +DoDKjvbdiMEdOUcZ +DoDKjvbdZQleIldq +EPCkKvbdnQZyVkYb +DoCjjvbdNGbpNPuL +DoCkKvbdOStVgFVQ +EOcKjvbdGBPQxizm +DnbjjvbdOXoVzcnU +DncKjvbdyqPNIiwA +DoDLKvbdkIGlGGNk +EPDKjvbdbiNKLFvx +DoCkKvbdCTBCsfWr +DoDKjvbdShyjRABM +EPCjjvbdxwhjBozL +DoCkKvbdqUUHSSLU +DoDKjvbdbBVdfPow +DoCkKvbdqYnggRDx +DoCkKvbdtkwwAsaX +EPDLKvbdZMSDsnMN +EPDLKvbdZjTIQGbG +EPCjjvbdzoPpdblY +EPDKjvbdVviYWEFH +DnbjjvbdUsltGLuj +DoCkKvbdQdDAopcr +EPDKjvbdZxcjNbkr +EPCjjvbdZisHpGbG +EPDKjvbdEuxpPmKF +EOcKjvbdQwNccLgc +EPCjjvbdEYYLstUM +EObkKvbdZRNEhmEq +DoDKjvbdaRfDIUGL +DncKjvbduaDxsOeI +EObkKvbdmaiwYPOV +EOcKjvbdKDJbqJbx +DoDKjvbdQvnEDLgc +DnbkKvbdtlXvaTaX +EPDKjvbdzQoNIiwA +EOcLKvbdNeDsiIjd +DnbkKvbdBdQAvJlf +DoCkKvbdhzVGMROG +EPDLKvbdUaCQsRRy +EOcLKvbdZisHogCG +DoCkKvbdlqxtzTDi +DoCjjvbdRkZGUgKs +EObkKvbdZnmhdeZj +EOcLKvbdZjTHogBf +DncLKvbdhytfLqNf +EPCkKvbdnPyxvKxb +DncLKvbdjcMKqHVH +EPCkKvbduWNwjRTA +DnbkKvbdwygfGXeS +EObjjvbdTlWOaVoJ +EPCjjvbdUtNUGLvK +EObkKvbdKkAgvAKZ +EObkKvbdaMkCTUmH +EPDKjvbdOFDshhjd +EPDLKvbdhzUfLpmf +EPCkKvbdkySrTYgU +EOcLKvbdFfKSNhsq +DncKjvbdOAJTUKSA +EPDLKvbdrDeJPmvB +EPCkKvbdKRZdnfNe +EPCjjvbdRDcAoqDr +EOcKjvbdNHDQNPtk +EOcLKvbdVTmTfMVj +EOcKjvbdrXQMChyR +DoCjjvbdZQmFJNEq +EPCkKvbdWRmwadkc +EObkKvbdSCDeLhyL +DncKjvbdyNsHxTJD +EPDKjvbdtSrTYydc +DoDLKvbdiGjCxuiu +DoCkKvbdrNZjZLgi +EPDLKvbdJmADzGuB +DncLKvbdtcCuWuno +DnbjjvbdDxXktTtM +EPCjjvbddZyPxZQb +EPDLKvbdlqxtysDi +DoDLKvbdbAueGPpX +EObjjvbdVviXvDdg +EPDKjvbdBdQAvKMf +DnbkKvbdPxmAHSqj +DoDLKvbdUsltFlWK +DncKjvbdVhYWYHYz +DoDKjvbddwzTtSFz +DncLKvbdIGfzYwwg +EPCjjvbdmJDsqUrB +EPCkKvbdGQASwGey +EOcLKvbdTlWOaVoJ +DncLKvbdLFehCBRV +DnbjjvbdTkvOaVoJ +EPCkKvbdwXMAvBWV +EObjjvbdpxnhGqDx +EOcLKvbdsrqryZeD +DoDLKvbduVnXjQsA +DncLKvbdRotHKFdX +EOcKjvbdnUtyjirG +EOcKjvbdCJLCLJFj +EOcLKvbdSCEFLiYk +DoDLKvbdjcMLQgVH +DoCkKvbdLBLGlaxR +EObkKvbdZQldiNFR +EOcLKvbduMXwAsaX +DncKjvbdxrnIlrBg +EObkKvbdehKvRnRH +DoDLKvbdRosfiecw +DoCkKvbdFjdrcINV +EPCjjvbdkWWmdBxX +DnbjjvbdFkFTDHlu +DoCjjvbdTAEhgaoE +DoDKjvbdANIZTWyx +EObkKvbdJSyAsNYM +EPDLKvbdqTtHRqkU +EPDKjvbdbBVeFoow +EPCkKvbdYSkaMsoY +DncLKvbdDnbkKwDE +DncKjvbdMSWlzUpz +DncKjvbdauCHXjsh +DoCjjvbdTvMQKUBR +DoDLKvbdrRuLOLAm +EOcKjvbdatbGxKtI +DncLKvbdNGcQMotk +EPDKjvbdiCObeWqR +DoDKjvbduDDUwVno +DncLKvbdYlRcsmkm +DncKjvbdbAueFoow +EObkKvbdYTMBNToY +DncKjvbdvAdYsPEh +EObjjvbdBdQBWKMf +DnbkKvbduCbuWuno +EOcLKvbdKWVGEFHJ +EObkKvbdcyyQXxqC +DnbkKvbdaMjasUmH +EPCkKvbdmgEwlmfy +DoDLKvbdrDdiQOVa +DoDKjvbdUyIUZjnn +DnbkKvbdnBjXYOnV +EOcKjvbdRpTgJfDw +DncKjvbdjcLjqGuH +DnbkKvbdZjTIQHCG +EOcKjvbduVnYKRTA +DnbkKvbdGckWJbKK +EObjjvbdZyEJnDMS +DncKjvbdNsUWGduQ +EObjjvbdKQzEoFme +EOcKjvbdVUMtGLvK +EPDKjvbdrJAKFMoF +DoCkKvbdNrsvHFVQ +DncLKvbdSKyGUfjs +DoCkKvbdVvhxWEFH +DncLKvbdFejRnIsq +EObjjvbdVYhUZkOn +DoCjjvbdxUmEpxkn +DoDLKvbdBiLCKhej +DoDKjvbdIjEAJofd +EOcKjvbdwzHfFwdr +DncKjvbdFjeTDHlu +DnbjjvbdbiMjKewY +DnbjjvbdaNLCTUlg +EObjjvbdDwxMUUTl +DoCkKvbdmttykKSG +EPDKjvbdiUyeXSVC +EPDLKvbdWIYVwfxz +EPDLKvbdemFvgMik +DoCkKvbdUyHszKoO +EObkKvbdTXkMNzjx +DoDKjvbdSQTgKFdX +DnbjjvbdLiBkpxAS +EPCkKvbdRosgKGEX +DoCkKvbdmfdwmNgZ +DncLKvbdiHJbyViu +DncLKvbdxrnJMqbH +EOcKjvbdhlFENtcZ +DoCjjvbdbKkennDA +DnbkKvbdGckWKBjK +DnbjjvbdUyIUZkOn +EPDKjvbdeEnrCXDK +EOcKjvbdsBfMkgKy +DncKjvbdxsNiNSBg +EPDKjvbdkNCLzEgP +EPDKjvbdSKyGVGjs +DoDKjvbdrWolChyR +DncLKvbdWSNwaeLc +EOcKjvbdJYTbHkqQ +DnbjjvbdZshiZDsO +DoDKjvbdSKxfUfjs +EPCkKvbdptTgRrKt +EPCjjvbdREDApQdS +DncLKvbdtvOXjRTA +EPDKjvbdemGXGljL +EObjjvbdBdQAvJmG +EPDLKvbdhuZdwRuC +DncLKvbdjvWnDaxX +EPDLKvbdFVxopMie +EPCkKvbdajkeoNcA +EPCjjvbdSPsfifEX +DnbkKvbdBsAcTfWr +EPCjjvbdEOcLLWcE +DoCjjvbdZLrDsmlN +EPCkKvbdxnSgxTIc +EObjjvbdGQATXGey +EObkKvbdbsDLUEKB +DoCjjvbdrSVKmjaN +EPCkKvbddneTLUUS +DoCkKvbdxmrgwsJD +EPDKjvbdGYuVAdXb +DncLKvbdauBfxLTh +EPDLKvbdrMzKZLgi +EObkKvbdUsltGLvK +DnbjjvbdDxXlTstM +EObkKvbdsBfNLgLZ +DncKjvbdidjgUoAO +EPDLKvbdJJdAKQHE +EOcKjvbdbBWFFpQX +EPCjjvbdSZihTDWA +EPCkKvbdhgKCxuiu +DncKjvbddneTLUTr +DoDKjvbdczZPxZRC +DnbjjvbdlYrrTYft +DoDKjvbdWXJXvEEg +EPDLKvbdbhmJkFvx +EPCjjvbdDxYLtTsl +EPDKjvbdqdFIonVa +EObjjvbdCIjbLIej +DnbjjvbdmbKXXnmu +EPDKjvbdlZTSTYft +EPDKjvbdwXMBVaWV +DnbjjvbdSPtGjGEX +DoDKjvbdrMzKYlHi +EPCkKvbdiVZdwSVC +DnbjjvbdptUHSSKt +DncLKvbdcSbjscjB +DoDKjvbdSPsfiecw +EOcKjvbdegkVqnQg +EObkKvbdjuvmcbXw +DncKjvbdCJLCKhfK +EObjjvbdVqnYBeMD +DoCjjvbdKCjCqJcY +DncLKvbdZRMdhmEq +EOcKjvbdrRtkOKaN +DoDLKvbdRpTfiedX +DoCjjvbdRMwbZOUz +DoCjjvbdrXQMDIxq +EObjjvbdsrqsZZdc +DnbjjvbdfjfzbfAE +DoCkKvbdJSyBTMxM +EPDKjvbdnCJvwoNu +DoCjjvbdmbJvwoNu +DnbkKvbdFWZQPljF +DncLKvbdxnSgwriD +DnbjjvbdVvhwucdg +DoCjjvbdjgfkfFnL +DncLKvbdzRPMiKXA +EOcLKvbdqZPHgREY +EPCkKvbdrylPsAgn +EPCkKvbdVZITykPO +DoCjjvbdhkeEOVDZ +EOcKjvbdUVkpJtAq +EOcKjvbddCTMrAUN +EPDKjvbdZeXfzghb +EPCjjvbdiMFDmuDZ +EPCjjvbdJKEAJpHE +EOcLKvbdajkeoODA +DnbjjvbdZRNEhmFR +EOcLKvbdNHCpNQVL +EObjjvbdmRxtzSci +DoCjjvbdzRPMhjXA +DnbkKvbdnGdwmNfy +EObkKvbdvAcxsOeI +DoDLKvbdBsAcTevr +DoCkKvbdozmdKxPA +DnbkKvbdTlVoBVoJ +EPCkKvbdqwQLcIxq +DncLKvbdbiMjLGWx +DoDLKvbdfHkWRnRH +EOcKjvbdbVCGxKsh +DoCjjvbdTqRPUthN +DoCkKvbdbQGgELzd +EOcLKvbdQZNAHSrK +DoDLKvbdZyDjNbkr +EPCjjvbdqiAJdmOe +EObkKvbdKaLHNBxR +DncKjvbdyXhjBozL +EObjjvbdDjIKWYKA +EOcKjvbdLFegaaQu +EPDKjvbdZjTIPgCG +EOcLKvbdfHjuqnQg +DnbjjvbdlhcsqVRa +DoCjjvbdMuSqkNAX +DncLKvbdCIkBkIej +DncKjvbdUaCQsQqy +EObjjvbdRbDdkhyL +EOcKjvbdpssfrRkU +EOcKjvbdLGFhBaQu +EPCkKvbdqqtjnLBN +EOcLKvbdWRmwbEkc +EObjjvbdpedFTuaI +DoCkKvbdJJdAJofd +DoDLKvbdwNWANEEm +EPCkKvbdYgWdAOri +DoDLKvbdvAcyTOeI +DnbkKvbdbhmJjfWx +EOcLKvbdypnliKXA +EOcKjvbdZyEJnClS +DoCjjvbdZoNhdeZj +EPCkKvbdkDLkRGtg +EObjjvbdNsUWGdtp +DnbjjvbdZQldhmFR +EOcKjvbdYpmEhldq +EPCkKvbdZQmEiMeR +DnbjjvbdhytfLpnG +EObjjvbdmtuZkJrG +EObjjvbdGLEsDINV +EPCjjvbdVhXvYHYz +DoDLKvbdKefICAqV +DncKjvbdUtMsfLvK +EOcLKvbduaEZTOeI +EPDKjvbdddoSBwDK +DoCkKvbdffLymgHA +DnbkKvbdbAueGQQX +DnbkKvbdbrcLTcia +EPCjjvbdRbEElJYk +DoCkKvbdGFirNiTq +DoDKjvbdNdctIhkE +EPDLKvbdQccAoqES +DnbkKvbdFfKRnJUR +DnbjjvbdFfJrNiUR +EPDLKvbdCfkegAzc +EPCjjvbdRXNccMHc +DoCkKvbdZjShPgBf +EOcKjvbdSLZGUfkT +DoDLKvbdBcpAujMf +EOcLKvbduWNwiqTA +DoDLKvbdpyOgfqEY +EOcKjvbdcScKtEJa +EObjjvbdnCJwXoNu +DnbkKvbdjFLGtoAO +DoCjjvbdXrlBMsnx +EPDKjvbdhgJcZWJu +DoCjjvbdiBoDEvpq +EPDKjvbdczYoxYqC +DoDLKvbdjFLHVPAO +DnbjjvbdbPgGdLzd +DoDKjvbdWIYWYGxz +DncKjvbdhytfLpnG +EObjjvbdfHjuqnQg +DnbjjvbdmgExMmgZ +EOcLKvbdhgKDYuiu +EPDKjvbdmJEURVRa +DoDLKvbdJpyePGNe +DoDLKvbdlhdUQuRa +EObkKvbdmuUzLKSG +DnbjjvbdxwhjBozL +EPDLKvbdVZIUZjnn +EPDLKvbdJpydnfOF +EPCkKvbdqqtjmjaN +EPCkKvbdZoOJFFZj +DnbjjvbdmttzKjRf +EPDLKvbduWOXjQsA +EOcLKvbdwtleRYkn +DoCjjvbdLYpjSzuG +EObjjvbdIsYaSmYM +DnbjjvbdyzeORhJI +EOcLKvbdkWWnECXw +EPDKjvbdVviYVcdg +DoDKjvbdBcoaVjMf +DoCkKvbdiMEcmuDZ +EObjjvbdLKaHvAKZ +DncLKvbdJTZArlwl +EOcLKvbdhaoCeWpq +DncLKvbdrWpLcJZR +EObkKvbdHkaznWpk +DnbjjvbdzjVPocrt +EOcKjvbdyqPMhiwA +DoCkKvbdpstHRqkU +DnbkKvbdRkYfVHKs +DoDLKvbdVgwvYGxz +EOcKjvbdFfKSNiUR +DnbkKvbdqquLOLBN +DncKjvbdOAJTTjSA +DoDKjvbddneSkUTr +EObkKvbdlqyUysEJ +DoDKjvbdbhmKKevx +EOcLKvbdiCObdwQq +EPCkKvbdFejSNiTq +EObkKvbdwygfGYEr +EPDLKvbdsQWPKDVf +DncKjvbdjbkjpfuH +EPDKjvbdRkZFuGjs +EPDKjvbdwyhFfXdr +DncKjvbdcIlikFvx +DoCkKvbdiUydwSVC +DncKjvbdiUzFXSVC +EOcKjvbdjKFgimYS +EPDKjvbdjvXODaww +EPCkKvbdRbDdlJZL +EObkKvbdrEEhpNvB +EObjjvbdrpVoKDWG +DoCjjvbdNxPVzcnU +EPDKjvbdVgwvYHYz +DnbjjvbdmuUyjirG +EObjjvbdrSVLNkBN +DncKjvbdUWLojUBR +EOcLKvbdwygefXeS +EObkKvbdhaoDEvqR +EOcLKvbdGGKRmiUR +EOcKjvbdeEnqawDK +EPDLKvbdGGJqnItR +DoDLKvbddeOrBvbj +DnbkKvbdiVZeWquC +DncLKvbdJcJcQjDY +EPDLKvbdkDMLQgUg +EObjjvbdemFvflik +EObkKvbdwzHeewdr +DoCjjvbdHDjuiajK +DoCkKvbdrEEiPnVa +EOcLKvbdypnmJKXA +DoDLKvbdmgFXmOHZ +EObkKvbdUsmUFkuj +EPDLKvbdcScKtDjB +EPCkKvbdUyITzLOn +DncKjvbdZnnIddyj +EPCkKvbdaaVeGPow +DoCjjvbdSQTfifDw +DoDKjvbdDoDKkXCd +DncLKvbdhtzEwRuC +EObkKvbdMpXqVnGs +DoDKjvbdDncLLXCd +DoCkKvbdtcDUwVoP +DoDKjvbdtSqryZdc +EPDKjvbdbBWFGPpX +EPCjjvbdmRxtyrdJ +DoDLKvbdGckVjCJj +EObjjvbdzoPpeCkx +DnbjjvbdKWVFceHJ +EPCjjvbdSKyGVHLT +DoDLKvbdelevgNKL +DoCjjvbdTXjlNzkY +DoDLKvbdpstHSSLU +EPDKjvbdhgKCxuiu +EObkKvbdZQleJMeR +EPCjjvbdKVuGDdfi +DncKjvbdUGzmkvvF +DncKjvbdxrnJMqbH +EPCjjvbdKVuGDdgJ +EObjjvbdptTgRqjt +EObjjvbdCDpAujMf +EPDKjvbdczZQXyRC +DncLKvbdqYngfpdY +EOcLKvbdqBIeAXIE +EPDLKvbdZLrETmlN +EPDKjvbdNeEThhjd +EOcLKvbdmbKWxOnV +DoCkKvbdCDoaWKNG +EOcLKvbdEOcKkWbd +EPCkKvbdNQXpvOGs +EPDLKvbdFyUtaDxC +EPDKjvbdbLMGOnDA +DoDLKvbdJcJcQjDY +EPDLKvbdOTUWHFUp +DoCjjvbdmgFXlnGy +EOcLKvbdRDbaQRES +DoDLKvbdcyxowxpb +EPDLKvbdliEURVSB +EOcKjvbdXnRAXuWU +DoCkKvbdDnbjjwDE +DoCkKvbdKVuGEEfi +EObkKvbdyOTHxShc +EPDKjvbdySnIlqbH +DoDLKvbdHELWJbJj +DnbjjvbdyOTHxShc +DnbjjvbdczZQXxpb +EPDLKvbdZLrDsmkm +EPCjjvbdfNGWflik +EPDKjvbdmbKWwnmu +DncKjvbdrDdiPnWB +EObjjvbdHDjvKCKK +DnbkKvbdUVkojTaR +EObjjvbdptTfrSKt +EPDKjvbdFxttaEXb +DoCkKvbdjvXNcbYX +DoCkKvbdSLYfUgKs +EOcKjvbdHakzEzAD +DncLKvbdiCObdwQq +EPDLKvbdZLqdUNlN +DoDLKvbdhkeDnVCy +EPCkKvbdemFvgNKL +EObjjvbdliDtQuRa +EObkKvbdwuMdpxkn +EObkKvbdirzhrkJz +EPCjjvbdJYTahLqQ +DncLKvbdIHGyxwwg +EPCjjvbdSQUHKGEX +DoCjjvbdZshiYcsO +EOcLKvbdPyNAHSrK +EPCjjvbdbsCjscia +EObjjvbdUWLojUBR +DoDLKvbdKeehBaQu +EObjjvbdjuwODaww +DoDLKvbdtkxXAsaX +DncLKvbddneSkTtS +DnbjjvbdZtJIxcsO +DnbjjvbdJTYaTNXl +EPCjjvbdGKeTDHlu +DoDLKvbdKQydoGNe +DoDKjvbdVrOXaeLc +EPCkKvbdzHYlAMeX +DoDLKvbdBvzchdov +EObkKvbdapGgELzd +DoDKjvbdaMkBsUlg +DnbjjvbdVUNTelWK +EObjjvbdiHJcZWKV +DncLKvbdZoNheEyj +DncKjvbdDHMFgAzc +DnbkKvbdFpATXGey +EPDKjvbdMpXqWOHT +EPCjjvbdmSZVZrdJ +EPDKjvbdcIljKfXY +DoCkKvbdjcLkRGuH +DoDLKvbdGYuVBEXb +EObkKvbdWXIxWDeH +DncKjvbdQlxCZOUz +DnbjjvbdYNqAXtut +EPDLKvbdGdKvJbJj +DoDLKvbdGLFSbglu +EPCkKvbdRjxfVGkT +DoCkKvbduCbuXWOo +DoCjjvbduCbtvuno +EObkKvbdjAQGaQGj +DoDLKvbdqBJFAXHd +EOcKjvbdkClKpgVH +EOcLKvbdiMFDmtby +EPDLKvbdjvXNcbXw +EPCkKvbdxUmFRYkn +DoDKjvbdHgGyyYXg +DoCjjvbdRzJhScWA +DnbkKvbdlZTRsYgU +DnbkKvbdFVxpQNJe +EPCkKvbdZyEJmcMS +EObjjvbdZQldhmFR +EObjjvbdYSlBMtPY +DncLKvbdvBDxsOdh +DoDLKvbdvAdYrndh +DoCjjvbdZyEJmcLr +DnbkKvbdKaLGmCXq +DnbkKvbdZQmFImEq +EOcKjvbdqvolDIxq +DnbkKvbdVqnYBdkc +DoCkKvbdnPyxvLZC +EOcLKvbdmJEURUqa +DoDLKvbdfHkVrNpg +DoCjjvbdznopdblY +DoCkKvbdjvWmdCXw +EOcKjvbdunszpjnt +EObkKvbdzoPqFDMY +EObjjvbdDxXktTtM +EObjjvbdBcoaVjMf +DncKjvbdtcDVWuno +EObjjvbdpyOggQdY +DnbkKvbdwWkaWAuu +EPCjjvbdajkeoODA +EOcKjvbdKNAEZfta +EOcKjvbdZisIQHCG +DncLKvbdEXwksstM +DoDKjvbdtbbuXVoP +DncLKvbdDxYMTstM +DoCkKvbdcyyPwxpb +EPCkKvbdxmrgwsJD +DoDKjvbdYSkaNUOx +EOcLKvbdxwhjCPyk +DncKjvbdUsmTekuj +DnbkKvbdkVwOECXw +EObkKvbdnBjXYOnV +DncKjvbdcasNSATm +EPDKjvbdTAFIhCOd +DnbkKvbdkWWnECYX +DnbkKvbdFjeSbgmV +DoCjjvbdJzoewdAN +DnbkKvbdZeXfzhIb +DncKjvbdMJCLqYAS +DoCkKvbdGLFTCglu +DoDLKvbdMuSrLNAX +EOcKjvbdqceIomvB +DoDLKvbdegkVqnRH +DoDKjvbdKfGICBQu +EOcKjvbdEvYopNKF +DnbjjvbdlrZVZsEJ +DoDLKvbdqqtjmjaN +DncLKvbdQmXaxmtz +EPDKjvbdCDoaVjNG +EPCkKvbdqquLNjaN +DnbjjvbdKRZdoFnF +DoCkKvbdkVwOECYX +DncKjvbdGQATXGfZ +DncLKvbdCDpAujMf +EOcKjvbdDxXlUUTl +EPCjjvbdYkrEUNlN +DnbjjvbdZtJIyETO +DoCjjvbdXsMAltPY +EOcLKvbdxxIjCPzL +DoDLKvbdSLZFuHLT +DncKjvbdFVyQQMjF +DoCjjvbdFaOpyJzm +EPCjjvbdrJAJdmPF +EOcLKvbdMuSqjmAX +DncLKvbdEJgiuxKA +EPDKjvbdBdQAuimG +DnbjjvbdWXIxVdFH +DnbkKvbdHDkVjBjK +EPDKjvbdnHEwlmgZ +EPCkKvbdBiKbKhfK +EPDKjvbdhyuGLpnG +DoCkKvbdZsiJZDsO +DnbjjvbddBrlrAUN +DoCkKvbdYqMeIldq +DncLKvbdZLqdUNkm +EOcLKvbdMuSrKmAX +DoCkKvbdDxXksstM +EOcKjvbdqdEiPmua +DoCjjvbdOEdUJIjd +DoCkKvbdEObkLWbd +EObkKvbdfekynHHA +EPCkKvbdrEFIpNvB +DnbkKvbdnBjXXoOV +EPCjjvbdmgEwmOGy +DncKjvbdKCjDQjCx +EPDKjvbdJqZdoGOF +DncKjvbdUsmTfLuj +DoDLKvbdjcMKpgUg +EPDLKvbdSQUGjGDw +DnbjjvbdRacdlJYk +DncKjvbdYgXEAOsJ +EPCjjvbdhficZWKV +DoDKjvbdGAnpxizm +EPCkKvbdRbDeLhyL +DoDKjvbdiBncEwQq +DoCkKvbdxZgfFxFS +DoCjjvbdqvpMChyR +EObjjvbdbUbGxKtI +DoCkKvbdEObkKvcE +DnbjjvbdKQzEnfNe +DoCjjvbdRWnDblID +DnbkKvbdkxrqsYgU +DncLKvbdqwPlCiYq +EPDKjvbdSZjHsDWA +DncLKvbdEPCjjvbd +EOcLKvbdpyPIGpcx +DncLKvbdbVCGwkTh +DnbkKvbdnPzZWKxb +EObkKvbdGKeTDIMu +EOcKjvbdiifIKNYS +DncLKvbdnQZxvKxb +EPDLKvbdGFjSNiUR +DnbjjvbdRNXaxnUz +EPCjjvbdOTTvGduQ +EObkKvbdUtMselVj +DoCjjvbdnUuZkKSG +EPDKjvbdQmXaxnUz +EPCkKvbdNeDtIhjd +DncLKvbdNxOuzdOU +DncKjvbdJJdAJpGd +DoDKjvbdwuNEqYkn +DncKjvbdZMSDtOLm +DnbjjvbdNeDsiJLE +EPCjjvbdJpzEoGOF +EPCjjvbdkDLkRGtg +DoCjjvbdUWLpJtAq +EPDKjvbdfMfWfljL +EPCkKvbdrMzJyMIJ +DoCjjvbdJKEAJofd +DnbjjvbdnBiwXoNu +DoCjjvbdDihJvYKA +DnbkKvbdSZigsDWA +DoCjjvbdFejRmhsq +DnbkKvbdaMkCTVNH +EObkKvbdczZPxZRC +EPDKjvbdVZIUZjnn +DoDKjvbdkySrTZGt +DoDLKvbdsPvPKDVf +DoCkKvbdwWlBVaVu +EPDKjvbdANIZSvyx +EPCkKvbdnHFYNNgZ +DnbkKvbdNdcsiIkE +EPDLKvbdDoCkLWbd +EPDKjvbdQccBPqDr +EObkKvbdSPsfifEX +EOcKjvbdelfXHNJk +EObkKvbdFfKRmiUR +EOcLKvbdKCibqKDY +EPDLKvbdUWLpJsaR +EPCkKvbdKfFhCBQu +EOcKjvbdmuUzLJrG +EOcLKvbdBdQBVjMf +EOcKjvbdfpBzvcwh +EOcKjvbdmRyUzSci +EOcKjvbdFVxpPlie +DnbjjvbdDwwlUUUM +DncKjvbdUyHsyjoO +DoCkKvbdUslselVj +DncLKvbdmuUykJqf +DncLKvbdLFfHbApu +DncLKvbdhyuFlROG +EPDKjvbdxnTIYTJD +EPDKjvbdTulPjUAq +DoCjjvbdCDoaWJlf +DoCkKvbdbLMGOnDA +EPDKjvbdOStVfdtp +EPCkKvbdZRMeImFR +DoDLKvbdiVZeXRuC +EPDKjvbdRosfiedX +DoCjjvbdnGeYMnGy +DoCjjvbdiiehKNYS +DncKjvbdbhmKKfXY +EOcLKvbdnBjXXoNu +EPDKjvbduLwwAtAw +EOcLKvbdygYlAMeX +DoCkKvbdNsTvHEtp +EPCjjvbdsrrTYzFD +EPCkKvbdBdQAuimG +DncKjvbdmfeYMnHZ +EOcKjvbdxZhFexEr +DncLKvbdZshhyETO +EObkKvbdOFEUJJLE +DoDLKvbduDCtvuoP +EOcKjvbdGZVVBEYC +EObjjvbdZRMeJNEq +DnbkKvbdkxsRsYft +DnbkKvbdsBfNLfjy +EOcLKvbdNPxQvOHT +DnbjjvbdpstHRqkU +EOcLKvbdZQleJNFR +EPCjjvbdxVNEpxkn +DoCkKvbdwtmEqZLn +DoCkKvbdGAoQxizm +DoDLKvbdVqmwaeLc +DoDKjvbdKfGHaaQu +DoCjjvbdcJNKLGWx +EPDLKvbdrzMPsBHn +DncKjvbdfoazwDxI +EPDKjvbdZyEJnClS +DnbjjvbdwMvANDeN +EObjjvbdZshiZETO +EPDKjvbdUslselVj +DoDKjvbdwtmEpyLn +DncLKvbdJTYaTMxM +EPDKjvbdvBDxsOeI +DoDKjvbdxrmhmSCH +EPDLKvbdjJegjNYS +EOcKjvbdJvUedEgJ +DnbkKvbdVZITyjoO +DoDKjvbddePSCWbj +DncKjvbdWIXvXgYz +EPDKjvbdZQmFJMeR +DnbjjvbdqdEiPnWB +DoDLKvbdUVkojTaR +DoDLKvbdFVxpPmJe +EPCjjvbdxmsHwsIc +EPDLKvbdiiehJlxS +EPDLKvbdCTAbsewS +EPCjjvbdzoPpdbkx +DnbkKvbdijGHilxS +EPDLKvbdOYOuzdNt +EOcLKvbdTppoUuIN +DnbkKvbdcScLUDia +EOcLKvbdePFTLUTr +EOcLKvbdhgKCxvKV +EPCkKvbdrJAKFNOe +EOcKjvbdVwJXucdg +EPCkKvbdNddUJJKd +DncLKvbdJYUCHlQp +EObjjvbdkVvnDaxX +EPCjjvbdNeDsiJLE +EPDKjvbdyzeNqhJI +EPCjjvbdmIdTqUrB +EPDKjvbdZoOJFEyj +DoDKjvbduaDxsOeI +EPCkKvbdKjaIWAKZ +DncLKvbdKaLHMbYR +EOcKjvbdrafMlHKy +EPCjjvbdhtzEvqtb +EPCkKvbdddoSCXDK +EOcKjvbdzjUpPdTU +EPCjjvbdLZRJrzuG +EOcKjvbdaMjaruMg +DoCkKvbdyOSgwsJD +EPCjjvbdKDKCqJcY +EObkKvbdvAcxrneI +EObjjvbdwuMeQxkn +DncLKvbdmSZUysDi +DnbkKvbdcIlijfWx +DoDKjvbddndrjtTr +EOcKjvbdwtmEqYlO +EOcKjvbdYzcFqivZ +DnbkKvbdCDpBWJmG +EOcKjvbdaSGCgsfL +EObjjvbdIwtBhLqQ +DnbkKvbdyzdmrIIh +EPDLKvbdWexzUAOs +DncLKvbdRXNdCkgc +EOcKjvbdkVwNdBww +DncLKvbdIGfzYxYH +DoCkKvbdbAvFGPow +DoCkKvbdQlxBxnUz +DncKjvbdqrUkOKaN +EPDLKvbdZisIQGaf +DoDKjvbdsQWPJbvG +DncLKvbdjhHMFfNk +EObkKvbdwNWAMdFN +DoCkKvbdeKKRutzn +EObkKvbdJpyeOfNe +EOcKjvbdQmXayNtz +DncKjvbdnHExNNgZ +EPCjjvbdULuoBVni +DoCjjvbdqquLNjaN +EPDKjvbdyzdnSIJI +DnbkKvbdQvnDcLgc +DoCkKvbdtcDUvvOo +DnbjjvbdnGeXmNfy +DoDKjvbdxsNhmRbH +DoDKjvbdtTSSyZeD +DoDKjvbdRadFMJZL +EOcKjvbdUaCQrpqy +DoDLKvbdEJgivXjA +EOcLKvbdGFjSOItR +EPDLKvbdaSGDIUGL +DnbjjvbdJYTagkqQ +EOcLKvbdZLrDsmlN +EOcLKvbdEJgiuwjA +DoDKjvbdxUleRYlO +DnbjjvbdQwODcLhD +EObkKvbdOTUVgEtp +EObkKvbdRMwaxnUz +EObjjvbdrEFJPmua +EOcLKvbdiUzEvquC +DoDKjvbdMpYQumfs +EPCkKvbdhancEvqR +DncKjvbdkNCMZdfo +DncLKvbdZHWdAOri +EObjjvbdlrYuZrci +EObjjvbdgLGzbfAE +EObjjvbdcTCkUEJa +EPDLKvbdVAbRTRRy +DoCjjvbdYqNEiMeR +DncKjvbdBvzchdpW +DnbkKvbdtSqryZdc +EPCjjvbdwygeeweS +DoCkKvbdqlzJyLhJ +EOcLKvbdtbbtvvOo +DoDKjvbdrSVKnLAm +DnbkKvbdfMevgNKL +EObjjvbdRacdkhyL +EPCkKvbdFpASvgGZ +EPDLKvbdZoOJFEyj +EPCjjvbdzjUpPcrt +EOcKjvbdcbSlrATm +EOcKjvbdqwPkbhxq +DnbjjvbdHELVibKK +EPDKjvbdZQldiMeR +DnbjjvbdpstGqrKt +DoDKjvbdGFjRmiUR +EPCkKvbdssRsZZdc +DnbkKvbdlqxuZsDi +DncKjvbdEXwlUTtM +DnbjjvbdyzdnRhIh +EPCjjvbdkCkkRGtg +EOcLKvbdLrWlytpz +EPCkKvbdCEQAvKNG +DncLKvbdVwIxWDeH +EObkKvbduMYXBTaX +DoCkKvbdRyihTDWA +DnbjjvbdkaMoNALA +DnbjjvbdaMjartlg +DoCkKvbdNVTSKmAX +DoDLKvbddwystRez +EPCjjvbdcImJjevx +DoCkKvbdeAUQlwjG +DoDKjvbdZxcjNblS +DncLKvbdkIGlFenL +DoCjjvbdfHjurNqH +DoCkKvbdiBoDFXRR +EPDLKvbdvBDyTPFI +DnbkKvbdUxhUZkPO +EObjjvbdqZOhHQdY +EOcKjvbdSCDeLiZL +DncKjvbdozmckYPA +DncKjvbdgGLymgHA +DncKjvbdILaznWpk +EPCjjvbdqUTgSSKt +DoCkKvbdrovOjCuf +EOcLKvbdKfGIBaQu +EPDKjvbdCIjajiFj +EPCkKvbdmoyxujyC +EObkKvbdySnJMrCH +EOcLKvbdHDjujBij +EObjjvbdrMyiyMHi +DoCkKvbdiifHimXr +DnbkKvbdbsCkTcia +DnbkKvbdMfbpNPtk +EOcLKvbddoErkUTr +DncLKvbdqZOhGqDx +DnbjjvbdDncKkXCd +DoCjjvbdSCEElIxk +EPCkKvbdbUbHXjsh +DnbkKvbdCTAcUGWr +EPDLKvbdZtIiZESn +DnbjjvbdrDeJPnVa +DoCkKvbdZisIQHCG +DncLKvbdgFkzOHHA +EPCkKvbdmfdxMmfy +DncLKvbdMIbMRYAS +EOcKjvbdaogGckzd +EOcLKvbdLAkHMawq +DncLKvbdxwiJbQZk +DncLKvbdauBgYLUI +DnbkKvbdnQZxvKyC +EOcKjvbdFkEsChNV +DoDLKvbdpstGrRjt +EPDLKvbdlYrrSxgU +DnbjjvbdZQmFIldq +DoCjjvbdbhmKLFvx +EObkKvbdsBellGjy +DncLKvbduCcUwWOo +EObkKvbdJuuGEEfi +DoCkKvbdIwtCHkqQ +EPCkKvbdaMkBruMg +DncLKvbdEARiMyvw +EObjjvbdmgExNOGy +DoCjjvbdpfDdsuaI +EPDLKvbdEzspdlCi +EPDKjvbdqdFJQNua +DnbkKvbdnBjWxOnV +EPDLKvbdZisHogBf +EPCkKvbdjcMKpftg +DnbkKvbdauCGwjsh +DoDKjvbdlYrrTZHU +EOcLKvbdzjVPpDrt +DoCkKvbdQdDApQdS +DoDKjvbdehLWRmpg +EPDLKvbduoTzpkPU +DoCkKvbdliDspuRa +DoDKjvbdEXxLsssl +EObjjvbdZsiJYcrn +DoCkKvbdaaWFGPpX +DoCkKvbdrafNMHLZ +DoCjjvbdmgEwlnHZ +EPCkKvbdFkEsCgmV +DncKjvbdqmZjYlHi +DoCkKvbdfILWSORH +DoDLKvbdnCKXYOnV +DnbkKvbdHgGyyYYH +DoDLKvbdEKHjVxKA +EPDKjvbdbAueGPow +DnbkKvbdFyUuBDwb +EPDKjvbduCcUvvOo +EObkKvbdauBfxKsh +EObjjvbdZjTIPgBf +EObkKvbdNGbolpVL +EOcKjvbdeFOqbWbj +DoCjjvbdvwMAvBVu +DnbkKvbdzRPMhjXA +DncKjvbdFkErcIMu +EPCjjvbdhlFEOUcZ +DoCkKvbdJbjCpicY +EPCkKvbdZGwEAOri +DnbkKvbdNQYQunHT +DoCkKvbdkIHMFfOL +EObkKvbdHELVjBij +DoDLKvbdZQldhleR +DoDLKvbdVTmTelVj +DnbjjvbdJTZArlwl +DnbkKvbdCDpAvKMf +DoCjjvbdDxYLtUTl +DoDLKvbdwkWcgzyf +EPDLKvbdLBKgNCYR +DoDLKvbdZMSEUNkm +EOcLKvbdxUmEpxkn +EOcKjvbdGLFTDHlu +EOcLKvbdyYJKCPyk +DoCjjvbdDnbjjvcE +DoDLKvbdatbHXjtI +EObjjvbdbiMjLGWx +EPDKjvbdTYKlNzjx +EOcKjvbduDDUvvPP +EObkKvbdliETpuSB +DnbjjvbdrWolDIxq +EObjjvbdqZOggQcx +EOcLKvbdyXiKBoyk +DnbjjvbdqmZiyMIJ +EPCjjvbdULuoAuoJ +DoDLKvbdYzcGRivZ +DnbjjvbdtkwwBTaX +DnbjjvbdJbicQicY +DoCkKvbdTukojTaR +EPCkKvbdHbLydzAD +EObjjvbdVTltGLvK +EPCjjvbdUsmUFkuj +EPDLKvbdTqROuVIN +DncLKvbdYkrETnLm +DoCkKvbdeFPSBwDK +DnbjjvbdNGcPmPtk +DnbjjvbdWHwuxHYz +DoDLKvbdNUsRjmAX +EOcKjvbdZjTHpHBf +DncKjvbdWXIwvDeH +EOcLKvbdrJAKEloF +DoCjjvbdFeirOJUR +EOcKjvbdWWhwvEEg +DncKjvbdKeehBaQu +DnbjjvbdZLrDsmlN +EOcLKvbdZnnIeFZj +DoCkKvbdjKGHjMwr +EObkKvbdmIctQtqa +DoCjjvbdkClKpfuH +DnbjjvbdcTDKscia +DnbjjvbdADSYKZiQ +EObkKvbdygZMANFX +EPCjjvbdaMkCTUlg +DoDKjvbdzjVPodTU +EPCkKvbdIxTagkpp +EPCjjvbdZjSgpHBf +EOcLKvbdiCOcEvpq +EOcLKvbdsQWOibvG +DoDKjvbdEuxoomJe +DoDKjvbdmuVZkKSG +DoCjjvbdSZjITDWA +DoCkKvbdCJLBkJGK +EPCkKvbdliDsqVSB +DoCjjvbduaDxrneI +EOcLKvbdtvNxJpsA +EOcKjvbdEuyPoljF +DnbjjvbdwWlAuaWV +DncLKvbduMXvaTaX +EObjjvbddxZstSFz +EPDLKvbdmttykKSG +EPCjjvbdfIKvRnRH +DoDLKvbdjgfkeemk +DoCkKvbdHELVjBjK +EObjjvbdaRecIUGL +DnbkKvbdmSYuZrci +DoDLKvbdKfGHaaQu +EOcLKvbdIwsahLpp +EOcLKvbdEuyPomKF +DoCkKvbdsQWPJcVf +DnbjjvbdbPgHDkzd +DoDKjvbdZMSETnMN +DoDKjvbdJSyBTMwl +EPCkKvbdSCDeMIxk +DoDLKvbdtkwwBTaX +DoCjjvbdtbcVWuoP +EPCjjvbdozmdKxPA +DoCjjvbdtkwwBUBX +DoDLKvbdQdDBPpcr +DoCjjvbdJbjCpjDY +EPCjjvbdCTBDTfWr +EPDKjvbdYNqAYUut +DoDKjvbdURRPVUgm +EOcLKvbdNPwqVmfs +DoDKjvbdsCGMkgLZ +DoDLKvbdZtIiYcsO +EObjjvbdhficZWJu +EPCjjvbdTqRPUuIN +EPCjjvbdyOShXsIc +EOcLKvbdliETqVRa +DncKjvbdYqMdhmEq +DoCkKvbdKfGHbBQu +DnbkKvbdqBIeAXIE +EPDLKvbdQZNAHTRj +EObkKvbdRosgJecw +EPCjjvbdKQzEnfOF +DoDKjvbdzRPMiKXA +DnbkKvbdGcjvJbJj +DoCjjvbdbAvEeoow +DncKjvbdFVyQPmKF +EPDLKvbdRzKIScWA +EPCkKvbdKkAhWAJy +EPCkKvbdJqZdnenF +DoCkKvbdVUMtGMWK +DncKjvbdBiLBjiGK +DnbkKvbdjvWnDbYX +DnbkKvbdwuNEqYkn +DoDKjvbdegjurORH +EObjjvbdpeceTvAh +DoCkKvbdAMgySwZx +EPCkKvbdlZSqsZGt +EPDLKvbdbrbkTdKB +EPDKjvbdhzUekpnG +DncLKvbddeOqbWbj +EPCjjvbdsPunibvG +EOcLKvbdVwIxVdEg +DoCjjvbdkIHLefNk +DnbkKvbdxmrhXrhc +EPCkKvbdziuPocrt +EOcLKvbdNUsSLNAX +DncKjvbdhkddNtcZ +DoCjjvbdMpYRWNgT +EObjjvbddZxoxYqC +EOcLKvbdNVTRjmAX +EPDKjvbdZjTIQHCG +DnbkKvbdHEKvJbKK +EOcKjvbdiGibxvJu +DnbjjvbdsCGNMGjy +DoCjjvbdBhkBjhfK +EPCkKvbdSCDdkhyL +DnbjjvbdNPwpvNfs +EOcLKvbdJTZBTNYM +DncKjvbdqGEFTvBI +EObkKvbddneSjtTr +DncLKvbdqdFJPmua +EPDKjvbdrbFmMGkZ +DoCjjvbdhXZAzzAJ +EOcKjvbdkxsSSxgU +EPDKjvbdrEEhonVa +DnbkKvbdYzcGSKVy +DoCjjvbdzROmJJwA +EPDLKvbdOEdUJJKd +EPCjjvbdqquKmkAm +EOcLKvbdZyEKODLr +DnbkKvbdIsZAsMxM +DnbjjvbdZjTHofaf +DoCjjvbdrSUkOLAm +EPCjjvbdBsAbsewS +EObkKvbdUsltGLuj +EPCkKvbdANHyTWyx +EObkKvbdsBemMGjy +EObjjvbdMoxRVmfs +EPCkKvbdNGbolouL +EPDLKvbdjKGHimXr +DncKjvbdUMWPAuni +EOcLKvbdOEdUIhkE +EPCkKvbdjKGHimXr +EPCkKvbdhuZdwSVC +DoCjjvbdCIkBjiFj +EPCkKvbdxZhGFxFS +EObjjvbdOFDtJJKd +DoCkKvbdfNGWgNKL +EPDLKvbdcarmSATm +DoDKjvbdkNCMZeHP +DoDLKvbdkMakyeGo +DnbjjvbdiHJcYvKV +DnbjjvbdWWhxVcdg +EPDKjvbdVUNTelVj +DoDKjvbdZGvdAPTJ +DoCjjvbdDncLLXCd +EPDKjvbduDCuWuno +DoCkKvbdPyNAHTSK +DncKjvbdqwPlDIyR +EOcKjvbdYzbfSJvZ +DnbkKvbdRotGifDw +DoDLKvbdRDcBQRDr +DoDKjvbdEARiNZvw +DncKjvbdJSxaTNYM +EPDKjvbdVwJXvDeH +EOcKjvbdQwOECkhD +DoCjjvbdEPCkLWbd +EPDKjvbdVBBpsRSZ +EOcKjvbdddoSBwCj +EOcKjvbdFkFScINV +EObjjvbdpstGrSLU +EPDLKvbdhaoDFXRR +EPDKjvbdKfGICApu +EObkKvbdBsAcTevr +EObkKvbdhkeDmtby +DoCkKvbdqYngfpdY +EOcKjvbdsPvPKCvG +DoDLKvbduVmwiqTA +EOcKjvbdidkGtoAO +EPCkKvbdyzeORgiI +DoCkKvbdmJDsqUqa +DncLKvbdiGibyVjV +DncKjvbdhtzEwSVC +EOcLKvbdZRMdiNFR +EOcKjvbdrafMkgKy +DoDKjvbdZGwEAOsJ +EOcLKvbdjmCMZeHP +DncLKvbdjKFgimYS +EPCjjvbddZxpYZRC +DncKjvbdjmBkzEgP +EObkKvbdkIHLeemk +EPDKjvbdjAQGaQGj +DncLKvbdSPtHJfDw +DoCkKvbdGKdsChNV +EPCjjvbdrouoJbuf +EPDKjvbdlhcsqUqa +DoCjjvbdwXMBWAvV +DnbkKvbdhkdcmtby +EOcLKvbdFkEsDHmV +EOcLKvbdCIkBjhej +DoCkKvbdiLeDnVDZ +DoDLKvbdDxXlTssl +DnbjjvbdNrtVfduQ +EPCkKvbdHDkWJajK +EPCjjvbdTulQKUBR +DoDKjvbdJYUBhLpp +DncKjvbdiCOcFXRR +DoCkKvbdxsNiMrBg +EObkKvbdQlxByNtz +EPCjjvbdBhkBjiFj +EPCjjvbdNeDsiIjd +DncLKvbdBsAcTfXS +DncLKvbdDwwlUTsl +EOcKjvbdUQqPVUgm +DncKjvbdmttzKirG +EPCjjvbdKWUfEFHJ +EPCjjvbdGKdrcINV +EPDLKvbdkxrrTYgU +DoCkKvbdQdCaQQcr +DnbkKvbdvAdYroFI +EObkKvbdFxttaDwb +DnbkKvbdQdDBPqES +DncKjvbdkVwODbXw +DoCkKvbdrounicVf +EPCjjvbdBcoaVjMf +DncKjvbdcImKKevx +DoCjjvbdxLWdHzyf +EOcLKvbdcbTNSATm +EPDKjvbdRacdlJZL +EPDLKvbdZQleIleR +EPCkKvbdTfznLwWF +EObkKvbdsCFmLgKy +DoDKjvbdyqOlhiwA +EOcKjvbdtcCtwVoP +DnbjjvbdRWmdCkgc +EOcKjvbdqUTfqrKt +DnbkKvbdRyjHsDWA +DoDLKvbdYqMdiNEq +EOcKjvbdhbPCeXRR +EOcKjvbdVrNwbFLc +EObkKvbdZLqcsmkm +DoDKjvbdRWmdDMID +EPCjjvbdkWXNcbYX +DncLKvbdZyDinClS +EOcLKvbdqUTfqqjt +DncLKvbdUtNTelWK +EPDKjvbdkWWmdCXw +DoDKjvbdezuxdhtX +DoCkKvbdaSGCgtGL +EPDKjvbdVwJYWDdg +DoDLKvbdWSOYCFMD +EObkKvbdxwiJaozL +DoCjjvbdTpqOuVIN +DoCkKvbdrzLpSaHn +DnbkKvbdJutecdfi +DnbkKvbdhgKDZVjV +DncKjvbdCJKajiGK +EPCkKvbdbrcLTcia +DncKjvbdxxIibPzL +DoDLKvbdNUsRkNAX +DoCkKvbdZRMeJMdq +DnbjjvbdxsOJMqbH +DncKjvbdqAheAWhE +DoCkKvbdZnnIddyj +DoCjjvbdrpWOibuf +DoCjjvbdDxXlUUTl +EPDKjvbdZirgofbG +DnbjjvbdDnbkKvbd +EOcLKvbdoznDkXoA +DnbjjvbdozmdKxPA +DnbkKvbdfHkVqmqH +DoDLKvbdkDMLRGtg +EPDKjvbdDxXlUTtM +DoDLKvbdZLrETmkm +DoCjjvbdLAkGlbYR +DncLKvbddndsLUUS +DoCjjvbdaRfDIUFk +DnbjjvbdjJfHjNXr +DncLKvbdeFPRbXDK +DoCkKvbdJYTbIMRQ +DnbkKvbdptUGrRjt +EOcKjvbdkMbLzEfo +DoCjjvbdezuxeJUX +DoCjjvbdZMRctOLm +DoDLKvbdWWiXudEg +DnbkKvbdiiehKNXr +DoCkKvbdXrkaNUOx +EPDLKvbdZjTIQGbG +EObjjvbdeOeTLTtS +EPDKjvbdBraCsewS +EPDLKvbdLBKflaxR +DncKjvbdRzJhScWA +EPDLKvbdGKdrbhMu +DoDKjvbdFeiqmiUR +DnbjjvbdFWYooljF +DnbkKvbdUWLoisaR +EPDKjvbdfRaWzkbo +EPDLKvbdKQzEnfNe +DoDLKvbdnUtyjiqf +DnbjjvbdyNrgxSiD +EOcKjvbdjlakzFHP +DoCkKvbdjvXODaxX +DnbkKvbdLFfHaaRV +EPCkKvbdwuMeRYlO +EPDLKvbdtSqrxzEc +DncKjvbddwytTqez +EOcKjvbdZLqcsnMN +DoCjjvbdkxsSTZHU +EPDKjvbdiZtekqNf +EObkKvbdnCKWwnmu +EObjjvbdauBgYKsh +EPDKjvbdrSVKmkBN +EObkKvbdxrnImSBg +DncKjvbdZnnJEeZj +DoDKjvbdZjTIQHBf +DncLKvbdmIctRVRa +DoCjjvbdziuQQDsU +EPDKjvbdZRNFJNEq +EOcKjvbdTqRPUthN +EPCkKvbdePFSjssr +EPDLKvbdfIKuqmqH +DoDKjvbddZyQYYpb +DoDLKvbdWRmwaeMD +DoDLKvbdOYOuzcmt +DoDLKvbdxsNiNRbH +EPCkKvbdNeEThiLE +EPCkKvbdNPxQunHT +EPCjjvbduCbtvuoP +EOcLKvbdjgfkeemk +EObjjvbdjlbLydfo +DoDLKvbdxmsIXrhc +DoCkKvbdlrZVZsDi +DoDKjvbdEztRElCi +EObjjvbdBsAbsfWr +DoDLKvbdZHWdAOsJ +DnbjjvbdSCDdkhxk +EObjjvbdeFOqbWcK +EPDLKvbdZtJJZESn +EPCkKvbdKfFhBaQu +DoCkKvbdMpYQvNfs +EObjjvbdrpWOjCvG +EPDLKvbdJSxaTMxM +EPCjjvbdOSsvGduQ +DoDLKvbdtumxKRTA +EPDKjvbdBcpBWKMf +DnbkKvbdtbbuWvPP +DoDLKvbdKWUfDdfi +EPDKjvbdOStVgFVQ +EObkKvbdZnmheFZj +DoDLKvbdQwODcMID +DoDKjvbdVrNxBeMD +DoCkKvbdaSFbgsek +DoCjjvbdTvMQKTaR +DoCkKvbdZsiIxdSn +EObkKvbdakMFnnDA +DoDLKvbdJutedFHJ +EOcLKvbdhzVFlQnG +EObjjvbdzjUpQDsU +EPCkKvbdzoQQeCkx +DncKjvbdZjShPgCG +DnbjjvbdMgCpMpVL +DnbkKvbdNGbpNPuL +EObkKvbdKfFhBaRV +DnbjjvbdKQzFPFnF +EPDKjvbdCIkBkJGK +EObkKvbdmajXXnnV +DoCkKvbdNwnuzcnU +EObjjvbdauCGwkTh +DnbkKvbdbiNKKfXY +DnbjjvbdQmYCYnUz +DoDKjvbdiLddNtcZ +EOcKjvbdeEoSBwDK +DoDKjvbdcTCkUDia +DnbkKvbdZRNEhmEq +EPCkKvbdHfgZxxXg +EObjjvbdbsDLUDjB +EPDKjvbdhbPDFWqR +DncLKvbdKNADyfuB +EObkKvbdEztREkcJ +DncLKvbdbLMFnnDA +EObkKvbdZjShPgBf +DncLKvbdbVCHXkTh +DnbkKvbdqTtHSRkU +EObkKvbdfSBWzlDP +DnbkKvbdGKeTDIMu +EOcLKvbdGcjvJbJj +EPCkKvbdMowqWOHT +DncKjvbdYpmFIleR +EPDKjvbdZxcjNblS +DncLKvbdNrtVgEuQ +EOcKjvbdqrVKnLBN +DnbkKvbdatbHXkUI +DoCkKvbdEPDKkWbd +EPDLKvbdmIdURVRa +DoCkKvbdMoxRWNgT +EObjjvbdLBKflbXq +DoCkKvbdSwjkmzkY +DoDKjvbdJbicQicY +EObkKvbdNQYQumgT +DoDKjvbdxxJKCPzL +DncLKvbdnGdxNNgZ +DoCkKvbddijSVtzn +EPDKjvbdrJAJdmOe +DnbjjvbdzoQQeDLx +DoCjjvbdZRMeIldq +DnbjjvbdkHgMGGOL +DoCjjvbdaSGChTfL +EOcLKvbdCJLCKiFj +DoCkKvbdVhXvYHYz +EPCjjvbdcSbjscia +EOcKjvbdxZgeewdr +EPDLKvbdYkqdUNlN +DnbkKvbdREDApQdS +DnbjjvbdmozZVkYb +EPDKjvbdaRecITfL +DncLKvbdZyEJmbkr +EOcKjvbdZnnIdeZj +DncLKvbdeXzTsrFz +DoCjjvbdZRMdhmEq +EOcLKvbdGGJqmhtR +EPDKjvbdIidAJpHE +DncKjvbdMRwNZtpz +DncLKvbdnBiwXoOV +DoDLKvbdqYnhGqEY +EOcKjvbdWexytAOs +EOcKjvbdiZuFlQnG +EObkKvbdVAaqTRRy +EPCkKvbdTAEhgaoE +DoDKjvbdMoxQvNfs +EPDKjvbddjJqvUzn +EObkKvbdBiKajhfK +EPDLKvbdZLqcsmlN +DoCjjvbdgPazwDwh +EPCkKvbdwkWcgzzG +EPDKjvbdlYsSSyGt +EObjjvbdZLrDsmkm +DncLKvbdbsCkUDia +EObkKvbdkxrrSyGt +DnbkKvbdnBivxOnV +DoDLKvbdZirhPgCG +EObjjvbdfMevfmKL +EPDKjvbdSQTgJecw +DoDLKvbdUWMPitAq +DoDKjvbdwtleRZMO +EObjjvbdKRZdoGNe +DoCjjvbdauBgYKsh +DoDKjvbdXrlAlsnx +DncKjvbdUMVnaVni +DncKjvbdiHKDYvKV +DnbkKvbdySnJNSCH +EPCjjvbdfNGWgNKL +EOcLKvbdnQZxujxb +EObjjvbdVgwvXgYz +EOcLKvbdjKGHimYS +DnbkKvbdhanbeXQq +DncLKvbdhzUfLpmf +DoDLKvbdczZPxZRC +EPDKjvbdRNYBxnUz +EOcLKvbdlrZVZrdJ +DncKjvbdtcDUwWOo +EPCkKvbdQvmdDLhD +EPCjjvbdfMfWfljL +DoCjjvbdZyEKNbkr +EOcKjvbdgPazvcxI +DncKjvbdfNGXHMjL +DncLKvbdEKHjWXjA +EObkKvbdZjSgogCG +EPCjjvbdxnSgxShc +EPCjjvbdqrVKmkBN +EPCjjvbdbBVdepQX +DoCkKvbdrXQLbhxq +DoCjjvbdbVBfxLTh +EPCkKvbdHlBznWqL +EPDKjvbdTAEhgaoE +DnbjjvbdCfkfHAzc +DnbkKvbdptTfqqjt +EPDLKvbdWIXuwgYz +EObjjvbdrJAJeNPF +DncLKvbdKDKDRJcY +DnbkKvbdrDeIpNvB +DncLKvbdVwIwudFH +DncKjvbdICMZdzAD +EPCkKvbdsQVnjDVf +EPDKjvbdiZuGMRNf +DoDLKvbdIGfyyXwg +EPDLKvbdYORAXtut +DoCjjvbdhzVGMQnG +EPDLKvbdQwNcbkgc +EObjjvbdsBemLgLZ +DoDLKvbdZtIiYdSn +DoCjjvbdelevfljL +DoCkKvbdcyxowxqC +EPDLKvbdZMRdUNlN +EOcLKvbddZyPwyRC +EPCjjvbdZLrDsnLm +EPCkKvbdgPazwEYI +DoDKjvbdqFdEsvBI +EOcKjvbdVviXvDdg +EPCjjvbdCWzdIdov +DncKjvbdrSVKnLBN +EObkKvbdiLddNtcZ +EPDLKvbdrDdiPmvB +EPDKjvbdKDKDRKCx +DoDKjvbdtSqsZZeD +DoDLKvbdwuNFRYlO +DoCjjvbduLwvaTaX +EObjjvbdtkxXBUBX +EOcLKvbdSQTgJfEX +EObjjvbddneTKtUS +DoDLKvbdAMhYsXZx +EOcLKvbdczZPwxqC +EPDLKvbdjbkjqGtg +EOcLKvbdFkEsChMu +EObjjvbdbsCkUDia +EObkKvbdEzsqElDJ +EPDLKvbdGZUuBEYC +DoCkKvbdzROmJJwA +EPDKjvbduMXwAsaX +EPCjjvbdqwQMDJZR +DoDKjvbdqUUHSRkU +DoCkKvbdwtleQxkn +DnbkKvbdQvnEClHc +EPDKjvbdjvXNcaww +DoCjjvbdjggMFenL +EPDLKvbdJYUBhLpp +DnbkKvbdkNCLyeGo +DoCjjvbdDoCkLWcE +EOcKjvbdYqMeJNFR +EPCjjvbdRDcApQdS +EObjjvbdjblKpgVH +EPDKjvbdqqtjnKaN +DoDLKvbdwtmFRYlO +DoCjjvbdnHEwmNgZ +DncLKvbdaMjasVNH +DncKjvbdnUtzLKSG +DoDLKvbdkySrSyGt +EPCjjvbdyNsIXriD +DoCkKvbdRadFMIyL +EOcKjvbdqvokbhxq +EPCjjvbdYkrEUOLm +EPDKjvbdrpWPKCvG +DncKjvbdxUldpyLn +EObjjvbdrbFmMHKy +DoCjjvbdZHWdAPTJ +DncKjvbdEPDLKwDE +DnbjjvbdZHWdAPTJ +DoDLKvbdNrsvHFUp +DncLKvbdCTBDUFvr +EPDLKvbduDDUvuno +DoDLKvbddwystSFz +DnbkKvbdmbJvwoNu +EPCjjvbdcbTNSAUN +DnbjjvbdnVUzKjRf +EOcLKvbdYlRdUOMN +DoCjjvbdTAFIgand +DnbkKvbdpeceUVaI +DoDLKvbdlZSrTYft +EPCjjvbddePRbXDK +EOcLKvbdJqZdnfNe +EPCkKvbdRaceLhyL +EPDKjvbdLAkGlaxR +EPCjjvbdqGDdsvAh +DnbjjvbdxZgefYEr +EObkKvbdKWVGEFGi +EPCjjvbdSQUHKFdX +EPDKjvbdDxYLsssl +EPCjjvbdfHjvSNqH +EPCkKvbdQwODbkhD +EOcKjvbdZnmiFEyj +EPCkKvbdqwQMChyR +EOcLKvbdZyDimcLr +EObjjvbdjAQGaQGj +EPCkKvbdZtJJYdTO +EObjjvbdjFKgUoAO +DnbkKvbdcScLUEKB +EPDKjvbdjcMLRGuH +EObjjvbdqlzKZLgi +EOcKjvbdFfJrNiUR +EObkKvbdKaKgNBxR +EOcKjvbdHDjujBij +EObkKvbdFejSOJUR +DncLKvbdMIalRYAS +EOcKjvbdVTlsekvK +DoCjjvbdUQqOtthN +DnbjjvbdVYgtZkOn +DnbkKvbdrovOicVf +DncKjvbdKfGIBaQu +DnbjjvbdjuvnDaxX +EPDLKvbdHakzEzAD +EPDLKvbdyzdnRhIh +DoCjjvbdZGvdAPTJ +DoDLKvbdqvolChyR +DncLKvbdjlbLyeHP +EPCkKvbdmIdTptrB +EPCkKvbdQcbaPqES +DoDLKvbdddoSBwCj +DnbjjvbdjvWnECXw +DnbjjvbdZisHofbG +EOcKjvbdZQldhldq +DnbkKvbdfekymfgA +DnbjjvbdLBKgMbYR +EPCjjvbdEARiMzWw +EObjjvbdtSrTYzEc +EPDKjvbdZoOIddyj +DnbkKvbdcSbjtEKB +EObjjvbddndsKssr +DoCjjvbdxnSgxShc +EPCjjvbdOTUVfdtp +DoCkKvbdUtMselWK +DnbjjvbdJpydoGNe +DoCkKvbdGQASwGey +DnbjjvbdnGdxMnGy +EPDKjvbdHDkVibKK +DoCjjvbdtbbuXWOo +EPDKjvbdKWVGEEgJ +EObkKvbdGLEsCgmV +DoCkKvbdbrbjtEKB +EPDLKvbdRzJgrcWA +EPCkKvbdaRecITfL +EObjjvbdrbGMlHKy +DnbkKvbdZdwfzgiC +EPDKjvbdVwJXudFH +DoCjjvbdiZtekqOG +EObkKvbdqrUkOKaN +EObkKvbdySnImRbH +EObjjvbddoFTKstS +EOcKjvbdyOTHxTJD +DncKjvbdFVxoolie +DoCkKvbdFejRnIsq +EPDLKvbdptUGrRkU +EOcKjvbdajlGOnDA +EPDKjvbdrRtkOKaN +EOcKjvbdzoQQeDLx +EPCjjvbdrafMlGkZ +EPCjjvbdmpZyWKyC +DoCkKvbddBrlrAUN +DnbkKvbdMgDPlpVL +DnbjjvbdUxhTzKoO +DoCkKvbdSCDdlIyL +EPDKjvbdmbJvxPOV +EPCkKvbdNGcQMpUk +EPCjjvbdVqmxCFLc +DoDKjvbdrDdhonWB +EOcLKvbdYTLaNToY +DoCkKvbdkIGlFemk +EPDKjvbdNrsvHFVQ +EPDLKvbdrzLoraHn +EObkKvbdraelkgLZ +DoDLKvbdBdQAujMf +DncKjvbdwzIGGYFS +EOcKjvbdZeXfzhIb +DoDKjvbdbAueGPpX +DoCjjvbdZtJJYcrn +DoDKjvbdyqPNJKXA +DoCkKvbdTAFIhCPE +DoDLKvbdjblLQgVH +DoCjjvbdZtJJZDsO +EOcLKvbdrNZixkhJ +DoCjjvbdzoPpdblY +DnbkKvbdqcdhpNvB +DncKjvbdYpldhleR +DoCjjvbdmRyUysEJ +DoCjjvbdJXtBgkqQ +EOcKjvbdVwJYWDeH +DoDLKvbdZLqdUOLm +EPDKjvbdEXwlUUTl +EObkKvbdoznDkYPA +EPCkKvbdEASJNZvw +EPCjjvbdFjdsCglu +DoCkKvbdTlWPBWOi +DnbjjvbdcTCjsdKB +EObkKvbdkySrTYft +EPCkKvbdLrXMytpz +DncKjvbdZQmEhleR +EOcLKvbdHkaznWpk +DnbkKvbdHfgZyXxH +EObkKvbdpecdtWAh +DnbkKvbdRadElJYk +EPCjjvbdTXkMNzjx +DoCjjvbdmSYtzTEJ +EPCkKvbdZsiJZDsO +DncKjvbddoErkTtS +DoCkKvbdZRMdiMeR +EObkKvbdTfzmkvvF +DncKjvbdpxnhHQcx +EPDLKvbdaMjbStlg +DoCjjvbdkHfkefOL +DoCjjvbdqqtkOLAm +DnbjjvbdyzeNqgiI +EOcKjvbdiLeDnUby +DncKjvbdyYIjCPyk +EOcKjvbdpfEFUVaI +EPCjjvbdZirgpHBf +DnbkKvbdKWUecdgJ +EOcLKvbdiHKCxvJu +EPDKjvbdcTCkUEKB +EOcLKvbdaMkBsVNH +EPDLKvbdJutfEFGi +EPCkKvbdFaOqZJzm +EObjjvbdhaoCdvqR +EPCkKvbddZxpXxqC +DnbjjvbdZxcinDLr +DoDLKvbdpssfqrKt +DoCjjvbdqTsgRrLU +EPDLKvbdEYXlUTtM +EObjjvbduVmwjQsA +EOcLKvbdNPxQunHT +DnbjjvbdBhjajiGK +DoCkKvbdUGznMXVe +EPDKjvbdVwIwvEFH +EObkKvbdRMwayNtz +DoDLKvbdQZNAGrrK +EObjjvbdKWUedFGi +DoDLKvbdaNKartlg +DncKjvbduWOXipsA +EObjjvbduVmxKRTA +DoDKjvbdygZMAMdw +DoDLKvbdqTsfrRkU +DoCjjvbdEvYpQMjF +EObkKvbdNPxQunGs +EObkKvbdsZlPsAgn +DnbkKvbdZnnIddzK +EPCkKvbdNQXqWOHT +DnbkKvbdGLFSbhMu +DoDKjvbdrzMPraIO +DnbkKvbdZirgofaf +EPDKjvbdijFhJlxS +DncKjvbdWRmxBeLc +DnbkKvbduDDUvuoP +DoDKjvbdiZuGMQmf +EObkKvbdelfXGljL +EPDLKvbdfNFvfljL +DncKjvbdGKdrcINV +EObjjvbdFfJqnIsq +EOcLKvbdILaznWqL +DncLKvbdJutedFHJ +EOcLKvbdIwtBhLpp +EPDLKvbdsrrSyZdc +EPDKjvbdczZQXxpb +DncLKvbdDoCjjvcE +EPCjjvbdpxoIHREY +DoCkKvbdxxJJbPzL +EPCkKvbdVZIUZkPO +EPDLKvbdULuoBWPJ +EPCkKvbdfMfWfmJk +DnbjjvbdZtIiZETO +DoCjjvbdiMEcnUby +DoCkKvbdcyyPxZQb +DoCkKvbdZirgofaf +EObkKvbdozmdLYPA +DoDKjvbdYkrEUNkm +DoCkKvbdLqwMzVQz +EObjjvbdLFfICBRV +EObjjvbdjJehKNYS +DoCjjvbdEJgiuwjA +EPCkKvbdyqPNIiwA +EPDKjvbdNdcsiIjd +EPCjjvbdauBgXjsh +DnbkKvbdyzeORgiI +EPCkKvbdsCGNLgLZ +EObkKvbdtbbtwVno +EObjjvbdwuMdqZLn +EObjjvbdSQTfiedX +EPCjjvbdmttyjjSG +DncLKvbdnHFYMnGy +DncKjvbdxmsIXrhc +EPDKjvbdQYmAGsRj +EObjjvbdfoazvdYI +DoDLKvbdhaoDEvpq +EObjjvbdDihKVwjA +DoCjjvbdZMSDtNlN +DnbjjvbdhlFDnVDZ +EPCjjvbdiCPCdwRR +DncLKvbdULuoBVoJ +DoDLKvbdyYJKBpZk +DoDLKvbdRbDdlIyL +EOcKjvbdYSlAlsoY +DoCkKvbdySmhlqbH +EOcKjvbduWNxKRTA +DnbkKvbdFjeTDIMu +DoDLKvbdzaAPGgCM +EPCkKvbdBhkCLJGK +DnbkKvbdYpmFJNFR +EPCjjvbdQccBQQdS +EOcKjvbdqGDdtVaI +EOcLKvbdILazmvqL +EPDLKvbdajkennDA +DoDKjvbdxVMdqZLn +EPDKjvbdNPxQunGs +EObjjvbdhytfMROG +EPDKjvbdEXxLtTtM +EPDKjvbdZnnIdeZj +DoDKjvbdGKeTChNV +DncLKvbdjmCMZeGo +DnbkKvbdQwNdClHc +DncKjvbdXrlBMtOx +DoCkKvbdzaAOgHBl +DncLKvbdcIlijewY +EObjjvbdrbFllHKy +EOcKjvbdmbJwXnmu +EObkKvbdssSSxydc +DoDKjvbdSQTgKGEX +DnbjjvbdUyHtZkPO +EPCjjvbdFyUuAdYC +DoCkKvbdqFcdsvBI +EOcLKvbdqwQLbhyR +DoCkKvbdbsCkUEKB +EPCjjvbdIjEAKQHE +DnbkKvbdaNKbTUmH +EObkKvbdnCKWxPOV +EOcLKvbdZxcinClS +EObjjvbdhlFDnVDZ +DncLKvbdpyPHfpdY +EOcKjvbdTlVoAuoJ +EOcKjvbdmbKXXoOV +DoCkKvbdxsOImSBg +DncKjvbdZHXEAPTJ +DoDLKvbdDjIKVwjA +DoDLKvbdnCJvwoNu +EPCjjvbdZeYGzghb +EPDKjvbdHffzYxXg +EObjjvbdirzhrkJz +DoCjjvbdZnnJFFZj +EPDKjvbdeATqMwif +DoDKjvbdbVCHXjsh +DoCjjvbdGckVjCKK +EOcLKvbdyYJJbPzL +DoCjjvbdiCPDFWpq +EOcLKvbdIwtCILqQ +DoDLKvbdKQzFOfOF +EOcKjvbdNPwqWNgT +EObjjvbdZLqcsmkm +EPDLKvbdnPyxvKxb +DoDLKvbdKjaHvAKZ +EObjjvbdjKFgjNYS +DnbkKvbdLAkGmCXq +DoDLKvbdeEoSBwCj +DnbjjvbdHlBznXRL +DnbjjvbdKfGHbBRV +DnbkKvbdZQldiMdq +EOcLKvbdnBivwnnV +DncKjvbdsQVoKDWG +EObkKvbdypnlhiwA +EObkKvbdrykpTAgn +DoCjjvbdaMkBsUmH +EPDLKvbdRDcBPqES +DoCjjvbdpxngfpdY +EOcKjvbdEztRFLbi +EOcLKvbdcbTNSAUN +DoCkKvbdjcLjpfuH +EPCkKvbdjSzhsKiz +EPCkKvbdoAKztIDn +EPCjjvbdMgDQNPuL +DoDLKvbdKNAEZgVB +EPCjjvbdZsiJZDsO +EOcLKvbdkCkkQfuH +DoCjjvbdnGeXmNfy +DnbjjvbdrpVoJbuf +DoCkKvbduCbuWuoP +EObjjvbdSwkMNzkY +DoCkKvbdrNZiyMHi +DnbjjvbduDCtvuoP +DoDLKvbdMuSqjmAX +EObkKvbdsQVnicVf +EPCjjvbdmfeYNNgZ +DncLKvbdmIdURUqa +EPCkKvbdGBPQyJzm +EPCjjvbdZRNFImEq +DncKjvbdNddUJJLE +EObkKvbdaSFbgsek +DncKjvbdDoCkKwDE +DoCjjvbdtkxWaUBX +DncLKvbdfNGXHMjL +EPCkKvbdqTtHSSKt +DnbkKvbdxmrhXsJD +DnbjjvbdmttykKSG +EObjjvbdqcdhomua +DoCkKvbdVTlsfMVj +DnbkKvbdRECaPpcr +DnbkKvbdijFhKNYS +EObkKvbdIwsbIMRQ +EPDLKvbdJbibqJbx +EPDKjvbdxxJKCPyk +EOcKjvbdjuvnECYX +DnbkKvbdKRZePFme +DnbkKvbdMpYRVnGs +EOcKjvbdfMevgNKL +DoCkKvbdmfeXmOHZ +DncLKvbdFpATXGey +DoDKjvbdJXtCIMQp +EObjjvbdZshiZDsO +EPDLKvbdaRfDHsfL +DncKjvbdMIakqYAS +EObjjvbdSLZGUfjs +DoDKjvbdBcoaWJmG +DoDKjvbdEuxpPlie +EObjjvbdJcJbqKCx +DoCjjvbdxwhiapZk +DnbkKvbdsBemLfkZ +DoDLKvbdHgGyxwxH +EOcKjvbdQdDApRDr +EPDLKvbdKWUfDeHJ +DnbjjvbdjvXODbYX +DoDLKvbdHELWJbKK +DncLKvbdgFkynHHA +EPCkKvbdPxmAHSqj +DoDLKvbdYkqdTnLm +EPCkKvbdJYUCILpp +EOcKjvbdxwhjBpZk +DoCjjvbdiMFENtcZ +DoCjjvbdnCJvwoOV +DoDKjvbdSKxetgKs +EOcKjvbdWRmxCFMD +EOcLKvbdpedFTvBI +EObkKvbdbAvEfPow +EObkKvbdZnmiEeZj +DnbkKvbdtTSSyZeD +EPCkKvbdPxmAGsRj +EPCkKvbdVTmUGLvK +EObkKvbdJmADyfta +EOcKjvbdwWlBVaWV +DoDLKvbdjcMKqGtg +EOcLKvbdGGJrNiTq +DnbkKvbdgPazvdYI +EPCkKvbdGLEsDHmV +DnbjjvbdqceIomua +DncLKvbdjbkjpgUg +DoCjjvbdSxLLmzkY +EPDLKvbdjKGHilxS +EPDKjvbdmbJvwoNu +EPDKjvbdjmBkyeHP +EPDLKvbdzROliJwA +DnbjjvbdUaBprprZ +DoDKjvbdtbbtwWPP +DnbjjvbdURQoVVHm +DoCjjvbdjbkjqGuH +DoCjjvbdRbEFLhyL +DncKjvbdBcpAujMf +DoCkKvbdPxmAGrqj +EPDLKvbdZRMeImFR +EOcLKvbdcScKscia +EObjjvbdeXytTrFz +EPCjjvbdKfGICBQu +DncKjvbdijGIKMwr +EObjjvbdZLqctOLm +EObkKvbdSLZFuGjs +DnbjjvbdZMRcsnMN +EPCkKvbdWSOYBeMD +EObjjvbdRacdlJYk +DnbjjvbdFyVUaEXb +EObjjvbdRbEFLiYk +EObjjvbdZjTIQGaf +EPCkKvbdNsTugEtp +DoCkKvbdEASIlyvw +DoCjjvbdsrrSxzFD +DoDLKvbdQwOEDMID +EPDKjvbdaaVeGQPw +DoCjjvbdFejRnItR +EObkKvbdRacdlIyL +DnbjjvbdGGJqnIsq +DoDLKvbdGYtuBDxC +DncKjvbdbLMGPODA +EObjjvbdqYoIGpcx +DncKjvbdrykosAgn +EPCjjvbdJbjDQjCx +EObjjvbdkySqsYft +EPDKjvbdxwhjBpZk +DncKjvbdauBfwkTh +EPCkKvbdtSrSxydc +DoDKjvbdMRvmZuQz +DncLKvbdnUtyjiqf +DoDKjvbdSLYetgKs +DoDLKvbdJbjCqJcY +EPDLKvbdShyiqAAl +EPDLKvbdSQUHJfDw +EOcLKvbdijFhJmYS +EPDLKvbdvwMBWAvV +EObjjvbdeXytUSFz +EObjjvbdWXJXuceH +EPCkKvbdrDeIomvB +DncKjvbdczZQXyRC +DnbjjvbdQlxCZOUz +EPCjjvbdQccApRDr +DoCkKvbdqiAJdloF +DoCjjvbdDwwktTtM +EPCjjvbdRpUGjGEX +DnbkKvbdWfYytAPT +EPCjjvbdUMVoBVni +EObkKvbdxnShYTIc +EObjjvbdVAaqSprZ +DncLKvbdKVtfDdgJ +DoCjjvbdliEUQtqa +DnbjjvbdiGjCyWKV +DnbjjvbdqrVLOLBN +EObkKvbdUaCRSqSZ +EObkKvbdTkvPAuni +DoCjjvbdIGgZyXwg +DoDLKvbdssRsYzEc +DnbjjvbdZLqdTmkm +EPCjjvbdUtNTfLvK +DncKjvbdfMewGmJk +EOcLKvbdCTBDTfWr +EPDKjvbdFpASwGey +EPCjjvbdZLrETmkm +EPDLKvbdyXhjCQZk +DnbkKvbdeATqMxJf +DoCjjvbdjJfHilwr +EPDKjvbdzitopESt +EPDKjvbdEuxopMjF +DoCkKvbdvBEYroFI +DnbkKvbdrNZiyMIJ +EPCjjvbdxVMdpyMO +DnbkKvbdQlxCZOUz +DnbkKvbdqmZiyLhJ +DncLKvbdXnRAXuWU +EObkKvbdRadElJYk +DncKjvbdLiBkqYAS +DnbjjvbdmRyUysDi +DoDKjvbdKCicQjDY +EOcLKvbdRkZGVGjs +DoDKjvbdtSrSyZdc +EOcKjvbdRyjISbvA +EPCjjvbdHffyyYYH +EOcKjvbdaogHDkzd +EPCjjvbdidkGuPAO +EOcKjvbdCDpAujMf +DoCkKvbduVnXjQsA +DnbjjvbdTulQJtAq +DncKjvbdqTsgRrLU +DoCkKvbdzdynzdyp +EObkKvbdemGXHNKL +EOcKjvbdJXtCHlRQ +EPDKjvbdegkWRnQg +DoCjjvbdyXiKCPyk +EPDLKvbdlZTRsZHU +DoCjjvbdfNFvgNKL +DnbjjvbdbVBgYLTh +DncKjvbdcJMikFvx +EPDLKvbdUMVnaVoJ +DoCkKvbdgQBzvcxI +DoCjjvbdZtIhxdSn +EPCjjvbdRWnEDMID +EObkKvbdjlakydfo +DncLKvbdrpWOicVf +EOcKjvbdhgKDYuiu +DoDKjvbdmIdTqUqa +EPCjjvbdwtleQxkn +EObkKvbdcJNKKfWx +DncLKvbdNsUWGdtp +DoDKjvbdWSOXbEkc +EPCkKvbdpyOhHREY +DoDKjvbdkyTSTYft +EPCjjvbdFjdrbgmV +DncLKvbdrounjDWG +DoDKjvbdVTmTfLvK +EPDLKvbdSCDeLiYk +DoCkKvbdrXPlDIxq +DncLKvbdKVuGDeHJ +DnbjjvbdrWokcIxq +EObjjvbdKVuGEEfi +EPDLKvbdrbGMlGjy +EPDKjvbdlqxtzSci +EOcLKvbdwygeeweS +EObjjvbdjKGIKNYS +EObkKvbdVrOXbElD +DnbjjvbdrMzKZLgi +EPCkKvbdMpXqWNfs +EPDLKvbdrSUkOLAm +EPDKjvbdZisIPfbG +EPDLKvbdRDbaQRES +DncKjvbdVTmUGLvK +EOcKjvbdYzcGRjWZ +EObjjvbdMuSrLNAX +DncKjvbdjgflGFnL +DncLKvbdWIXvXfxz +DoDLKvbdNHComPtk +EOcLKvbdSBceLhyL +DoCkKvbdZRMeImFR +EPDLKvbdiifIKMwr +DoCkKvbdvBDxsOeI +EPDLKvbdxmsHxShc +EOcKjvbdcyyPxZRC +DoCkKvbdsBfNMHKy +DoDLKvbdaRebhTfL +DncLKvbdypoNJKXA +EObkKvbdzRPNJKXA +DnbkKvbdTvLoitBR +EOcKjvbdWHwuxGxz +EObjjvbdZHWdAPTJ +DnbjjvbdySnJMqag +EPCkKvbdtTRsYzFD +EPDLKvbdhytelQnG +EPCkKvbdTppntuHm +DnbjjvbdZeYGzhIb +EPCjjvbdIwsaglQp +DoCkKvbdpstGrRkU +EObjjvbdCJLBjiFj +EOcLKvbdePErjstS +EPDKjvbdpxnhGqDx +DnbjjvbdZyEKOClS +DoCjjvbdpyOhHREY +DncLKvbdNGcPmPuL +DoDLKvbdQwNccLgc +EPDKjvbdmbJvxPNu +DnbkKvbdQwOEDMHc +DoDKjvbdXrlAltOx +EPCkKvbdGQASvgGZ +EOcLKvbdmttykKSG +EOcLKvbdGLFSbgmV +DncLKvbduCbuWvOo +EPDKjvbdSQTfiecw +DoCkKvbdYkqctNkm +DoDLKvbdlZSqsZHU +DoDLKvbdqGEEtVaI +EObjjvbdhytekpmf +DoDKjvbdmuUzKiqf +EObjjvbdrMyiyLhJ +DoDLKvbdEARhlzWw +EObjjvbdaRfCgsek +EPDKjvbdaNKaruNH +EOcLKvbdJqZeOenF +DnbjjvbdTfzmlXVe +DoCjjvbdzQoNIjXA +EObkKvbdMpYQvNfs +DncLKvbdVrOYCElD +DoCjjvbdijGIJlwr +DoDLKvbdrXQMDIyR +EPDLKvbdEYYMUTtM +DncKjvbdkHgMFenL +DnbjjvbdqdFIpOWB +EObkKvbdqFceTvAh +EObjjvbdyOSgxSiD +EOcKjvbdDnbkKvcE +DoDLKvbdYqMeImFR +EObkKvbdwtleRZMO +EPCkKvbdrWolCiYq +EObjjvbdrXPkcJYq +DoCkKvbdtlXvaUBX +EOcLKvbdeYZssrFz +DoDLKvbdnGeYMnHZ +EObkKvbdYTLaMtOx +DoDLKvbdJcJcRKDY +EPDKjvbdeKJrVtzn +DoCkKvbdrSUkNjaN +DncKjvbdeATqNXjG +EObkKvbdqlzJyLhJ +EObjjvbdDjIJvXjA +EObjjvbdzGyMAMdw +DoDLKvbdFfJrNiTq +EOcLKvbdBhkCKiGK +EObjjvbdpssgSRjt +DncKjvbdKaLGlbXq +EOcLKvbdlYrqrxgU +EPCjjvbdVqmxBeLc +EPDLKvbdZQmFJNFR +DoCkKvbdkCkkQfuH +DncKjvbdauCGwjsh +DoCjjvbdEASIlywX +DncKjvbdLAjgNBxR +DncKjvbdCDpBVimG +EOcLKvbdqlzJxkhJ +EPDLKvbdtvNxKRTA +DnbkKvbdGLFScINV +DoCkKvbdQvmdCkhD +EPDKjvbdFjdrbhNV +EPCkKvbdZLrETnLm +EPDLKvbdTvLoisaR +EPDLKvbdsrrTZZdc +EPCkKvbdZMRcsmlN +DncLKvbdxnTHxTIc +EOcKjvbdzROliJwA +EOcKjvbdsQVnjDVf +EObkKvbdqGDdsvBI +DncKjvbdwtleQxkn +EObjjvbdTqRPUuHm +DnbjjvbdVwIwvEFH +EPCjjvbdZshhxcsO +DoCkKvbdKCibqJbx +EOcKjvbdUVlQKTaR +EObkKvbdVTmUFlWK +EOcLKvbdmIctRVRa +DoDKjvbdPIAYZAYa +DoCkKvbdjvWnDbXw +DnbjjvbdtvNwjRTA +EObjjvbdNHComQUk +EOcKjvbdySnImRbH +DoCjjvbdDjIKVxKA +DncLKvbdKefHbApu +EObjjvbdehLWRmpg +EOcLKvbdJTZAsMwl +DoDKjvbdZirgpHCG +EObkKvbdozmcjxPA +EObkKvbdsZkosAgn +EPCjjvbdSxKlNzjx +DoCjjvbdfILVrNpg +EPCjjvbdGGKRnJTq +DnbjjvbdpssgSSLU +DoDKjvbdrDdiPmvB +EPCkKvbdZtJJYcsO +DoDLKvbdNdctIhkE +EPCjjvbdcImJkFvx +EOcLKvbdGLErbhNV +DoCkKvbdnQZxukYb +EPCkKvbdWSNxBeLc +EPCkKvbdsPvOjDWG +EOcLKvbdeFOqavbj +EPCjjvbdjAQHApHK +EPDKjvbdwXMBVaVu +DncLKvbdMowqWNfs +DoCkKvbdRbEFMJYk +DoCkKvbdrNZjZLhJ +DoCjjvbduDCtwWPP +EObjjvbdNeEUJIjd +DnbkKvbdlYsRsYgU +DoCjjvbdUxgsyjnn +EObkKvbdbLMGPODA +DoCkKvbddneTKtUS +EOcKjvbdvvkaWAuu +EPDKjvbdVUNUFkuj +EObjjvbdKDKDQjCx +EPDKjvbdnUuZjiqf +DoCkKvbdsCFmMGkZ +DncKjvbdrpVnjDWG +DnbjjvbdiZtfMQmf +DoCkKvbdwWkaVaVu +DoCjjvbdSCDeLiZL +DncKjvbdEYYLtTsl +EPDLKvbdOSsufeVQ +EOcLKvbdWSOXadlD +EPDLKvbdpaJFAXHd +DncKjvbdSCDdkhyL +DoCjjvbdIMBzmvqL +DnbkKvbdVUMsfLvK +DoCkKvbdlhctQuSB +DncKjvbdJuuGEFGi +EPCjjvbdJSyAsMwl +EOcKjvbdUtMtGMVj +EPCkKvbdHDkWKCKK +DncLKvbdySnImRag +EPCjjvbdwMvAMcdm +DnbkKvbdelevfmJk +EPDKjvbdYORAYUvU +EPCkKvbdVwIxWDeH +EObjjvbdtvOXipsA +DncLKvbdhlEdOUcZ +EOcLKvbdTlVoAuoJ +EPCkKvbdNQXpunHT +EOcLKvbdWXJXvDdg +DnbkKvbdZoOJFEzK +EObkKvbdmbKWwoOV +DnbjjvbdiHKDYvKV +DncKjvbdfSBWzlDP +DoCkKvbdLBKflawq +EObkKvbdUsmUFkvK +EObjjvbdLqwNZtpz +DoCkKvbdsBfNLfjy +DncLKvbdjvWmcbYX +EObkKvbdaMkBruMg +EPCkKvbdHkazmvqL +DnbjjvbdRyjHrbvA +EPCkKvbdNQXpvOHT +EObjjvbdOYPVzcnU +DoCjjvbdaSGCgtFk +DoDKjvbdxmsHxSiD +EObjjvbdZirgogCG +EOcLKvbdmuVZkKSG +DncLKvbdUyHszKnn +DnbkKvbdxmsHxTJD +EPCkKvbdVrOYBdkc +EOcLKvbdhkdcmuDZ +DncKjvbdwuMdpyLn +EObkKvbdxVMdpxlO +EPDKjvbdmbKWwoOV +DoCjjvbdhkeDmtby +DncLKvbdLFehCBQu +DoCkKvbdYSkaNUOx +DnbkKvbdmaivxPNu +EPDKjvbdfNFvgNKL +EPDKjvbdhlEdOUcZ +EPDLKvbdTukpKUAq +DncKjvbdUVlQKTaR +DnbkKvbdYgWdAPSi +DoDKjvbdIwsbHkpp +EOcKjvbdlZTSTYgU +DoCkKvbdNHColpVL +EPCjjvbdxrmhmRag +EObkKvbdUxgsyjnn +DoCjjvbdsQVoJbvG +DoCkKvbdBdQBVjMf +EObkKvbdIHHZxxXg +EOcKjvbdJuuFdEgJ +DoDLKvbdwyhGGXeS +DnbkKvbdSKyFuGkT +DoDKjvbdiGibxvKV +DncKjvbdnBjXXoNu +DnbkKvbdFpATWffZ +EPCjjvbduDCtvvOo +EObjjvbdIsZArlxM +DncKjvbdEvYopMjF +EObjjvbdwuMdqYkn +DoCjjvbdwyhFfYEr +EPCjjvbdqUTfrSLU +EOcLKvbdzGxlANEw +EPCjjvbdEOcKjwCd +EPCkKvbdOSsvGeUp +DncKjvbdhlEcnUcZ +EPCkKvbdUVkoitAq +DnbjjvbdOAJTTjSA +DncKjvbdqmZiyLhJ +EObjjvbdpstGqrLU +EPDLKvbdFxuVAcwb +DoCkKvbdauBgYKsh +DnbjjvbdZMRcsmkm +EOcLKvbdqrVLNkBN +DoDKjvbdNQYRWNgT +DoCjjvbdCTBCtFvr +DncKjvbdZyEKNcMS +EPCkKvbdVviYVdFH +DoDKjvbdePErjtUS +EObkKvbdwtmFRZLn +DncKjvbdpedEsvAh +EPCkKvbdzoQRFClY +DoDKjvbdIxTbIMQp +DoDLKvbdxsOImSCH +EPCjjvbdYfwEAOri +EOcKjvbdnPyyWLZC +EOcKjvbdhlFEOVCy +DoCjjvbdwyhFfXdr +DnbkKvbdZQmEhleR +DnbjjvbdbAudepPw +DnbjjvbdMpXqVmgT +DncLKvbdNeEUIhjd +EObkKvbdMfbomQUk +DoCkKvbdqvpMDJYq +DoDLKvbdfekzNfgA +EOcLKvbderAvzlCo +EOcLKvbdiZtelQnG +EPDLKvbdRXNdClHc +EPDKjvbdNrsufeUp +DncKjvbdZQldiMeR +EObkKvbdiLdcmtby +DncLKvbdZQmEhleR +DncLKvbdZRNEiMdq +DncLKvbdWRmwadlD +EPDLKvbdGLEsDHlu +DncLKvbdZjTIPgCG +EObjjvbdxnTIXsIc +EPCjjvbdliETptqa +EOcKjvbdlrZUyrci +DoDKjvbdbKlFnnDA +DnbjjvbdwXLaWBWV +DoCkKvbduaEZSoFI +EPCjjvbdRyjHrbvA +EPCjjvbdLhakpxAS +DoCkKvbdmaiwXoNu +EOcKjvbdyNrhYShc +EObjjvbdsCFllGjy +DnbkKvbdZshhxdTO +DoDKjvbdZjShPfaf +EOcKjvbdmajWwnmu +EObjjvbdJvUfEFHJ +EPCkKvbdOEcsiIkE +EPCkKvbdkNBlZeGo +DoCjjvbdVviXudFH +DnbkKvbdjJfHjMxS +DoDLKvbdGBPRZJzm +EOcKjvbdiCObdvqR +DnbjjvbdVwJYWDeH +DncKjvbdGAoQxizm +EObjjvbdxmsIYSiD +DncLKvbdqqtkOLAm +EObjjvbdvvlAvBWV +DncKjvbdvAdZTPFI +EOcKjvbdjAQHAogK +EObkKvbdpxoIHRDx +EPCkKvbdffLynGgA +EPDLKvbdTvLpKUAq +EOcKjvbdmttzKjSG +DoCkKvbdqwQMChyR +DoDKjvbdrzMPsAgn +DoDLKvbdyYJKCPyk +DoCkKvbdRbEEkhxk +EPCkKvbdBdQAuilf +EPDLKvbdRaceMIyL +EOcKjvbdraelkfjy +EOcLKvbdEASIlzWw +DnbkKvbdOSsvGeUp +DnbjjvbdmuVZkJrG +DnbkKvbdVwIwvDeH +DoDKjvbdwWlAvBVu +DncKjvbdSKyFuGjs +DoCkKvbdOXnuzcmt +DncKjvbdrXPlDJZR +EPDLKvbdsBfNMGjy +EPDLKvbdiifHilwr +DnbkKvbdjvWmcbYX +DoDLKvbdZnmhddyj +EPCkKvbdemFvfmKL +EPDLKvbdNxPVzcnU +DnbjjvbdRkYfUgLT +EPCkKvbdZRMdhldq +EObjjvbdYqMdhmFR +DncLKvbdJvVGDeGi +EPDKjvbdUtMsfLuj +DoDLKvbdZyEJnClS +DnbkKvbdjcMKqGtg +EPCjjvbdDnbjkXDE +DnbjjvbdLGGICAqV +EPDKjvbdWIXvYGxz +EOcLKvbdBiLCKhfK +DnbkKvbddwzUURez +EOcLKvbdZQldiMdq +DncLKvbdKVtfEFGi +DoCkKvbdvAcxsPEh +DncLKvbdjvWmcbXw +EObkKvbdqiAJeNOe +EOcLKvbdUMWPBWPJ +EPCjjvbdOFDshhjd +EOcLKvbdVrNxBeMD +EPDKjvbdiGicZWKV +EObkKvbdtTRrxzFD +DoCjjvbdjJfHilxS +DoCjjvbdelfXGmKL +EPCjjvbdIrxaTMwl +EOcLKvbdRECaPpcr +DnbkKvbdiLeDmtby +EPDLKvbdGcjvKCJj +EOcKjvbdWWiXuceH +DoCkKvbdpstHRrLU +EPDLKvbdkHgLeemk +EPCkKvbdzGxlANEw +EObkKvbdjKGHjMwr +EPCkKvbdiUzEvquC +EOcLKvbdwXMBWBVu +EObkKvbdeKKRvUzn +DncLKvbdSBceLhxk +DoDLKvbdJbibqJbx +DncKjvbdeAUQlxJf +EPDKjvbdbUafwkUI +DoCkKvbdxnTIXriD +EPDLKvbdRacdlJYk +EOcLKvbdmgFXlnGy +EOcKjvbdHELWJaij +EPDLKvbdLhbMQxAS +DnbkKvbdhbPDFXRR +EOcKjvbdqwQMDIxq +DncKjvbdeOdrkTsr +EObjjvbdyOSgwriD +EPCkKvbdjmCLyeHP +DnbjjvbdZisHpGbG +EOcKjvbdIHGzZXwg +DncLKvbdwWkaWAvV +DoDKjvbdffLzOHHA +EPCjjvbdqZPIHREY +DoCkKvbdDjHivYKA +DoDLKvbdYNqAYVWU +EPCkKvbdzjUpPcrt +DncLKvbdlqyVZrdJ +DncLKvbdDoDLLXDE +DoCjjvbdcSbjtDia +DoDKjvbdDxXlUTsl +DncLKvbdJYTahLpp +EObkKvbdNQXqVnHT +EObjjvbdijGIJlxS +EObjjvbdOStVfdtp +EPCkKvbderBWzlCo +EObjjvbdKQzEnenF +EPCjjvbdmtuZkKRf +EPCkKvbdEJhJuxKA +EPCjjvbdgGLymfgA +EObjjvbdRbDeLhxk +EOcKjvbdrSUkNkAm +DoDLKvbdEOcLLXDE +EObjjvbdBhjbKiFj +DoDLKvbdBdQAuimG +DnbjjvbdDwwkstTl +DoDLKvbdVwJYVdEg +EOcKjvbdACqwizJQ +EObjjvbdZsiIyETO +EObkKvbdGLFSbhMu +EOcLKvbdFkFTChNV +DnbjjvbdVBCRSprZ +DoCjjvbdssRsYydc +DoCkKvbdUMWOaWOi +DoDKjvbdYSlBMsnx +EObkKvbdNsTvHFVQ +EPDKjvbdZisIPfaf +EOcLKvbdpssfqqjt +EPCkKvbdNHCpMpVL +EPDKjvbdczZPwxpb +EPCjjvbdnBivxPOV +DoDKjvbdUtNTelVj +EPDKjvbdjhHMFfNk +EObjjvbdEuyPolie +EPDLKvbdKQydneme +EPCkKvbdQvnECkgc +EPDLKvbdatbGxLTh +DoDLKvbdNPxQvOGs +DoDLKvbdySnImSCH +EObkKvbdvBEZTOeI +DoCjjvbdatagXkUI +DnbjjvbdmbKXXnnV +EOcLKvbdmbKXXoNu +EPCkKvbdNsUWGduQ +DncLKvbdpssgSRjt +EPDLKvbdiUzFXSUb +EObkKvbdyzeORgiI +EOcLKvbdKDKDQibx +DoCjjvbdmJDtQuSB +DncLKvbdaNKaruMg +DnbkKvbdOEctJJKd +EObjjvbdkVvnECXw +EObkKvbdKaLHMbXq +DoCjjvbdYzcFqiuy +DoCkKvbdvwLaWAvV +EPDLKvbdnBiwXoNu +EOcLKvbdLBKgNBwq +EPCkKvbdCJLBjiFj +EObjjvbdptUGqrLU +DoCkKvbdWXJYWEFH +EOcLKvbdNeEThiLE +EPCjjvbdtAHQhAAr +EOcKjvbdUGzmlXVe +DnbkKvbdrylPsBIO +EPCjjvbdICLzEzAD +EPDKjvbdrpVoKCuf +EPCjjvbdRkZFuGjs +Dnbjjvbdznopdbkx +DoDLKvbdmgFYNNfy +EObjjvbdptUHRrKt +DoCkKvbdhfjDZWJu +DncLKvbdLGFgbBRV +EPCjjvbdZnnIeEyj +DoDKjvbdmtuZjirG +EPCkKvbdmbJvwoOV +DncLKvbdJpydoFme +EPDKjvbdFyUtaEXb +DnbkKvbdqFcdtWAh +DnbjjvbdWRnXaeMD +EOcKjvbdCIkBkJGK +EOcKjvbdJTZBSlxM +DnbjjvbdziuPocsU +DnbjjvbdhzUelQmf +EPCjjvbdUaBqSprZ +DncLKvbdxZgefXdr +EObjjvbdKVuFdEgJ +EPCjjvbdAMgyTWzY +DnbjjvbdiHJbxuiu +DoDLKvbdUtNTekuj +EPCjjvbdUQpnttgm +DoDLKvbdVAbRTRSZ +DncKjvbdkxsSTYgU +DnbkKvbdMfbomQUk +DoCjjvbdTAEiHbOd +DoCjjvbdczZPxYpb +DnbkKvbdUVkojUBR +DncKjvbdddnqavbj +DoDLKvbdxwhiapZk +DoDKjvbdZirhPfaf +DoDKjvbdTukoitAq +DoCjjvbdrJAKFMne +EObkKvbdZQmEhmFR +DoCjjvbdHgHZyXxH +DncLKvbdNHCpNPuL +DoCkKvbdfIKvRmpg +DoCjjvbdNsUWHEtp +DoCjjvbdpfDdtWAh +DoDLKvbdBhkCKiGK +EObjjvbdtSqsYydc +EPDLKvbdQccBPqES +EOcLKvbduMXvaUAw +EOcLKvbdZMRctNkm +EObjjvbdRadFMIxk +DncLKvbdjhGlFfOL +DoCjjvbdhtzEvqtb +DnbjjvbdUtNUGMWK +EPCjjvbdaaWEfQQX +DncKjvbdunszpkOt +DoDKjvbdEJgjWYKA +DoCkKvbdQYmAGsRj +DoCjjvbdmozYujyC +DnbkKvbduVnYKRTA +DnbkKvbdZxcjNblS +EPDKjvbdzRPNIiwA +EObkKvbdzitopESt +EObjjvbdfILVrNpg +DoCjjvbdNGcPmPuL +DnbjjvbdEYXlUUTl +DnbjjvbdraellHKy +DoDKjvbdZQmEhmFR +DoCkKvbdZnnIdeZj +DnbjjvbdjcMKpgVH +EObkKvbdTfznLvue +EOcKjvbdFkErcIMu +DncKjvbdGdKvKBjK +DoCjjvbdVvhwvEFH +EPCkKvbdmJEUQuSB +DncKjvbdIsZBSlxM +DnbkKvbdmbJvxPNu +DoDKjvbdTqRPVUhN +DoDLKvbdwygefXdr +DnbjjvbdLGGHbBRV +DncLKvbddijSVtzn +EObkKvbdZnnJFFZj +EOcKjvbdCTBCsfXS +DoDLKvbdmttzKjSG +EOcKjvbdyNsIXsIc +EOcKjvbdbVBgXjtI +EOcLKvbdGFjRnJUR +DnbkKvbdYTMBMtOx +EPCkKvbdNGcQMouL +DoDKjvbdJcKDQibx +DoDLKvbdrpWOicWG +EOcKjvbdRaceMIyL +EPDLKvbdWWiYWDeH +EPDLKvbdczZQXxqC +DoDKjvbdLBKgMaxR +DnbjjvbdZjShQHBf +DoCkKvbdKaLGlbXq +DnbkKvbdGdKujCJj +EObkKvbdIBkydzAD +DnbkKvbdqUTgSRkU +EOcLKvbdBiKbKhfK +DoDKjvbdVwIwvEEg +EPDKjvbdIjEAKQHE +DoCkKvbdEPCkLWcE +DoDLKvbdrDeJQNua +EOcLKvbdNddUIhjd +EPCkKvbdYNqAXtvU +EObkKvbdUaCRSqRy +EPCjjvbdqqtjmjaN +EPDLKvbdhbOcFWpq +DoDKjvbdULvPBVni +DoDKjvbdGGJrOJTq +DoCkKvbdqceIpNvB +EOcKjvbddePSCXCj +EPCjjvbdVUNTekuj +DnbjjvbdLGGHbApu +DoCkKvbdcTDLTcia +DnbkKvbdNsUWGeVQ +EObjjvbdZLqcsmlN +EObkKvbdxrnJMrCH +DnbjjvbdqvolChxq +EPCjjvbdaNKbSuNH +DnbkKvbdlYrrTYft +EPCjjvbdwtldpyMO +DnbkKvbdNddThiKd +EPCkKvbdjJfIJlwr +EPCjjvbdJpzEoFme +DnbkKvbdiMEcmuDZ +EOcKjvbdkVvmdBww +EOcLKvbdAMgxrwZx +EObjjvbdatbGwjtI +EOcKjvbdTAEhhCOd +DnbjjvbdfNFwHNJk +EObjjvbdVBBqSpqy +EPCjjvbduaEZSndh +EPDLKvbdpstGqqkU +DnbkKvbdIwtCHlQp +DncKjvbdrbGNMGkZ +EOcKjvbdILaznWqL +DoCjjvbdTXjkmzkY +DoCjjvbdIGfyyXxH +EOcKjvbdjKFhKNXr +EPDKjvbdRDcApRES +EObjjvbdmfdxNNfy +EObjjvbdDihKWYKA +DoCjjvbdzaAOffal +EPDLKvbdQccBQQcr +EPCjjvbdTlWPAvOi +DnbjjvbdqUTfrSLU +EObjjvbdVAbRTRRy +DoCkKvbdnCKWxPOV +EOcKjvbdFjdrbhNV +DnbjjvbdrzLpTAhO +DoCjjvbdDxYMUUUM +DnbjjvbdmoyxujyC +DnbjjvbdUVkoitAq +EObjjvbdrEEhpOWB +DncKjvbdRjyGVGjs +DoCkKvbdJJdAKPgE +DoDKjvbdKDJbqKCx +EPDLKvbdcTDLUDia +DoCkKvbdePEsKssr +EPCjjvbdJbjCqJbx +DoDLKvbddBrmSATm +EOcLKvbdlhcsqVRa +EOcLKvbdKfGICBRV +EPDLKvbdrovPJbvG +DoCjjvbdbAvFGQQX +EPDLKvbdlZTSSxft +DnbjjvbdLqvmZuQz +DncLKvbdZshiYdSn +EOcLKvbduMXvaTaX +EObjjvbdZtJJYcrn +EOcLKvbdczZPwxpb +EPDKjvbdatafwjtI +EObkKvbdsQVnicWG +DnbjjvbdrWokcIyR +DncLKvbdJuteceGi +EOcLKvbdADRwiyiQ +EPDKjvbdCIkBjiFj +EPDKjvbdrNZjYkgi +DnbkKvbdSLYeuHLT +DoDKjvbdkNBkzEfo +DnbkKvbdcyxowyQb +EPDKjvbdYkrETnMN +DoDKjvbdwWlAvAvV +EPCkKvbdczZPxZQb +EPCkKvbdKCibpjCx +EOcKjvbdhytfLqOG +DnbjjvbdxmsHwriD +EPDKjvbdmfeYMmgZ +DoCkKvbdNQXpvNfs +DncLKvbdirziSkJz +EOcKjvbdHffzYxYH +EOcKjvbdWXIxWDdg +DncLKvbdVvhwuceH +DoDLKvbdFxtuBDxC +DncLKvbdJcKCqJbx +DoCkKvbdxLWcgzyf +DnbjjvbdCJLBjiGK +EPCjjvbdcasMrATm +DoDLKvbdLFfICAqV +EPDKjvbdqmZjZMHi +DncKjvbdczZPwxqC +EObkKvbdrWpMDJYq +EPCjjvbdLFehCBQu +EPCkKvbdRzJgsDWA +DoDKjvbdIsZArlxM +DncLKvbdqFcdsuaI +DncLKvbdULvPBVni +EOcLKvbdWXJXuceH +EPDLKvbdaNLCTVMg +EObkKvbdUxhUZjnn +DncLKvbdeATplxKG +DoCjjvbdmSYtzSci +EOcLKvbdkMbLzEfo +EPCjjvbdrpVoJcWG +EPCjjvbdXrlAlsoY +DoDLKvbdUxhTzKnn +EPCjjvbdOEdUJJLE +EObjjvbdKDJcRKCx +EPDKjvbdcyxpXxqC +DnbkKvbdZxdKODMS +DncLKvbdcImJjfWx +DnbjjvbdpfEFTuaI +DnbkKvbdZoNheEyj +EOcKjvbdjFKfuPAO +DnbkKvbdFVyQQNKF +DnbkKvbdDjHiuwjA +EPCkKvbdMgDPlotk +EPDKjvbdxnShXsIc +DoDLKvbdOTUVfduQ +DncKjvbdFejRnIsq +DncKjvbdSQUHJfEX +DncLKvbdRXOEDMHc +DoCkKvbdsZkosAgn +DoDKjvbdUsmUGLuj +EPDKjvbdiifIJmYS +DoDLKvbdZQmEhmFR +EObjjvbdeUAUASlv +DoDLKvbdUsltFlVj +DoCjjvbdSiZjRABM +EOcLKvbdegkVrORH +DoDKjvbdYlRdTnLm +DncKjvbdzitopESt +DnbkKvbdhbPDEwQq +DncKjvbdSKxetgLT +DncKjvbdZQmEiNFR +EPDLKvbdUyITzLPO +DnbjjvbdznpQdblY +EObkKvbdbLMFoODA +EPDLKvbdBhjbLJFj +DoDKjvbdNwoVzdOU +DncKjvbdvBDxsPEh +DnbkKvbdSBceLiZL +EPCkKvbdOhAXyAZB +EObjjvbdZisIQGbG +EOcLKvbdAMgxrvyx +EPDKjvbdCDpAvKMf +DoDKjvbdxVMdpxlO +EOcKjvbdJbicRJbx +DoCkKvbdTppnuVIN +EObjjvbdZjTIPfbG +DoCkKvbdpyOhHQcx +DoCjjvbdfHjvSOQg +DoCjjvbdzoPpdcMY +EPDKjvbdmfeYNNfy +EPCjjvbdXGYzUAPT +DoDLKvbdypnmJKXA +DnbkKvbdBsAcUFwS +DoDLKvbdQYmAGsRj +EObjjvbdUxhTyjnn +DoCkKvbdrouoKCvG +DoDLKvbdhtydwSUb +EPCkKvbddwytUSFz +EOcKjvbdrbFmLgLZ +EObkKvbdbPffckzd +EObjjvbdDxXlTtUM +DnbkKvbdqGEFTvAh +EPCjjvbdDoCkKwDE +EOcLKvbdVviYWDeH +EPCjjvbdWSOYCFLc +DncKjvbdmbKWxPNu +DoCkKvbdZshhxdTO +DoDKjvbdwtldqYkn +DoDLKvbdYSlBMsoY +EPDKjvbdRkZFuHKs +DnbkKvbdeYZstRez +DoCjjvbdrNZixlIJ +DoCjjvbdmgFXlmgZ +EPCkKvbdYlRcsmlN +DoCjjvbdOFETiJKd +EPDLKvbdBhkCLJFj +EPCjjvbdmuVZkJrG +DnbkKvbdFjeTChMu +DoCjjvbdJTZBSlwl +DnbkKvbdozmdLYPA +EObjjvbdtbbtvuoP +DncKjvbdqUTfrSKt +DncKjvbdyTOImSBg +DnbjjvbdcTCkTdKB +EOcKjvbdKaKgNCXq +EPDKjvbdZoOIeEyj +DoDKjvbdYqMeIleR +DncKjvbdnPzZWLZC +EPDLKvbdZirhPfbG +DnbkKvbdGQATXGey +EOcKjvbdZsiJYcsO +DnbkKvbdrWpMDJYq +DoCkKvbdMuTSLNAX +EObjjvbdpxnhHRDx +EOcKjvbdzitpQESt +EPCjjvbdhuZeXSUb +DoCjjvbdNeDtJIkE +DoCkKvbdCEQBWKMf +EPCkKvbdHEKvKCJj +EPCjjvbdatbHYLTh +EObkKvbdLGGICBRV +DncKjvbdRjxeuGjs +DoDKjvbdnHFYNOHZ +EObkKvbdIryAsNYM +EObjjvbdmfdwlnGy +EOcLKvbdNeDsiIkE +DnbjjvbdJTYaSlxM +DoCkKvbdRadEkiYk +DncLKvbdjKFgjNYS +EObkKvbdZjShQGaf +EOcKjvbdKfFgaaQu +DoDKjvbdhgJbyVjV +DoCkKvbdwuNFRZMO +DncLKvbdfekzNfgA +DncKjvbduCcVWuno +EPDLKvbdVrNxBdkc +DnbkKvbdRkYeuHLT +DoDLKvbdwuNEpxlO +DoCjjvbdQccAoqDr +EOcKjvbdUGzmkvvF +DncKjvbdEJhKWYKA +EOcLKvbdssSSxyeD +DoCjjvbdVviXvEEg +DnbjjvbdEuxopNKF +EObkKvbdLAkGlbXq +DoCkKvbdZsiJZESn +DoCkKvbdhkeEOUby +DnbkKvbdbhlikGXY +EObkKvbdLBLGmCYR +EPCjjvbdxUleQyLn +DncLKvbdrbGNMGjy +DoCkKvbdddoSBwDK +EPDLKvbdkyTRsYgU +EPDKjvbdehLVqmqH +EPDLKvbdrbFmMHKy +DncLKvbdmbJvwoOV +EOcLKvbdVUNUFkvK +EPDLKvbdrpWPJbvG +DncKjvbdGAnpxizm +EOcKjvbdyzeNqghh +DoDLKvbdhbPDFWpq +DoDLKvbdfVzxQJzs +DoDLKvbdUMWPBVoJ +EOcLKvbdRpTfjFdX +EPCkKvbdpfDeUWBI +EObjjvbdmuUyjirG +EObjjvbdtbbtwWOo +EObkKvbdrylPsAgn +EOcLKvbdmSYtysEJ +DncKjvbdSCDeMJYk +DoCjjvbdTppoUthN +EPDKjvbdVTmUFkuj +EObjjvbdIsZAsNXl +EOcKjvbdSBcdlJYk +DnbkKvbdZQleIleR +DnbjjvbdddoSBvcK +EOcLKvbdNHComPuL +DncKjvbdiCPCdvqR +EOcKjvbdliDspuSB +EObkKvbdzoPpeCkx +DnbjjvbdcJMijevx +DoDKjvbddZxpYZQb +DoDKjvbdkySrSxft +DoDKjvbdyXhiapZk +EPCkKvbdOAIrsirA +EObkKvbdUaBqSqSZ +EPCkKvbdZtJIyESn +DnbkKvbdTvLoitAq +EPCjjvbdyzeNrIJI +EOcKjvbdiCPDEwRR +EPCkKvbdnCJvwoNu +EPCkKvbdIGfzZYXg +DoCkKvbdkySqrxft +DoCjjvbdZdxGzgiC +DncKjvbdzitpPcsU +DncLKvbdbVCHXjsh +EPCkKvbdlhcsqVSB +EPCjjvbdGYtuAcxC +EOcLKvbdjAQGaQHK +EObjjvbdjlakzFGo +EOcLKvbdvwMAvAuu +EPCjjvbdTqQoVUhN +EPCkKvbdeEnrBwCj +DoCkKvbdsCGMkgKy +DnbjjvbdhkeDnVDZ +EPCjjvbdOFDshiLE +DnbjjvbdDwwlUTsl +EPCkKvbdKWUedEgJ +EPDLKvbdsQVnicWG +EPCkKvbdjgflFfOL +EObkKvbdQYmAHTSK +EObkKvbdSPsgJecw +EObjjvbdjAQGaPgK +DoDLKvbdDxXlUUUM +DoCjjvbdegjuqnQg +DnbkKvbddwzTsqez +DncKjvbdxxJJbPyk +EOcKjvbdGKeTChMu +DoCkKvbdeFPSCWcK +EObkKvbddeOrBwDK +EPCkKvbdaNLBsUmH +DoDLKvbdRpTgJedX +EPCkKvbdkySrSxgU +EPCkKvbdVYhTzKoO +EPCjjvbdxxIjCPyk +EPDLKvbdVrOXadkc +EOcLKvbdEOcKjwDE +DncLKvbdmfeYMnGy +EPCkKvbdVAaprprZ +EPCjjvbdFWYpQMjF +DoCkKvbdqrUjmkAm +DoCjjvbdQvmdDLhD +EPDLKvbdeATqNYKG +DnbkKvbdLGGHaaQu +EObjjvbdezvZEhtX +DnbkKvbdjuwNdBww +DncKjvbdJTZAsMwl +EPDKjvbdkxrrTYgU +EPDKjvbdbAudfQQX +DoCkKvbdVUNUGMVj +EPDLKvbdaNLBsUlg +EPDLKvbdDwxLtUUM +EPCjjvbdMgColpUk +EPDLKvbdaogGdLzd +EPDKjvbdzGxlANFX +EPCkKvbdUQqOuUgm +DoDKjvbdEPDKkXCd +EPDKjvbdbsCkTcia +EObjjvbdTAEhhBnd +EPCkKvbdhzVFkpmf +DnbkKvbdaSFcHtGL +DoCjjvbdGBOpxizm +DncLKvbdGYttaEYC +DoDKjvbdqYoHfpdY +EOcKjvbdrouoKCuf +EOcKjvbdiCPDFWqR +DnbjjvbdVAaprqRy +EPCjjvbdePFSjtUS +DnbkKvbdLGGICBRV +EPDLKvbdkMalZeHP +DoDLKvbdJutfEFHJ +DoDKjvbdVBCRSqSZ +EObjjvbdvvlBWBWV +EOcLKvbdFVxpPmJe +DoDLKvbdKfGHaaRV +DnbjjvbdBvzdIdpW +DncKjvbdNsUWHFUp +EPDLKvbdrSVLNjaN +EPDKjvbdgGMZnGgA +DnbkKvbdSBceMIyL +EOcLKvbdSBdFLiYk +EOcLKvbdRyigrcWA +EPDKjvbdaMkBruNH +DncKjvbdUaCRSpqy +DnbjjvbdIMBzmvpk +DnbkKvbdbVCGxKtI +DncLKvbdliDtQuSB +EObkKvbdHDkVjBjK +DncKjvbdmSYtyrci +DnbkKvbdxVMdpxlO +EPCjjvbdRpTfjGDw +EPCkKvbdhancEvpq +EPDLKvbdNsTvHEuQ +DoDKjvbdfekymfgA +EObkKvbdUWLojUBR +EPCjjvbdJXtBgkpp +DoCjjvbdEPCkLXCd +EPCjjvbdZxcjNcLr +DoCjjvbdZsiJYcrn +EPCkKvbdZtIiZDrn +EObkKvbduLxWaUBX +EObkKvbdZdxGzghb +EOcKjvbdkClLRHVH +EOcLKvbdFjdsDINV +DncKjvbdNeEUIiKd +EPCkKvbdYpmFJNFR +EPDKjvbdlhcsptqa +DoDLKvbdnCKWwoOV +EObkKvbdDnbkLXCd +EObkKvbdQwOECkhD +EOcKjvbdUaCRSpqy +EPCjjvbdBcoaVjNG +DnbjjvbdxmrhXsJD +EObjjvbdcImKKewY +DnbkKvbdpyOgfpdY +DnbjjvbdpyOggRDx +EObjjvbdEOcKjwDE +DnbkKvbduCcUwVoP +EOcKjvbdhgKCxuiu +DoDKjvbdiZtelQmf +DoDKjvbdnBjXYOnV +EPDLKvbdczZPwxpb +EPCjjvbdADRwizJQ +EObjjvbdfVzwpJzs +DnbjjvbdxxIiapZk +EPCjjvbdjcLkQfuH +EPCjjvbdcyyQYYqC +DoCkKvbdEuyPpNJe +DncLKvbdcJNJkGWx +DoDKjvbdZoOIdeZj +DoCjjvbdWHxVwgYz +DnbjjvbdeEoRbWbj +DncKjvbdZMSDsnLm +EOcLKvbdbiNKLFvx +DnbkKvbdjcLjqHVH +DnbjjvbdEYXktTtM +EPCjjvbdCSaCsfWr +EOcLKvbdBdQAuimG +EObkKvbdqdFIpOWB +DncLKvbdelevgNKL +EObkKvbdZMRdUNkm +EPCkKvbdrDdiQOVa +DoDLKvbdCWzdJFQW +EObjjvbdxUleQyMO +DncKjvbdBsAcTfXS +EOcKjvbdRMxBxmtz +EOcKjvbdSKyFuGkT +EPCkKvbdEuxooljF +DncLKvbdYgWdAPSi +DoCkKvbdiHJcYvKV +EPCkKvbdZQldiNFR +DncKjvbdjAPgAofj +EObjjvbdkVvmdBxX +DoDLKvbdsBfMlHLZ +DoDLKvbduWNxKQsA +EObjjvbdOTTugEtp +DoCjjvbdIxUBgkqQ +EOcKjvbdqFceUWAh +DnbjjvbdTkunaVoJ +EPDKjvbdiZtfLqOG +DoCjjvbdcImJkGXY +DncLKvbdpstGrSLU +DncLKvbdRpTfjGDw +DnbkKvbdznpREblY +DnbjjvbdqdEhomvB +DncLKvbdIwtBhMRQ +DoDKjvbdhtzFWqtb +EOcKjvbdiBncEwQq +EPDKjvbdZQleJMdq +EOcLKvbdLAkGlaxR +DoCkKvbdZsiIyDsO +EObkKvbdeOdsKssr +DnbjjvbdJcKCpjDY +EPDLKvbdSBdElIyL +EPCkKvbdyOTHwrhc +EPDLKvbdGLEsDIMu +EPCjjvbdmJETqVRa +DncKjvbdKDJbqJbx +EOcKjvbdbsCkTdKB +EOcKjvbduDCuXVno +EOcKjvbdrXPlDIxq +EOcKjvbdqlyixkhJ +EObjjvbdRkYfUgLT +EPDLKvbdLAkGmCXq +DnbjjvbdHgGzYxXg +DncKjvbdpstHSSKt +DoCkKvbdqvolCiYq +DoCkKvbdmgFYNOHZ +DnbkKvbdqGDeTvBI +DoDLKvbdyzeNrHhh +DnbkKvbdwzHefXeS +DoDKjvbdbiMjLGXY +DnbkKvbdTulQKTaR +DnbjjvbdsPunicVf +DncKjvbdqvpLcIyR +DncLKvbdOFEThhkE +EOcKjvbdZshhxdSn +DncKjvbdpyPHfpdY +DoDLKvbdNGcPmQUk +DoCkKvbdVgwvXfxz +DoCjjvbdCgLegAzc +DnbjjvbdauCGxLTh +DoDKjvbdqFceTvBI +DoCjjvbduMYXAsaX +EPCkKvbdrSVKmkAm +EObkKvbdOYOuzcnU +DncKjvbdYkqctNlN +DncKjvbdSZjHrcWA +DoCjjvbdrEFJQNua +EPCjjvbdRosfjFcw +EObkKvbdZoNiFEyj +EPDKjvbdVgwvXfxz +DoDLKvbdhbPCdvqR +DncKjvbdqvokcIyR +DnbjjvbdpssfqqkU +DncLKvbdzoPpdbkx +DnbjjvbduaDySoFI +EOcKjvbdEASImZwX +DncKjvbdbrcKtDjB +DoCjjvbdQccBQQdS +DoCkKvbdDigjVwjA +DnbkKvbdbVBfwkUI +EOcKjvbdIsYaSlxM +DoDLKvbdKVtedEgJ +EPCjjvbdIryArlxM +DncKjvbdpeceTuaI +EObkKvbdZshiYdSn +DncLKvbdZtIhyESn +DnbjjvbdOYOuzcnU +DoDKjvbdUxhTyjoO +EObjjvbdTppoVVHm +DncKjvbdrWolCiYq +DoDLKvbdNVSrKmAX +EObkKvbdiGicZWKV +DoDKjvbduVmwipsA +EPCjjvbdNPwqVnHT +EObjjvbdelewGmJk +EOcLKvbdgGLzNgHA +DoDKjvbdcJNJjfWx +DoCkKvbdyOTHwriD +EObjjvbdEzspeLcJ +DnbjjvbdjhHLeenL +DncKjvbdOStWHFVQ +EOcLKvbdsZlPsBHn +EPDLKvbdtcCuWuno +DnbkKvbdULunaVni +EPDKjvbdJqZdnfNe +EOcKjvbdqwPkcIxq +EObjjvbdrJAJeNOe +DnbjjvbdRECaPpdS +EPCjjvbdpfEEsvBI +EPDLKvbdIsZArmYM +EPDLKvbdJYUCILpp +EOcLKvbdYlSDtNlN +EPCjjvbdJYTbHkpp +EPDKjvbdYzbfSJvZ +EPCjjvbdRaceMJYk +EObjjvbdZisHofaf +DnbkKvbdRbEElIyL +EOcLKvbdijFhKNXr +EOcKjvbdRXNdDMID +DncLKvbdbiNKLGXY +DoDLKvbdlZSrSyHU +EObkKvbdqZPIHRDx +DoDKjvbdnPzYujxb +EObkKvbdnHEwlmfy +EObkKvbdCWzdIePv +EObkKvbdqlyiyLgi +EPCjjvbdkySqryHU +EObkKvbdcImKKevx +DncKjvbdEASJMzWw +DncKjvbdRkYfUfkT +EPCjjvbdqYoIGpcx +DncKjvbdGckWKBjK +EPCjjvbdYTLaNUOx +EPDKjvbdwtleRZMO +EObkKvbdGFiqnJUR +DncLKvbdlhdURVRa +EObjjvbdqlzJxkhJ +DncLKvbdFaPQyJzm +EPCkKvbdpssgRrLU +EObjjvbdiCOcFXRR +DncKjvbdqTtGqrLU +EPCjjvbdsCFlkgLZ +EOcKjvbduWOXiqTA +EOcKjvbdkClKqGuH +EPCjjvbdMowpvOGs +EPCkKvbdxrmhmRag +DoCjjvbdiUzFXRuC +EOcLKvbdUMWPAvOi +DoDLKvbdmfdwlmgZ +EPCjjvbdehKurNpg +EOcLKvbdBsAcTevr +EPCjjvbdZjTIPgBf +EObjjvbdPIAXyAZB +EPCjjvbdCDoaVjNG +DncKjvbdrpVnicVf +DoDKjvbdlZTSSxgU +DncKjvbdGZVVAdYC +EPDLKvbdsCGMkfjy +EPCjjvbdSPsfjFdX +DoCjjvbdJXsbIMQp +DncKjvbdzeZnzdyp +DnbkKvbdlYsRsYft +DncKjvbdbiMjLFwY +EPDKjvbdyOShYSiD +DoCkKvbdOTTufduQ +EPDLKvbdVwJYVcdg +DoCkKvbdGFiqnJTq +EOcLKvbdUslselWK +EObjjvbdkxsSSyHU +EOcLKvbdxsNhmSBg +DnbjjvbdqqtkOLAm +DnbjjvbdeFPRawDK +DnbkKvbdLZQirzuG +EPCkKvbdFWYpPlie +EObkKvbdrWpMCiYq +EOcKjvbdiiehKNXr +EPDKjvbdEvYopNJe +EPCkKvbdxrmhmSCH +DoCkKvbdptUHSRkU +EOcKjvbdKCjDRJcY +DoDLKvbdrMzKYkgi +DoCjjvbdZLrDtNkm +DoCkKvbdqYnggQcx +DnbkKvbdrovOibvG +DncKjvbdADRwizIp +EOcLKvbdZisHpHCG +EPCjjvbdZRNFImFR +EPDKjvbdVwIxVceH +EOcKjvbdrDeJQNua +EPCkKvbdIxTaglQp +DncKjvbdGFiqmiUR +EPCjjvbdVwJXvEEg +DnbkKvbdwuMeRZMO +EPCkKvbdZRNFImFR +EPCkKvbdnHEwlmgZ +EPDKjvbdLYqKSzuG +DoDKjvbdZsiJYdTO +DoDLKvbdShyjRAAl +DoDKjvbdRadFLiYk +DnbkKvbdjbkjpgUg +EObkKvbdUaBpsRRy +EOcKjvbdehKuqnRH +EObkKvbdDwxMUTsl +EOcKjvbdptUHSSKt +EPDKjvbdHEKuibJj +EOcKjvbdxxIjBpZk +EObkKvbdelewGmJk +DncLKvbdTvLpKUAq +EPCjjvbdGLErbhNV +DncLKvbdfHjvRmqH +DnbjjvbdkMakyeHP +EPDKjvbdJcKCpjDY +DoCkKvbdRECaPpcr +EOcLKvbdmgFYMmgZ +EObjjvbdZRMdiMeR +DoCjjvbdYzcFqivZ +DoCkKvbdeOeTKtTr +EPCkKvbdXFxytAPT +DncLKvbdZnnJEdzK +DncLKvbdhtyeWrUb +EOcKjvbdEJgivXjA +EPDLKvbdssSTYyeD +EPDLKvbdLBLGmCXq +DnbkKvbdKeegbApu +DoDLKvbdJYUBhLqQ +EPDKjvbdwNWANDdm +DoCjjvbdKfGIBaRV +DoCjjvbdbhljLFwY +DncLKvbdmgFXmNgZ +DoDKjvbdZRMeJNFR +DoCkKvbdWeyZtAOs +DoCkKvbdbiNKLFvx +EPDKjvbdUsmTfMVj +EPCkKvbdijFgjMwr +DnbkKvbdbsCjtDia +DnbjjvbdZQleJNFR +DoDLKvbdNQXqWNfs +EOcLKvbdULunaVoJ +DncLKvbdrEEhpOVa +DncLKvbdRyigsCvA +DoCkKvbdVwJYWEEg +DncLKvbdjKGIKMwr +EObkKvbdrEFIpNvB +DoCjjvbdGLEsDINV +EOcLKvbdJSyArlxM +EPCjjvbdTJZiqABM +DncLKvbdCTAbsewS +DnbjjvbdZjTIPfaf +EPCjjvbdbPfgELzd +DnbjjvbdLBLHMbXq +EPCjjvbdqiAKFMoF +DnbkKvbdIBlZdzAD +EPDLKvbdyTNiNRag +DoDLKvbdZjSgogCG +EPCjjvbdjAPgAofj +EPCjjvbdxmrgxTJD +EObjjvbdSPsgKGEX +EObkKvbdRWnDblHc +DnbjjvbdZQmFImFR +DoCjjvbdjuwODaww +EOcLKvbdVviXvEFH +EPCjjvbdcImJkGXY +EPDKjvbdVAbQrqSZ +DoCjjvbdWWiXudFH +EPDKjvbdapGfdLzd +EObkKvbdQwOEDMID +EPCjjvbdKDKCqKCx +DncKjvbdJvUfEEgJ +EObkKvbdDoDLKvcE +EOcKjvbdqwPkbhyR +EObjjvbdyTOJNSCH +EObkKvbdZsiIxdTO +DoCjjvbdaSFbhTfL +EOcKjvbdUslsekvK +DoDKjvbdehLWSORH +EPCkKvbdBsBDTfWr +DoCkKvbdMfbpNQVL +DoCkKvbdezvZFJUX +EObjjvbdJYUBhMRQ +DncKjvbdlhcsptqa +DoCkKvbdiZtfMQnG +EObkKvbdZRMdhleR +EPDLKvbdkySrSxgU +DoCkKvbdYlSDsmkm +DnbkKvbdkNBkzEfo +EPDLKvbdyYJKCPzL +EOcKjvbdqwPkbiZR +DncLKvbdqdFJQOWB +DoDKjvbdFyUtaDxC +DnbjjvbdZyDinDMS +EOcKjvbdqrVKnKaN +DoCjjvbdMgDPlotk +EPCjjvbdUVlPitBR +DoDLKvbdbsCkTcjB +EPCjjvbdnGdwlnGy +DnbkKvbdapGfdLzd +EPDKjvbddndsKtTr +DncLKvbdsrrTZZeD +EObkKvbdqdFJQOWB +DncKjvbdRadFLhxk +DnbkKvbdfILWSORH +DnbkKvbdqZOggQcx +EPDKjvbdCDpAujMf +EObjjvbdxsOImSBg +DoDKjvbdrSUjmjaN +EObkKvbdrMyjYkhJ +EObkKvbdANHySvzY +EObkKvbdgGLynGgA +DoDLKvbdNdcshiKd +EObjjvbdePErkTtS +EPCkKvbdSCEFLhxk +DoDKjvbdIxUBhLqQ +EPCkKvbdVvhxWDdg +EOcLKvbdKfGHbBQu +DoCjjvbdajlFoNcA +DoCkKvbdQdDAopdS +DoDKjvbdSBceMJZL +DoDKjvbdOStWGdtp +DoCjjvbdGdLWKBij +DnbkKvbdvOszpjnt +DncLKvbdUVlPjTaR +DoDLKvbdliDsptrB +EOcKjvbdZisHpHCG +DoDKjvbdkVwODaxX +DoDLKvbdfVzwpJzs +DnbkKvbdDjIKWYKA +EObkKvbdrJAJdmPF +EObjjvbdeATpmYJf +DnbkKvbdQmYByOUz +EPDLKvbdxmrhXsJD +EPDLKvbdCJLBjiGK +DoCkKvbdYpmFJMeR +DoDKjvbdXnRAXuWU +DoDKjvbdiMFDmtby +DnbkKvbddZyQYZQb +DncLKvbdZtIiYdSn +EObjjvbdwMvANDdm +EPDLKvbdIwsbHkqQ +DncKjvbdURQntthN +EObkKvbdTqROttgm +EPCjjvbdTkvOaVni +EOcLKvbdfNFwHNKL +EObkKvbdjgflFfOL +EObjjvbdUQqOuUhN +DncLKvbdegjurNqH +EPDLKvbdxUmEqZMO +DoDKjvbdGcjvKBjK +DoDKjvbdVTltFkuj +DnbkKvbdLYqKSztf +DoDKjvbdUyHtZkOn +EPDLKvbdvAcyTOdh +DncKjvbdqFcdsvAh +DncLKvbdrbFmMHKy +EOcKjvbdYlRdTnLm +DoCjjvbdEASJMzXX +EObkKvbdMoxQvNfs +EOcKjvbdiHJcYujV +DnbjjvbdvAcyTPEh +DoDLKvbdGQASwGfZ +EObkKvbdMoxRVnHT +EObkKvbdhgJcYvJu +DnbjjvbduWOXipsA +DoDLKvbdQcbaQQdS +EObkKvbdUsltFkvK +EPDKjvbdKyQirzuG +EPCjjvbdmJDtQuSB +EObkKvbdXrkaMsoY +EOcKjvbdrEFIpOVa +EPDKjvbdVqmwadkc +EOcKjvbdqYoIGqDx +EObkKvbdtbbtwWOo +EPCkKvbdSKxfUfkT +EPCkKvbdmJDsqUrB +DncKjvbdhaoCeWpq +EObjjvbdFxuVAdYC +EPCkKvbdqFcdsvBI +EPDLKvbdOTUWGeVQ +EPCkKvbdlhdUQtrB +DoDKjvbdCJLCLJGK +EPDKjvbdMgCpMotk +DnbjjvbdrbFlkgLZ +DoDKjvbdqBJFAWhE +EPCjjvbdpyPHfqDx +EOcKjvbdTlVoBVni +EPCjjvbdrRtkNkBN +EPCkKvbdWWhwuceH +EPDKjvbdcImKKewY +EOcKjvbdYSlBNToY +EObkKvbdZRMeIldq +EPDLKvbdMoxRWNgT +EObjjvbdMIbMQxAS +EPCjjvbdQdDBQQdS +EObkKvbddZyPwxqC +EOcLKvbdACrXiyiQ +EPDLKvbdcSbkUEJa +DncLKvbdTkunaWPJ +DnbjjvbdvBEYrndh +EObjjvbdmIctQuRa +DncKjvbdiUydvqtb +DoCjjvbdhkdcnUby +EOcKjvbdePFTLTsr +EOcLKvbdiHJbxujV +EObjjvbdZsiJZESn +EOcKjvbdpxoHfqEY +EPDKjvbdFyUuBDwb +DoDLKvbdBiLBkJGK +EPCkKvbdliDtQuRa +DoDKjvbdhbOcEwQq +DncLKvbdRosgJfDw +EObjjvbdrzMQSaIO +EObkKvbdUsmTfMVj +EOcKjvbdWXIxWEFH +EPCjjvbdcTCjtDjB +EObkKvbdbBVeGQPw +EOcLKvbdaSGDHtFk +DoDLKvbdqFdFUVaI +EPCkKvbdxxIjBozL +DncLKvbdNddUIiLE +EObjjvbduMYWaUAw +EPCkKvbdWWiXvDdg +EObjjvbdJXsbILqQ +DnbkKvbdDnbjjwCd +DnbkKvbdxUldqZMO +DoCjjvbdKyRKSztf +DncLKvbdLFehBaQu +EPDLKvbdjvXNdBww +EOcLKvbduaEZTPFI +DoCkKvbdfMevfmKL +EPCkKvbdpxoIGqEY +EPCkKvbdKWUecdgJ +EObkKvbdmbJwYOmu +EPCkKvbdIsZArmYM +DnbjjvbdxLXDgzyf +DncLKvbdEvYopMjF +DncLKvbdmJETqVRa +DnbkKvbdrouoKDWG +EPDLKvbdbVCGwkTh +DoDKjvbdZirhPgCG +EPDKjvbdTvMQKUAq +DnbkKvbdLrWlzVQz +EOcLKvbdrEEiPmua +DnbjjvbdczZQXyRC +DncKjvbdnUtzKjSG +EPCjjvbdkNCLzFHP +DncKjvbdZyEKNbkr +EObkKvbdJuuFdEgJ +DncLKvbduCbuXWPP +EPCjjvbdyNrhXriD +DnbkKvbdIxTaglQp +EPCjjvbdJvVFceHJ +EPCkKvbdVBBprqSZ +EOcKjvbdkxrqsYgU +EPCjjvbdGLFSbhMu +EObjjvbdnPzZWLYb +EObkKvbdjblLRGuH +DoDLKvbduaDyTPFI +EPCjjvbdiifIJmXr +EObkKvbdYkqctOMN +EPCkKvbdelfXHMjL +EPDLKvbdeFOrCWbj +EObjjvbdeUAUATNW +EPCjjvbdWRmxBeMD +DoCjjvbdZxcinDMS +EOcLKvbdWRmwbElD +DoDLKvbdpssfrSLU +DncLKvbdQccApRES +DoDKjvbdGdKujBij +DoDKjvbdZLqdTmlN +DoCjjvbdbiNKLGXY +DoCjjvbdVZITzKoO +DoCkKvbdsPuoKCvG +EPDKjvbdNGbomQVL +DnbkKvbdkIHMGFnL +EPDKjvbdvPTzpjoU +EOcKjvbdczZPxZQb +DncKjvbdliEURUrB +DnbkKvbdGZUtaDxC +EPCjjvbdrMyjZLhJ +EPCjjvbdTulPjTaR +DoCkKvbdZeYGzhJC +DncLKvbdwygefYEr +DnbjjvbdehLVrOQg +DnbjjvbdZxcjNblS +DoCjjvbdSLYetgKs +EPCkKvbdVAbQrpqy +EPCjjvbdtTSTZZdc +DnbkKvbdSCEFMIyL +DoDKjvbdrDeJPmvB +EOcLKvbduDDVXVno +DoDLKvbdZdxGzhIb +EObkKvbdhgJbxujV +DncLKvbdlYsRsZHU +DoDLKvbdhzUelQmf +EObkKvbdWWhwvDeH +EPCjjvbdjgfkfFmk +EObkKvbdzaAPHGal +DoDLKvbdEPDLLXDE +DoCjjvbdTukpKTaR +EOcKjvbdhaoCeWpq +EPDKjvbdwjvdHzzG +EPDLKvbdJTZBTNYM +DoDLKvbdRECaPqDr +DncKjvbdjhGkfGNk +EObkKvbdjhGkfFmk +DncLKvbdqlyixkhJ +EObkKvbdjEkHUoAO +EPCkKvbdcasMrAUN +EObjjvbdhzUfLqOG +DoCkKvbdEvYopNKF +EPCjjvbdjuwODaxX +DncLKvbddiirWUzn +EObkKvbdOStVfduQ +DnbjjvbdypnmIjXA +DnbjjvbdRWnEClHc +EOcLKvbdbhljLFvx +EPDLKvbdJXsaglRQ +EObkKvbdhzUfLqOG +EObkKvbdnPyxujyC +DoDKjvbdBiKajiFj +DoDKjvbdZjTHpHBf +EPCjjvbdaSFcITek +EObjjvbdYzcFqiuy +DncLKvbdqdFIpNvB +DoDKjvbdLYqJrzuG +DoDLKvbdVwJXucdg +DnbjjvbdhbObdvqR +DoCkKvbdCEQBWJlf +DoDLKvbdSCDdlJYk +EPDLKvbdZyEJnCkr +DoDKjvbdvAcyTOeI +DoDKjvbdkIHLfFmk +EPCjjvbduaEYroFI +DnbkKvbdjblKpgUg +EOcKjvbdwygefYFS +EOcKjvbdliDsqUqa +DnbjjvbdjcMLRGtg +EObkKvbdRbEElJYk +EPCkKvbdqrUkNjaN +EOcLKvbdRotGifDw +DnbkKvbdUsmUGLuj +DoCjjvbdeKJqvUzn +EPDKjvbdQwNdClHc +EOcLKvbdcScLTcjB +DoCjjvbdvBDxroEh +DoDLKvbdIxUBglQp +EPDLKvbdfVzxQJzs +DncLKvbdqlzKYlIJ +DoDKjvbdaNLCSuMg +EOcKjvbdwjwDgzyf +EPDKjvbdIxTaglRQ +DoDKjvbdVTltGLuj +DoCkKvbdiMFENuDZ +EOcLKvbdZyEJnDMS +DnbkKvbdiBoCeXRR +EPCkKvbdbiMijewY +EOcKjvbdmttzLJqf +DncKjvbdYTLaMtOx +EPCjjvbdfIKuqmqH +DoCjjvbdBdQBVjNG +EObkKvbdieLGuPAO +EPDLKvbdsZlQSaIO +DnbkKvbdEztQeMDJ +EPCjjvbdIjEAJpHE +EOcLKvbdfILWRmpg +EPCjjvbdZyDinDLr +DncKjvbdLGGIBaRV +DncLKvbdmozZWLZC +DoCkKvbdlZSrSxft +EOcLKvbdFjdrcINV +EOcKjvbdQvnDblHc +DoCkKvbdqUUHRqkU +EPDKjvbdnBjWwnmu +DoCjjvbdZxcjNbkr +DncKjvbdZisIQHCG +DoCkKvbdJcJcRJbx +EPDLKvbdlhdUQtqa +DnbkKvbdrzLpSaHn +DoDKjvbdziuPpDrt +EPDKjvbdEYXlTtUM +EObkKvbdqdFIpOVa +DncKjvbdpxnhHQdY +DnbkKvbdLhakqYAS +EPCkKvbdrRtkNkBN +EObkKvbdqrVKmjaN +EOcKjvbdxUldqZMO +EOcKjvbdrbFllHKy +DoCkKvbdySmhlrBg +EPCkKvbdkxrqsYgU +EPCkKvbdZLqcsnMN +DncKjvbdFpATXHFy +EPDLKvbdZRMdiMeR +EPDLKvbdRNXbYmtz +DoCkKvbdpyPIGqEY +DoDLKvbdKaKfmCYR +EPDLKvbdrylPsBIO +EObjjvbdUQqOuVHm +EPCkKvbdezvZFItX +EOcKjvbdZirhQHCG +DoDKjvbdePFSjssr +EOcKjvbdCTAcTfXS +EOcKjvbdkxsRsYft +EPDLKvbdQwODcMHc +DoDKjvbdwuNFRZMO +EPCjjvbdEuyPomKF +DoCkKvbdpxnhGpcx +DncKjvbdiVZeWrUb +EOcKjvbdrEEiPmvB +EOcLKvbdZxdJnDLr +EObjjvbdUtNUFkvK +DoDLKvbdZQmFIldq +EObjjvbdnCJvwnmu +EPCkKvbdRWmccLgc +DnbkKvbdnUtykJqf +DnbkKvbdVBBqSpqy +EPCkKvbdZoOIddyj +DnbkKvbdZQldiNFR +DncLKvbdmRyVZsDi +DoCjjvbdcasMrATm +EOcLKvbdtbbtvuno +DoDLKvbdZtJJYdSn +DnbkKvbdGKeTDHlu +DoCkKvbdZjTHpGbG +EOcKjvbdHDjvKCKK +EObjjvbdddnqbXCj +EObkKvbdlZTSTYgU +EPCjjvbdqqtjmkBN +EObjjvbdtAGqIAAr +EObkKvbdrRtjmjaN +DnbjjvbdMRwMytpz +EPCkKvbdsQWPJbuf +DoDKjvbdqFceUWBI +DoCkKvbdnBjWxPNu +DoDLKvbdiUzFXRuC +EObkKvbdQccBPqES +DnbjjvbdOFDtIiLE +EPDKjvbdYlRcsnMN +DncKjvbdFfJrNhsq +DoCkKvbdsCFmMHKy +EPDLKvbdYkrETnMN +DoCjjvbdYNqAXuWU +EPDKjvbdrovPKDWG +DoDLKvbdbKlGOmcA +DoCkKvbdOStWHFVQ +EObjjvbdhbObeXQq +EPCjjvbdeEnrBwDK +DoDLKvbdrbFmMGkZ +DncKjvbdxZhGGYFS +EPDKjvbdbrbkTdKB +EPDKjvbdraellGkZ +EPCkKvbdssSTZZeD +EPDKjvbdDjHiuxKA +DoCjjvbdzoPqFDMY +EPCjjvbdlAlnmALA +DoDKjvbdmtuZjjRf +DoDKjvbdFpASvfey +DoCkKvbdjlakyeGo +DoDKjvbdxnSgxTIc +EPCjjvbdxZhFfXeS +EPCkKvbdqcdiPnVa +EOcLKvbdmfeYMnHZ +DoDLKvbduCbuWvOo +DoDKjvbdmIcsqUqa +EPDKjvbdzoQQdblY +DoDLKvbdRNXayOUz +DnbjjvbdrJAKFNOe +DnbjjvbdZLrEUOMN +EOcKjvbdwygeexEr +EPCkKvbdbVBfwjtI +EObkKvbdKDKDRJbx +DoCkKvbdGckWKBij +EOcKjvbdzjVQPdSt +EPDLKvbdqlzKYkhJ +DnbjjvbdajkennDA +DoDLKvbdRzJgsCvA +EObjjvbdehKuqmqH +DncKjvbdajlFnnDA +DnbjjvbdjEkHUoAO +DoCjjvbdFVyPomKF +DoCkKvbdJcJbpjCx +DnbkKvbdRaceLiZL +EPDKjvbdeEnrBwDK +DoDLKvbdxKvdHzyf +DoCkKvbdSPtHKFcw +EObkKvbdjhHMGGOL +EOcLKvbdGGJqnItR +DoCjjvbdnGdxNNgZ +DoDKjvbdbKkfOmcA +DnbjjvbdelewHNKL +EPCkKvbdcSbjsdJa +EPCkKvbdTAEhgbOd +DncLKvbdUslselVj +DnbjjvbdVrOYBeMD +EObjjvbdEzspeMDJ +EPCjjvbdcTDLTcjB +EPDLKvbdsPvPJbuf +EOcKjvbdqGEFUWBI +EPDKjvbdVgxWYGxz +EOcLKvbdSPtGjGDw +EObkKvbdGckVibJj +DoDLKvbdeEoSCWcK +EPCkKvbdQvmdClID +DncLKvbdhytelROG +EPCkKvbdeXzTtSFz +EPCkKvbdrXQMDIxq +EObkKvbdtlXvaUAw +DnbkKvbdiMFDmtcZ +EPDLKvbdJqZeOfNe +EPDLKvbdmIdUQtrB +DoDKjvbdVTltGLvK +DncLKvbdZRNEhleR +EPDKjvbdjlakydfo +DnbjjvbdFpASvfey +EPCkKvbdkySrTYft +EOcLKvbdVUMtGMVj +EPDLKvbdmRyUysDi +EPCkKvbdGKeScHlu +EObjjvbdczZPwyRC +EPDLKvbdVYhUZkOn +DncLKvbdJbibqKDY +EPDLKvbdfekzNfgA +EObkKvbdKQydoGOF +EObkKvbdVgwvXfxz +DncLKvbdQdDApQcr +DncLKvbdGFjRnJUR +DncKjvbdjgflFemk +DoDKjvbdlhctRVSB +DncLKvbdZLqctOLm +DncKjvbdfSAvzlCo +EPDKjvbdZRMeIleR +EObjjvbdZRMeJMdq +EOcKjvbdMuTSKmAX +DncKjvbdqYngfpdY +DnbkKvbdxrmiMqbH +EObjjvbdbPgGckzd +DoCkKvbdpstGqqkU +DncLKvbdmJDsqVSB +EPDLKvbdtunYKQsA +EObkKvbdDnbkKwCd +EPDLKvbdEXwkstUM +DoDKjvbdrRtkNkBN +DncLKvbdIwtCIMQp +EPDLKvbdZQmEhmEq +DnbkKvbdxmrhYTIc +DoCjjvbdCSaDUGWr +EPCkKvbdatagXkUI +DncLKvbdEPDKkWcE +DncKjvbdZjShPgBf +EPDKjvbdHDkVjCJj +DoCjjvbdsrrTYzEc +EObjjvbdhlEcnUby +DnbjjvbdemFvfmKL +EObkKvbdlhcsqUqa +DoCkKvbdZtIiYdTO +EObkKvbdEXwlTssl +DoDKjvbdhaoCdvqR +EObkKvbdliEURUrB +DoDLKvbdEYXkstTl +DncKjvbdFkEsDINV +DoDKjvbdFkErcHmV +DoDLKvbdKCjCpjDY +EPCjjvbdjJegjMxS +DnbkKvbdnCKWwnmu +DnbjjvbdqwQLbiYq +DoDLKvbdSZigsDWA +EObjjvbduVnYKRTA +EOcKjvbdTlWOaVoJ +DnbjjvbdSCDeMJYk +DnbkKvbdQvmdClID +EPCkKvbdziuQPdTU +EOcLKvbdhficZWJu +EOcKjvbdZLqdTmkm +DoDKjvbdcImKKevx +EOcLKvbdGFirOJUR +EObkKvbdREDApRES +DoDKjvbdHELWKBij +EOcKjvbdrSVLNkBN +EOcKjvbdBdQBWJlf +DoCjjvbdFpATXHGZ +DnbjjvbdqZOhGpdY +EPDLKvbdCSaDUGWr +DoDLKvbdrpWPJcWG +DnbjjvbdZsiJYdTO +EPDKjvbdJvVGEFGi +EPCkKvbdmIctRVSB +DncKjvbdBiLCKhfK +DoCkKvbdZisIQGbG +DoCjjvbduWNwjQsA +EOcLKvbdiHKCyVjV +EPCjjvbdlZSrTZGt +EObjjvbdNPxRWNgT +DncKjvbdeAURNXif +DncLKvbdOStWGeVQ +DoCjjvbdJvUeceGi +DoDKjvbdXsMBMsnx +EPDKjvbdGLFSbhMu +EPDLKvbdEvZPolie +EOcKjvbdrRtjnLBN +EPDKjvbdyOTHxTJD +EPDKjvbdmajWwnmu +EPCjjvbdrNZjZLhJ +DncKjvbdajlFoODA +DoDKjvbdrEFIpOVa +DnbkKvbdpedEtWBI +DncKjvbdqwQMChyR +DnbjjvbdnCKWwnnV +DoCjjvbdNUsRkNAX +EOcLKvbdULvPBWPJ +DncLKvbdjlalZdfo +EPDKjvbdjJfHjNYS +DoDKjvbdPxmAHTSK +DnbkKvbdmIctQtqa +EObjjvbdnHFXmNfy +EPCkKvbdqlzJyLhJ +DnbjjvbdVqnYCElD +EPDKjvbdqTsgRqkU +EPCjjvbdADSYKZhp +EPDLKvbdEvZPoljF +DoCkKvbdLFfICBRV +EOcLKvbdZRNFJNFR +EPDKjvbdpedFUWBI +EPDKjvbdVwJYVceH +DoCjjvbdGYtuBDwb +DoCjjvbdVYgtZjoO +DncKjvbdQccApQcr +EOcLKvbdWWiYWDdg +DncKjvbdyTOJNSBg +DnbjjvbdbAueFpQX +DnbkKvbdiUydwSUb +DoDKjvbdKVtfDeHJ +DoDKjvbdEObjkXCd +EOcKjvbdqlyjYlHi +EOcKjvbdfRaWzlCo +EObjjvbdRWmcblID +DoDLKvbdCDpAvKMf +DncLKvbdmuVZjjSG +EPDLKvbdkaMnmALA +EPCkKvbdcSbkTdKB +DnbjjvbdZtJIyESn +EPCkKvbdQvmccMHc +DncLKvbdfHjvRmpg +DoCjjvbdVvhwvEEg +EPCjjvbdXrkaNTnx +DnbkKvbdGFirNiUR +EObkKvbdZLrDsnLm +EObkKvbdySnJNRbH +DncKjvbdaMkBsUmH +EPCkKvbdqGEFUWBI +EObjjvbdmajXYOnV +DnbkKvbdHELWKBjK +EPDKjvbdWSOYCFLc +DncLKvbdehKurNqH +EPDLKvbdSZjIScWA +DncKjvbdZQldiNEq +DncLKvbdVwIwvEEg +DnbjjvbdauCGxKsh +DnbkKvbdKefHbApu +DoCkKvbdssSTYyeD +DnbjjvbdSPsgJfEX +DoCkKvbdeKKRvUzn +DoDLKvbdiMEcnVCy +DoDLKvbdoAKzsgcn +DoDKjvbdDoDKjvbd +DncKjvbdFWYopMie +EPDLKvbdRNXaxmtz +EOcLKvbdKefHaaRV +EPDKjvbderAvzkbo +EObjjvbdzoQREcMY +DnbkKvbdijFgjMwr +EObjjvbdhbObdvqR +EPCkKvbdySmiMqbH +EObkKvbdyzeOSIIh +DnbkKvbdjcLkRHUg +DoDLKvbdJpydoGNe +DoDKjvbdwXMBWBWV +EObkKvbdsBfMkgKy +DnbkKvbdYkqdTnMN +EPCjjvbdEPDLLWbd +EObkKvbdDwxLtUUM +DncKjvbdNrtVgFUp +EPDKjvbdZQleJNFR +EPDKjvbdJKEAKPfd +DnbjjvbdhgKCxvJu +EObkKvbdLAkHMbXq +EPDKjvbdhancEvqR +DoCjjvbdNsUWHEuQ +DnbkKvbdZjTHofaf +EPCjjvbdrDdiQOVa +EPDKjvbdkMbLzEgP +EPCkKvbdZoOJFEyj +EPCkKvbdADRxJyhp +EObjjvbdaSGCgsfL +DnbjjvbdJbjDQibx +EPCjjvbdpfEEtWBI +EOcLKvbdZxdJmblS +EPCkKvbdRpTgKGEX +DoCjjvbdzRPNIiwA +EObkKvbdzoPpeClY +EObjjvbdeFOrBwDK +DoCkKvbdOTTvHEtp +DnbjjvbdGQATWgFy +EPCjjvbdEvZQQNJe +EObkKvbdjvWnECYX +DoDLKvbdyTOIlqag +DnbkKvbdEASJNZvw +EOcKjvbdsZkosBHn +DoDLKvbdtSqsYyeD +DncKjvbdqlyixkgi +EPCjjvbdTppnuVHm +DncKjvbdatbHYKsh +DoCkKvbduVmwjQsA +EPCkKvbdvAcxsOeI +EObkKvbdRjyFuHLT +EObjjvbdTukoitAq +EOcLKvbdkySqrxft +EObjjvbdQccBPpdS +DoDKjvbdffLzNfgA +DoDKjvbdiCOcEvqR +DncKjvbdIBkzEzAD +EObjjvbdVZHsyjoO +EOcLKvbdZoNheEzK +DnbkKvbdsZkpTAhO +DnbjjvbdqFdEtVaI +DnbkKvbdIGfzZXwg +EPDLKvbdlrZVZsEJ +EObjjvbdBcpAvJmG +DnbjjvbdtSqsYzFD +EPDLKvbdJJdAJogE +DncKjvbdxVMdpyMO +EPCjjvbdQwOEDLhD +DoCjjvbdmgFXmNgZ +DoDLKvbdjEkGuPAO +EPCjjvbdACrXjZiQ +DoCjjvbdZMRdTmlN +DncLKvbdiLeDnVDZ +EObjjvbdVAaprpqy +DoDLKvbdRjyFuGjs +DnbjjvbdVAbQrprZ +EObkKvbdSZjHrcWA +EPDKjvbdVrOYBeMD +EPDLKvbdDwxMUTsl +EPDKjvbdRadElIxk +DnbjjvbdmozZWKyC +DoDLKvbdptTgRrKt +EPCjjvbdatagXkUI +DncLKvbdZLqcsnMN +DoDLKvbdfNFwGmJk +EObkKvbdqTsfrSKt +DncLKvbdZjTHpGbG +DoCjjvbduWNwipsA +EPDKjvbdauCGwkTh +DncLKvbdKVuGEFGi +EObjjvbdZirhPfaf +DoDKjvbdxKvcgzyf +DnbkKvbdxsNhlrCH +DoCkKvbdBsBDUGWr +DncKjvbdfMfXHNJk +DnbjjvbdOSsugFVQ +DncKjvbdZisIPfaf +DnbjjvbdZHXEAOsJ +DnbjjvbdLZRJrzuG +EObkKvbdwuNFQxlO +DncKjvbddxZtURez +EPCkKvbdxrmiNSCH +DoDKjvbdiUydwSVC +EObjjvbdiifIJlwr +DncLKvbdssSSxyeD +EPDKjvbdOEcsiJLE +EOcKjvbdySnIlrBg +EPCkKvbddZyQYZRC +DnbjjvbdWXJXudEg +DoDLKvbdKaLHNCXq +DoDKjvbdGGKRmiTq +DnbkKvbdlrYtyrdJ +EPDKjvbdhtzEvrVC +EObkKvbddZyQYYqC +DoDLKvbdhaoCdwRR +EPCkKvbdxLWdHzyf +DoDKjvbdySmhmRbH +DnbkKvbdZLqcsmlN +EObjjvbdZtJIxdTO +DoDKjvbdDwwksssl +EPDKjvbdFyVVAdXb +DoCkKvbdUtNUFkvK +EPDLKvbdxmsIXsIc +EPDLKvbdUsmUFkuj +EOcKjvbdGKdsDHlu +EOcKjvbdACqwjZiQ +EPDKjvbdFpASwHGZ +DoCkKvbdGZUtaDxC +DncKjvbdmSZVZsEJ +DoCjjvbdJbicRKCx +DncLKvbdTvMQJsaR +DoCjjvbdNeDtJJKd +EPCjjvbdnPzYvKxb +DoDLKvbdyTNhlrCH +EPDKjvbdRosgJecw +EObkKvbdTAEiICOd +EOcKjvbdapHHDkzd +DoCkKvbdjlakzFGo +DncLKvbdrpWPJbuf +DnbjjvbdNQXqVnHT +EOcLKvbdkNCLzFHP +EObjjvbdTukpKTaR +EOcLKvbdEuxpPlie +EPCkKvbdJuuFdFHJ +EPDKjvbdGGJqmiTq +DnbjjvbdOAIrtJrA +DnbjjvbdelfWgNKL +EObkKvbdhbOcEwRR +DncLKvbdqiAKFNPF +DncKjvbdVqnYCFMD +DoDLKvbdWHxWXgYz +EOcLKvbdNVTSKmAX +EPDKjvbduaDySndh +DnbkKvbdiifIJlxS +EPDKjvbdeATpmYJf +DncLKvbduCcVWuoP +EPCjjvbdhficYvJu +DncKjvbdehLVqnQg +EPCkKvbdrDeJPmua +DoCjjvbdTfzmlWue +DncKjvbdZoNiFEyj +DoDLKvbdxmsHxSiD +EObkKvbdVwJYVdFH +EPCjjvbduMXwBUBX +DnbkKvbdTqROuVIN +EPCjjvbdGKeTCglu +EPDLKvbdcyyPwxpb +EPDLKvbdQmXayOUz +EPDLKvbdZyDinCkr +EPDLKvbdZoNheEyj +DncLKvbdmfdxMnGy +DnbkKvbdkClLRGuH +DncLKvbdJXsbIMQp +DnbjjvbdjJegilxS +DoCkKvbdnPyxukZC +EPDKjvbdZMRcsnLm +DoCkKvbdHffzYxYH +DnbkKvbdbsDLTcjB +DoDLKvbdSwjlNzjx +DncKjvbdkaMnmALA +DncLKvbdqmZjZLhJ +DoDKjvbdqrUkNkBN +DncLKvbdmfeXmOGy +EPCjjvbdZMRdTmlN +DnbkKvbdypnlhjXA +EPDLKvbdyOTHxTJD +EObjjvbdMRwMzVQz +EPCjjvbdSCDeMIxk +EObjjvbdOXnuzdOU +EPDKjvbdOStWHFVQ +DoDLKvbdrzLpTAgn +DnbkKvbdULuoAvPJ +EPDKjvbdZxdKODMS +EOcKjvbdbAvEfPpX +DncKjvbdyOSgwriD +EPDLKvbdrJAJdmPF +EPDLKvbdauCGxKtI +DncLKvbdqrVLOLAm +EPDKjvbdkHgLfFmk +DncKjvbdUaCRSqSZ +DnbkKvbdbQGgELzd +EOcKjvbdcJMijfXY +EPCkKvbdeOeTLUTr +EOcKjvbdQmYByNtz +EPDLKvbdFxuVBDwb +EOcKjvbdGGJrNiUR +DoDKjvbddndsLTtS +EOcLKvbddZyPxYqC +EPCkKvbdSKxfVHLT +EOcKjvbdSCDdkiYk +DnbjjvbdtvNwjQsA +EOcKjvbdJXsbILqQ +EObjjvbdjcLkRHVH +EObjjvbdkCkkQgUg +DoCjjvbdTqQnttgm +EPCkKvbdEuyPoljF +DoCkKvbdTqQnuUgm +DoDLKvbdLrWlzVQz +EPCjjvbdRjyGVGkT +DoDLKvbdHEKvKBjK +DoCjjvbdnCJvxOnV +EObkKvbdptUGrRkU +EPDKjvbdQwNcblID +DoCjjvbdIidAKPgE +DoCjjvbdTYLMNzkY +DnbjjvbdEztRFMCi +EObkKvbdBhkCLJGK +EPDLKvbdZisHpGbG +EPDLKvbddePRbXDK +EObkKvbdUQpntuIN +EObjjvbdEPCjjvcE +DncKjvbdbiNJjewY +EPDLKvbdVrOYCElD +EPCkKvbdSBdElIyL +DoDLKvbdzjVQQETU +DoCjjvbdCDpAvKNG +EObkKvbdNHComPuL +EOcKjvbdGdKvJaij +DnbkKvbdqmZjYkgi +DncKjvbdQvnEClID +DncLKvbdWWiXudFH +DoDLKvbdCEQBWJlf +DncKjvbdMpXqWOGs +EPDKjvbdVBCRSqRy +EPDLKvbdqUTgSRjt +EOcLKvbdJXtCHkqQ +EObkKvbdBiLBkJFj +EOcLKvbdVvhwvEEg +EOcKjvbdCTBCsewS +EOcKjvbdyNsHwriD +DoDKjvbdwzHfFxEr +DnbjjvbdypoMiJwA +DoCjjvbdJbicQjCx +EOcLKvbdVUMsekuj +EOcKjvbdCEQBWJlf +EObjjvbdIjEAKQGd +DoCjjvbdDjIJvXjA +DoDLKvbdFyUuAdYC +DncLKvbdRotGiedX +DoCjjvbdBhkBjhej +EOcKjvbdBhkCKhfK +EPCkKvbdLFfHbBRV +DoCkKvbdNUrrLNAX +EOcKjvbdZoOIeEzK +EPCjjvbdkMbMZeHP +DoCjjvbdkVwNdBxX +EPCkKvbdNddThiKd +DnbjjvbdjcLkQftg +DnbkKvbdFkErcHmV +DnbjjvbdqGEEtWAh +DncKjvbdmSYuZsEJ +DoCjjvbdUsmTfMWK +DoCkKvbdVUMtFkvK +EOcKjvbdKfGICBRV +DnbkKvbdMSWlzUpz +EOcLKvbdVBBprpqy +EPCjjvbdnHEwmNgZ +DoCkKvbdeEoRawDK +DnbkKvbdpssgSSLU +DncKjvbdOSsugFUp +DnbkKvbdwzHfGYFS +DoCjjvbdTAEiHbPE +EObkKvbdKaLGmCXq +DnbkKvbdCWzciFQW +DncLKvbdnVVZjiqf +EPCjjvbdOStWHEtp +DoDKjvbdkIGkfFmk +DoDKjvbdZjTIPfbG +EOcKjvbdXsMAlsnx +DnbjjvbdILazmwRL +EOcKjvbdrDdiPmvB +EPDKjvbdiUzEwRuC +EOcKjvbdqAheAXHd +EPCjjvbdRyigsCvA +DoCjjvbdpyOggQcx +EPCkKvbdZyDjNblS +DncLKvbdFejSNiTq +EPDKjvbdzRPNIjXA +DncLKvbdaMkBsVMg +EObkKvbdLYqJrzuG +DncKjvbdsBfNMHLZ +EPDKjvbdjgflFfOL +DoDKjvbdCTAcUGWr +DnbjjvbdSLZGVGkT +DoCkKvbdZQmEhldq +EPDKjvbdUsmTfMWK +DoCjjvbdKefICBRV +EPCjjvbdZMSDsnMN +EObkKvbdwzIGGXdr +EObjjvbdrRtjnLAm +EPDKjvbdXrlAmTnx +EPCjjvbdZtJJZETO +DnbjjvbdieLGtoAO +DnbkKvbdnCJvxPOV +EPDKjvbdjKFgjNYS +DoCkKvbdlhcspuRa +EPDKjvbdbAvEfQPw +EOcLKvbdiGjDYuiu +DncKjvbdnQZxvLZC +DoDLKvbdaogHDkzd +DnbjjvbdMfcQMouL +DncKjvbdKaKgMbYR +DncKjvbdrbGNMHKy +DoCkKvbddoFSjtUS +EPDLKvbdNddTiIjd +EPDKjvbdhgKDZViu +EPDLKvbdkMbLzEfo +DoDKjvbdjmCMZdfo +DoDKjvbdSCDeLhyL +DoCkKvbdQwODcMID +DnbkKvbdgGLymgHA +EPDKjvbdWIYVwfxz +DnbkKvbdZLqdUNkm +DoCkKvbdYlSETmkm +DnbkKvbdLqvlyuQz +DnbkKvbdZRMdiMdq +EOcLKvbddePSCXCj +EPDLKvbdRacdkiYk +DnbjjvbdZisIQGbG +EObjjvbdrpVnibvG +DncLKvbdIxUCHlRQ +EPCkKvbdhuZeXRtb +DnbjjvbdQwODblID +DoDKjvbdezuyEhsw +DncKjvbdiLddNtcZ +EPCkKvbdiLeENtby +DnbjjvbdxKvcgzzG +EPDLKvbdRXNdClID +DncLKvbdEKHjVwjA +EOcLKvbdzoPqFCkx +DoDLKvbdliEURUqa +DoCjjvbdyOTIYTJD +DncLKvbdIHGyyXwg +EPCjjvbdShyjRABM +DoCkKvbdnPyyWLYb +EObjjvbdsPvPJcVf +EPDKjvbdTXjlNzjx +DoDKjvbddneTLUUS +EOcKjvbdmuUyjiqf +DncKjvbdZoOIddzK +DoCjjvbdpyOhGqEY +DoCkKvbdwjwDgzyf +DnbkKvbdxZgeexEr +EOcLKvbdHDjvKCKK +DoCkKvbdpxnhHQdY +DoDLKvbdLrWlzUpz +EPDKjvbdatbHXkTh +DoDLKvbdZyDinDLr +EPCjjvbdGGJqnJTq +DoDKjvbddneTLTsr +DncLKvbdyzdmqhJI +EObkKvbdRjxfVGkT +EPDKjvbdOAJTTirA +EPCjjvbdZoNiFEzK +DnbjjvbdOhAXyAYa +DnbjjvbdACqwizIp +DoDLKvbdcImJjevx +EPDLKvbdxmrhYTIc +DoDLKvbdjcLkRGuH +EPCkKvbdxVNEpxlO +EPCkKvbdKCibqJbx +DoCkKvbdjJfIKMxS +DoDLKvbdVYhUZjoO +EPDLKvbdrJAKEmPF +EOcLKvbdRDbaQRDr +DoCkKvbduWOXiqTA +DoCjjvbdZyDjNcLr +EObjjvbdbBWEeoow +EPDLKvbdUQpnttgm +EOcKjvbdlBNOmALA +DnbjjvbdSPsfiecw +DnbjjvbdwzIGGYFS +EOcKjvbdLGFgaaRV +EOcKjvbdrXQLcJYq +DnbkKvbdmbKXYPOV +DoCkKvbdZisHogCG +EPCkKvbdFVyPpMjF +EOcKjvbdYkrDsmkm +DoDKjvbdxUmEqYlO +EPDKjvbdKNAEZgUa +DoDLKvbdqZPIGpcx +DoCjjvbdMgComPtk +EObjjvbdUyHszKoO +DoCkKvbdeEnqavcK +EPDKjvbdqYoIGqEY +DoDLKvbdCDoaWJmG +EPDLKvbdlZSrTZHU +EPCkKvbdZxcinDMS +DoCkKvbdgFkzNfgA +EOcKjvbdYNqAXtvU +EObjjvbdwygefYEr +EPCkKvbdbBVdfQQX +DnbkKvbdqrVLOLAm +EOcKjvbdFjeTDINV +DnbjjvbdnHFYMnGy +EPCjjvbdrbFllHKy +EPCjjvbdZLrDtOMN +EPDLKvbdcJNKKfWx +DoCjjvbdraemMHLZ +DoDKjvbdeJjSWUzn +EPCkKvbdZnmiEdyj +DnbjjvbdwtleQxlO +DnbkKvbdDwwlUTtM +DoDKjvbdrWpMDJZR +EOcKjvbdegkVrORH +EPCkKvbdiCOcFWqR +DnbkKvbdBsBDTevr +DoCjjvbdjcLjpfuH +DnbjjvbdZxdKODLr +DoCjjvbdqceIpOVa +DoDLKvbdVvhxVceH +EObkKvbdsrqryZdc +DnbkKvbdMSWlytpz +DoDLKvbdqTsfqrKt +EPCjjvbdjKGIKNYS +EOcLKvbdiGibxvKV +EPCjjvbdKDKCpibx +EPDKjvbdQdDBPqDr +DncKjvbdozmdLYPA +DoCkKvbdTvLojUAq +DnbkKvbdbhmKLFwY +EPDKjvbdCIjbLIej +DncKjvbdkHfkeenL +DoDKjvbdtAGqIABS +EPCjjvbdRosfjFdX +EOcKjvbdraemLgLZ +DnbkKvbdxmrgxTIc +DoCkKvbdOAJStJrA +EPCjjvbdqYngfpdY +EPDLKvbdBvzdJEov +DoDKjvbdrDeIpOWB +EObjjvbdqUTfrSKt +EOcKjvbdxnShXsIc +DoDKjvbdEzsqFLcJ +EObjjvbdDxYMUUUM +EOcKjvbdjKFhKNYS +EOcKjvbdjgflGFmk +DoCkKvbdGGKRnItR +EPCkKvbdREDApRDr +EOcLKvbdNQYRWOHT +EPCjjvbdxmrgwriD +DncLKvbdbsCjsdJa +EOcKjvbdypoNIiwA +DncKjvbdZoOJFEyj +DoCjjvbdrbGMkgKy +EPDKjvbdyTNiNSBg +DoCjjvbdczZPwyQb +DoDKjvbdWfZZtAOs +EPDKjvbdznoqFClY +DncKjvbdTlVoBVoJ +EPCkKvbdIxUBhMRQ +DoCkKvbdZQmEiNEq +DoDKjvbdnVUykKRf +DnbjjvbdUtMtFlWK +EObjjvbdOTUVfeUp +DoCjjvbdZMSEUOMN +DoCjjvbdwjwDgzzG +DoDKjvbdYqNEiNFR +DoDLKvbdqiAKEmOe +EPDLKvbdfNGXHNJk +DnbjjvbdCEQBVjMf +EObkKvbdqUUGrRjt +DnbkKvbdjmCLyeHP +DnbjjvbdcJMikFwY +EPCjjvbdjuwNdBxX +DoCkKvbdeqaWzkbo +DncKjvbdTkvOaVoJ +DoDKjvbdZoOIeEzK +DoDLKvbdKDKDRKDY +DncLKvbdqwQMDJYq +EObkKvbdKeegbBRV +EPDKjvbdegjuqnRH +DoDKjvbdxwhjBpZk +EObjjvbdziuQPdSt +EPCjjvbdZyEKOCkr +EPCjjvbdRWmdCkhD +EOcLKvbdQcbaQRES +DncLKvbdIrxaTNYM +DnbjjvbdGFiqmiTq +DoCjjvbdZeXfzghb +DoCjjvbdSLZFuGkT +EPDKjvbdIryBSmYM +EOcLKvbdRyjHsCvA +EPDKjvbdzoPqFCkx +EPDLKvbdFeirOIsq +EObkKvbdLiBkpxAS +DoCjjvbdmuUyjirG +EOcKjvbdpfDeTuaI +DncLKvbdtSqsYyeD +EOcLKvbdAMhYrwZx +EOcKjvbdJSyAsNYM +DncLKvbddneTLTsr +EPDLKvbdANIYsWyx +EObkKvbdRXODblHc +DoCkKvbdYzcGRjWZ +DoDLKvbdkHgLfFnL +DoCkKvbdpyPIGqDx +EObkKvbdwuNEpxkn +DoDLKvbdJSxaTNYM +DoDLKvbdRNXbZOUz +DnbjjvbdNHDPlpUk +EObjjvbdKQzFPFnF +EOcKjvbdwkWdHzzG +EObkKvbdiCPCdvpq +EPCkKvbdwzHfFwdr +DoDLKvbdwuMeQxkn +DoDLKvbdmoyxujyC +DncLKvbdyYJKBoyk +EOcKjvbdhgJbxujV +EOcKjvbdvAcySndh +EPCjjvbdOYPVzcmt +DncKjvbderBWzlCo +DncLKvbdEuxoolie +DoDLKvbdUsmTelVj +DoCkKvbdcImKKfXY +EPCkKvbdKDJcRJcY +DoDLKvbdfILWSOQg +DoDLKvbdtcDVWuno +DoDKjvbdegjvSNpg +DncKjvbdjvXOEBxX +DncKjvbdvOszpjoU +EOcLKvbdkIGkfFnL +EPDKjvbdZxcinCkr +EOcKjvbdNxPVzcnU +DnbkKvbdNrsvHEtp +DnbjjvbdwygefXeS +EObkKvbdnHEwmOGy +EObkKvbdZRNFIleR +DoCjjvbdNHColotk +EPDKjvbdTkuoBVni +EObkKvbdkHgLfGNk +DoCkKvbdVvhxWEEg +EOcLKvbdtbcVWvOo +DoDKjvbdULvOaWOi +EObkKvbdNdcsiJLE +DoDLKvbdOYPVzdNt +DoCkKvbdNeDsiJLE +EOcLKvbdXGYytAOs +EOcKjvbdcIljLGWx +DoDKjvbdIMBzmwQk +EPDKjvbdbrcKscjB +DoCjjvbdqdEhpOWB +DnbjjvbdzoPqFClY +DnbjjvbdKDKCqJcY +EPDLKvbdZRNEhldq +DncLKvbddZyQXyRC +DncLKvbdRzKHrcWA +EObkKvbdTAFIgbPE +EObjjvbdwtmFRYkn +DoDLKvbdCTAbtFwS +EObjjvbdJzpFwdAN +DoCjjvbdCTAbsevr +EObjjvbdyzdmrIIh +DnbkKvbdANIZTXZx +EPCkKvbdVwJXvDeH +DncKjvbdmfdwlnHZ +DoCjjvbdZirhPfaf +EPCkKvbdiHJcYvJu +DnbjjvbdRMxCYmtz +EPDLKvbdZHWdAPSi +DnbjjvbdWSNxBdkc +DoDKjvbdNxPVzdNt +EObjjvbddePRawDK +DncKjvbdaSGCgtGL +DncKjvbddoFSjstS +DnbjjvbdOFETiJLE +DoDLKvbdeAUQmYJf +EObjjvbdZshiZESn +EPCjjvbdVwIwvEFH +DnbkKvbdKDKDQjDY +EPDLKvbdRbEFMJZL +DoDKjvbdiZuGLpnG +DoCjjvbdqGEEtWAh +DnbjjvbdnBiwYPNu +DnbjjvbdtlXwBTaX +DoCjjvbdqYoHfqEY +EPCkKvbdIsZArmXl +DoDLKvbdmfeYNNgZ +DoCkKvbdrafNLgKy +DnbkKvbdYfwEAOsJ +DoDLKvbdrEFIonWB +EPCjjvbdRXODcMID +EPCjjvbdZisIPfbG +DncKjvbdoAKzshEO +EOcLKvbdNQXqVmfs +DnbkKvbddoEsKssr +EPDKjvbdNeETiJLE +EPCkKvbdVgwvXfxz +EOcKjvbdIsZBTNXl +EObkKvbdFeirOJUR +EPCjjvbdVAbRSpqy +DnbjjvbdeXyssqez +EPDLKvbdZGwEAOri +DoCkKvbdVAaqSqRy +DoDLKvbdiVZeWrVC +EPDKjvbdGYuUaDwb +DncLKvbdLrXMyuQz +EPDKjvbdGZUtaEXb +EOcLKvbdzoQRFDLx +EPCkKvbdTAFJICOd +EPDKjvbdNPxRVmfs +DoCjjvbdauBfxKsh +DncLKvbdMIbLpxAS +DoCkKvbdmgEwmNfy +DoDLKvbdhanbdvqR +DoCkKvbdSLYfUfjs +DoCjjvbdTvMQJsaR +DnbkKvbdlhcspuRa +DnbjjvbdJSyBSlxM +EPCjjvbdSLZFuHLT +DoCkKvbdYTLaNUPY +EObjjvbdFeiqnJUR +EPDKjvbdYlRctNkm +EOcKjvbdHDjvJaij +DnbkKvbdnCJvwnnV +DoCjjvbdNHDPlouL +DncLKvbdWXIxWDdg +DoCkKvbdJSyAsMwl +EObkKvbdxmrhXriD +DnbkKvbdJzpGYEAN +EOcLKvbdddnqawDK +EOcLKvbdhyuFkpnG +DnbkKvbdtAHQhABS +DoCjjvbdjhGlFemk +DncLKvbdjJehJmXr +EPDLKvbdHffyyXwg +DoCkKvbdRbEFLiZL +DoCjjvbddePSBwCj +EPDKjvbdeOeTKtUS +DnbjjvbdrDeIomvB +DnbjjvbdVZIUZjoO +EPDKjvbdxmsIYTIc +EPCjjvbdDnbkLXDE +DnbkKvbdYlSDtNlN +EObkKvbdeFPSBvbj +EPCkKvbdkDMKpgUg +DoCkKvbdbKlGPODA +EObjjvbdGdLVjCKK +EPCkKvbdkCkjqGuH +EOcLKvbdqYngfpcx +EPDLKvbdeKJqvUzn +DoCkKvbdkIHMGGOL +DncKjvbdDoDKkXDE +EPCkKvbdsCGNMHLZ +EOcKjvbdyzeNqhJI +DnbjjvbdqwQLbhxq +EObjjvbdaaWEepPw +EObjjvbdDxXktUTl +DnbjjvbddwzTtRez +DnbjjvbdKQyeOfNe +EPDKjvbdbBVdepPw +DncLKvbdfSAvzkbo +DoDKjvbdqYoIHQcx +DoCkKvbdeEnrBwCj +DncKjvbdehLVqnRH +EPDLKvbdhfjDYuiu +EPCkKvbdvmWANEEm +EPCkKvbdZRNEiNFR +EOcLKvbdCSaCtGXS +DoDKjvbdbhljKevx +DoDKjvbdbBVdepQX +DncLKvbdqTsfrSKt +EPDKjvbdjEjgVPAO +DoCjjvbdFeiqmiTq +EObjjvbdcImJkGXY +EObjjvbdJbjCqJcY +DnbkKvbdjcLjpftg +EPDLKvbdWXJYWEEg +DoDKjvbdznpREbkx +EObjjvbdfILVqmqH +DnbkKvbdxwiKCQZk +EPDLKvbdOEdUJIjd +DnbkKvbdsCFmLgKy +DncKjvbdijFhKMxS +EPCjjvbdzitpQDrt +EPCkKvbdZQleImEq +DoDKjvbdZxdKNcLr +DncKjvbdGdLVjCKK +EOcKjvbdhzUfLpnG +DncLKvbdwzHfGYEr +EObjjvbdEObjjvcE +EOcLKvbdfHkVqmpg +DnbjjvbdXnRAXuVt +EOcLKvbdeFOrBwDK +EPCjjvbdzitoocsU +EPDKjvbdZxdJmblS +EObjjvbdFjeScHlu +DoDKjvbdjhGkfFmk +EOcLKvbduDDVXWPP +EPDLKvbdJYUCHkpp +EPCkKvbdkClKpgVH +EObkKvbdJcKCqJbx +DncKjvbdEXwlUTsl +EObkKvbdxwiJbPzL +DncLKvbdHDjujCKK +DnbkKvbdEuyQQMie +EPCkKvbdUaBpsRSZ +EPCkKvbddoFTKstS +EPCjjvbduaEYsOeI +DoDLKvbdcTDKscjB +DncLKvbdNdcshiKd +DnbjjvbdWSOYCEkc +EOcKjvbdZnmiEdzK +EPDKjvbdUQpnttgm +DoCjjvbdnGdwmOGy +DoCkKvbdZyDjNblS +EOcKjvbdShyjRAAl +DncKjvbdTkvOaWPJ +DoDKjvbdOEcsiJKd +DncKjvbdbVBfxKtI +EPCkKvbdrafNLfjy +DoDKjvbduaEZTOeI +DncLKvbdGGKSNhtR +EPCjjvbdnBjWxOmu +EObkKvbdKefICBRV +DncKjvbdZoNheFZj +DnbkKvbdEOcKkWbd +EPDKjvbdNGcPmQUk +EObkKvbdaMjbStlg +DnbkKvbdJYTbIMRQ +DncLKvbdJXsahLpp +DncKjvbddeOrBvbj +DoDLKvbdJSyAsMwl +EPCkKvbdZdwfzhJC +DoCjjvbduDDVWuno +DnbjjvbdEztQdkbi +EOcLKvbdUyHsykOn +EObjjvbdDjHivYKA +DoDLKvbdnUtzLKSG +DncLKvbdSLZFuGkT +DoDKjvbdlYrrTZGt +EOcLKvbdqUUGqrKt +EPDLKvbdEPCjjvcE +EPDKjvbddxZtTrFz +EObkKvbdlYrqrxgU +DoCjjvbdauCGwjtI +DnbjjvbdQZNAHTRj +DoDKjvbdMoxRVmfs +DncLKvbdOTTvGeUp +DncKjvbdcJNKKewY +DoDKjvbdmuVZjjSG +EPDKjvbdUWLpKUAq +EOcLKvbdSLZGVGjs +EObjjvbdCIjakJGK +EPDLKvbdZnmhddyj +EOcKjvbdLBKgMaxR +EOcLKvbdDjHjVwjA +DnbkKvbdYlRcsnLm +DoCjjvbdrRuKnKaN +EPCkKvbdptUHSSLU +DncLKvbdYpmEiNFR +EObkKvbdMIalQxAS +DnbjjvbdJuteceHJ +DncLKvbdFWYpPlie +EPCkKvbdmgFYMmgZ +DoCjjvbdmbJvxOnV +DncKjvbdIGfzZYXg +EPDLKvbdqTtGqrLU +EPCjjvbdWRmwbElD +EPDLKvbdGLErcIMu +EPDLKvbdwygefYEr +EPDKjvbdrSUkOLBN +DoCkKvbdNQYQumfs +DoCkKvbdRjyGVGjs +EPDKjvbdmajXXoOV +DncKjvbdIGgZxwwg +DnbkKvbdxwiJapZk +DoDKjvbdYqMdhleR +EOcLKvbdZtJIxdSn +EPDLKvbdTIzKRABM +EPDKjvbdCEPaWJlf +EOcLKvbdjgflFfOL +EPCjjvbdZjShQGbG +DoDLKvbdHDjvJbKK +EOcLKvbdBiKbLIfK +DncLKvbdiHJbxujV +EObkKvbdKeehBaQu +EPDLKvbdYSlBMsnx +EObkKvbdmJDsptrB +DoDKjvbdTkuoAvPJ +EPDKjvbdZyEJnDLr +EPCkKvbdZoNhddyj +EPDKjvbdVZHsykOn +DnbkKvbdjJegjNYS +DoDLKvbdtcCtwVno +EOcKjvbdkIHLefOL +EOcKjvbdYkqdTnLm +DnbkKvbdiZuGMQmf +DoCjjvbdZLrDsnLm +DoCjjvbdDwwktTsl +EObjjvbdRzKHrbvA +DoDKjvbdQlwaxnUz +EObkKvbdyTOImRag +EPCjjvbdQmYByOUz +EObjjvbdbrbkUDjB +DoDLKvbdGYtuAcwb +DncLKvbdePFSjssr +DoDKjvbdRbDdlIxk +DoDKjvbdwzIGGXeS +EPCjjvbdOTUVgEuQ +EPCkKvbdemGWfmJk +EOcLKvbdZQmEhmEq +DoCjjvbdZRMeJNFR +DoCjjvbdvBEZSoEh +DncLKvbdhlFDnVDZ +DoCjjvbdJJdAKPfd +EObjjvbdyYJKCQZk +EObjjvbdRzKITCvA +EPCjjvbdUMVnaWPJ +DoCjjvbdNddThhjd +EOcKjvbdNPwpvOHT +DnbjjvbdZisHpHCG +EObkKvbdGLFScINV +EOcLKvbdbsDLTdJa +EObjjvbdbhlijfWx +DoDLKvbdVZHszLPO +EObjjvbdZnnJFEyj +DoDKjvbdeOeSkTtS +DoDLKvbdkCkjpgUg +EPCjjvbdFejRnJUR +DoCjjvbdZsiIyDrn +DoDLKvbdtunYJqTA +DnbkKvbdoznELXoA +DoCjjvbdZtIiYcsO +EOcLKvbdGGKSOJUR +DoCjjvbdUMWPAuni +DnbkKvbdEPDKkWbd +EPCkKvbdUxhTzLPO +DoDKjvbdGdKvKBij +DncKjvbdmSZUzSci +EPCjjvbdZjShQGaf +DncLKvbdWRmxCElD +EPDLKvbdqvpMDIyR +DncKjvbdCJKakIfK +EPDKjvbdHELWJbKK +DoDKjvbdjlbLzFGo +EPCjjvbdTkvPBWOi +DoCkKvbdJvVGEFGi +EOcLKvbdUyHszLPO +EObjjvbdVBBpsQqy +DnbkKvbdZdxGzhIb +DnbjjvbdsPvOicVf +DoDKjvbdtcCtwWPP +EOcLKvbdwtmFRYkn +EPDKjvbdegjvSNqH +DoDKjvbdIxUBglQp +EOcLKvbdBcpAvKNG +DnbjjvbdwXMAvAvV +DnbkKvbddoEsLUUS +DncKjvbdCIkCKiGK +DoDKjvbdlZTSTYft +EPCjjvbddoEsKtTr +EObjjvbdFfJrOJTq +EPDLKvbdliDsqVSB +DncLKvbdbUagXjtI +EObkKvbdIsYaSlxM +EPCjjvbdHkaznXRL +DnbkKvbdxUmFQyMO +DoCjjvbdWWiXvDdg +EPCjjvbdSQUHKFcw +EPDLKvbdjKGIJlwr +EOcKjvbdXFxytAOs +DncKjvbdmbKWwoNu +EObjjvbdiZuFkpmf +DoCjjvbdFyVVBDwb +DnbjjvbdeqaWzlDP +EPCjjvbdRyjHsDWA +DnbkKvbdqlzJyMHi +DnbkKvbdZRNFImFR +DoCkKvbdYfwEAPSi +DoCjjvbdOAIrsjSA +EPCkKvbdaNLCTVMg +DnbjjvbdqceIomvB +DnbjjvbdsCFlkgLZ +DoDLKvbdmIdURUqa +EOcKjvbdZshhxcrn +DoDKjvbdZjTIPgCG +DncKjvbdemGWfmJk +DnbjjvbdACqxKZiQ +EObkKvbdkVvnEBxX +DncLKvbdUtNTfMWK +EPDLKvbduaDxsPFI +EObkKvbdgQBzvcxI +EObkKvbdSZihTDWA +EOcLKvbdqYnggREY +EPDKjvbdqiAJdmPF +EOcLKvbdiGjDZVjV +EOcLKvbdGZVVAdXb +DoDKjvbdhfjCxuiu +DnbkKvbduMYXBTaX +DoCkKvbdjSziTKiz +DoDKjvbdqlzKZMIJ +DnbjjvbdkVwOEBxX +DoCjjvbddtAUASmW +DoDLKvbdzjVQQESt +EOcLKvbdkySrSyHU +DncLKvbdNGbolotk +DnbjjvbddeOrBwCj +DoDLKvbdiLdcmuDZ +DoDKjvbdSPsfjFdX +DoCkKvbdbUafxKtI +DnbkKvbdcJNJkFvx +EObjjvbdFejSNiUR +EPDKjvbdQmYCYmtz +DncKjvbdfVzwpJzs +EPDKjvbdWRmwbEkc +DncLKvbdFkEsDIMu +DoCjjvbdQccBPqES +EObkKvbdKCibpjCx +EOcKjvbdLBLHNBwq +DoCkKvbdUMWOaVoJ +DoCjjvbdrbFmMGjy +EOcLKvbdJvVFdEgJ +EPCkKvbdjhHMGFnL +DncKjvbdNxOuzcmt +EPDKjvbdEXxLstUM +DoDKjvbdwygfGXeS +EObkKvbdyTNiMrBg +DncKjvbdlZSrSxgU +EPDKjvbdJXtCHlQp +EPCkKvbddndsLTsr +EObjjvbdNdcshhkE +DncLKvbdSCDeLhyL +DncLKvbdNsTvHEuQ +EOcKjvbdACqxKZiQ +DoCjjvbdptTgRqjt +EPDKjvbdOEdTiJLE +DoDKjvbdrpVoKCvG +DnbjjvbdFjeSbhNV +EPCjjvbdNGbolouL +EPDLKvbdrEFIonVa +DnbkKvbdOFDsiIjd +DoCkKvbdTqQoUuIN +EPDKjvbdeOdsKtTr +DncKjvbdyNrhXsIc +EPDKjvbdnQZxujyC +EPCkKvbdYqMdhmFR +DncLKvbddeOrBvbj +DoCjjvbdLGFgbApu +DoCjjvbdemFwHMik +DoCkKvbdRXOEClHc +DoCkKvbdZQmEiNFR +EPCjjvbdEASIlzXX +DnbkKvbdrWokbiZR +EObkKvbdHELWKBij +DnbkKvbdbUagXkUI +EOcKjvbdbsDLUDia +EOcLKvbdUWLojUAq +DnbjjvbdQvmccMID +DoDKjvbdZxcjODMS +EPDKjvbdTulPjUBR +DncLKvbdjSzhsKiz +EOcKjvbdTAFJICOd +DnbkKvbdKNADzHVB +DoCjjvbdliDtRVSB +EObjjvbdWXIxVceH +EPCjjvbdfHkWRnQg +EObkKvbdjAQGaPgK +EObkKvbdkClLRGuH +DncLKvbdZnnIdeZj +EObjjvbdlYsRsYgU +DoDLKvbdpyPHgQcx +DnbjjvbdnPyyWKyC +EObjjvbdQwNcblID +DnbjjvbdCJKajhfK +EPDKjvbdiHKCyWKV +EObjjvbdeEoRavbj +EOcKjvbdmaivwnnV +EOcKjvbdwNWANDeN +EPDKjvbdTAFIhCPE +DoCjjvbdZQleJMeR +EPDKjvbdmtuZjiqf +DnbkKvbdEPCkLXCd +EObkKvbdqGEEsvBI +EOcKjvbdmIdTqVSB +EObjjvbdJTZBSlwl +EPCjjvbdqlzKZMIJ +EPDKjvbduCbtwWOo +EPDLKvbdnPzYukYb +EPDKjvbdeFPSBvbj +EPDLKvbdHEKvKCJj +EPDKjvbdVUNUGLuj +EOcLKvbdJuuGEEgJ +EOcKjvbdzQnmJKXA +EOcLKvbdrbGMkfjy +DnbjjvbdUsltFkuj +DnbkKvbdDxYMUUUM +DnbjjvbdUQpoUuHm +EPDKjvbdRbDdlJZL +DncLKvbdmgFXlmfy +EPCjjvbdJbibqJcY +DoCjjvbdEPDLLWcE +DoDLKvbdMJCMRYAS +DoCkKvbdQZNAGsSK +EObjjvbdiCPDFXQq +EOcLKvbdVwJXvEEg +DoDLKvbdsrqsYzFD +DncLKvbdjuvnDbXw +EPDKjvbdhgKCyWKV +DoDLKvbdNdctIiKd +EObkKvbduaEYrneI +DoCkKvbdNVSrKmAX +DncKjvbdXnRAXtvU +DoDKjvbdhkddNtcZ +DoCkKvbdiBnbdwQq +DnbkKvbdLBLGlawq +DoDKjvbdygZMANEw +DnbkKvbdZsiIxcsO +EObjjvbdiBoDEwRR +DoCjjvbdHbLzEzAD +EPCkKvbdjbkkQgVH +EOcLKvbdsBemLgLZ +EOcLKvbdptUGrRkU +EPCjjvbdznpQdbkx +DoDKjvbdGYtuAdXb +EOcKjvbdzjUpQETU +EOcLKvbdypoNIjXA +DnbkKvbdSQUHJfDw +EPCkKvbdbsCjtEKB +DoDLKvbdajlFoODA +DoDKjvbdelevfmKL +DnbkKvbdCTAbsfWr +DoDKjvbdjhGlGGNk +DoCkKvbddCTMrATm +EPDLKvbdaMjbSuMg +DoCkKvbdKaLHNCYR +DncLKvbdGGKSNiTq +DoCjjvbdLZRJrztf +EPDLKvbdjlakyeGo +EObkKvbdwuMdpyLn +DnbkKvbdegjuqnQg +EPDKjvbdtTSTYydc +EObkKvbdZyDjOClS +DnbkKvbdqGEEtWAh +EOcLKvbdKQydoFnF +EPDLKvbdqUTgSSKt +DnbjjvbdMJCMQxAS +EPCkKvbdiMFDnUby +EOcKjvbdfpBzwEXh +DoCkKvbdSBceMIxk +EObjjvbdfMevgMik +EPCjjvbdjAQHAofj +EPCjjvbdZLrETnMN +EObkKvbdDoDLLXCd +DncLKvbdSZjHsDWA +DnbjjvbdOStVgFVQ +EObkKvbdbhlijfXY +DnbkKvbdjEjftoAO +DoCjjvbdeEnrCXDK +EOcLKvbdZyEKNcMS +EPDKjvbdWSNwadkc +EPCjjvbdkDLjqHUg +DoCkKvbdSCEFLiYk +DncKjvbdtkwwBTaX +EPDKjvbdCTAbsevr +DncLKvbdmfdwlnGy +DncLKvbdTukpJtBR +DoCjjvbdlYrrTZGt +EOcKjvbdnCKWwoOV +DncKjvbdMgColpVL +EPDLKvbddwytURez +DoCkKvbdakLenmcA +EPCkKvbdQvmdCkhD +DncLKvbdEARhlzWw +EOcLKvbdrXQMDJYq +EObkKvbdmJETptrB +EOcKjvbdAMgxsXZx +EPDKjvbdULvPBVni +DoDKjvbdqGEFTvAh +DoDKjvbdGLFTChMu +DoCjjvbdLBKgNCXq +DoCjjvbdOEcsiJLE +EObjjvbdSLZFuHKs +DoCjjvbdtkxXAsaX +DnbjjvbdNGbpNQVL +EOcLKvbdiLeEOUby +EObjjvbdDoCjjwDE +EPCkKvbdxrnJMrCH +EPDKjvbdJTZBTMwl +DncKjvbdBcpBWJlf +DncLKvbdGKdsDHmV +DncLKvbdDwwlUUTl +EPDLKvbdbQHHELzd +EPDLKvbdYlSEUOLm +EObjjvbdhtyeXSUb +EPCjjvbdACqxKZiQ +EObjjvbdrDdiPmua +EPCkKvbdcyxpYYqC +EPDKjvbdrXQLbiZR +DncKjvbdjmBlZeHP +DncKjvbdlYrrTYft +EObkKvbdaaWFFpPw +DncKjvbdwyhGFwdr +EPCkKvbduLxXAtBX +EObjjvbdhancEvpq +DncLKvbdbiMjKevx +DncKjvbdTIyjRABM +DoCkKvbdcImKLFvx +DnbkKvbdZjSgpHBf +EPCkKvbdGdKvJbJj +EOcLKvbdSCDeMIyL +EOcKjvbdZxdJnClS +EOcLKvbdHDkVibJj +DoDKjvbdezuxeJTw +EOcKjvbdqFceUVaI +EPDKjvbdWIYWXfxz +DoDKjvbdNQXqWOHT +DnbkKvbdOStWHEtp +EPDKjvbdLAkGmBxR +EPDKjvbdDxXksssl +EPCkKvbdTqRPVUgm +DoDLKvbdrDdhomvB +DncLKvbdptUGrSKt +EOcKjvbdiBnbeWqR +DoDKjvbdezvYeJUX +DnbkKvbdOAJStJrA +DnbjjvbdtcCuWvPP +DnbjjvbdIjEAKPgE +EObkKvbdWWiXvEEg +DnbkKvbdSBdFMJYk +EOcKjvbdQdCaQQcr +EPDLKvbdLZRKSzuG +DoCkKvbdpfEFTuaI +DnbkKvbdVBBqSqRy +DncLKvbdMoxRVnGs +EOcLKvbduoTzqKnt +DoCjjvbdxxJKCPyk +DncLKvbdVvhwvEFH +EPDLKvbdOYPVzcnU +EOcLKvbdBdPaWJlf +DnbkKvbdJSyAsMwl +DoCkKvbdYTLaMsnx +EOcKjvbdUWLpJsaR +DoCjjvbdhbOcEwRR +DncKjvbdKfGHbAqV +DoCjjvbdlZTSSyGt +DncLKvbdatbGxLTh +EPDLKvbdiGicYvKV +EOcLKvbdTIyjRAAl +EPDKjvbdZsiIyDsO +DnbjjvbdZLqcsmlN +EOcLKvbdeOeTLTtS +DncKjvbdQdCaPqDr +EPCjjvbdUGznLvvF +EObkKvbdrDdhpNvB +EPDLKvbdRadFLhxk +DnbjjvbdhytelQmf +EPDKjvbdFkFSbhNV +DoDKjvbdaSGDHsek +EObkKvbdzHYlAMdw +DnbjjvbdliDsptrB +EPCkKvbdYlSDtNlN +DoDKjvbdnPyxujxb +EObjjvbdRkYfVGjs +EPCjjvbdRaceMJZL +EOcLKvbdnUuZkJrG +DncKjvbdOYOuzdNt +DoCkKvbdJbjDQicY +DnbjjvbdRyjHsCvA +EOcLKvbdUGzmlXVe +EPCjjvbdMoxRWOGs +DncKjvbdlrZUzTEJ +DoCjjvbdJYUBgkpp +EOcLKvbdACrXizJQ +EPDKjvbdsCGMkfkZ +DncKjvbdqYnhGqEY +DncLKvbdjgflFemk +DncKjvbdrzMQTAgn +DoCjjvbdlZTSSxgU +EPDLKvbdKCibqKCx +EOcLKvbdmJDtQuSB +DncLKvbdQcbaPqES +DoCjjvbdOXoVzdNt +EObkKvbdbsCjsdKB +EPDKjvbdySmiMqbH +DoCjjvbdrMzKZLhJ +DncKjvbdtAGqIAAr +EPCjjvbdEXxMTtUM +EOcKjvbdVrOYBdkc +DoDKjvbdzROlhiwA +DncKjvbdqTtHRrLU +DnbkKvbdiUzEwSUb +DoCkKvbdZLqcsnMN +DnbjjvbdUaBqTRRy +DoDKjvbdRosgKGEX +EObkKvbdShzKRABM +DoDLKvbdqZOhHRDx +EPDLKvbdiUzFWqtb +DoCkKvbdZyEJmbkr +DncKjvbdREDBPpdS +EPCjjvbdMSWmZtpz +EPDLKvbdTAEiHaoE +DoDKjvbdNeETiIjd +EOcLKvbdqdFJPmua +DoCkKvbdRpTfjFcw +DncLKvbdznoqEcMY +DoCkKvbdFfJqmiUR +EOcLKvbdSPsfifEX +DnbjjvbdtunYJpsA +EPDKjvbdqcdiQOVa +DnbkKvbdeXyssrFz +EPDLKvbdQYmAGrqj +EObjjvbdegjuqmpg +EOcLKvbdbLLenmcA +EOcLKvbdpyPHgREY +DoDKjvbdZRMdhmEq +DncLKvbddZxoxZRC +EOcKjvbdKxpjSztf +EPDKjvbdKkBHvAJy +EObkKvbdnBiwYOnV +EObkKvbdrWolDJYq +DoCkKvbdZyEJmbkr +DoDKjvbdkDMLRHUg +EPCjjvbdQwNccMID +DncKjvbdSZihSbvA +DncLKvbdnHFXmNgZ +DncKjvbdGKeSbhMu +DncLKvbdULvPAuoJ +EOcLKvbdYqNFJMeR +DoDLKvbdMfcPmQVL +EPDKjvbdFpATWgGZ +EObjjvbdeqaWzkbo +EOcKjvbdZoNhddzK +EObjjvbdFeiqmiTq +DoDKjvbdauBfwjsh +EOcLKvbdBraDUFvr +DoDLKvbdyYIjCPzL +DnbjjvbdmRxuZsEJ +EObjjvbdMfcQMpUk +EOcKjvbdyNsIXrhc +EPDKjvbdREDBPpcr +EPCjjvbdRkYeuGkT +EPCkKvbdtAHRIAAr +DnbkKvbdxUmFQxkn +EObkKvbdtTSTZZdc +EOcKjvbdmIdUQtqa +EOcKjvbdXrkaNUPY +DoDKjvbdCWzdIePv +DoDKjvbdbBVdfQPw +EPCjjvbdZyEJmblS +DncKjvbdlZTRrxft +EPDLKvbdIxUCIMQp +DnbjjvbdKyRKSztf +EOcKjvbdNeEUIhjd +EOcLKvbdjKGIJmXr +DoDLKvbdCEPaVimG +EPCkKvbdOFDsiIkE +EOcLKvbdehKvSORH +DoDKjvbdwWkaWAuu +EPDKjvbdpxoHfpcx +EPDKjvbdJbjCqJbx +DncKjvbdZtJJZETO +EPDLKvbdsZkpTBHn +EPCkKvbdTlWPAuoJ +DoCjjvbdjggMFfOL +DoDKjvbdfMewGlik +EPDLKvbdnBivwoOV +DoCjjvbdwuNEpxkn +DnbkKvbdiifIKNYS +EOcKjvbdKVuFdFGi +EPCjjvbdZdxGzgiC +EOcLKvbduaDxsPEh +EPCkKvbdRotHJfEX +DncLKvbdCIjajhej +DoCkKvbdcImJjfWx +EOcLKvbdKVtecdgJ +DoCjjvbdeFOrBwCj +EPDKjvbdqvpLcIxq +EObjjvbdEARiMyvw +DncKjvbdbUafxLTh +DncLKvbdLAkGmCYR +DoDKjvbdxVMdqYkn +EPDKjvbdWWiYWDdg +EObkKvbdKDJbpjCx +DoCkKvbdnPyxvKyC +DoCkKvbdZsiJYcsO +EObkKvbdJpzFOeme +EOcLKvbdOSsufeUp +DoDLKvbdTfznMWvF +EPDLKvbdfNFwGlik +EPDLKvbdCDpAuilf +EPDKjvbdbiMikGWx +DoCkKvbdrbGMkfjy +DoCjjvbdWIXuxHYz +EPDKjvbdGFiqnIsq +EPDLKvbdNGbpMpVL +EOcLKvbdtSrTYyeD +DoDKjvbdjJfHjNXr +EPCkKvbdzitpPcrt +DoDLKvbdxmrgxSiD +EPDLKvbdcJNKLFvx +EPDLKvbdsrrSxydc +DnbkKvbdqceIonWB +EPCkKvbdZnnIddzK +DoCjjvbdLYpirztf +EPCjjvbdLrWlzUpz +DnbjjvbdRkZGVGjs +EObjjvbdnBivxOmu +DoCjjvbdmIdUQuSB +EObkKvbdtcCtvuoP +DnbjjvbdANIYrvzY +DncKjvbdmaivwoNu +EOcLKvbdrouoJcWG +DoDLKvbdTppoVVIN +DoDLKvbdVUMtFkuj +DncLKvbdznpQdblY +DncKjvbdEPCkLXDE +EOcLKvbdfHkVqmqH +EPDKjvbdapGgDkzd +EPCjjvbdSPsfifDw +DoDLKvbdGKeTDINV +EObjjvbdyqPNIjXA +EPCjjvbdatbGwkUI +DoCjjvbdCTAcTewS +DnbjjvbdxnTIXsJD +EOcKjvbdbKlFnnDA +DncKjvbdjJegjNXr +EObjjvbdMuTRkNAX +EObkKvbdUxgsykOn +DoCkKvbdRaceMIxk +EPDLKvbdJbibpibx +DoDKjvbdEztQdlCi +EPDKjvbdcyyPwyRC +DncKjvbdjlbMZdfo +EPCkKvbdRXNdClID +DncLKvbdtbbuXVoP +DoDKjvbdieLHVPAO +DoDKjvbdFVxopMie +EObjjvbdzoPpdblY +EPCjjvbdmIdUQuSB +EPCkKvbdYkrEUNkm +DoCkKvbdVwIxVdEg +DoCjjvbdOSsvGdtp +EPCjjvbdmSYtysDi +EObkKvbdWWiYVceH +DoDKjvbdrNZixkgi +EPDKjvbdbVCHYKsh +DnbkKvbdjKFgimXr +EPDKjvbdNsUWHFUp +EObkKvbdeAUQlwjG +EOcKjvbdTAEiICPE +DoCkKvbdZLqdUNkm +EOcKjvbdZisHogCG +EPCkKvbdKVtfEEgJ +EObjjvbdaSGDIUGL +EPDKjvbdZRNFIleR +DoDKjvbdyXiJaoyk +EObkKvbdRkYfVHKs +DnbkKvbdLAkHNCXq +DncKjvbdJpyePFnF +EPCkKvbdkHgMFenL +DoDLKvbdOFDtIhkE +DoCkKvbdtTSTZZdc +EOcLKvbdkClKpfuH +DoCjjvbdBcpBVjNG +DnbkKvbdfMfXHNJk +DoDKjvbdBsBCtFvr +DoCjjvbdHgGzYwwg +DncLKvbdSwjkmzkY +DoCkKvbdDihJuwjA +EPDKjvbdQccBPpdS +EPDKjvbdehLVqnQg +DoCjjvbdmozZVkZC +DoDLKvbdaNKasVNH +EObkKvbdrRtkOLBN +DoDKjvbdehLWRnRH +EObkKvbdSCEEkiYk +DoCjjvbdRXOEDMID +EOcKjvbdFejRmiUR +EOcLKvbdFkEsChNV +DncKjvbdWWhwuceH +EPCkKvbdNwoVzdOU +EOcKjvbdePFSkUTr +DoDKjvbdMRwMzUpz +EObjjvbdLrXMzUpz +EPDKjvbdZxdJnDLr +EOcLKvbdrRtkNjaN +EPCkKvbdTvLoitBR +DncKjvbdKeehCApu +EPDLKvbdemFvfljL +DncLKvbdeFOqawCj +DoDKjvbdZyEJnCkr +DoCjjvbdlZTRsZHU +DnbkKvbdRbDdlJZL +DnbjjvbdYqMdiNFR +EObjjvbdSQTfjFdX +DoCjjvbdgFlZnGgA +DoDLKvbdwtldqYkn +EObkKvbdjggLfFmk +DncLKvbdMgCpNPtk +DncKjvbdmpZyWKxb +EPDKjvbdVqnYBeMD +DoDKjvbdULuoBWOi +DncLKvbdezvZEiTw +EPCkKvbdjblLRHUg +EPCjjvbdBiKakJGK +DncKjvbdTukpJtAq +DoCkKvbdkWWnEBxX +EPCjjvbdnPzYvLZC +EOcLKvbdWHxVxGxz +DncLKvbdNsUWHEtp +EObkKvbdHDkWKBij +EObkKvbdVAbQsQrZ +DnbkKvbdKCibqKDY +EObjjvbdLYqKSztf +DoCkKvbdZLrDtOMN +EOcKjvbdemFvgNJk +DncLKvbdiCOcEvpq +DnbkKvbdEXxLtTtM +EObkKvbdFjdrbglu +EObkKvbdmttykJrG +DoCjjvbdePFTLUTr +DoCkKvbdWRmwadlD +DoDLKvbdVqmxCElD +EPCkKvbdnBiwXoOV +DnbjjvbdEvZQPmKF +EObkKvbdSKyGVGkT +EPCjjvbdauBgXkTh +EPCjjvbdVrNxBeLc +EObjjvbdOEcshiLE +DoDLKvbdbLMGPNcA +DnbkKvbddZxpYYqC +DoCkKvbdlZTSTZHU +EObkKvbdtlXwBTaX +EObkKvbdHffyxwxH +EPDKjvbdrpWOicVf +DncKjvbdkVvmdBww +EPDKjvbduaDySoFI +EObkKvbdsZkosBHn +DoDLKvbdTAFJICOd +DnbjjvbdpstHRrLU +DncKjvbdUQqOtuIN +EPDKjvbdVUMtFlWK +DoDLKvbdrouoKDVf +DoCjjvbdmRyUysDi +EPDKjvbdgFkzNgHA +DnbjjvbdZshiZDsO +DnbjjvbdIMBzmwRL +EObjjvbdZshhxdTO +EOcLKvbdZGwEAOri +EPCkKvbdkHflFfOL +DoCkKvbdKDJcQibx +EOcLKvbdFkEsCgmV +EPCjjvbdJutfEEgJ +DoCkKvbdOXnuzdNt +EPDLKvbduLwwAtAw +DoDKjvbdqvpLbiZR +EPCjjvbdGYuVBEXb +EOcLKvbdCJKajhfK +DnbjjvbdkMbLyeGo +EPCkKvbdijGIKMwr +DoDLKvbdJzpGXdAN +DoDKjvbdNwnuzdOU +EOcLKvbdtSqsYyeD +EOcLKvbdmRxuZrdJ +EPDKjvbdhlEcmtcZ +DoCkKvbdbiNJjevx +DoDKjvbdGckVibJj +DoDLKvbdGLFSbhMu +EPDKjvbdEObjkWbd +EObkKvbdBhkBjiGK +EPDKjvbdtAGqIAAr +DoCkKvbdWRmwadkc +EObjjvbdQdDAoqDr +EOcLKvbdwNWANDeN +EPCjjvbdMowqVmgT +EPDLKvbdegkWSNpg +EPDLKvbdjAQHAogK +DoDLKvbdvwLaVaWV +EPCjjvbdLGFgbBQu +DoCjjvbdxsOJMrCH +EObkKvbdFkFTChMu +EObjjvbdbLLenmcA +EPDLKvbdiCObeXRR +EPCjjvbdhbObdvpq +EObkKvbdVZIUZkOn +EPDLKvbdfVzxPizs +EPDKjvbdnPyyVjyC +DncLKvbdRzKITCvA +EOcLKvbdUtMsfLuj +DncKjvbdVBBpsRRy +DnbkKvbdzeZnzdzQ +EOcLKvbdUtNTfMVj +EObjjvbdqcdiQOWB +DoCkKvbdNddTiIjd +DncLKvbdrykosBHn +EPDKjvbdWRnYBeLc +DncLKvbdrXQLcIxq +EPCkKvbdUWLpKTaR +DoCkKvbdZRNFJMeR +EPDLKvbdunszpjoU +DoDKjvbdzitpPdSt +EObkKvbdvBDxrneI +DoDLKvbdVviXvDeH +EPCkKvbdDihJuxKA +EPCkKvbdNPxQunGs +DoCjjvbdmuUzKjRf +DnbkKvbdbPffdLzd +DoDLKvbdXrlBNTnx +DoDKjvbdZQmEhmFR +EObjjvbdmttzLKRf +DoCkKvbddijRvUzn +EPDLKvbdHffyyYXg +EPCkKvbdcTDKtEJa +EPCkKvbdpecdtWAh +DncKjvbdRjxeuGkT +EPCjjvbdqdEhpOVa +EPCjjvbdelfXGmJk +EObkKvbdWWhwudFH +EPDKjvbdhbObeXQq +DoCkKvbdffLynHHA +DnbjjvbdpaJFAXIE +DoDKjvbdqZPIGpcx +DoDLKvbdmaivxPOV +DncKjvbdqFdEsvAh +EPCjjvbdrpWOibvG +EPCkKvbdyfyMAMdw +DoDLKvbdhuZdvqtb +DncLKvbdWRnYBeMD +DncLKvbdDncLKvbd +EObkKvbdhzUfLpnG +EOcLKvbddoFSkTtS +EPDKjvbdbKlFoODA +DoCkKvbdRWmccLhD +EObjjvbdeAUQlxJf +DncLKvbdKVuGEEfi +EObkKvbdVvhwvEEg +EPDLKvbdhaoDEvqR +EPDKjvbdpfEFTvBI +EPCkKvbdyzeNrIJI +DoDLKvbdGckViaij +EObjjvbdnHExNNfy +EObkKvbdZLqdUOLm +DoDLKvbdDxXktTsl +EObkKvbdFVxpPmKF +DoDKjvbdNdctJJLE +DnbkKvbdTXkMNzjx +DncKjvbdbrbkUEKB +DoCkKvbdGKeSbhNV +EPDKjvbdYSkaMtOx +EPCjjvbdiGicYujV +EObjjvbdnHFXmOGy +DoDKjvbdZyDjNblS +EOcLKvbdGYtuBEXb +DnbjjvbdqGDeUWAh +DnbkKvbdTppnuVHm +EOcLKvbdPyNAGsRj +EPCkKvbdIrxaSlxM +DncKjvbdCfkfHAzc +DnbkKvbdIHHZxxXg +EPCjjvbdjKFhKMxS +EOcKjvbdehKvRnRH +EObjjvbdxVMdpyMO +DnbjjvbdSLYetgKs +EObkKvbdRjyGUfkT +DoCjjvbdwyhFeweS +DncLKvbdrJAKElne +EPCjjvbdiGjCxvKV +EPCjjvbdCIjajiFj +DoDLKvbdunszqLPU +DnbjjvbdySmhlrCH +DnbkKvbdnBjWxPNu +DoDKjvbdlhdTqUrB +DoCjjvbdGdKvJajK +EObjjvbdkySqryHU +EPCjjvbdYkqdTmkm +EObkKvbdDnbjkXDE +EPDKjvbdKDKCqKDY +EOcLKvbdeYZstSFz +EPDKjvbdZyDjNbkr +DncLKvbdPyNAGrrK +DoCkKvbdTlVoAuni +DncKjvbdEPCkKvbd +EPCkKvbdcTCkTcjB +DnbkKvbdcJNKLGXY +DnbjjvbdRkYfVHKs +DoDLKvbdaaWEfQQX +EPDKjvbdmbJvwnmu +EOcLKvbdZyDimcMS +DoDLKvbdYkrEUNkm +DoDKjvbdmaivwnmu +DoDLKvbdqYoIHQcx +EPDKjvbdLrWlyuQz +DncLKvbdkCkkQgVH +EObjjvbdrXPlChyR +DoCjjvbdJTYaTMwl +EPCkKvbdNsTvHFVQ +DnbjjvbdeEnqavcK +EPCjjvbdVvhwuceH +EPCkKvbdbLMFoODA +EPDLKvbdCIkCLIfK +DoDLKvbdbLLennDA +DncLKvbdyNrhYTIc +EPDLKvbdNHCpNQUk +DnbkKvbddndsLUTr +DncKjvbdaogHDkzd +EPDLKvbdZjSgpGbG +DnbjjvbdaSGDIUGL +EPCkKvbdjhGlFfNk +EPDLKvbdbKkenmcA +EOcKjvbdIHHZyXxH +DoCjjvbdiUydwRtb +EPDLKvbdauBgYKtI +EPDLKvbdZMSDsmlN +DoDKjvbddneSjtTr +EPCjjvbdJbibqJbx +DnbjjvbdGYtuAcwb +DoDLKvbdsQVoJbvG +DoCkKvbdxmrhXsIc +DoCjjvbdyNsHwsJD +DoCkKvbdKWVFceGi +DoDLKvbdsBfNMGkZ +DnbkKvbdJzoewdAN +EPDKjvbdwzHefYFS +DnbjjvbdBiKbKhej +EOcKjvbdjuvmdCXw +EOcKjvbdbhmKKevx +DoCjjvbdehLWRmpg +EPCjjvbdACrYJzJQ +EOcKjvbdhuZeXSUb +DoCkKvbdJcJbqJcY +EPDKjvbdYqMeJNEq +DncLKvbdmJDtRUqa +EPDKjvbdnBjWxOnV +DoDLKvbdOEctJIkE +DoCjjvbdDxYLtTtM +EOcLKvbdZnnJFFZj +EOcKjvbdKRZeOfNe +DoCjjvbdTukpJtAq +DoDKjvbdhyuGLpnG +DoDKjvbdhtzFWrUb +DnbkKvbdQccBQRDr +EPCjjvbdTukojUBR +EPDKjvbdeKKRvUzn +EOcLKvbdeXzTtSFz +DncKjvbdyTOJNSCH +EObkKvbdjmBkydfo +EPCjjvbdelevflik +DoDKjvbdZtJIxcrn +DoDKjvbdqiAJeNOe +DoCjjvbdddnqavbj +DoCjjvbdZLrDtOMN +EPDKjvbdZyEKNcLr +EObkKvbdMgDPmQVL +EPCjjvbdxrmiMrBg +EObjjvbdZGvdAPSi +EPCkKvbdvvkaWBWV +DncKjvbdfMewHNJk +DoCjjvbdlrYtyrdJ +DncLKvbdiLeDnVCy +DnbjjvbdvwLaWBWV +EOcLKvbdVBCRSprZ +DoDLKvbdYzbfSKVy +DnbkKvbdXrlBNUPY +EObjjvbdKfFhCAqV +DoCkKvbdVTmTekvK +EPDLKvbdaSGChTfL +DncLKvbdauCGwjsh +EObjjvbdBcpBWJlf +DnbjjvbdZjTIQHCG +DoCkKvbdDjHiuxKA +EObkKvbdZxdKNblS +DoDLKvbdptTfrRjt +DoDLKvbdJbjCqKDY +EOcKjvbdEJhKWYKA +DnbkKvbdssSSyZeD +EOcLKvbdZshhyESn +EPDKjvbdRjxfUgKs +DncKjvbdwygefYEr +EPCkKvbdiLeEOVCy +DnbkKvbdTvLojTaR +DoCkKvbdzdzOzdyp +EPDKjvbdVUNUGMWK +EObjjvbdqdEhonVa +EPDKjvbdKefHbAqV +DncKjvbdtSqsYzFD +DoDLKvbdZjTIPgBf +EPCkKvbdRjyFuHLT +EOcKjvbdUtMsfLvK +DoCjjvbdnHEwlnGy +DnbjjvbdURQnttgm +DoCkKvbdFfJrOIsq +DoDLKvbdjKGIKMwr +EOcKjvbdTAEiIBnd +EPDLKvbdFxttaEXb +DoDKjvbdJTZAsNYM +EPCkKvbdFejSNhtR +EPDKjvbdwkXEHzyf +DnbjjvbdbUafxLTh +DoCkKvbdZQleJNEq +EPCjjvbdmpZyVkZC +DnbjjvbdmJEUQuRa +EObkKvbdrEFIpNua +EOcLKvbdJpzEnfNe +DnbjjvbdyTNiMqag +EObjjvbdNQYQvOHT +EPDKjvbdGKdrbgmV +EOcLKvbdCJKakIej +DncLKvbdlhcsptrB +DnbjjvbdZirhPfaf +DncKjvbdZoNiFFZj +EOcLKvbdjuwNcaww +EOcKjvbdUyITzLPO +DnbjjvbdxVMdpyLn +EObjjvbdnCJwXnnV +EPCjjvbdIMBznWqL +EObkKvbdJpzFOenF +EObjjvbdlhdTpuRa +DncLKvbdSCDdkiZL +EObjjvbdZxcimcMS +EOcKjvbdxVMdqZLn +DoCkKvbdrJAKFMne +EObjjvbdXsMAmUPY +EObjjvbdeFOqbWbj +DncKjvbdCTBCsfWr +DoCjjvbdRyjHsCvA +EPDKjvbdziuQQDrt +EOcLKvbdziuPocrt +EPCkKvbdWWhwvEEg +EPCkKvbdeEoRavcK +EPCjjvbdSKyFuGkT +EPCjjvbdrEFIonWB +EObjjvbdrEFIpOVa +DncKjvbdzGyMANEw +EPDKjvbdrRtjmjaN +DoCkKvbdJbjDRKDY +EObkKvbdfNFvgNKL +DnbkKvbdZHWdAPTJ +EPCjjvbdCDoaWKMf +DncLKvbdJKEAKPgE +DnbjjvbdssSTYydc +EOcKjvbdIsYaTNYM +EPCkKvbdgPazvcxI +DoCjjvbdmozYvLYb +DnbkKvbdeATqNYKG +EObjjvbdIwsbIMQp +EPDLKvbdpssfrSKt +EPCkKvbdhzUfLpmf +EOcKjvbdNGcPlpUk +DncLKvbdhkeEOVDZ +EPDKjvbdLFfIBaRV +EPCkKvbdJuuGEFGi +EOcKjvbdRacdlJYk +EPCjjvbdmbKWxOmu +EPDLKvbdwtmFQxkn +DnbjjvbdgvyAzzAJ +EPDKjvbdNrsugFVQ +DncKjvbdmttzLKRf +DnbkKvbdZyEKNcLr +EObkKvbdxrmiNRag +DoDLKvbdiMFDnVCy +EObjjvbdWSNxBdlD +DnbkKvbdCTBDUFwS +DoDKjvbdYTLaMtPY +EOcLKvbdZtIiZDrn +EObjjvbdYzcGSJvZ +EObkKvbdCSaDUFvr +DoCjjvbdTppnuUgm +DoCkKvbdOTUVfduQ +EOcLKvbdfpBzwDwh +DncKjvbdGBPQyJzm +EPCjjvbdVZITyjnn +EObkKvbdVhXuxGxz +EObjjvbdiifHimXr +EPDKjvbdvwMAvAvV +EOcKjvbdkWXODbYX +DoDKjvbdmbKXXnnV +DoDLKvbdZsiJZDrn +DoCkKvbdlrZUzTDi +DoDKjvbdSQTfjGEX +EOcKjvbdqcdiPnWB +EOcLKvbdpssgSSKt +EPDLKvbdhkeENuCy +EPDKjvbdZQmEhmEq +DoDKjvbdZtJIxcrn +DncLKvbdhgJbxujV +DoCkKvbdDoDKkXCd +EObkKvbdZGvdAOsJ +EObkKvbdwjvdHzyf +EPCjjvbdUQpoUuHm +EPDKjvbdUGznMXVe +DnbjjvbduaEYroFI +DoDLKvbdehLWRnRH +DoDLKvbdgQBzwEYI +EObkKvbdbUagYKsh +EObjjvbdyqPMhiwA +EPDKjvbdvvkaWBWV +DnbkKvbdJTYaTNYM +DoDKjvbdZtIhxdSn +EOcLKvbduaEZTOdh +EObjjvbdkNCMZeGo +EPCjjvbdZLqdTnLm +DoCkKvbdUsltFkuj +DncKjvbdnPyyVkZC +DoDLKvbdwjvdHzzG +EPCkKvbdGKdsCgmV +DnbjjvbdiMFDmtby +EObjjvbddneSjtUS +DncLKvbdezvZFJUX +EPCjjvbdhbOcFWqR +DoCkKvbdaMjbTVMg +DoDLKvbdHDjvKCJj +EOcLKvbdpxoIHRDx +DoDKjvbdZshhxcrn +EOcLKvbdcJNKKewY +EObjjvbdTppntuHm +EPCjjvbdemGWfmJk +DoCkKvbdjcLkQftg +EObkKvbdQwODbkgc +EPDLKvbdCTAcUFwS +DnbjjvbdvOszpkPU +EOcKjvbdkClLRHUg +EOcLKvbdNHCpMpVL +EObjjvbdZMRcsnMN +DoCjjvbdpxnggQcx +EOcKjvbdyTOJNRbH +EPDKjvbdeKKRutzn +DncKjvbdrzLosAgn +EPDKjvbdYzcGRjWZ +EPDKjvbdQcbaPpdS +DnbkKvbdtkxXAsaX +DncKjvbdCDpAvKMf +EPDKjvbdHEKvKBjK +EOcKjvbdfpBzvdYI +DncLKvbdiifIJmYS +EPDLKvbddeOqbWbj +DnbkKvbdZyDinDMS +DoDLKvbdkNCLydgP +EOcLKvbddePSCWbj +DnbkKvbdZxcjNcMS +DoCjjvbdQwNccMID +EPDLKvbdiiehKMwr +EOcLKvbdCTBDUFwS +EPDLKvbdbLMGOnDA +EOcLKvbdUMWOaVni +DnbjjvbdyqPMhjXA +DncKjvbdCTAbsewS +DncKjvbdMpYQvOHT +EPDKjvbdTqRPVVIN +DoCjjvbdZxdJnClS +DoCjjvbdWSNwbElD +DnbkKvbdrWokcIxq +EObkKvbdWIYWXgYz +EPDKjvbdzitopDsU +EObjjvbdUVkojUBR +EPDLKvbdEObkLXCd +EOcKjvbdrbFmMHKy +DnbjjvbdehKuqmpg +EOcLKvbdZshiYcrn +DoCjjvbdZnnIdeZj +EOcLKvbdmttzLKRf +EObjjvbdGZUuBDwb +DoCjjvbdHDjvJaij +DnbjjvbdKQzFPGNe +DncKjvbdRbDeMJYk +DoCjjvbdezuyEhsw +DoDKjvbdwkWdHzzG +DncKjvbdEASJMyvw +DncLKvbdyfyMANEw +EPCjjvbdCSaDTfXS +EOcKjvbdCJKajiGK +EObjjvbdrJAKFNOe +DnbjjvbdFWZPoljF +DnbjjvbdmpZyVjyC +EPDKjvbdiifIKNYS +DncKjvbdGAnqYizm +EOcKjvbdiMFEOVDZ +DnbjjvbdJXtBglRQ +DoCkKvbdijGHilwr +DoCjjvbdDwxMUUUM +DoDLKvbdUMWPBVni +EPCjjvbdDwwksssl +DnbkKvbdNeDshhkE +EObkKvbdbAudfQQX +DnbkKvbdwuMdqZLn +DnbjjvbdijGHjNXr +EPCjjvbdOFETiIkE +DoCjjvbdxsOImSCH +DoCkKvbdLiBkqYAS +DncKjvbdFkFTDHmV +DoCjjvbddoErjstS +EObjjvbdyOTIXsIc +DncKjvbdeXzTtSFz +DoCjjvbdqdFIonWB +EPDLKvbdMpYRWNgT +DoDLKvbdfNGXHNJk +EPCjjvbdePErkTsr +DoCjjvbdNHCpNQVL +EObjjvbdsQVnjCuf +DnbjjvbdtcDUwWPP +DoCjjvbduaDySndh +EPDKjvbdqZPIGqDx +EObjjvbdijFgimYS +DncKjvbdZyEJmblS +DoDKjvbdirziSkJz +DncLKvbdeOeTKtTr +EOcKjvbdfpBzwEYI +DnbkKvbdezvZFItX +EPCjjvbdrRuLOKaN +DncLKvbdbrbjscjB +EObkKvbddBrlrAUN +EPDKjvbdZoOIdeZj +EOcKjvbdGYuUaEYC +EPCkKvbdNxPVzdNt +EOcLKvbdhlFDmuDZ +DncKjvbdKVtecdgJ +EPDLKvbdqlzJxkhJ +EOcKjvbdySmhlqbH +EPCkKvbdxsNiNRag +EPDKjvbdTYKkmzjx +EObkKvbdIryBTMxM +EPDLKvbdxnShXsIc +EPCjjvbdaSFbhUGL +EObjjvbdRDbaQQdS +EObkKvbdrbFmMGkZ +EPCkKvbdWXJXudEg +EOcLKvbdcJNKKfXY +DncKjvbdEuxpPljF +DncKjvbddCTNSATm +EOcLKvbdFVyQPmKF +EPCkKvbdpeceUWBI +DoDLKvbdVTmUGMWK +DoCjjvbdFyVVBEXb +EOcLKvbdTukpKTaR +DncLKvbdDHLegAzc +EPCjjvbddxZtTrFz +DncKjvbdssRsZZeD +DoDKjvbdeOeSjstS +DoDKjvbdQdDApQcr +DncLKvbdURQoUuIN +DnbkKvbdezuxdiUX +EPCjjvbdbPgHDkzd +EOcKjvbdFWZQQMjF +DoDKjvbdMfcQMotk +EPCjjvbdrWokbiYq +DoDKjvbdnGdwmOGy +EOcKjvbdnBjXYOmu +EOcLKvbdDoCjjvbd +DoDLKvbdsQVoJbuf +EObkKvbdZirhQHBf +EPCkKvbdIGgZxwwg +DncLKvbdrMzKZMIJ +DnbkKvbdkHflFemk +EObkKvbdfHkWSORH +DnbkKvbdwygfGYEr +EOcKjvbdxmrgxTJD +DnbjjvbdGdLViaij +DoDKjvbdmSYtysEJ +EObkKvbdfILVqmpg +DncLKvbdADSXizIp +DoCjjvbdznpQdbkx +DncLKvbdmbKWxOnV +EPCkKvbdJvUfEEfi +EOcLKvbdcScLTdJa +DnbjjvbdQcbaPpdS +EPDKjvbdDoDKjvcE +DncKjvbdhzUfMROG +DncKjvbdbrcKtDia +EOcLKvbdJpydoFme +DnbjjvbdxLWdHzyf +EPCjjvbdwuMeQyMO +EOcLKvbdiifHimXr +EOcLKvbdySmiNSCH +EPCjjvbdznopeCkx +EPDLKvbdZshhyESn +DoDLKvbdrDeJQNvB +DoDLKvbdILaznXQk +DoCjjvbdnUtzKiqf +DnbkKvbdjJehKMwr +EOcLKvbdDxXlUUUM +DoCkKvbdtSqsYyeD +DoDKjvbdxVMeQxlO +EPDLKvbdZjTHofaf +EObkKvbdZisHogBf +DnbkKvbdnBiwXoOV +DoCkKvbdYSkaMtPY +DncLKvbdHELVibKK +EPCkKvbdhlEcnVCy +EPCkKvbdZLqdTnMN +DoDKjvbdbsCkUEKB +EPCkKvbdMpYRVnHT +EOcLKvbdFWZQPljF +DoDLKvbdznoqEcLx +DnbkKvbdcImJjewY +EPCkKvbdvvlBVaWV +DoCkKvbdmIdTqUrB +DncKjvbdxZgeexFS +EOcLKvbdrouoJbvG +DoCkKvbdWRnYBdlD +DoCkKvbdBhjbLJFj +DnbjjvbdrouoKDWG +DoDKjvbdUxgsyjnn +DoDLKvbdakMFnnDA +EOcLKvbdZtJJYcsO +DncLKvbdrbFllHKy +EPCjjvbdmajXXnmu +DncLKvbdpyPHgQdY +EObjjvbdyNrgwsJD +EPCjjvbdaMjaruMg +DncLKvbdYfwEAPTJ +DoDKjvbdbiNKLFvx +DoCjjvbdajkfOnDA +EObjjvbdZoOJEeZj +EOcKjvbdqZOhGqEY +EOcKjvbdziuPodTU +DoDKjvbduLxWaUBX +EObkKvbdyXhjBoyk +DoDKjvbdTkunaWPJ +EObkKvbdBraCsfXS +DoDLKvbdTAEiICPE +DnbkKvbdDjHjVwjA +EOcKjvbdqlzKZLhJ +EObkKvbddneTLTsr +EObkKvbdWRmwaeMD +DoDLKvbdLBLHNBwq +DoDLKvbdUxhUZkPO +DncKjvbdYlSDsmkm +DoCkKvbdxZhGFwdr +EObjjvbdbsDKsdJa +EPCkKvbdGYuVAdYC +EObkKvbdRXNccLhD +DnbjjvbdFVxpQMjF +DoDLKvbdMgDQNPtk +EObkKvbdQvmccMHc +DncKjvbdMpXqVnHT +DoCjjvbddZxoxYqC +DncKjvbdnVUzKjRf +DoCjjvbdEuyQPmKF +DoDKjvbdLYqKSzuG +EPDLKvbdTAFJICOd +DoCjjvbdCJLCKiFj +EOcLKvbdFyVVAcwb +DoCjjvbdbQHHDkzd +DoCkKvbdNrsvGduQ +DnbjjvbdRWmcblID +DnbkKvbdQvnEDLgc +DnbjjvbdVZITzKnn +EPDLKvbdxxJJaoyk +EObkKvbddoEsLUTr +DncLKvbdZQldhldq +DoDLKvbddCSmSAUN +DoDLKvbdYpldhldq +DoDLKvbdDxXlUTsl +EPCkKvbdnGdxMmfy +DncKjvbdwWlBWAuu +EOcLKvbdkDMKpgUg +DoDLKvbdZshiYdSn +EPDLKvbdhfjCyWKV +EObjjvbdKRZeOeme +DoCkKvbdznopdcLx +EPCkKvbdZMSDsnMN +DnbkKvbdkWWmcbXw +EObjjvbdpxoHfqEY +DnbkKvbdtlYXAsaX +EPDLKvbdjvXNcaww +EPDLKvbduDDVXVoP +DoDKjvbdLGFgbBQu +EObjjvbdmuUzLKRf +EObjjvbdRaceMIyL +EPDLKvbdiHKCyVjV +DoCkKvbdxnTHwriD +EOcLKvbdZjTIPgCG +DncLKvbdBcpBVjNG +EPDLKvbdVwIxVceH +DoCkKvbdkIGkeemk +DnbkKvbdozmdKxPA +DoDKjvbdjuwNdCXw +DoCkKvbdeEoSCXCj +EPCkKvbdcScKtEJa +EPDLKvbdySnIlrBg +EPCjjvbdnQZyVkYb +DoDLKvbdqYnggREY +EObkKvbdBsBDUGXS +DnbkKvbdUWLoitAq +DoCkKvbdIGgZxxYH +DoDLKvbdvwLaWBVu +EObjjvbdmfeXlnHZ +EPDLKvbdRXNdDMID +EPCjjvbdZLrDsmkm +EOcKjvbdUQpoUuHm +DnbkKvbdEzsqFMDJ +EOcLKvbdQlwayOUz +EPDKjvbdyzdnRhJI +DoDLKvbdwzHfGXeS +EOcKjvbdTvMPitBR +EOcKjvbdJbicRJcY +DoDLKvbdFVxpQNJe +DoDLKvbduLxXBTaX +DoCjjvbdLYpirzuG +DnbjjvbdvwMAvBWV +EPCkKvbdBiKbKiFj +DncLKvbdIryArmYM +DncKjvbdySmiNRag +DncKjvbdeEoRbWbj +DoDLKvbdjuwOECXw +EPDLKvbdFWZPomJe +EObkKvbdjcMLRGtg +DncLKvbdQwNccMHc +EPDLKvbdzQoMiJwA +DoDKjvbdmSYtzSdJ +EOcLKvbdelfWgMjL +EOcLKvbdiMFENuCy +EPCkKvbdezvZEhsw +EPDLKvbdUVlPisaR +EPDKjvbdbKlGOmcA +EObkKvbdzGyMANEw +DoDKjvbdXFxzUAPT +EPDLKvbdqrUkNkAm +EOcKjvbdPxmAGsSK +EOcLKvbdyfyMAMeX +EObjjvbduDDUwVoP +DncLKvbdyYJJbQZk +DoDLKvbdxVNEqYkn +EPCjjvbdNPxRWOHT +EObkKvbdYqNEiNEq +EPDKjvbdXrlAlsoY +EPDLKvbdbrcKtEJa +EObjjvbdGdKvJbJj +DoCjjvbdrDeJPnVa +DoDKjvbdZLrETnMN +DoDKjvbdKVuGDeGi +DoCkKvbdZtJIyETO +EObjjvbdYSlAlsoY +DoDLKvbdCSaDUGWr +EObjjvbdmfeYNNgZ +DoDKjvbdtumwiqTA +DncKjvbdqFdEtWAh +EPCkKvbdauCHXjtI +DnbjjvbdvOszqKoU +EOcKjvbdxrnImSBg +DoCkKvbdjvWmdBww +EPCjjvbdmuUzKiqf +EObjjvbdNdcsiIjd +EOcLKvbdNPxRVnGs +EObkKvbdSPsgKFdX +EPDLKvbdVAbQsQqy +EPDKjvbdVZHsyjoO +DncKjvbdJzofXdAN +EObkKvbdFjeTChNV +DnbjjvbdjJegjNXr +DnbkKvbdZLrDsnLm +DnbjjvbdbAueGQQX +DncLKvbdQcbaQQdS +DnbjjvbdFjdrbglu +DncLKvbdAMgxsWyx +DnbjjvbdRpUHKGDw +DncLKvbdMfcPlpVL +EObjjvbdIwtBhMRQ +EPCkKvbdelfXGmKL +DoDLKvbdFkErbhMu +EPCjjvbdHffyyYXg +DoDKjvbdOEctJIkE +DoCkKvbdKkAgvAKZ +EObjjvbdzitopDsU +EPCjjvbdRpUHJfEX +DoCkKvbdZLrDtNkm +EPCkKvbdijGIKNXr +DoCjjvbdxUmEpxlO +DnbjjvbdIxTbIMRQ +EPCkKvbdMfbpMotk +DncLKvbdjlbLzFGo +EObkKvbdrRtkNjaN +DnbkKvbdRosgKFcw +EPDLKvbdpfDeUWAh +DnbkKvbdkxsRryHU +EPCkKvbdkVvmcbXw +EOcKjvbdhficZWJu +EPDKjvbdCEQBWKMf +DoCjjvbdUyITzKoO +DnbjjvbdaNKbStmH +EPDLKvbdFWYpQMie +EObjjvbdhytekqNf +EObjjvbdeXyssqez +DnbkKvbdLAjgNCYR +DncKjvbdSBdFLiZL +EPDKjvbdBhkBjiGK +DoDKjvbdmajWxOmu +DoCjjvbdrMzJyMHi +DoDKjvbdZLqctOMN +EOcKjvbdnPzYujxb +DncKjvbddoFTKstS +DncLKvbdjcMLRGuH +DoCkKvbdbUagYKtI +DncLKvbdVAaqTRSZ +EPCjjvbdOEdTiJLE +EPCjjvbdJvUfEFHJ +DnbjjvbdIryBTNYM +EPDKjvbdYpleJNEq +DncKjvbdZGwEAOri +DncLKvbdBdQAvJmG +DoCkKvbdmIdTqUqa +EPCkKvbdtcCuWuno +EPCjjvbdmuUyjjSG +DncLKvbdjAQHApHK +EPCjjvbdGdKujBjK +EPDKjvbdYkrETmlN +DncKjvbdYORAYUut +DnbkKvbdiHKCxvJu +EPCjjvbdkHgLfGOL +DoCjjvbdpssfqqkU +EPDKjvbdZnmheEzK +EPDLKvbdySmhlrCH +EPCkKvbdjJegilxS +DoCkKvbdqcdhpNua +EPDKjvbdIHHZyXxH +DnbjjvbdjmBkydgP +DoCjjvbdYkqcsnLm +EPCkKvbdZnmhdeZj +EPDLKvbdDjIJuwjA +EOcLKvbdnQZxvKyC +EPCkKvbdBhkCKiGK +DnbjjvbdYkrDsnMN +DncLKvbdyzeNqghh +DncLKvbdrRuKmjaN +EPCjjvbdssRsYzEc +DoDLKvbdZQleJNFR +EObjjvbdZQleJMeR +EPDKjvbdtvNxJqTA +EObjjvbdbBWFGPpX +EPDLKvbdajkeoODA +EPDLKvbdSZihTCvA +EObkKvbdZMRdTnMN +EPCkKvbdsCFmLgKy +EObjjvbdVvhxVceH +EPCkKvbdaaVeFpQX +DoCjjvbdZQmEhleR +EOcKjvbdhzUfLpmf +EPCkKvbdREDBQRDr +DncLKvbdemFwHNJk +EOcKjvbdGAnqYizm +DncLKvbdtTRsZZdc +DoDLKvbdGGKRmhtR +DoDLKvbdIidAJogE +DoCkKvbdxZhGFxEr +DncLKvbdpxoHgREY +DnbjjvbdQcbaQRES +EPDKjvbdjAPfaPgK +EPCkKvbdvwMAuaWV +EOcKjvbdZLrDsnMN +DncKjvbdyqOlhiwA +EObkKvbdRacdkiYk +DoDKjvbdUWMQJsaR +EPDKjvbdUGzmkvvF +DoCjjvbdhbPDFXRR +EObjjvbdXGZZtAPT +EPCjjvbdMoxRWNgT +EOcKjvbdGFiqmhtR +DoCkKvbdNPxRWNgT +EObkKvbdyNrgxTJD +EPDKjvbdrXPkcJYq +EOcLKvbdFjeTChMu +DncKjvbdjvXNcaww +DncKjvbdkMbMZdgP +EOcKjvbdDnbkLXDE +EObjjvbdbBWFGPow +DoCjjvbdAMhZSwZx +EPDLKvbdZRNEiMeR +DoDKjvbdqdEiQNvB +DoCkKvbddePRavbj +EPDKjvbdaMjbStlg +EObkKvbdHgGyxxYH +EOcKjvbdtkxXBUAw +DnbjjvbdmSZUysEJ +EObkKvbdrXQLbhxq +EObkKvbdVTlsfMWK +DoDKjvbdSLZGUfjs +DoCkKvbdFVyPpMjF +DoCjjvbdhgKCyViu +EPCkKvbdZMSDtOLm +EPCjjvbdySmhlqag +EPDKjvbdWRmwadlD +EPCjjvbdqZPHfpdY +DoDLKvbdXsMBMsoY +DncLKvbdelewHMjL +EObjjvbdYpleImEq +DoDKjvbdZirgogBf +EOcLKvbdrXPlChxq +EPCkKvbdFVxpQMie +DoCkKvbdrNZjZMHi +EOcKjvbdDjIJuxKA +DncLKvbdeOeSkTsr +DoCjjvbdZoNhddyj +DoDKjvbdkWXNcaxX +DoDLKvbdTpqOtthN +DnbjjvbdehKuqnQg +EPCjjvbdmgFXlmfy +DncLKvbdShyiqAAl +EOcKjvbdKaKgNBwq +EPDKjvbdEztREkbi +EOcKjvbdVviXvEFH +EPDKjvbdcIlikGWx +EPCkKvbdUWLojUAq +EPDLKvbdOStWHEtp +DoCjjvbdHlBzmwRL +DnbjjvbdWIYVxHYz +EPDLKvbdADSXjZhp +EPDKjvbdRzJgrcWA +EObkKvbdxrnIlqag +EObjjvbdRosgKFcw +DoDKjvbdkySrTYgU +DncKjvbdsrqrxydc +EPDLKvbdZyEKODLr +EPCjjvbdEXxMUUTl +EOcKjvbdtcCtwWOo +DncLKvbddndrkTtS +EPDKjvbdrafMkfjy +EPCjjvbdJcJbpibx +EObkKvbdFfJqnIsq +EPCkKvbdyNsHwriD +DoCjjvbdaRebgsfL +DnbjjvbduoTzpjnt +EPCjjvbdZGvdAOsJ +DoDKjvbdmozYujyC +EPDKjvbdZGvdAPSi +DnbjjvbdmSYtzTDi +DoCjjvbdRotGjFdX +EObkKvbdSBceLhxk +DoCjjvbddijRvUzn +EObkKvbdMgDQNPtk +DoCkKvbdFVxoomKF +DncKjvbdGcjujBjK +EPDKjvbdBcpAvJlf +DncLKvbdLBLHNCYR +EObkKvbdmIctQtrB +DoDLKvbdFpATXGey +EPCkKvbdbrbkUDjB +DncLKvbdcTCjtEJa +DncLKvbdBsAbsfXS +EPDKjvbdFpATXGfZ +DoDKjvbdwuMeQxlO +EObkKvbdqUUGqrKt +DncKjvbdZyEKODLr +EPDKjvbdjhHLefNk +EPCkKvbdrbFmMGjy +DoCkKvbdsQWOjCvG +DoCjjvbdLBLHMbXq +EObjjvbdrpVnicVf +EPCjjvbdVqmwaeMD +DncLKvbdRNYCYnUz +EObjjvbdRXNdCkhD +DncKjvbdIHHZyYXg +DnbjjvbdyTOJMrCH +DoDLKvbdUsmUFkuj +DncKjvbdQcbaPqES +DnbkKvbdmgFYNNgZ +EOcKjvbdkySrTYgU +DoCjjvbdHlBzmwQk +DnbjjvbdaSFcITek +EObjjvbdQdCaPqDr +DncKjvbdxVMdpyLn +EOcKjvbdiMEdOVCy +DoCjjvbdRosgJecw +DncLKvbdkDMLQftg +EPCkKvbdKDKCqKDY +DoCjjvbdjvWnDaww +EOcLKvbduVnYJpsA +DoDLKvbdWRnYBdlD +DoDKjvbdssSSxzFD +EPDLKvbdJYTaglRQ +EOcLKvbdhzUfLpmf +DoDLKvbdJutfDdgJ +EOcKjvbdxmrgwrhc +EObkKvbdwWkaVaVu +EOcKjvbdxrmiMrBg +DoDKjvbdRDcApRES +DoCjjvbddjJrVtzn +EOcKjvbdxVNEqYlO +DoCjjvbdJJdAJofd +DoDLKvbdemGWfmJk +EOcKjvbdnPyyWKyC +DoCjjvbdbrcLTcia +DoDKjvbdjuvmdCXw +DncLKvbdtkwvaUAw +EOcKjvbdHDkViaij +EObkKvbdRDbaPpcr +EOcLKvbdtSqryZeD +EOcKjvbdrRuLOKaN +EOcKjvbdczYowyRC +DnbkKvbdjcMLQfuH +DncKjvbdmbJwYOnV +EPDLKvbdZnmiFEzK +EPDKjvbdjbkkQgVH +EObkKvbdJTZArmYM +DncKjvbdSPsgJfEX +DncLKvbduMYXBUBX +EObkKvbdkIHMFfOL +EOcKjvbdYORAYVWU +DoCjjvbdyzdmqghh +DncLKvbdtumwiqTA +EPDKjvbdQmYCZOUz +DoCjjvbdtcCtvvPP +EObjjvbdVTmUGMVj +EObkKvbdBsAcUGXS +DoCjjvbdqYngfqDx +EPCkKvbdtkxXBTaX +DoDLKvbdACqwiyhp +DncKjvbdraelkgKy +EPDKjvbduLwvaUBX +DncKjvbdpssgSSLU +EPCjjvbdIxTbHlRQ +EPDKjvbdPyNAGrqj +DoDLKvbdnCJvxOnV +EObkKvbdZRNFJNEq +DoCjjvbdFxuVBEYC +EOcKjvbdVAbRSpqy +DnbjjvbdJbibqKDY +DoDLKvbdKCicQjCx +EPCjjvbdNrtVgFUp +EOcLKvbdZQleJNEq +DoDLKvbdaRebgsfL +DoCkKvbdCIjakIej +EOcLKvbdBraDUGWr +EPDLKvbdADRxKZiQ +DoCjjvbdHkazmvpk +EPDKjvbdUsltGLvK +EOcKjvbdTkvOaVoJ +DncLKvbdZnmiEdyj +DoDKjvbdZtJJYdSn +DoDLKvbdbiNJjfWx +DnbjjvbdIsZBTNYM +EPCkKvbdhbPDEvpq +DncKjvbdqlyjYlIJ +DoCkKvbdbsDLTcia +DoDKjvbdKCjCqKCx +DoDLKvbdnBiwYOmu +DnbkKvbdjKGIKMwr +EPCjjvbdHgGyxxYH +EOcLKvbdcyxpXxqC +DncLKvbdlZSrSyGt +EPCjjvbdTAFIhCPE +EObkKvbdZdwfzgiC +DoDLKvbdSLYfUgLT +DoCjjvbdRMwayNtz +DnbjjvbdCflGHAzc +DoCjjvbdrJAKFNOe +EPCjjvbdjblKpgUg +EPDLKvbdQccAoqDr +DnbjjvbdCJKbKhfK +EPDLKvbdiGibyWJu +EOcLKvbdyNsHxShc +EPDLKvbdmIcspuSB +DnbjjvbdnGdxNOHZ +DoCkKvbdhzVGMRNf +DoDLKvbdeFPRawDK +EObjjvbdsQWOjCvG +EObkKvbdhzUelQmf +EObkKvbdeJirWUzn +DncLKvbdxxIibPzL +EObkKvbdSBceMIxk +DoCkKvbdehKvRmqH +EObjjvbdRbDeLiZL +EObjjvbdGYtuAdYC +DnbjjvbdHDkVibKK +DoCjjvbdKQyeOfNe +DoCkKvbdmbJvxOmu +DoCkKvbdULvOaWPJ +DncLKvbdrWpMCiZR +EObjjvbdhytfLqNf +DoCjjvbdgPazvdXh +DoCjjvbdiHKDYuiu +EPDKjvbdRWnDbkhD +DncLKvbdrMzKZLhJ +EObkKvbdyXhiaoyk +EPCkKvbdjmCLydfo +DnbkKvbdDxYMUTsl +EPDKjvbdxmrgxSiD +DnbkKvbdmSYtyrci +EPCjjvbdqvokcIxq +DoDLKvbdXsMAmUPY +DncKjvbdDoDKkWcE +EPCkKvbdMgDPmQUk +DoDLKvbdKyQirztf +EPCjjvbdmajWwnmu +EOcLKvbddCSlrATm +EPDLKvbdrJAKElne +DoCkKvbdIsZBTMxM +DnbkKvbdffMZnGgA +EOcKjvbdJcKDQjDY +EObjjvbdxsOJMrCH +EObkKvbdEKHiuwjA +DncKjvbdunszpjnt +DoDLKvbdZjTIQHCG +DnbjjvbdsQVnibvG +DnbkKvbdGQATXHGZ +DnbkKvbdBsBDTfXS +DoCkKvbdBsAbsevr +DoCkKvbdRXNdDLhD +EPCjjvbdRadElJZL +DnbkKvbdxwhibPzL +EOcKjvbdCJLBjiFj +DncLKvbdZMSDsmkm +DoDKjvbduaEZSoFI +EPCjjvbdhgJbxujV +EOcLKvbdCJLBjhfK +DoCkKvbdZisHpHBf +DoCkKvbdqFdFUWBI +EPCkKvbdDGlFgAzc +DncKjvbdZxcjNblS +EPDLKvbdLqvmZuQz +DoDKjvbdxZhGFxFS +EObkKvbdZdxGzhIb +DoDLKvbdqwQMChyR +DoCkKvbdjlalZeGo +DncKjvbdZRNEhldq +EPCkKvbdZHXEAPSi +DoDKjvbdDoDLKwCd +DnbkKvbdmbJwYPNu +DncKjvbdMfcPlouL +DoCkKvbdQwODblHc +DoCjjvbdNQYQunGs +DnbjjvbdlqxtzSci +EOcLKvbdrDdhpNua +DncLKvbdKefICApu +EPDKjvbdatagXkUI +DoCjjvbdaofgDkzd +EObkKvbdIrxaTMwl +DncLKvbdSLYfVGkT +EPCkKvbdelevfmKL +DncKjvbdFfKSOIsq +EObjjvbdfILVqnQg +DncLKvbdZjShPgCG +DoCjjvbdrNZixlHi +DnbkKvbddoFTKstS +EOcKjvbdWSNwbFMD +EPDLKvbdpxngfqDx +EOcKjvbdIHGyxxYH +EOcLKvbdvwMAuaVu +EOcKjvbdkxrqryGt +DncLKvbdZjShQHBf +DnbjjvbdiUzEvquC +EObkKvbdpxoHfpcx +DoCkKvbdGAoRZJzm +EOcKjvbdehLVrOQg +EPDKjvbdkDMLRGuH +DnbkKvbdKCjDRKDY +EPCjjvbdLGFhBaRV +EPDLKvbdaMjbSuNH +DncKjvbdWfYzUAOs +DoCjjvbdsBelkfjy +DncLKvbdZnmheFZj +EOcLKvbdatagYLUI +EObkKvbdWXJXvEEg +DoDKjvbdZMRdTmlN +EPCjjvbdWXIwvEEg +DoCjjvbdkCkjqHUg +EPCjjvbdijFhJlxS +EPDKjvbdmSZUysEJ +DoDKjvbdMgDQMouL +EPCkKvbdrDdhomvB +EPCjjvbdRNXbYmtz +EPCkKvbdUtMtFlWK +DnbjjvbdGcjvJajK +EPDKjvbduaDyTOeI +DncLKvbdziuPocrt +DoCjjvbdcScKscjB +DncKjvbdmgExMmfy +EObjjvbdJcJcQibx +EPDKjvbdMpXpvNfs +EObkKvbdyqPNIjXA +EPCjjvbdCSaDUGWr +EOcKjvbdZnnJFEyj +EObkKvbdyOSgwriD +EPCjjvbdtkwwAtBX +DnbkKvbdDncLLXDE +EOcKjvbdZshhxcsO +DoCjjvbdxVMdpxlO +DncKjvbdLGGHaaQu +DoCkKvbdxUmFQyMO +EPDKjvbdpfEEsvAh +DoCkKvbdZRMdhldq +EPDLKvbdYzberJuy +EObjjvbdfHkWSOQg +EPDLKvbdRMxByNtz +DncLKvbdmoyyWLZC +EObkKvbdhtydvrVC +DoCkKvbdVhYWYGxz +EPDKjvbdbVCHXjsh +EPCkKvbdTlWPBVni +DncLKvbdFkEsCgmV +DnbkKvbdIsYaSlxM +DncKjvbdzaAOffbM +DncLKvbdaSFcHtGL +DoDLKvbdiGjDYuiu +EObjjvbdDigjVwjA +DncKjvbdqmZixlIJ +DnbkKvbdRjxfUgLT +EObkKvbdeAURNYKG +EPCjjvbdjvWnECXw +EPCjjvbdNQXqVmgT +DoDLKvbdxmsHxShc +EPCkKvbdqwPlChxq +DnbjjvbduLwwAsaX +DncKjvbduCbuWuno +DnbkKvbdJpydnenF +EPDLKvbdRXOEClID +DncKjvbdSKyFuGkT +DncKjvbdczZQYZRC +EPCkKvbdGZUtaDxC +EPCjjvbdOAJTUKSA +DnbkKvbdsZlQSaHn +DncKjvbduWNwiqTA +DoDLKvbdRNYCZOUz +DoCkKvbdVTmTfMVj +EOcLKvbdeATpmYJf +DncKjvbdbUbGxKsh +DnbkKvbdLZRKSztf +DncKjvbdcJMjLFwY +DnbkKvbdRadEkhyL +EPCkKvbdauBgXkTh +EObkKvbdrJAKFNOe +EOcKjvbdDnbjkXDE +DoDKjvbdrafMlGjy +EOcLKvbdliDtRVRa +EObjjvbdZjShQHCG +DnbjjvbdZnmiFEyj +EPDKjvbdbAueFpQX +EPCjjvbdVwJYVcdg +EObkKvbdijGIJmYS +DoCjjvbdJpyeOenF +DoDKjvbdYlSDsnMN +DncLKvbdehLVqmqH +DnbjjvbdTppnuVHm +EOcKjvbdSLYetgLT +EPCkKvbdZyEKOClS +DoDKjvbdHDjujBij +EPCkKvbdHkazmvpk +EObkKvbdkxrrTYft +EPCjjvbdOTUVfeVQ +DoCjjvbdYzbfSKWZ +DncKjvbdkxrrSxgU +EObjjvbdEOcKkXCd +EPDKjvbdcTCkTcia +DoDKjvbdatagXkTh +DoDLKvbdNHCpMpUk +DoDKjvbdhtzEvquC +EPCjjvbddePSBvbj +DoDLKvbddneTLUUS +DncLKvbdijFhKMwr +EPDLKvbdpxoIHRDx +DncLKvbdqquLOKaN +EPCkKvbdSCEEkiZL +DoDLKvbdvAdYroEh +DncLKvbdDwwksstM +EOcKjvbdKWVFcdgJ +EPDKjvbdZnmhdeZj +DoCjjvbdJSyBTMxM +DoDLKvbdtcDVXVoP +EOcLKvbdbAudfPow +EPCjjvbdpfDdtWAh +DncKjvbduCcUwWOo +DnbjjvbdGFirOItR +DnbjjvbdLBKgNBxR +DnbjjvbduVnYJpsA +DnbjjvbdjuvnDbXw +DoDKjvbdFkFTDINV +EOcKjvbdEvZQQMie +DoCkKvbdMfbolpUk +EPCjjvbdhbPCdwQq +DoDKjvbdZyEKNblS +EPCjjvbduCbtwWPP +DnbjjvbdgLGzbfAE +EObjjvbdqGDdsvAh +EPDLKvbdNGbolotk +DoCkKvbdSPsfifEX +DncLKvbdbVCGwjsh +EObkKvbdijGHjMwr +DnbjjvbdRosfifDw +DoCjjvbdQccApRDr +DoDKjvbdqTtHSSKt +EOcLKvbdsQWPJcVf +EObkKvbdeOdsLTsr +DncLKvbdcTDLUDjB +DoDKjvbdVgwvXfxz +EOcKjvbduoTzqKnt +EPCjjvbdYNqAYVWU +EObjjvbdemGXGmJk +DoCkKvbdVgxWXfxz +DoCjjvbdqlzKZLgi +EPDLKvbdLFfHaaQu +DnbkKvbdcSbkTcjB +EObjjvbdgGLzNgHA +EObjjvbdZjSgpGbG +DnbjjvbdGckVjBij +EOcLKvbdUMVnaWOi +EObkKvbdrylQSaHn +EPDLKvbdZHWdAOri +DoDKjvbdyfxlAMdw +DnbjjvbdZMSDsnLm +DoDKjvbdOTUVgEtp +DnbkKvbdJSxaSlwl +DncKjvbdkNCLzFGo +DoDKjvbdfMevgMik +DnbjjvbdMgDPlpVL +DncKjvbdqquLOLAm +DoCkKvbdfNFwGlik +DncLKvbdpxnhHRDx +DoDLKvbdZMRdTmlN +EPCkKvbdURRPVVHm +EPCkKvbdmgEwmOHZ +EOcLKvbdVAapsRSZ +DoCjjvbdczZPwxpb +EPDLKvbdWXIxWDdg +EPCkKvbdUVlQJtBR +EOcKjvbdelfWgNJk +EPDKjvbdUtMtFkuj +DnbjjvbdRkZFtfjs +EObkKvbdCJLCLJGK +DoDLKvbdKVuGEEgJ +DncKjvbdIxTbHkqQ +DncLKvbdMSWlzUpz +EPCkKvbdKefICAqV +EOcKjvbdtunXjRTA +DoDLKvbdZMSETmlN +EObkKvbdapHHELzd +EObkKvbdmRxtyrdJ +DoCjjvbdtTSSxzEc +EObjjvbddeOrBvbj +DncLKvbdJYUBgkpp +EPCjjvbduLxXBUAw +DnbjjvbdSLYetfjs +DncKjvbdzQnmIiwA +EPCjjvbdRpUGjFdX +EOcLKvbdddnqbWcK +EOcKjvbdWWhwucdg +EOcLKvbdCWzdJEov +EPDKjvbdTkuoAuni +DncLKvbdqUTgSSLU +DoDLKvbdNHDQMotk +DncLKvbdWXJXvEEg +EPCjjvbdaNKaruNH +EPDLKvbdraelkfjy +DncLKvbdLqvmZtpz +DnbjjvbdNddThhkE +DoDKjvbdzoQQdcLx +EPDKjvbdYpldiNFR +EObjjvbdZtJIyDsO +DoCkKvbdWWiYWDeH +DoCkKvbdeEoSBwDK +DoCjjvbdBsAcTevr +EObjjvbdqvpMChyR +EPCjjvbdsCGMlHKy +DnbkKvbduLwwAtAw +EObkKvbdMRwMyuQz +DncLKvbdwWlAuaWV +DncLKvbdHgHZxwxH +DncKjvbdBsAcTewS +DoDLKvbdJpyePFme +DncKjvbdVUNUFlWK +DncKjvbdEYXktTtM +DncLKvbdwMvANDeN +DnbkKvbdtSrTZZeD +EOcLKvbdJYUBhMRQ +DncKjvbdlYrrTZGt +DoDLKvbdliDsqUrB +EObjjvbdegjuqnQg +EObjjvbdlZSrTZHU +DncLKvbdfNGWfljL +DoDLKvbdLFegbBQu +DncLKvbdemGXGmKL +EPDKjvbdDwwksssl +DnbjjvbdxmsIYTJD +DoDLKvbdBsBCtGWr +DoCjjvbdIsYaTNYM +DncKjvbdJuuGEEgJ +EObkKvbdkySqsYgU +DnbkKvbdNPwqWNfs +EPDLKvbdmIdTptrB +DoDLKvbdyqOmIjXA +EPCjjvbdhkeEOUcZ +DoDKjvbdJqZePFme +EPDLKvbdfSAvzlCo +EObjjvbdbhljLFvx +EOcLKvbdaMkBsUmH +DoCjjvbdKyRKSzuG +EObjjvbdcSbjtEJa +EOcLKvbdkHflGFmk +DoDLKvbdemFwHMjL +EObjjvbdSLZGVHLT +DoCjjvbdJXtCILpp +EOcLKvbdaaVdfPow +EOcLKvbdFpATWgGZ +DoCjjvbdxZgeewdr +EObkKvbdeEnqawCj +EObjjvbdhytfMQmf +DnbjjvbdoznEKxPA +DnbjjvbdoAKzsgdO +DoCkKvbdYzbfRivZ +DoDLKvbdqqtkOKaN +DncLKvbdqvokcJYq +EPDKjvbdOStVfeUp +DoDKjvbdZxcinDLr +DoCkKvbdcyyQYYqC +EObkKvbdcIlikGWx +EOcLKvbdffLzNgHA +EPCjjvbdMtsRkNAX +EOcKjvbdpeceTvBI +EOcKjvbdZsiIxcsO +DncLKvbdJvVGDdgJ +DnbkKvbdZMRdTmlN +EPDLKvbdnCJwXnnV +EObkKvbdxUldqZLn +EPCjjvbdNddUJIkE +DoCjjvbdyYJJapZk +DnbjjvbdpxoHgQcx +EObjjvbdHDjvKBij +DncKjvbdUtNUFlWK +EPCkKvbdkVvmdBww +DnbjjvbdgGMZmgHA +DoDLKvbdmIdTqVSB +EOcLKvbdzitpPdTU +DncLKvbdkxrqrxgU +DoCjjvbdVBBpsRSZ +EOcLKvbdGFiqmiTq +EOcKjvbdxsOJMqag +DoCkKvbdHDkVjCJj +EPDKjvbdjSziTKiz +EOcKjvbdCTAbsewS +EPCkKvbdkWWnDbYX +DoDLKvbdJSxaTMxM +DoDLKvbdMoxRWNgT +DoDLKvbdmuVZkJrG +EPDKjvbdbUbHXjtI +DnbjjvbdkWWnEBxX +EOcLKvbdnPyxukZC +DnbjjvbdXrlBMtOx +DoDLKvbdJuuGEFGi +EPDKjvbdUaBprprZ +EObjjvbdsrqrxydc +EObjjvbduCbtwWOo +DoCkKvbdSLYeuHLT +DoDKjvbdKQyePFme +EOcKjvbdeYZssrFz +DoDKjvbdpxoHfpdY +EPCkKvbdcIljKfXY +EPDKjvbdDwwksstM +DnbkKvbdsQWOicVf +EPDLKvbdIidAKQHE +DoDLKvbdrDeJPnWB +EOcLKvbdZoNiEeZj +EObjjvbdptTgRrLU +EPDKjvbdmRyUzTEJ +DoDLKvbdFxtuBEYC +DnbkKvbdehLVqmqH +EPCjjvbdUtNUGLuj +DoDLKvbdxVNEqZLn +DncKjvbdySnImRbH +DoCjjvbdbLMGPNcA +EPCkKvbdzQoMiKXA +DnbkKvbdbiMijevx +EOcKjvbdSQTfiedX +DnbjjvbdZisIQHBf +EObkKvbdYpleIldq +DncLKvbdjmBlZeHP +DncKjvbdSCDdkhxk +DnbkKvbdrykpTAgn +EObkKvbdZQldiMeR +DnbjjvbdeYZssqez +EPDLKvbdlYrrSyHU +EOcLKvbdTpqOttgm +EOcKjvbdCJLCLIej +EPDKjvbdUQqOttgm +EObkKvbdGBOqZJzm +DncKjvbdqwQMDIyR +EPDKjvbdbBWFFoow +EOcLKvbdZMRctOLm +EPCkKvbdHEKuibKK +DnbjjvbdNddThiKd +DncKjvbdJuuFdEgJ +DncLKvbdRzJgsDWA +DncLKvbdRWmdCkhD +EPCjjvbdZRNFImEq +EOcLKvbdUaBqTRSZ +EObkKvbdWIXvYGxz +DoDKjvbdrRuKnKaN +DoCjjvbdYgXEAPTJ +DoCkKvbdwuMeQyMO +EPDLKvbdkHfkfFmk +DoDKjvbdTqQnuUhN +DoCkKvbdbKlFoODA +EObkKvbdrzLoraIO +DncLKvbdFxuVAdYC +DoCjjvbdZQldiMeR +EOcKjvbdJTZBTNXl +EPDKjvbdsQWPKCvG +EOcLKvbdeEoRawDK +EPDLKvbdtTSSxzEc +DncLKvbdliDsqUqa +DnbjjvbdZQleImEq +EPCjjvbdaSGDITek +DoDLKvbdRWnDbkhD +EPDLKvbdpedEsvAh +EPCkKvbdYpldhldq +DoCjjvbdZoOJEdyj +EOcLKvbdmoyxvKyC +EObjjvbdmSZVZsEJ +DoDLKvbdqUUGrSLU +EPDLKvbdmpZxujyC +EPCjjvbdCDpBVilf +EPCjjvbdFfJrNhsq +DoDKjvbdsZkosBIO +DnbjjvbdiBnbdvpq +DncKjvbdkDMKpftg +EPCkKvbdatbGxLTh +DoCjjvbdJTYaTNXl +DnbjjvbdhkdcnVCy +DncLKvbdyNrgxTIc +EPDLKvbdyNsHwriD +EPDLKvbdBdQBVilf +DoDLKvbdIsYaTNXl +DnbkKvbdkxsSTZHU +EPCjjvbdBsBDUGWr +EOcLKvbdgQBzwDxI +DnbjjvbdjblLQfuH +DnbkKvbdbVBgYKsh +DncLKvbdMgComPuL +EPDLKvbdqceIpOVa +DnbjjvbdqFceTvAh +EPCjjvbdFWYpQNJe +DoDLKvbdHDjujBjK +DncLKvbdIHGyyXxH +DnbjjvbdeFOqawCj +DoDKjvbdGQASwGfZ +DncLKvbdrWokbhyR +DncKjvbdSKyFtfkT +DoCkKvbdemFvfmKL +EPDKjvbdxsNhmRbH +EOcKjvbdsPunicVf +EObjjvbdrbGNMGjy +EPDLKvbdOXoVzcnU +EOcLKvbddZxpYYpb +DoDKjvbdVBBpsRRy +EPDKjvbdHDkWKCKK +DoCkKvbdSiZjRAAl +EPDKjvbdURQoVVHm +DoCkKvbdpyPHgQdY +EOcKjvbdGAoQxizm +DnbjjvbdMpXpvNfs +DncKjvbddndrjtUS +DnbkKvbdlhcsptqa +DoCkKvbdfNFvfmKL +EPCkKvbdHffyxxXg +DoCkKvbdYpleImFR +DoCkKvbdbBVdfPpX +DncLKvbdWSNxBdlD +EPDKjvbdSQTfjFcw +EPCjjvbdkxrqsYgU +EPDKjvbdrovOjCvG +DoCjjvbdaSGCgsek +DncLKvbdZGwEAOri +DoDLKvbdJmADzHUa +DoCjjvbdNdcshiKd +DoCkKvbddneTLTtS +EObkKvbdMoxQumfs +DncKjvbdVgxVwfxz +DoDKjvbdGcjuibKK +EObkKvbdTqQnuUhN +DncKjvbdURRPUuIN +EObkKvbdbrbjtEJa +DnbkKvbdKQyeOenF +EObjjvbdbKkfOnDA +EPDLKvbdlhdTptrB +EObjjvbdxnTHxTJD +EObjjvbdKCjCpjDY +DoDLKvbdMSWmZtpz +DoCkKvbdBsBCsfXS +DnbkKvbdfRaWzkcP +EPDKjvbdbAvFGQQX +DoCjjvbddoFSjtUS +DnbjjvbdypoNJJwA +EPDKjvbdzdzOzdyp +EObjjvbdJpzEoFme +DoCkKvbduCbuXWPP +EPCkKvbdFfJrOItR +DoDLKvbdkIGlFfOL +DnbjjvbdbAudfPpX +DoDLKvbdtAHRIABS +EOcLKvbduDCuWuno +DoDKjvbdkHgLfGNk +EOcLKvbdxZhFeweS +EObkKvbdUxgszKoO +EOcKjvbdiBoCeXRR +DnbkKvbdZeXfzhJC +EObkKvbdtcDUvvPP +EOcKjvbdMtrrLNAX +DnbkKvbdWXJYVceH +DnbkKvbdJbjCpibx +EPCkKvbdajlFnnDA +DnbjjvbduaEZTPEh +EOcKjvbdGcjuibJj +DncLKvbdKefHbAqV +DoDKjvbdUxgtZjnn +EPCjjvbdVZITzKnn +EPDKjvbdHkaznXRL +DnbkKvbdOEdTiIkE +DnbjjvbdiGjDYvJu +DoDKjvbdnUtykJrG +EPCkKvbdBdQBWKNG +EPDKjvbdsBemLfkZ +EPCjjvbdtumwiqTA +EOcKjvbdnCKXYPOV +DncLKvbdVwIxVdFH +DnbjjvbdWIYWYGxz +EObkKvbdFpATXHFy +DoCjjvbdauBgXjtI +DnbkKvbdTqROuVHm +DnbjjvbdlhcsqUqa +EPDLKvbdxZhGGXeS +DoDLKvbdZjTHogCG +EOcKjvbdbKlGOnDA +EObjjvbdLiBlRYAS +DncKjvbdxrnJMrCH +EOcLKvbdMJBlRYAS +EOcKjvbdUsmTekuj +DnbjjvbdEYYMTssl +EObkKvbdZMSEUNkm +DncLKvbdGGKSNhsq +DoDKjvbdGZVVAdXb +EPDKjvbdKRZdoFnF +EOcLKvbdEXwlUTtM +DoDKjvbdEztQeLcJ +DoCkKvbdJYUBglQp +DoCkKvbdJTZAsNXl +EObjjvbdvmWAMdEm +EPCjjvbdxZgefYFS +DncKjvbdtTRrxzEc +EOcLKvbdiGjDZWJu +DoCkKvbdYlRctOLm +DncKjvbdDxXlTtUM +EPCjjvbdcyxpYYqC +EOcLKvbdqGDeUWBI +DnbjjvbdnPyxvLZC +DoDLKvbdKefHbApu +DoCkKvbdjblKqHVH +EObkKvbdTfzmkvue +EOcKjvbdZnmiEdzK +EOcKjvbdDxXkstTl +EPDLKvbdBdQAujMf +DoDKjvbdGZVVBDwb +DoDLKvbdEvZPpMie +EPCjjvbdVwJXuceH +DoDLKvbdRjyFtgLT +DoCkKvbdXsLaNTnx +DnbjjvbdDHLfHAzc +DoCkKvbdVBCQrprZ +DoCkKvbdyNsIYShc +EPDKjvbdyXiJbPzL +DoCjjvbdUsltFlWK +EPCkKvbdcyyQYZRC +DnbkKvbdddnqbWbj +EPCkKvbdmuUyjjSG +EObkKvbdZyDinDLr +DnbjjvbdZtIiZESn +EPCjjvbdVBCRTRRy +EOcLKvbdCWzciFPv +EObkKvbdrEFJPnWB +DnbkKvbdqUUHSRkU +EPDLKvbdlqyUyrci +DoCjjvbdIMBznXQk +DoCjjvbdUxgsykOn +EPCjjvbdXsMBMsnx +DncKjvbdjuvmdBxX +EOcLKvbdkIGkeemk +DoCjjvbdjKGIKNYS +EPDLKvbdSLZGVGjs +EOcKjvbdMfcPmQUk +DoCjjvbdrNZjYlIJ +EOcLKvbdkyTSTZHU +EObjjvbdjAQGaQHK +EPDKjvbdMoxRVnHT +EObkKvbdeATpmXif +EObkKvbdFjdsDHmV +DncLKvbdbLLfOmcA +EPCkKvbdunszqLOt +DnbkKvbdnQZxvLZC +DncLKvbdZyDjNblS +DnbkKvbdptTfrSKt +DoDLKvbdzaAOgHCM +EPCjjvbdhbPCeXRR +DnbkKvbdmuVZkKSG +DoCkKvbdziuQQESt +DnbkKvbdhgKDZWKV +DnbjjvbdULuoBWPJ +DncLKvbdWXJXucdg +DoCjjvbdRacdlJYk +DoDLKvbdegjvSNqH +EOcLKvbdnUtzLKRf +EOcKjvbdFxtuBEXb +DoCkKvbdmIcsqUrB +EObjjvbdULvPAvPJ +EOcLKvbdSwkLmzkY +EPCkKvbdSZjITCvA +EPCkKvbdeOdrjtUS +EPCjjvbdIxUBhLpp +EObkKvbdqiAJeMoF +DnbkKvbdhlEcmtcZ +EOcLKvbdFejRnJTq +EOcKjvbdwXMAvBWV +DoDKjvbdmpZyWLZC +DoCjjvbdGLErbhNV +DoDLKvbdmaivwnmu +EOcLKvbdOXoVzcnU +DncLKvbdBhjbLJGK +EPDKjvbdZjTIQGaf +DoCkKvbdgPazwEYI +DncLKvbdGGKRmiUR +EObjjvbdfHkWRmpg +DnbkKvbdXrkaNUPY +EPCkKvbdzQoMhiwA +EOcKjvbdrpWOjDVf +DncKjvbdZtJJZDrn +EPDKjvbdqZOggRDx +DnbjjvbdhgJbyWKV +DoDKjvbdiVZdwRuC +DoDKjvbdIwtCHkpp +DoDKjvbdVAapsRRy +EPDLKvbdwjvcgzzG +DoDLKvbdRyihScWA +DoDLKvbdrRuKmkAm +DnbkKvbdqGDdsuaI +EPCkKvbdAMhYrwZx +DncKjvbdSPsfjGEX +DncKjvbdczYpXxpb +DoDLKvbdkIHMGFmk +EPCjjvbdkClKqHUg +EObkKvbdxVMdqZMO +DoDKjvbdBdQBVjMf +EObkKvbdZjTHpGbG +EPDKjvbdTfzmkvue +EPCkKvbdLAjfmCXq +DoCjjvbdLGGHbApu +EPDKjvbdEzsqEkcJ +DoDKjvbdwygfGYFS +DoDLKvbdhgJbyWKV +EPDLKvbdZshiZETO +EPDLKvbdKWUfDdfi +DnbkKvbdqYoHgQcx +DncKjvbdnGeYMmgZ +EPDKjvbdKCjDRKDY +DoCkKvbdJcKDQibx +EObkKvbdZoNiFFZj +EPCkKvbdUyHsykPO +EOcKjvbdtvNxKQsA +EObjjvbdatafwjtI +DoDLKvbdhzVFkpmf +EObkKvbdMgComQVL +EPCkKvbdSCEEkhxk +DoDLKvbdgFlZnGgA +EObjjvbdZMSETnLm +EObkKvbdtumxKQsA +EObjjvbdZoOIddyj +EOcLKvbdqZOggQcx +EOcLKvbdKfFhBaQu +DncLKvbdzGxlANEw +EObjjvbdehLWRnQg +EObkKvbdEPCjkWbd +EObkKvbdqYnhHRDx +EObkKvbdjvXODaww +DnbjjvbdqTsgSRkU +EOcKjvbdTqQoVVHm +DnbjjvbdQmYBxnUz +DnbjjvbdpyOhGqEY +EOcLKvbdLGGHbAqV +EObkKvbdZirgpHCG +EObkKvbdqYnhGpcx +DncLKvbdrbGNLgKy +EObkKvbdkySrSxgU +EOcLKvbdeAUQlwjG +DncKjvbdkVwNdCYX +DoCjjvbdJvVGDeHJ +EPCkKvbdEuyPpNKF +EOcKjvbdDjHivXjA +DnbjjvbdkNCLydfo +EPCjjvbdZjTHogBf +DoDKjvbdGKeTDINV +DnbkKvbdJXtBglQp +DnbjjvbdFejSOIsq +EOcKjvbdhytelRNf +DnbjjvbdbBVdeopX +DoCkKvbdFjdsDINV +DoDLKvbdjvXNcbXw +DnbkKvbdZdxGzhJC +EPDLKvbdjAPgBQGj +EObjjvbdJXsbHkqQ +EPDKjvbdiVZdwRtb +EObjjvbdGFjSNiTq +EPDKjvbdznpQdbkx +EPCjjvbdemFvgNKL +EPDKjvbdWXIxWEEg +DncLKvbdEObkKvcE +DnbjjvbdLAjfmCYR +EPDLKvbdEXwkstTl +EObjjvbdFfKSNhsq +DncKjvbdygZMANFX +EPCkKvbdYqNFIleR +DoCkKvbdSKyGUgLT +DncKjvbdBdQBVjNG +DnbkKvbdbUagYLTh +EOcKjvbdsPunjDWG +DncLKvbdrEFIonVa +DncKjvbdaSGChTfL +DoCkKvbdcJNKKfXY +EObkKvbdULuoBWOi +DncLKvbdKWVGEEgJ +EPCkKvbdqFdEsuaI +EPDKjvbdAMgySvyx +DncLKvbdiUzEwRuC +EObjjvbdZoNheEzK +DnbkKvbdZLrETnMN +EObjjvbdKWVFcdfi +DoDLKvbdcScLUEJa +EPCkKvbdIwsbIMRQ +EOcKjvbdsBemMHKy +EOcLKvbdzitoodSt +EPDKjvbdrMyjZLhJ +DnbjjvbdaRfCgsfL +DoCkKvbdKQzEnenF +EOcLKvbdUGznLvue +DncLKvbdZxcinCkr +DnbjjvbdEuyPpNKF +DncKjvbdGFirOIsq +EOcLKvbdVqmxBeMD +EOcLKvbdwuMeRZLn +DnbkKvbdBhkBkIej +EOcKjvbdNQXpumfs +EObkKvbdVBCRTRSZ +DoDLKvbdZeYGzhJC +DncLKvbdREDBPqES +DnbjjvbdvBEZSoFI +EPCjjvbdakLeoNcA +EPDLKvbdeFOqbWbj +EPDLKvbdiGicZWJu +EPCkKvbdEKHiuwjA +EPCjjvbdwkWcgzyf +DoDKjvbdmpZyVkZC +EPCkKvbdSZihSbvA +EPDKjvbdelevfmKL +DnbjjvbdeATplwif +DoCjjvbdGAnpxizm +EPDKjvbdTlWPBWOi +EOcKjvbdmSYtzTEJ +DncLKvbdnGeXmNfy +DoDKjvbdTIzJqAAl +EOcKjvbdqdEiPnVa +EOcKjvbdcTCkUEKB +DoCjjvbdEvYopMjF +DoDLKvbdwuMdpyMO +EPDKjvbdEuyQPlie +EOcLKvbdVUMsfMVj +EObjjvbdijFgilxS +DoDKjvbdnPyxujyC +EOcKjvbdTAFIgbPE +DnbkKvbdZxdJnDLr +DncLKvbdqdEiPmua +EOcKjvbdhgJcZVjV +DnbkKvbdRbEFLhxk +DoDKjvbdmaivwoNu +DoCkKvbdZQmFJMdq +DncLKvbdeYZtTqez +EObkKvbdqYoIGpdY +DnbjjvbdEASJMyvw +DoDKjvbdwzHfGYFS +DncKjvbdjvXOECYX +DncLKvbdbBVdepQX +DoDLKvbdrEFIomua +DnbjjvbdYgWdAOsJ +EOcKjvbdkMakydfo +EPCjjvbdegkWSNqH +EPDLKvbdYlSEUNkm +EPDLKvbdzRPMhjXA +DnbjjvbdmSZUyrci +EPDKjvbdiiehKNXr +EPDLKvbdwzIGGXdr +DncKjvbdSLYetfkT +EOcLKvbdURROtuHm +EPDLKvbdEYYLtUUM +EOcLKvbdaSGDIUFk +DnbkKvbdhfibyViu +DncKjvbdeFOqavcK +EPDLKvbdZtIhyETO +EOcKjvbdsPuoKDVf +DoDLKvbdBhkBjiGK +EPDLKvbdnQZyVkYb +DncLKvbdNsTugEtp +EPCjjvbdCDpBWJmG +DoCkKvbdmIdTqVRa +EOcKjvbdptUHRqjt +DnbjjvbdRpTfifDw +DncKjvbdaRebgtFk +EPDLKvbdEARiMyvw +EOcKjvbdyNsHxShc +DoCkKvbdxKwDgzyf +DncKjvbdwuNFQyLn +DncLKvbdegjvSORH +DncLKvbdOStWGdtp +EOcLKvbdcTCkTdKB +DncKjvbdRECaQRES +DoDLKvbdkIHMFemk +EPCkKvbdfjfzcGAE +DncKjvbdZLqdTnLm +EOcKjvbdIMBzmwRL +EOcKjvbdwzHeexFS +EPCjjvbdKVuFdFHJ +EPCjjvbdRXODcLgc +DoDLKvbdlrZVZrdJ +EPDKjvbdjKGIJmYS +EObkKvbdHEKujCJj +DncKjvbdNddTiIjd +DoDKjvbdZjSgpGaf +DoCjjvbdmfeXlnHZ +EPCjjvbdRosfifDw +DoCjjvbdZxcinDLr +DoCjjvbdNeDsiIjd +EPDKjvbdVgxVwgYz +DnbkKvbdqTtGrRjt +DnbkKvbdTqQntuIN +DncKjvbdBvzdJEpW +EPCjjvbdqUUHRrLU +DnbjjvbdqcdhonWB +DncKjvbdHDkWKBjK +DnbkKvbdxVMeQxlO +EObjjvbdkClKpgVH +EOcLKvbdCSaDUGXS +DncLKvbdUQqOttgm +DoCkKvbdZxcjOClS +EPDKjvbdVqmxCFMD +DnbjjvbdqmZixlHi +DnbjjvbdiUydvquC +DoCkKvbdOTTugFVQ +EOcKjvbdUQpoVVIN +DoCkKvbdNHDPlpVL +EOcLKvbdDncLKwCd +EOcLKvbddeOrCXCj +EObjjvbdqvolChyR +EOcLKvbdaofgELzd +DoDLKvbdrpVoKDWG +DncKjvbdaMjasUmH +EObjjvbdliETqUrB +DncLKvbdXsLaMtOx +EObkKvbdrykpTAhO +EPDKjvbdehKvRmpg +EObjjvbdUxhTzKnn +DncLKvbdTfznMXVe +EPDLKvbdqUTfqqkU +DoCjjvbdHELWKCKK +DoDLKvbdwuNFQyMO +DoCjjvbdffLynGgA +EOcLKvbdSLYetfkT +EPDKjvbdtTRryZeD +EPDKjvbdddoRbXDK +DoDKjvbdFVxooljF +DoDLKvbdxsNiNSCH +DoDLKvbdsCGNMGkZ +EOcLKvbdkHfkfFnL +EPCkKvbdqrUjnLAm +DnbkKvbdHELViajK +EOcKjvbdNHDQMouL +EPCkKvbdWWhxVdFH +DnbkKvbdUWMPitBR +DncLKvbdZoOJFFZj +DncKjvbdcIljKewY +DoDLKvbdVUNUGLvK +EObkKvbdNsTufdtp +DnbjjvbdGKdsCgmV +EObkKvbduDCtwWPP +EObjjvbdkMbMZeGo +EPCkKvbdJSyAsNXl +DnbjjvbdmbJwXnmu +EPCkKvbdRjxeuGkT +EObkKvbdaSFcITek +EPDLKvbdGYtuAdYC +DoDKjvbdFeirNiUR +EPCjjvbdhyuGMQmf +EObjjvbdDxYLstUM +EObkKvbdFfKRmhtR +DnbkKvbdyTNhmSCH +EPCjjvbdJSyAsNYM +EPCkKvbdEuxpQMie +DoDLKvbdkClLQgUg +DnbkKvbdssRrxzEc +EPDLKvbdRMwbZNtz +EPCkKvbdssSTYyeD +DoCkKvbdYqMeImEq +EOcLKvbdjuwOECXw +EOcKjvbdOTUWHFUp +EPCjjvbdliDtQtrB +EPDKjvbdZxdJmblS +DoDKjvbdbVCHXkTh +DoDKjvbdpstHSRjt +EOcLKvbdNPwpunGs +DoCkKvbdLAjgNCXq +DoCjjvbdDoDKjvbd +DoCkKvbdZirgpHBf +EPDLKvbdezuxdiTw +DoCkKvbdLrXMyuQz +DncLKvbdqlyjYkgi +DnbkKvbdLrWlzUpz +DoCjjvbdhytfLpnG +EObjjvbdxrmiNSBg +EPDLKvbdqquLNjaN +EObjjvbdiHKCyVjV +DncKjvbdjSziTKiz +EPCjjvbdCflGHAzc +EPCjjvbdZtJJZDrn +EPCjjvbdJKEAKQHE +EPDKjvbdIxTbHlRQ +EOcKjvbdZRMdhmEq +EOcLKvbdmttykJqf +DncLKvbdEzsqFMDJ +EPDKjvbdJuteceGi +EOcKjvbdemFvfmJk +DoCkKvbdkySqsZGt +EOcLKvbdlrZVZsDi +EOcLKvbdEXxLstTl +DnbkKvbdkNBlZeHP +DncLKvbdauCHYKsh +EPCkKvbdhuZeXSVC +EPCjjvbdOTTufdtp +DoDKjvbdDoCkKwCd +DoDLKvbdOAIrsirA +EPCjjvbdlAmPNALA +EOcLKvbdiBoCdwQq +DoCkKvbdnCJwYOnV +EOcLKvbdqwQLbhxq +DncLKvbdGYuVBEYC +EPCjjvbdcyyQXxqC +EPDKjvbdrEEiPmvB +DnbkKvbdJbibqJbx +DncLKvbdiGjCxuiu +EObjjvbdjKGIJmXr +EPCjjvbdFkEsDIMu +EPDKjvbdCWzchePv +EObjjvbdEObjjwDE +EPCkKvbdQdDApRDr +DoDLKvbdbAvEfQPw +DoDLKvbddtAUATNW +DnbjjvbdUxhUZkOn +DnbjjvbdwNWANEEm +EPCjjvbduDCuWuoP +DnbjjvbdjAQHApHK +DncLKvbdJzpFxEAN +DncKjvbdwtldpxlO +EObjjvbdBraCtGWr +EPDKjvbdJmADzGuB +DoDLKvbdRadEkiZL +DoCkKvbdAMhZTXZx +DoCjjvbdqGDeUVaI +DoCjjvbdVvhxWDdg +EOcKjvbdSBceMIyL +DnbkKvbdRkYfUfjs +EOcLKvbdFWYpQMjF +DoDLKvbdhlFENuCy +EObkKvbdiCObeWpq +DnbkKvbdHELWJaij +EObkKvbdCTAcTfWr +EPDKjvbdbrcLTdJa +DoDLKvbdDncKkXDE +DoCkKvbdmSYtzSdJ +EOcLKvbdVZHszLPO +DnbjjvbdhkdcmuCy +DnbkKvbdLrXNZuQz +EPDKjvbdZnmiFEzK +EPCkKvbdlrZVZsEJ +DnbjjvbdqmZixkhJ +DoDLKvbdcTCjsdKB +DoCkKvbdcyyPxYqC +DoDKjvbdssRrxydc +DoDKjvbdvPTzpjnt +EObjjvbdZLqctOMN +DoDLKvbdRNXbYnUz +DncKjvbdJYUBglRQ +EObkKvbdkIGlGFnL +DoDLKvbdiUzEwSUb +EPDKjvbdeEnrCWbj +DoDLKvbdRbDdkhxk +EObjjvbdYzcFqjWZ +EOcLKvbdjggLfFnL +DncLKvbdgQBzwEXh +DoCjjvbdQlxByNtz +DnbkKvbdoznDjwoA +DnbkKvbdVgwuxHYz +DoDLKvbdaaVdepQX +DoDKjvbdLZRKSztf +EPDKjvbdbUbHXkUI +EOcLKvbdjhGkfFmk +EObkKvbdeEoSBvcK +DncKjvbdUtMtGMVj +EPDLKvbdJTZAsMxM +DnbkKvbdOEdUJJKd +DoDKjvbdZHXEAPSi +EObkKvbduaDyTPFI +DnbjjvbdqAiFAWhE +EObjjvbdelevgNKL +DnbjjvbdTAEhgbPE +DoDKjvbdnPzZVkZC +DoDKjvbdQwNdDLhD +DnbjjvbdnBjWwoNu +EObkKvbdfMewGljL +DncKjvbdrpVnjCuf +EPDLKvbdLGFgbBRV +EObkKvbdkCkkRHUg +EObkKvbdTlVoAuoJ +EPDLKvbdrMyjZMHi +EOcLKvbdWHwuxHYz +EOcKjvbdLrXNZtpz +EObjjvbdbQHHDkzd +EOcLKvbdfILWRnRH +EPCjjvbdyfyMAMeX +DncLKvbdNHCpNQVL +EPCjjvbdFkEsDHlu +DncKjvbdGGJqmhtR +DnbkKvbdvAcxrndh +DoCjjvbdqGDeTvBI +DoCjjvbdJvUfDdgJ +DoCjjvbdUVlPisaR +DoCkKvbdqTsgSRkU +EObjjvbdjblKpftg +EObkKvbdtcDVXWPP +DnbkKvbdfHkVqnRH +DncLKvbdmoyxvLZC +EObjjvbdkHfkfFnL +EPDKjvbdwNWAMcdm +EPCjjvbdJpzFOfNe +DncKjvbdmbJvxOnV +DncKjvbdTqQnuUgm +EOcLKvbdTpqOuVHm +DoCjjvbdYlSETmkm +DoDKjvbdjEkGuPAO +DoCkKvbdwygefXdr +EObkKvbdrXPkcJYq +DoCjjvbdxUleQyMO +EOcLKvbdBsAcTfXS +EPDLKvbdLBLGlbXq +EObjjvbdmbJvwnnV +DnbjjvbdbVCGwjsh +DnbkKvbdxUmEpyMO +EPCkKvbdYSlBNTnx +DoDKjvbdeOeSkUTr +DncLKvbdqmZixlHi +EPCkKvbdNHCpNQVL +DoCkKvbdDigjWXjA +EObjjvbdrDeJQNvB +EOcLKvbdJuuGDeHJ +DoCkKvbdddnrCXCj +DoDKjvbdqTtGqrKt +DoDKjvbdeOeTKstS +EObjjvbdySmiNRbH +DnbjjvbdZshiYdTO +EObjjvbdnCKXXnmu +EPDKjvbdqiAKFMne +DoDKjvbdNeEUIiKd +DnbjjvbdzitpPdTU +EPCkKvbdzaAOffal +EOcKjvbdZtIiZDrn +DoCjjvbdtSrTYyeD +DoDLKvbdFVxopNJe +DoDLKvbdJJdAJpHE +DoDLKvbdHDjuiaij +EObkKvbdUWMQKUAq +EPDKjvbdTpqOuVIN +EOcLKvbdqvpMChyR +DoCkKvbdVviXudEg +DoCkKvbdGLErbgmV +EPCkKvbdZirhPfbG +DoCkKvbdWXJYVceH +DnbjjvbdhkeEOUcZ +DncKjvbdSPtHJedX +DncKjvbdFfKRnIsq +DncKjvbdWWhxVdEg +DoCkKvbdOStWHEuQ +DoDLKvbdEuyQPmKF +DncKjvbdrpVoKDWG +DoCjjvbdKVtfEEfi +DoCjjvbdWXIwudEg +EPDKjvbdSCDeMIyL +EPDKjvbdDoDKkXCd +DoCkKvbdJpzEnenF +EPDKjvbdaaWEfPow +DoCjjvbdVwJXucdg +EPCjjvbdauCHYKtI +EOcLKvbdNeDshhkE +DncLKvbdNGcQMpVL +EOcLKvbdIryBSmXl +DnbkKvbdTAFJICPE +EOcLKvbdrMzKYlHi +EOcKjvbdznopeDMY +EOcLKvbdMRvmZuQz +DncKjvbdeFOqbXCj +DncLKvbdbhlijfWx +EOcKjvbdqdEhpOWB +DoDLKvbdUWMQJsaR +DoDLKvbdptUGqrLU +EObjjvbdaSGChUFk +EPCjjvbdYTMAltOx +DncKjvbdEPCkLWbd +EOcKjvbdKCjDRKCx +EPDKjvbdZyDjNcMS +DncLKvbdFfKRnJUR +EPDKjvbdrNZiyLhJ +EOcKjvbdZeXfzgiC +EOcKjvbdbUbGwkTh +EPDLKvbdHfgZxwxH +DncLKvbdrovOjCuf +DnbjjvbdfNGWflik +DnbkKvbdZoNiFEyj +EPCjjvbddneTKtUS +EObjjvbdRbDdlIxk +EOcKjvbdKfFgbBRV +EPDKjvbdFyUuBDxC +EPCkKvbdiUzFXRtb +EPCjjvbdrJAJeNPF +DncLKvbdVAbRSqSZ +EObjjvbdaNKbTVMg +DoCkKvbdlhctQtqa +DoDKjvbdZshiZDrn +EPDLKvbdFkFSbglu +EPCjjvbdHffyxwxH +DncKjvbdTvLojTaR +DnbkKvbdauCHXkUI +DoDKjvbdGdKuiajK +EOcKjvbdkClKqHVH +EPDLKvbdnUtykKSG +DnbkKvbdBiKbKhej +DoDLKvbdHffzZXwg +EPCjjvbdbrbkTcjB +DoCkKvbdVwJYWDdg +DncLKvbdJJdAJogE +EPCkKvbdJvUfDdfi +DoDKjvbdZeYGzgiC +EObjjvbdZyEJnDMS +EOcLKvbdmSZVZsEJ +EPCkKvbdDnbjjvbd +EPCkKvbdJvVGDeGi +DoCjjvbdTXkLmzkY +DnbkKvbdLqwNZuQz +DncKjvbdZtIiYcsO +DoDKjvbdLYqKSztf +DnbkKvbdULuoBVni +EObkKvbdiBnbeWqR +EObjjvbdfILWRmqH +DncKjvbdezvYdhsw +DnbjjvbdJvUfEEfi +EPCkKvbdRpUHKGDw +EObkKvbdZGwEAPTJ +EOcLKvbdcTCkUEKB +EObjjvbdGAoQxizm +DnbjjvbdNwoVzcmt +DncLKvbdJbicRKDY +DnbkKvbdGZVVAcxC +EPCkKvbdRadFMJYk +DnbjjvbdxsNiNRag +DnbjjvbdiBncFXRR +EPCjjvbdySmiNRbH +DoDKjvbdeATqMxKG +DnbjjvbdtSrSyZdc +EOcKjvbdwtldpyLn +EPDKjvbdqwPkbiYq +EPDLKvbdzitpPcsU +DoDKjvbdDjHiuwjA +EPCkKvbdfMewGmKL +DncKjvbdlrYtyrci +EPCjjvbdZQldiMdq +EPDKjvbdJbjDQjCx +DncKjvbdqTsgRrKt +EPCkKvbdEvZQPljF +DoCkKvbdUsltGMWK +EOcLKvbdEJgivXjA +DnbkKvbdePFTLTtS +EPDKjvbdEYYLstTl +EPDKjvbdMfcPmPuL +DoDKjvbdBsAcTevr +EPDLKvbdwtleRZMO +EObjjvbdRotHJfDw +EOcKjvbdJuuFdFHJ +DnbjjvbdZoOIeFZj +DoDLKvbdsZlQSaHn +EPCjjvbddoFTLTtS +DncKjvbdbVBgXjsh +EPCkKvbdaMkBrtlg +EPDKjvbddiiqutzn +EObkKvbdiZuFkpnG +EPCkKvbdIxTaglRQ +EOcKjvbduaEYrndh +DnbjjvbdzQoMiJwA +DoCkKvbdsCGNMHKy +EObjjvbdMoxQunHT +DnbkKvbdxwiJbPzL +EOcLKvbdJbibpjCx +DncKjvbdIxTbHkpp +DoCkKvbdwuMeQxlO +EOcKjvbdKeehCBRV +EPCkKvbdZxdKNblS +EPCjjvbdLFegbBQu +DoCkKvbduLwwBUBX +DoDKjvbdjlbMZeHP +DoDLKvbdjAPfaPfj +EObjjvbdqGEFTvBI +EObjjvbdeAURNXif +EObjjvbdxmrgxTJD +EPCkKvbdqGDeUWAh +DncKjvbdqTsfqrKt +EObjjvbdjEjftoAO +EOcKjvbdNrtWHFUp +EObkKvbduCcUvvOo +EPCkKvbdvwMAvBWV +DncLKvbdtkwwBUBX +DoCjjvbdVZHsyjnn +EPDKjvbdQccBQQdS +DnbkKvbdjgfkeemk +EPDLKvbdFyVVBDxC +DncLKvbdrNZiyMIJ +EObjjvbdHfgZxwwg +DoDKjvbdqceIomvB +EPCkKvbdNGcPlouL +DoCkKvbdCIkBkIej +DoCjjvbdjKFhJmYS +EObkKvbdBsBDUGWr +EObkKvbdnQZxvKyC +DnbjjvbdhzVFkqOG +EPCjjvbdGLFScHlu +DoCjjvbdtlXwAtBX +DoDLKvbdUtMtFkvK +DoCkKvbdBvzchdov +DncLKvbdlZSrTZHU +EOcKjvbdZnnJEdyj +DncKjvbdYpleJMdq +EPDKjvbdiMEcmtcZ +EPCjjvbdfelZmgHA +DnbkKvbdLhalRYAS +DncKjvbdehLWRnRH +DnbjjvbdeKJqvUzn +EPCjjvbdqqtkOLBN +EOcLKvbdfRaWzlDP +DncLKvbdhtzFWquC +EObkKvbdJvVFdFGi +EObkKvbdMfcPlotk +DoCjjvbdtcCuWvPP +DnbjjvbdwtmFRZMO +DoDKjvbdsPvPKCvG +EPCjjvbdmfdwmOHZ +EPDLKvbdMgDPlouL +DoDKjvbdnGdwlnHZ +DoCkKvbdVwJXudFH +EObjjvbdQdCaQQcr +DnbkKvbdYSkaNUPY +DoCjjvbdULvPAuni +EPCjjvbdSZihScWA +DoCkKvbdBiLCKhej +DnbkKvbdhXZAzzAJ +EOcLKvbdQYmAGsRj +EOcLKvbdZtJIyDrn +DnbkKvbdNsTufduQ +EOcKjvbdEXxMUTsl +DoDLKvbdKyRJrzuG +DoDKjvbdrWpLbhxq +DnbjjvbdrDeIonWB +EPDKjvbdHELViaij +DoDLKvbdBdQBWJmG +DncLKvbdRjyGUfkT +EPDLKvbdYNqAYUut +EPDKjvbdRXNdClID +EPCkKvbdNwnuzdOU +EOcLKvbdjmBkydfo +DoCjjvbdrpWPKDVf +EPCkKvbdZyEKNbkr +EOcKjvbdQZNAHTRj +EOcKjvbdwtmEpxkn +DncLKvbdLhbMRYAS +DoCjjvbdsrrTZZdc +DncKjvbdxmrgxShc +EPCkKvbdmozZVkZC +EPCjjvbdbsDLTcia +DoDKjvbdGKeScIMu +EPCjjvbdrEFIpOWB +EOcKjvbdmpZxukZC +DoCkKvbdTkunaVni +DoCjjvbddneSkUUS +EPCjjvbdTlVoBWPJ +DoDKjvbdxsNhmSCH +EPCkKvbdVviXvDdg +DnbjjvbdwzHfFwdr +EPDKjvbdfMewHMjL +DoCjjvbdbsDKtDjB +EPDLKvbdUQpoVVIN +EObkKvbdrEFJPmua +EObkKvbdhlEcnUcZ +DoDKjvbdZRMeIleR +DnbjjvbdmajXYOnV +DoDKjvbdaRfDHtGL +DoCjjvbdbhljKewY +DoDLKvbdDwwksssl +DncLKvbdUMWOaVoJ +DncKjvbdWWiYWDdg +DoCjjvbdyXiJbQZk +DnbkKvbdHDkVibKK +EPCjjvbdtSrSxzEc +EOcLKvbdaSGChUFk +DnbkKvbdYSlBNUOx +EPDLKvbdJTZBSmYM +DoCjjvbdTkvOaWOi +DncKjvbdMowpvNfs +EPDKjvbdeEnqavcK +EOcLKvbdiifIJlxS +DnbkKvbdqceIpNua +EPDKjvbdrNZixkhJ +DncKjvbdiHKDZViu +DnbkKvbdrDdiPnWB +DncLKvbdLGFhCAqV +DoCjjvbdwuMdqYlO +EPCjjvbdePFTKssr +EObjjvbdVBCQrpqy +EObjjvbdbrcKsdKB +DnbkKvbdBvzciEpW +DoCjjvbdIHGyyXxH +EObjjvbdrzLpTAhO +EOcKjvbdemGWgNJk +EObkKvbdVZHtZjnn +EOcKjvbdiCObeXRR +EPCkKvbduoTzpkPU +DoCkKvbdrNZjYkgi +DnbkKvbdTAEhgand +EOcKjvbdhuZdwRuC +DoDLKvbdWWiXuceH +EPDKjvbdZoOIddzK +DncLKvbdVAbRSprZ +DnbjjvbdhgKDZWJu +DoCkKvbdVZITykOn +DoCkKvbdiGibyWKV +EPDLKvbdwyhGGYFS +DoDKjvbdiHKCxvJu +EPDLKvbdhyuGLpnG +EPDKjvbdOAJStKSA +EOcKjvbdzitpPdSt +DoCkKvbdzROlhjXA +DoDLKvbdtTSSxzEc +DoDKjvbdzoQRFCkx +DnbkKvbdxnSgxShc +DnbjjvbdiBoDFWqR +DoCjjvbdnBjWwoNu +DncLKvbdVYhTzKnn +DncLKvbdkIGkefNk +DnbkKvbdlqxuZsEJ +EOcLKvbdACrYJzIp +EPDKjvbdmaiwYOnV +EOcKjvbdYkrEUNlN +DoCjjvbdVUNTfLuj +DoDLKvbdfHkWSOQg +DnbkKvbdBraCsfXS +EOcKjvbdMJBkpxAS +DoDKjvbdcyyQXyQb +EObkKvbdeEnrCXDK +EObkKvbdFejSNiTq +DoCjjvbdEYXkstTl +EPDKjvbdyYIjBpZk +DncKjvbdiHJcZWKV +DncKjvbdQdDAoqDr +EObkKvbduDDUvvOo +EPCkKvbdzGyMANEw +DoDKjvbdQvnECkgc +DncKjvbdVviXudEg +DoDLKvbdQZNAHTSK +EPDKjvbdkCkjqHUg +EObjjvbdwyhFeweS +DoCjjvbdxwiJbQZk +EOcLKvbdEPDLLXDE +DncLKvbdVrNwbFLc +DoCkKvbdjAPgBPgK +EOcKjvbdpstGqqjt +EPDLKvbdHDkVjCKK +DncKjvbdirzhrjiz +DnbjjvbdxrnJNSBg +EPCkKvbdraelkgLZ +DncLKvbdptTgRqjt +DoCkKvbdIsYaTMxM +DoCjjvbdMpXqVnGs +DoDLKvbdUVkoitBR +DoCkKvbdjmCLyeHP +DoCjjvbdiVZeWquC +DoCjjvbdVUMtFlWK +EPDLKvbdxKvdHzzG +DoDKjvbdiMEdNuCy +EPDKjvbdwzIFfYEr +EObjjvbdJXsagkpp +EPCkKvbdxrmhmSBg +DoDKjvbdlqxuZsDi +EPDKjvbdsQVoJcVf +DnbjjvbdEYYLstUM +DncLKvbdkHgLfGNk +EPCjjvbdbsDKtDjB +DnbjjvbdJcKDQibx +DoCjjvbdyzdnSIIh +DnbkKvbdrpWOjCuf +EObjjvbdbAudeopX +DnbkKvbdYkqctNlN +EPDLKvbdfHkWRnRH +EPDLKvbdXmqAYUut +DncKjvbdFyVVBEXb +DnbkKvbdrDdhpNua +DncKjvbdeAURNXjG +DoCkKvbdOTUVgEuQ +EPCjjvbddwyssrFz +DoCjjvbdMpYRWNfs +DoCkKvbdjuvnDaww +DnbkKvbdVhXvXgYz +EObjjvbdTulQKTaR +EObjjvbdOAJTUJrA +EPDLKvbdsZkosBIO +DoCkKvbdhgJbxvKV +EPCjjvbdnBivxOnV +DncKjvbdxrnIlrCH +DncLKvbdzaAPHGbM +EPCkKvbduMXvaUBX +DnbkKvbdSBceMJZL +EObjjvbdJpzEoGOF +DnbkKvbdWexytAPT +DnbkKvbdkVwNcaxX +EOcLKvbdEYYLsstM +DoCkKvbdRosfiedX +EOcKjvbdwuMdpyMO +EObjjvbdUsmUFlWK +EObjjvbdjuwOECXw +DncKjvbdqlzJxkgi +DoCkKvbdiHJbxujV +EPDLKvbdakMFoNcA +EOcLKvbdmIcsqUqa +EPCkKvbdeKKSVtzn +EPCkKvbdvBEZTOeI +DncKjvbdpstHSRjt +EOcKjvbdKVuGEEfi +DoDLKvbdZQldiNFR +EPCjjvbdxnTIYShc +EOcKjvbdtunXjQsA +EPDKjvbdjcLkRHVH +DncKjvbdDoDLLXCd +DnbjjvbdZyEJnDMS +DoDLKvbdFkFTCgmV +EOcKjvbdhkddOUby +EPDLKvbdNeEUJIkE +DnbkKvbdyzeNqghh +EPDKjvbdFVxopMjF +EOcKjvbdGdLVibKK +DncKjvbdBdQAvJlf +DoDKjvbdbiNKLFwY +EPCkKvbdnGeYNNgZ +EPDLKvbdEYXlUTsl +DncLKvbdOEcsiIjd +DncKjvbdKaLHMbYR +DncKjvbdyTOIlrCH +EPCkKvbdMpXpumgT +EPCjjvbdtbbtwVno +DoDKjvbdrRtkOLAm +EObjjvbdbLLfPNcA +DncKjvbdjmCLydgP +DnbkKvbdTkuoBVoJ +DnbkKvbdSCDdlJYk +EObkKvbdCEPaVjNG +DoDLKvbdFaOpxizm +EPCjjvbdfMevgMjL +DoCkKvbdYzcGRjVy +DnbjjvbdKRZdoGNe +EPDLKvbdZisIQHCG +EOcLKvbdZMSEUOMN +DoCjjvbdiGibxuiu +EPDLKvbdZQmFJMeR +DoCkKvbdsBemLfjy +DncLKvbdzoPqEcMY +DncLKvbdMoxRWOGs +EOcLKvbdFeirOJUR +DoDLKvbdpyOgfpdY +DncLKvbdyzeOSIJI +DoDLKvbdRkZFuHKs +DnbkKvbdxVNEqZLn +DoCjjvbdMgDPmPuL +EPDKjvbdZQmEhmFR +DncKjvbdBraDUFwS +DoCkKvbdqqtjmkAm +EPDLKvbdLZQirzuG +DoDLKvbdlYsRryGt +EOcKjvbdKaLHNBxR +EOcKjvbdTqQoUthN +EObkKvbdhbObeXRR +EPDKjvbdJutfDeGi +DoDLKvbdRkZFuGkT +EOcKjvbdrbGNLgKy +DnbjjvbdmpZyWKyC +EPDKjvbdHELVjBij +EPCjjvbduDDUvuoP +EOcKjvbdrDeIonWB +DoCjjvbdnPyyWLZC +EPDKjvbddndrjtUS +EObjjvbdjuvnDbYX +EPDLKvbdCIkBjhfK +EObkKvbdZjTHogCG +EOcKjvbdjJehKNYS +DnbkKvbdSxLMNzkY +DoDLKvbdKDKDRJcY +EPCkKvbdmpZxvKxb +DnbjjvbdssSTYyeD +EObjjvbdHDkVibJj +DnbkKvbdSLZFtgLT +DoCjjvbdxnTIXriD +DnbkKvbdcSbjsdJa +DoCkKvbduoTzpjoU +DoCjjvbdXsLaNUOx +DoDLKvbdcScKtEJa +DnbkKvbdfpBzwDwh +EPDKjvbdjlakyeGo +DnbjjvbdYzcFqivZ +DncLKvbdCIkBjiGK +EPDLKvbdxZhFfYFS +EObjjvbdrEFJQNvB +DoDLKvbdjAPgBQHK +EOcLKvbdkDLjqHUg +DoCkKvbdiUzFWqtb +DoCkKvbdKVtfDdfi +DoDLKvbdwkXEHzyf +EObjjvbdqcdhpOWB +EPCkKvbdeEnrBvbj +DoCkKvbdCTAbsewS +DnbjjvbdNHCpMouL +DoDKjvbdSQUGiecw +DoDLKvbdelevfmKL +DoCkKvbdySnImSCH +DncKjvbdANIZSvzY +DncKjvbdrJAJeNPF +EPCjjvbdqTtGqqjt +EObjjvbdaRfDHsfL +EPCkKvbdrJAJeMne +EPDKjvbdiGjDYvJu +DoDKjvbdMgCpMpVL +DncKjvbdZjTIQHCG +EOcLKvbdJYTbILqQ +DoCkKvbdzoPqEbkx +EPDLKvbdvlvANDeN +DncLKvbdatafwjsh +DncLKvbdJuuFcdgJ +DncLKvbdwXMAvBWV +DoDLKvbdaMjbStmH +DoCkKvbdeOdsLTtS +DoDKjvbdbLLeoNcA +EPDKjvbdJKEAJpGd +DnbjjvbdZnnIeEyj +EOcLKvbdunszpjnt +EObkKvbdmoyyWKxb +EObkKvbdILazmvpk +EPDKjvbdQlwbYmtz +EPCjjvbderAvzkcP +EObkKvbdegjvSORH +EOcKjvbdsrqsYydc +EOcKjvbdfIKvSORH +DnbkKvbdFjdsDIMu +EPDKjvbdpstHRqjt +EOcLKvbdWRmxCElD +EOcLKvbdkHflGFnL +DoCjjvbdZjTHofbG +EObjjvbdeEoSBwCj +EPCkKvbdJSyBTNXl +DnbkKvbdUaCRTQqy +EPDKjvbdSLZFtfkT +DncKjvbdyNrgwsJD +DoDKjvbdezuxdiUX +DoDLKvbdACrXiyhp +DoDLKvbdxwiJaoyk +EOcKjvbdUxhTzLOn +DnbjjvbdnHFYNNfy +EOcLKvbdhanbeWqR +DoDKjvbdzHYlAMdw +DoCjjvbdKyRJrzuG +DncLKvbdliETpuRa +EObkKvbdczYpXyRC +DoDKjvbdFfKRnIsq +EPDKjvbdVAbQsRSZ +DncKjvbdezvZEiUX +DoCkKvbdZisHofbG +EPDKjvbdjKFgilxS +EOcLKvbduVmxKQsA +DnbjjvbdhuZeWrUb +EObkKvbdGYuUaDxC +DoDLKvbdaaWFGPpX +DnbkKvbdUQpoVUhN +EPCjjvbdZxdJmcMS +DncKjvbdhbPCdwRR +EObkKvbdZRMeJNFR +DnbjjvbdTlVoBWOi +DoCkKvbdatbHYKtI +EObkKvbdiHJbxvJu +DncKjvbdsQWOjCvG +DncLKvbdRosfjGEX +EObkKvbdREDBQRDr +EOcLKvbdeEnqawCj +EPDLKvbdGZVUaEXb +EPDLKvbdIryArmXl +EObjjvbdiiehJlwr +DoCkKvbdMJCMRYAS +DnbkKvbdlrYtzTDi +DoDLKvbdnGeXlmfy +DoCkKvbdSCDeMJZL +EObkKvbdLFegaaRV +DoDKjvbdGGKRmhsq +EObkKvbdiLdcnVDZ +DnbjjvbdGBOqZJzm +DnbjjvbdhfjCxvKV +EPCjjvbdlBNPNALA +EOcKjvbdtbbuXWPP +DncLKvbdEPCjjwDE +DoDLKvbdLqwNZtpz +EPDLKvbdbVCGwkUI +DncLKvbdZyDimcLr +DncLKvbdfILWSNpg +DoDKjvbdFVyPpNJe +DncKjvbdqiAJeMoF +EOcKjvbdqrVLOLAm +DoCjjvbdehKuqnQg +DoDLKvbdGLFTCglu +DoCjjvbdXrlBMtPY +DncKjvbdlYrrTYgU +EPCkKvbdWSNxCFMD +DncKjvbdUVkoitAq +DncLKvbdfHjvSORH +DoCkKvbdCEPaWKMf +EObkKvbdmbJvxPOV +EPDKjvbdwzHefXeS +EOcKjvbdvvlAvAuu +DncLKvbdpxngfqDx +DnbjjvbdIwtCIMQp +DncKjvbdHDjvKBjK +EOcKjvbdjmCLzFGo +DnbkKvbdZMRdTnMN +EObjjvbdEOcLLWbd +DoDLKvbdkNBlZdfo +EPCjjvbdemGXHNKL +EOcLKvbdkxrqryGt +EOcKjvbdsPvPKDWG +EOcKjvbdXsMAlsoY +DnbkKvbdmIcspuSB +DoCjjvbdUaBpsRRy +EOcLKvbdSPsfiedX +EOcKjvbdSCEEkiYk +DncKjvbdWXJXudEg +DncLKvbdRyigrbvA +DoDLKvbdUMVoAvOi +DnbjjvbdZtIhxcsO +EOcLKvbdJXsbHkpp +DnbkKvbdZtIhyETO +DncLKvbdHlBzmvpk +EObkKvbdzHZMAMeX +EPDKjvbdKCjCpjDY +EOcKjvbdjblKqHUg +DoDKjvbdGGJrNiUR +DoDLKvbdrEFIomvB +EPCkKvbdrovPKDVf +DoDKjvbdpxnhGpdY +EPDKjvbdemGWgNKL +EPDLKvbdTlWPAuoJ +EOcLKvbdhuZeWqtb +DnbkKvbdhyuGLpnG +EObjjvbdSBcdlJZL +DnbkKvbdeEnqbWcK +DnbjjvbdJKEAJofd +EObjjvbdbQGfckzd +EPCjjvbdRkYeuHLT +DoDLKvbdXrlBMtOx +EObkKvbdznoqFCkx +EPDLKvbdjggLfFnL +EPDKjvbdhuZdwSVC +EPCkKvbdeEoRbXDK +EPCkKvbdKaKgNCYR +DoDLKvbdWWhxWDdg +EPCjjvbdqUTfqqjt +EOcKjvbdcSbkTdJa +DncKjvbdauCHXjtI +DoCkKvbdQlwbZNtz +DnbjjvbdqvolCiYq +EOcLKvbdePFSjstS +EOcKjvbdhgKDZWKV +EObkKvbdCgLfHAzc +DncKjvbdnUuZkKSG +DnbjjvbdlhctRUrB +DoDKjvbdpyPHgREY +DoCkKvbdjJegimXr +EPDKjvbdfHkVrORH +EPDKjvbdyTOIlqbH +EPDKjvbdjKFhKNYS +EPDKjvbdFWZPpMie +EPCjjvbdIwsahLpp +EObkKvbdKfGIBaQu +DncKjvbdGFirOJTq +DnbjjvbdpedFUWBI +EPCkKvbdNeDshiKd +EObjjvbdBiLBjhej +EObjjvbdCJKbLJFj +DncKjvbdvwMAuaWV +DnbjjvbdZRMdhleR +DncKjvbdhgKCyViu +DoCkKvbdhficZWKV +DnbjjvbdwkWdHzyf +DncLKvbdVBBqSprZ +EOcLKvbdUsmTelVj +EOcLKvbdFxuVBEYC +DoDKjvbdKaLHMbYR +EPCkKvbdGdKuiaij +EPDKjvbdfIKvRnQg +DncKjvbdfekzNfgA +DoCkKvbdJbicRJbx +EOcKjvbdIwsagkpp +DncKjvbdOEctIiKd +DncKjvbdOTUVfduQ +EPCkKvbdFWZPomKF +EObjjvbdezvZFJUX +DoCjjvbdtSrTYzFD +DoCkKvbdbVCHYLTh +EPDLKvbdZMRdUOLm +DoDLKvbdNwoVzdNt +EPDLKvbdFaPRZJzm +DoCjjvbdxZhGFweS +EPCjjvbdZQmFImFR +DnbjjvbdsQWOibvG +DoCjjvbdSBdFMIxk +EPCkKvbdEObkKvcE +DoDKjvbdqFcdsvAh +EOcKjvbdezuyEhsw +DnbkKvbdVqnXaeMD +EObjjvbdnGeXlmgZ +DncLKvbdCIkBkIfK +EPDLKvbdpecdtWAh +EPDKjvbdsQVnjCvG +DoDKjvbdkDMLQfuH +EObjjvbdAMhZTWzY +EPCjjvbdiCObdvqR +DoDKjvbdUWLoisaR +DncLKvbdSPtHKGDw +EObjjvbdaNLBrtmH +EPDKjvbdUyHszKoO +DoDKjvbdQwNccLhD +EPDLKvbdnVUzKjRf +DoCkKvbdRyigrcWA +EOcLKvbdbiNKLGXY +DncKjvbdlhctRVSB +DoCkKvbdNPxRWNfs +EObjjvbdANHxsXZx +DnbjjvbdNrsvHEuQ +EPCjjvbdmbJvxPNu +EOcKjvbdJvVGEFGi +EPDKjvbdUWLoitAq +DoCkKvbdkDMKpfuH +EOcLKvbdfjfzbfAE +EOcLKvbdczZQYZRC +DoDLKvbdQwNcblHc +EObkKvbdOTTugEtp +DncKjvbdbUagYLTh +EPCjjvbdfNGWfmKL +EObjjvbdiVZdvrUb +DncLKvbdZyDinDMS +EPCkKvbdmaiwYOmu +EOcLKvbdqUUHSRkU +DncLKvbdDncKjvbd +DoCkKvbdVqmxCElD +EPCkKvbdaRfDIUFk +EOcKjvbdjKGIJlxS +DncLKvbdkxrrTZHU +DncKjvbdypnmIjXA +DoDLKvbdJpyeOfOF +DoDLKvbdwXMBVaVu +DoDKjvbdKfFhCAqV +DoCjjvbdIxTahLqQ +EOcLKvbdADSYKZiQ +DoCkKvbdMowpunHT +EOcKjvbdgKfzbfAE +EPDKjvbdhkddOVDZ +EPDLKvbdemFwHMik +EPCjjvbdUVlQKTaR +DncLKvbdRWnECkhD +DnbjjvbdkWXODbYX +DoCjjvbdZeYGzghb +DoCkKvbdSKyFtfkT +DoDLKvbdBhkCLJFj +DncKjvbdlhdTqVRa +EPDKjvbdqqtjmjaN +DoDLKvbdZjTHofbG +EPDLKvbdJmADzHVB +DoDLKvbdSBceLhyL +EObjjvbdqwPlCiYq +DncLKvbdYORAXtvU +EPDLKvbdZnnJEdyj +DoCjjvbduWNxKQsA +EPDKjvbdWSNxCElD +DoCkKvbdRjyFtgLT +DoCkKvbdeOeSkUUS +EOcKjvbdDihKVxKA +EObjjvbdffLymgHA +DoDLKvbdcScKsdKB +EPDLKvbdlYsSSyGt +DnbjjvbdGKeTDINV +DoDLKvbdCTBCtGXS +EObjjvbdEASIlyvw +EPDLKvbdfMfWfmKL +DoCkKvbdpstGqrLU +DncLKvbdtlXwAsaX +DoDKjvbdNrsvHEuQ +EObjjvbdCTBDTfXS +DoDKjvbdkMalZeHP +DoDLKvbdQccBPqDr +DnbkKvbdYqNEiNEq +DnbkKvbdvBDyTOeI +DnbjjvbdLAkGmBxR +EObkKvbdLiBlRYAS +EPCjjvbdTukpKUBR +EObkKvbdhuZeWqtb +DoDLKvbdZyEJmbkr +DnbjjvbdxrmiNSCH +EPCjjvbdKWVFdFHJ +EPCjjvbdRWmcblID +EPCkKvbdsQVoJcVf +EPCkKvbdGcjuibJj +DoCjjvbdJuteceHJ +DnbjjvbdLLAhWAJy +DncKjvbdULunaWOi +EOcLKvbdHlBznXQk +DoDKjvbdvBDxroEh +DoDKjvbdzaAPHGbM +DoDLKvbdUyITyjoO +DnbkKvbduaDxroFI +EObkKvbdAMhZSvzY +EObjjvbdDoDKkWbd +EObkKvbdGKdrbhNV +EPCkKvbdmgFXlnGy +EOcKjvbdzdzOzdzQ +EPCkKvbdKkBHvAJy +EOcKjvbdqAiFAWhE +DoCjjvbdQvmdClID +DncKjvbdMtsSKmAX +EObjjvbdziuPpETU +DoDKjvbddZyQYZQb +EPDLKvbdauBgXkTh +DnbkKvbdnCJvwnmu +DoCjjvbdxUmFQyMO +DncKjvbdXGYzUAPT +EPDLKvbdOAJTUKSA +DncKjvbddZyPwxqC +EOcKjvbdqlzKYlIJ +DnbjjvbdkVvnDaww +DnbjjvbdZdxGzhIb +DnbkKvbdDwxLtTsl +EObkKvbdGKdrcHmV +DncKjvbdTAFJHbOd +DoDKjvbdEObkKvcE +DnbkKvbdaNLCSuNH +DoDLKvbdDxYLtTtM +EObjjvbdVZIUZjnn +DoCkKvbdNsUVfduQ +EOcLKvbdGGKRmhtR +EPDKjvbdbKlFnmcA +DncKjvbdvvlAvBWV +DoCjjvbdliEUQtrB +DnbjjvbdjgfkfGNk +EPDKjvbdlYsSTYft +DoDLKvbdbKlGOnDA +EPDKjvbdjAPfaPfj +DnbkKvbdzGyMAMeX +DoCjjvbdZnmhddzK +EPCkKvbdIMBzmwQk +EObkKvbdjEkHVPAO +EPCkKvbdQccBPpdS +EPCjjvbdhgKCxvJu +DncLKvbdVgxVxHYz +EOcKjvbdxVNFQxkn +DoDKjvbdbLMGPNcA +DncLKvbdGckWJajK +DnbkKvbdrMyiyLgi +EOcLKvbdKefICApu +DoCjjvbdqFdEtWBI +EPCkKvbdYSlBNUPY +DoCjjvbdIwsbILpp +EPCjjvbdmgFYMnHZ +EObjjvbdQvmccMID +DncLKvbdURQntthN +EOcLKvbddxZtUSFz +EPCkKvbdhtzFWqtb +EOcKjvbdVBCRSpqy +DncKjvbdtbbtvvOo +EPCkKvbdczZQYZQb +DnbjjvbdQwODcLgc +EPDLKvbdtunXipsA +DncLKvbdBhjajhej +DoDKjvbdNrtVfduQ +EOcLKvbdKWUfDdfi +EObjjvbdpstHRrLU +DnbjjvbdznpRFClY +EPCjjvbdfNFvgMik +DoCjjvbdUsltGLvK +DnbjjvbdlqyVZsDi +DoCkKvbdNPwqWOHT +EOcLKvbdakLeoNcA +DoDKjvbdsCGNMGkZ +EPDKjvbdaRfDHsfL +DoDKjvbdZtIhyDrn +EPDLKvbdOStVgFUp +EPCkKvbdeATplxKG +DncLKvbdySmhlrBg +DoDKjvbdnCKWwoOV +DnbjjvbdDncKjvcE +EOcLKvbdwzIGGXdr +EObjjvbdmIdTqVSB +DnbjjvbdUGznLwVe +DncLKvbdTkvOaWPJ +DncKjvbdyOSgwsIc +DncKjvbdjmCLzFGo +DoDLKvbdpssfqqkU +EPDKjvbdmtuZjirG +EOcKjvbdOFEThhkE +DoDKjvbdIMBznWqL +EPCkKvbdJvVFcdfi +EPDKjvbdnBivxOmu +EObkKvbdTvLojTaR +DoCkKvbdMRwNZtpz +EObjjvbdEARhlzXX +DnbjjvbdcScLTcjB +DncKjvbdxmrhXrhc +DoDKjvbdEvZQQNKF +DncLKvbdGLErcHmV +DoDLKvbdFkFTChMu +DoCkKvbdOFETiIkE +EPDKjvbdnVUzLKRf +EPDKjvbdmuUzKjSG +EPCjjvbdwuNFQxkn +DncLKvbdeATpmXjG +EObjjvbdxUmEpxkn +EPDKjvbdcSbkTcjB +EPCjjvbdmbKXXoNu +EPDKjvbdSQUHKFdX +DoDKjvbdCTAbsewS +EOcLKvbdVwJYVdFH +DoDKjvbdZtIiYcsO +EPDKjvbdhkeENtcZ +EObkKvbdGBOpyJzm +EPCkKvbdRMxCYmtz +DoCjjvbdzjVPocsU +DoDLKvbdrDdiPnWB +EPCjjvbdFjdsDIMu +DoDLKvbdSLZGUgLT +EPDLKvbdKefHaaQu +DoDKjvbdKCibpicY +EOcLKvbdijGIJmYS +EObjjvbdelfWgNKL +DnbkKvbdbhmKKfWx +DoDKjvbdSQUHKGEX +EPCkKvbdnGdxMmgZ +DncLKvbdJJdAKPgE +EPDLKvbdmRyUyrdJ +EOcLKvbdhzUfLqOG +DoDKjvbdLAjgMaxR +DoDKjvbdRosfjGEX +EObkKvbdpssfqqjt +DnbkKvbdjAQHAofj +DncLKvbdidkHUoAO +DoCkKvbdCIjbLIej +DncLKvbdelfWfmKL +DoDLKvbdxUleQxkn +EPDLKvbdEvZQPljF +DncLKvbdJbjDQjCx +DncLKvbdyOTIXriD +DoDKjvbdTulPjUAq +DnbjjvbdJSyAsNYM +EOcLKvbdbBVeGQQX +EPCjjvbdbKkenmcA +EPCjjvbdiGjDZWJu +DncLKvbdcSbjsdJa +EObkKvbdZtJIyDsO +DoDLKvbdrafMkgLZ +DoCjjvbdiMFDmuDZ +DnbkKvbdnUtyjirG +EPDKjvbdfNFvflik +DoDLKvbdrWokcJZR +DncKjvbdWWhxWDdg +EPDLKvbdNeDtJJKd +EOcLKvbdqlzKYkhJ +DncKjvbdSQUHKGDw +DoCkKvbdkHflFfOL +EPCkKvbdRXNdDMID +DncLKvbdSLZFtfkT +EOcLKvbdZQldiMeR +DnbjjvbdSBdElJYk +DncLKvbdwWlBVaWV +DoCjjvbdhzUfLqOG +DoDLKvbdmJEUQuSB +DnbjjvbdULvPBVoJ +EPDLKvbdYkrDtOMN +EPDKjvbdHEKujBij +EObjjvbdJuuGDdfi +EObjjvbdzaAOgGbM +DncLKvbdkClLRHUg +EObkKvbdYTMAmToY +EObjjvbdxVMeQyLn +DoDKjvbdrEFJQNua +DncKjvbdYSlBNTnx +DnbjjvbdrSUkOLAm +EOcLKvbdrylQTBIO +DnbjjvbdrouoKDVf +DoDLKvbdwWkaVaVu +DoCkKvbdZQmFIleR +EPCjjvbdiLeENtby +DoCjjvbdrDeJQNua +EObjjvbdIGfzYxXg +DoCkKvbdySmiMqag +EOcKjvbdbVBgYLTh +DoDKjvbdLFehCApu +EPCkKvbdCDpAvJmG +EObkKvbdZLrDtOLm +EPCkKvbdZnnJEdyj +EPCjjvbdZjSgpGbG +EOcKjvbdWSOYBdkc +EPDKjvbdwtleQyLn +DnbkKvbdmJDtQuSB +EObkKvbdkWXODbXw +DncKjvbdezuyEiTw +EObjjvbdnBjWwnmu +EPDKjvbdZxdJmcMS +EPDKjvbdrbGNMHLZ +EObkKvbdEYXlTssl +DnbjjvbdyTOJNRag +DnbkKvbdGZVVAdYC +EPCjjvbdTYLMNzkY +DncLKvbdJcJcRKDY +EOcLKvbdYpmEhldq +DoCkKvbdjKFgjNYS +EPDLKvbdJbibqKCx +EPCjjvbdyTNiNSCH +DoDLKvbdGGKRmhsq +EPDLKvbdLAkGmCYR +EPDLKvbdCEPaWKMf +DoCkKvbdZsiIyDsO +EPCjjvbdjbkkRGuH +DnbkKvbdqYoHgREY +DoDLKvbdZMRctNkm +EObjjvbdDjIJvYKA +DncKjvbdVqnXbEkc +EPCkKvbdiHKCyViu +EOcKjvbdkHflGFmk +DoDKjvbdOFDsiIjd +EOcLKvbdVrOYCEkc +EPCjjvbdhtydvrUb +DoDLKvbdrNZjYlHi +EPDKjvbdVwIxWDeH +EObkKvbdhyuFlRNf +EPDLKvbdSKyFuHKs +DoCkKvbdBhjajiFj +DoDKjvbdhanbeWpq +DncKjvbdGGJqnJTq +EPDKjvbdZtJIyETO +EOcLKvbdANIZSvzY +DnbkKvbdptUHSSLU +DoDLKvbdRDcBPpdS +DoDKjvbdBcpAujNG +DnbjjvbdaaVdeopX +DnbjjvbdhtydvrUb +DoCkKvbdkWXNcaxX +DncLKvbdrNZjYkgi +EPCjjvbdBiKajiGK +EObkKvbdwkWcgzzG +EPCkKvbdRDcApQcr +DncLKvbdfekzNgHA +DoDKjvbdiBoCdwRR +EOcLKvbdIBlZdzAD +DnbkKvbdZLqcsnMN +DoDKjvbdatbGwkUI +EObjjvbdmgFXlmfy +EPDLKvbdxUmEqYkn +EPDLKvbdauBfxKsh +EObjjvbdsPvOjDVf +DnbkKvbdkVwNdBww +EPCkKvbdzaAPGfbM +EOcLKvbdRotGjGDw +EPCkKvbdqceJPmua +EPDLKvbdZyDinCkr +EObkKvbdCDoaWKMf +EOcKjvbdjmCLzEgP +EPDKjvbdHlBznXRL +DncKjvbdeOeTLTtS +EPCjjvbdGZUuBEXb +DnbkKvbdqTtHRqjt +EOcLKvbdFyUuAdXb +EPDLKvbdEARiMzWw +EOcKjvbdFeirNiUR +DoCkKvbdzjUoocsU +EOcLKvbdEztQdlCi +DncLKvbdKCjCpibx +EPCjjvbdxZhGFxFS +EObjjvbdwWkaWAvV +DnbkKvbdaaWFFoow +EOcKjvbdBsBDUGXS +EPDLKvbdmIdUQuRa +DncKjvbdVAbRTRRy +DoCkKvbdHffyxxYH +EObjjvbdDGkfHAzc +DoCkKvbdiCPDFXRR +EPCkKvbdVrNwbEkc +EPCkKvbdiGjDYvKV +DnbkKvbdIMBzmvpk +EPCkKvbdKxqJrztf +DncLKvbdmIctQuSB +EOcKjvbdaSFbhUGL +DoCjjvbdmbKWwnmu +DoCkKvbdiUyeWrVC +DncKjvbdGGKRmhsq +DoCjjvbdehLVqnQg +DncLKvbdTkunaVoJ +DnbjjvbdGZUtaDxC +EPCjjvbdtSrSyZeD +DoDLKvbdjbkkQfuH +EOcLKvbdOFDtJJLE +DnbjjvbdBdQAvJlf +DoCkKvbduDDVWvPP +EOcKjvbdZtJIyDsO +DncLKvbdQccBPpdS +DncLKvbdiUzEvquC +EPCjjvbdvvkaWAuu +DoDLKvbdZoOIeEzK +DnbkKvbdkCkkRGuH +EOcKjvbdRkZGVHLT +EObkKvbdtcCuXVno +EPCjjvbdMpYRVnGs +DoDKjvbdFfJrNiTq +DnbkKvbdZnmiFFZj +EPDLKvbdbhmKKfWx +DoDLKvbdDjHivXjA +DoDLKvbdiLeDnVDZ +EOcLKvbdUQqOtthN +EPDKjvbdZHXEAOri +EObkKvbdvAdYrndh +EObkKvbdQlwaxnUz +DoCjjvbdQwOEDLhD +EPDLKvbdqrVKnLBN +EObjjvbdwtmFQxkn +EPDLKvbdTfznMWvF +DnbkKvbdaMjasVNH +EPCjjvbdcyyQXxpb +DncKjvbdMfcQMpUk +DnbjjvbdZnmheEzK +DncLKvbdbrbkUDia +DncLKvbdiCOcFXRR +DoCjjvbdZxcimblS +EPDLKvbdRkYfVHKs +DncKjvbdDoDKjvbd +EOcKjvbdGAnpxizm +EOcKjvbdYpldhldq +DnbkKvbdQwOEDMID +DnbjjvbdcyxoxYpb +DoCjjvbdakMGOnDA +EPCjjvbdLAkGlawq +DncKjvbdJJdAKPfd +EOcLKvbdxrnImSBg +DoDLKvbdNddUJIjd +DncLKvbdfIKvRmpg +DoCjjvbdiZuGLqOG +EOcLKvbdeAURMwif +DncLKvbdiCPCeWpq +DoCjjvbdGcjvKBij +EPDKjvbdRDcBQQdS +EPCjjvbdUtMtGLvK +EPDKjvbdyXhjBoyk +DoDKjvbdqZOgfpcx +EObjjvbdYTMAmUPY +DoDLKvbdiCObeXQq +DncKjvbdmJDtRUqa +EObkKvbdSCEElIyL +EObkKvbdNGbpMouL +DoCkKvbdEzsqElCi +EObjjvbdOStWHFVQ +EPCjjvbdjmBlZdfo +EPDKjvbdiUyeWqtb +DnbjjvbdYSkaNUPY +DoCkKvbdTAEhhCPE +DoCjjvbdmttyjjSG +EOcKjvbdrMyjZMIJ +EPDKjvbdUsmTelVj +EPCkKvbdNsTugFUp +DnbkKvbdWRnYBeMD +DncLKvbdHgGzZXxH +EPDLKvbdZLrDsmlN +DncLKvbdcSbkUDjB +EObkKvbdziuPpDrt +DoCjjvbdZyEJmblS +EObkKvbdjggMFenL +DnbkKvbdmfeXmNfy +EObkKvbdiBncFXRR +EPDKjvbdADSXiyiQ +EObjjvbdLFfHbApu +EOcLKvbdRMwbZOUz +EPCkKvbdFVxoomJe +EOcLKvbdZnmiEdyj +DncLKvbdULunaVoJ +DncLKvbddndsKtTr +EPDKjvbdEztQeMDJ +EObkKvbdcScKscjB +EOcKjvbdFkErbglu +DoCkKvbdsBfMlGkZ +EPDLKvbdCSaCsfWr +EPCjjvbdVAapsRSZ +EOcLKvbdgFkzNfgA +EPDLKvbdjhHLefNk +EObjjvbdyNsIXsIc +DoCjjvbdqcdiPmvB +EOcKjvbdeXyssrFz +DnbjjvbdEOcKjwCd +DoDLKvbdGKdrbgmV +DncLKvbdKQzEoFnF +DoCkKvbdqvpMDJZR +EObkKvbdZyEKODMS +DncKjvbdBhjbKiFj +DncKjvbdfHkVrNqH +DncLKvbdeXyssrFz +EObjjvbdxmsHwriD +EPDKjvbdRyigsCvA +DoCkKvbdZoNiEeZj +EPCkKvbdhzUfLpnG +DncKjvbdVUNUFkuj +EPDKjvbdRXNdDMID +EObkKvbdlBMnmALA +EPDKjvbdffMZnHHA +EPCjjvbdEARhlyvw +EOcKjvbdVTltGLvK +EOcKjvbdJqZdoFme +EObkKvbdyOTHwsIc +DoDLKvbdCfkegAzc +DnbkKvbdZMRdTmkm +DnbkKvbdhkeEOUcZ +DoDKjvbdZnnIeEyj +DnbjjvbdrafNMGkZ +DoDLKvbdZtJIyESn +EOcLKvbdaRecITek +EPCjjvbdZoOJEdyj +DoDLKvbdxsNhlrBg +EPCjjvbdZxdKNcMS +DoCjjvbdCWzdJEov +EObkKvbdTppnttgm +DnbkKvbdjmCLydfo +EObkKvbdBsAbsewS +EObjjvbdjgflFemk +DnbjjvbdpstGrSKt +EOcLKvbdOTTvHFUp +DoCkKvbdczYowyRC +EObkKvbdTvMPjUAq +EOcKjvbdezvYeJUX +EPCkKvbdzHYlANEw +EPCkKvbdqcdiQOVa +DoCkKvbdsrrSxyeD +EObkKvbdOTUWGeUp +DoDKjvbdbUbHYLTh +DoCkKvbdHakydzAD +DoDKjvbddjJrWUzn +EPDKjvbdmaiwYPOV +DoCjjvbdtbcUwVno +EPDLKvbdrMyjYkgi +DoCjjvbdUQpoUtgm +DncKjvbdddoSBwDK +EPCkKvbdatbGwkTh +DncKjvbdmbJvxPNu +DnbjjvbdwzHeewdr +DncLKvbdzitpPcrt +EOcLKvbdrMyjYkgi +EOcLKvbdrEFIomvB +DoDLKvbdiifIJlxS +EOcLKvbdtvOYKQsA +DoCkKvbdxsNhlqag +DnbjjvbdyTOIlqag +DncLKvbdIGgZyYXg +EOcKjvbdUsmUGMWK +EObkKvbdhzUfMQnG +EPDLKvbdZxdJnCkr +DncKjvbdKWUeceGi +EOcLKvbdmbJvwnnV +DoDLKvbdDncKjvbd +EPCkKvbdZoNheEyj +DncLKvbdVqnXadlD +DncLKvbdtunXipsA +DncLKvbdjAPgBPfj +DoCkKvbdyqPNJKXA +DncKjvbdrpWPJbuf +EOcKjvbdqvpMDJYq +DnbjjvbdcTDLUDia +DnbkKvbdiGjCxvKV +EPDKjvbdauBfxKtI +DoCkKvbdLFfHbApu +DoDLKvbdHffyyXwg +EOcKjvbdIxUCHkqQ +DoDKjvbdzQoMiJwA +DoDKjvbdyYIjBoyk +EObkKvbdxnSgwriD +EObkKvbdIMBznWpk +EPDKjvbdYlSDtOMN +DoDKjvbdijGHjMxS +EOcKjvbdYkqcsnMN +DoCjjvbdmaiwYOmu +EPDKjvbdHELWKBjK +DoCjjvbdwtmFRYlO +EOcLKvbdFeiqnJTq +EPDKjvbdiBncEvqR +DoCkKvbdJXsbILpp +EObjjvbdULunaVni +DncKjvbdDwxLstUM +DoDKjvbdrWpMChyR +EObkKvbdYzcFqivZ +DncKjvbdEzspdlDJ +EPDKjvbdfMfXGmKL +DoCkKvbdCTAbtGWr +DoDLKvbdRkZGUgKs +EPCkKvbdFWZQQMie +DnbjjvbdxVNEqYkn +DoCjjvbdeFPRbWbj +EPCkKvbdZshhyESn +EObjjvbdqrVKnLAm +EPCjjvbdptUGqqjt +EOcLKvbdrEEhpOVa +DncKjvbdzQoNIjXA +DncLKvbdmgFXlnGy +DoDKjvbdZjShQHBf +DnbjjvbdjKGHjNXr +DoDLKvbdqFcdsvAh +EPCkKvbdOEdUIiLE +EPDLKvbdNeEUJJKd +EPCjjvbdzHZMANEw +DnbkKvbdqlzJyMIJ +DnbjjvbdelfXHMjL +EPCkKvbdANHyTWzY +DnbjjvbdREDBPpcr +DncLKvbdQmYCZOUz +EOcKjvbduoTzpjoU +DoCjjvbdqrUjmkBN +DnbjjvbdyfxlANFX +EOcLKvbdJmADygUa +EPDLKvbdyNrhYTIc +DoCjjvbdCTAbtFwS +DncLKvbdSwkLmzkY +DnbjjvbdjhHMFfNk +DoCkKvbdZeXfzhIb +DnbjjvbdbrbjtEJa +DoCkKvbdxrmhmRbH +DoDLKvbdrXQLbhxq +EObjjvbdTulQKUBR +EPCkKvbdMpYQumgT +DncKjvbderBWzlDP +DoCjjvbdiGjCxvJu +DoCjjvbdlZSqsZGt +EOcLKvbdZisIPfaf +DnbkKvbdHEKvKBij +DncLKvbdjSziSjiz +EPDKjvbdCEQBWJmG +EObkKvbdGGKRmiUR +EPDKjvbdMuTRkNAX +DnbjjvbdrXQLbiYq +EPCjjvbdOTUWGduQ +EPCjjvbdnBjXXoNu +DoDLKvbdcarmSAUN +DoCjjvbdNPwqWOGs +EObkKvbdUslsekvK +DnbjjvbdzaAPGfbM +DoCkKvbdGdLVjCJj +DoDLKvbdRjyFtfkT +DoDLKvbdGLFTDHlu +DnbkKvbdGFirOJUR +EPDLKvbddoFTLUUS +EObkKvbdkxrrTZGt +DncKjvbdxrnJMqag +EOcLKvbdCDpBWJmG +DoCjjvbdlqyUysDi +EPDKjvbdTfzmlXVe +DncKjvbdEuxpQMie +EOcKjvbdbLLfPNcA +DncKjvbdVgxWXgYz +DoDKjvbdrbFmLgKy +DoCjjvbdzaAPGfbM +DncLKvbdYSlAlsoY +DoDLKvbdZyEJnClS +EPDLKvbdEvYopMjF +DncKjvbdmtuZjiqf +DoCjjvbdCJKbLIfK +EOcLKvbdcIljLFvx +EObkKvbdrJAKFNPF +DoDKjvbdBiKbKhfK +EPDKjvbdWIYWYGxz +DoCkKvbdjAQGaQHK +DnbjjvbdjblLQftg +DncLKvbdbhlikGXY +EPDKjvbdZLrDsmkm +DoDLKvbdVTlsfMWK +DoCjjvbdliDsptqa +DnbkKvbdjuvmcbXw +DoCjjvbdbVCHXjtI +DoCkKvbdQvmdClID +DnbjjvbdLAkHNCXq +EPDKjvbdZtIhyETO +DnbkKvbdYkqdTmlN +DoDKjvbdMtrrKmAX +DncLKvbdJXtCIMQp +EPCkKvbdlhdTqUqa +EObjjvbdnHFYNNfy +EPDKjvbdxrmhlrBg +DncLKvbdiLeDmtcZ +DncKjvbdNrsufdtp +EObkKvbdlhcsptqa +EObjjvbdNeETiIkE +DnbkKvbdxsNhmRbH +DnbkKvbdADRxKZhp +DnbjjvbdTqROuUgm +EOcKjvbdpxoIGqDx +EOcLKvbdqBIeAWhE +DnbjjvbdCIkBjiFj +DncLKvbdTlWPBWPJ +DoCjjvbdEKHjVxKA +DnbkKvbdZRNFImEq +EObkKvbdJbicQjCx +DoDKjvbdNsTufeVQ +EObjjvbdDxYMUTsl +DoDLKvbdaSFcITfL +EPDKjvbdcTDLTcia +DoCkKvbdlhdTpuRa +EObjjvbdCJKbKiFj +DncKjvbdqAiFAWhE +EPDKjvbdUslsfLuj +EObjjvbdWWiXuceH +EPCjjvbdOEcshiLE +EPDLKvbdEJhJuxKA +DoCkKvbdKyRKSzuG +DncKjvbdHffzZXxH +EOcLKvbdSLZGUfkT +EObkKvbdHgHZxwxH +DnbkKvbdcSbjtEJa +EPDKjvbdZGwEAPTJ +DoDLKvbdeAURNXif +EPDLKvbdMpYQunGs +EObkKvbdNeDshiKd +DoDLKvbdzoQQdbkx +EPDKjvbdWHxWXfxz +EPCjjvbdCEPaVjNG +DoCjjvbdbhlikFvx +EOcLKvbdBvzdIdpW +DoCkKvbdNPwqWNfs +EPCjjvbdbhlijfWx +DncKjvbdqwQLbiZR +EObjjvbdkClLRGuH +DncKjvbdNHDQNQVL +DncKjvbdhkdcmuDZ +EOcKjvbdKWVFdFHJ +EPDLKvbdYTMBMtOx +EObkKvbdSKxfVGjs +DncKjvbdZoOJEdzK +EObjjvbdMpXqVmgT +EPDKjvbdhaoDFXRR +EPCjjvbdrpWPJcVf +EOcKjvbdczYpYZRC +DoDLKvbdLLAhWAJy +DoDKjvbdEObkLXDE +EPDKjvbdnVUykKRf +DnbkKvbdBvzdIdov +EOcKjvbdGFirOJUR +DoCjjvbdGGJrNiTq +EPDKjvbdqAheAWgd +DncKjvbdxmsIXriD +EObkKvbdVAbQsRRy +EPDKjvbdRXODbkhD +EObjjvbdVZHtZjoO +EOcKjvbdffMZmfgA +EOcLKvbdbiMjLGXY +DoDKjvbdUQpoVUhN +EPCkKvbdhfjCxuiu +DoCkKvbdziuPocsU +EObjjvbdBhkBkJFj +DnbjjvbdeAURNXif +DncKjvbdQlxByOUz +EPDLKvbdRbEEkhxk +EPCjjvbdrbFlkgKy +DoCjjvbdaSFbhUGL +EOcKjvbdsCGMkfkZ +DoCkKvbdJbicRJcY +DnbkKvbdqlzKYlHi +DoCjjvbdZyDimblS +EOcLKvbdsrqsZZdc +DoDKjvbdjggMGGNk +DnbkKvbdADSXiyiQ +DoCkKvbdehKurORH +EOcLKvbdrylPsAgn +EPCjjvbdRWmdClID +EPCjjvbdbsCjsdKB +EObjjvbdUQpoVVHm +DnbkKvbdiCObeXQq +DncLKvbdUQpoVUhN +DoCkKvbdKCicRKDY +DncKjvbdjlakzFGo +DnbkKvbdMgDQMpVL +DoDLKvbdWSNxBeMD +DnbkKvbdvBEZTOdh +EPCjjvbdsQWPKCuf +EObjjvbdZeYGzghb +DnbkKvbdxsNhmSCH +EPDLKvbdkySrTZGt +EObkKvbdrDdiQNvB +DncLKvbdHDjuiajK +DoCjjvbdURROtuIN +DncKjvbdKyRJrztf +EObjjvbdIGfyyYXg +DncLKvbdXsMBMtPY +EPCkKvbdaaVdfPpX +DncKjvbdiHJbyWJu +EOcKjvbdSKxfVGjs +DoDKjvbdxZgfFwdr +DnbkKvbdRNYCZNtz +EPCkKvbdCDoaWKNG +DoDKjvbdDjHjWYKA +EPDKjvbdyNsHwsIc +DoDKjvbdUtNTfLuj +DoDLKvbdGGKRnJTq +EPCkKvbdsBemMGjy +EPDKjvbdSQUHKFcw +DnbjjvbdkClKpfuH +EObjjvbdRyjHrcWA +EOcLKvbdSPsfjGEX +DoCjjvbdGckWKBij +EPCkKvbdGdKujBij +DnbjjvbdcJMijewY +EPDKjvbdkIGkefOL +EPCkKvbdrSVLNkBN +DnbkKvbdrpWPJbvG +DoDLKvbdZirgpHBf +EPCkKvbdHDjujBij +EPCkKvbdvBDySoEh +DoDLKvbdePEsKssr +DoDLKvbdZRMdhldq +EObjjvbdUQqPUtgm +DoDLKvbdMSXNZtpz +EObjjvbdVYhTzKnn +EOcKjvbdrNZixlIJ +DoDLKvbdTpqPVVIN +DnbkKvbdkCkjqHVH +DnbkKvbdkWWmcaxX +EOcLKvbdJSyBSlwl +EObkKvbdmRxtzTEJ +DncKjvbdptTgRqjt +EOcLKvbdqYoHfqEY +DoDKjvbdGZUtaDxC +EOcKjvbdKQydoGNe +EPDLKvbdssSTZZeD +EObjjvbdhkddOUcZ +DoDKjvbdGdKvJbKK +EOcKjvbdULvPAuoJ +DoCkKvbdrEFJPnWB +DnbjjvbdfNGWfmJk +EPCkKvbdkWXODaww +EOcKjvbdMtrrKmAX +DnbjjvbdEuyPpMie +EObjjvbdrSVKmkAm +EPDLKvbdhanbdvqR +DoCkKvbdkWWmdBww +DnbjjvbdxUleQyLn +EOcLKvbdpyPHfpdY +DncKjvbdpfDeTvBI +DoCkKvbdnVVZjirG +DnbkKvbdzjVPocsU +EPDLKvbdmfdwlmfy +DnbkKvbdSKyFuGjs +EObkKvbdVAaprpqy +EPCjjvbdUaBqTRRy +EObkKvbdZoNhddzK +DncKjvbdrNZiyLhJ +DncKjvbdaMkBruNH +DoDKjvbdZyDjNcMS +EPCjjvbdZjTIQHCG +EObkKvbdjJegilwr +EPDKjvbdHffzYxYH +EPDKjvbdaSGChTfL +DoDLKvbdcJMjLGWx +EOcLKvbdtlXvaTaX +DoCjjvbdGYuVAcxC +EOcLKvbdUsltGLvK +EPDLKvbdRNXayOUz +DoDLKvbdRadFLiYk +EOcKjvbdCTAbsfXS +EPCjjvbdGZVVAdYC +EPDLKvbdypnliJwA +EPCjjvbdSBdFLhxk +EOcLKvbdGLFSbhNV +DncKjvbdTppnuUhN +EObkKvbdezvYdiTw +DoCkKvbdIsZBSlxM +DncLKvbdRNYBxmtz +EPCkKvbdeFOqawCj +DnbjjvbdtSrTYzEc +DncKjvbdkDLkQgUg +DnbjjvbdEARhlzXX +EOcKjvbdWRmxBeMD +DoDLKvbdzQnliKXA +EPDKjvbdpfDdtWAh +DncLKvbdMgCpMpVL +DnbkKvbdiZtfLpmf +EPDLKvbdzQoNJJwA +EPCkKvbdaNKasUmH +EPDLKvbdRbDeLhyL +DoDLKvbdKRZeOeme +EOcKjvbdZxdJmcMS +DncLKvbdeKKSVtzn +EPDLKvbdRjxeuHLT +EObkKvbdNGcPmPtk +DoCkKvbdtcDVWvPP +EPCjjvbdcTDKscjB +DoDLKvbdbrcLTcia +EObjjvbdvlvAMcdm +EObjjvbdFxuVBDwb +EPCjjvbdhkdcmtby +EOcKjvbdRotHKFcw +DncLKvbdelfWgNKL +EObkKvbduCbuXVno +EPDKjvbdEYXlUUUM +EOcKjvbdbUbHXjsh +EOcLKvbdmgEwmOHZ +DoCjjvbdEXxLsssl +EPDLKvbdZLqdTmlN +EOcLKvbdbsCkUEJa +EOcKjvbdqvpLbhxq +EOcKjvbdfIKvRmpg +DncLKvbdGBOpxizm +DoDLKvbdnBiwXnmu +DoCjjvbdKWVFceGi +EOcLKvbdRbEEkiZL +EObjjvbdffMZmgHA +DoCjjvbdUMWPBWPJ +EObkKvbdkClKpftg +DoDLKvbdBhkBkIej +DoDKjvbdhgJbyWJu +DoCjjvbdEASIlzXX +EPDKjvbdGZUtaDxC +DnbjjvbdlYsRryHU +EOcKjvbdhgKCyWJu +EPCkKvbdsQWOibuf +DoCjjvbdRMwbYmtz +DoDKjvbdZxdJnClS +EPCjjvbdJTZBTNYM +DnbjjvbdiLeEOUby +EOcLKvbdjEjgUoAO +EPCkKvbdzitopDrt +EPCjjvbdtcCuWvPP +DncKjvbdZMRdUNlN +DoDLKvbddZxoxZRC +DoDKjvbdFVxoomKF +DoCkKvbdSLYeuGkT +DncLKvbdYSlBNTnx +EObkKvbdeuzwoizs +EPDKjvbdUQpoUuIN +DoDKjvbdmpZxujyC +EPCjjvbdDGlFgAzc +EPCjjvbdkCkkRGuH +DnbkKvbdvlvAMdFN +DoDLKvbdatbHXkUI +EPCjjvbdFWYoolie +DnbjjvbdrEFJPnWB +EObkKvbdpyOggQcx +EOcKjvbdqwQMChxq +EOcKjvbdqrVLNkAm +EOcKjvbderBWzlCo +DoDLKvbdRWmdDMHc +EOcLKvbdZoNhdeZj +DnbkKvbdunszpkPU +EPDKjvbdGAnpxizm +DoCkKvbdKCjCqKCx +EOcKjvbdZshhyDrn +DoDKjvbdddoSBvcK +DncKjvbdcScKtEJa +EOcLKvbdZjShQGbG +DncLKvbdDncKkXDE +EPDLKvbdrzMQTBHn +EPDLKvbdIxUBglRQ +EPDKjvbdcyxpXxpb +EObkKvbdMSXMytpz +EObkKvbdijGIKMwr +EObkKvbdzdzOzdyp +DnbjjvbdeATplwjG +DnbkKvbdcIlikFwY +DoDLKvbdsPunicVf +EPDKjvbdmozYvLZC +DoCkKvbdkyTSSxgU +DncLKvbdRWnDcLhD +DncKjvbdHELWJaij +DncKjvbdZQmFIleR +EOcKjvbdiCOcEvpq +EOcKjvbdbrbkUEKB +EOcLKvbdOFEThhjd +EObkKvbdbBVdepPw +EObkKvbdUxhTzKnn +EObkKvbdzoPpdblY +EOcLKvbdrbFllHLZ +DoDKjvbdjggMGGOL +DncLKvbdqceJQNua +DoDKjvbdiHJbxvJu +DoDLKvbdySnImSBg +EPCkKvbdtTRrxzFD +EOcLKvbdkVvnEBxX +DnbjjvbdtcCtvvOo +EPCkKvbdyzdmrHiI +DoDKjvbdFjdrbhMu +DoDLKvbdZyEKODLr +DoDKjvbdURQnuVHm +EPCkKvbdZyDimcMS +EOcLKvbdNQXpunHT +DnbjjvbdQlxCYmtz +DnbjjvbdCDoaVimG +EObjjvbdsPvOibvG +DnbjjvbdgGLynGgA +DncLKvbdCDoaWJmG +EObkKvbdnCKXXnnV +EOcLKvbdUxgtZkPO +DnbkKvbdiMFDmuDZ +DncKjvbdiGicZWKV +DoDKjvbdcScKtEJa +DoDKjvbdpssgRqkU +DncKjvbdsBfNLgKy +DoDLKvbdGYttaDwb +DncKjvbdjvWnDaxX +EPCjjvbdhgJcYuiu +DnbjjvbdxUldpxlO +DoDKjvbdUaCRSqSZ +DnbkKvbdNwoVzdNt +DoCkKvbdZnnIeEzK +EPDKjvbdNeEUJIkE +DnbjjvbdJbjDQjDY +EPDLKvbdKVuFceGi +EPCkKvbdKkBIWAJy +EObjjvbdrafMlHLZ +EOcLKvbdZLqctNkm +EObjjvbdMgComPtk +DncKjvbdjhHMGGOL +DnbkKvbdJYUCIMQp +DoCjjvbdhlEcnVCy +DoDLKvbdxsOJNSBg +EOcLKvbdRMxBxmtz +EOcLKvbdHDjujCJj +EObjjvbdZRMdhmFR +EPDLKvbdUQpoUthN +EPCkKvbdvlvANEFN +EObkKvbdSCEEkhxk +EPCjjvbdLBKfmCXq +EPDKjvbdOStVfduQ +EPCjjvbdGcjvJbKK +DnbjjvbdVBBprpqy +DoCjjvbdirziTLJz +DncLKvbdFWYpQNKF +DoDLKvbdjKGHjNYS +DncKjvbdZnmiEdzK +DoDKjvbdySmiMrBg +DncLKvbdeAURNYKG +EPDLKvbdemGWflik +DoDKjvbdaMkBrtmH +DoDKjvbdIxUBglRQ +DoDKjvbdOEcshhjd +EPCjjvbdpxnhGqDx +DncKjvbdYSlBNToY +DnbjjvbdGGKSOJUR +EOcLKvbdZjTHpGbG +EPCjjvbdIHGzZYXg +DncKjvbddndsLTsr +DnbjjvbdqAheAXIE +EOcKjvbdVhXvXfxz +DncKjvbdFyVVAdYC +DnbjjvbdJvVFceGi +EPCkKvbdoznDjwoA +EPDKjvbdvPTzqLPU +EObjjvbdiifIKMwr +EOcLKvbdlZTSSxgU +EObjjvbdQvnECkgc +DncLKvbdjgfkfGNk +DnbkKvbdCDoaWJmG +DnbkKvbdxnTHwriD +DncKjvbdoAKzshDn +DoDKjvbdvAdZSndh +DnbjjvbdRpTgKFcw +EOcLKvbdiiegilwr +EOcKjvbdGdLVjBjK +EObkKvbdGFjRmhtR +EPCjjvbdZsiJYdTO +EPCjjvbdJJdAKPfd +EPDLKvbdKfGHbBRV +DncLKvbdjhHMFenL +EObkKvbdbLMFnnDA +DoCjjvbdUWMPisaR +DnbkKvbdZjTHpHCG +EObkKvbdbsCkTcjB +EPCkKvbdSLYfUfkT +DoDKjvbdZeYGzhIb +DncKjvbdrovPJcVf +EPCjjvbdePFSjtTr +DncKjvbdJbibqJbx +EPDLKvbdDxYMUUTl +DnbkKvbdZHXEAPSi +DncKjvbdVTmUFlVj +EPDKjvbdzoQREcLx +EPDKjvbdKfFhCAqV +DoDKjvbduDDUwVoP +DoDKjvbdgFlZmfgA +EObjjvbdTAEiHbOd +DoCkKvbdMowqVmgT +DncKjvbduMXwBTaX +DncKjvbdeYZssrFz +DncLKvbdmfdxNNgZ +DncLKvbdxLXDgzzG +DoCjjvbdNsTvGduQ +EPDLKvbdTpqOtuHm +EObkKvbdZMRctOMN +EPCjjvbdHEKuibJj +EPCjjvbdBiKbLJGK +DoCjjvbdUtNUFkvK +EOcKjvbdVTltFkuj +DnbjjvbdczYpXxqC +EPDLKvbduWNxKQsA +EOcKjvbddZyQYYqC +DnbkKvbdyfyMAMdw +DncLKvbdDihKWXjA +EPCjjvbdoAKztIDn +DoCjjvbdcTDLUDjB +EPDKjvbdJcJcRKCx +DncKjvbdIxTahLqQ +DoDLKvbdTqROttgm +DoDKjvbdjblLQgUg +EOcLKvbdTppnuUhN +EPCjjvbdrMyjZLgi +EObjjvbdypnmIjXA +DoCkKvbdczYoxZRC +EObkKvbdFjeTDHmV +EPCjjvbdZxcimbkr +DoDKjvbdatbHXkUI +EPDKjvbdvmWAMdEm +DoCjjvbdqwQMCiYq +DoDKjvbduWNwjQsA +DncKjvbdACqwjZiQ +DoCjjvbdOTTvGduQ +EObkKvbdirzhsKiz +EObjjvbdOTTugFUp +EOcLKvbdKDJbqJcY +DoCjjvbdiUyeXRtb +EObjjvbdfMfXHNKL +EOcKjvbdjhHMFfNk +DncKjvbdRpUGjFcw +EPCjjvbdfILVqnRH +EOcKjvbdiHKCyWJu +DoDLKvbdnPzYvLYb +DnbkKvbdnGeYNOHZ +DoDKjvbdtvOXjQsA +EPCjjvbdmIctRVRa +EOcKjvbdpyOhGpcx +DnbkKvbdKQydoFnF +DoDKjvbdkVvnDaww +EObjjvbdbUbHXjsh +EOcKjvbdCJLCLIfK +EPDKjvbdZeYGzhJC +DncKjvbdcScLUDia +DoCkKvbdQmXbZOUz +EOcLKvbdRadFMIxk +DnbkKvbdziuPodSt +EOcKjvbdEXxMUUTl +DnbjjvbdegjvSOQg +EObkKvbdZtJJYdTO +EPDKjvbdVAbQsQrZ +DnbkKvbdkHflFfOL +EObkKvbdtcCuXWOo +DnbjjvbdcTDLUEJa +EPCjjvbdZjTIQHBf +EObjjvbdTAEhhCPE +EOcLKvbdbhlikFwY +DoDLKvbdEPDKkWbd +EOcKjvbdZtJJZESn +EPDKjvbdZMRdUNlN +EPCkKvbdhgJcZWJu +DncKjvbdUaBqSprZ +EOcLKvbdEJgiuxKA +EObjjvbdSPtHKFcw +DoCjjvbdFfKSOJUR +EObjjvbdVrOXaeMD +DoCjjvbdrXPkcIxq +DoDKjvbdZjTHofaf +EOcLKvbdVYgszLOn +DncKjvbdIwsagkpp +DncLKvbdTkvPBVni +EOcLKvbdUtNUFkuj +EObjjvbdZnmheEyj +EPDKjvbdyYIjBoyk +EPCkKvbdqlyiyMIJ +EPCjjvbdYzbeqjVy +EOcLKvbdUQqOuVIN +EObkKvbdZMSDtOMN +DncKjvbdVvhxWDdg +EOcLKvbdiZuFlRNf +EObjjvbdZtJJYcrn +EPCjjvbdmuUzKirG +DoDLKvbdVUMtGMVj +EPDLKvbdhWyAzzAJ +DoDLKvbdfIKvRmqH +DnbjjvbdqdFIpOVa +DnbkKvbdIwtCHkpp +EOcKjvbdeEnrBvcK +DnbkKvbdJuuFdFGi +DoDKjvbdeOeTKtUS +EObjjvbdKWUfDeGi +EPCjjvbdiHJbyViu +EOcKjvbdBraCsfWr +DoCjjvbdGYuVBEYC +DoCkKvbdnHEwmOHZ +EPDKjvbdZisIQGaf +EPCkKvbdmpZxvKyC +DoDLKvbdmSYuZrdJ +EObkKvbdKDJbqKCx +EOcLKvbdZsiJZETO +EPDKjvbdnCJvxOmu +DoCkKvbdjgflGGOL +DnbkKvbdRosfjFdX +EPCjjvbdRECaQQcr +DnbkKvbdNHComQVL +EPCjjvbdrJAKEmOe +DoDLKvbdqBJFAXIE +DncLKvbdGLFTDINV +EOcLKvbdhgJbxujV +DnbkKvbdjSzhsKiz +EOcKjvbdKWVGDdfi +DoDKjvbdZnnIeFZj +DnbjjvbdxxIiaoyk +EObkKvbdczYpYZQb +EPCjjvbdZxcjODMS +EObkKvbdiHJbxvKV +DoCjjvbdJzoexEAN +DoCjjvbdaRfChTek +DoDLKvbdxwhjCPyk +DoDLKvbdVqnYBeLc +DnbkKvbdRDcBPpdS +EObkKvbdYqNFImFR +EPDKjvbdsrrTYzFD +EOcKjvbdqcdhpOWB +EOcKjvbdaNLCTUmH +DoDKjvbdnPzYukZC +DncLKvbdKCjDRKCx +EObjjvbdFkEsDINV +EPDKjvbdMgDQMouL +DncLKvbdOXnuzdNt +EPCjjvbdpstGqrLU +EPCkKvbdRbDdkhyL +DnbkKvbdaogGdLzd +DncKjvbdjlbLydgP +DnbjjvbdUMVoAvPJ +EPCjjvbdJqZeOfOF +DoDLKvbdUsmTekvK +DoCjjvbdpyOgfpcx +DnbkKvbdJYUCIMRQ +DncLKvbdjJfHjMwr +DoCjjvbdRosgKGDw +DoCkKvbddZxpYYqC +DncKjvbdddnrBwCj +EPDKjvbdijGIJlxS +DoCjjvbdkWWnECYX +EObkKvbdqlzJxlIJ +EOcLKvbdzaAPHHBl +DoDKjvbdlZTSSyGt +DnbjjvbdatbHXkUI +EOcLKvbdNdcshiKd +DncKjvbdGdKujBjK +DnbjjvbdRWnDcMID +DoCjjvbdSxKlNzkY +EPDKjvbdHDkWJbJj +EPDLKvbdZxcjNcLr +EOcKjvbdLYqKSzuG +EPDLKvbdjuvmcaww +EPDKjvbdxmrhYTJD +EOcKjvbdZirhPfaf +DnbjjvbdfIKurNqH +EPCkKvbdYTLaNTnx +DoDLKvbddtAUASlv +EPCkKvbdZLrDtOLm +DnbjjvbdnGdxMnHZ +DoCjjvbdeFPSCXCj +DncLKvbdYORAYUvU +EPCjjvbdrXQMDJZR +EPCkKvbdRpTfjGDw +DoCjjvbdpssfrSKt +EPCkKvbdKWUedFHJ +DnbjjvbdVvhwvDdg +DncKjvbdLrWlzUpz +DncKjvbdwtmFQxkn +EObkKvbdmIdTqUqa +DnbkKvbdJutedFHJ +EOcKjvbdVZITykPO +DoDLKvbdhbPDFXQq +DnbjjvbdmuVZjirG +DncLKvbdieKgVPAO +DncKjvbdEuyPpNJe +DoDKjvbdiHJcYuiu +EPDKjvbdmgFYNNfy +DnbkKvbdOTUWGeUp +DoCjjvbdZRNFJNFR +EPDLKvbdYpmFJNEq +EObkKvbdRMxBxnUz +DncKjvbdNQYQvOHT +EOcLKvbdMoxRVnHT +DoDKjvbdpyOhGpcx +EObjjvbdRyjITDWA +EObjjvbdrykosAhO +EOcLKvbdhaoDFXRR +DoDLKvbdIryBSmYM +DnbjjvbdlZSrTYft +DncLKvbdegjurORH +EOcKjvbdJYUCHlRQ +EOcLKvbdREDApRES +EObjjvbdmgFYMnHZ +EPCkKvbdZyDimblS +DoCkKvbdiCPCdwQq +EObkKvbdbVBgYKtI +DoDLKvbdNddUJJLE +DoCjjvbdrpVnibuf +EPDLKvbdKaLGlbYR +DnbjjvbdTpqPVUhN +DoCjjvbdcyxoxYpb +EPDKjvbdhfibxvJu +EPCjjvbdJpydnfNe +DncLKvbduWOXipsA +DoDKjvbdrRtkNkAm +EObkKvbdNQXqVmgT +EObkKvbdCIkBkJFj +EPDLKvbdqUUHSRjt +EOcLKvbdeYZtTqez +EPCjjvbdqUUHRqkU +DncKjvbdkWXODaxX +EPCkKvbdaNKbTVNH +EPCjjvbdvAcxroEh +EOcKjvbdlZTSTZGt +EOcLKvbdLAkHNCYR +DoDLKvbdUtMselWK +EPCjjvbdnVUzKjRf +DoDLKvbdypoMiJwA +EObjjvbdKDKCqKDY +DoCjjvbdrWolDIxq +DoDKjvbdwyhFfXeS +EOcKjvbdnGeYMmgZ +DoDLKvbdREDAopcr +EPCjjvbdiUzFXRuC +DoDLKvbdZQldhmEq +EPCjjvbdtvNwipsA +EPDKjvbdbrcLUDia +DoDLKvbdegkVqnQg +DoCjjvbdznopdcMY +DoCjjvbdmfeXlmgZ +DncLKvbdXrlBMsnx +DoCjjvbdmgEwmOGy +DoCkKvbdjmCLydgP +DncLKvbdmJEUQuSB +DnbjjvbdRbDeLiYk +DnbkKvbdQdDBPqDr +EObkKvbdjKGHjMxS +DoCkKvbdyOTHxSiD +EPCjjvbdQwNdCkhD +EObjjvbdfNFwGljL +EObjjvbdVqmxCElD +EOcKjvbdeOeTKtTr +DoDKjvbdUaBqSpqy +DnbjjvbdmIdURUqa +DoCkKvbdUWMQJtBR +DnbjjvbdxnSgxSiD +DncKjvbdwXMBVaVu +DnbjjvbdvvkaVaWV +EObkKvbdmaiwXnmu +DoCjjvbdgQBzwEYI +EOcKjvbdFVxpPmJe +EObjjvbdKDJcQjCx +DoCkKvbdYlRdUOMN +EOcLKvbdZoOIddzK +DoCjjvbdffMZnHHA +DncKjvbdnQZxujxb +EPDLKvbdwXMBWBVu +DoCjjvbdLFfIBaQu +DncKjvbdGQASwHFy +DnbkKvbdauBfxKsh +EOcLKvbdraelkgKy +EObkKvbdnVUzLKSG +DoDKjvbdANHxrwZx +DncLKvbdqZPHfqEY +EObjjvbdvPTzpjoU +EObjjvbdrWpMDIyR +DnbkKvbdCDpBWKNG +DnbkKvbdyOSgwrhc +DnbkKvbdeKKSVtzn +DncKjvbdMowpumgT +EOcLKvbdOFDtIhjd +EPDKjvbdkDMLRGtg +EPDKjvbdiiehJlwr +EPDLKvbdBdQAvJlf +DoDLKvbdZyEKODMS +EObjjvbdJqZePFme +DnbkKvbdKxqKSztf +EObkKvbdmJEUQuSB +DnbkKvbdREDAopdS +EPDKjvbdwzHefYEr +EPDKjvbdnHExMnGy +EOcKjvbdmozZVjyC +EPDKjvbdZHWdAPTJ +DoDKjvbdjgfkfFnL +DncKjvbdczZPxYqC +DoDKjvbdEXwlUUTl +DncKjvbdhuZdvrVC +DnbkKvbdxKwDgzzG +EPCkKvbdsZlQSaIO +EOcKjvbdzRPMiKXA +DoDKjvbdqvolDIxq +DoDKjvbdQdCaPpcr +EPCjjvbdJmADyfuB +DnbjjvbdsCGNLgLZ +DoDKjvbdKfGICAqV +DoCkKvbdbiNJkGXY +DncKjvbdiGicYvKV +EPCjjvbdSxLLmzjx +DncKjvbdLAjflaxR +EPCkKvbdUyHsyjoO +DnbjjvbdcyxoxYqC +EObkKvbdxZgfGYFS +EPDLKvbdZoNiEeZj +DncLKvbdZtIhxcrn +EPDLKvbdIwtCILqQ +DncLKvbdQmXbYmtz +EOcLKvbdmuUzKiqf +EPDKjvbdsQVnibuf +EObjjvbdOSsugEtp +EOcLKvbdYlSETnLm +EObkKvbdUtNUGMWK +DoDLKvbdzeZnzeZp +DoDKjvbdqTtHRqkU +EObjjvbdmbJvxPNu +DoDLKvbdliDsqUqa +EPCjjvbdhanbdvpq +DoDKjvbdiifHilxS +DoDKjvbdmJDsptqa +DnbkKvbdDncKkWcE +EPCkKvbdaofgELzd +DncKjvbdijGIJmXr +EPCkKvbdRkYfUgLT +EObkKvbdHEKuibKK +DnbjjvbdVhXuwfxz +DoDLKvbdiMEcmuCy +DnbkKvbdJcJcQibx +DnbkKvbdmfeYNOGy +DoDKjvbdqUTgSSKt +EPDLKvbdePErjtUS +EObkKvbdaNKasUmH +EObkKvbdiifIJmYS +EOcKjvbdsPunjCvG +EObkKvbdbrcKtDjB +EPDKjvbdbhlikFwY +EPCjjvbdrpVnjDWG +EPCjjvbdaMkCStlg +DncKjvbdMpXqVnGs +EPDLKvbdZjShPfbG +EPDLKvbdfHkVrOQg +DoCkKvbdDnbjjvbd +DoCkKvbdkySqsYft +DoDLKvbdZRMeImEq +DoDLKvbdYpleIleR +DncKjvbdiHJbyViu +EObkKvbdrMyixkgi +EPDKjvbdqvokbiYq +EOcKjvbdzitoodTU +DnbjjvbdVYhTyjnn +EPDLKvbdyYJJbPzL +EObkKvbdeFPSCWcK +EPDKjvbdIsZArlxM +DnbjjvbdkIHLfGNk +DoDLKvbdehLVqmqH +EOcLKvbdvBEZTPFI +DncKjvbdnUuZjirG +EPCjjvbdakLfOnDA +DnbkKvbdEzsqEkcJ +DnbjjvbdVhXvXgYz +DoCjjvbdIryBTNYM +DncKjvbdZirgpHBf +DoDKjvbdEYYLsstM +DnbjjvbdZshhyETO +DoCjjvbdOTUVgFVQ +EObjjvbdZisHpGbG +DoDLKvbdkDLkRGtg +EObkKvbdegjvSNpg +DncLKvbdfIKvRnQg +DncLKvbdJKEAJpGd +DncKjvbdrRtkNkBN +EPCkKvbdjvWnDaxX +DoCjjvbdmfdwmNgZ +DnbjjvbdbrcLUEJa +DncLKvbdnQZxujxb +DoDKjvbdNsTugEuQ +EOcKjvbdUVlPisaR +EObkKvbdHDjujBij +EPDLKvbdSBdFMJYk +EPCkKvbdVvhxVdFH +DncKjvbdIsYaTNXl +EPDLKvbdIrxaSlxM +EPDKjvbdfoazwDwh +EPCkKvbddeOqbXDK +DoCjjvbdJpzEnfNe +DncKjvbdqiAKFNOe +EPDLKvbduDCtwWOo +DnbjjvbdZjShQGbG +EObjjvbdVAbQsRSZ +DncLKvbdtcCuWuoP +DoDKjvbdTvLoitAq +EOcLKvbdZQleIleR +DoCkKvbduLxXAtAw +DnbjjvbdqYoHfqDx +DoDKjvbdJYTbHkqQ +DncLKvbdGZUtaDxC +EObjjvbdqFdEtWAh +EPCkKvbdILaznWqL +EObkKvbdQwNdCkhD +EPCkKvbdmJDsqUqa +EOcKjvbdvBEYrneI +DoDKjvbdapGgELzd +DoCjjvbdwWlAvAvV +DoDLKvbdJbicQicY +EPDKjvbdaaVdepPw +DoCkKvbdsZkosAhO +DoCkKvbdNeETiJKd +EObkKvbdEObkLXCd +EPCjjvbduCbuXVno +DoCkKvbdrykpTBHn +DnbkKvbdrEFIpNua +DoCjjvbdlYrrSxft +DoDLKvbdqdFIpOVa +EObjjvbdrbFmMGjy +DnbkKvbdRpUHKGDw +EOcLKvbdzoPpdcMY +DoDLKvbdfILVqnQg +DoCkKvbdlZSqsZHU +DncKjvbdrzMQSaIO +DoCkKvbdhuZeWrUb +EObjjvbdfSAvzkbo +DoCkKvbdVZIUZjnn +EOcLKvbdhlEdOUcZ +DoDKjvbdbUagXkUI +DoCjjvbdqUTgRqjt +DoDLKvbdqTsfrRjt +DnbkKvbdrouoKCuf +EPDKjvbdmbKXXoNu +DoDLKvbdhbPDEwRR +DncLKvbduVnYKRTA +DoCjjvbdcJNKKfXY +EPCjjvbdeFOrCXDK +EPCkKvbdczYoxYpb +DnbkKvbdKfGHaaRV +DoCjjvbdMuTRjmAX +DoDKjvbdkMalZeGo +DnbkKvbdbhmKLFvx +EPDLKvbdjuwODbXw +DoDLKvbdUMVoBVoJ +DoCkKvbdRpTgJfDw +EOcLKvbdajlFoNcA +EPCjjvbdRMwaxnUz +EOcLKvbdJcJbpjDY +DoCjjvbdjhHLefNk +EOcLKvbdcasNSATm +DoDKjvbdyOTHwriD +EObjjvbdKQydnenF +EObjjvbdZirhPgBf +EPCjjvbdBiKbLIfK +EOcKjvbdNeDtIiKd +EOcKjvbdkDLjqGtg +DoDKjvbduDDVWuoP +DncLKvbdePErjtTr +EOcKjvbdJbicQjDY +EPDKjvbdrylQTBHn +DnbjjvbdkMbMZeGo +DncLKvbdtlYWaUAw +DoCjjvbdDwxMUTtM +EObkKvbdjblKqGtg +DoDKjvbdRMxCZNtz +EObkKvbdqYoIGqDx +EPDKjvbdmfeYNNgZ +EObjjvbdTAFIhCPE +DoCjjvbdjKGIKMxS +EOcLKvbdMpYRWOHT +EOcLKvbdMoxRVnGs +DncKjvbdhaoDEwQq +DnbkKvbdEXxMTtTl +EPCkKvbdMgCpMpVL +EObjjvbdRzKITDWA +EOcLKvbdrzLosBHn +EPCkKvbdBraCsfWr +DoCkKvbdaaVeGPow +EOcLKvbdIGgZyXxH +EPDKjvbdliETptqa +EOcLKvbdbKlGPODA +DnbjjvbdRadElJZL +EPDLKvbdjFLHVPAO +DnbkKvbdiBnbdwRR +EObkKvbdvBDyTOeI +DnbjjvbdUyHtZjnn +DnbkKvbdmgFYNOGy +DnbkKvbdGKdsDHlu +EPDLKvbdZRNEiMeR +DoCkKvbdbLLeoODA +EObkKvbdANIZSvzY +DoCkKvbdziuPpDrt +DnbjjvbdWHwvXgYz +EPDKjvbdsBfNLgLZ +DoCkKvbdWWiXudFH +EPDLKvbdwzIGGYEr +EOcLKvbdVTmUGMWK +EObjjvbdMSXMytpz +DncKjvbdZirhQGaf +EObjjvbdCJLBjiGK +EPCjjvbdZLrETnLm +EObjjvbdelevfljL +DncKjvbdGYuVBEYC +EPCkKvbdkCkjpgUg +DoCkKvbdbhljLFwY +DnbjjvbdeEoSBvbj +DncLKvbdvAcyTPFI +DnbkKvbdjblLQgVH +EPCjjvbdeEoSBvbj +DnbkKvbdaMjbStlg +EObjjvbdrDdhpOWB +EOcKjvbdbKlFoODA +EPDLKvbdZjTIQGaf +EObjjvbdEzsqEkcJ +DnbjjvbdZRNEiNEq +EObjjvbdqlzJxlIJ +DnbkKvbdkIHLfFmk +EObkKvbdMtrrKmAX +EPCkKvbdNQXpvNgT +EPCkKvbdbrcKtEKB +EObjjvbdSPtGjGEX +DoDKjvbdxwiJaoyk +DnbjjvbdVYhUZkPO +DoDLKvbdXrlBNUPY +DoDKjvbdZnmiEdzK +DoCjjvbdWWiXvDeH +DoDLKvbdyNsHwsIc +DoDKjvbdwyhFfYEr +EPDLKvbdNeDshhkE +EPDKjvbdBiLBkJFj +EOcKjvbdJqZdoGNe +EOcKjvbdbAvEepQX +DoCjjvbdaNLBsUlg +EPDLKvbdvBDxsOdh +DncKjvbdGFirNiTq +EPDLKvbdZnmiEeZj +DncLKvbdePFSjtTr +EOcKjvbdnGdwlnHZ +EOcLKvbduDDUvuno +EObjjvbdZQmFIldq +DoCkKvbdcyxpYYqC +EOcLKvbdMRvlzVQz +DoCjjvbdtcDUwVoP +EPCkKvbdrXQLbhxq +DoDKjvbdkVwODbXw +DnbjjvbdnCJwYOmu +DnbkKvbdqvpLbhxq +DoDKjvbdKDJcQjDY +DnbkKvbdvwMAvAuu +EPDKjvbdtvNxKRTA +DoDKjvbdYkqctOMN +DoDKjvbdtcCuWvOo +DoCjjvbdEObkLXDE +DoCkKvbdbrbjtDia +EObkKvbdDncKkXDE +DnbjjvbdxxJKBozL +EPCjjvbdbhlikGWx +DncKjvbdJXtCIMRQ +EOcLKvbdkVvmcaxX +DoCjjvbdqwPkbhyR +EObjjvbdySnImRbH +EObjjvbdZQleImFR +EObkKvbdmpZxujyC +EPCjjvbdhbPDEvpq +EObkKvbdpyPHgREY +DoDLKvbdwzIGGXeS +EObjjvbdaSGChUGL +DoDKjvbdrbFmMGkZ +EPCkKvbdxKwEHzyf +DnbkKvbdJXtBgkpp +EPCkKvbdlZTRrxft +EOcKjvbdFVyPpNKF +DoCkKvbdaRecHsek +DoDKjvbdFfKRnJUR +DoCjjvbdyOTIXrhc +DoDLKvbdyOSgxShc +DoDKjvbdEOcKjwCd +DoCjjvbdzoPpeClY +DoCkKvbdURRPVUhN +DoDLKvbdVqmxCFMD +EOcKjvbdNVSrKmAX +EOcKjvbdTvLpKTaR +EPDLKvbdCTAbtFwS +EPDLKvbdZyEKNblS +EOcLKvbdsCFllHLZ +EObkKvbdjlbMZeHP +EPDKjvbdMpXpunGs +EObjjvbdaNLCSuNH +DoDLKvbdkCkjqHUg +EPCjjvbdTYKlNzjx +DnbjjvbdNxOuzdOU +DoCkKvbdegjvRmpg +DoCjjvbdhfjCyWKV +DncLKvbdjggMFfNk +EOcKjvbduVmwjRTA +DnbkKvbdDjHiuxKA +EOcLKvbddePRavcK +DnbkKvbdwkWcgzyf +DnbkKvbdHlBznXQk +EPCkKvbdatafxKsh +EPCjjvbdcJMjKfXY +DoDKjvbdrDdiQOWB +DoDLKvbdVvhwvEEg +EObjjvbdwjvdHzzG +DncLKvbduMYXAtAw +DoDLKvbdZQmFJNEq +EPCjjvbdyOTIXriD +DoCkKvbdbiNKLGWx +DncKjvbdHEKvKBij +EPDLKvbdYlSDtNkm +DoDKjvbdTqROuVIN +EPCkKvbddeOqbXCj +EOcLKvbdCTBCsewS +EPCjjvbdnUtykJrG +DnbjjvbdlZTSSyGt +EPCjjvbdjmBkyeGo +DnbkKvbdVhXuwfxz +DncLKvbdePFTLTsr +EOcKjvbdemGWgMik +EObkKvbdhuZeWquC +EPCjjvbdEvYpQNKF +EOcKjvbdpaJFAXHd +DoDKjvbdJSyBSmYM +EOcLKvbdSCDdlIxk +DncKjvbdSLZGVGkT +DnbkKvbdrbFlkgKy +EObjjvbdJSyAsMwl +EOcKjvbdEOcKkXDE +EPCjjvbdMoxQumfs +EPDKjvbdUQpnuUgm +DncKjvbdaaWFFoow +DnbkKvbdakMGPODA +EObkKvbdrEEhomua +EOcKjvbdmozZWLYb +EObjjvbdVgwuxGxz +EOcLKvbdCJLCKhej +EPDLKvbdVUNUGLvK +EOcLKvbdLGGHbBRV +DoCkKvbdlqxtysEJ +EOcLKvbdcScLTdKB +DncKjvbdhtydwRtb +DoCjjvbdcTCjscia +DncLKvbdUslsekuj +DoDKjvbdwuNFRYkn +EOcLKvbdijGHjNYS +DoCjjvbdJSyBSmYM +DoDKjvbdEYXlUTtM +EPDKjvbdUyITzKoO +DnbkKvbdvBDyTPFI +DoDKjvbdYlRcsmkm +DoDKjvbddePRbXCj +EPCkKvbdVZHtZjoO +EPDLKvbdWXIxVceH +EPCjjvbduDDUwVoP +DncKjvbdQlxBxnUz +DoDLKvbdfpBzvdYI +DoCjjvbdMJBlRYAS +EPCkKvbdZisHofaf +DnbkKvbdkWXNdCXw +EOcKjvbdEYXkstTl +EOcKjvbdfekymgHA +EPDKjvbdelfWflik +EPCjjvbddCTNSAUN +EPDKjvbdpfDeUVaI +DncLKvbdiBnbeWqR +EObjjvbdEuyPoljF +EPCkKvbdRDcBQRES +DncKjvbdhfibxujV +EObkKvbdVqnYBeMD +EPDKjvbdJKEAKQGd +EOcLKvbdsQVoJbuf +EOcKjvbdqcdhonVa +EObjjvbdJcKCqJcY +EOcKjvbdpfEEsuaI +EPDLKvbdxnTIYShc +EOcLKvbdxVMdqYlO +EObjjvbdZyDimcMS +DncKjvbdiGjCxvKV +DoCkKvbdRbEEkiYk +DoCjjvbdWIYVxHYz +EPDLKvbdYzcFqjVy +DncLKvbdTYLLmzjx +DoDLKvbdwXLaVaWV +DoDLKvbdMRvlyuQz +DoCjjvbdajkeoNcA +EPCjjvbdjEkHUoAO +DoCjjvbdZoNiFFZj +DncLKvbdlZTRryHU +DoCjjvbdcTDLTdJa +EOcLKvbdlhctRVSB +EObjjvbduaEYroFI +DncKjvbdzjUpQDsU +DoDLKvbdyqPNIiwA +DnbjjvbdhkdcnUby +EObjjvbdVYgtZjoO +DnbjjvbdCJLCLJFj +EPCjjvbdzeZnzdyp +DnbjjvbdqlyjZMIJ +EOcLKvbdGAnpyJzm +DoDLKvbdNGcQMpVL +DncKjvbdADSXiyiQ +DoCjjvbdLBLHNCYR +DoCkKvbduVnXjRTA +DncKjvbdtSqsZZeD +EPDKjvbdpyOhGqEY +EObjjvbdEuyPomKF +EPDKjvbdyOSgxTIc +EPDKjvbdGFiqnJTq +EOcKjvbdyYJJbPzL +DncLKvbdADRwjZiQ +DncLKvbdCSaDUFwS +DoDLKvbdEzsqEkbi +EOcLKvbdssSTYyeD +DnbkKvbdSBdEkiZL +EObjjvbdFWZQPlie +EObkKvbdbBVeFpPw +DoDLKvbdBdQBVjMf +EPDLKvbdptUHRqjt +EPCkKvbdQwODcMID +DoDLKvbdelevgMik +DnbjjvbdVTmUFkuj +DnbkKvbdLYqJrzuG +DoCkKvbdCTAbsevr +DoCjjvbdJpyeOfOF +EPCkKvbdOStWHEtp +EOcLKvbdKVtfEEfi +DoCkKvbdmuUykJqf +DnbjjvbdQZNAHSrK +DnbjjvbdMgDPlpUk +DnbkKvbdCIkBjhfK +EObjjvbdBsBCsewS +EOcLKvbdYzbfRivZ +EOcLKvbdrzMQSaHn +EOcKjvbdRosfjFcw +EPDKjvbdANHyTXZx +EPCkKvbdliDsptqa +EOcLKvbdACrXizIp +EPCjjvbdLFfICApu +DoCjjvbdbAvEepPw +EOcKjvbdTpqPVVHm +DoCjjvbdsBemMGjy +EPCkKvbduaEZTPEh +DoCkKvbdOStWHEtp +EPCjjvbdbBVeGQPw +EObjjvbdOSsufeUp +DoCkKvbdjAQHBPgK +EPCjjvbdbBWEfPow +EPDKjvbdtSqsZZdc +EPCkKvbdegjuqmpg +DoDLKvbdRotGifDw +DoDKjvbdmJEUQtrB +DoCjjvbdcIljKewY +EObkKvbdbiMjKewY +EObjjvbdcScKsdJa +EPDKjvbdtSqsYyeD +DnbkKvbdrpWOjCvG +EPDLKvbdBiKbLIej +EPCkKvbdBdPaWJmG +EObjjvbdZRNEhmEq +EOcLKvbdiUzFWrUb +EPCkKvbdmIdUQtrB +EPCkKvbdbUafxLTh +EOcKjvbdnCKWxOmu +DoCkKvbdsZkosBIO +DnbkKvbdHDjujCJj +DoCjjvbdWSOYCFLc +EPDKjvbdmJETqVSB +DnbjjvbdrXPkcJYq +EObkKvbdMgDPlpVL +DnbjjvbdZisHpGaf +DoCjjvbdGGJqmiTq +EObkKvbdIHGyyYXg +EObkKvbdqTsgRrKt +EObjjvbdmJDtRVSB +DnbjjvbdddoSBvbj +EPDKjvbddePSBvbj +DnbjjvbdBcpAvJlf +DncKjvbdezvYeItX +DoDKjvbdmgEwmNfy +EObjjvbdDigivXjA +EOcLKvbdmJEURUrB +EOcLKvbdePFTLTtS +EPDKjvbdVTmUGMVj +EPDKjvbdnBivwnnV +EPCjjvbdZnmhddzK +DncKjvbdZeXfzgiC +DoDLKvbdEuyPpNJe +DoDLKvbdqdEhpNua +DoDKjvbdFWYpQMie +DoCkKvbdMfcQMpVL +EOcKjvbdmttykKSG +DnbjjvbdlhcspuSB +EPCjjvbdWSNwbFMD +EPDKjvbdRbEElIyL +EOcKjvbdyNsHwsIc +EPCjjvbdrylQTAgn +DncLKvbdADSYJyiQ +EOcKjvbdZjTIPgBf +EObjjvbdKDKDQibx +EObkKvbdKDJcRJcY +DoCkKvbdmSZUzSdJ +EPCjjvbdaNKartlg +DoDKjvbdIGgZyXwg +EObjjvbdauCHXjsh +EObkKvbdxUmEpyLn +EPCjjvbdNsTugEtp +EPDLKvbdZyDimblS +DoDKjvbdbUagYKtI +DncKjvbdliETpuSB +EOcKjvbdDihKWXjA +DncKjvbdZtIiZETO +EObjjvbdygZMAMeX +DoDKjvbdfNGWgMik +DoCjjvbdZMSEUNkm +EOcKjvbdsrqsZZdc +EPCkKvbdACqxJzJQ +EPDLKvbdNdcshiKd +DoDKjvbdyqOmIiwA +EOcKjvbdRMwbYmtz +EOcKjvbdYpmEhleR +DoDKjvbdjJfHimYS +DoCjjvbdrbFmMHLZ +DoCkKvbdBcpBWKNG +DoDKjvbdIxTbHkqQ +DoDKjvbdhuZdwSUb +EPDLKvbdJYUBglQp +EPCkKvbduCcUwVno +DnbkKvbdwuNEpyMO +DncKjvbdssSSxzEc +DoDLKvbdGdLWJbKK +EObjjvbdFjdsDIMu +DncLKvbdfkGzbfAE +EOcLKvbdrRtkOLBN +EPDLKvbdajkfOmcA +EPCjjvbdrMzJxkhJ +DncLKvbdqZOhHREY +DoDKjvbdmJEUQuSB +DnbkKvbdRDbaQRES +EPCjjvbdpyPHgREY +DnbjjvbdMIalQxAS +DncLKvbdiZuGMROG +DoDKjvbdgFkymfgA +DncLKvbdsCGMkgLZ +EObkKvbdRotHJecw +EPDKjvbdkClKpftg +EPCkKvbdRjyGUgLT +EOcKjvbdhuZdvqtb +EOcLKvbdmttzKjSG +EObjjvbdhlEdOVDZ +DoDLKvbdZisHpGaf +DnbkKvbdTqQntuHm +EPDLKvbdNdctIiLE +EObkKvbdWRnXbFLc +EPDLKvbdKVtfDdgJ +EPCkKvbdJSyBTMwl +DnbkKvbduWNxKQsA +DoCkKvbdqGEFUVaI +EPDKjvbdhkdcnVDZ +EPCjjvbdySnIlrBg +EOcLKvbdYlRctNlN +EObkKvbdvBDxroFI +DoDLKvbdxwiJbPzL +EPCjjvbdyNsHxTJD +DoCjjvbdhfjDYujV +DoDLKvbdcImKLFwY +DnbjjvbdqwQMChxq +DncLKvbdaaWEfQPw +DnbkKvbdUQqOuUhN +EOcLKvbdUaCRSqSZ +DnbjjvbdRMxByOUz +EPDKjvbdKCjCpjCx +DncLKvbdrMzJyMIJ +EPCjjvbdOEdThhjd +EPDKjvbdrSUkOKaN +EObkKvbdMowpunGs +DoCjjvbdhzVGLpmf +EOcLKvbdaMkBsVMg +DoCjjvbdkIGkfFnL +DnbkKvbdYpldiNFR +EPDLKvbdZxcjNcMS +EPDKjvbdGGKRnJUR +EPCjjvbdbiNKKfWx +EObjjvbdmRyUyrci +DncKjvbdLrXNZtpz +DncKjvbdZjTIPgCG +DnbkKvbdypoNIiwA +EPCjjvbdDihKVxKA +DncKjvbdyfxlANFX +DoDKjvbdiMFEOVCy +EPCkKvbdtcDUvvPP +DoCkKvbdEvYpQMie +DnbjjvbdZLrDtOLm +EPCjjvbdKQzFPGNe +EPDKjvbdGdLVjCJj +DoDKjvbdqYoHfqDx +DoDLKvbdFVxoomJe +DnbkKvbdKRZePFnF +DoCjjvbdFVyQQMjF +DnbkKvbdTulQJsaR +EObkKvbdkHgMFenL +DoDKjvbdVUMselVj +EPDLKvbdrDdhonVa +DncKjvbdkVvmcaxX +DoDLKvbdrRuKnLAm +EOcKjvbdJbibpjDY +EPDKjvbdXrlAmToY +DnbkKvbdZirhQGbG +DnbjjvbdjgfkfFnL +EOcKjvbdGFjSOJTq +DoDKjvbdSCDeMJYk +DoCkKvbdpecdtWAh +EObjjvbdzeZnzdyp +DoCjjvbdMJBlQxAS +EPDKjvbdnBivwnmu +DoDKjvbdRadElIyL +DoDLKvbdsZlPsBHn +EObjjvbdznopeDLx +EOcLKvbdCJKbKiFj +DncLKvbdmgExNNfy +DnbkKvbdnPzYvKxb +DncKjvbdrDdiPnVa +DoCjjvbdAMgxrwZx +DncLKvbdTfzmkwWF +DncKjvbdqiAJdloF +EPCkKvbdwuMeRZLn +DoCjjvbdVUNUFkuj +DoDLKvbdKQyePGNe +DncKjvbdLqvlzVQz +DoDKjvbdmgFYNNgZ +DnbjjvbddxZtTrFz +EObkKvbdqTsgSSKt +DnbkKvbdZxcimcMS +DoCjjvbdANHySvyx +DoDLKvbdZQmFJMdq +DoCkKvbdHDjujBij +EPDLKvbdsPuoJbuf +EPCjjvbdYpmEhmFR +DncLKvbdZjTHpGaf +EPDKjvbdEuyQQNKF +DoCkKvbdmbKWxPNu +DoCkKvbdRjyFtfjs +DoCkKvbdiifHjNYS +EPDKjvbdpyOhGpdY +DoDKjvbdUVlPitBR +DoCjjvbdEKIJuwjA +EPCjjvbdFkFTDHmV +EOcLKvbdySnJNSCH +DncLKvbdRpUHJedX +EPDKjvbdtvOYJpsA +DoDKjvbdKDKDQjCx +DoDLKvbdaMkCTUmH +EOcKjvbdMpYRVnGs +EOcKjvbdtSqsYzFD +DncLKvbdKaKgNCXq +DoCkKvbdsCFllGkZ +EObkKvbdNrsvGeUp +DoDKjvbdmaivxOnV +EOcLKvbdOEctIhjd +DoCkKvbdemGXGljL +DoDLKvbdjvWmdBxX +EPCkKvbdCIjbLIej +EPCjjvbdkHfkfFmk +DoDLKvbdwzIGFwdr +EOcKjvbddBrlrAUN +EPCkKvbdJutecdgJ +DoCjjvbdWRmwaeLc +DnbkKvbdiVZdwRuC +DnbjjvbdGLEsDHmV +EPCkKvbdxsOJNSCH +EPCjjvbdIwtBgkqQ +DncKjvbdbrbjtDjB +EPCkKvbdjhGkeemk +DncKjvbdWWiXvDeH +EPCjjvbdnUtzKiqf +DncKjvbdTukoitAq +DncLKvbdCIkBjhfK +DoCkKvbdhgKDZWJu +EPDKjvbdBhkBjiFj +DnbjjvbdMfbpNPtk +DoDKjvbdnBjWxPOV +DoCjjvbdEJhKWYKA +EOcKjvbdTpqOtuHm +DoCjjvbdwzIFfXdr +EOcKjvbdrpVoKDVf +EOcLKvbdEYYLtTsl +DoCkKvbdLFfICBQu +EOcKjvbdeXzTsrFz +EOcLKvbdSQUHKFdX +EOcLKvbdraemMHLZ +EPDKjvbdkIGlFemk +DncKjvbdOYOuzcnU +DoCkKvbdIwtCILpp +DncLKvbdZoNiEdzK +DoDKjvbdsrqsZZeD +EPDLKvbdzGyMANEw +DncLKvbdBraCsewS +EObkKvbdpyOgfpcx +DnbjjvbdxmrgxTIc +EOcLKvbdZjSgpHCG +EPCjjvbdrWpMDIxq +DncKjvbdZtJIyESn +EPCjjvbdJSxaSmXl +DoCjjvbdiMFEOVCy +DoCjjvbdDwwlTstM +DncLKvbdJYUCHkpp +EPDLKvbdsrrSxzFD +EObjjvbdkHgMFfNk +EPDKjvbdOStVgFUp +DnbjjvbdjhHMGGOL +DnbjjvbdZyEJmcLr +EPDKjvbdDihKWYKA +DncLKvbdRosfiecw +DoCjjvbdyTNhmSCH +DnbkKvbdFeirNhsq +DoDKjvbdrDeIpNvB +EObkKvbdVAaqTRSZ +EPDLKvbdLAkGlbXq +EOcKjvbdVAaprqRy +EPDLKvbdfIKvRnQg +EPCjjvbdUQpoVUgm +EObjjvbdxVNEpyMO +EOcKjvbdsCFllGkZ +DncKjvbdsBelkgLZ +DoDLKvbdvlvANDeN +DoCjjvbdnBivwoNu +EObjjvbdsCGMkgLZ +EObjjvbdsPvPJbvG +EPDLKvbdxrnImRbH +EPDLKvbdNPxRVnHT +DoDLKvbdMtrqkNAX +DoDKjvbdiGicZWJu +EPDKjvbdOFEUJJLE +EPDLKvbdoAKzshDn +DoDKjvbdehKvRnQg +EObjjvbdLLBIWAKZ +EPDKjvbdeOdsLUUS +DncKjvbdjvWmdBxX +DncLKvbdezuyFJTw +EPCkKvbdNPwpumgT +EPCjjvbdkxsRrxgU +EPDLKvbdptUHSSLU +EPDKjvbdeATqNXif +EPCkKvbdjlakzEgP +EObjjvbdyXiKCPzL +DoCjjvbdhlFDmuDZ +DncKjvbdauCGxLUI +EObjjvbdySmiNSBg +EOcLKvbdfNGWfljL +DncLKvbdVviYWDdg +EPCkKvbdkIHLefOL +EPDLKvbdRNYCZNtz +DoDLKvbdmfdxNOGy +DoDLKvbdcScKtDjB +EOcLKvbdEPDLKvcE +EPCjjvbdUaBprqSZ +EObkKvbdddnqbXDK +EPCkKvbdaaVeGQQX +DoDLKvbduoTzqKnt +DnbjjvbdqwPkbhxq +EObkKvbduaEZTOdh +EOcLKvbdKfFhBaRV +EOcKjvbdVYgtZjoO +EOcLKvbdrSVKnKaN +DnbkKvbdsCFmMGjy +DnbkKvbdSLYeuGkT +DoCkKvbdwWlAvAuu +EPCjjvbdRXOEClID +EPCkKvbdCIkCKiFj +EOcKjvbdGckViajK +DoCkKvbdznpRFCkx +DnbjjvbdxKwDgzyf +DncKjvbdVAaprprZ +DoDKjvbdOEctIhjd +EObjjvbdmIdTptqa +DnbjjvbdvwMAuaWV +EObkKvbdEYXksssl +EPCkKvbdiZtelQnG +EOcKjvbdqdEhpOVa +DnbjjvbdidjfuPAO +DnbkKvbdnBivxPNu +EObkKvbdrSVKmkBN +DnbkKvbdiCPDFWqR +DncKjvbdZisHofaf +DoCjjvbdJvVFcdfi +DoDLKvbdcyxpYYpb +DoCjjvbdrykpTBHn +EPDLKvbdqrUkOKaN +DoCkKvbdGQATWgFy +DncKjvbduaDxsPFI +EPCkKvbdYkqdTnLm +EObjjvbdQYmAGsRj +DnbkKvbdZyEKOCkr +DnbkKvbdOEdThhjd +EPDKjvbdiCOcFWpq +EOcKjvbdMfcQNPtk +EPDLKvbdLGFhBaRV +EPDLKvbdssSSyZeD +EPCkKvbdTAFJIBoE +EObkKvbdeFPRavbj +DnbkKvbdjKFhKNYS +DncLKvbdCJLBjiGK +DncLKvbdqlzJyLhJ +EOcLKvbdRyigsCvA +DoDKjvbdYqMdhldq +DnbjjvbdehKvSOQg +EObjjvbdMgColouL +DoCkKvbdehKuqnRH +DoDKjvbdQvmdCkhD +DoDKjvbdMSWlzVQz +EObkKvbdbhlikGXY +DoCjjvbdeAUQmYJf +EPCjjvbdZyEJmcMS +DoDKjvbdIGfzYxYH +DoDLKvbdHDjvJbJj +EOcKjvbdQwNdCkgc +EPCkKvbdRWnDcMHc +DnbjjvbdrMzJyMIJ +DncKjvbdlhctQuSB +DoDKjvbdbPgGdLzd +EObkKvbdijFhJmXr +DoCjjvbdbQGgDkzd +EPDLKvbdDihJvXjA +EObjjvbdaNKasUmH +DncKjvbdZyEKOClS +DnbjjvbdSLYfVHLT +DoDLKvbdwzHfFweS +EPCjjvbdfNFwHNJk +DoDLKvbdelewHNJk +EPCjjvbduaDxroEh +DoDKjvbddwytURez +DncKjvbdwtmEpyLn +EOcLKvbdCIkBkIej +EOcLKvbdiLddOUcZ +EPDKjvbdiUydwSVC +DncKjvbdrEEiQOVa +DnbkKvbdYzbeqivZ +DoCjjvbdkVwOECYX +DoDLKvbdZLqcsmkm +EObjjvbdVYgtZkPO +EOcLKvbdHffyxwwg +EPDKjvbdcIljLGWx +DnbkKvbdMpXpvNfs +EOcLKvbdFeirOJTq +DncLKvbdWWhxWEFH +DoCjjvbdZRMdhmEq +DnbkKvbdULvPBWPJ +EPDLKvbdZRMdiMdq +DnbjjvbdTYLMNzkY +DoCkKvbdZxcjNblS +DoCkKvbdKCibpicY +EPDLKvbddoFTKtUS +DncLKvbdcImKLGXY +EOcKjvbdKaLGmBwq +EPCkKvbdnHFYMnGy +EPDKjvbdUQqPUuIN +EPDKjvbdeAURNYJf +DoCkKvbdxwiKCQZk +DnbkKvbdKVuGDeGi +EPDKjvbdrovOicVf +DoDLKvbdrylQSaHn +EOcLKvbdySmhlrBg +EOcLKvbdNrsufeVQ +EOcKjvbdzoQREblY +EPCkKvbdzaAOgHCM +DoCjjvbdZLqdTmkm +EObkKvbdNGbpNQUk +EOcKjvbdZshiYdSn +EPDLKvbdDncLKvbd +EOcKjvbdqlzJyMHi +DoCkKvbdBhkCKiFj +EOcLKvbdRaceLhyL +EPDLKvbdxsNiNRbH +DoDKjvbdtcCtwWOo +DnbjjvbdmfdwlnGy +DncKjvbdREDBQQdS +DncLKvbdnPzYvKxb +EPCjjvbdjgfkefNk +DnbkKvbdnUtykJrG +EPDKjvbdSCEFLiYk +EOcLKvbdGcjuiajK +EPCjjvbdJYUCHlRQ +EPDLKvbdYpleIldq +EObkKvbdfMfWflik +DncLKvbdwuMdpyLn +DoDLKvbdEPDLLWcE +DoDLKvbdZLrDtOLm +DoCkKvbddZxoxYqC +DncLKvbdTulQKUAq +DncKjvbdqrUjnKaN +DoCkKvbdGFjRmiTq +EPCjjvbdpssfrRkU +EPDKjvbdrXQLbiYq +DoCkKvbdNQYQunHT +DoCkKvbdNrtWHEuQ +DncLKvbdjgflGGNk +DncKjvbdBsBCsewS +DoCkKvbdMpYRVmfs +DnbkKvbdKfFhBaQu +EObkKvbdGcjuiaij +EObkKvbdakMGOnDA +DnbkKvbdFyUuAcxC +DnbkKvbdtSrTZZdc +EPCjjvbdatafxLTh +EPCkKvbdUGzmlXVe +EObkKvbdZyDinClS +DncKjvbdyzdnSIJI +DnbkKvbdnPyxukZC +DoDKjvbdkDMLQgVH +EObjjvbdbVBfwjtI +EPDLKvbdzRPMhiwA +EObkKvbdhkeDmuCy +DnbkKvbdZQleImEq +EObjjvbdrDeJPnVa +EPDLKvbdaNLBsVMg +DnbkKvbdOEctIhjd +EOcKjvbdatagXkUI +DncKjvbdMowpunGs +EObkKvbdtvNwiqTA +DnbjjvbdyzdnSHiI +EObkKvbdbhlikFvx +EOcKjvbdaNKaruNH +DnbkKvbdiVZdvqtb +EObkKvbdVYgszKoO +DoCkKvbdjJfIKMwr +DncLKvbdezvZFJTw +EObkKvbdcyxoxYqC +EPDLKvbdFejSNiTq +DncKjvbdIwsbIMQp +DnbjjvbdTukpJsaR +EPDLKvbdIsZArlxM +EPDKjvbdTAEhgand +EOcLKvbdfNGXHMik +DoDKjvbdjcMLQgUg +DncKjvbdSLYfVHKs +DoCjjvbdnBjWwoOV +EPCjjvbdnBjWwnnV +EObkKvbdQvmccLgc +EPDKjvbdwuMeRYlO +DoDKjvbdNddUJIjd +DoCkKvbdqUTgSRkU +DoDLKvbdehLVqmpg +DoDLKvbdrovOjCvG +EObjjvbdzoPpdcMY +EPDLKvbdZRNFIleR +DnbkKvbdSLZGVGjs +DoCkKvbdySmiMrBg +DnbkKvbdwyhFfXeS +DoDLKvbdWHwvYHYz +DoCjjvbdIHHZyYYH +EObjjvbdJSyArmXl +DncKjvbdACqxJyiQ +DncLKvbdmpZxujyC +DoCjjvbdFkFScINV +EPDLKvbdCDpAujNG +DnbkKvbdhkeDnUby +DncLKvbdFWYopNJe +DoCjjvbdLAjfmCYR +EPCjjvbdxrmiMrCH +EObjjvbdcImJkGWx +DoCjjvbdFejRnJTq +EObkKvbdYTMAlsnx +EPCjjvbdsPvOibuf +EObjjvbdNeDshhjd +EOcLKvbdBiKbLIej +EObkKvbdauCGxLTh +EPDKjvbdbBWEepQX +EPCkKvbdVrNxBdlD +EObjjvbdMIalRYAS +EOcKjvbdJcKCpjCx +EOcLKvbdLqwNZtpz +DoCkKvbdZisHogBf +DnbjjvbdEPDKjvbd +DoDLKvbdFWZQQNJe +EObkKvbdHgGzYwxH +EOcKjvbdjbkkQfuH +DnbjjvbdtkxXAtBX +EPDLKvbdLAkHNCXq +EOcLKvbdWWhxVdFH +DncLKvbdCWzdIeQW +DoDLKvbdVvhwvDdg +EObjjvbdpfDeUWAh +EOcLKvbdqmZixkhJ +DncKjvbdyzdmrIJI +DncLKvbdRpTgJecw +DoDLKvbdGFjSOIsq +EOcKjvbdwuNFQyLn +DnbjjvbdIsZAsMwl +DncKjvbdptTgRqkU +DncKjvbdZQmEiNEq +DnbkKvbdauCHYLTh +EPDLKvbdyzdmrHhh +EPCjjvbdZoOJFEyj +EOcLKvbdUQqOttgm +DoCjjvbdRNYCZNtz +EPDKjvbdrRtkOLBN +DncLKvbdmajWxOmu +EPDLKvbdLBLHMbXq +DoDLKvbdCIjajhfK +EObjjvbdYkrDtOMN +EOcLKvbdUtNUGMVj +EObjjvbdaSFcHsek +DnbkKvbdXrkaMtPY +DoCkKvbdZQmFImFR +EOcLKvbdcJMijewY +EPDLKvbdGLErbhNV +DnbkKvbdiUydwSVC +EPDLKvbddndsKssr +DoDLKvbdxwhjCPzL +DoCkKvbdxVMeQxkn +DncKjvbdiBoCdwRR +EPDLKvbdnPyyVkZC +EPCjjvbdmuUzLKRf +DoDLKvbdSQUGiecw +DoDKjvbdRbDdlJZL +DncKjvbdqrVKnLAm +DoDKjvbdVBCQsQrZ +DoDKjvbdmbKWxPNu +EObjjvbdFVyQPmKF +DnbjjvbdiiehJlxS +EOcKjvbdIrxaSmYM +EOcKjvbdsZkosAgn +EOcLKvbdnCKWxPOV +EPDLKvbdKWUecdfi +DncLKvbdhgKDZWKV +EPDLKvbdySnImSCH +EObkKvbdJKEAKQGd +EOcLKvbdZMSETmkm +DoCjjvbdhgJcYujV +EOcLKvbdehLVqmpg +DoCkKvbdezuyFItX +DncLKvbdvBDxsOeI +EObkKvbdTulPisaR +DnbkKvbdajkfPODA +DoDKjvbdYkrEUOLm +EPCkKvbdfIKvSNpg +EPCkKvbdiBncEwQq +EOcKjvbdKWUecdgJ +EObkKvbdYlRcsmkm +EPCjjvbddwzUTqez +DnbjjvbdeYZstRez +EPDLKvbdxVNEqZLn +DncLKvbdFjeScINV +EObjjvbdxUleQxkn +DncKjvbdKWUfDdfi +DoDLKvbdssRrxzEc +EObjjvbdRpUGiedX +EOcLKvbdZQleJMdq +DnbkKvbdqdFIpNua +EPCjjvbdYzberKWZ +DoDKjvbdxxIjBoyk +EOcLKvbdEObkKwDE +DoDLKvbdqquLNjaN +DncKjvbdwuNFRZLn +DoCjjvbdqUTgRrKt +EObkKvbdVwIwvDeH +DnbkKvbdVwJYWEEg +DnbjjvbdYlSETnMN +DnbkKvbdqTsgRqjt +DoDKjvbdiGicZVjV +DnbjjvbdxnTHxTJD +EObkKvbdqUTfrSKt +DoCkKvbdFyVVBEXb +EOcKjvbdqGDdsvAh +EPCkKvbdTkunaVni +EObkKvbdMRvlzVQz +EPDKjvbdDncKkWbd +EObjjvbdqqtkNkBN +DncLKvbdfHkWRnRH +DnbjjvbdiLdcnUby +EOcKjvbdVYgsyjnn +EPCjjvbdUtNTfMWK +EPDKjvbdqYoHgREY +DncKjvbdGZUuAdYC +DnbjjvbdDnbjjwDE +EOcKjvbdTqQntthN +EOcLKvbdUyITzLPO +EOcLKvbdjblLRHVH +DoCkKvbdLGFhCBQu +DncLKvbdliEUQuSB +EObkKvbdRacdkiZL +EOcLKvbdaSFcHtFk +DoDKjvbdJYTahLpp +EPDLKvbdUQqOuVIN +EPCjjvbdqmZjYkhJ +DoCkKvbdRjyGUgKs +EObjjvbdyNrhYSiD +EPCkKvbdBhkCKiFj +EObjjvbdYlSDtOLm +DoCjjvbdTAFIhBoE +DncKjvbdNdctJIjd +DoDLKvbdGdKvJaij +EObjjvbdJpydnfNe +EPDLKvbdCDpAvKNG +DoDLKvbdeEoRavbj +DoCkKvbddoFSjssr +EPCjjvbdqYoHfqEY +EPCkKvbdFkFScHmV +EObjjvbdcyyQYZRC +DoDKjvbdyzdmrHhh +DoDKjvbdUWLojUAq +EObkKvbdiCPCdwRR +DoCkKvbdCTBDTevr +EOcKjvbdLAkGlbXq +EPDKjvbdcyyQXyRC +EPDLKvbdyNsHxSiD +EPDKjvbdqUTgRrKt +DoDKjvbdJuuFdEfi +DoDLKvbdEXwktTtM +EObkKvbdeJirVtzn +EObjjvbdYTMBMsnx +DnbkKvbdNQXpumfs +EPDLKvbdzitopDrt +DncLKvbdDxXlUUUM +EOcKjvbdADSXiyhp +DoCjjvbdqTsgSSKt +DoCkKvbdZtIhxdTO +EOcKjvbdUyHtZjnn +EPDLKvbdcSbkTdKB +DncLKvbdxZgfGYEr +DncKjvbdeATplxJf +DoDLKvbdnCJwXnmu +DnbkKvbdbKlFnnDA +DoCkKvbdrDeIpNua +EPCjjvbdmttzKirG +DoDKjvbdbrbkUDjB +DnbkKvbddZxoxZRC +EObkKvbdhgKDZWKV +DnbjjvbdGFiqmhtR +EPDKjvbdULvOaWPJ +EOcLKvbdygYlANFX +DnbjjvbdIHGzZYYH +EOcKjvbdhkeENuCy +EOcLKvbdNddTiJLE +EObjjvbdGFiqnJUR +EOcLKvbdjvWnEBxX +EPCjjvbdVBCRTRSZ +DncKjvbdVBCRTRSZ +EObkKvbdBdQAvJlf +EObkKvbdJYUCHkpp +EOcKjvbdGckVjCJj +EObkKvbdBsAcUGWr +DoDLKvbdIxUBhMQp +DoDKjvbdMgDQNPtk +EOcLKvbdHEKujCKK +DoCjjvbdLhalQxAS +EObkKvbdULuoBVoJ +EPDKjvbdhfjDZVjV +DoCkKvbdKDJbqJbx +DoCkKvbdbKlGPNcA +DncKjvbdrpVnicWG +EPDKjvbdvAdZSneI +DnbkKvbdFyVUaEYC +EOcKjvbdHDjuibJj +DnbjjvbdbiMjLFvx +EPCjjvbdUsltGLvK +DoCjjvbdkNBkzEgP +DncLKvbdFxtuBEYC +EOcKjvbdnBjWxPNu +DnbkKvbdqUTfrRjt +EPCjjvbdZHXEAPSi +DoCjjvbdxxJJapZk +DncKjvbdZyDimcLr +DnbjjvbdiBnbeWpq +EObjjvbdjbkkQftg +EObjjvbdqvokbhyR +EOcLKvbdeYZtTrFz +EPCkKvbdLqvmZtpz +DoDKjvbdNeDsiIjd +EPCkKvbdeXystRez +EOcKjvbdAMhZSvzY +EPCjjvbdSwkMNzkY +DoDKjvbdtlYXAtBX +EPCjjvbdBvzdIdov +DoDLKvbdVBBqSqRy +EOcLKvbdTvMQKUAq +EOcLKvbdxVMeQyMO +EPDLKvbdBsAbtGWr +DoCkKvbdKefHaaRV +DncLKvbdCTBDTewS +EPCjjvbdTIyjRAAl +DoDKjvbdkxsSSxft +EObjjvbdjvXOECXw +EPDKjvbdVTlsfLvK +EOcKjvbdjJfHjNXr +EObjjvbdfMfWflik +DnbkKvbdYqNFImEq +DoDLKvbdcJMikFvx +DoCkKvbdrXPlDIyR +EObjjvbdeOdsLTtS +DncLKvbdJSyArmXl +EObjjvbdkNBlZeHP +EObkKvbdfHkVqnRH +DncLKvbdKCjCqKDY +DoDLKvbdUyHsykOn +DncKjvbdWWiYWEEg +EPCkKvbdKWVFdEfi +EObkKvbdFpATWgFy +EOcKjvbdrzLpTAgn +EPCjjvbdhuZeWrVC +EPCkKvbdraellGjy +DncLKvbdGKeTCgmV +DoDLKvbdCEQAvJlf +DoDLKvbdJvUfEFGi +EOcKjvbdHDkVjCJj +EPCjjvbdZxdJnClS +DoCjjvbdcImJjewY +DoDLKvbdkDMLRHUg +DoDLKvbdqZOggREY +DoCkKvbdkMakyeHP +DoCkKvbdEvYpPmJe +DncLKvbdJJdAJpHE +DoDKjvbdEPCjkXCd +DnbjjvbdlAmOmALA +DoDLKvbdsBfNLgLZ +DncLKvbdKyQjSzuG +EPDLKvbdeAURMxJf +EPCjjvbdkHflGGOL +EOcKjvbdEuxpPlie +DncKjvbdcyyPxYqC +DoCkKvbdRDbaPqES +DncLKvbdaaVeFpQX +EOcLKvbdMuTSLNAX +EPCkKvbdbiMjKfWx +EOcKjvbdSCEEkiZL +DncKjvbdbhmJkGWx +DncKjvbdWXJYVcdg +EOcLKvbdvBDxrndh +DoCkKvbdCEQBVjNG +EPDLKvbdxUmFQyMO +DnbkKvbdznpRFCkx +DoCjjvbdKDJbpjDY +EOcLKvbdREDBQRDr +DoDLKvbdZtIhyETO +EObjjvbdKfGHbBQu +DnbjjvbdnUtzKirG +EPDLKvbdyNsHwsIc +DoCjjvbdIrxaSlxM +DoCkKvbdRjyFuHLT +EPCkKvbdJvUfDdgJ +DnbkKvbdgQBzvcwh +DnbkKvbdpyOgfqEY +DnbkKvbdmRxuZsEJ +EObkKvbdmRyUysDi +DnbjjvbdrzMPraIO +EPDLKvbdDxXksssl +EPDLKvbdqUUGrSKt +EPCjjvbdZisIPfbG +EPDLKvbdiGicZVjV +DnbjjvbdqcdiPnVa +DoDLKvbdGKdsCglu +EPCkKvbdYSlBNUOx +DoCkKvbdjmBkyeHP +EObjjvbdKDJcRKDY +EPDKjvbdiLdcmuCy +DoCjjvbdbAvEfQQX +EPDKjvbdegjvRmqH +EOcLKvbdrounibvG +DoCkKvbdliEUQtrB +DoCkKvbdrXPlChyR +DnbkKvbdcyxoxZRC +DoCkKvbdWIYWYHYz +DnbkKvbdmJETptrB +EObjjvbdbBVeGPpX +DoCkKvbdypnliKXA +EOcLKvbdatagXkTh +EPDKjvbdrounjDWG +EPDKjvbdUyHsyjnn +EPDKjvbddZxoxZRC +DnbjjvbdKCjCpjDY +DoCjjvbdKkBHvAJy +DnbjjvbdjbkkRGuH +DoCjjvbdrafNMGjy +DncKjvbdxnTHwsJD +DncKjvbdemFvfmJk +DnbjjvbdIwsbILqQ +EObjjvbdUMWPAvOi +EOcLKvbdGKdsChMu +DoCjjvbdWXIxWEEg +DoCjjvbdvPTzqKnt +DoDKjvbdILazmwRL +EPCkKvbdjlakzFHP +EPDLKvbdKDJbqKCx +EOcLKvbdHELWKBjK +DoCkKvbdOFDshhkE +EPDKjvbdBhkCKhej +DoDKjvbdNddTiJKd +EPCkKvbdVqmwadkc +EPCkKvbdFfKSOItR +EPCjjvbdZshiYcrn +DncLKvbdvAcxsOeI +EObkKvbdKVtfEFHJ +DncLKvbdXsMBNUPY +DoDLKvbdCTAbtGXS +DoDKjvbdRyjHsDWA +DoCjjvbdJcKDRJcY +EOcKjvbdEuxpPljF +DncLKvbduWNxKQsA +EOcLKvbdhuZeXSUb +EObjjvbdjvWnDaxX +EObjjvbdwWlAvAuu +EObkKvbdqquKnLBN +DoDLKvbddCSmSATm +DoCjjvbdwtmEpxlO +DnbjjvbdDoCkLWcE +DncLKvbdwyhGFxEr +EOcKjvbdrykosAgn +DnbjjvbdNeEUJJLE +DoDKjvbdjuwNdCYX +EPDKjvbdiGibyVjV +DnbjjvbdYqNEhmEq +EPDLKvbdxVNEpyLn +DoCjjvbdZeYGzgiC +DoCjjvbdZjTIQGbG +DnbkKvbdSPsfjGEX +EObjjvbdBsBDUGXS +DoCkKvbdsBfNMGkZ +EOcLKvbdLBLGmCXq +EPDKjvbdJTZBTNYM +DnbjjvbdJTZBSmYM +DoDLKvbdjKFgjNYS +DoDKjvbdqlzKYkhJ +EPCkKvbdkWXOECYX +EObkKvbdFkEsDINV +EObjjvbddndsKstS +DoCjjvbdauBfwjsh +DnbjjvbdFjeTCglu +EOcLKvbdfMfWflik +EObjjvbdlYsRryGt +EPCjjvbdtbcVWuoP +DnbjjvbdMgDPmQVL +DoDLKvbdjhHLefNk +EOcLKvbdUsmTfMWK +DoCkKvbdptTfqqjt +EObkKvbdrRuKmjaN +EPCjjvbdzoQQdcMY +DoDKjvbdrpVoKDVf +DoCkKvbdlZSrTYft +DoCjjvbdBhjajiFj +EOcLKvbdzoQQdbkx +EObkKvbdOhAYZAYa +EOcKjvbdjvXNdBww +DnbjjvbdEXwlTtTl +DoCkKvbdzjVPocsU +DoDLKvbdZQldiMeR +DncKjvbdYNqAYVVt +DnbjjvbdtvNxKRTA +EPCjjvbdqceIonWB +EOcKjvbdyXiKCPzL +DoCkKvbdfIKurNpg +DoDKjvbdFxuVAdYC +EOcLKvbdeOdrjssr +DncLKvbdxnShYTIc +EPDLKvbdoznEKwoA +DoDLKvbdptTfrRkU +DncLKvbdkWWnDaxX +EPCjjvbdKWVGDeHJ +EPCjjvbdtumwipsA +DoCkKvbdZxcinDMS +EObjjvbdCWzdIeQW +EPDKjvbdHgGzYwwg +EOcKjvbduDCtvvOo +DnbjjvbdqvokbiZR +DnbjjvbdmIcsptqa +DncLKvbdrJAJdmPF +EPCkKvbdKjaHvAJy +DoCkKvbdhuZdwSUb +EOcKjvbdnPzZVjyC +DoDKjvbdYSlAmUPY +EOcKjvbdffLzNgHA +DncLKvbdptUHRqjt +EPCjjvbdyTNiMqag +DoCjjvbdauBgXkTh +EPCjjvbdbiMikGXY +EOcLKvbdIHGzZXwg +DncKjvbdrXPkcIxq +DnbjjvbdOTTugEuQ +DnbkKvbdjcMKqHUg +DoDKjvbdffMZnHHA +DoCjjvbddijSWUzn +DncKjvbdBhkCKiGK +DncKjvbdJYTbHkqQ +DnbkKvbdqwPlCiZR +DoCkKvbdxUmFRYkn +DoDKjvbdmSZUzTDi +EPDLKvbdkyTSSxft +DoCjjvbdmajXYPOV +EPCkKvbdMowqVnHT +DncLKvbdTppoUuHm +EPDLKvbdgFkymfgA +EObjjvbdhgJcYujV +DncKjvbdtAGqIABS +DoDLKvbdqZOhGpdY +EObkKvbdjbkkRGuH +DoCjjvbdGLEsChNV +DnbjjvbdZoOIeEyj +DncLKvbdbrbjsdJa +EPCjjvbdGGJqmiTq +EPCkKvbdNPxRWNgT +EPCjjvbdJpydnfOF +EOcKjvbdcyxoxYpb +EPDKjvbdmozZWLYb +EObjjvbdVTmUFlVj +DoCjjvbdNrtWGduQ +DncKjvbdqUTfqqkU +DoDKjvbdTfznMWue +EOcLKvbdNsTugEuQ +DoDLKvbdjhHLfGOL +EObjjvbdZtJJYdSn +DoDKjvbdZjTHofbG +DncKjvbduCbtwVno +EPCkKvbdZtIhxcsO +EOcLKvbdnUuZkJqf +EObkKvbdiCPCeXQq +EOcKjvbdZtJIxcsO +EOcLKvbdZRNEhmFR +DnbkKvbdFjdsDINV +DncKjvbdsZlQSaIO +EObjjvbduLxXAtAw +DncKjvbddoFSjtTr +DoCkKvbdmbKXXoOV +DoDKjvbdOAIsTirA +DncLKvbdMfcQMpVL +EPDKjvbdsrqrxzFD +EOcLKvbdZRMdiMdq +EObkKvbdCTAbsfXS +EPDLKvbdtunYJpsA +EObkKvbdYSkaNToY +DoCkKvbdZMRdUOMN +EPCkKvbdIsYaSmYM +DncLKvbdVYgtZkPO +EObjjvbdaNLBsUmH +EOcLKvbdZyEKOCkr +DoDLKvbdOSsufdtp +DoDKjvbdhbPCdvqR +DnbkKvbdiZuFkpnG +DoDKjvbdHDjujCJj +EPDKjvbdCDpBVjMf +EObkKvbdeFOrBwDK +DoDLKvbdhgJbxvJu +EObjjvbdiZuFlQmf +EPDKjvbdeuzwpJzs +EPDKjvbdezuyEhsw +EPCkKvbdJYTbIMQp +DnbkKvbdkIHLeenL +DoCkKvbdAMgyTXZx +DnbkKvbdfIKvRnQg +EPDLKvbdJqZePFnF +DoCjjvbdRjxfVGkT +EOcLKvbdySmhlqbH +DnbjjvbdEYYMUTtM +DoDLKvbdhtydvquC +EObjjvbdZRMdiMdq +EPCjjvbdVZITzLOn +DoCkKvbdmuVZjjRf +DoCjjvbdzoQREbkx +DnbkKvbdkyTSSxgU +DoCjjvbdzRPNIjXA +EPDKjvbdnPyxvLZC +EOcKjvbdSZjHrbvA +EPCkKvbdShyjRABM +EObjjvbdYpmEiMeR +DoCjjvbdFaOqYizm +DncLKvbdEvZQQMjF +DncKjvbdNrtWGeVQ +DoDKjvbdqdFJPmvB +DnbjjvbdRXODblID +DoDLKvbdyzdnRhIh +EPCkKvbdcTCjsdKB +DncLKvbdJcKCqKCx +EObjjvbdmfdwmNgZ +EPDLKvbdqUTgSSLU +EObjjvbdZyEKODLr +EPDKjvbdTppoVVIN +DnbjjvbdFVyPpNJe +EPDKjvbdJYUBhLqQ +EPDLKvbdqceIpOWB +EPDLKvbdiBnbeXQq +DnbkKvbdGZVVBEYC +DncKjvbdGLFTDINV +EObjjvbdUGzmlXWF +EOcLKvbdxrmiMqbH +DoDLKvbdJpzEnenF +EObjjvbdEvYoomJe +DoDKjvbdJqZdoFme +EObjjvbdEuyPpMie +EOcKjvbdmtuZjjRf +EPDKjvbdjKGHilwr +EPCkKvbdpaIeAWgd +DoDKjvbdGZVUaDxC +DoCjjvbdFkErcHlu +EOcKjvbdrbFllGjy +DnbkKvbdMRwMzUpz +DoCkKvbdDxYLtTsl +EOcLKvbdLBKfmBxR +DoCjjvbdVwJYWDeH +DoCkKvbdZoOIdeZj +EPDLKvbdpfEFUWAh +EOcLKvbdKWVGDdfi +EObkKvbdtvNwipsA +DoCjjvbdwuNEqZMO +EObkKvbdfSBWzkbo +EPDLKvbdFxuVAdXb +DnbkKvbdRWnEClHc +EOcKjvbdkCkjqHUg +DoCjjvbdbsDKscia +EPDLKvbdzQoMiKXA +DnbkKvbdRDcApQcr +DoDKjvbdZtIiYcrn +DoDLKvbdqZPHgQdY +EObjjvbdyfxlAMeX +EObjjvbddjJrWUzn +EPDKjvbdjcMLQgVH +EOcLKvbdozmckXoA +EPDKjvbdcJMjLGWx +EPCkKvbdbhlijewY +EObjjvbdrEFJPnWB +EOcKjvbdmuVZjirG +DncKjvbdnBjXYOmu +DncLKvbdjcLjqHUg +EPDLKvbdlhdUQuRa +DoDKjvbdVwIwvEFH +EObkKvbdZMSDsnLm +DoDLKvbdzHZMAMdw +EOcKjvbdZMSDsnLm +DncKjvbdZshhyDsO +DncKjvbdCEPaWJlf +EOcKjvbdxxJKCQZk +EPCkKvbdezvZEiTw +EPDLKvbdypoMiKXA +EPCkKvbdnUuZjjRf +DnbkKvbdFfJqnJUR +DoCjjvbdTpqPUthN +DncKjvbdcyxoxYpb +EObkKvbdCSaCsfXS +DnbkKvbdRacdlIyL +DoCjjvbdTIzKRABM +EPCkKvbdatbGwjsh +EObjjvbdUsltGMWK +DoDLKvbdtvOXjQsA +DnbjjvbdYSlAmUPY +EOcKjvbdwuNEpxkn +EObkKvbdYqMdiMdq +EOcKjvbdnGeXlmgZ +DnbkKvbdqwQLcJYq +EObkKvbduVmxJqTA +EObjjvbdmoyyVkYb +DoDKjvbdBdPaWKMf +DncKjvbdVvhwvEFH +EObkKvbdauBfxLUI +EOcLKvbdMgDQNQUk +EOcKjvbdsQVnjCuf +EObkKvbdjuvnEBww +DoCkKvbdkWXODbXw +EPCkKvbdZyDjNblS +DoDKjvbdZLqdUNlN +DoDKjvbdbLMFoNcA +DoCkKvbdFVyQPmJe +EOcKjvbdhkdcmuCy +EPCkKvbdmtuZjiqf +DnbjjvbdRbEFLiYk +EPCkKvbdySnJMqag +EPDLKvbdhlFDnVCy +DoCjjvbdzoQREblY +EPCjjvbdvBEYroFI +EPCjjvbdJbjCqJcY +DnbkKvbdliEURUrB +DoDKjvbdOTUWGdtp +EOcLKvbdZnmhddzK +EPDKjvbdSBcdkiZL +DoCjjvbdZMRctOLm +DoDLKvbduCcUwVno +DoDLKvbdEzspeMDJ +EPCjjvbdULunaWOi +DoDLKvbdIwsaglQp +EObkKvbdJuuFdFGi +EPCkKvbdQccBQRDr +EPDKjvbdNrsugEtp +EPDLKvbdEXxLtUUM +DoDKjvbdVBCQsRRy +DncKjvbdeFPSCWcK +DoDLKvbdhficYvJu +DncKjvbdkClLRHVH +EOcLKvbduWNxKRTA +EObjjvbdNPwpumgT +DoCjjvbdjmCLzFGo +DncKjvbdZtIhxdSn +EObkKvbdKQyePFme +EPCjjvbdEuxpPljF +DoCkKvbdZtIhyDrn +EPDLKvbdJpzFOfNe +EPDKjvbduaEZTPFI +EPDLKvbdSQTgKFcw +EOcLKvbdBcpAujMf +EPCjjvbdfHkVrOQg +EPCjjvbdKaKflaxR +EObkKvbdZjTIQGaf +EOcLKvbdijGIKMwr +EPDLKvbdvBEZTOdh +DnbkKvbdZRNEhleR +DnbkKvbdijFgimXr +EObjjvbdEASIlywX +DoCjjvbdKaKgNCXq +EPDLKvbdTppoUuHm +EPCkKvbdwzHefYEr +EPCkKvbdhtyeWrUb +DnbkKvbdPyNAGsRj +EPDKjvbdmttzKiqf +DnbjjvbdRacdkhyL +EOcLKvbdeJjRvUzn +EObjjvbdNHCpNQVL +EPCjjvbdgLGzcGAE +DoCkKvbdidkGtoAO +DnbkKvbdKDJcRKCx +DnbjjvbdSQTgKGEX +EPDLKvbdyqPMiJwA +DnbkKvbdLrWlytpz +DnbjjvbdmgExNNgZ +EPCkKvbdlYsRrxgU +DnbjjvbdTkuoAvPJ +EOcKjvbdgFkymgHA +EPDLKvbdmaivxOnV +DnbjjvbdEztQeMDJ +EObjjvbdWfYzUAPT +DnbkKvbdiMEdNuDZ +DoDKjvbdgQBzwEXh +EOcLKvbdSBcdlIyL +DnbjjvbdrMzJxkhJ +DnbjjvbdddnrCXDK +DncLKvbdmbKXXnnV +DnbjjvbdYzbfSKWZ +EPCjjvbdUMWPBVoJ +EPDKjvbdBraDUGWr +DoCkKvbdFkFTDINV +DncKjvbdYkqdTmkm +DncKjvbdmpZyVjyC +DoCjjvbdZisIQHCG +DncLKvbdYqMeJMeR +EPDKjvbdZjTHpHBf +EOcLKvbdcJMikFwY +DoCkKvbdFpATXHGZ +DnbjjvbdVBBqSpqy +DoCkKvbddZyQXxpb +EOcLKvbdqlyiyMHi +EPDLKvbdfMfWgNJk +DoCjjvbdrNZjZLgi +EPCkKvbdeOdsKtTr +EPDKjvbdLrXMytpz +DncLKvbdQvnDcMHc +DoDLKvbdyYJJbPyk +DnbjjvbdrylPsBIO +DnbkKvbdTqROuUgm +DoCjjvbdcyyQYZRC +EObjjvbdbLMFnmcA +EObjjvbdbVCGxKsh +EObjjvbdelfWgMjL +EPDLKvbdnGdwmOGy +EPCkKvbdcTDLTdKB +DncLKvbdUxhTyjoO +EPCjjvbdwzHfFxEr +EPCjjvbdkxrqryHU +DncLKvbdDihJvYKA +EPCkKvbdRzJhScWA +EObjjvbdZHWdAOri +DoDLKvbdjbkkRGuH +DncKjvbdNVSrLNAX +DncKjvbdVqnYCElD +DnbjjvbdFWZPpMjF +DoCjjvbdZMRctNkm +EPCjjvbdRNXaxmtz +EOcLKvbdLZQjSztf +EObjjvbdePFSjssr +EOcKjvbdjbkkRHUg +EPDKjvbdcSbjtEJa +EObkKvbdKQzFPFme +DoCkKvbdnUtzKjRf +DncLKvbdeOeTKtUS +DoCjjvbdpstGqqjt +EOcKjvbdrpWPJcWG +EPCkKvbdwkXDgzyf +DncKjvbdnPyxvLYb +DoCkKvbdpxoIHRDx +DnbjjvbdLFegaaRV +EPCjjvbdrXQLcJYq +DncKjvbdWXJXvDdg +DnbjjvbdQdCaQRDr +EOcLKvbdWWiXuceH +DoCjjvbdbiNJkGXY +EPDKjvbdijGHjMxS +DoDLKvbdTfzmkwVe +EObkKvbdmSZUzTEJ +DnbjjvbdKefHaaRV +DncLKvbddoFSjstS +DncLKvbdSLYfUgKs +EPCkKvbdCIjbLJGK +DncKjvbdKNADzGuB +DoDKjvbdBcpBVjMf +DnbjjvbdpxoHfqEY +DoCjjvbdANHyTWyx +DoDKjvbdFjeSbgmV +DnbkKvbdxwiKCPzL +DncKjvbdqceIpNvB +DnbjjvbdLFfHbAqV +EPDLKvbdtTSTYydc +EPCjjvbdezvYdiTw +EObjjvbdWWiYVdFH +EOcLKvbdZyDjNbkr +EObkKvbdwzIFeweS +EPCjjvbdjmBkzFGo +EObjjvbdGAoRYizm +EObjjvbdjcMLQgVH +DoCjjvbddePRavbj +EOcKjvbdlhcspuSB +EPCjjvbdSCEFMJZL +EObkKvbdEYYLsssl +EObkKvbdpstGrSLU +DoDLKvbdIGgZxwwg +EObkKvbdWIYWYGxz +EPCjjvbdfILWSNqH +DnbkKvbdFWYpPljF +DoCjjvbdVAbRSqRy +EOcKjvbdeEoSCWcK +EOcKjvbdSBceMIxk +DoCjjvbdgFkzOGgA +EObkKvbdbPfgELzd +DnbjjvbdmtuZkJqf +EPCkKvbdYgWdAPSi +EObkKvbdmaiwXoOV +EOcKjvbdjuvnDbXw +DncLKvbdiBoCdvpq +DnbkKvbdZxcjNbkr +EPDKjvbdKfFgaaRV +DoDKjvbdNGcPlouL +EOcKjvbdHlBznXQk +EPCjjvbdKQydoFme +EPCjjvbdDxYLsssl +DoCjjvbdHbLydzAD +DnbkKvbdZisHofbG +DnbkKvbdvvkaWBWV +DncLKvbddxZtUSFz +EPCjjvbdBcpBWJlf +EObkKvbdVBBprpqy +DoCkKvbdaSFcITfL +DoCkKvbdZLqctOMN +EPDKjvbdFWYpQMie +DncKjvbdOEctJIjd +DoCkKvbdEuyQPmJe +DncLKvbdZGwEAOsJ +DncKjvbdlqyUzSci +EOcKjvbdKCibqKCx +DnbjjvbdEOcLKvbd +DncKjvbddneTLUUS +EPCjjvbdhbPDFWpq +DoCjjvbdeAUQmXjG +EPDKjvbdVwJYWDeH +DncKjvbdePFTKstS +DoCjjvbdjggMFemk +EPCjjvbdcScLUDjB +DoDKjvbdZjTIQGbG +EObjjvbdehKurNpg +DncLKvbdbsDLUEJa +EOcLKvbdEJgjWXjA +EPCkKvbdqquKnKaN +DnbjjvbdZjShQHCG +DoCjjvbdCEPaVilf +EObjjvbdzjUpQDrt +EOcLKvbdUVlPjUBR +DnbjjvbdeFPSCWbj +DoCkKvbdKxpirzuG +DncLKvbdrykpTAgn +DoDKjvbdemGXGljL +DncLKvbdTYKlNzkY +DncKjvbduaDyTOeI +EObkKvbdnBjWwoOV +EPCkKvbdGdLWKCJj +EPDKjvbdKeegaaQu +EObkKvbdxnShXrhc +DoCkKvbdsBemLgKy +EPCjjvbdrzLoraHn +EPDLKvbdrRuKmjaN +DncLKvbdmajWxPOV +DncKjvbdKVuGDeGi +EObjjvbdziuQPdTU +DnbkKvbdZxcinCkr +EPCkKvbdlqxtzTDi +EPCkKvbdyzeOSHiI +DnbkKvbdqmZiyMIJ +EOcLKvbdIwtBgkqQ +DncLKvbdfekzOHHA +EPCkKvbdKNADzGuB +EOcLKvbdUaBqSqRy +EPDKjvbdddnrBvbj +DncLKvbdmuVZjirG +EOcKjvbdbBWEepPw +DncLKvbdwjvdHzyf +EPDKjvbdmgFXlmgZ +EPCkKvbdtSqryZeD +EObkKvbdOFEUIhkE +EOcKjvbdiBncFXRR +DncLKvbdxZgeeweS +EPDLKvbdxwiKCPyk +EPDKjvbdHEKvJajK +DncKjvbdrafMlGjy +EOcLKvbdwWlBWBWV +DncLKvbdegjvRmqH +EObkKvbdehKvRmqH +DoDLKvbdUaBpsQrZ +EPDKjvbdRaceMJYk +DnbkKvbdZRNEhldq +DnbjjvbdKCibpjDY +DoDLKvbdKaLGmCXq +DncLKvbdKaKflbYR +DoCjjvbdZQleJNFR +EPCjjvbdZHWdAOsJ +EObkKvbdpxnggRDx +EPDKjvbdiUzFXSVC +DncKjvbdhfjDZWJu +DoCjjvbdYkrDtNlN +EOcLKvbdkVvmdBxX +DnbjjvbdFkFScHlu +DoCjjvbdlrYuZrci +EOcKjvbdrDdiPnWB +DoCjjvbdfoazvcwh +EPCkKvbdtkxWaUAw +EObjjvbdVYgsyjoO +EPCjjvbdssSTZZeD +DoCjjvbdbVBfwjsh +EPCjjvbdVgwuxGxz +EOcKjvbdZoNhdeZj +EPCkKvbdGYttaDwb +DncLKvbdvAcySoEh +DoDKjvbdIGfzZYYH +DoDKjvbdtcCtvvPP +EObjjvbdkxsRryHU +DnbkKvbdJSyBTMwl +DoCjjvbdsPuoJbuf +DnbjjvbdZxcimcMS +DoDKjvbdNGbpMouL +DnbjjvbdSZjHrbvA +DoCkKvbdmRxtysDi +EOcLKvbdZQmEiMeR +EPCjjvbdpfEEtVaI +EPCjjvbdtTRrxzEc +DoCkKvbdZdxGzghb +DncKjvbdrykpTBIO +EPCkKvbdxxIjCPyk +DncLKvbdCEQAujNG +EOcLKvbdrWokbhyR +EPDKjvbdjJehKMwr +DncLKvbdSxLMNzjx +DnbjjvbdZyDinDMS +EObjjvbdZirhQGaf +DncLKvbdkClKqHVH +EObkKvbdfIKvRmqH +DoDLKvbdQvmcblID +EPDKjvbdNsTufdtp +EObkKvbdZRMeIleR +DnbkKvbddwytTrFz +EObjjvbdZxdKODMS +EPCkKvbdSLZFtgKs +EPDKjvbdrovPJbuf +EPCjjvbdHgHZxxYH +EPCjjvbdddoSBvbj +DoDKjvbdegkVqmpg +DoDKjvbdCfkfHAzc +EObjjvbdtvNxJqTA +EPDKjvbdhtyeXSVC +EPDLKvbdUtMtGLvK +EPCjjvbdFaPRYizm +EPCkKvbdVZIUZkOn +EPDKjvbdFeiqnIsq +EObkKvbdddoRbWcK +EOcLKvbdaNLCSuMg +EObjjvbdFpATXGfZ +DncLKvbdrXPkcJYq +EPCjjvbdFjdrcHlu +EObkKvbdUQqPVUhN +DoDLKvbdpxoHfqDx +DncLKvbdypoNIjXA +EPCjjvbdmRxuZrdJ +EPDKjvbdqZPHgREY +EOcLKvbdZGwEAPTJ +DncLKvbdjuwNcbXw +DoCkKvbdTlWPBVoJ +DoCjjvbdRzKIScWA +EPDLKvbdZnnJFEzK +EPDLKvbdqvokbhyR +DnbkKvbdAMhZTWyx +EPCkKvbdqYoHgRDx +EPDKjvbdZtJJZETO +EObkKvbdWRmxBdlD +DnbkKvbdwWkaWBWV +DncKjvbdgKfzcGAE +DncLKvbdtbcUwVno +EOcLKvbdcImJjfWx +DncLKvbdSwjlNzjx +EObkKvbdjblLQftg +DncLKvbdQmYByNtz +DnbjjvbdhlFDmtby +DnbjjvbdcTDKsdJa +EPCkKvbdqUTgSRkU +EOcKjvbdZQleImEq +EOcLKvbdtTRrxzFD +EPCkKvbdUVkpKUAq +DncLKvbdmbJvwoNu +EPDKjvbdrJAKFMne +DncKjvbdpyOhGqEY +EOcLKvbdLrWlzVQz +DnbjjvbdvAdYsPFI +EPCkKvbdDoDKjvbd +DoDLKvbdelfWgMjL +EObkKvbdaMjbTUlg +EObjjvbduVmwjRTA +EPCjjvbdHffyxwwg +DnbkKvbdXrkaNToY +DoCjjvbdZshhyDrn +DoDKjvbdunszqKoU +EPCkKvbdmJDtRVSB +DnbkKvbdcImKLFwY +DoCjjvbdpedEtVaI +DnbjjvbduMXwAtBX +EPDLKvbdhbPDFWpq +EPCjjvbdrDdiQNua +DnbkKvbdKxpirzuG +EObkKvbdcTCjtEJa +DncLKvbdZQmFIldq +DoCkKvbdqUUGrRkU +DnbkKvbddZyQXyRC +DncLKvbdIryBTNXl +EPDKjvbduaDxrneI +DoCkKvbdZMSDsmlN +DoDKjvbdrovOjCvG +EOcLKvbdhyuFkpmf +DoDLKvbdddnrBwDK +DncKjvbdDwxLstTl +EPDLKvbddZxpXxpb +DoDKjvbdCSaDTewS +EPCkKvbdVqmxBeLc +DoCkKvbdZMSEUNkm +DnbkKvbdznopdcMY +EPCjjvbdqYoHgQcx +EPCkKvbdlhdUQuRa +EObjjvbdauBgYLUI +EObjjvbdySnJMrCH +EObjjvbdkIGlGGOL +DoCkKvbdwXMAvBWV +DnbjjvbdiCOcFXRR +EPCkKvbdIHGzZYXg +EPDKjvbdiMFDmuCy +EOcKjvbdtlXvaUBX +DoDLKvbdhfibxuiu +EPCkKvbdqwQMChxq +EObkKvbdRkYeuGjs +DoDKjvbdYkrEUNlN +EPDKjvbdZshiYcsO +DnbkKvbdQlxBxnUz +DncKjvbdSPtGifEX +DoDLKvbdmajXXoNu +EObjjvbdHbMZdzAD +EPCkKvbdZyEKNblS +EObkKvbdKfFgbBRV +EOcLKvbdOTUVgFVQ +DoCkKvbdfMevgMik +EPDKjvbdptTfrSKt +DnbkKvbdxZhFexFS +DncLKvbdUaBqTQrZ +DoCjjvbduDDUwWPP +DoDKjvbdNsUVfduQ +EObkKvbdvOszpjoU +EObkKvbdNsTvGdtp +EPDKjvbdxwhiapZk +DoDKjvbdiGjCxvJu +DoDLKvbdxxIibPyk +DncKjvbdvAdYroFI +EOcLKvbdLAkGmBwq +DncLKvbdIsYaTMxM +EPDLKvbdFejRmiUR +DoCkKvbdbrbjscia +DoDLKvbdiHJbyWJu +EOcKjvbdIwtBhMQp +EObkKvbdpfDdtVaI +EObjjvbdfMevfmJk +EObjjvbdptUHRrLU +EPDLKvbdYgXEAOri +EObkKvbdZoOJEeZj +DoDKjvbdqUUGqqjt +DnbjjvbdxnTHwriD +EPDKjvbdfHkWRmpg +EPDLKvbdePEsLUUS +EPCjjvbdEPCkLXDE +DoCjjvbdgQBzvdYI +DoCkKvbdZjSgogBf +EObkKvbdtunYKQsA +EPDKjvbdezvYdiTw +EPDLKvbdLBLGmCYR +EObkKvbdSLYfVHKs +EPDKjvbdfILWSNqH +EObjjvbdqlyixkhJ +DoCkKvbdjKFgjNXr +DoDLKvbdyzdmrHhh +DoDLKvbdYpleImEq +DoDKjvbdUxgtZkPO +EPDLKvbdJKEAKPgE +DoDKjvbdRXODblHc +DoCkKvbdmozYujxb +EOcKjvbdMgCpMouL +DncKjvbdZsiJZESn +EPCkKvbdzROmIiwA +DnbkKvbdEOcLKvbd +EPCjjvbdpxoIHRDx +DnbkKvbdEJgivXjA +DoDKjvbdfHjurOQg +EObjjvbdyYIjCPzL +DoCjjvbdvlvANEEm +DncLKvbdOXoVzdOU +EObkKvbdatagYKtI +DnbkKvbdGYtuAcwb +EObkKvbdegjuqnRH +DnbkKvbdtumxKQsA +DnbkKvbdIxTbILqQ +DncKjvbdIsZBTMxM +EPCjjvbdRjyFuHLT +EOcKjvbdJXtCIMQp +DoDKjvbdYkqdUOLm +EObjjvbdZsiIyESn +DnbkKvbdhtyeWrUb +EPCjjvbdEuyQPmKF +EOcLKvbdeFOrCWcK +DoDLKvbdEvYpPlie +DoCjjvbdZtJIyETO +EPCjjvbdrWokcJYq +DoDLKvbduaDySneI +DncLKvbdsPunjCuf +EObkKvbdpyOhGpcx +EObkKvbdliDsqUqa +DoDLKvbdhaoCeXQq +DncLKvbdaRfChUFk +EOcKjvbdYTMAlsoY +EPCkKvbdfkGzbfAE +EOcKjvbdURQnttgm +DoDLKvbdDoCjjvcE +DncLKvbdCJKbLJGK +EPDKjvbdhlFEOVDZ +DnbkKvbduCcVWvOo +EPCjjvbdQdDBPpcr +EObkKvbdbBVdeopX +DnbkKvbdWHwuwfxz +DoDLKvbdsrqrxzFD +DoDKjvbdCSaCsfXS +DoCkKvbdNPxQunGs +EPDLKvbdyzeNrHhh +EObjjvbdWXIwudFH +EPCjjvbdKWVFceHJ +EOcLKvbdqwPlCiZR +DncLKvbdyOTHwsJD +DncLKvbdxUleRZMO +DnbjjvbdZHWdAPTJ +DoDLKvbdePEsKstS +EPDKjvbdHDkVjBij +EObjjvbdSPtHJecw +EObjjvbdyTOJNRag +EOcKjvbdhfibxuiu +EOcKjvbdRDbaPqES +DnbjjvbdemGWflik +DoDKjvbdwjwEHzzG +EObjjvbdsCGNMGjy +DnbjjvbdssRsYyeD +DoDKjvbdJvVFceGi +EPCkKvbdLZQjSzuG +DoDLKvbdqUUHSSLU +EPCjjvbdaaWEeoow +EPCjjvbdDjHiuxKA +EPDKjvbdZQmFIleR +DoDKjvbdRDbaPpdS +EPCjjvbdZoOJFFZj +EObjjvbdQmYBxnUz +EPDKjvbdKCibqKDY +DoDLKvbdsCFmMGjy +DncKjvbdKaKgMaxR +DoCjjvbdrMzJxkhJ +EObkKvbdeKKRutzn +EPCkKvbdcTCjscjB +EPCkKvbdZsiIyDrn +EObjjvbdnBjXXoOV +DoDKjvbdBiKakIfK +EOcKjvbdRpTfjGEX +DoCkKvbdtSqrxydc +EObkKvbdHDkVjBij +DncLKvbdqTsgSSLU +DncLKvbdzdzOzdzQ +DoDLKvbdVrNwadlD +DncLKvbdSQUGifEX +DncLKvbdxxJKBoyk +EPCjjvbdrzLpSaIO +DnbkKvbdhtyeXRuC +DoDKjvbdyTOImSBg +EPDLKvbddZxpXxqC +DoCkKvbdZMSDsnLm +DncLKvbdEARhlzXX +EPDKjvbdkWXOECYX +EObkKvbdSLYetgLT +EPDKjvbdTfznLvvF +DoCjjvbdSZjHrcWA +DncKjvbdmJDsptqa +EOcLKvbdZxdJmblS +DnbjjvbdKWUfDeHJ +EPCkKvbdLiBkpxAS +EObkKvbdePFSkTtS +DoDKjvbdYzbfSKWZ +EPCjjvbdvAdYsPFI +EObkKvbdTAFJIBnd +DnbkKvbdsZkpSaHn +DoDLKvbdczZQYZRC +EPDKjvbdTvMQKTaR +DnbkKvbdyYJKCQZk +EPCkKvbdVAaqTQqy +EOcLKvbdbPfgDkzd +EObkKvbdePErjssr +EPDLKvbdyTOJNRag +EPDLKvbdyTNiNSBg +DoCjjvbdqvpMCiYq +DoDKjvbdRpUHKGEX +DoCjjvbdDoCkLWbd +DncLKvbddCTNSATm +DoCkKvbdcSbkUEJa +EPDLKvbdzjVPocrt +DnbkKvbdxVNFQyLn +DnbkKvbdSKyFtfkT +DoCkKvbdmpZxukZC +DncLKvbdGFjSOJTq +EOcKjvbdhkdcmtcZ +DoCjjvbdyzeORghh +EPCkKvbdRbDeMJZL +DoDLKvbdZMRctOMN +EObjjvbdAMgySvyx +EOcLKvbdTYLMNzkY +DnbjjvbdmuVZjjSG +DnbkKvbdZsiIyDrn +EPDLKvbdjEjfuPAO +DoCjjvbdkxrrSxgU +DncKjvbdSLYfUfkT +DnbjjvbdBcpAvJmG +DoDLKvbdSPsgKFcw +DoCkKvbdrXQMDIyR +EObkKvbdKVuFdEfi +DnbkKvbdrSVLOLBN +DoDKjvbdZnmhdeZj +DoDKjvbdNHDQNPuL +DoDKjvbdpyOggREY +DoCkKvbdQvmcblID +EPCkKvbdMfbomQVL +EPCjjvbdNVTRjmAX +EOcKjvbdbhlijevx +EObkKvbdWWiXvEFH +DncKjvbdlqyVZrdJ +DnbjjvbdrSUkNjaN +DncLKvbdmSZUzTDi +EObjjvbdZQmEhmEq +EOcKjvbdiLdcnVDZ +EObkKvbdySmhlqag +DnbjjvbdbUagYLTh +DncKjvbdBdQAvKNG +DncLKvbdyzdnRghh +EObkKvbdLZRKSztf +DoDLKvbdRXOEDMHc +DncKjvbdFkFSbgmV +EPCjjvbdZQldiMeR +EPDLKvbdFfJqmiTq +EOcLKvbdpssgRrKt +DnbjjvbdKRZeOeme +DnbkKvbdnPzYvLZC +DoDLKvbdUVlQJsaR +EPCjjvbdqFceTvAh +EPDKjvbdEARhlyvw +EPCjjvbdNGbolotk +DoCjjvbdVhYWXgYz +DoCjjvbdUtMtFkvK +DncKjvbdZQldhleR +DnbjjvbdCEPaWKMf +EObjjvbduWOXjQsA +EOcKjvbdIjEAKPfd +DoCjjvbdURRPUuIN +EObkKvbdbhmKKfWx +DoDKjvbdxrnJMrCH +EObjjvbdGFirNiTq +DoDLKvbdtSqsZZeD +EPDLKvbdKkAhWAJy +EPCkKvbdbVBgYKsh +DoCjjvbdKWVFdFGi +EPDKjvbdwXMAuaWV +DoCkKvbdRXNdCkhD +EPCjjvbdZRMdhmEq +DncLKvbdcJMijfWx +DnbkKvbdZRNEiNFR +EObjjvbdAMhYrvyx +EPDLKvbdijGIJmXr +DoCkKvbdbhmJjfXY +EOcLKvbdrzMQTBHn +DnbkKvbdKVtfEEfi +EPCkKvbdxVNFRZMO +EPDLKvbdjcMLQgUg +EObjjvbdjuwODbXw +EObkKvbdZeXfzhJC +EPCkKvbdUyITyjoO +EPCkKvbdGFjRnIsq +DnbjjvbdIwsbHlRQ +DncKjvbdtTSTYzEc +EPDKjvbdhfjCyWKV +DoCjjvbdhytelQnG +DoDKjvbdxnTHxTIc +EOcKjvbdUQqPUtgm +EPDLKvbdkNCMZdgP +DnbkKvbdGKeTDINV +EOcLKvbdZMRcsmlN +DnbjjvbdRXNdCkgc +DoCjjvbdRXNccMHc +EObkKvbdRjyFuGjs +EPDLKvbdmJDtRUrB +DoDLKvbdpyPIGpdY +EPCjjvbdkNCLzEgP +DoDLKvbdZoNiFEzK +DoDKjvbdKVuFcdfi +DoDKjvbdqZOggQdY +EPCkKvbdSQTgJecw +EOcKjvbdrRuKnLAm +EObkKvbdbUbHYLUI +EOcLKvbdyNrgwsJD +DoDKjvbdegkVqnQg +DnbkKvbdGBOpxizm +EObkKvbdJbjDQicY +DncLKvbdSLZFuGjs +DoCkKvbdGckVibJj +DoCkKvbdzeZnzdyp +EObjjvbdxxJKCQZk +EObjjvbdJpzFPGNe +EPCkKvbdUsltGLvK +DoDLKvbdziuQQDsU +DncLKvbdRzKIScWA +DoCkKvbdSLYfVGjs +EPCjjvbdhgKDYujV +DoDKjvbdtunXjQsA +EPDKjvbdqceJPnWB +DncKjvbdUQqOuUhN +EOcKjvbdJvVFceHJ +EPCkKvbdMfcPmQVL +EObkKvbdNrsufdtp +DncLKvbdUQpnuUhN +DncKjvbdYkqdUOMN +EObkKvbdqceJQNvB +EPDLKvbdCWzdJFPv +DncKjvbdauBfxLTh +DncKjvbdZnnJEdyj +DncLKvbdEvYpPlie +DoDLKvbdhaoCdvpq +EObkKvbdCEQBVimG +EOcKjvbdBiKbKhfK +DnbkKvbdeuzwpJzs +DncLKvbdhlEcnVDZ +EObkKvbdkCkjpftg +DncKjvbdZQldhmEq +DoDKjvbdFyVVBEXb +DncKjvbdZirgogCG +EPCkKvbdWXJXvEFH +DnbkKvbdOStVfduQ +DnbkKvbdNGbpMouL +EObkKvbdcIljKfXY +DoDLKvbdXrlBMsnx +EOcLKvbdfNFwGmJk +EObjjvbdUQqPUuHm +DnbjjvbdEXxLtUTl +EPDKjvbdLGFhCBQu +DncKjvbdTYLLmzkY +DoCkKvbdkaNPNALA +DoCjjvbdFxtuBDwb +EPDLKvbdGGJrNhsq +DoCkKvbdZyEJnDLr +EObkKvbdDxXlTssl +EPCkKvbdGKdrbglu +EOcLKvbdmoyyVjxb +DnbkKvbdRNYByNtz +EObjjvbdGFirOItR +DoCjjvbdxUmFRZLn +EPCkKvbdsQWPJcWG +EPCjjvbdegkWSORH +DncLKvbdYzcGRjVy +DoCkKvbdRXNcblHc +EObkKvbdwtldqYkn +DnbkKvbdZisHpGaf +EPCkKvbdGQASvfey +DnbjjvbdeFPRavbj +EOcLKvbdGZVVBEYC +EPCkKvbdKDKDQicY +EPCkKvbdUsmUFkuj +DoCkKvbdatbHXjtI +EObkKvbdlrYtyrdJ +DnbjjvbdjKGHilwr +EOcKjvbdjlakyeGo +DoDLKvbdnPzZVkZC +DnbjjvbdCIjbLJFj +DoCkKvbdegkWSORH +DoDLKvbdjvXODbYX +EPDKjvbdaaVeFoow +DncKjvbdwtmFRZLn +EObkKvbdkNCLzEfo +DncLKvbdrbGMlGkZ +EObjjvbdczZQXxqC +DoCkKvbduaEZTOdh +EObjjvbdZxcjNbkr +EOcKjvbdCJKbKiFj +DnbjjvbdjEkGuPAO +DnbjjvbdZshhyDsO +DoDLKvbdbsCkUDjB +DoCkKvbdNddUIhkE +EPDLKvbduVnYJpsA +DnbjjvbdQvmccMHc +DoDKjvbdDjIKWXjA +DoDLKvbdxZhGGYEr +EObkKvbdqquKmkBN +EObjjvbdLBLHMawq +DoDLKvbdrbFmLgLZ +EPDLKvbdddnrBwCj +DoCkKvbdbrcLUEKB +DoDKjvbdqlyjYlHi +DncKjvbdQwNdDMID +EObkKvbdBiLCKhej +EPCkKvbdSZigsDWA +DnbkKvbdwuNFRYlO +EPDLKvbduCbtvvOo +DnbjjvbdaaWFFpPw +EObkKvbdRECaQQdS +DncKjvbdyOShXsJD +EPCkKvbdFVyPomJe +DoDLKvbdcJMijevx +EObkKvbdSZigsCvA +EObjjvbdrNZjYlHi +DnbkKvbdKfFhBaRV +EPDLKvbdSLZFtgKs +EPDLKvbdrbGNMGjy +EPCjjvbddwzTtSFz +DoDLKvbdnGdxNNgZ +DncLKvbdTfzmlWue +EOcKjvbdbLLfOmcA +DoDLKvbdNGcQNPuL +DncLKvbdUaCQsQqy +EPCjjvbdCfkfHAzc +EPDKjvbdlrYuZsDi +EPDLKvbdmajXYPOV +EObjjvbduCcUvvOo +DoDLKvbdJXsahLqQ +EPCkKvbdOSsugEuQ +DnbkKvbduaDyTOeI +DncLKvbdYqNEhldq +EOcLKvbdeOdsKtUS +EOcKjvbdkHgLefOL +EPCkKvbdrpVoKCuf +EObjjvbdShzJqAAl +DnbjjvbdgPazwDxI +EPDLKvbdEztQdlDJ +DoDKjvbdYpmFImFR +DncLKvbdsBellHLZ +DoCjjvbdatbHYKsh +DoCjjvbdptTgRrLU +EOcLKvbdznpRFCkx +EPCjjvbdWWiYWEFH +EPCjjvbdRosgJedX +DnbjjvbdkIGkefOL +DnbjjvbdiZuGLqNf +EPCkKvbdANIZTWyx +EObjjvbdZQmFJMdq +EObkKvbdjvWmcbYX +DncLKvbdRbEFMJYk +EOcKjvbdpfDdtVaI +EPDKjvbdJqZePFnF +DnbjjvbdeFOqavcK +DoCjjvbdnHFXlnHZ +EPCjjvbdTvLpKTaR +EPDLKvbdVgxVxHYz +EObkKvbdZRNFJMdq +EPDLKvbdbUafwkUI +EObjjvbdKCjDQibx +EPDLKvbdrXPlChyR +DoCjjvbdxsNhlqbH +DoDKjvbdNGbomPtk +EPDLKvbdLBLGmBwq +DncLKvbdIsZBTNYM +EPDLKvbdOXnuzcmt +EPDKjvbdKDJcRJcY +EObkKvbdiBncFWqR +DncLKvbdlhcsqUrB +DncKjvbdrylQTAgn +DoDLKvbdTlWOaWOi +EPCkKvbdegjurNpg +EObjjvbdyTNhmSBg +EPCjjvbdQccBPpcr +EPDKjvbdeOeSkTtS +DoCjjvbdGYuVAdXb +EObjjvbdrzMPsAhO +DncLKvbdrEFJQOVa +EPCjjvbdbhmKKfWx +EPCkKvbdeYZssqez +DnbkKvbdURQntuHm +EPDLKvbdkDLkRHVH +EOcKjvbdlZSrSxft +EObkKvbdijGHimXr +EOcLKvbdpxnggQdY +DncKjvbdJKEAJpGd +EPCjjvbdMowpumfs +DoCkKvbdmSYtysDi +DoDLKvbdBsBDTfWr +EPDLKvbdrMzKZMHi +DnbkKvbdBraDUGWr +DnbjjvbdDxYMTtTl +DncKjvbdFyUuBEYC +EPCkKvbdVZITzKnn +DnbkKvbdTkvPBWPJ +EObkKvbdSQTfjFdX +DoCjjvbdZisIPgBf +EPCkKvbdLGFhCAqV +DoCjjvbdNGcQNPuL +DoCkKvbdqlzJyMIJ +EObjjvbdZtIiZDrn +DnbjjvbdeEoRawCj +DoDKjvbdUaBqSqRy +EOcLKvbdmfdwmOGy +DoDKjvbdptTfqrKt +DoDLKvbdvAcxsPEh +DoCkKvbdySmhmRbH +EOcLKvbdhfjDZWKV +EOcKjvbdHffzZXxH +DoDKjvbdLFfHaaQu +EPCjjvbdgFlZmfgA +EOcKjvbdtcCuXVno +DoDLKvbdZirgpGbG +EObjjvbdNsUWHEuQ +DoDLKvbdsBfNLgKy +DoDKjvbdGGKRnJUR +DoDLKvbdKkAhWAKZ +DnbjjvbdOFDtJJKd +EPCjjvbdMuSrKmAX +DnbjjvbdyXiKBpZk +DncLKvbdOFDtIhjd +DoDKjvbdNPxQumgT +DnbjjvbdrSVLOKaN +EPCjjvbdmJDtRVRa +EPCkKvbdZeXfzgiC +DoDKjvbdhaoCdwRR +DncKjvbdiBncFXRR +EPDLKvbdvBEYrndh +DnbjjvbdBiLBkIfK +EPDLKvbdhgJbyVjV +DncKjvbdzRPNIiwA +DnbjjvbdegjvRmpg +DncLKvbdyYIibQZk +EPCkKvbdxnTIXrhc +EPCkKvbdhkeEOUby +DnbkKvbdjJehKMxS +DoDKjvbdkVwODbYX +EPCkKvbdFWYpQNKF +EPCjjvbdXrkaMsnx +EPDKjvbdRjxetgLT +DoDKjvbdEztRFLbi +DnbkKvbdqdFJQNua +EPDLKvbdTqQntthN +DoDLKvbdYORAXtvU +DnbjjvbdEYXksstM +EPDKjvbdkMbMZdfo +DncLKvbdJKEAKQGd +EOcKjvbdFejSOJUR +DoCjjvbdYlRdTmkm +DoDKjvbdlYrqrxgU +EPDKjvbdKVuFdFGi +EOcLKvbdJqZeOfNe +DnbkKvbdzoPpdcLx +DoDKjvbddePSCXCj +DoDKjvbdEASIlywX +DoCjjvbdrEEiPmua +EPCkKvbdidkGuPAO +EObjjvbdKRZdnfNe +DncKjvbdhgJcZWJu +EPDLKvbdZxcimbkr +EPDKjvbdNeEUIiKd +EOcKjvbdvAdZSndh +DncLKvbdjggMGGNk +EObkKvbdOStVgFUp +EPCkKvbdRaceMIxk +DncKjvbdDwxMUUUM +DncKjvbdWeyZtAPT +EPCjjvbdEYXkstTl +EOcKjvbdxsOJNSBg +EPCkKvbdKQzFPFnF +EOcLKvbdJXtCHkpp +DoCjjvbdtlYXBUBX +EPCjjvbdwuNFRYkn +DoDLKvbdkDLjpfuH +EPDKjvbdxrmhlqbH +EOcLKvbdjmCLzEgP +DoCjjvbduaEYsPFI +EPCkKvbdCEPaWJmG +DncKjvbdwtmEpxlO +EPCkKvbdJbjCpjCx +DnbjjvbdhzVGMRNf +EPCkKvbdZxcinDMS +DoCkKvbdrNZiyLgi +EOcLKvbdIHGyyYYH +EObkKvbdYNqAXuWU +EPDKjvbdtvNwjRTA +EPCkKvbdcJMjLFvx +EPCjjvbdNrsvHEuQ +DoCjjvbdnGeYMmgZ +DoDLKvbdSLZGUfjs +EPDKjvbdtvOYKRTA +DoDKjvbdziuPpESt +DoCkKvbdMgDPlotk +DoCkKvbdeFOrCXDK +DnbkKvbdMgColpUk +EPCkKvbdKVuFdFGi +DoDLKvbduCcUvuoP +DoCkKvbdRDcAopdS +EPDLKvbdehKvSNpg +EOcKjvbdDoCjjvbd +DoCjjvbdOSsufdtp +EObjjvbdGQASwGfZ +DncLKvbdiHJcYujV +DncKjvbdRadFMJZL +EPDLKvbdZxcinDLr +EPDLKvbdhaoDFXQq +DoDKjvbdcJNJkGXY +DoDLKvbduaDySoEh +EOcKjvbdUxhUZkPO +DncLKvbdVYhTzKoO +DnbjjvbdehKvRnQg +DnbkKvbdOhAXyAYa +DncLKvbdxsNiNRag +DoDLKvbdTppoVUgm +EObkKvbdURROuVIN +EOcLKvbdNsTugFVQ +DoCkKvbdrXPlChxq +EPDKjvbdHDkWJajK +DoCkKvbdxnTHxTIc +EPDKjvbdEvZPoljF +EPDKjvbdrzMQTBIO +EPCjjvbdqZPHgQcx +DoCkKvbdVqmxCFMD +DncLKvbdSPsgKGEX +DoCkKvbdzjVPodSt +DoDKjvbdnUtyjiqf +DnbjjvbdIBkydzAD +DoDKjvbdcTDKscjB +EOcKjvbdiHKDYuiu +DncKjvbdBraDUFvr +DoCjjvbdQmYCZOUz +EPCkKvbdySnIlqbH +DnbkKvbdkDLjqGuH +DnbjjvbdVqnYCFMD +DncLKvbdGKeTCglu +DncKjvbdlZSqrxft +DncLKvbdrEEhpNvB +EOcLKvbdrDeJQNvB +EPCkKvbdQmXbYmtz +DoCkKvbdQlxCYnUz +EPCjjvbdEObkLWbd +EPDLKvbdehKuqmqH +EPCkKvbdkCkjpfuH +DncKjvbdRXNcblHc +EPCjjvbdsrqrxydc +EPDKjvbdddoSBvcK +EPCjjvbdADRxJzIp +EPDLKvbdvAcxsPEh +EPDKjvbdSLYfUgLT +DoCkKvbdsrrTYyeD +DoCkKvbdLFegbApu +EPCjjvbdyqOliJwA +EPDKjvbdqTtGrRjt +EPCkKvbdhbObdvqR +EPCjjvbdcScLUEJa +DoDLKvbdRWnDblID +EObkKvbdZLrETnLm +DoDKjvbdiBoDEvpq +DoDKjvbdMpXqVmfs +EPCjjvbdpxngfpcx +DncKjvbdsCGNLfjy +DncKjvbdRjyGVHLT +EPDKjvbdkHflGFmk +DoDKjvbdlhdUQuSB +EPCjjvbdKaLGlbXq +EPCkKvbdVhXvXgYz +EOcLKvbdKyQirztf +EOcLKvbdliDsqVRa +DncKjvbdJutfDdfi +DoDKjvbdEXwksssl +DncLKvbdxxIjCPyk +EObkKvbdKaKgMaxR +EPDKjvbdkCkjpgUg +EOcLKvbdZLqctNlN +EPDKjvbdNddThhjd +EOcKjvbdYlSDsmlN +EPDLKvbdmgExNOGy +DoDKjvbdePErjstS +DnbkKvbdZQleIldq +DncKjvbdpssfrRkU +EOcKjvbdDxYMTtTl +EPCjjvbdySmhmSBg +EPDKjvbdiiehJlxS +EOcLKvbdFkFTDINV +EPCjjvbdVqmxCFMD +DncLKvbdIsZAsMwl +DncKjvbdBraDTfXS +EPDKjvbdmuUykJqf +DnbkKvbdFyVUaEXb +EObjjvbdzROmJJwA +DncKjvbdEYXlUUTl +EPDKjvbdBhjbKhfK +DoCjjvbdJpzEneme +DncLKvbdVwIwuceH +EPDKjvbdhfjDYuiu +EOcLKvbdFpASwHGZ +EPDKjvbdZoOJEdyj +DoDKjvbdqdEiPnWB +DoDKjvbdnBjXYPNu +DoCjjvbdiHKCxuiu +EOcKjvbdGLFTChMu +EOcKjvbdiMEdNtby +DnbkKvbdGdKujBij +DncKjvbdKQydneme +DnbkKvbdziuPocsU +DoDKjvbdmfdxNNgZ +EObjjvbdDxXlUTtM +EObjjvbddePSBwCj +EOcKjvbdNPxQvOHT +DnbkKvbdZHWdAOsJ +EPDLKvbdyqPNIiwA +DoCkKvbdpyPHfqDx +EPDLKvbdUslsekuj +EPCjjvbdiZtfLpnG +DoCkKvbdmSZVZsDi +EPCjjvbdpyOhGpcx +EPDLKvbdzitoodSt +DoDKjvbdVYhUZkOn +EObkKvbdBsAbtGWr +EPDKjvbdvBEYsOdh +EObkKvbdGcjuibKK +DncKjvbdeATqNYKG +DoCjjvbdKNAEZgVB +DncLKvbdqUUHSRjt +EOcLKvbdGcjuibJj +DoDLKvbdnBivxPOV +DnbkKvbdKCjDRKCx +DnbkKvbdrykosAgn +EOcKjvbdUaBqTRRy +EPCjjvbdcSbkTcjB +DoDLKvbdIxTbILpp +DoCjjvbdHDjuibJj +DncKjvbduaDxroFI +DoDKjvbdpedEtWBI +EOcKjvbdXsLaNTnx +EPCjjvbdYORAYVWU +DoCjjvbdYpleIleR +DoDKjvbdCDpAujMf +EPCkKvbdpxoHfpcx +DoCkKvbdUWMPisaR +EPCjjvbdmuUzKjSG +EPDKjvbdkxsRsYgU +EPCkKvbdZxcjNblS +DnbkKvbdbPffckzd +EPDKjvbdUVkpJtBR +DoCkKvbdvlvANEFN +EObkKvbdShyjRAAl +EPDKjvbdxrmhmSCH +DoDKjvbdjvXNcaww +EPDKjvbdkDLjqGuH +EObkKvbdhfibxuiu +EPCjjvbdlqyUyrci +EPDLKvbdFVxopMjF +EOcKjvbdqdEiPnWB +DncKjvbdrXPlChxq +DoCkKvbdxVMeRYkn +EPCjjvbdlhdUQtqa +EObjjvbdRotHKFcw +EObkKvbdwjvcgzzG +EPDLKvbdBhkBjiFj +EObjjvbdlZTSTZGt +DoCkKvbdkIHMFemk +EObjjvbddndrkTsr +DoDLKvbdFVxpQNKF +EPCjjvbdZsiJZETO +EObjjvbdiMFEOUby +DoCkKvbdhlFEOUby +EPCkKvbdrWolDIyR +EObjjvbdmajWwoOV +DoCkKvbdypoMiJwA +DoDKjvbdCDpAvKMf +EPDLKvbdzjVQQDrt +EObjjvbdjlakydfo +EObkKvbdJpyeOeme +DoDLKvbdiHJcYvJu +EOcLKvbdbsDKtEKB +EOcLKvbdrpWOjDVf +EObjjvbdelfWfmKL +EObjjvbdxnSgwriD +DnbkKvbdqlyjZLhJ +EPCkKvbdQdDBPqDr +EPCkKvbdRkYfUfjs +EObjjvbdhtydwSVC +DnbjjvbdWWhwvDdg +DoDLKvbdypnliKXA +DncLKvbdhfibxvKV +DncLKvbdxrmiNSCH +DncKjvbdUaBqSqRy +DoDKjvbdZMSDsmkm +DncLKvbdFjeScHmV +EPDLKvbdQYmAHSrK +DoCkKvbdUVlQJsaR +DoDKjvbdGKdsDHmV +EPCkKvbdkHgLfGNk +EPDKjvbdCIkCLJFj +DoCkKvbdrpWOicVf +DncLKvbdqmZiyMIJ +EObkKvbdNGcQMpUk +EOcLKvbdhfibxuiu +DoCjjvbdjcLjqHVH +EPDLKvbdZxdJnDMS +DncLKvbdHDkViajK +EPDKjvbdhytelRNf +EPDKjvbdZRNFIleR +EObjjvbdNQYRWNgT +EPCjjvbdNdcsiIkE +DoCkKvbdajkfOnDA +EPCjjvbdRNYCZOUz +EPCkKvbdBcpAvKNG +DncKjvbdqTsfqrLU +EPCjjvbdsZlQSaHn +EOcKjvbdqdFIpNvB +DoCjjvbdtbcUwWPP +EObjjvbdEYYMTtTl +EOcLKvbdgGLzNfgA +DoDLKvbdzdynzeZp +DnbjjvbdajlGPNcA +EPCjjvbdEJhJuxKA +EPCjjvbdLLBIWAJy +DnbkKvbdwzIFewdr +DoCkKvbdBvzciEpW +DoDKjvbdaNKasVNH +EPDLKvbdVviXudEg +EPDKjvbdcbSmSAUN +EPDKjvbdqcdiQNua +EPCkKvbdbBVdfPpX +EOcLKvbdrEFIpOVa +DoDKjvbdDigivXjA +DoDKjvbdYSlBMtPY +DoDKjvbdrRtjnLAm +DoDKjvbdKeegbApu +DnbkKvbdHgHZyXxH +EPCkKvbddwzUTrFz +DnbjjvbduDCtwWPP +EOcLKvbdaRfDHsfL +EPCjjvbddeOqbWbj +DncLKvbdOFDsiJLE +EObkKvbdSBceMIyL +EOcLKvbdrylQSaIO +DncLKvbdJcJcQjCx +EPCkKvbdaRfCgsek +EOcKjvbdzitoocsU +DoDKjvbdyzdnSIJI +EObkKvbddndsLTsr +DoDLKvbdcTDKtEKB +EPCkKvbddZyQYYpb +EPDLKvbdCIjakJFj +DncLKvbdLrWlzVQz +EOcKjvbdxrnIlqag +DncLKvbddeOrCWcK +DoCkKvbdRaceLiZL +EPCkKvbddePSCXCj +DoDKjvbdJpzFOeme +DoCkKvbdiMFEOUby +DncKjvbdUQqPVVHm +EOcLKvbdcSbjscjB +DnbjjvbdvPTzpjoU +EPDKjvbdEPDLKvbd +DncKjvbdvBEYsPEh +DnbjjvbdIxTbIMQp +DoDLKvbdZLrETnMN +EPCkKvbdZxdJmbkr +EPCjjvbdIidAKQHE +DncKjvbdrSUjmjaN +DnbkKvbdkaNOmALA +DnbkKvbdiGjCyViu +EPCjjvbdYkrDsmlN +EOcKjvbdypoMhjXA +DoCkKvbdiGjDZViu +DoDLKvbdZxcinClS +DoCjjvbdqUUGrSLU +DnbkKvbdYTLaNUPY +EObkKvbdehKurNpg +EOcKjvbdmRyVZrdJ +EObkKvbdZirhPgBf +EOcKjvbdpyOggQcx +DnbkKvbdfoazwEXh +DnbkKvbdmuUzLJqf +EPDLKvbdYlRdUOLm +DncKjvbdRjyFuGjs +DoDLKvbdQdDAopdS +DoCkKvbdmSYtysEJ +EObjjvbdQdDApRDr +DoDKjvbdyOTHxShc +EPDKjvbdptUHSRkU +EOcKjvbdLGGHaaRV +EOcLKvbdaaWFFopX +DoCjjvbdlBMnmALA +DnbjjvbdZnnIdeZj +DoCjjvbdZMRdUNkm +DoDLKvbdRMxByNtz +EPCkKvbdJYTahMRQ +DncLKvbdpyPIHQdY +DoCkKvbdVBCRTRRy +EOcLKvbdZyEKODLr +EObkKvbdRadEkiYk +EOcKjvbdcyyQXyRC +DnbkKvbdVqnXadkc +EPCkKvbdGKeTDIMu +DnbkKvbdrRtjnKaN +EObkKvbdFVxooljF +DoDKjvbdDoCjjvcE +DnbkKvbddneTLTsr +EPDKjvbdGcjvKCKK +EObjjvbdgPazvdYI +DoDKjvbdSLYfVHKs +DoCkKvbdEPCjkWbd +DnbjjvbdmaivxPOV +EObjjvbdJJdAJogE +DoDKjvbdhkddNtby +DoCkKvbdiCPDEwQq +EOcKjvbdmajXYOmu +DnbkKvbdqYngfqEY +EOcKjvbdTppoUuIN +EPDKjvbdNddThhkE +DncKjvbdDnbkKvbd +DnbjjvbdZRNEiNFR +EPCjjvbdaaWFFopX +EPDLKvbdBhjbKhej +DoCkKvbdfpBzvcwh +DoDKjvbdmSZVZrdJ +EObkKvbdbAueGQQX +EOcKjvbdNQXqWOGs +EPCjjvbdvAcySndh +EOcLKvbdySnImRag +EObkKvbdSxLLmzkY +DnbjjvbdcJMjLGXY +EObkKvbdBsBDUFwS +DoCjjvbdqlyjZLhJ +EPCjjvbdliEURVRa +DoDKjvbdptTgRrLU +DncKjvbdiBoCdwQq +EOcKjvbdEOcLLXDE +EObjjvbdEYYLtTsl +EPDKjvbdVTmTekuj +DncLKvbdLFegbBQu +EPCjjvbdmttzLKRf +EPDLKvbdpfEFTuaI +DncKjvbdiiegjMwr +EObkKvbdxVNEqYlO +DoCjjvbdRWnDblHc +EPCjjvbdaSFbgtGL +DnbkKvbdozmcjwoA +DoDKjvbdPyNAHSrK +DncLKvbdVqnXbEkc +EPCkKvbdFWYpQNJe +EOcLKvbdlYsRsZHU +EOcLKvbdQvmcblID +EObjjvbdRkYetfkT +DoCjjvbdFjdsDINV +EPCjjvbdrafNMGkZ +EPDKjvbdczZQXxqC +EPDLKvbdDwxLtTsl +DoCjjvbdFpASvffZ +DoCjjvbdiMEdOVCy +DoCkKvbdelevfljL +DnbjjvbdaSFcHtFk +DncKjvbdBhkBkIfK +EObjjvbdGKdsDHmV +DncLKvbdhzUekqOG +EOcLKvbdZshiZDrn +DncLKvbdDjIJuwjA +EPCjjvbdpxoHfqEY +EPCjjvbdOAIrsjSA +EPDLKvbdEuyPolie +EPDKjvbdssRrxydc +EPDKjvbdjlakzEgP +DncKjvbdiUydwRuC +DoCkKvbdZMSDtNkm +EPDLKvbdbBVeGQPw +EObkKvbdNHDPlpVL +DoDLKvbdDjHiuxKA +EPDKjvbdatbGwkUI +DnbjjvbdeqaWzkbo +DoDKjvbdvvlBWAuu +EObjjvbdZirhQHBf +EPCkKvbdDncLKvcE +DnbjjvbdehKvSNpg +DncKjvbdVwIwudFH +DoCjjvbdNQYRVmgT +EOcKjvbdNrtWGeUp +DncKjvbdvvlAvAuu +DnbkKvbdjKGHimXr +EObjjvbdhkddNuDZ +EPCkKvbdNddThhkE +EPCjjvbdsPunjDVf +EPDKjvbdxZgfFwdr +DncKjvbdZyDjNblS +EPDKjvbdjcMLQfuH +DncKjvbdwtmFRZMO +DncKjvbdVhXuwgYz +DoCkKvbdVZITyjnn +EPCkKvbdNrtWHEtp +EPCjjvbdMfbomQUk +EObkKvbddwyssqez +EPCkKvbdhfjCyVjV +DoDKjvbdtvOYJpsA +DoDKjvbdiLdcnVCy +EObkKvbdLrWlzUpz +DoCkKvbdSPsgKFdX +EPCjjvbdkNCLyeGo +DncKjvbdCSaCtGWr +DnbjjvbdRkZFtgLT +DoCkKvbdVAaprprZ +DnbjjvbdyXhibQZk +DoCkKvbdsQVnibvG +EPCjjvbduaDyTPFI +DncLKvbdUaCRSpqy +DoDLKvbdnPzYukZC +DoDKjvbdRWnDcMHc +EOcKjvbdxVNFRZLn +EOcKjvbdRkZGUfkT +DnbkKvbdvmWAMdEm +EOcKjvbdmbKXYOmu +EPCkKvbdyXiKCPyk +DnbkKvbdkHgMFfOL +DncKjvbdVYgtZkPO +EPCkKvbdDnbkKwCd +EObkKvbdKfGHaaRV +EPCkKvbdqZOggQdY +EOcLKvbdTlVnaVoJ +DoCkKvbdhanbeWqR +DnbkKvbdypoMiJwA +DnbkKvbduMXvaUBX +DoDKjvbddiirWUzn +EObkKvbdqYoHgQcx +DnbjjvbdFyUuBDwb +DoCkKvbdKCicQjDY +EPDLKvbdezvYeJTw +EPCjjvbdSxKlNzkY +DoDKjvbdQmYByOUz +DnbjjvbdIGgZxxXg +EPDKjvbdqmZjZLgi +DncKjvbdmfeYMmgZ +DncLKvbdGdLVibKK +DoCkKvbdZGvdAOsJ +EObkKvbdjSzhrkJz +EPDLKvbddePRbWcK +EObjjvbdDxXkstUM +DoCjjvbdvlvANDeN +EOcKjvbdrDdiQOWB +DoCkKvbdmajXXoOV +DncKjvbdUtMsekvK +EOcLKvbdxxJKBoyk +EPDKjvbdqYnhGpcx +EObjjvbdatafwkTh +DncLKvbdajkenmcA +DnbjjvbdZQleImEq +EPCjjvbdDncLKwCd +EObjjvbdHELWKBij +EPDLKvbdxrmhmRag +DoCjjvbdwXMBWBVu +EObjjvbdsPvOjCvG +EOcLKvbdssSTZZdc +EPCkKvbddndrkUUS +EOcLKvbdNGbolotk +EObjjvbdZMSDtNlN +EObkKvbdZshiYcsO +DncKjvbdDwxLsstM +EOcLKvbdqZPIGqEY +EOcKjvbdZRNFImFR +EOcKjvbdrDeIonVa +DnbjjvbdYzberKWZ +EObjjvbdegjvRnQg +DoCkKvbduDDUwWOo +EPDKjvbdRotGjGEX +EOcKjvbdKQyeOeme +EPCjjvbdDwxMTtUM +EObjjvbdpedFTvAh +EPDLKvbdFxtuBDxC +DoCjjvbdlqxtzSdJ +DncKjvbdZLrDtOMN +EPCkKvbdGdKujBjK +DoCkKvbdezvYdiTw +DnbjjvbdrEEiQOVa +DncKjvbdOYPVzdOU +DnbjjvbdxwiKCPzL +EObkKvbdRpTgJecw +DoCkKvbdwtmEpxlO +EPDKjvbdqFceTuaI +DncKjvbdsPuoJcWG +DncLKvbdRyjHsCvA +EPCkKvbdyXiJaoyk +EPDLKvbdJvVFcdgJ +DncLKvbdrXPlChxq +EObjjvbdvBEZTOdh +DoDKjvbdqvokcJYq +EOcKjvbdlqxtzSci +EPDKjvbdFkErbglu +DoDKjvbdEPDLKvcE +EObkKvbdijFhJlxS +DoCjjvbdOFDtJJKd +DnbkKvbdyXhiapZk +DncKjvbdEXwlTtTl +DncLKvbdZyEKOCkr +DnbkKvbdqlyjYlIJ +EObkKvbdIGfyxwxH +DnbjjvbdyNrgxTIc +DnbkKvbdeOeSkTsr +EPCjjvbddZyPxZRC +DncLKvbdkDMKpgUg +EPDKjvbdfIKuqnQg +EPCkKvbdhlFENuDZ +DoDLKvbdiBoCdvqR +EPCkKvbdySnImRag +DnbjjvbdIxTahLqQ +DoDKjvbdZnmhddyj +EOcKjvbdgQBzwEXh +EPDLKvbdfILWSNqH +DncKjvbdjcMKqGtg +EObkKvbdKQzEnfNe +EPDKjvbdUQqPVVHm +EObjjvbdREDBPpcr +EObjjvbdnHExMnGy +DnbkKvbdvBDxrndh +DncKjvbdCEPaVimG +DnbkKvbdGBPQxizm +EPDKjvbdLqwMzVQz +DnbkKvbdEPDLLXDE +EPDKjvbdwWkaWBVu +EObkKvbdxrnImSCH +DncKjvbdsrqrxzEc +DnbkKvbdpfDeUWAh +EPDKjvbdjAQHApGj +DoCkKvbdaSGChTfL +DoDKjvbdiHJbxvKV +EPDLKvbdlhdURUqa +EPCjjvbdIwsahMRQ +EObjjvbdGYtuBEYC +DncLKvbdNeEThhkE +EObkKvbdBvzdIePv +EPCjjvbdbAueFpQX +EOcLKvbdjAQGaQGj +EPCjjvbdNHDQNPuL +DncLKvbddoFSkUUS +DncKjvbdACqxJzIp +DnbkKvbdxLWcgzyf +EPCkKvbdTlVnaWPJ +DoCkKvbdCJKbLIfK +DoCkKvbdDwxMUTtM +EPCkKvbdEPDLKwDE +EOcLKvbdTvMQKTaR +EOcLKvbdeXytTrFz +EPDKjvbdNUrrLNAX +DnbkKvbdZjShPgBf +EObjjvbdjAPfaQGj +EPCkKvbdYlRdUNlN +EPDKjvbdzjUoocsU +DoDLKvbdKDKCqJbx +EPCjjvbdQvnECkhD +DnbkKvbdGckVjBij +EObjjvbdXmqAXuVt +EPCjjvbdeFPRavcK +DoDKjvbdEYXlUTsl +DoCjjvbdXrlBNToY +DoDLKvbdrRuLNkAm +DncLKvbdDxXlUTtM +EOcKjvbdwuNEqZLn +EPDKjvbdEOcLLWbd +DoCkKvbdpfDdtVaI +EOcKjvbdmpZyVjyC +EOcKjvbdtSrSxzFD +EObkKvbdsBemLfjy +DoCjjvbdUGznMWue +DncLKvbdbAvEfPpX +DnbjjvbduCcUwVno +DoDLKvbdTppoUuIN +DncKjvbdYqMeImEq +DoCkKvbdrDdhomvB +EObjjvbdgFkzOGgA +EPDKjvbdSwjkmzjx +DoCjjvbdREDBPpcr +EObjjvbdYkrDtNlN +EObjjvbdZisHogCG +DncKjvbdUtMselWK +DoDKjvbdkHfkeemk +DncLKvbdSLYeuHLT +EOcLKvbdeFOrBwCj +EObjjvbdHDjvKCJj +DnbkKvbdkIGkeemk +DoCkKvbdZQmFJMeR +DoCkKvbdqTtGrSKt +DncLKvbdcIljKfWx +DnbjjvbdRjxfUgKs +DnbkKvbdhyuFlROG +EObkKvbdpxoHfpdY +DoDKjvbdhuZdwRtb +DnbkKvbdBdQAvKMf +DoCkKvbdVTlsekuj +EObkKvbdCJLBkIfK +EOcKjvbdmgFYNNgZ +EPDLKvbdxrnImRag +DoCjjvbdbKlGPODA +DoCjjvbdMoxRVmgT +EPDLKvbdKfGIBaRV +DoDKjvbdSCEElJZL +EPCkKvbdmRxtzSdJ +EPDKjvbdjKGIKNXr +DnbkKvbdlhdTptrB +EPDKjvbdBcoaVilf +EPDKjvbdRzKIScWA +EOcKjvbdnHFXmOGy +EPCjjvbdFfJrNhtR +DnbkKvbdzaAPHHCM +DnbkKvbdwXLaWBWV +DoDKjvbdKeegaaQu +EPCjjvbdRotHKFcw +EOcKjvbdnGeXmOGy +DoCjjvbdmIdTqVRa +DncLKvbdfNGWgMik +EPCkKvbdrovPJbuf +EObkKvbdEvYpPljF +DncLKvbdOYPVzdOU +EObjjvbdrzLosAhO +DnbjjvbdyzdnSIJI +EOcLKvbdIsZArmYM +DoDLKvbdvAdZTPEh +DoCkKvbdQvnDcMHc +EObjjvbduMYWaUBX +DncKjvbdUyHszLOn +EPCkKvbdbrbjscia +EObjjvbdTkunaVni +EObkKvbdeATpmYKG +EOcKjvbdqUTfqrLU +EPDLKvbdGYttaDxC +EPDKjvbdRNYByNtz +DncLKvbdADRwizJQ +DncLKvbdKfFgaaQu +EPDKjvbdxZhGGYFS +DncLKvbdwtmFRYlO +EOcLKvbdehLVrNqH +DnbkKvbdKxpirztf +DoCjjvbdZxdKNcLr +DoDLKvbdrbFmMGjy +DoDLKvbdqYnhHQcx +EPCjjvbdGKeTDIMu +EPCjjvbdZRNEhleR +DnbkKvbdfMfXGmJk +DnbjjvbdRjyGVHKs +EPDKjvbdZHXEAOri +EObjjvbdxnTIYTIc +DnbjjvbdTpqOttgm +EOcLKvbdWXIwuceH +EOcLKvbdzROmJKXA +EPCkKvbduCbtwWOo +DncLKvbdJTZBTMwl +EObkKvbdlqyUysDi +DnbjjvbdrpVoJcWG +DoCjjvbdHDjvKCKK +EObkKvbdVwJXvDeH +EPDKjvbdZsiJZDrn +DoCkKvbdhfjDYvJu +DoDLKvbdZyEJmcLr +DnbjjvbdmajXXoOV +DoCkKvbdelewGmKL +DoDLKvbdUtMsfMVj +EOcKjvbdegjuqmpg +DnbkKvbdZMRctNkm +DncKjvbdhlEdOUcZ +DoDLKvbdqAiFAXIE +EObjjvbddBsMrAUN +EPDKjvbdaSGDHtGL +DnbjjvbdbVCGwjtI +DncLKvbdzdzOzeZp +EPDKjvbdKQyePFnF +EPDLKvbdauBgXjtI +EPDLKvbdCSaCtGWr +DnbkKvbdbsCjtEKB +DoDKjvbdCWzdIeQW +EPCkKvbdRbDeLhxk +EObjjvbdOEctJIkE +DoCkKvbdSPtGiedX +DncKjvbddZyPxZRC +DnbjjvbdTukpKUBR +DoCjjvbdpstHRqkU +DncKjvbdNdctIhjd +EOcKjvbdUWMPjTaR +DoCkKvbdLGGHbApu +EObjjvbdmozZWLZC +EObjjvbdULvPAvOi +EPDLKvbdcJMikFvx +DncLKvbdjJfHjMxS +EPCjjvbdqYoIHREY +DoCjjvbdiifHjNXr +EObkKvbdZLrETnMN +DnbkKvbdtSqsYydc +EPDLKvbdCIkCLJFj +DoCkKvbdliDsqUrB +DnbkKvbdNPxQumgT +EPDKjvbdACrYJyiQ +EOcLKvbdYTMBMtOx +DoDLKvbdNGcQNPtk +DncKjvbdtbbtvuno +DncKjvbdZLrEUNlN +DoCkKvbdaogHELzd +DoCjjvbdgFlZmfgA +EPCjjvbdvPTzpkOt +DoCjjvbdjKGHjMxS +EPDLKvbdauBgXjsh +EOcLKvbdiBoCeWpq +EObkKvbdSPsfjGEX +DnbkKvbdzGxlAMeX +DoDLKvbdqFcdtWAh +EPCkKvbdOYOuzcmt +DoCjjvbdDwxLtUTl +DnbkKvbdOTUVgFUp +DnbkKvbdiGibyWJu +EPCjjvbdUyITzLOn +DoCkKvbdbLMFnnDA +DoCjjvbdDwxLsssl +DncLKvbdBiLBjhfK +EPDKjvbdNPwpvOGs +EObkKvbdzQnliKXA +DoCjjvbdeYZssqez +DoCjjvbdeATplxKG +EOcLKvbdRyjIScWA +EPDKjvbddeOqbWcK +EPDLKvbdACrXjZhp +DnbjjvbdmuVZkKSG +EPDKjvbdVqmwbFLc +EPCkKvbdCSaCtFwS +DnbjjvbdVZHszLPO +DoDKjvbdVrNxCFLc +EOcKjvbdegjuqnQg +EPCjjvbdZMSETmlN +EOcKjvbdHDjvKBjK +EPCkKvbdyOTIXsJD +DoDKjvbdnQZyWKxb +DncLKvbdxwhiaozL +DncLKvbdNdcshhkE +EPCjjvbdXnRAYUut +DoDLKvbdNsUWGeUp +DncKjvbdWHwuwfxz +DnbkKvbdRpUGifEX +DnbjjvbdEOcLKwCd +EPDKjvbduaEYsOeI +DnbkKvbdjhHLfFnL +DncLKvbdZoOJEeZj +EPCkKvbdEPCjjvcE +EObjjvbdxUldqYkn +EObkKvbdOEdThiLE +DnbkKvbdjcMKpgVH +EObjjvbdkIGkeenL +DncKjvbdZsiJZDrn +EPCkKvbdxnShXsIc +DoDKjvbdZnmiEdzK +DoCkKvbdVTmUGLvK +EOcLKvbduCcVXVno +EObjjvbdZQleJNFR +EObjjvbdFejRmhsq +EPDLKvbdaMkBruNH +DoCkKvbdNQXqWNgT +DoDKjvbdjuwNcbXw +EPCjjvbdSBceLiYk +DoCjjvbdMgColpVL +DoDLKvbdVZHtZkPO +DoDKjvbduMYXBUAw +EPDKjvbdNeDshiKd +DoDKjvbdTAFJICPE +EObjjvbdJvVFceGi +EObjjvbdNHCpMpUk +DnbkKvbdijGIKNYS +DoDLKvbdDncKkXCd +DncKjvbdkMakyeGo +EObkKvbdjKFgilwr +DoCkKvbdOhAXyAZB +DoCkKvbdUGznMWvF +EOcKjvbdRosfifEX +EPDLKvbdfNFvgMjL +EObkKvbdxxJJbPzL +EPCjjvbdQlxCYmtz +EOcLKvbdgPazwEXh +DoDLKvbdkySrTYft +DoDLKvbdhgKDYuiu +DoDKjvbdYkrETmkm +EObjjvbdNPwpunHT +EOcLKvbdYlRdUNlN +DnbkKvbdZLrDtOLm +EObjjvbdxrnJMrCH +EObjjvbdZnnIeFZj +DoCjjvbdzRPMhiwA +DncKjvbdssSSxyeD +EOcLKvbdjAPgAofj +DncKjvbdRosfifEX +DoDKjvbdEXwktUTl +DnbjjvbdWRmwadkc +EPDLKvbdeEoRavbj +DoDKjvbdXsMBNToY +DnbkKvbdVqmxCFLc +EOcKjvbdkVwOEBww +DoCjjvbdfNGXGmJk +EOcLKvbdmtuZjiqf +DoCkKvbdnPyyWKyC +EObjjvbdJpydoGNe +DnbkKvbdjJfHimYS +DoCkKvbdyXhjBozL +DoCjjvbdkIHLeenL +EOcLKvbdTAEiIBoE +DnbkKvbdvBDxsPFI +DncKjvbdlhdTpuRa +EObjjvbdFfJqmiUR +EPCjjvbderAvzkbo +DncLKvbdwygeexEr +EObjjvbdSBdElJZL +EOcKjvbdySmiMrBg +EPDKjvbdatbGwkTh +DncKjvbdnBivwnmu +EPDKjvbdFxuVAdYC +EPDLKvbdqlzJyMHi +EPDKjvbdZRMdhldq +DoCjjvbdNeDtIhkE +DoCkKvbdfMewGlik +EOcLKvbdhaoDEwQq +DnbjjvbdIwsagkqQ +DncKjvbdkIHMGFnL +DoDLKvbdGdKuibKK +DnbjjvbdTAEiICOd +DncLKvbdNeEThiKd +EObkKvbdYpmEiNFR +EPDLKvbdFkFTDHlu +DoCkKvbdkDLkRHUg +DnbkKvbdyYIjCPyk +DncLKvbdFVyQPmKF +DnbjjvbdZQldhldq +DoDKjvbdVqnYBdkc +EPDKjvbdSKxeuGkT +EPCjjvbdiZuGLqNf +DnbjjvbdJTZArmXl +DnbkKvbdyNrgwrhc +EOcLKvbdrNZiyLgi +DncKjvbdSBdFMJZL +EPCkKvbdfMfWfmKL +EPDLKvbdfMevfljL +DoCjjvbdmIcsqVRa +DoDLKvbdrEEhpOVa +EPDLKvbdZRMeImEq +DoDLKvbdyTNiMrBg +EPCjjvbdsQVnibvG +EOcKjvbdvBDxsPFI +DoDKjvbdqquKnKaN +DncLKvbdqGDeTuaI +EPCkKvbdZdxGzgiC +DoDKjvbdkDLkQftg +DoDKjvbdePEsKtUS +DoDKjvbdUxgtZjoO +DncLKvbdxUmFRYlO +DnbjjvbdwuMeRYkn +DoCkKvbdRWmdClID +EPDLKvbdCDpBWJlf +DncKjvbduaEYrneI +DnbjjvbdfHkVqmpg +EPDKjvbdKxpirzuG +DoDLKvbdZLqdUNkm +DoDLKvbdDwxMTstM +EOcKjvbdrzLosAhO +DnbjjvbdqZPHgQdY +EObkKvbdjggMFfNk +EPCjjvbdZMRcsmkm +EObjjvbdEJgiuxKA +DncLKvbdZtJJZDsO +EObkKvbdRjxeuGkT +DncKjvbdqdFJPmua +DoCkKvbdGYtuAcxC +DoCjjvbdZnmheEzK +DoCkKvbdKWUfEFGi +DoCkKvbdfMfXGmKL +DnbjjvbdjvWmcbXw +DnbkKvbdyzeORhJI +EPDLKvbdpstHRqjt +DoDKjvbdTukpKUAq +DoDKjvbdSPtGjFcw +DncKjvbdWSNxCFMD +DnbkKvbdjlalZdgP +EOcLKvbdkxsRsYgU +EObjjvbdLFfICApu +DoDKjvbdCEQBWKMf +DoDKjvbdbAvFFpQX +DoCkKvbdhgKCxvKV +DncLKvbdjcMLQgVH +EPCkKvbdzitpQDrt +EOcKjvbdNVTRjmAX +EPDKjvbdkxsRsZHU +DoDKjvbdKDJcRKCx +EPDKjvbdFjeScHmV +EPCkKvbdZjTIQHBf +DnbkKvbdlqyUyrdJ +DoDKjvbdehKurORH +EObjjvbdbKlFoODA +DoCkKvbdwtmFQyMO +DoCjjvbdXnRAYUut +DoDKjvbdxsOIlqbH +DncLKvbdyNsIXrhc +DoDLKvbdCEQAvKNG +DncKjvbdRotHJedX +EPDLKvbdVZHsyjoO +DnbjjvbdkCkkRHVH +DoDKjvbdRWmcblHc +DncLKvbdqvokbiYq +DoDLKvbdRkZGVHLT +EObjjvbduCbuXVno +DoCkKvbdEJgivYKA +DoDKjvbdkWWnDbYX +EPDKjvbdnGdxMmfy +DoDLKvbdIHGzYxYH +DoDKjvbduCbtwVno +EObkKvbdqlyjYkgi +EObjjvbdVwIwudEg +DnbjjvbdfRaWzkcP +EPCkKvbdEARhlzXX +DnbkKvbdfMevfmJk +DncLKvbdZyDjNcLr +EOcKjvbdtAHQhABS +DncKjvbdkClKqGtg +DoCkKvbdEObkLXCd +EObjjvbdFkFTDINV +EOcKjvbdEztQdkcJ +DoCkKvbdKaLHNBxR +EPDLKvbdhaoCdvqR +EObkKvbdrJAJdmOe +EObjjvbdrpVnjCuf +EPCkKvbdFjeTCglu +DoCjjvbdqdEiPnWB +EPDKjvbdGFirOJUR +EPCkKvbdJmADzHUa +EPCjjvbdWWhwucdg +DncLKvbdBhkBjiFj +DoCkKvbdSZihSbvA +DncKjvbdZtIiZETO +EPDLKvbdCTAcUGXS +DoDKjvbdVqmxCFLc +DncLKvbdmajWwoOV +EPDKjvbdVhYVxHYz +DoDLKvbddoFSjtTr +DoDLKvbdrzMQTAgn +DoCjjvbdUVlPjUBR +EPDLKvbdtvOXipsA +DoCjjvbdrouoKCvG +EObkKvbdOSsufdtp +EPDLKvbdIGfzZXxH +EObkKvbdbQGgDkzd +DoCkKvbdOFDtJIkE +EPCjjvbdiHJbyWJu +DnbjjvbdLAkHMaxR +EPCkKvbdJTZBTMwl +DncLKvbdSQTfjGEX +EOcLKvbdlrZVZrci +EObjjvbdkyTSTZHU +EPCjjvbdxUleQxkn +EPDLKvbdEKIKWYKA +DoCkKvbdZHWdAPSi +EPDLKvbdxVNFRZMO +EPDLKvbdcSbkTcjB +DoCkKvbdlYsSTZGt +EPDKjvbduaDxroFI +EObkKvbdNHDQMouL +DoDLKvbdxrnJMqbH +DnbjjvbdmfeXmOGy +DoDKjvbdidkGtoAO +DnbjjvbdGYtuBEXb +DnbjjvbdRECaQQdS +DoCkKvbdmajXXnnV +DncKjvbdZMSEUNlN +EPCkKvbdZtJIxcrn +DncLKvbdJpydneme +DncKjvbdVviYWEEg +DoDLKvbdyXhjBoyk +DoCjjvbdbhlikGXY +DnbkKvbdVviXudFH +EPCkKvbdYTMAlsnx +EPCjjvbdxZhFeweS +DoCjjvbdyNsIXriD +DoDKjvbdznoqEcMY +DnbjjvbdauCHXjtI +DncKjvbdIsZAsMwl +EPCkKvbdZMSDtOLm +DnbkKvbdJqZePFme +EPDKjvbdkHfkeenL +DoDLKvbdaNLCStmH +DncLKvbdIwsbHkqQ +EObkKvbdfHjvRnRH +EPCjjvbdlqyVZsDi +EObkKvbdEuxoolie +DoDKjvbdjAPgAofj +EOcLKvbdjcMLRHVH +DncKjvbdjKFgjNXr +EPCkKvbdmIctQuRa +DncLKvbdJpyePGOF +DncLKvbdNGbpMouL +EObkKvbdpfDdsuaI +EPCjjvbdyzeORhIh +DoDKjvbdrDdhpNua +DoCjjvbdFfKRmhtR +EPDLKvbdpfEEsuaI +EPDLKvbdqcdhpOVa +EPCjjvbdVYgsykPO +DoDLKvbdDncLLXCd +EObkKvbduaEYroEh +EOcLKvbdkNBlZeHP +EObjjvbdGcjvJajK +DncLKvbdrpVoJbuf +EObjjvbdEKIJuxKA +DncKjvbdZxcjODMS +DncLKvbdmgFXmOGy +DoCkKvbdUMVoAuoJ +DoDKjvbdqcdiQNua +DnbkKvbdbrcKtDia +DnbkKvbdKfFgbApu +DncKjvbdezvZEiTw +DnbkKvbdlqxtzSdJ +DoCjjvbdOTUWGeUp +EPCkKvbdJXtBhMQp +EOcLKvbdOAJTTjSA +EOcKjvbdfILVrNpg +EOcLKvbdnQZxvLZC +EPDKjvbdyYJJaoyk +DnbjjvbdkMakzFHP +DnbjjvbdjbkjpfuH +DoCkKvbdgGLymfgA +DoDLKvbdJYUBhLpp +EPCjjvbdJSyBTMxM +DnbjjvbdyTNiMrBg +DnbkKvbdqYoHfpdY +EOcKjvbdZyEKNcLr +DoCkKvbdZtIiYcsO +EPCkKvbdZQmFJNFR +DncKjvbdSPsgKFdX +DoCjjvbdvwMAuaWV +EPDKjvbdHfgZxxYH +EObkKvbdrSUjnKaN +DnbjjvbdKWVGEFGi +DncKjvbdsPvOjDWG +EPDKjvbdhzVFkqOG +DoDKjvbdssSSyZdc +DoDKjvbdYkqcsmlN +EPCjjvbdYpldiNFR +DncLKvbdemFwGlik +DoDLKvbdjuvmdBxX +DoDKjvbdCTBDTewS +DoCkKvbdKeehBaQu +EObkKvbdwyhFexEr +DoDKjvbdQvmccMID +DoDKjvbdVviYVceH +EPCkKvbdmRxtyrdJ +EPDLKvbdYqMeJNFR +EPCkKvbdRbDeMIxk +EPCkKvbdcJMjKfXY +DnbkKvbdVwIwvDdg +DnbjjvbdIwtCHkpp +DncLKvbdczYpYYqC +EPCkKvbdKaLGmBxR +DncKjvbduLwwAsaX +DncLKvbdssRrxzEc +EObjjvbdrXQMCiZR +DnbkKvbdZRNFImFR +EOcKjvbdACqwjZhp +DnbjjvbdbKlGOmcA +EObjjvbdGFirOJUR +EPDLKvbdqvokbiYq +EOcKjvbdJmAEZgUa +DoCkKvbdbhljKevx +EPCjjvbdbKlGPNcA +EOcKjvbdRMxByOUz +EOcKjvbdbsDLUEJa +EPCkKvbdRacdlJZL +EObkKvbdmuUyjjSG +EObkKvbdjKFgjNXr +DoDLKvbdlhctQuRa +DoCkKvbdjKFhKMxS +EObjjvbdpedEtVaI +EOcKjvbdIwtBhLpp +DnbjjvbdZHWdAPSi +EOcLKvbdiLdcmuCy +EOcLKvbdjcMLRGuH +EPCjjvbdRbDdkiZL +EOcKjvbdiHJbxvKV +EOcLKvbdaSGDHsfL +DoCkKvbdjKFhJlwr +DncKjvbdiBoCeWqR +EOcLKvbdegjvSNpg +EOcLKvbdrbGMlHLZ +DnbjjvbdBraDUGXS +DncLKvbdFeirOIsq +EPDLKvbdhytekpmf +EOcKjvbdIsYaTMwl +DnbkKvbdrSVLOKaN +DoCkKvbdTIyjRABM +EOcLKvbdsBfNMGkZ +EPDLKvbdUtNTfMWK +EObkKvbdRjxeuGjs +EObkKvbdTqQnuVIN +EObjjvbdhuZdwRuC +EOcLKvbdqTtHSSKt +DncKjvbdmpZxvLZC +DoDLKvbdlAloNALA +EPDKjvbdiLddOUby +EPDLKvbdwuMdpxlO +DncKjvbdNrsvHEuQ +EPCkKvbdyOSgxTJD +EOcLKvbdIryArlxM +EPDLKvbdZHXEAPSi +EPCjjvbdSCDdlIxk +EOcKjvbdySnJNSCH +DnbjjvbdijGIKNXr +EPDKjvbdVAaqTRSZ +EObjjvbdkxsSSxft +EPCkKvbdnUtzKiqf +EPCkKvbdlqxuZsEJ +EObjjvbdEXxMUUUM +EPCkKvbdLFfIBaQu +DnbjjvbdrRtkNjaN +DoCjjvbdNHCpMpUk +EPDKjvbdZjTIQGaf +EPCkKvbdHELWJbKK +DoDKjvbdJbibpjCx +DnbjjvbdJSyArmYM +EPCjjvbdfNFwGmJk +EOcLKvbdYTMBMsnx +DoDLKvbdyTOJMqbH +EObjjvbdEPDLLXDE +DncLKvbdkyTSTZGt +EObjjvbdGBPRYizm +DoCkKvbdVviXvDeH +DncKjvbdsQWOicVf +DoCkKvbdfHjvSNqH +DncKjvbdlZTSSxft +DncKjvbdFVyPolie +EPCjjvbdRXODblID +DoCjjvbdlhcsqVSB +DncLKvbdqYnhGqDx +EObjjvbdFeiqmiUR +DnbjjvbdKefHaaQu +DoDKjvbdRNXbYmtz +EOcKjvbdNwnuzcmt +DoDLKvbdXFxytAPT +EPDLKvbdOTUVfdtp +DoCjjvbdraelkfkZ +DncKjvbdXsMAltPY +DoDKjvbdVUMsfLuj +EPDLKvbdZisIPfbG +EPDKjvbddZxpYYqC +DnbkKvbdzjUopESt +DnbkKvbdVUMtGMVj +DncLKvbduCbtwWOo +EObkKvbdaaVeFpPw +DncKjvbdKNADzGta +DncKjvbdeEoSCXCj +EObjjvbdhancEvqR +EObkKvbdKCicQibx +DncLKvbdijGHjMwr +DoCkKvbdziuPpETU +DoCjjvbdiBnbeXRR +DoCkKvbdZQmEiMdq +EObkKvbdrMyjZMHi +EOcKjvbddoErkTtS +DoCkKvbdtkwvaUAw +EPDLKvbdTlVnaVoJ +DncKjvbdfHjurOQg +DoDLKvbdWWiXvEEg +EPCkKvbdqdEhpNua +EOcLKvbdYSkaMtPY +EPCkKvbdxmsHxTIc +DnbjjvbdJqZdnenF +EPDKjvbdWexzUAOs +EOcLKvbdrovPKCuf +DoDKjvbdkxsSSyGt +Dnbjjvbdzdynzdyp +EOcLKvbdHEKvJbJj +EObjjvbdOStWHEuQ +DnbjjvbdkyTRsZGt +DoCkKvbdcJNKKevx +DoDKjvbdSPtGifDw +EObkKvbdGdLVibKK +DnbjjvbdbBVdfPow +DncKjvbdhtyeXSVC +EPDLKvbdptTfrSLU +DncKjvbdjvXODaww +DncKjvbdqZOgfqDx +DncLKvbdTJZjRABM +EOcLKvbdTpqPVUhN +EOcKjvbdRWmdClID +DoCjjvbdqquLOLAm +DoCjjvbdFfJqmiUR +EOcKjvbddBsMrATm +EOcKjvbdYzcFrKVy +EPCjjvbdsZlQSaIO +EPCkKvbdkHfkeenL +EOcKjvbdiHJcYuiu +DoDKjvbdCEPaVilf +DoCjjvbddBrmSAUN +EPDLKvbdSPtGifDw +EOcLKvbdAMhYrvyx +DncLKvbdTIyjRAAl +EOcLKvbdZtIhyESn +DnbjjvbdVUNUFlWK +EOcKjvbdyXiJaoyk +EPCkKvbdDncLKvbd +EOcLKvbdKWVFcdgJ +EPDKjvbdnQZxvKyC +DncKjvbdjJehJlxS +DoDKjvbdRkYfVHKs +EPDLKvbdirzhsLJz +EObkKvbdVUMtFkuj +DnbjjvbdqwPkbiYq +EPCjjvbdIGfzZYXg +DoCkKvbdlYsRryGt +EObjjvbdpfDeUWBI +EOcKjvbdwtldpxkn +DoCkKvbdzitopETU +DoDKjvbdJuuGEEfi +DnbkKvbdnPzZVkZC +EOcKjvbdmfeYMnGy +EPDKjvbdkIGlGGNk +DncKjvbdezvZEhtX +EPDKjvbdqqtjmkAm +EPDLKvbdzRPNIiwA +DoCkKvbdGKeSbgmV +EPDLKvbdmJETqVSB +EPDKjvbdbVCGwkTh +DoCjjvbdBhkBkIej +EOcLKvbdbBWFFopX +DncLKvbdjggLfGOL +EPCkKvbdzQnmIiwA +EOcLKvbdhbPDFWpq +EPDLKvbdkClLQgVH +EObkKvbdrWpMChyR +DncKjvbdMfbpNPuL +DnbjjvbdNsUVfeVQ +EOcKjvbdaRfDHtFk +DoDKjvbdRbEFLhyL +EOcKjvbdmIcsqUqa +DncKjvbdFVyPpNJe +DoCjjvbdLAjgMaxR +EOcLKvbdypoNJKXA +DncLKvbdEztRFMCi +DoCkKvbduVmwiqTA +EObkKvbdUyHsykPO +DoCkKvbdhzUfLqNf +EPCjjvbdiUzEvqtb +EPDKjvbdpfDeTuaI +EPCkKvbdSwjkmzjx +DncLKvbdjKFgjMwr +EOcLKvbdRWnECkhD +EOcKjvbdZoOJFEyj +DnbkKvbdvvlAvAvV +DncKjvbdZLqcsmlN +DncKjvbdyqOliJwA +EPCkKvbdKWUedEfi +DoCkKvbdePEsLTtS +DnbkKvbdtcDVXVoP +EPCjjvbdKCjCpicY +EObkKvbdZdwfzhJC +EPDLKvbdBhjajiGK +EOcKjvbdJXsahMRQ +DoCkKvbdZxdKNcLr +EPDKjvbdnBjWwoOV +DncLKvbdapGgDkzd +EPDKjvbdjmCLzEgP +EPCkKvbdWRmwbFMD +DnbjjvbdBdQAujMf +EObkKvbdzjUpPcsU +DoDLKvbdwtmFQyMO +DoCkKvbdiMEcmtby +DncKjvbdSBcdkiYk +EPCkKvbdfSBWzkbo +EOcLKvbdxVMeRZLn +DnbjjvbdCSaDUGXS +DncKjvbdZtJIyETO +EPCkKvbdTkvOaVni +DnbkKvbdkySqsYft +EPCjjvbdxsOJMrCH +EPCjjvbdCWzdJEov +EPCjjvbdEARiMywX +EObkKvbdxsNiNSCH +DncLKvbdhbPDFWqR +EObkKvbdVUNUFlVj +EObjjvbdXrlBNToY +EOcLKvbdfHjvSOQg +EPCjjvbdwWkaWAuu +DncKjvbdbKlFnnDA +EPCkKvbdRkZFuGkT +EPCjjvbdMowpvNfs +DncLKvbdmtuZjjSG +DnbkKvbdiCPDEvqR +DncLKvbdbAudfPow +DnbjjvbdFjeSbhMu +DncKjvbdSQTfjGEX +EPDKjvbdbAueGQQX +DnbkKvbdjKGIJmXr +EOcKjvbdIryBTNYM +EPDLKvbdmgEwlnGy +EObjjvbdSBdEkhxk +DoCjjvbdfMfWgMjL +EPDLKvbdEObjjwCd +EObjjvbdhzUekqOG +EObjjvbdWSNwbElD +DoDKjvbdrNZjYkhJ +DoCkKvbdRkYfUgKs +EObjjvbdczYpYZRC +DoCkKvbdzoQQeDMY +DncKjvbdFxuVBEXb +DoDKjvbdSiZjRABM +DoDLKvbdYzbfRivZ +EPDLKvbdlqyUyrdJ +EOcLKvbdtbbuWvOo +DncKjvbdSKxfVGkT +DoCjjvbdEXxLtUTl +EOcLKvbdEPCjkWbd +EPDLKvbdEObkLXDE +EPCkKvbdxKvdHzzG +EPDKjvbdpfDdtVaI +DoCjjvbdbAueGPpX +DoCjjvbdZMRdUOLm +DoDLKvbdwtmFRYkn +DoCjjvbdNPwpumgT +DoCkKvbddijSWUzn +DoDKjvbdJXsbHkqQ +DnbjjvbdxZhFexEr +DoCjjvbdSQUHJedX +EPDLKvbdjmCMZdgP +DncLKvbdMfbomPtk +EOcLKvbdqTtHRqjt +EPCkKvbdqceIpNvB +DncLKvbdFxtuBDxC +EPCkKvbdxVNEpyLn +EOcKjvbdYzbeqivZ +DoCjjvbdNdcsiJLE +DoDKjvbdzjVQQDsU +EObjjvbdvBDySneI +DoDKjvbdBhjbKhej +EPDLKvbdWSOYBdlD +EOcKjvbdOYOuzcnU +EPCkKvbdkCkkQgVH +DnbkKvbdtlXwBTaX +DnbkKvbdTppoVUgm +DoCjjvbdQmXaxnUz +DncKjvbdkHfkfFmk +EPCjjvbdmgEwlnHZ +EPDLKvbdZdxGzhJC +EPCkKvbdmIdTqUqa +DoDKjvbdzGyMAMeX +DnbkKvbdTppnuUhN +DoCjjvbdSLYfUgLT +DnbkKvbdZsiJZETO +EObkKvbdNUrqjmAX +EObjjvbdZyDimcLr +DoCkKvbdRDbaQRDr +DnbjjvbdbAudfPow +EPDKjvbdZjTHpGaf +DoDKjvbdqwQLcIxq +DnbjjvbdZLqdTmkm +DoDKjvbdyXiKCPzL +EObjjvbdssSTYyeD +DoCjjvbdddoRawCj +DoCjjvbdkMbLydfo +DoCjjvbdVTmUFkvK +DoCjjvbdhyuFkpmf +EObkKvbdlYsSSyGt +EPCjjvbdtvNxKQsA +DoDKjvbdRpTgKFdX +EObjjvbdjbkkQgVH +DnbjjvbdaNLCStlg +EOcKjvbdDxYLsssl +DoCjjvbdfNFvgMjL +DncLKvbdrovPJcWG +DnbkKvbddoFSjssr +DnbjjvbdSQTgKGDw +DoCjjvbdQvnEDLhD +EOcKjvbdUxhUZkOn +EPCjjvbdEzsqFMDJ +DoDKjvbdGdKuiaij +EOcKjvbdxrnJMrCH +DnbjjvbdUWMQJtBR +EObkKvbdEKHivYKA +EPDLKvbdYSlAltOx +DnbjjvbdbVCHXjtI +DnbkKvbdtkwwAtBX +DoCjjvbdZQleJNEq +EPDKjvbdEPCjjvcE +EPCjjvbdCSaDUFwS +EPDKjvbdHELViajK +DoDLKvbdijFgjNXr +DncLKvbdjmCLydfo +EObkKvbddZyQXxqC +DnbkKvbdySnImSCH +EPCjjvbdqmZjYkgi +EPCjjvbdGFirNiTq +DoDKjvbdRXNdDMID +DncLKvbdMfcQNQUk +EOcLKvbdZdwfzghb +EPDLKvbdULuoBWOi +EObjjvbdFyVUaDwb +DoCjjvbdNQXpumfs +DnbkKvbdrWolDIxq +EPCkKvbdBvzdIeQW +DnbkKvbdfIKuqmpg +EOcKjvbdnBiwXoNu +EObjjvbdiHKDZWKV +EPCjjvbdZLqdTnLm +DoCjjvbdlYsSTYgU +EPDLKvbdsBfNMHKy +DnbkKvbdjuvmdCXw +EPDLKvbdRDcBQQdS +EOcKjvbdySmhmRbH +EPDLKvbdbrbjscia +EPDLKvbdkxrrTZGt +DoDKjvbdcJMjLGWx +EPDKjvbdKeegbBQu +DnbjjvbdvPTzqKoU +EOcLKvbdIidAKPgE +DoDLKvbdVrOYBdkc +EObjjvbdeFOqawDK +EOcLKvbdZRNEhmFR +EObjjvbdKfFgbBRV +DoCjjvbdiLeEOVCy +EPCkKvbdqmZjYkgi +EPDKjvbdHffyxxXg +EPDKjvbdZLrDsmlN +DnbjjvbdTkuoBVoJ +EOcKjvbduDDUvvOo +DoDKjvbdZdwfzhJC +EPCkKvbdfMfWgNKL +EPCjjvbdRXOECkgc +EOcKjvbdMowpvNfs +DoDLKvbdiBoCeWpq +EObkKvbdNwoVzdOU +EPDLKvbdDoDKjvbd +EObjjvbdLFehCBRV +EOcLKvbduCcVWuno +EOcKjvbdXsMBMtOx +DnbkKvbdcIljKewY +DoDLKvbdEzspdkcJ +DncKjvbdqcdhomua +EPDKjvbdiifHjNXr +EObkKvbdVqnXbFLc +EPCkKvbddwyssrFz +DncKjvbdrSVKmkAm +EPCjjvbdTlVoBVni +EObjjvbdOhAYZAYa +EPCjjvbdRadEkiZL +DoCkKvbdSCEEkiYk +EObjjvbdGZVVAcxC +DnbjjvbdZyEJnDMS +EOcKjvbdzitoodSt +EPDKjvbdXFxzUAPT +DnbjjvbdziuQQESt +EPCjjvbdEARhmZvw +DncLKvbdatbHXkTh +DncKjvbdbsCjtDjB +EPCjjvbdKWVGDdgJ +EPDKjvbdrafNLfkZ +EObkKvbdFkEsChMu +DnbkKvbdVgxWXfxz +EObjjvbdJbjDRJbx +EObkKvbdwyhFfYFS +EPCjjvbdMfbpNPtk +EObkKvbdbsDKtDia +EPCkKvbdkxsRsZHU +DnbkKvbdvAdZTOdh +DncKjvbdptUHRrLU +DncKjvbdvPTzqKnt +DncLKvbdTppoUthN +DnbkKvbdrbFlkgLZ +EPCjjvbdGdKvJajK +EPDLKvbdACqxKZiQ +DoCkKvbdbPffckzd +DoCkKvbdhbOcEvqR +DnbjjvbduCcVWvOo +DoCkKvbdmuUzLKRf +EPCjjvbdbUbHYLUI +DoDKjvbdbKkeoNcA +DoCjjvbdcScKtEJa +DoCjjvbdyzdnRgiI +EPCjjvbdkIGlFfOL +EOcLKvbdzjUpPcsU +DoDLKvbdJuuGEEgJ +DncLKvbdTqROtthN +EOcLKvbdpstGqqkU +EPCkKvbdtSrTYzEc +EPDKjvbdezvYdiUX +DoDKjvbdtTRrxzFD +DoCjjvbdrovOjDWG +DoDKjvbdUQpoUthN +EOcKjvbdKDJbpicY +DnbjjvbdaSGCgtFk +DoDKjvbdGZVVAcwb +DnbjjvbdEvYopNJe +EObjjvbdSQTgKFdX +EPDLKvbdrXPkbhyR +DoDLKvbdhyuGMROG +DoDKjvbdzoQRFClY +EPCkKvbdKWUeceHJ +EObkKvbdZnmiFFZj +DnbjjvbdtcDUwVoP +DoCkKvbdjlakyeHP +EPCkKvbdBvzdIdpW +EPCjjvbddePRawCj +DoDKjvbdmfeYNNfy +DnbkKvbdSLYetgKs +DncKjvbdFejRnJTq +EPDLKvbdIGfzZXwg +DncKjvbdJvVFdFHJ +EOcLKvbdIHHZyYYH +EPDLKvbdyXhiaoyk +DoCjjvbdADSYJzIp +EObjjvbdNPxQunHT +EPCkKvbdxnTHwrhc +DncKjvbdTppnuVHm +EObkKvbdjlbLydfo +DoDLKvbdVBBpsRRy +DnbjjvbdACqwiyhp +DoCkKvbdZRNFJNEq +EOcLKvbdaRfDHtFk +DoCkKvbdKfFgbBQu +DnbjjvbddCTNSAUN +EPDLKvbdTfznMXVe +EOcKjvbdeOeSkUTr +DnbkKvbdqdEiPnVa +EOcLKvbdsBemMHLZ +DoCkKvbdNPxQvOGs +EPDLKvbdOTTufeUp +DncKjvbdraelkfjy +DoDLKvbdZoOIeFZj +DnbkKvbdptTgRrLU +DncKjvbdACrXiyhp +EPDLKvbdIGgZxwxH +DnbjjvbdZnmiEeZj +DnbkKvbdWRmxCFLc +DoDLKvbdyYIiaozL +EPCjjvbdOTTvGeUp +EPCkKvbdNUsSKmAX +EPCjjvbdDigiuwjA +DoDKjvbdIrxaTMxM +DoDKjvbdZyDimcLr +EPCjjvbdjbkkRHVH +DoCjjvbdWXJYVceH +EOcLKvbdlZTSSyHU +DncLKvbdwuNEqYlO +EPCkKvbdrpWPJbuf +DncKjvbdtbcUwWPP +EOcKjvbdGKeScINV +DncKjvbdZeXfzhJC +DncKjvbdUQqPVVIN +DoDKjvbdxsNhmSBg +DoDKjvbdURROuVHm +DncKjvbdRMwbYmtz +DoDKjvbdZRMeImEq +EOcLKvbdWHwvXgYz +EPDLKvbdIwsahMQp +EOcKjvbdfHkVrNqH +EObjjvbddjKSWUzn +DncKjvbdxwiJbQZk +EPCkKvbdMSWlzVQz +DoDLKvbdUQpnuUhN +DncLKvbdiCPCdvqR +DoCjjvbdapHHELzd +DncKjvbdyOSgwrhc +DoCkKvbdDxYLtUTl +EObjjvbdyfyMAMdw +EObjjvbdHffzYxYH +DoDKjvbdYzcFrKWZ +EPDLKvbddZyPwyRC +EPCkKvbdLhalRYAS +DoCkKvbdGYtuBEXb +DoCjjvbdrylQTAgn +DoCjjvbdbBVeGPpX +EPDLKvbdYpmFImFR +DnbkKvbdJcKCpjDY +DncLKvbdYTLaNUPY +DnbkKvbdeOeSjtTr +DoCkKvbdEYYLtTtM +EPCkKvbdrzLoraIO +DoCjjvbdKWVGDdfi +DoDKjvbdBhjbLIfK +EPCkKvbdNQYQvOGs +EOcLKvbduLxXBTaX +EPDKjvbdANHySwZx +DnbkKvbdeOdsLTtS +DnbkKvbdUsmTfMWK +DoDLKvbdcImJkGXY +DncKjvbdsPunibuf +DnbjjvbdIGfyxxYH +DoDLKvbdvBDyTOeI +EPDLKvbdGKeScHmV +EOcLKvbdqFceUVaI +DncLKvbdqdEhpOWB +DoDLKvbdTulPitAq +DnbjjvbdWXIwudEg +EPDLKvbdcTDKtDjB +DoCjjvbdgFlZnHHA +DnbkKvbdwuNEqZLn +EObkKvbdmRxtzSci +EObjjvbdjvXNdCYX +DnbkKvbdqGDdsvBI +DncKjvbdqdEhomvB +DoCjjvbdrpVoKCvG +EObkKvbdWHwvYHYz +EOcKjvbdrykoraHn +EPCkKvbdsPuoKCuf +DncKjvbdZjSgofaf +DncKjvbdNeETiIjd +DoDLKvbddoFSkTsr +EPCkKvbdkWWnECXw +DnbkKvbdZRNFIldq +EObjjvbdzjVQPdTU +DnbjjvbdhytelRNf +EOcKjvbdNPxQunHT +DoCkKvbdmuVZkJrG +EPCjjvbdUVlQJtBR +DoDKjvbdzitpQESt +DoCjjvbdraemLfkZ +DoDLKvbdkNBlZeHP +EObkKvbdrbGNMHLZ +EPDLKvbdkIHLeemk +DoDKjvbdbAvEeopX +DoDKjvbdiGjCxujV +EPCkKvbdqlzJxkgi +DncLKvbdVZITzLPO +EOcLKvbdVZITykOn +EPCjjvbdjuvnDaww +DoDKjvbdkVwOECYX +EObjjvbdcyxpXyRC +DnbjjvbdULvPAuni +DnbkKvbdOTUWGdtp +EOcLKvbdKDJcRKCx +EPCkKvbdBsBDUFwS +DncLKvbdQdDAopcr +EObjjvbdcSbjtEKB +DnbjjvbdlAloNALA +DoCjjvbdADSXizJQ +EOcKjvbdrpWOibvG +EObjjvbdIGfzZXwg +EPDKjvbdptUHRrKt +DncLKvbdZdwfzhIb +DoCkKvbdQZNAGrrK +DoDKjvbduCbtvuoP +EPCjjvbdJuuFceGi +EPCkKvbdgGLymgHA +DnbjjvbdcyyPxYpb +EPCkKvbdhuZeWquC +EObkKvbdyTNiNRbH +DoCjjvbdVAaqSprZ +DncLKvbdoznDkYPA +EPCkKvbdiUydvquC +DncLKvbdhytfMROG +DoCkKvbdmbKXYPNu +DnbkKvbdMpYQunHT +EOcLKvbdHkaznXQk +DoDLKvbdTvMPisaR +DoCkKvbdIryBTNXl +DoDLKvbdZLrDsmkm +DncLKvbdlhctRVRa +EPCjjvbdYkqcsmkm +EPCjjvbdEXwlUTtM +EObkKvbdEvZPoljF +EPDLKvbdZRNEiNFR +DoCkKvbdANIZTXZx +DncKjvbdZoOIeFZj +DoDLKvbdeJirWUzn +DoCjjvbdRWmdDLgc +DoDKjvbdACrYKZhp +EPDKjvbdMowpunHT +EOcKjvbdYTLaNTnx +DnbjjvbdQvnEClHc +DnbkKvbdSBceLhyL +DoDKjvbdjgflGGOL +EOcKjvbdYpldiMdq +DoCjjvbdrovPKDWG +DoDKjvbdZisHofbG +DoDKjvbdEOcLKwDE +EPCjjvbdhfjDZWJu +DncKjvbdhfjCyWJu +EOcLKvbdtSqsYzEc +DoDLKvbdbQHHELzd +DoDKjvbdySnImRbH +EOcLKvbdVqmxCElD +DnbjjvbdNdcsiJKd +EPCkKvbdkNBkzEfo +DnbkKvbdJKEAKPfd +DncLKvbdiifIJlwr +DnbjjvbdhtzEvqtb +EObjjvbdwWlAvBWV +EPDLKvbdlhctQuSB +EOcLKvbdNddUIiKd +EPDKjvbdJSxaTMxM +EPDLKvbdVrOXaeMD +DoDLKvbdGcjvKBjK +DncLKvbdqvpLbiZR +EPCkKvbdjKFgilxS +DncLKvbdDoCjjvbd +DoCjjvbdqqtjnKaN +EOcKjvbdBvzdJEpW +DoCkKvbdcarlrATm +DoDLKvbdQdCaQQdS +DncKjvbdVqnXadkc +DoCjjvbdJvUecdgJ +DnbkKvbdVYhUZkPO +EPDKjvbdxZgfFxEr +EPCjjvbdsPunicWG +DnbkKvbdmSYtyrdJ +DnbjjvbdTulQJsaR +DncKjvbdsrrSxyeD +DnbkKvbdzQnmJJwA +DncKjvbdatafxLTh +EOcLKvbdmfeYNNgZ +EObkKvbdNxOuzcnU +EPDLKvbdDwwksstM +EPDLKvbdxnTIYTIc +EPDKjvbdHgGyyXxH +EOcKjvbdGAnpyJzm +DoCkKvbdUQqPVUhN +DncLKvbdYgWdAOri +DoDLKvbdygZMANFX +EPCkKvbdrJAJdlne +EPDLKvbdZnmheEyj +DnbjjvbdIxUCHkpp +DnbkKvbdjJehJlwr +DoDKjvbdhlEdNuDZ +EOcKjvbdeOeSkTsr +EOcLKvbdVqnYBdlD +DoDKjvbdeATqMwif +EPCjjvbdrXQLbhyR +DnbjjvbdFkErbhMu +DoCjjvbdpxnhHQcx +EOcLKvbdrWpMDIxq +EPDKjvbdVhYWYGxz +DoCkKvbdwzIGFxFS +DoCjjvbdEztQeLbi +DnbjjvbdlZTRrxgU +DncLKvbdSZihSbvA +DnbjjvbdrzLpTAgn +EPCjjvbdNrsugFVQ +DnbjjvbdxUleQxlO +DncKjvbdtkwwBUAw +DoCjjvbdbBVdeoow +EPDKjvbdEObjkXDE +DnbjjvbdhgJbxvKV +EPCkKvbdIwtCHlQp +DoCkKvbdxmsIXrhc +EObkKvbddePSCXDK +EOcKjvbdVrOXbEkc +EOcLKvbdFVyPomJe +DoDLKvbdREDBPqDr +DncLKvbdaNLCStmH +DncLKvbdbAudfQPw +DoDKjvbdRaceLiZL +DoCkKvbdJYUCIMRQ +DnbkKvbdYkrDtOMN +DnbjjvbdFkFTChNV +EOcLKvbdZRMeImFR +EObkKvbdUxgszLOn +EOcKjvbdFjdsChMu +EObkKvbdrafNLgLZ +EPDKjvbdelewGmJk +EOcKjvbdZMRctNlN +DoDLKvbdliEUQtqa +DncKjvbdqUUHSRjt +EPDKjvbduCbtwVno +DoCkKvbdaaVeFoow +EPDLKvbdkClKqGuH +DoDLKvbdCflFgAzc +DoDLKvbdTAEhgbPE +EObkKvbdmtuZjjRf +EObjjvbdKDKCqJbx +DncKjvbdrovOjDVf +DoCkKvbdhtzFWqtb +DncLKvbdEvYpQNKF +EOcLKvbdeFPRavcK +DoDLKvbdhlEcnUby +DoCkKvbdegjvSOQg +DncKjvbdhbPCeWpq +DnbjjvbdsrrTYyeD +DncLKvbdTlWPAvOi +EPCjjvbdwzHeexEr +DncLKvbdmJEUQuRa +DnbkKvbdkIHLeemk +EObkKvbdhtyeXSUb +EOcLKvbdHDkWKCJj +EOcLKvbdRbDdkhyL +EObkKvbdRosfifDw +EPCjjvbdOStVfduQ +DnbkKvbdiHJbxujV +DoCjjvbdsPuoJcWG +EPCkKvbdDxXktTtM +DoCjjvbdHDjujCJj +EObjjvbdUWLoisaR +EPDKjvbdqiAKEmOe +DoDLKvbdxmsIYShc +EPCkKvbdCJKbKiGK +DoDLKvbdRECaQRDr +EPDLKvbdYqNEiNEq +DnbkKvbdiMEcnVCy +DoCkKvbduCbtwVno +DoDKjvbdHbMZdzAD +DnbkKvbdemGXGmKL +DoDLKvbdgQBzwDwh +DoDKjvbdKQzEoGOF +DoDKjvbdWSNwaeMD +EPDKjvbdySmhlqbH +EObkKvbdDxYLtTtM +DnbjjvbdFxuVBEXb +EObjjvbdiBoCdwRR +EPCjjvbdGQATWgGZ +EPCkKvbdYpleJNEq +EOcLKvbdvPTzqKoU +DnbkKvbdZQmEhldq +DncKjvbdLBKgMawq +EPCkKvbdqFceTvAh +EPCjjvbdkIHMFenL +DoDKjvbdehLVqnRH +DoDKjvbdxwhibPyk +DnbkKvbdkMbMZeHP +EOcKjvbdsrrSyZeD +EOcLKvbdMowpunHT +EObjjvbdJqZdnfOF +DoCkKvbdezuxdhtX +DnbjjvbdaaWFFopX +DoCjjvbdqdFJQOVa +EPCjjvbdWWhwudFH +EPDKjvbdhtzFWrUb +EPCkKvbdWSNwaeMD +EObkKvbdcIlikFvx +EPCkKvbdauCGwkTh +EPCkKvbdbhmJkGWx +EPDKjvbdRosgJfEX +DnbkKvbdTvMQJtAq +DnbkKvbdsBfMlGkZ +DnbkKvbdVrNxCElD +DoDLKvbdmpZxukZC +EObkKvbdhlEcnVCy +EOcLKvbdwzIFfYFS +DnbkKvbdZtIhxdSn +DoDLKvbdjgfkfFmk +DoDLKvbdqTtHSRkU +EObjjvbdSCDeLiZL +DoDKjvbdeATplxJf +DnbkKvbdIBkzEzAD +EOcKjvbdFWZQPljF +DoCjjvbdRbDeMJYk +EPDLKvbdDoCkKvcE +DoCkKvbdZjShPfbG +DnbjjvbdNPxQvOGs +EPDLKvbdKyQirztf +DoDLKvbdJutecdfi +DoCjjvbdTppoUuHm +EPDLKvbdjEkGuPAO +DnbkKvbdVTmTekuj +DnbkKvbdZyEJmcMS +EOcKjvbdNddThhjd +DncLKvbdrDdhpNua +EOcKjvbdBiLBkJGK +DoCkKvbdrXPkbhxq +DnbjjvbdZQmEiMdq +DncLKvbdhzUfMROG +EPDKjvbduaEYroEh +DoCjjvbdJYUCHkqQ +DoCjjvbdwzHfFxEr +EPCjjvbdLiBkqYAS +DoDLKvbdxZgfFxEr +DoCkKvbdraemLgLZ +DoDLKvbdxxJJaozL +EPDLKvbdKeehBaRV +DoCkKvbdPIAYZAZB +EObjjvbdBvzdIdov +DoDKjvbdjblKqGuH +DoDKjvbdlhdURVSB +EPDKjvbdqvpMDJZR +DncKjvbdajkeoODA +EOcKjvbdkySqsZHU +DnbjjvbdJqZdnfOF +DncKjvbdZHWdAOsJ +DoCkKvbdaNLCStlg +DoDLKvbdVZHszKnn +DoCjjvbdtvOYJpsA +DoCjjvbdNPxQvNfs +DoDLKvbdZLqctOMN +EObjjvbdvwMAvAvV +DnbkKvbdEuxpPlie +DnbkKvbdAMhYsWyx +DoCkKvbdtumwjQsA +EPCjjvbdVAaprqRy +EObkKvbdlZSqsYgU +EObkKvbdBvzdIdov +DnbjjvbdyOShYTJD +EOcLKvbdZshhxdSn +EPDKjvbdUtMselWK +DoDLKvbdYqNEiMeR +DncLKvbddePSBwDK +DncLKvbdqYnggQcx +DnbkKvbdqceJQOVa +DoDLKvbdtSrTZZeD +EPCjjvbdANHyTWzY +DoDLKvbdcIlikFvx +DoDKjvbdxmsHwsIc +EObkKvbdYzbfRiuy +EPDKjvbdWHwuwfxz +EOcLKvbddndsLTsr +EObkKvbdwXMAuaVu +EPDLKvbdbVBfwjtI +EObjjvbdfMfXHMik +DoCkKvbdOXoVzdOU +DnbkKvbdnGeXlnHZ +EPCjjvbdGGJrOJTq +EPCkKvbdhanbeWqR +EOcLKvbdLhbLpxAS +EPDLKvbdbBVdepPw +EOcKjvbdWSNwadlD +DoCkKvbdaRfChTek +EPCkKvbdmbJvxOmu +DoCkKvbdCSaCsfXS +EObkKvbdbhljKewY +DncLKvbddZxowxpb +DnbjjvbdRDcBQQdS +DnbjjvbdKDJbqKDY +EObkKvbdWRmxCFLc +EPDLKvbdYlSETmkm +EOcLKvbdMIalRYAS +DoDKjvbdCEQAuimG +EPDKjvbdCTAcTewS +EPCjjvbdrRtkOKaN +DnbkKvbdtTRryZeD +DnbjjvbdMgColpVL +EOcKjvbdrDdhomua +EPDKjvbdRbDeMJZL +DnbkKvbdxnSgwrhc +DoDKjvbdVvhxVdFH +DncKjvbdLYqJrzuG +DncLKvbdZsiIyETO +EPDLKvbdieLHUoAO +EPDLKvbdNsUVgEuQ +EPDLKvbdoAKztHcn +DncKjvbdfNFvgNJk +DoCkKvbdqYoHgQcx +DncLKvbddwzUUSFz +DoCkKvbdIHGzZYXg +DncLKvbddZxpXxpb +DnbjjvbdhlFDnUcZ +EPCjjvbdSKxfUfjs +DoCkKvbdbAvFGPpX +EOcLKvbdVhXuwfxz +EPCkKvbddoEsKtTr +DncKjvbdhkeEOVDZ +EObjjvbdNUrqjmAX +EPDLKvbdUWLojTaR +DoDLKvbdWIYVwfxz +DnbkKvbdUtMsekvK +EOcKjvbdRpUHJecw +DoDKjvbdCJKbKiFj +EObjjvbdEuxoomJe +EPCjjvbdLrWlytpz +EObjjvbdMgDPlotk +DncLKvbdNrtWHFVQ +DoCjjvbdZeYGzgiC +EPCkKvbdKaKfmCYR +DoCjjvbdjlakzEfo +EPDKjvbdpeceTvBI +DnbkKvbdKDKCqJcY +DoDKjvbdMowqWNgT +EPDKjvbdRMxCYmtz +EObjjvbdrXQLbiYq +DncLKvbdZnmheFZj +EOcLKvbdiLeENtcZ +DncKjvbdzaAPGfal +EPCkKvbdeATqNYKG +EObjjvbdSCDdlIyL +DoCkKvbdVZHtZjnn +EPCjjvbdZtIhxdTO +EPDKjvbdTlVoAuoJ +EObjjvbdZRNFIleR +DoDLKvbdEPDLKwCd +DnbjjvbdfRaWzkbo +EPDLKvbddneSjstS +EObkKvbduCbtwWOo +EPCkKvbdmoyyWKyC +EPCjjvbdehLVrORH +DoDLKvbduCcUvuno +EObkKvbddZxowxqC +EObkKvbdKQydoFme +EPCkKvbdqqtkOKaN +DoDKjvbduaEYsOeI +EObkKvbdePEsLUTr +DoDLKvbdbsDLTcia +DncLKvbdDwwlTtUM +EOcKjvbdOEdUIhkE +DoDLKvbdtvOXjRTA +EObkKvbdeFPSCXCj +EPCkKvbdqlzJxlIJ +EOcKjvbdUMVoBVni +EPCkKvbdqqtkNkBN +DoDLKvbdiVZeWquC +DncKjvbdZLrDsmlN +EPCkKvbdzitopESt +EOcKjvbdnBjXYPOV +EObkKvbdehKurOQg +DoCjjvbdmJDsptrB +DnbkKvbdaNKbTVNH +DncLKvbdGQASvfey +EOcLKvbdtbcUwVno +EOcKjvbdqUUHSSLU +EOcLKvbdvwLaWBWV +EPCkKvbdRacdlIxk +DnbkKvbdxZgfGXeS +EOcLKvbdVAapsQqy +EOcLKvbdQvnECkhD +EPDKjvbdCWzchdpW +DoCjjvbdpedFUWBI +EPDKjvbdqvpMCiYq +EPDLKvbdEPDKjwCd +DncLKvbdGckWJaij +EObjjvbdgPazwEXh +DoCkKvbdUVlPitBR +DoCjjvbdMSXMzVQz +DnbkKvbdliEUQuRa +DoCkKvbdOStVgFUp +EPCjjvbdUtMtGMVj +DoCkKvbdKWVFdFHJ +EPCkKvbdUxhUZkOn +DnbkKvbdLBKflbYR +EPCkKvbdFkEsCglu +DnbkKvbdKCibpjCx +DnbkKvbdGLEsChNV +DoCjjvbdLGFhCApu +DncLKvbdeXzTsqez +DoCkKvbdxrmhlqbH +EPDLKvbdYlRdTmlN +EPCjjvbdqYnhHRDx +EPDKjvbdWfYzUAOs +EPCkKvbdMJCLpxAS +EObkKvbduCbtwVoP +DoCkKvbdmfdwlmfy +EPCjjvbdVBBprpqy +DoDLKvbdEKHivXjA +DoDLKvbdkWWnECYX +EOcKjvbdqUUHSRkU +DncKjvbdYlRcsnLm +EOcKjvbdelfWfmJk +EPDLKvbdZtIhxcsO +EOcLKvbdGKdrcINV +EPDLKvbdOAIsUKSA +DoCjjvbdXFxytAOs +EPCjjvbdUQpntuIN +EPDLKvbdTvLpJtBR +EPDKjvbdRyihSbvA +DnbjjvbdhyuFlROG +EObkKvbdZxcinClS +EOcKjvbdptTfqrKt +DoDLKvbdURRPUtgm +EObkKvbdaNKbTVNH +EOcLKvbdiZuFlQmf +EPDKjvbdePEsLUTr +EPCjjvbdFxuUaEYC +EPDLKvbdliETpuRa +EObjjvbdjKFhKNYS +DoCkKvbdwzHefXeS +DoDLKvbdFfJqmiUR +EObjjvbdcJMjKewY +EObjjvbdqdFIomua +DnbkKvbdFejRnJTq +DnbjjvbdEzsqFMCi +EPDLKvbdhzUelROG +EPDKjvbdLKaIWAKZ +DoCkKvbdGGJrOIsq +EOcKjvbdVUMtGMWK +EObkKvbdmpZyVkZC +DoDLKvbdJTYaSmXl +EObjjvbdmSZUyrci +EObkKvbdxnSgwsIc +EOcLKvbdhgJcYujV +DoDKjvbdUQpoVVHm +EPDKjvbdKWVFdEgJ +DoCkKvbdWXJXudEg +EObkKvbddxZtURez +DnbkKvbdZRMeJNEq +EOcKjvbdpxoIHRDx +EObkKvbdGGKSOJTq +EOcKjvbdkIHMFenL +EPDLKvbdTqQoUtgm +DnbjjvbdtvNxJpsA +DnbkKvbdFyUtaDxC +DnbkKvbdSLYeuHKs +DncLKvbdxrmhlrBg +DncLKvbdGdLWJajK +EPCkKvbdSPtHJfEX +EPCkKvbdeKJrVtzn +DoCjjvbdWRnXadlD +DncKjvbdhkdcmtby +DoDLKvbdVviYWEFH +EOcKjvbdTAFJICPE +EPCjjvbdCJKbLIej +DoDLKvbdyYJJaoyk +EPDKjvbdNsUVgFUp +EPCjjvbdrDdhomua +DoDKjvbdySnJNRag +EPCjjvbdyNrgxShc +DnbjjvbdADRxKZhp +DnbkKvbdaMkCStmH +EPDKjvbdfIKvRnRH +DnbkKvbdoAKztIEO +DnbjjvbdDjHjVwjA +EObkKvbdjuwODbYX +DoDLKvbdbhmKKfWx +EPDLKvbdKaLGlaxR +DoDLKvbdwzIGFxFS +EPCkKvbdGBOpxizm +EPDKjvbdRXODcMHc +EOcLKvbdYqNFJMdq +EOcKjvbdxUleQxkn +EPDKjvbdZirgpHCG +DncLKvbderAvzkbo +EPCkKvbdTvMPisaR +EPCkKvbdZtJIxdTO +EOcKjvbddePRavcK +DncLKvbdCDpAuimG +EPDLKvbdQdCaPqES +EObjjvbdZyEJmbkr +DoDLKvbdOEcsiIkE +EOcKjvbdrbFlkgLZ +EOcKjvbdRacdlJZL +EPCkKvbdKDKCqKCx +EPDKjvbdrDeIonVa +DncKjvbdOFEThhjd +DncLKvbdLAkHMbXq +EObkKvbdhytekpnG +DncLKvbdrSUkOLAm +DncLKvbdiCOcFWpq +DoCjjvbdrylPsAhO +EOcKjvbdxVNEpyLn +DnbkKvbdmbJvwnnV +DnbkKvbdVAbQsQrZ +EPCkKvbdCTBCtGXS +DncKjvbdTAEiHbPE +EObjjvbdFeiqnJTq +EPDLKvbdDxYMTtTl +DncLKvbdHDkVibKK +DnbkKvbddePSBvcK +DoCjjvbdauCGwkTh +EPDLKvbdWIYWYGxz +DoDLKvbdjcLjqHVH +DoDLKvbdTfznMXWF +DnbkKvbdkVwNcaww +EObjjvbdlYrrSxgU +DncKjvbdaNLCTUmH +EOcKjvbdznoqEblY +DncLKvbdjuwOEBww +DncKjvbdGQATXHGZ +EOcKjvbdiZuFkpmf +EPCjjvbdajlGOnDA +EPDKjvbdJcJbpjCx +DncKjvbdauBgXjtI +EPCkKvbdsZkpTAhO +EPCkKvbdOEdUIhjd +EOcKjvbdNsUWGduQ +DnbkKvbdVTltFlVj +EObjjvbdaNKasVNH +DnbjjvbdhancEvpq +EPDLKvbdZtIiZETO +DoDKjvbdFxuUaEYC +DoDLKvbdLGGHbAqV +DoDKjvbdqceIpOWB +DoDKjvbdvBEZTPEh +DoDKjvbdKefHbBQu +EPDLKvbdlZTSSyHU +DncKjvbdnPyyWKyC +EObjjvbdsZkpTBHn +DoCjjvbdaaVdepPw +EPDKjvbdtkwvaUAw +EObjjvbdEPCkKvbd +EPCjjvbdtkwvaUBX +DncKjvbdRbDeMIyL +EOcKjvbdxwhjBoyk +DoDLKvbdFxuVAcxC +DnbkKvbdxZgfFxFS +EOcKjvbdjhGkefNk +EOcKjvbdEPDKkWcE +EPDLKvbdQvnEDMID +EOcLKvbdqquKmjaN +DoCkKvbdZtJJZESn +EPDLKvbdTkvOaWPJ +DnbjjvbdcSbkUEJa +EObjjvbdQlxBxmtz +EOcLKvbdehKuqmpg +EObjjvbdpyOggQcx +DncLKvbdnVVZjjSG +EPCjjvbdyqOmIiwA +EPDLKvbddZxpXyRC +EObkKvbdRXODcMID +EOcKjvbdnHFXlmfy +EPDKjvbdznpQdcLx +EOcLKvbdqGDdtWBI +EPCjjvbdZoNhddzK +EOcKjvbdqTsgSSLU +EOcLKvbdRzJhTCvA +EOcKjvbdCIjbLIfK +DncKjvbdKQzEoGNe +EOcKjvbdACrXizJQ +EObjjvbdEzspdkcJ +EObkKvbdsZlQTAhO +EPDKjvbdfoazwEYI +DoDLKvbdjAQGaQGj +DoDLKvbdEzsqFMCi +EPDKjvbdyYJJapZk +DnbkKvbdIxUBglRQ +DoCjjvbdtTRsYyeD +EPDKjvbdGKdsDIMu +EOcLKvbdFyVVAcxC +DnbkKvbdZLrDtNkm +EPDLKvbdsrqrxydc +EPDKjvbdrpVnjCvG +DoDLKvbdmSYtzTEJ +EPDKjvbdajkfOmcA +EPDLKvbdssSSxzEc +EObjjvbdDxYMTssl +DnbkKvbdiMFEOVDZ +EOcLKvbdULvOaVni +EPDLKvbdlqyUzSdJ +EObjjvbdZoNheFZj +DncKjvbdcScLTdKB +EObkKvbdGLFTDINV +DncKjvbdcyyQYZRC +EOcKjvbdYqMeIldq +DoCkKvbdOEcshhkE +EObkKvbdirzhrjiz +EOcLKvbdxUmFRYlO +DoDKjvbdkyTRsZGt +DncKjvbdIryAsNYM +EObkKvbduWNxJpsA +DncKjvbdYkqcsnLm +DoDLKvbddZxpXyQb +DncKjvbdRotGiedX +DnbkKvbdKVtedEgJ +EOcKjvbdjvWnEBww +EObkKvbdFyVVAdXb +DoCkKvbdYlSEUNkm +EOcKjvbdcTDLTcia +EPCkKvbdzjUpQESt +DnbkKvbdqUTfqrLU +EPDKjvbdSQUHJfEX +DnbjjvbdiGjDYvKV +EObkKvbdhkdcnVCy +EPCjjvbdJuuFdFHJ +EObjjvbdYkqdTnMN +DoCkKvbdpssgSRkU +EObkKvbdUWLpKUBR +DoDKjvbdZsiJZESn +DnbkKvbdYqMdhmEq +DoCkKvbdjcLkRHVH +DnbkKvbdSPsgKGDw +DoDLKvbdKVtfEEfi +EPCjjvbdiGibyWKV +EPCjjvbdEYYLtUTl +EPCjjvbdFejSOIsq +DncLKvbdRECaQRES +EPCkKvbdEuyQQNKF +EObkKvbdxwhjCPzL +DncLKvbdiLeDnUby +EOcKjvbdEuxpQMie +EOcKjvbdIidAJogE +DoDKjvbdxsNhlqag +EOcKjvbdEzsqFLcJ +EObjjvbdYTMAmToY +DoDLKvbdwuNFQyLn +DoCkKvbdzitpQDrt +EOcLKvbdZtJIxdSn +DncLKvbdqZPHgRDx +EPDLKvbdMoxQvNfs +DncKjvbdmIctQuSB +DoCkKvbdFfKSNiUR +EPDLKvbdhtydvqtb +EObjjvbdxrnJNRag +DnbjjvbddoFTKssr +EPDKjvbdqlyjZLgi +DnbkKvbdyNsHwsJD +EOcLKvbdxnTHwsJD +EObjjvbdUQqOtuIN +DnbkKvbdwtleQyMO +DoDLKvbdrovPKDVf +EOcLKvbdFaPQxizm +EObjjvbdVAapsQqy +EOcKjvbdJvVFdFGi +DnbkKvbduDDVXVno +EObkKvbdZjTHpGbG +EObjjvbdZirgofaf +DncKjvbdAMgySvzY +DoDKjvbdGdLVibKK +DoDKjvbdWRmwbEkc +DncKjvbdXsMAlsnx +DoDLKvbdtcCuXVoP +DoDLKvbdqlyjYlIJ +EPCjjvbdHELVjCKK +DncLKvbdBdQAuilf +DoCjjvbdeFOrCXDK +DoCjjvbdRpTgJfDw +DoCkKvbdLAkHMbXq +EOcLKvbdaRebhUGL +DncLKvbdnQZyWLYb +EObjjvbdXsMBNUOx +DncKjvbdrSVKnKaN +EPCjjvbdAMhZSwZx +EOcLKvbdcScKtEKB +DncKjvbdKaLGlaxR +EOcKjvbdZRMeJNFR +EPCkKvbdwygeewdr +DnbkKvbdhancFXRR +EOcKjvbdOTUVfdtp +EPDLKvbdmbKXYOnV +DoDKjvbdGLFSbhNV +EPDLKvbdMfbomPtk +DnbkKvbdmIcsqVRa +DoDKjvbdwtmFRZLn +DoCkKvbddtAUATMv +DncKjvbdiBoDEvqR +EObkKvbdiHJcYujV +DnbjjvbdiCPDFWqR +EOcKjvbdyTNhlrCH +DoDKjvbdNQYRVmfs +EOcLKvbdFjdrbhMu +DoCjjvbdsrrSyZeD +EPCkKvbdXsMBMsoY +DoDKjvbdjhHLfFmk +EPCkKvbdyOTIYTIc +EOcLKvbdbhmKLGWx +DnbjjvbdxnTHwsIc +EOcLKvbdZoOJEeZj +EOcKjvbdjmBkzEfo +EPDKjvbdYORAXuWU +EPDKjvbdtkxXAsaX +DoDLKvbduaEYsPFI +EPCjjvbdypoNIiwA +DoDKjvbdVBCRTQrZ +DnbjjvbdlrYtyrdJ +DoCjjvbdhzUekpnG +EOcKjvbdcTCjsdJa +EObkKvbdbhlijfWx +EOcLKvbdYTLaMsoY +DnbjjvbdKVtedFGi +EOcLKvbdsPvPJbuf +DncLKvbdNrsvHEuQ +EObkKvbdmfeYMmfy +EPCjjvbdZjTHpHCG +DoDLKvbdpyOhGqDx +DoDKjvbdRkZGVGjs +DnbjjvbdRWnEDMHc +EPCkKvbdjlbMZdfo +DoCkKvbdyqOmIiwA +DoCkKvbddxZstSFz +DnbjjvbdKCibqJbx +DoCjjvbdqqtjnLBN +DnbjjvbdBhjbLJGK +DoDLKvbdrWokbhxq +EOcLKvbdJzpGXdAN +EPDKjvbdRMxCZNtz +DncKjvbdkClLRGuH +DncLKvbdIHHZxxXg +EPDKjvbdZshiYdSn +EPCkKvbdqcdhomvB +DoDKjvbdVTmUFkvK +EObkKvbdZisHogBf +DoCjjvbdRbDdkiYk +DnbkKvbdGGJrOJTq +DncLKvbdeFPRavcK +DnbjjvbdSPtHKGDw +DoDLKvbdJmADyfuB +EPCjjvbdKCibpicY +DoDLKvbdiGicZVjV +DoCkKvbdZLqdUNkm +EPDKjvbdVUNUFkvK +EPCjjvbdemFvflik +EPCkKvbdkxrqrxft +DnbkKvbdRbEElIxk +EPCjjvbdaaVdfQQX +DoDLKvbdySmhlqag +EPCjjvbdrRuKnKaN +DncLKvbdezuyEhtX +DnbkKvbdtbbuWuoP +DnbkKvbdZtIhxcrn +EObkKvbdcyxoxZQb +EOcKjvbdDxYLtTtM +EObjjvbdjggMFfOL +EPCkKvbdGckWJbKK +DnbjjvbdddnqavcK +EPDKjvbdYgWdAPTJ +DnbjjvbdbhlikGXY +DncKjvbdNPxRVmgT +EObkKvbdRpUHKGDw +EObkKvbdmfdwlmgZ +DoDLKvbdBvzdJFPv +DnbjjvbdZHXEAPSi +EPDKjvbdbQHGdLzd +EOcKjvbdCIjbLIej +DnbjjvbdOXnuzdNt +EObkKvbdrSUkNkBN +DoDLKvbdNeDsiJLE +EPCkKvbdiUyeXRtb +EObkKvbdbsDKsdJa +DncLKvbdbrcLTdJa +DncLKvbdSPsgJecw +EObjjvbdKNADzGta +EPDLKvbdFWZPomKF +EPCjjvbdRzKISbvA +EOcKjvbdvmWAMcdm +DncKjvbdwyhGGYEr +EPDLKvbdfHjuqnRH +EPCjjvbdRXOEDLhD +EPCkKvbdyOSgwsJD +DoDLKvbdnCKXYOmu +DnbjjvbdjmCLyeGo +DnbjjvbdTYKlNzjx +DoCjjvbdZisHpGbG +EObjjvbdUWMPisaR +EObjjvbdqFcdtWAh +EOcLKvbdYqNEhleR +DnbjjvbdlZSrSyGt +EPDLKvbdePEsLTsr +DncKjvbdSBcdlJYk +EPDKjvbdePEsLTsr +EPDKjvbdypnmIjXA +DnbjjvbdsQWPKCuf +EOcKjvbdZRNEhldq +EPCjjvbdYpmFImEq +EPCkKvbdKfFhBaRV +DncLKvbdezvZEhtX +DncKjvbdiCObdvpq +DnbjjvbdmJETqUrB +EOcLKvbdfpBzvcxI +DncKjvbdRbDdkhxk +EPCkKvbdmpZyVkZC +EPDLKvbdyNsIXrhc +DnbkKvbdyYJJaoyk +DncKjvbdwWlBVaWV +DoDKjvbdqwPlCiYq +DncLKvbdvvkaVaWV +DncKjvbdcJMjKewY +EObkKvbdbBWFFpPw +EPCjjvbdpyOhGqEY +EPDKjvbdCDpAujNG +EPDLKvbdCSaCtFvr +DoCjjvbdwygfFxEr +EOcLKvbdLFehBaQu +EPCjjvbdssSSxydc +EPCjjvbdHfgZyYYH +DnbkKvbdnBjWxOmu +DnbkKvbdcJNJjewY +EObjjvbdrzLoraIO +EOcKjvbdADRwjZiQ +EPCkKvbdOAJStJrA +DncLKvbdajkennDA +DoCjjvbdmbKWxPNu +EObkKvbdmbKXYPOV +DoCkKvbdKCjCpjDY +EPCkKvbdIjEAJogE +DoCkKvbdkHgLfGOL +DoCkKvbdJcJbqKCx +EPCkKvbdVUMtGMWK +DoDKjvbdNxOuzcmt +EPDLKvbdNQYRVnGs +DnbkKvbdzjUoocrt +DoDKjvbdDnbjjvcE +DoCkKvbdGBPRZJzm +DoCjjvbdtvNwjRTA +EPDLKvbdZQldhleR +DoDLKvbdUtMsfMWK +DnbkKvbdDxYLtTsl +DoCjjvbdmbJwYPOV +DoCjjvbdaNLCTVMg +DoCjjvbdWXIwvEFH +DoDKjvbddZxoxYpb +DncLKvbdijGHimXr +EPDKjvbdZQmEiMdq +DncKjvbdTulPisaR +DncLKvbdnGdxMnGy +EPCkKvbdlYsSSyHU +DoDKjvbdKRZePFme +DoCkKvbdZRNFJNEq +DncLKvbdkMbMZeGo +DoCkKvbdBiLBkIej +EObjjvbdWXIwvEFH +EOcLKvbdGGJqnJTq +DoDLKvbdRWmcblID +EObjjvbdxUleQxlO +DnbkKvbdREDBPpdS +DnbjjvbdiifHjMwr +EObjjvbdZLqctOMN +EPCjjvbdmRxtyrci +DoDLKvbdDxXlTtUM +DoDKjvbdxrmiNSBg +DoDKjvbdTppntthN +EObjjvbdnUtykKRf +DoCkKvbdRNYBxmtz +EOcLKvbdQYmAHTSK +EPCjjvbdZtIhxcsO +DoCjjvbdbsCjsdJa +EPDKjvbdsZkoraIO +DoDKjvbdEJhJvYKA +EOcLKvbdJSxaTMwl +DoDLKvbdANHxrvzY +EObkKvbdcTDKtDia +EPDKjvbdrWolDJZR +DoDKjvbdsQVnicVf +EPCjjvbdYSlAlsoY +EPCkKvbdJYUBhMRQ +DncLKvbdtlXwBUBX +EObjjvbdVrOYBeMD +EPCjjvbdcJNJkGWx +DncLKvbdjKGHjNXr +DncKjvbdRMwayOUz +EObjjvbdzdzOzdyp +DnbjjvbdNHColpVL +DoDLKvbdNddThiLE +EPDKjvbdFjdsCgmV +DnbjjvbdTJZjRABM +DncKjvbdOTTugFVQ +DncLKvbdVYgszLPO +DncKjvbdEARhlzWw +EPDLKvbdUGzmkvvF +DoDLKvbdmRyVZsEJ +EObjjvbdptUHRqjt +EOcKjvbdJpzFOeme +DnbkKvbdMgDPmPtk +EOcKjvbdhzUfMRNf +DoDLKvbdpyPHgQdY +DoCjjvbdZjShQHCG +EOcKjvbdOTTvGeVQ +EPCjjvbdRacdkiZL +DnbjjvbdzitoodTU +EOcKjvbdxxIjCPyk +EObjjvbdunszqLPU +EObjjvbdwjwDgzzG +DnbkKvbdUyHtZkOn +DnbjjvbdqvpMChyR +DnbjjvbdmIctRUrB +EObkKvbdNHCpMpUk +DoDKjvbdeFPSCXCj +EOcKjvbdtvOXjRTA +DncLKvbdZGvdAPSi +DoCjjvbdQcbaPpcr +DoDLKvbdVUMselVj +DnbjjvbdVgxWXgYz +DoDLKvbdjAQHBQHK +EOcKjvbdxxJKCPyk +DnbkKvbdQdDApQcr +DnbjjvbdqrUjmjaN +EOcKjvbdJzofYEAN +DoDLKvbdJvVGEFHJ +EObkKvbdJcJbpjDY +EPDLKvbdhanbdwRR +EObkKvbdiZtfLqOG +DoCjjvbdeOdsLTsr +DoCjjvbdSLZFuGjs +DoCjjvbdqTsfrRjt +EObjjvbdACqxKZhp +EPCjjvbdxZhFexEr +EPDKjvbdiBoCeXRR +DoDKjvbdqFcdtVaI +DnbkKvbdkClLQgVH +DnbkKvbdZQmEhldq +DnbjjvbdQYmAGrqj +DnbjjvbdiLddNuDZ +DoDLKvbdsQWOjDWG +EPDKjvbdVqnXaeLc +DnbjjvbdwNWANEFN +EPCkKvbdsBfNMHKy +EOcLKvbdKQzFOfOF +DoDKjvbdHELVibJj +EPDKjvbdcImJkFwY +DncKjvbdIwtBgkqQ +EObkKvbdANHySvyx +DoDLKvbdpxnhGqEY +EPCjjvbdrafNMHKy +DoDLKvbdSQTfiecw +DnbkKvbdiMEdOUcZ +EObjjvbdQmYCYnUz +EPDLKvbdWIYWXfxz +EPCjjvbdNeEThiLE +EObjjvbdHDkWJaij +DncKjvbdMgDQNPuL +DncKjvbdKWUedFGi +EPDLKvbdJYUCIMRQ +EOcLKvbdRacdkhyL +EPCkKvbdSBdEkhyL +EPCkKvbdMRwMzUpz +EPDLKvbdkxrqsYft +EObkKvbdRkYetgLT +EPCkKvbdNrsvHFVQ +DoCjjvbdqiAKFNOe +DoDKjvbddwystRez +EOcKjvbdrylQTBHn +EPDKjvbdDjHjWXjA +EObjjvbdCIkCLJGK +DnbjjvbdqwPlDJYq +EPCjjvbdnVUzLKRf +EOcLKvbdUxhUZjnn +DnbjjvbdRpUHJecw +DnbjjvbdjhGlFfNk +EObkKvbdJKEAKPgE +DoDLKvbdIidAKPgE +DncKjvbdCSaCtGXS +DoCjjvbdIidAKQHE +DnbkKvbdFjdsCgmV +DoCkKvbdGKeTCglu +EOcKjvbdEzspeMDJ +EOcLKvbdqUTgSSKt +DoCkKvbdnBivwnmu +DncLKvbdJcJcRKCx +EPCjjvbdVwJXucdg +DnbjjvbdKVuGEFHJ +DncLKvbdnVUzKjSG +DoCkKvbdqGDeTuaI +DnbkKvbdLFfICBQu +DnbkKvbdZjTIQGbG +DoDLKvbddBrlrATm +DncKjvbdYNqAXtut +DnbjjvbdURROtuHm +EObjjvbdxmrgxSiD +DoCkKvbdjJfHjMwr +DncLKvbdNwoVzdOU +EPDLKvbdyTNhlqbH +EObkKvbdiMEcnUby +DoDKjvbdJcKCqJbx +EPDLKvbdNrtVgEtp +DncKjvbdjEkGtoAO +DoDKjvbdNVSrKmAX +EOcLKvbdxmsIYTIc +EObkKvbdcTDKtDjB +EPDLKvbdxsOIlrCH +DnbkKvbdbrbjsdKB +DoCjjvbdpfEEtWAh +DoCkKvbdMowqVmfs +EPCkKvbdeATqMxJf +EObkKvbdjJehJmYS +EPDKjvbdxmrhYSiD +EObjjvbdjbkkQgUg +DoCjjvbdYlRdUNlN +DoDLKvbdiHKDZWJu +DoDKjvbdpedEsvAh +DoCkKvbdEuyPomJe +EPCkKvbdhtyeWrVC +DncLKvbdbAvEfQQX +DnbjjvbdTkvPBWPJ +DncKjvbdYlRdUOLm +DncLKvbdCIjajiGK +EPDKjvbdUtNTfLuj +DnbkKvbdKVuFdEgJ +DoDKjvbdfVzwoizs +EPCjjvbdySmiMrBg +EPCkKvbdrpWPJcVf +DoDKjvbdcImJjewY +DoCkKvbdkVvnECYX +DncKjvbdWRnYCEkc +DoDKjvbdCIkBjhfK +EObkKvbdmIdURVSB +DoCkKvbdTppoUuHm +EPDLKvbdUQqOtuHm +DnbkKvbdhgKDYvJu +DnbkKvbdkHgLfFmk +EPDLKvbdCDoaVjMf +EPCkKvbdehKvSNqH +DncKjvbdNeEUJJLE +DncKjvbdlhdTqVSB +EOcKjvbdEuxpPmJe +DncLKvbdqceIpNua +DnbjjvbdnVVZjjRf +DnbkKvbdKDJcRJbx +EObkKvbdnHEwlmgZ +EOcLKvbdFWZQQMjF +DoDKjvbdKWUedEgJ +DoDLKvbdmozZVkZC +DoCkKvbdZdxGzhJC +EObkKvbdGQATWffZ +EPCkKvbdJuuGDeHJ +DoCkKvbdiGibxvJu +DnbkKvbdBraDUGXS +EPDLKvbdiHKDYvKV +DnbjjvbdZxcjODMS +DnbkKvbdnGdwlmgZ +DoDKjvbdkxsRrxgU +EOcKjvbdrzMQTAgn +DncLKvbdjhHLfGOL +DnbjjvbdQvnEClID +DoDKjvbdqdEhomvB +DoDLKvbdGdKvKCJj +DnbjjvbdqvpLbiYq +EObjjvbdsPvOjCuf +DoDLKvbdVqnXbElD +EPDLKvbdeEoRbXCj +DoCkKvbdyYJKBoyk +DoDLKvbdlhdURUqa +EPDLKvbdYkqdTnMN +DoCkKvbdnGdwmNgZ +EObkKvbdGGKSOIsq +EObjjvbdLLAgvAJy +DnbjjvbdajlFnmcA +DoDLKvbdiifHimYS +EPCjjvbdnPzYukYb +EPDLKvbdVYhTyjnn +EOcLKvbdfNFwHNJk +DoCjjvbdbrbkTcia +DncLKvbdRkZGVHLT +EObkKvbdSQUHKFdX +EOcKjvbdSKxeuHKs +DncKjvbdFxuUaDwb +DoCkKvbdaSGDHtFk +EPDKjvbdZyDimcLr +EObjjvbdiGibxvJu +EPCkKvbdDwwktTsl +EPDKjvbdRadEkiZL +EPDKjvbdmgEwlmfy +DncLKvbdaogHDkzd +EOcLKvbdjuvmdCXw +EPDKjvbdqwPlCiYq +DoDKjvbdLBLHNBxR +EObjjvbdeFOrBvbj +EPDKjvbdFyVVAdYC +EPDLKvbdKNADygUa +DncKjvbdbVCGxLUI +DoCkKvbdJSyArmXl +EObkKvbdQvnDbkgc +EObjjvbdrEEiQOWB +EOcKjvbdZMSDtOLm +DoDKjvbdQvmccLhD +EPCkKvbdrzMQTBHn +EPDKjvbdMgCpNQUk +DoDKjvbdmbJwYPOV +EOcKjvbdgGLymgHA +EObjjvbdsrqsYzFD +EPDLKvbdrNZiyLgi +DnbkKvbdiiegimYS +DoDKjvbdqwQLcJYq +EObkKvbdaNLCSuNH +EPCkKvbdnUuZkJqf +EPCjjvbdSCEEkiZL +DncLKvbdVZHszKnn +DnbjjvbdUtMsfLuj +DoDKjvbdxmrgwriD +DoCkKvbdxxJKBpZk +EObkKvbdZMRdUNlN +EObkKvbdbPgHDkzd +EObkKvbdqqtjnLAm +EPDKjvbdURROuUhN +DoDKjvbdCWzdJFPv +DoDLKvbdMSXMytpz +DnbjjvbdqlyjZMHi +DoDKjvbdbsDLUDia +EOcLKvbduVnXiqTA +DoCjjvbdDxYLsssl +DoDLKvbdyqPMiJwA +EObkKvbdeOdsLUUS +EOcKjvbdEuyQQMjF +DoDKjvbdEztQeMDJ +EPCkKvbdGZVVBDxC +DnbkKvbdnGdxNNgZ +DoCkKvbdcIljLFvx +DoCjjvbdYqMdhmEq +EPDLKvbdgKfzbfAE +EPCjjvbdJcKDRJcY +EOcKjvbdOFDtJJLE +DncKjvbdiLdcmuDZ +EObkKvbdrWpLcJZR +DnbkKvbdVAaqTQrZ +DnbjjvbdFkFTChMu +DncKjvbdaaWEepQX +EPCkKvbdpedEsvAh +DncKjvbdjAQGaPfj +DoDKjvbdbUbHXkTh +DoDKjvbdRjyFtfkT +EOcLKvbdOTTvHEtp +DoCjjvbdRkYfVGjs +DncLKvbdzoQRFCkx +DncKjvbdrMzJyMHi +EOcKjvbdULvPBWOi +EOcLKvbdzdynzdzQ +EPCjjvbdtumxJpsA +DoDLKvbdwMvAMcdm +EOcLKvbdqceIonVa +EObjjvbdOEdUIiKd +EObjjvbdHELVjBij +EObjjvbdqcdiPmvB +DoCjjvbdJvVFdFGi +EPDKjvbdWRmwaeLc +EPDKjvbdZxdJnDMS +DoDKjvbdZxdJnDMS +EObjjvbdxUldpxkn +DnbkKvbdSLYetfjs +EPDLKvbdYqMeIldq +DoCjjvbdrMyjYlIJ +EObkKvbddxZtTqez +EPCkKvbdWSNxCElD +DoDKjvbdWWiYVcdg +DoDLKvbdqGDdsvAh +EOcLKvbdhzVFlRNf +EOcKjvbdaNLCSuNH +DnbkKvbdkHgMFfNk +DnbkKvbddePRbXDK +DncKjvbdNVTSKmAX +EObkKvbdhzUfLpmf +EOcKjvbdZMSDtNkm +EPDKjvbdTqROtuHm +DoCkKvbdddnqbXCj +DoDKjvbdliEURVSB +DncKjvbdtvNxKQsA +DnbjjvbdqceJQOVa +EPDKjvbdpyOggQcx +EOcKjvbdtcDUvuoP +EObjjvbdrWpMChxq +EPDKjvbdGYttaEYC +EObjjvbdiifIKNYS +DoCjjvbdZyEJmcMS +EPDLKvbdKQzFOfNe +DoCkKvbdqYoIGpdY +EPDLKvbdxwhibPzL +EPDKjvbdRadElJYk +DoDLKvbdtkwwAtAw +EPCjjvbdDjHjVxKA +EPDKjvbdrzLosBIO +EPCkKvbdBdPaVimG +DoCjjvbdrafMkfjy +EPDKjvbdNGcPmQVL +DoDLKvbdVviYVdFH +EPCjjvbdkVwODaxX +DncKjvbdkMbMZeGo +EOcLKvbdfkGzbfAE +DnbkKvbdpyOhHQdY +DoDKjvbdQdCaPqES +EObjjvbdEKHiuxKA +DnbjjvbdpxnhGpcx +DnbkKvbdkxsSSxgU +DnbjjvbdURQnuUgm +DoDLKvbdTukpJtBR +EPCkKvbdqAiFAWgd +DnbjjvbdgGLymfgA +EOcLKvbdyYIibQZk +DoDLKvbdWHxVxGxz +EPDLKvbdFyVVAdXb +DnbkKvbdrRuKnKaN +DoDLKvbdTpqOttgm +EPDKjvbdLhbLqYAS +DoCjjvbdHELVjCKK +DncLKvbdfSBWzlDP +DoCkKvbdRDcBPpdS +DoDLKvbdsQWPJcVf +EPCkKvbdySmiMrCH +EPCkKvbdbUbHXjtI +DoDLKvbdUtMsfLuj +EPCjjvbdEvZQPmKF +EObjjvbddeOqbXDK +EPDKjvbdkClKqGtg +DncKjvbdqiAJdmPF +EOcLKvbdlrZUyrci +EOcKjvbdbBVeFpPw +EOcLKvbdULvPBWOi +EPCkKvbdcJMjLFwY +DnbjjvbdZtIhxcsO +EPDLKvbdSPtHJfDw +EObkKvbdaNLBsUlg +DoDLKvbdqvpLcIxq +DoCkKvbdpxoIHQcx +EPCkKvbdlZTRsZGt +DoCjjvbderBWzkcP +EPDLKvbdZtJIxdSn +EOcLKvbdmoyyWKxb +DoDLKvbduaDxroEh +EPDLKvbddoErkTtS +DncKjvbdnPzYvKxb +EObjjvbdsZlPsAhO +EPDLKvbdjJfHjMxS +EOcLKvbdbsDLUDia +DncLKvbdMuTSLNAX +EPDLKvbdemGWfmKL +EObkKvbdKefHbBQu +EOcLKvbduVnXjRTA +DnbjjvbdGZVUaEYC +EOcKjvbdkNCMZeGo +EPCkKvbdGKeSbgmV +DoDKjvbdqrVLNjaN +DnbjjvbdEASIlzWw +DnbjjvbdeOdrkUUS +DncKjvbdDjIJvXjA +DoCjjvbdqGEFUWAh +EPCjjvbdQcbaQRES +DnbkKvbdhtydwSUb +DoCkKvbdMuTRjmAX +DnbjjvbdJutfEEfi +EPCjjvbdzGxlAMeX +DncLKvbdIHGyyYYH +DoDLKvbdxUmEqZLn +DnbkKvbdNHCpMotk +DnbjjvbdFyVVAcwb +EPCjjvbdShzJqABM +DnbjjvbdcyxoxZRC +EPCjjvbdqquKnLBN +DncLKvbdcIlikFwY +DoCkKvbdeOeSkTsr +EOcLKvbdYpldhldq +EPDLKvbdQYmAGsRj +DoCkKvbdzGyMAMeX +EPCkKvbdqrVKnLBN +EObkKvbdxUldpxlO +EPCjjvbdfIKuqnRH +EPDKjvbdFWYpQMjF +EPDLKvbdOFEUJJKd +EOcLKvbdHEKvKBij +DoDKjvbdjcMLRHUg +EPCkKvbdWXIwudEg +DncLKvbdgPazvcwh +DnbjjvbdnVUykJrG +EPCjjvbdxxJJbPyk +DncLKvbdjJehKMxS +DncKjvbdEzspdkbi +EPDKjvbdrpVnjDWG +DnbjjvbdVrOYCFLc +DoDLKvbdMfbpMotk +DncKjvbdbhljLGWx +DncKjvbdxrmhlrBg +EOcKjvbdbKlGPODA +DoDKjvbdJvUfEFHJ +EPCkKvbdySnIlqag +EPDKjvbdVAbQrpqy +DnbjjvbdrykosAhO +DnbkKvbdKfFhCBQu +DnbjjvbdEXwktTsl +DoDKjvbdDoDLLXCd +EObkKvbdvwMAvAvV +EObkKvbdXsLaNUOx +DnbkKvbdRDcBQRES +EOcLKvbdZisIPgCG +DoDKjvbdpfEEtWBI +DoDKjvbdfoazwDwh +EPCkKvbdFpASvffZ +EObjjvbdRWnDblHc +DoCkKvbdNxOuzdOU +DncLKvbdYlSDtOLm +EPCjjvbdjbkjqHVH +EPCkKvbdrMzJxkgi +EPDKjvbdCIkBjhfK +EPCkKvbdUslsekvK +EOcKjvbdFejRnJUR +EPDLKvbdNHColotk +EPCjjvbdUxgtZjnn +DoDKjvbdEOcLLXCd +EPCkKvbdkHflGFnL +EPCjjvbdwygfFxEr +DncKjvbdeOdrjtTr +DoDLKvbdqTtHRqjt +EPDLKvbdQwNdCkgc +EPCkKvbdhzVGLpnG +DoDKjvbdxwiKCPzL +EPCkKvbdZirhQGbG +DoCjjvbdqrUkOKaN +DoDLKvbdlrZUysEJ +DoCjjvbdqFdFUWAh +DnbjjvbdyYJKCPzL +DncKjvbdxUldpyMO +EPCjjvbdvAcyTOeI +EObjjvbdLFegaaRV +DncKjvbdemFvgNKL +EOcLKvbdjcLjqHVH +DoDKjvbdRMxCYnUz +EPDLKvbdRjxfUfkT +DoDLKvbdiMEdNuDZ +DoDLKvbdZRMdhmEq +DoDLKvbdqlyiyLgi +EObjjvbdiiehJmYS +DoCjjvbdwuMeRYlO +EPDKjvbdqquKmkAm +EOcKjvbdlrYtysDi +EPDLKvbdliETqUrB +EObjjvbdePErkTsr +DoDLKvbdfHjvRnQg +EObjjvbdRXOECkgc +EObkKvbdMpXqWOGs +DncKjvbdEJhJvYKA +DoCkKvbdVrOYBeMD +EPDKjvbdTkvPBWOi +EOcLKvbdjuvmcbYX +DncKjvbdMfcQMouL +EOcLKvbdMpXpvOHT +DoCjjvbdiLdcmtcZ +DnbkKvbdiHJcZWJu +EPDLKvbdTqQnuUgm +DncKjvbdLGFgbBQu +EPDKjvbdNdctIiLE +EPDKjvbdZxdKODLr +DoDKjvbdSZjITCvA +EPCjjvbdDwxMUTsl +EPCkKvbdySmhmRag +EOcLKvbdSPtHKGDw +DoDKjvbdmIctRUqa +DoDKjvbdaRfChTek +DncLKvbdyNrhXsIc +DncLKvbdJTZBSlxM +DoDKjvbdFeirOIsq +DnbjjvbdJutedFHJ +DnbkKvbdUsltGMWK +DnbkKvbdbhljLGWx +EPCjjvbdirziTLJz +EOcKjvbdnPzYvKyC +DoDKjvbdkDMLRGtg +DncLKvbdyzeNqhIh +EPCjjvbdYTMAmUPY +DoCkKvbdgGMZnHHA +DncLKvbdlZSqsYft +EOcLKvbdZjShQHCG +DnbjjvbdjhGlGGNk +DoDLKvbdkxsRryGt +DoCjjvbdZyDjNbkr +DnbkKvbdNeEUJIjd +EOcKjvbdxxJJbPyk +DoDLKvbdRbDeMIxk +EObjjvbdrDeJPnWB +EPCkKvbdrXPkbiYq +EPCjjvbdeFPRbWbj +DncLKvbdHffyxxYH +EPDKjvbdcyyQYZQb +DoCkKvbdNsTvGeUp +EPCkKvbdfpBzwDxI +EPCjjvbdqTtHRrLU +EPCkKvbdhgJbxvJu +EOcKjvbdkxsRryGt +EPCkKvbdZshhyETO +DnbkKvbdrWpLbiZR +EObkKvbdnHExMmfy +DnbkKvbdbUbGwkTh +DnbkKvbdnHExMnHZ +EObjjvbdZnmiFEyj +EObkKvbdSQUGjGDw +EPCkKvbdqTtGrRkU +EObjjvbdcImKLGXY +EObkKvbdShzJqAAl +DncLKvbdGGJqnIsq +DnbkKvbdehKuqmpg +DncLKvbddeOrCXDK +EOcLKvbdRMwbYmtz +DnbjjvbdgFlZmgHA +DnbkKvbdyOSgxTJD +EOcLKvbdQZNAGsSK +DoCkKvbdRMwayNtz +DncLKvbdezvYeItX +EOcLKvbdVAapsQrZ +DoCjjvbdcImKLFwY +DoDKjvbdTqQnttgm +DnbjjvbdOEdUJIkE +DoDKjvbdeYZssqez +DnbjjvbdZjSgpHCG +DoCkKvbdTvMPisaR +EOcKjvbdZjSgofaf +EPDLKvbdfVzwoizs +DnbjjvbdCSaCsewS +EPDLKvbdFVyPpMjF +EObkKvbddjJrVtzn +DnbjjvbdyOSgxTIc +EOcLKvbdrovPKDVf +DnbjjvbdxZhGGXeS +DncLKvbdbLLeoNcA +EOcKjvbdMfbomQUk +EPDLKvbdaRebhTfL +DoDLKvbdoAKztHcn +EOcLKvbdGckWJbJj +DncLKvbdqmZjYlHi +DncKjvbdZyDinDLr +DoCkKvbdxwhibPzL +DnbkKvbdZoOJFFZj +EPDLKvbdYpmEiMdq +DoCkKvbdiUzFWquC +DnbjjvbdsPvPJcVf +DncKjvbdDwxMTssl +EObkKvbdZQleJNEq +DoDLKvbdWSNxBdkc +DoCjjvbdcSbkTcia +EOcKjvbdqvolChyR +DnbjjvbdqlzJxlHi +DoCjjvbdlrZUzTEJ +EPCkKvbdGdLWJbJj +EObkKvbdzoPqFDLx +DncLKvbdANIYrwZx +EObjjvbdSPsgJfEX +DoCjjvbdbiNJjfWx +DnbkKvbdMfbpNQVL +EObkKvbddePRbXCj +EPDKjvbdShzKRAAl +DoDKjvbdnPyxukYb +EObjjvbdVZITzKoO +EPDLKvbdZyDinDMS +EPCjjvbdYpldhmFR +DoCkKvbdZjTIPfaf +EObjjvbdqdEiPmua +DnbkKvbdRadEkhxk +EPDLKvbdzjVPpDrt +DnbkKvbdaMkBsUlg +DncLKvbdMpXpunGs +DoDKjvbdUxgszLPO +EPCkKvbdiiegilxS +DoCjjvbdEOcKkWbd +EOcLKvbdcTDLUEJa +EPDLKvbdZtIiYcrn +DoDLKvbdmttyjirG +EPDLKvbdGdLVjBjK +DncLKvbdDigjVxKA +EPCkKvbdelfWflik +DoDKjvbdOTUVfdtp +DncKjvbdTlWOaVni +EPDKjvbdrpWOibvG +EPDKjvbdfRaWzlCo +DncKjvbdlrYuZrdJ +DoDKjvbdIsZBSlwl +EPDLKvbdqquLOKaN +DnbjjvbdJmAEZgUa +EPCkKvbdcImJkFvx +DncLKvbdkxrqsYft +EPCkKvbdUWLojTaR +DoDKjvbdnGeXlmfy +DoCkKvbdiMFDmuCy +EPDKjvbdauCHXjtI +DoCjjvbdBsAcUGXS +DoDKjvbdACrYJyhp +DoDKjvbdsZlPsBHn +DoDLKvbdjJegimXr +DoDKjvbdWXIwvDdg +DncKjvbdelewHNJk +EObkKvbdyTOJMrCH +DoCkKvbdNddUIiKd +DoCkKvbdRyjHrbvA +DoCjjvbdiGjCyWKV +DoDLKvbdhlFEOVDZ +EPCkKvbdQdDAoqDr +DoDKjvbdBiLBjhej +EOcKjvbdqlyjZLgi +DncLKvbdtSrTYzFD +DoCkKvbdrMyjYlHi +EObjjvbdhficYuiu +DoDKjvbdfekymgHA +EOcLKvbdiifHjNXr +EObjjvbdIwsaglQp +DoCjjvbdCIkBkIfK +EPDKjvbdaSFcHsfL +DoDLKvbdMgDPlpUk +EPDKjvbdqYnggQdY +DoDKjvbdaSFbgsek +DoCjjvbdiZtekqNf +EPDLKvbdkClKpftg +DoCkKvbduMYWaUAw +EObkKvbdtTSTYydc +DnbjjvbdptUGqrKt +EObjjvbdYlRctNlN +DncKjvbdMgDQNPtk +DncLKvbdILaznXQk +DoDLKvbdiCPDFWpq +DoCkKvbdiGicZWKV +DncKjvbdFjdrbglu +DncLKvbdKWUfDeGi +DoCjjvbdVhXuwgYz +DoDKjvbdhtzFWquC +EPCjjvbdRpTfiedX +DoCkKvbdKVuFdEfi +DoDLKvbdbBWEfPow +DoCkKvbdZyDjODLr +DncLKvbdeAUQmXif +DoCkKvbdIidAKQHE +EPCkKvbdTqROuVIN +DncKjvbdRXODcMID +DoDKjvbdkyTRsZHU +EPCjjvbdxnTIXrhc +EObjjvbdJzofXdAN +EOcKjvbdiBncFWpq +EObkKvbdYORAXuVt +DnbjjvbdiMEdNtby +EPDKjvbdVrOXbFMD +EPCkKvbdAMgxrwZx +DoCkKvbdtbbuXVoP +EPCjjvbdDoCkKwCd +DncLKvbdVBBpsRRy +DoDKjvbdemGWgMik +EObkKvbdeEnqbXDK +EPCjjvbdhanbdvqR +DnbkKvbdmaiwYOnV +DoCjjvbdcJMjLGXY +DnbkKvbdIryArlxM +EPCjjvbdtkwvaUAw +DnbkKvbdxZgefYFS +EPCkKvbderBWzlDP +EPCjjvbdNxPVzdOU +EPDKjvbdaSGDHsek +EOcKjvbdqcdhpOVa +EPCkKvbdxmsHxShc +DoDKjvbdDncKjwDE +DoCjjvbdYpmEhmFR +DncKjvbdaRfCgsfL +EObjjvbdegjurNpg +DnbkKvbdjhHMFenL +EPCjjvbdMfcPmQUk +EOcLKvbdACrYKZhp +DoDKjvbdffMZmgHA +DoCjjvbdaaVeGQQX +EOcKjvbdSCDdkiZL +EOcKjvbdqwPlCiYq +DoDKjvbdajlGPODA +DncLKvbdJYTbHkpp +DncLKvbdtcDVXWOo +EPCjjvbdEXxLtTsl +EPCjjvbdJuteceGi +DnbjjvbdDoCkLWbd +DoCkKvbduCbtwWOo +EPDLKvbdauBgYLTh +EPCjjvbdOXoVzcmt +DoCkKvbdRMxByOUz +DoCjjvbdqYoIGqDx +EPCjjvbdNGbpMpVL +DoCjjvbdJpzFOfNe +EOcKjvbdVAapsQrZ +DncKjvbdpxoIHQcx +EOcKjvbdRaceLiZL +DncLKvbdtcCuWvOo +EObjjvbdbBVeGPow +DnbjjvbdKyRKSzuG +EOcLKvbdFyVUaEYC +EPDKjvbdkCkkRHUg +EObkKvbdKaKfmBxR +DoDLKvbdbUbGwjsh +DnbjjvbdrovOjDVf +EPCjjvbdZsiIyDsO +EObjjvbdRDbaPqDr +EOcKjvbdnBivwnmu +EPCjjvbdYTMBMsoY +DoDLKvbdxKwEHzzG +EPCkKvbdqTsgRqkU +EPDKjvbdfMfWgNKL +DnbkKvbdznpREbkx +DncKjvbdJXtCHlRQ +EPDLKvbdGYuVBEXb +EPDKjvbdZLrEUOMN +EPDKjvbdtcCtvuoP +EObjjvbdXsLaNUPY +EPDLKvbdyOTIYSiD +EObjjvbdsrrTYyeD +EObjjvbdZisHpGaf +DoDLKvbdvOszqLOt +DncLKvbdaMjbSuNH +DncLKvbdYTMBMsoY +EPDKjvbdwzIGFxFS +EPDLKvbdmRyUyrci +DncLKvbdTkvPBWOi +EPCjjvbdNdcsiIjd +EPCkKvbdEzspdkbi +EObkKvbdrovOicVf +DoDKjvbdhbObeXQq +DncKjvbdZnnIeFZj +EObkKvbdRECaPpdS +EOcKjvbdnGeXlnHZ +EPCjjvbdauCGwjsh +EPCjjvbdczYpXyRC +EOcLKvbdDihJuxKA +EOcKjvbdkVwNcbXw +EObjjvbdbsCkTcia +DoCkKvbdfMewHNKL +DoCjjvbdxZgeexEr +EOcLKvbdiBoDEwQq +DnbkKvbdpstHSSKt +EOcKjvbdQvmdClHc +EPDKjvbdIxUBhLqQ +EObkKvbdZtJIyESn +EPCjjvbdtumwjQsA +DoCjjvbdNPxQunHT +EOcLKvbddndrkUTr +EObjjvbdCTBCsevr +EOcKjvbdiUzEwRuC +EPDKjvbdRyigrbvA +DoCjjvbdezvYeJTw +EOcLKvbdVgxVxGxz +DnbjjvbdZeXfzhIb +DncKjvbdxZgfFweS +DoCkKvbdKxqKSztf +DncLKvbdpyOggREY +EPDLKvbdXrlBNUOx +EPCkKvbdqwPkbiZR +EPDLKvbdbsCjscia +DoDKjvbdnGeYMmgZ +EOcLKvbdUsmTfLvK +DnbkKvbdjuwOEBxX +DnbjjvbdTAFJICPE +DncKjvbdEuxoomKF +EPDKjvbdeOdsLTsr +EObkKvbdZshiYdSn +DncKjvbdcTDKscjB +DncLKvbdvwMBWAvV +EOcKjvbdVwIwudFH +EPDLKvbdlZTSSxgU +EOcKjvbdMgColotk +EOcLKvbdZdxGzgiC +DnbjjvbdULuoBWOi +EObjjvbdiCObeXQq +EPDKjvbdNUsRkNAX +DoCjjvbdZxcjOClS +DncLKvbdiUzEwSVC +DoDLKvbdvlvAMceN +DoDLKvbdqcdhpOWB +EObkKvbdCSaDUGWr +DoCkKvbdssSTYydc +DoCkKvbdnGdxMmgZ +DoCkKvbdHELWJbKK +DoDKjvbdKefHbApu +EObkKvbdVqmwbFLc +DoCkKvbdUtNTekuj +EPDLKvbdTlWOaVni +DoCjjvbdDxXkstUM +EPCkKvbdpxoHfqEY +EPDKjvbdmSYtzTEJ +DoCjjvbdddnrCXDK +EPCkKvbdZjTHpGbG +DncLKvbdhzVGLqOG +EPCjjvbdZjSgogBf +EPDLKvbdkDLjqGuH +DncLKvbdxUmFRZLn +EPDLKvbdjhHMFfNk +EPCkKvbdZjTHpHBf +EObkKvbdegkVqnQg +EPDLKvbdGYttaEXb +EObjjvbdZdwfzhJC +DoCkKvbdGQASwHFy +EPDKjvbdkVvnDbXw +EObkKvbdJYTagkqQ +DoCjjvbdMSWlzVQz +DoCjjvbdnGeYMmfy +DoDLKvbdADRxKZiQ +EObkKvbdZLqdTmkm +EPCkKvbdFeirOItR +EPCkKvbdRjyGVGjs +DncLKvbdiMFDnUcZ +EObkKvbdVAaqSpqy +EPCkKvbdULunaVni +DnbkKvbdcImKKevx +DoCjjvbduaDyTPFI +EPDKjvbdKQydoFnF +EPCjjvbdozmcjwoA +DoDLKvbdZLqdUNlN +DoDKjvbdJXsbHkpp +DoCkKvbdelfXHNJk +EObjjvbdeFOqavcK +EPDLKvbdqlyjZMIJ +DoCjjvbdUtMsekvK +DoCkKvbdIxUBhMQp +EOcKjvbdemGWgMjL +DoCkKvbdwuMeQyLn +DncKjvbdkClKpgVH +DoDKjvbdfNFvflik +DncKjvbdhkdcmuCy +DoDLKvbdCJKakIfK +DnbkKvbdSQTgJfEX +DnbkKvbdkIGlGFmk +DoDKjvbdySmhlqbH +DoCjjvbdGdLVibJj +EPCjjvbdSLZGUfkT +EPDLKvbdSKxfVHKs +DoDKjvbdGLFSbhMu +DoCkKvbdqFcdtWAh +EOcLKvbdbVBfxLUI +DoDKjvbdcScKsdKB +DnbkKvbdVwJYWEFH +EPCjjvbdGQASwHFy +DnbjjvbdqUTfrRjt +EPDLKvbdEYYMTtUM +DoDLKvbdfNFwHNKL +EObkKvbdsQWPJbvG +EOcKjvbdIsYaSmYM +EPDKjvbdBdQAuilf +DnbkKvbdrounibvG +EObkKvbdiCPCdvqR +EOcLKvbdBsAbsfXS +DoCjjvbduDDVWuoP +EPCkKvbdbsCjtEJa +EOcKjvbdcTDLTdKB +DoCjjvbdXGYytAPT +DnbjjvbdePFTLTsr +EObkKvbddoErjssr +EPCkKvbdcTDKsdJa +EPDKjvbdjgflGFnL +EObjjvbddeOqbWcK +EObkKvbdACqwizJQ +EObjjvbdHgGyyXxH +DoCjjvbdqlzKZMHi +DnbjjvbdhfibxvJu +DoDKjvbdSCEFLiZL +EPCjjvbdSCEFLiYk +EObkKvbdiLdcmuDZ +EObkKvbdzGyMAMeX +EPDKjvbdVYhTzKoO +EPCkKvbdxrmiNRag +DoDLKvbdjKGHilxS +EOcKjvbdhWyAzzAJ +EPDLKvbdMfcQNQVL +DncKjvbdYkqdTmlN +DoDLKvbdjJfIJlwr +EOcLKvbdZeYGzghb +DncLKvbdJuuFceGi +EPCkKvbdhzUelRNf +DnbkKvbdBhkCKhej +DoDLKvbdhbObeXRR +DnbkKvbdzHZMAMdw +DoDKjvbdZxcjNblS +DoCjjvbdDwwksstM +DoCkKvbdUVkpJtAq +DoDLKvbdaaWEepPw +DncLKvbdGdKvJbKK +DoDLKvbdTulQJtBR +DoDKjvbdqceJPnVa +DnbkKvbdvAdZTOeI +EOcKjvbdVAbRSqRy +EPCkKvbdTqQnuVHm +DoCjjvbdwNWANDeN +DnbkKvbdZtIiYdSn +EPCjjvbdPIAXyAZB +EPCjjvbdZoOIeEzK +DoDLKvbdmJETqUrB +DoCjjvbdOFDtIiKd +DnbkKvbdqvolDIxq +DnbjjvbdmgFYNNfy +DncLKvbdieLHUoAO +EPCkKvbdDnbkLWcE +DoCjjvbdmJETpuSB +DncLKvbdiiegjNXr +EPDKjvbdZQldiMeR +EOcKjvbdZHXEAPTJ +EObkKvbdWHwvXfxz +DnbkKvbdxUleRZLn +DnbkKvbdtvNxKQsA +DoDKjvbdOStWHEuQ +DnbkKvbdsBellHLZ +DoDKjvbdsCFllGkZ +EPDKjvbdjhGlGGOL +DncKjvbdxxJKBoyk +DncKjvbdrXPkcJYq +DoCkKvbduVnXipsA +DoDKjvbdjKGHjMwr +DoDKjvbdbBWEfPpX +EOcKjvbdznoqEcMY +DoCkKvbdySnJMqbH +DoCjjvbdlrZVZsDi +EPDLKvbdKfFgbApu +DoDLKvbdZRMdiNFR +EObjjvbdpeceUWAh +EObkKvbdRotHKFcw +DncKjvbdiZuFkpmf +DoDKjvbdnGdwmNgZ +DoDKjvbdMoxRVnGs +DoDLKvbdiVZeXRtb +EOcKjvbdGAoRYizm +DoDKjvbdJJdAJpGd +DoDKjvbdwMvANEFN +DnbjjvbdaaWFFpQX +DnbjjvbdqlzKZMIJ +EPDLKvbdxnShXsJD +DncLKvbdMfcPlotk +DncLKvbdURRPVUhN +DnbkKvbdHgGzZXxH +EOcLKvbdYlRctOMN +DncKjvbdnHEwlnGy +DoDKjvbdlYsSTZGt +EOcKjvbdZxcjNcLr +EObjjvbdmttyjjSG +EObkKvbdffLynHHA +DnbkKvbdmpZxvLZC +DncLKvbdBhjakJGK +DoCkKvbdpstHSRkU +EPDLKvbdiLddOVCy +EOcKjvbdxUleQyLn +EPCkKvbdTukpKTaR +EOcLKvbdjvXOECYX +EObjjvbdRWnEDLgc +EObkKvbdbhljLGWx +EPCkKvbdZoOJEdyj +DnbkKvbdqrVKnLAm +DoDKjvbdVAbRTRRy +DnbkKvbdhfjDZWKV +EOcLKvbdkWXOECYX +DnbkKvbdYTLaMsnx +EObjjvbdZRNFImFR +DncLKvbdCWzdIdpW +EOcLKvbdpyPIGqDx +DoDLKvbdiCOcFWpq +EPCjjvbdhtzFXSUb +Dnbjjvbdlqxtyrci +DoCkKvbdiZtelROG +EPCkKvbdVUNUFkvK +DnbkKvbdNddUJJLE +DoCkKvbdNdctIhjd +DnbkKvbdcyyQYZQb +EObkKvbdQmYByNtz +DoDLKvbdVrNxBeMD +EPCjjvbdCTBCsevr +DncLKvbdtSrTYyeD +DnbjjvbdRyigsDWA +DncLKvbdJYUBglQp +DoDKjvbdSPsfiedX +DoCkKvbdADRxKZiQ +EPDLKvbdrEFJPmvB +DnbjjvbdvAcyTOdh +EOcKjvbdaMjasUmH +DoDKjvbdZjSgogBf +DnbkKvbdnGeXmOGy +DnbjjvbdMgComPuL +EPCkKvbdxKvcgzzG +DncKjvbdwtldpyMO +DoDKjvbdbhlikGXY +EPCkKvbdpyPIHREY +DoDLKvbdkClLRHUg +EPDKjvbdqFdFUWBI +EOcLKvbdkxrqrxgU +DoDLKvbdTvLoitAq +DoCjjvbdJuuFcdfi +EPCjjvbdrykpTAhO +EPCjjvbdiZuFkqNf +EObjjvbdEuxpQNKF +EPCjjvbdGGKSOJUR +EPCkKvbdcyxowxqC +DnbjjvbdjhGkeemk +EPDKjvbdijGIJmYS +DnbkKvbdypnliKXA +EOcKjvbdRadFLhyL +EPCjjvbdxwiKCPyk +DoCkKvbdfILVqnQg +DoDLKvbdkNCLzEgP +DoCkKvbdGKdrbglu +DnbkKvbdJcJcRJcY +DoDLKvbdIwsahMRQ +DnbkKvbdNddUIhjd +EPCkKvbdJuuGDdgJ +EPDLKvbdjKGHjMwr +EObkKvbdGdKvKCJj +DncKjvbdNUrqkNAX +DoDLKvbdTqQoVVHm +DoDKjvbdNddTiIkE +EPCkKvbduaEZTPFI +DnbjjvbdFWYopMie +EObjjvbdyXhiaozL +EPCjjvbdhaoDFWpq +DncKjvbdJJdAKQHE +DoDKjvbdegkVrOQg +DnbjjvbdwuMdqYlO +EPCkKvbdLKaHvAJy +DoDKjvbdRbEFLiYk +DoDKjvbdSxLMNzjx +DnbkKvbdGKdsChMu +DncKjvbdACrYJzJQ +DoCjjvbdbUafwkUI +DncKjvbdzjVPpDrt +DnbjjvbdFfKSOJTq +EPDKjvbdHffyyXxH +EOcLKvbdRkZFtgLT +EOcKjvbdXsMAmToY +EOcLKvbdNPwqWNfs +DoCjjvbdEuxpPljF +DncLKvbdjJfIJlxS +DoCjjvbdhgJbxuiu +EPCkKvbdrDdhpOWB +DnbkKvbdwWlBWAuu +EObjjvbdySmiMrCH +EPCjjvbduWOXjRTA +DncLKvbdRDbaPqES +EPCkKvbdjEkHVPAO +EPDLKvbddiiqvUzn +EPDKjvbdyYJKCPyk +DncKjvbdNeEThiKd +DncKjvbdrbGMlGkZ +EOcKjvbdOTTvHEuQ +EObjjvbdFyVUaEYC +EPCkKvbdbiMikFwY +EPDKjvbduaDxsPFI +DncLKvbdozmckYPA +DoDLKvbdVYgsykPO +DoCjjvbdQvnDbkgc +DncKjvbdZLrDtNkm +DoDKjvbdHfgZyYXg +DoDKjvbdauCGwkUI +DoDKjvbdmJDsqVSB +EOcKjvbdhgJbyWKV +EPCjjvbdrouoKDWG +DoDKjvbdQmYCYnUz +DoDLKvbdfHkVqmpg +DoCjjvbdZjShPfaf +DoCkKvbdIGfzYxYH +EPDKjvbdZRMeJNFR +EPCjjvbdRpTgKFdX +EPCkKvbdEYYMUUUM +DncLKvbdwuMdqZLn +EOcKjvbdmuVZkJqf +DncKjvbdhgJbyWJu +DnbjjvbdKVuFcdfi +EPCkKvbdRadElIxk +EPCkKvbdYlSDsmkm +DoDKjvbdhlFEOVDZ +DoCjjvbdIsZBSlwl +DoDKjvbdLAkGmCXq +DoDLKvbdqwQMCiYq +EPDKjvbdURROtuIN +DoCjjvbdpxoHgREY +DncKjvbdwXLaWAuu +EObjjvbdrpWPJcWG +EPDLKvbdmozYvLYb +EPCkKvbdMowpunGs +DnbkKvbdANHySvzY +DncLKvbdZyDinDLr +DoCjjvbdziuPpESt +EPDKjvbdiVZeXRuC +EPDLKvbdDncKkWbd +EOcLKvbdFVxopNJe +DncLKvbdACqxJzIp +DncKjvbdaMkCTUlg +DoCkKvbdhyuGMQnG +EObjjvbdbBWFFpPw +EObkKvbdTAEiICPE +DoDKjvbdbUagXjtI +DoDLKvbdGZUuAcwb +DoDKjvbdnGdwlmgZ +DoDLKvbdVBCRSpqy +DnbjjvbdfIKvRnRH +EObkKvbdaRebgsek +DnbjjvbdNVSrLNAX +EPDKjvbdrJAKEmPF +DnbkKvbdBdQBWKNG +DoCjjvbdePFTLUUS +EPCkKvbdRDcAoqDr +DncLKvbdrNZiyLhJ +DoCkKvbdLqwNZtpz +EPDLKvbdlqxtzTEJ +DnbkKvbdrRtjmkBN +EPCkKvbdZRMeJNEq +DnbkKvbdZsiJYdTO +EObjjvbdUtMtGLvK +EOcLKvbdnCJwYOnV +DncLKvbdUMWPAuni +EOcKjvbdJcJbpjDY +DoCkKvbdcImKLGXY +EObkKvbdYSlAmTnx +DncLKvbdCTBCtFvr +EObjjvbdqlyjYlIJ +DoCkKvbdmSZUzSci +DoDKjvbdjEjfuPAO +EPCjjvbdWfYzUAPT +DnbjjvbdzROmJJwA +EObjjvbdnQZyVjyC +DncKjvbdjAQGaPgK +EObkKvbdtTSTZZeD +DoDLKvbdZLrETnLm +DncKjvbdCDpAujNG +DncKjvbdUyHsykOn +EPDLKvbdeXystRez +EPCjjvbdlrZUyrci +EPDKjvbdwjvcgzzG +EPDKjvbdnHExNOGy +EOcKjvbdZLqdTmlN +EPCkKvbdEuxopMjF +EObjjvbdJYTaglRQ +EPCjjvbdrWpLbiZR +EPCjjvbdNxOuzcnU +DoDLKvbdijFhKNXr +DnbkKvbdKWVGEFHJ +DnbkKvbdKCicQjCx +DoCkKvbdcScLTdKB +EOcKjvbdKWUecdfi +DoCjjvbdiLeDmuDZ +DncKjvbdySnJNSCH +EPDLKvbdZshhyDrn +DnbkKvbdssSSxydc +EOcLKvbdqrUjnLBN +EPDKjvbdGdLWKCKK +EObjjvbdsQWPJbuf +DoDLKvbdJcKDRJcY +DoCjjvbdZoNiEeZj +DnbkKvbdGFjSOJTq +EPDLKvbdxxJKBozL +DoDKjvbdBraDUGXS +EPDKjvbdJbjCpicY +DoCjjvbdVqmwbEkc +EPDKjvbdijFhKMwr +EPDLKvbdrSVLNkBN +DoCkKvbdiUzEvquC +EPCjjvbdWIYVxGxz +DnbkKvbdZoOIdeZj +DncLKvbdZRMeJNEq +EObjjvbdZMSDtOMN +DnbjjvbdRWnDcLgc +DoDLKvbdmRxtzTDi +EOcKjvbdJmADygUa +EOcKjvbdxUmFQyMO +EOcLKvbdOTUWHEtp +DoDLKvbdZRNFJMeR +EOcLKvbdxmsHxShc +EPCkKvbdUxhTykPO +DoCkKvbdelfWfljL +EPDLKvbdFejSOJTq +EPCkKvbdKefIBaRV +DncKjvbddeOqbXDK +EOcKjvbdhlEcnUcZ +DoCkKvbdZtJJZETO +DnbjjvbdSPtHJfDw +DncLKvbdOFDtIhkE +EPDLKvbdFyVVAcwb +DoCjjvbdqTtGqqjt +EOcLKvbdyTOIlrCH +DnbjjvbdACrYKZiQ +DoDLKvbdvmWAMceN +DoDKjvbdLBLHNCYR +EPCkKvbdIxUCHlQp +EPDLKvbdQmXayNtz +DoCjjvbdKRZdoFme +DncLKvbdZoNiEdyj +DoDKjvbdqqtkOLBN +EPCkKvbdiZuFkpmf +DncKjvbdEPCjkXCd +DoDKjvbdbVBgXjsh +DoCjjvbdmRyUzSdJ +EObjjvbdMJCLpxAS +DoCjjvbdwWlBWAvV +EPDKjvbdNHCpMouL +DncKjvbdEOcLKwDE +DoCjjvbdwjvcgzzG +DnbkKvbdNGbpNPtk +DoDLKvbdZGwEAOri +EObjjvbdaRfDITfL +DoDKjvbdVvhwudEg +EPCjjvbdHgGyxwwg +DncKjvbdcJMikFwY +EObjjvbdwMvAMdEm +EOcKjvbduMYXBUAw +EPDLKvbdpfDeTuaI +DoDKjvbdssSSxzEc +DnbjjvbdjblLRHUg +EOcLKvbdVwIxWDeH +EPCkKvbdLGFgaaQu +EPDKjvbdBiKakIfK +DoDLKvbdEOcKjwDE +EOcKjvbddijRvUzn +DoCjjvbdmaivxPOV +DnbkKvbdMfcQNPuL +DncLKvbdZtIiZDsO +DoDLKvbdhlEcmuDZ +EOcKjvbdIGfzYxYH +DncLKvbdICLydzAD +EPDLKvbdMfcPmPuL +DnbjjvbdrRuKmjaN +DnbkKvbdbsDKscjB +DoCkKvbdhkddNtcZ +EOcLKvbdNQXqVnGs +DoDLKvbdrEFIonVa +DoCjjvbdQvnDcMID +EPCjjvbdjlalZeGo +EPCkKvbdjJfIKNYS +EObjjvbdREDBPqES +EPCjjvbdiZtfMRNf +DoDKjvbdADRxJyiQ +DncLKvbdYkqcsnMN +DncLKvbdZshiZDsO +DoDLKvbdRNXayNtz +DncLKvbdqcdiPmvB +EPCkKvbdrNZixlHi +EPCjjvbdwtmFRYlO +EObkKvbdJTZBTNXl +EOcLKvbdWRnXadkc +DoDLKvbdvwMBVaVu +DoDKjvbdlZSrTYgU +EPDLKvbdQcbaQRDr +DoCjjvbdhuZdvrUb +DnbkKvbdZxdKOClS +DncKjvbdJzoexEAN +EOcLKvbdQvmdDLhD +DncLKvbdunszpkPU +EOcKjvbdiZuGMQnG +DncKjvbdVZIUZkOn +DoDLKvbdkxsRsYgU +EPCjjvbdGQASwGey +DncKjvbdnBivwoNu +EPDLKvbdsBelkfjy +DoDLKvbdddoRbWbj +EPCjjvbdhancFXQq +EObkKvbdJvUfEEfi +EPDLKvbdIidAKPfd +DoDLKvbdxVMdpxkn +DoCjjvbdaNLCTVNH +DnbkKvbdZyDinDMS +DoDLKvbdrMzJyLhJ +EPDLKvbdyXhiaozL +DoCjjvbdGKeTDHlu +DncKjvbdwzIGFxFS +EObjjvbdJvUedEfi +DncLKvbdIjEAJpGd +DncKjvbdyTNiNRbH +EOcKjvbdidkGuPAO +DoDLKvbdkVvmcbXw +DoCjjvbdJYTbHkpp +DoDLKvbdFyVVBEYC +EPDLKvbdmoyyVjyC +EOcKjvbdcTDKtDjB +EPCjjvbdEvYpPmJe +DoCjjvbdCJLCKhej +DoCjjvbdSKxfUgLT +DoDLKvbdFjeTDINV +DncLKvbdEXxMUTtM +EOcKjvbdWRnXaeMD +DoCjjvbdrMzJyLgi +DoCkKvbdcSbkUEKB +DnbkKvbdyzeOSIIh +DncLKvbdpstGqrKt +EPDKjvbdCJLBkJGK +EOcLKvbdJcJcQjDY +EPDLKvbdbLLfPNcA +DnbjjvbdEASImZwX +DnbjjvbdtumwiqTA +DnbkKvbdxKvdHzyf +DoCjjvbdVwIxWDeH +DncLKvbdYzcFqjVy +EPDKjvbdqiAJeMoF +DoDLKvbdNQXqVmfs +EPDLKvbdFjdsChNV +DoCkKvbdOTUWGdtp +EOcKjvbdOEdUIiKd +EOcLKvbduaEZSoFI +EOcLKvbdxsNhlrBg +EObkKvbdcIlijfXY +DoDLKvbdLqvlytpz +DoDKjvbdIryBTNXl +EObjjvbdQwOECkhD +DoCjjvbdLFegaaQu +EObkKvbdFkFTChNV +DnbjjvbdyzeOSHiI +EObjjvbdLAkHNCYR +DnbkKvbdZyDimcMS +DncKjvbdkMbLzEgP +DnbjjvbdRbEEkhyL +EOcKjvbdLrXMzVQz +EOcKjvbdVBBqTRRy +EObjjvbdyNsHxTIc +EPCjjvbdMuTRkNAX +DoCkKvbdUaCQrprZ +EPCjjvbdjmCLydfo +DoCjjvbdFyVVAcxC +EPCjjvbdQvnDblID +DnbjjvbdLhbLqYAS +DncLKvbdFxuVBEYC +DncKjvbdGLFScIMu +DncKjvbdBvzcheQW +EPDLKvbdSPsfjFcw +DnbkKvbdsQWOibvG +DnbkKvbdaSGChTfL +EPDLKvbdjmBkzFGo +DoDLKvbdqAiFAWhE +EPDLKvbdkVwNcaww +DoCkKvbdKRZePGOF +EOcLKvbdJXtCIMRQ +EPCkKvbdaNLCTUmH +EPDLKvbdliDtRUrB +EOcLKvbdKfGHbApu +EObkKvbdDwwlTstM +DoDLKvbdmgExMmfy +EOcLKvbdKWUfEFHJ +EPCjjvbdkxrqrxft +DncLKvbdkClKqHUg +DoDKjvbdVqnXadlD +DoDLKvbdULvPBWPJ +DoDKjvbdUslsfMWK +EOcLKvbdJvVFdFGi +DncKjvbdiifHilxS +EPCkKvbdRaceMJYk +DoCkKvbddwytTrFz +EPDLKvbdYkrETnLm +DoCjjvbdiMEdOUby +DoCkKvbdxVMeQyLn +EPCkKvbdwuMdpxlO +EPDLKvbdNPxQumfs +DncKjvbdYpleJNEq +DncKjvbdTAEhhCPE +EOcLKvbdUGznLwVe +EOcKjvbdNPwpunHT +EPDLKvbdKaLHNBwq +EOcLKvbdFfKRmhtR +EObkKvbdYlRcsmlN +DoDLKvbdWSOXadlD +EOcLKvbdWWiXucdg +DoCkKvbdZsiIxcsO +DoDLKvbdbhlikFvx +EOcKjvbdtlYXAsaX +EOcLKvbdUtNTelVj +DoDKjvbdhaoDFXRR +DoDLKvbdEuxoomJe +DoDLKvbdEYYLtTsl +DncLKvbdbhmJkGWx +EPDLKvbdqwPkbhxq +DnbjjvbdlrYuZsEJ +DncLKvbdeKKSWUzn +DnbkKvbdyTNiNSCH +DncKjvbddwzTsqez +DncLKvbdTXkMNzjx +DoDKjvbdJmAEZgUa +DncKjvbdeEnqavbj +EPDLKvbdcJNJjfWx +DncLKvbdPyNAGsRj +DoCjjvbdLGGHbAqV +DncKjvbdddoRbWcK +DoDLKvbdZjTHogBf +EPDLKvbdRkZFuHKs +EOcLKvbdEuyPoljF +EPDKjvbdEYYMTtUM +DncKjvbdDxXlTssl +DnbkKvbdQvmcblID +EObkKvbdjmBkydgP +DoCkKvbdOAJTUKSA +DncKjvbdhgJbxvJu +DoDKjvbdVvhxVceH +DoCkKvbdjvXODaww +EPDKjvbdemFvflik +DoDKjvbdkCkkRGtg +DoCjjvbdDigjVxKA +DncLKvbdLAjgNCYR +EPDKjvbdbUbGwkTh +EObjjvbdmuUzLJrG +DnbjjvbdmgFXlnGy +DoCkKvbdFxttaDwb +EPCjjvbdJcKDRKCx +DoCkKvbdpfDeUWAh +EPDLKvbdADSYJyhp +DoCjjvbdHkazmvqL +DnbkKvbduLxWaUBX +EPCkKvbdQdCaPpdS +EOcLKvbdZdwfzhIb +EPDKjvbdKWUeceGi +EPDKjvbdSCDeMJZL +DoDKjvbdyOShYShc +EObjjvbdliEURVSB +DncLKvbdmgEwlnGy +DnbkKvbdsBemMHKy +DoDKjvbdYzcGSJvZ +EObkKvbdGcjvKBjK +EOcLKvbdJuuGDdgJ +EPCjjvbdOStWGeUp +EOcLKvbdGLEsChMu +EOcLKvbdeATqNYJf +DncLKvbdxxIjCQZk +EObkKvbddZyQXyQb +DoDKjvbdVBCRTRRy +EPCjjvbduDDVWuoP +EOcKjvbdVZHtZkOn +EPCjjvbdZQmEhmFR +DnbkKvbdZyDimcLr +EPDLKvbdjblKqHVH +EOcLKvbdZtIiZDsO +DnbkKvbdRWmcbkhD +EPCjjvbddneSjtTr +DoCkKvbdZQmFJMdq +DoDLKvbdLFegbBRV +EOcKjvbdSwkMNzjx +DoCjjvbdFjeTDHlu +EPCjjvbdtSqrxydc +DncLKvbdSPtHKFcw +DncLKvbdyYJJapZk +EOcKjvbddxZssrFz +EObjjvbdfekzOGgA +EPDKjvbdrylQSaHn +DnbjjvbdZisHofbG +EObjjvbdrbGNMHKy +DnbkKvbdLBKfmBxR +DncKjvbdACqxJyhp +DncLKvbddijRutzn +EPDLKvbdMpYRVmfs +DncLKvbdmttzKiqf +DnbkKvbdZnmhdeZj +EPCkKvbdjKFgjNYS +DnbjjvbdxnTHxShc +EPCjjvbdlZTSTYgU +DoCjjvbdqlyjYkgi +EObkKvbdxVMeQyMO +EPDLKvbdSPtHJecw +EPDLKvbdrpWOibvG +EObkKvbdRbEFLhyL +DoCkKvbdYNqAYUvU +DoCkKvbdnCKXXnnV +EObkKvbdddoSBvbj +DncKjvbdNGcPlpUk +DnbkKvbdmajXXnmu +DoCjjvbdJXsbHlQp +DncLKvbdNGcPlouL +DoCkKvbdTAFJHaoE +EPCjjvbdnPyxvKyC +EPCkKvbdRyihTDWA +DncLKvbdQlxCZNtz +EObkKvbdJSyAsMwl +DoCjjvbdmttykJrG +EPCkKvbdfpBzwEXh +DoCjjvbdrzMQTBIO +EPDKjvbddZxowyRC +DncKjvbdaNKaruNH +DnbjjvbdaNKasVMg +DncKjvbdcbTNSATm +EPCkKvbdiLdcnVDZ +EObjjvbdYTLaMtOx +EOcKjvbdEASIlzWw +DnbjjvbdziuPodTU +EOcLKvbdqUUHRqkU +DnbkKvbdyNsHxSiD +EObjjvbdhkeDnUcZ +EOcKjvbdNHCpNQUk +EPDLKvbdIryBSmYM +DnbkKvbdfekynGgA +EOcLKvbdiHKCyWJu +EObkKvbdrMzKYlIJ +DoCjjvbdsZkoraIO +EOcKjvbdQccAoqES +DoCjjvbdtTRrxzFD +EPCjjvbdJXtBhMRQ +DnbjjvbdsBfNMHKy +DnbkKvbdeEnrBwCj +DoDLKvbdTfzmkvvF +DoCjjvbdCJLCLIej +DnbjjvbdNUrrLNAX +DoCkKvbdxsNiNRag +EPCjjvbdtbcUwVoP +DoDKjvbdaogHDkzd +DncKjvbdpedFTuaI +DnbjjvbdqYngfpdY +DncKjvbdbiNJkGWx +DoCjjvbdGckVjBij +EObkKvbdqceIomvB +EPDLKvbdFWZQQNJe +EObkKvbdrRtkOLAm +DncKjvbdDwwktUTl +EObkKvbdwNWAMceN +DncKjvbdZMSDtOLm +EObjjvbdTkvPAuni +DoDLKvbdUxhTykPO +EOcLKvbdVBCQsQqy +EPDKjvbdZshhxcrn +DnbjjvbdqdEiQOWB +DoDKjvbdkWWmdBww +DoDLKvbdzQoMhiwA +DnbjjvbdUGzmlXWF +DncKjvbdJTYaTMwl +DoDKjvbdGLFScHmV +DoDKjvbdrWpLcJZR +EOcKjvbdwNWAMcdm +EObkKvbdmfeYNOGy +EObkKvbdtcDUwVoP +DnbjjvbdiZuGMQmf +EObjjvbdfMewGmJk +DnbjjvbdANIZTWyx +DncKjvbdtTSSxydc +DnbkKvbdsBfMkfjy +DoDKjvbdSLYfUgKs +DoDLKvbdZisHogCG +EObkKvbdVTlsfMVj +DncKjvbddZyPwxpb +DncLKvbdAMhYsXZx +DncLKvbdxwhjCPzL +EOcKjvbdKRZeOeme +DoCkKvbdunszqLOt +EPDKjvbdZRMdiMdq +DnbjjvbdEuxpPljF +EPDLKvbdGGJrOJUR +EPDKjvbdVviXudEg +DnbjjvbdpfDeTvBI +DncLKvbdRadElJYk +EPDKjvbdaMjbSuMg +EPDLKvbdTAEhhCOd +DncLKvbdTIyiqABM +EPCkKvbdBsBDUFvr +DoCjjvbdcSbkUEJa +EObjjvbdCIjbKhfK +DoDKjvbdauCHXjsh +DoCkKvbdpyPHfqEY +EOcLKvbdDwxMUUUM +DnbjjvbdGFjRmiUR +DoDLKvbdbQGgELzd +EOcKjvbdGGJqnItR +EPCjjvbdxrnJNRag +DoDLKvbdbhmJkFwY +EPDKjvbddoFSkTtS +DncKjvbdNUsSKmAX +EPCjjvbdfelZmfgA +DoCkKvbdjKGIJlwr +EPDLKvbdJYTaglQp +EPCkKvbdVrOXbFMD +EPDKjvbdTpqPUuIN +EPCjjvbdGckViaij +DnbjjvbdczZQYYqC +DoDKjvbdMtrqkNAX +EObkKvbdaNKartmH +EPDKjvbdmSZUysDi +EOcLKvbdlhdURVSB +DncKjvbdWRnXbEkc +DncLKvbdLBKfmBwq +EPDKjvbdZdwfzhIb +EPCkKvbdhancFXRR +EObkKvbdaSFbgtGL +DncLKvbdJXsaglQp +DncLKvbdUsltFlVj +DoDKjvbdLBKfmBwq +EPCkKvbdnVVZjirG +EObjjvbdiZuFlROG +EObkKvbdwygeeweS +EPCkKvbdwjvcgzyf +DnbkKvbdssRsYzFD +DnbjjvbdxwiJaoyk +EPCjjvbdVhYWYHYz +DncKjvbdhzVFkpnG +DncLKvbdeJjSVtzn +DncLKvbdyYIjCPyk +EPDLKvbdJpzEoGNe +DncKjvbdnBiwXoNu +EOcKjvbdVrOYCElD +EObkKvbdLBKgNCXq +EPDKjvbdTlWPBVni +EPDKjvbdFxuVBDxC +DncKjvbdnHFXlnGy +EPCjjvbdYkrDtOMN +DoCkKvbdUWMPjTaR +DoCjjvbdjSziSjiz +DnbjjvbdeOdsKtUS +EPCkKvbdmfdwmOHZ +EObjjvbdtSrTYydc +DnbkKvbdRjxeuGkT +EObkKvbdKeehCApu +EOcLKvbdpxoIGqEY +DncKjvbdbLMGOnDA +EPCkKvbdEXwktUUM +EObkKvbdiUzFWqtb +DoCjjvbdiHKCyViu +EObkKvbdvwLaWAuu +DoDLKvbdiCPDEvqR +EOcKjvbdWXJXvEEg +DoCkKvbdqTtGrSLU +DnbkKvbdtbbuXWOo +EObjjvbdgGLzOGgA +DncKjvbdTlVoBWPJ +DoCkKvbdeEoRbWcK +DoCkKvbdkWWmdCXw +DncKjvbdehLWRmpg +EPCkKvbdjFLGtoAO +DoDKjvbdGLFScIMu +EObjjvbdrRtkOKaN +EPCkKvbdczZQYYqC +DnbjjvbdfHkVqnRH +EOcLKvbdtvNxKRTA +EPCkKvbdADSYJyiQ +EOcKjvbdmJETptrB +EOcLKvbdURQoUtgm +DoDLKvbdZMSDtOMN +EPCjjvbdFfJqnIsq +EOcKjvbdcJNKKfWx +DnbjjvbdkySqrxft +DncLKvbdJpyePFme +DncKjvbduCcVXWPP +EOcLKvbdxKvcgzzG +DoDLKvbdpfEEsvAh +EObkKvbdZyDjNblS +EPCjjvbdhbPDEwRR +EPDLKvbdTqQoUthN +DoDKjvbdxnSgxShc +DoCkKvbdcTCjscjB +DoCkKvbdOTUVfeVQ +DncKjvbdkMbMZeHP +DncLKvbdEvYpPmKF +DncLKvbdJTZBTNYM +EObjjvbdIHGyxxYH +EOcKjvbdraemLfkZ +EOcKjvbdMpYRVmgT +DncKjvbdxZgfFxEr +DnbkKvbdpxoIGpcx +EPCkKvbdkIGlGFnL +DoDKjvbdUslselVj +DnbjjvbdZnnJEdzK +DncLKvbdehLVrORH +DoCjjvbdySmhlqbH +DoDLKvbdADSXiyhp +DoDKjvbdZtJJZDrn +DoCjjvbdezvZEiUX +EOcLKvbdqTtHSRkU +EPDKjvbdVgxWXgYz +DoCjjvbdGZUuBDwb +DncLKvbdhzUekpnG +EPCjjvbdZxcinDMS +EPCkKvbdOFEThiLE +DoDLKvbdhzVGLqOG +EObjjvbdkySqryGt +DoDKjvbdmpZyVkYb +DoCjjvbdnHFYMnGy +EObkKvbdRotGjFcw +EPDKjvbdjblKpgUg +EOcLKvbdWWiYVdFH +DoDLKvbdtbcVXVoP +EPDLKvbdqqtkOLAm +EPDLKvbdmRyUysEJ +DnbkKvbdxnShYTJD +DoDLKvbdGKeSbhMu +DoCkKvbdjuwODbXw +DncLKvbdaMkCSuMg +DncKjvbdtbcUvuno +DnbjjvbdiVZeWqtb +DoCjjvbdLBKgNBxR +EObkKvbdlZSqrxgU +EPCkKvbdULunaWOi +DoCkKvbdwzIGGYEr +EPCkKvbdnHExNOHZ +EObjjvbdpyOgfqEY +DnbjjvbdpedFUWAh +DoCkKvbdhaoDFXQq +DnbkKvbdYqMdhleR +DnbjjvbdsZkpSaIO +EPDKjvbdJcJbqJbx +EObjjvbdehKvRmqH +EOcLKvbdmIdURVSB +EPDLKvbdvOszqKoU +EOcLKvbdZisIQGbG +DnbjjvbdFyVUaDwb +EPCjjvbdTAEiIBoE +DncLKvbdRkZFtgKs +EOcLKvbdzdynzdyp +EOcLKvbdnUtykKSG +DoDKjvbdZQmEhldq +EOcKjvbdnBjWxOnV +EPCkKvbdqvpLbiZR +DoDKjvbdrykosBIO +EOcLKvbdBiKbLJGK +EPDLKvbdBvzciFPv +DoCjjvbdemFwGlik +EPDLKvbdqTsfqqjt +DncLKvbdptUHRrLU +EObkKvbdbUbGwjsh +DoCkKvbdHffyyXwg +EPCjjvbdgGMZnHHA +EPDKjvbdFejRmhsq +DoCkKvbdQvmdCkgc +DncLKvbdyNsHxShc +DoCkKvbdrDeIpOWB +EObkKvbdYzcGRiuy +DncKjvbdMowqWNfs +DoDLKvbdbsDLTcjB +EPCkKvbdZQmEiNEq +EObjjvbdNPwqWNfs +DoDLKvbddeOrBwDK +EObkKvbdrNZixkgi +DoDKjvbdtlXvaUBX +DncKjvbdtunYKRTA +EOcLKvbdfSBWzkcP +EObjjvbdVAbRTQrZ +DnbjjvbdcJNKLFvx +DncKjvbdssRsYyeD +DoDLKvbdqTsgSSLU +EPCkKvbdMowqVmgT +DoCjjvbdDnbjjvbd +EPCkKvbdlhdURUqa +DncKjvbdqrVLOLAm +DoDKjvbdNHDQNQUk +EPCkKvbdXsLaMtOx +EPCkKvbdRosgJfDw +DncLKvbdKVuFcdgJ +DoCjjvbdGGKRnItR +DnbkKvbdeEnrCWcK +EPDLKvbdlZSrTYgU +EPCjjvbdtSrTYyeD +DoCkKvbdZisHpHCG +DnbjjvbdbrbkUDia +DnbkKvbdhficYvKV +EOcKjvbdsBfMlHLZ +DoDKjvbdBdQBVjNG +DnbkKvbdTvLpKUAq +DoCjjvbdzaAPGgCM +EObjjvbdiVZeWrVC +EPCjjvbdZshiYcrn +EObjjvbdRNXbYnUz +EObkKvbdBcpBWJlf +DncKjvbdtbcUvuoP +DoCkKvbdmfeXmNgZ +DncLKvbdbPfgELzd +DncKjvbdZshiYdSn +EObkKvbdDjHiuwjA +DoDLKvbdfIKvRnRH +DnbjjvbdiLeDmtcZ +DoDLKvbdQwNcblID +EObkKvbdmRyUzSdJ +DnbkKvbdnHFYMnHZ +EOcLKvbdfHjvSORH +DncLKvbdlZSrSyHU +EObkKvbdtSrSxzFD +EObjjvbdZyEKNcLr +EObkKvbdRkYeuHLT +EOcKjvbdTkuoAuoJ +DnbjjvbdEPDKkXCd +EPCkKvbdnCJwXoOV +EObjjvbdxrmiMqbH +DoDLKvbdRaceMIyL +EPDKjvbdRosgKFdX +DoCjjvbdzoQQeDMY +DncKjvbdZyEJmcMS +DoDLKvbdOFDshiLE +EPDKjvbdSQUGiedX +EPCkKvbdTIyjRAAl +EObjjvbdxUmFRYkn +DncKjvbdmpZyWLYb +DoCkKvbdygZMANEw +DoDLKvbdhuZeWquC +EObkKvbdFyUuAcxC +DoCkKvbdiCPCeXQq +DncKjvbdsCFlkfkZ +EPCjjvbdNPwpvOHT +DoCjjvbdSPtGjGDw +DncLKvbdAMhZSvyx +EPCkKvbdWXJYWDdg +EPDKjvbdaogHDkzd +DoDLKvbdRosgKFcw +EPDLKvbdrRtjnKaN +DncKjvbdvBEZSoEh +DoDLKvbdmajXYOmu +DnbjjvbdfNFwHMjL +EPCkKvbdezuyEhtX +DoCkKvbdHffzZYYH +EPCkKvbdvAdYsOdh +EPCjjvbdhlFDnVDZ +DncKjvbdbiNKLFvx +DoDLKvbdMIalQxAS +EPDLKvbdGckWKBjK +EOcKjvbdvOszqKnt +DoCkKvbdraelkgKy +EOcKjvbdMgComPtk +DoDKjvbdOSsugFVQ +DoCkKvbdyNrhYTJD +EPCjjvbduDDVXWOo +DncLKvbdiCPDFXRR +DncLKvbdiGibyWKV +EOcLKvbdfNGXHNJk +EObkKvbdBhjakIej +EPCjjvbdxmrhXriD +DnbkKvbdJbibqKDY +DnbkKvbdSCDdkhyL +EPCjjvbdGFirOIsq +DnbkKvbdKVtfDeHJ +DoDKjvbdGKdrbhMu +DncLKvbdZLrETmlN +EObjjvbdjuvmcbXw +DncKjvbdQdDApRDr +EObkKvbdeATplwjG +DoCjjvbdZMRdUNkm +DoDKjvbdTqQoVVIN +EPCkKvbdOTTufeVQ +EPDKjvbdWRnXadlD +DncKjvbdZsiJYdSn +DoCkKvbdZLrDsnMN +DoDKjvbdEKHiuwjA +EPDLKvbdnBivxPOV +EPCjjvbdddnrCWbj +EOcLKvbdpssgSRkU +EPCjjvbdzdzOzdyp +EPCjjvbdZxcinClS +DoDKjvbdvAcySoEh +DnbjjvbdWHxWXfxz +DoDLKvbdCWzdJEpW +DoCjjvbdehLVqnRH +EObjjvbdEXxLstTl +EObjjvbdkMakzEfo +EPCkKvbdKaKflbXq +EPDLKvbdijFgjNYS +DoCjjvbdZsiIxdSn +DncKjvbdeATqNXif +DncLKvbdzoPqEblY +EObkKvbdLAjgNBwq +DncKjvbdUxgsykPO +DoDKjvbdaogGckzd +DncKjvbdFVxpPmJe +EOcLKvbdZLrDtNlN +EObjjvbdYNqAXuWU +DoCkKvbdEYYLstUM +EObjjvbdeFPSBwDK +DncKjvbdePEsKssr +DncKjvbdZjTHogCG +EPCkKvbdjKGHjNXr +DoCkKvbdNrtVgFVQ +DncLKvbdaMjaruNH +DoDLKvbdwjwEHzzG +EOcLKvbdTIzJqABM +DoDLKvbdliETqVSB +DoDLKvbdNrtVfdtp +DnbjjvbdZxdKNcMS +EPDLKvbdbUafxKsh +DoCkKvbdVrNxCFMD +DoCkKvbdxZgefYEr +DoDKjvbdYTLaMsoY +DncKjvbdeAURMwif +EOcLKvbdNGcPmQVL +EPDKjvbdqceJQOVa +DncKjvbdRotHKGEX +DoCjjvbdwNWAMdFN +EPCkKvbdFyVVAcwb +DoDKjvbdmozYvKyC +DncKjvbdSPsgJecw +EPDKjvbdZtJJYcrn +EOcLKvbdGckWKCJj +DoDKjvbdkxrrSxft +DnbjjvbdRbDdlIxk +DncKjvbdyYJJbPyk +DnbjjvbdhgJcYvKV +EObkKvbdjcLjqHUg +EObkKvbdhgJbyWKV +EObjjvbdrovPKCvG +DoCkKvbdbBVdepQX +DnbjjvbdUVkojTaR +EPCkKvbdbUagYLUI +DoDLKvbdptUGqqkU +DoCjjvbdyTNhlqag +DncKjvbdEYXlTssl +EPCkKvbdXFxytAOs +EOcLKvbdNdctIhkE +EPDLKvbdkDMLRGuH +EPDLKvbdDihJuxKA +EOcLKvbdrafNMHLZ +EPDLKvbdbKlFoODA +DncLKvbdZLqcsnMN +DnbjjvbdznpRFDLx +DncLKvbdziuQPdSt +EPCkKvbdbrcKsdKB +DncLKvbdaMkCTUmH +EPDLKvbdYkqdUOLm +DoDKjvbdjhHLfGNk +DoDLKvbdZMSDtNlN +DnbjjvbdZjTHpHCG +DoCkKvbdemFvgNKL +DncKjvbdrRtkOLAm +EPCjjvbdyNrhXsIc +EObjjvbdgPazwDwh +DoDKjvbdRDcAoqDr +DoDKjvbdvvkaWBWV +EOcKjvbdZRMdiNFR +EPCkKvbddePRawCj +DoCkKvbdHDjvKBij +DnbkKvbdZirgpGbG +EOcKjvbdhbPCeWqR +DnbkKvbdNPwpvNfs +EPCjjvbdZirhPfbG +EOcLKvbdIGgZxwxH +EPCkKvbdrykosBHn +DoDKjvbdxnTIYShc +DnbjjvbdNsTvGduQ +DncLKvbdBcpAvJlf +DnbjjvbdlqxtysDi +DoCkKvbdOEdTiIjd +DncKjvbdfHkVrOQg +DoCkKvbdiHKDYvKV +DoDKjvbdOTUVgFUp +EObkKvbdaaVdfPow +DncLKvbdZHXEAPTJ +DnbkKvbdkIHLefNk +DnbkKvbdjEjfuPAO +EObjjvbdhtzFWqtb +DoDLKvbdSQTfjFdX +DncLKvbdHEKvKBjK +DncLKvbdHDkVjBij +EPDKjvbdRpTfiecw +DnbkKvbdiBncEwQq +EObkKvbdRadEkhyL +EPCkKvbdezvYdiTw +EOcKjvbdaMjasUlg +EObkKvbdczZPwyQb +EPCjjvbdTvMQJtAq +EPCjjvbdJXtCIMRQ +DoDLKvbdkDMKpftg +EPCjjvbdiVZdvqtb +DnbkKvbdtunXipsA +DoCjjvbdjJehKNYS +DnbjjvbdJvUeceHJ +DoDKjvbdKRZdoFme +DncLKvbdJcKCpjCx +EPDKjvbdmbKXYPNu +DnbjjvbdkIHLeenL +EPDLKvbdNPxQunHT +DnbjjvbdUtMtFkvK +EPDLKvbdsPvPJcWG +EObjjvbdMRvlzVQz +DoCkKvbdsQWOjDWG +DnbjjvbdXGZZtAPT +DnbjjvbdunszpkOt +DncKjvbdxZhFfXdr +DnbjjvbdRzJgsCvA +EPCkKvbdSCDdlIxk +EPDKjvbdREDBPqES +DnbjjvbdBvzdIdov +DoDLKvbdSLYetfkT +EObjjvbdKWVGDeHJ +DoCjjvbduDDUvuoP +EOcLKvbdWIYWXgYz +DoCjjvbdbhmJjfWx +EPDKjvbdIxUCILpp +EOcLKvbdeXzTsrFz +EPDLKvbdsBemLgKy +EPCkKvbdzjVPpDrt +DncLKvbdZyDimbkr +DnbjjvbdRNYBxmtz +EPCkKvbdvOszpkPU +EObkKvbdSQTfiedX +DncKjvbdZRNFIldq +DoDKjvbdbhlijfXY +EObkKvbdEzspeLcJ +EPCjjvbdKCicRJbx +EOcLKvbdOYOuzcnU +DoCkKvbdhkddOVDZ +DncKjvbdIxTahMQp +EOcLKvbdwygeexFS +EPCjjvbdKRZeOeme +EPDLKvbdgPazvcxI +DncKjvbdfNFwHMik +EOcLKvbdtkwvaTaX +EObjjvbdURQnuVIN +DnbkKvbdiBncFWqR +DncLKvbdaMkCStmH +EPCjjvbdZjSgogBf +DoDKjvbdMowpvOGs +EPCkKvbdsrqsZZdc +DnbkKvbdRpTfjFdX +EOcKjvbdaMjbTVMg +EOcLKvbdmgExMmfy +DncKjvbdCJLCLJGK +DoCkKvbdNeDshiKd +DnbkKvbdGLFSbgmV +EObjjvbdMtrrLNAX +EOcKjvbdpedEsvAh +DoDKjvbdcyxpXyQb +EObkKvbdxZhGGXdr +DoCkKvbdEztQdlCi +EObkKvbdijFgilxS +EPDLKvbdkHgMFenL +EOcLKvbdlrYtysDi +DncLKvbdjcLjpgVH +DoCjjvbdnVVZkKRf +EPDKjvbdFeirNhsq +DnbkKvbdjblLRGuH +EPDLKvbdtTSTZZeD +DoDKjvbdVBCRTRSZ +DncKjvbdTYLMNzjx +DoCkKvbdEztQdkcJ +EObjjvbdpfEFTuaI +DncLKvbdYSlAmUPY +DncKjvbdYpldiNFR +DncLKvbdWXIwvDdg +DoDLKvbdeXyssrFz +DncLKvbdqdEhonVa +EOcLKvbdNQYRVnGs +EObjjvbdRpTgKGDw +DoDKjvbdauCHXkUI +DoDLKvbdhficZViu +DnbjjvbdzoPpeCkx +DoCkKvbdJYTaglQp +DoDKjvbdnBiwYPNu +EOcLKvbdMJCLqYAS +EPCjjvbdYkrDsnMN +EPCkKvbdehKvRmqH +EObkKvbdVqmxCFMD +DncKjvbdrDeJPmvB +EPDLKvbdzaAOgHCM +EOcLKvbdNPxQvNfs +DncLKvbdFVxopMie +EPDKjvbdgQBzwDwh +EObjjvbdTfzmkvvF +EPDLKvbdUaBprpqy +DoCkKvbdnGdxNOGy +DncLKvbdfIKurOQg +EPCkKvbdKDJcRKCx +EPCjjvbdmJEUQuSB +DncLKvbdrafNMGjy +EOcKjvbdZxdKNbkr +DnbkKvbdJmADzGuB +EPCjjvbdQvmdDMID +DnbkKvbdemGWgNJk +DncKjvbdyfxlAMdw +EPCkKvbddtAUATNW +DncKjvbdcasMrATm +DoDKjvbdVhYVxHYz +EPCjjvbdhyuFkpmf +DoDLKvbdcbTMrATm +EPCkKvbdILaznXRL +DoDKjvbdRDbaQQcr +DncKjvbdijFgjNYS +EObkKvbdIMBznXRL +EPCjjvbdxVNEpyLn +DncLKvbdYkqctOMN +EOcKjvbdxrmiNSBg +EPDLKvbdtTRsYzFD +EOcKjvbdzjVQQDsU +EPCjjvbdZMRctNlN +DncKjvbdXrlAmTnx +EOcLKvbdbPgGdLzd +EPDLKvbdFfJqmhsq +EOcLKvbdyzdmqgiI +DoCjjvbduCbtvuoP +DncLKvbdNGcPlpVL +EPCjjvbdGBOpyJzm +EPCkKvbdRDcBPpcr +EOcLKvbdRbEFLhyL +EOcLKvbdePFTLTsr +EObkKvbdcTCkUDjB +DnbkKvbdrWokbhxq +DncLKvbdqUTfrRjt +EOcLKvbdRyihTDWA +EObkKvbdpxnhHQdY +DnbkKvbdrSUkOKaN +DoCjjvbdIGgZyYXg +DoDLKvbdMowqWNfs +DoDKjvbdUxgtZkOn +EObjjvbdUtNTelVj +EObjjvbdlqxtyrdJ +DncKjvbdkVvnDbYX +EObjjvbdePFTKssr +DoCkKvbdMuSrLNAX +EOcLKvbdnQZyWLZC +DoDKjvbdhgJcYujV +DoDLKvbdaMjasVMg +EPCjjvbdcScLUDia +DnbjjvbdbKkeoNcA +DnbkKvbdfpBzwEYI +DoCkKvbdBhkBjhej +DnbjjvbdkDMLRGtg +EObkKvbdeATqNXjG +EOcKjvbdFkFSbglu +DnbjjvbdznpQdcMY +DncLKvbdIidAJpHE +DoCjjvbdLZQirzuG +DnbjjvbdzjUopDrt +EOcLKvbdnUuZjiqf +DoDLKvbdwyhFeweS +DoCkKvbdaoffckzd +EObkKvbdzaAPGgCM +EObkKvbdEzspdkcJ +DnbjjvbdDjHiuxKA +DnbkKvbdVqmxBdlD +EOcLKvbdrJAKFMne +EOcKjvbdZjSgofbG +EPCjjvbdfMfWgNJk +DoCkKvbdTukpJsaR +DoCjjvbdySmiNSBg +DnbkKvbdzGyMANFX +EObkKvbduWNxKQsA +DoDKjvbdRkZFuHLT +DncLKvbdbKlGOmcA +DncLKvbdyNsIXsJD +DnbkKvbdMpXqWNfs +DoCkKvbdHEKujBjK +DncLKvbdDxXktTsl +EPCkKvbdACrYJyiQ +EOcKjvbdqUUHSRjt +DoDLKvbdOFDsiJLE +EObkKvbdrbGMlGjy +DoCjjvbdjblKpgUg +EPCkKvbdiHJcYujV +EPDKjvbdrDeJQNvB +EPDLKvbdbrbkTdJa +DnbkKvbdNeDtIhkE +DnbkKvbdcJNKKevx +EPCjjvbdxVNFQxkn +EObjjvbdhyuGLqOG +EOcKjvbdrafMkfkZ +EObkKvbdRkYetgKs +DnbjjvbdUWLoitBR +DoCjjvbdQvmcblID +EOcLKvbdDoDLLXCd +DncLKvbdzRPMiJwA +DoCkKvbdsZkoraHn +DoDKjvbdkHgMGFnL +EObkKvbdrbFmMGjy +DnbkKvbdRWnDbkhD +EPDKjvbdJbicRJbx +DncKjvbdGZUuAcwb +DoCjjvbdmfdwmNfy +DoDKjvbdBdQAujNG +EPDLKvbdwWlAuaVu +DncLKvbdxmrgxSiD +DoCkKvbdUsmUFkuj +EOcKjvbdcTDKsdKB +DnbjjvbdjcLkRHVH +DoDKjvbdbiMijewY +EPCjjvbdPyNAHSrK +DnbjjvbdFkErcINV +EPDKjvbdZQldhmFR +EPDKjvbdTJZjRABM +EOcKjvbdKaKgMaxR +DoCjjvbdwzHefYEr +DoDLKvbdDwxLtUUM +DoCkKvbdfILWRmpg +DoCkKvbdRyihTCvA +DoDKjvbdSQUGjFcw +DoCjjvbdEYXktUTl +EPCjjvbdoznEKxPA +EPDLKvbdSiZiqABM +EObkKvbdVUNUFkuj +DncKjvbdMfbpNQUk +DncLKvbdEvYopMie +DnbjjvbdMowpvNgT +DncLKvbdKjaHvAKZ +DoDKjvbdqmZjZMIJ +EObjjvbdGcjuibJj +DoDLKvbduLwvaTaX +DoCkKvbdHgHZyYYH +EObjjvbdEOcKjwCd +EPCjjvbdGckWKCKK +EObkKvbdEuyQQMie +DnbjjvbdHgGzZYYH +EObjjvbdVUMsekuj +EObkKvbdWWiXucdg +EPDKjvbdRWnECkgc +EPDKjvbdxZgefYFS +DnbkKvbdEuyPomKF +EPCjjvbddePSCXCj +DoDKjvbdUsltFlWK +DnbkKvbdbsDKtEJa +EObkKvbdmoyyWLZC +DoDKjvbdSCDeMJZL +DnbkKvbdwtleRYkn +EPDLKvbdJpzEnfNe +DncKjvbdZisIQGbG +DoCjjvbdiUzEwRtb +DncKjvbdrounicVf +DncLKvbdmIdURVRa +DoDKjvbdYSlBNUPY +DnbjjvbdKDKDQibx +DoDLKvbdnCJvwoOV +EPDKjvbdgFlZmfgA +DoDKjvbdTukojTaR +DnbjjvbdVAbQsQqy +EOcLKvbdtAHRIABS +DnbjjvbdmbJvwnnV +EOcKjvbdvBDxrneI +DnbjjvbdeJirWUzn +DnbjjvbdKeegaaQu +DnbjjvbdzQoMiKXA +DnbjjvbdxwiJbPyk +EPDLKvbdKNADzHUa +DoCkKvbdANHyTXZx +EObkKvbdxLXDgzyf +EOcKjvbdpxoHgQcx +DncKjvbdLBKflawq +EPDKjvbdhanbdwQq +DnbkKvbdEASIlyvw +EPCkKvbdwzHfGYEr +EOcLKvbdqZPHgQdY +EPDKjvbdqTtGqqjt +DoCjjvbdDxXksssl +DoDKjvbdQlwayNtz +EOcKjvbdTvLoitAq +DnbkKvbdirzhsKiz +EPDKjvbdyzeORghh +DncLKvbdmJDsqVRa +DncLKvbdKefICAqV +EOcLKvbdZnmheFZj +DoDKjvbdIxUCILpp +DncLKvbdxsOIlrBg +DoCkKvbdiVZdvqtb +EPDLKvbdbBWEfQPw +EObkKvbdsCFllGkZ +EObkKvbdNdctIiKd +EObjjvbdozmcjwoA +EPDLKvbdlhdTqUqa +EOcKjvbdbUagYKsh +DnbkKvbdJpydoGOF +DnbkKvbdnGeYMmfy +DncKjvbdtlXwBUAw +DncKjvbdqiAJdlne +EPCkKvbdMIakqYAS +DnbkKvbdCWzchdov +EObkKvbdelewHNJk +EPCjjvbdFpASvgFy +DoDLKvbdVrNxCFMD +DnbkKvbdMpYQvNfs +EPCkKvbdEObkKwDE +EPDLKvbdHDjuibJj +EPCjjvbdKaLHMaxR +DoDKjvbdakLfOmcA +EPDLKvbdMgDQNQVL +DoCjjvbdEvYpQNKF +EPDKjvbdrEEhpOVa +EOcLKvbdOFDsiIjd +DncKjvbdtTSTYyeD +EObjjvbdQvnDblHc +DoDKjvbdVrNwbElD +EPCjjvbdZMRdUNkm +DoCjjvbdhfibxujV +DnbjjvbdYpmFJMeR +DncLKvbdDihKVxKA +DoCjjvbdrNZjYkgi +EOcLKvbdYqNFImEq +DoDLKvbdJbjDQjCx +DoDKjvbdwygefXeS +DncLKvbdUyHsykPO +DncLKvbdJSyBTMxM +EPDKjvbdcImKKfXY +EPCjjvbddndsLTtS +DoDLKvbdEASIlzWw +EObjjvbdrylQTAgn +DoDKjvbdFkFTChMu +DncLKvbdUaCQrprZ +DnbjjvbdOFEThhjd +EObjjvbdlYsRrxgU +EPCkKvbdnGeYNOGy +DoDKjvbdwygefYEr +DoCjjvbdGckViajK +DoDKjvbdSZjITDWA +EObjjvbdkWXNdCXw +EPCkKvbdKjaIWAJy +EObkKvbdKkBIWAKZ +DoDLKvbdptTfqrLU +DoDKjvbdPxmAGsRj +EObkKvbdTvMPitBR +EPCkKvbdegjvSOQg +DoDKjvbdwNWANEEm +EOcLKvbdRNXbYmtz +DoDKjvbdEOcKjwDE +EPDLKvbdfMfXHMik +DoCkKvbdWHwvXfxz +EPCjjvbdelfWgNKL +EPCjjvbdqcdiQOVa +DncKjvbdkyTSTZGt +DoCkKvbdbAueFpPw +EOcKjvbdQwNdClHc +DnbjjvbdxmsIYSiD +EPDKjvbdCTAbtFwS +DncLKvbdJpzFOeme +EOcKjvbdiZuGLqOG +DncKjvbdKaLHMaxR +EPDLKvbdbiMjLFvx +EPCkKvbdjvXODaxX +EOcLKvbdOAJSsirA +EPDKjvbdqYnhHQdY +DoCkKvbdDwwlTtUM +DnbkKvbdRjxfVHKs +EObjjvbdzjUpPcrt +EOcLKvbdeUAUATNW +EObkKvbdQlwaxmtz +EObkKvbdEXxLtUUM +EObkKvbdYkrETmkm +DoCkKvbdxmsHwsIc +DoDKjvbdzjUoocrt +EPDKjvbdqGEFTuaI +EPCjjvbdbiMjLGXY +EPDKjvbdfpBzwEXh +DncKjvbdZeYGzhJC +DoCjjvbdFkEsCglu +DncKjvbdOFDshhjd +DncKjvbdZMRcsnMN +EPCkKvbdrEFJPnVa +DoCkKvbdcyyPxYpb +EPDLKvbdijGIKMwr +DoCjjvbdbAudepQX +DncLKvbdFejSOItR +EOcKjvbdSLZGVHLT +EPDKjvbdMJBkpxAS +DncKjvbdJXsaglQp +DnbkKvbdjcMLRHVH +DoCkKvbdFjeTCgmV +DnbjjvbdqUTfrRkU +DnbjjvbdznoqFCkx +EObkKvbdVqnYBeLc +DoDLKvbdaMjbTVMg +DoCkKvbdSQUHKFdX +DoCjjvbdrDdhomua +DncLKvbdcTCjsdJa +DoCkKvbdsCFlkgKy +EPCkKvbdmbKWwnmu +DoCjjvbdZQmFImEq +EPCkKvbdyXiKCPzL +EOcLKvbdKQzEnenF +EPCjjvbdrbGNMGjy +EPDKjvbdgGMZnHHA +EOcLKvbdfHjuqnRH +EOcLKvbdFeirNiUR +DoCjjvbduaEZSoFI +DncKjvbdbAudfPow +DoCkKvbdbiMikFwY +DoDLKvbdcyxpYYqC +DnbjjvbdpxoHfpdY +DncKjvbdqUTgRqjt +DoDKjvbdcImKKfWx +DnbjjvbdmfeYNNfy +EPCjjvbdIjEAJofd +EObjjvbdLBKgNCXq +EObjjvbduLxWaUAw +DnbjjvbdJTZBTNXl +DoCkKvbduaDyTOeI +EOcLKvbdUyIUZkPO +EOcLKvbddePRawCj +EPDKjvbdhbObeWqR +EOcKjvbdBdQAvJmG +EOcKjvbdkVwODaww +DnbkKvbdUVkoisaR +DnbkKvbdMoxQvNfs +EObjjvbdCJKbLIfK +DncKjvbdYpmFJNEq +DoCjjvbdjKFhKMxS +DnbjjvbdZLrEUNlN +EPDKjvbdwuNFRZMO +EObjjvbdjuvnECXw +EPCkKvbdlZTSTZGt +DoCjjvbdsQVoJcWG +DncLKvbdmJETqVSB +DnbjjvbdjggLfGOL +EObjjvbdxwiKBpZk +DoDLKvbdKDKCpjDY +EPCjjvbdzRPNIjXA +DoCkKvbdkaMoNALA +EPCkKvbdjvWnDaww +EPCkKvbdSBcdkiZL +DnbkKvbdbUbHXkUI +EOcKjvbdURROtuHm +DncLKvbdJmAEZgVB +DoDLKvbdDxYLsssl +DncKjvbdWRnXadlD +EPCjjvbdADSXiyhp +DnbkKvbdNGcPlouL +DnbjjvbdBsAcTevr +EObjjvbdWWhwvDeH +EOcLKvbdbUafxKsh +DoCkKvbdtcCuXWOo +EOcKjvbdbKkennDA +EPDLKvbdGcjujBjK +DoDKjvbdRWmdDMHc +EPCkKvbdmSZUyrdJ +DoCkKvbdLZRKSztf +DncKjvbdZQmFJNFR +EPDLKvbdjhGkefNk +DncKjvbdeATpmYJf +EPCkKvbdDjHivXjA +EObjjvbdFyVVBEXb +DncKjvbdIHHZxxXg +DnbjjvbdMoxQvNfs +EObjjvbdlYsRsZGt +EOcLKvbdZHWdAPTJ +DoCkKvbdoznDjwoA +EOcLKvbdYpmEiNEq +EOcLKvbdfMfWgNJk +DnbjjvbdjlalZeGo +EPDLKvbdVgxVxGxz +DoDKjvbdZRMdiMeR +DnbkKvbdNsUVgFUp +EObjjvbdNGcPmPuL +EPDLKvbdrSUjnKaN +DncKjvbdMgDPmQUk +DoDLKvbdRkZGUfkT +EOcLKvbdpxoIGqDx +DoCkKvbdVwIxVcdg +DoDKjvbdZQmFIleR +EPDKjvbdZshiZDrn +EPCkKvbdFWZPpNJe +DnbkKvbdcImKKfXY +DoCkKvbdiVZeWqtb +EPCkKvbdkxsSSyHU +EObkKvbdcSbkTdKB +EOcKjvbdFxttaEYC +EPCkKvbdhtzEwSVC +EOcKjvbdLAjgNBwq +DoCkKvbdZisHofbG +DoDLKvbdIsYaTNYM +EPDLKvbdADRxJzIp +DoDKjvbdTkuoAvOi +EOcLKvbdZRMeJMdq +EPDLKvbdWWiXvDdg +DnbjjvbdbsDKscjB +DnbkKvbdtlXwBUBX +EPCjjvbdmgFXlmgZ +EObkKvbdjmBlZeGo +EObkKvbdmgEwmOGy +DoCjjvbdtlXwBTaX +EPDKjvbdSiZiqABM +EPDLKvbdEXxMTssl +EPCkKvbdRWmccLhD +DncLKvbdrWpMDJZR +EPDLKvbdelfXGlik +EOcLKvbdFjdsChNV +EPCkKvbdVUMtFkuj +DoDLKvbdtkxXBUBX +DncLKvbdMgDQNPtk +DnbkKvbdMJCMQxAS +EOcLKvbduWOYJpsA +EPCjjvbdZxcimcMS +DoDKjvbdqrUjmkAm +EObjjvbdRzJgsCvA +EOcLKvbdiBoDFXRR +EPCjjvbdSPtHKFcw +DncKjvbdbBVeGPpX +DnbjjvbdRotGiedX +DoDKjvbdIHGzZYXg +DnbjjvbdiGjCyViu +EPCjjvbdSxKkmzjx +EPCjjvbdmajWwoOV +DnbjjvbdmbKWxPNu +EObkKvbdCTBCsfXS +DoCjjvbdKQzEnfOF +EPCkKvbddijRutzn +EObkKvbdFjeTCgmV +DnbjjvbdURQnuUhN +DnbkKvbdiCOcFXRR +EObkKvbdJutfEEfi +DncLKvbdhtydwRuC +DoCjjvbdcTCjsdJa +DnbjjvbdzoPqEcMY +DoDLKvbdSCDdlJZL +EOcKjvbdlhctQuSB +EPDKjvbdOFETiJKd +EObkKvbddZyQYZQb +EOcLKvbdrMyjYlHi +DoDLKvbdqrVLOLBN +DncKjvbdyNsHwriD +EObkKvbdQvnECkgc +DnbkKvbdznopeClY +DoCkKvbdCJLBjiGK +EOcLKvbdauCGxKtI +EPCjjvbdeFOrCWcK +DncLKvbdcSbjtDia +DnbkKvbdKWVGDdgJ +EPDKjvbdrDdiQNua +DncLKvbdqTtGqrKt +DoDKjvbdjJfIKMwr +DoCkKvbdkxsSTZHU +EObkKvbdFejSNhtR +DoDKjvbdnCKWxOmu +DoDLKvbdvBDySneI +DncKjvbddZxpXyRC +EPDKjvbddwzTsqez +DoDLKvbdLFfIBaQu +DncLKvbdwzHeewdr +DncLKvbdOFEUJJKd +DoDLKvbdEvZQQMie +EPDLKvbdWHxVwgYz +DoCjjvbdiGjCxujV +EPDKjvbdrovPJcWG +DoDLKvbdZxcjOCkr +DnbjjvbdRzJgsDWA +DoDLKvbdiZuGLpnG +DncLKvbdTukoitBR +DnbkKvbdnBiwXnnV +DoDKjvbdBvzdIdov +EObkKvbdRWnECkhD +DoCkKvbdRbDeMJZL +DncKjvbdiGjDYujV +EPCkKvbdNdctIiLE +EPCjjvbdKWUfDdfi +EOcKjvbdkIGlGGNk +EPDKjvbdGZVVBDxC +EObkKvbdXsMBNUOx +EObjjvbdANHxrvyx +EPDKjvbdZtIhyDrn +DoCkKvbdRWmdCkgc +EObkKvbdffLynGgA +DoDKjvbdIxTahMQp +DncKjvbdKQzFPGOF +DoDKjvbduDCtwWOo +EOcKjvbdnCJvxOmu +DoCjjvbdEJgivXjA +DncKjvbdemGWgMjL +DncKjvbdCDpBVjMf +DncLKvbdmoyxukZC +EOcLKvbdtkwwBTaX +DoCkKvbdLqwMzUpz +DncLKvbdqFdFUWBI +EPDLKvbdZyEJmblS +EOcKjvbdEzsqFMCi +DoCkKvbdcarmSATm +DncLKvbdFfJqmiTq +DncLKvbdKQzEoGNe +DoCjjvbdUaCRTRSZ +EOcLKvbdqZOhGqEY +DoCkKvbdZisIQGaf +DoCkKvbdeFOrBwCj +DoDLKvbdmIctQtqa +EObkKvbdxVMdqYkn +DncKjvbdwygfFxFS +DoCkKvbdRWnEDLhD +EOcKjvbdmRyUyrci +DoCkKvbdWXIwvDeH +EPDLKvbdRXODcLgc +DoDLKvbdBsBDUGWr +EOcKjvbdEvYopNJe +DoCjjvbdBvzdIdov +DoCkKvbdyzeNrIJI +EObkKvbdCJKbKhej +EObjjvbdQccBQQcr +DnbkKvbdxZgeewdr +DoDKjvbdqcdhpNua +DoCjjvbdeJjSVtzn +DncKjvbddneTKssr +DnbjjvbdZxcjNbkr +EPCjjvbdZisIPfaf +EPCkKvbdkyTRrxft +DncKjvbdVwIxVcdg +DncLKvbdIxTagkpp +EPCjjvbdbrbjtEJa +DncKjvbdkCkjqHUg +DoCkKvbdUxgsyjnn +EObjjvbdUaCRSprZ +DnbjjvbdMJCLpxAS +DncLKvbdliEUQuRa +EPCkKvbdANHxrvzY +EPCjjvbdeAURMwjG +EPDKjvbdZoOIeEzK +DoDKjvbdmuVZkJqf +DncLKvbdaNLCTUlg +DoCkKvbdnQZxvLYb +DncLKvbdhficZWJu +DncKjvbdatbHYLUI +DoCjjvbddndrjtUS +EOcLKvbdsBfMkgKy +DnbjjvbdBiKakIfK +DnbjjvbdSQTfjFcw +DoCjjvbdmoyxvKyC +DoCkKvbdGcjuibKK +DnbkKvbdZQldiMeR +EObkKvbdqquKnKaN +DoCjjvbdZRNEhldq +EPCjjvbdBiKbLJFj +EPCjjvbdyXhjCPyk +DncLKvbdtTSSxzEc +EPCjjvbdnCJwXnmu +DoDLKvbdbBWEfQPw +EOcLKvbdemGXHNKL +DoDLKvbdmfdxMnGy +EOcLKvbdTqQntthN +EOcLKvbdrMyixlIJ +EOcLKvbdVUMselWK +EOcLKvbdBvzchePv +DoCjjvbdbVCHXjsh +EPCjjvbdZRMdhleR +EOcLKvbdhbObeXRR +EPCkKvbdFWZPpMie +DncLKvbdXFyZtAOs +DnbkKvbdTqQoUuHm +EPCjjvbdCSaDUFvr +DoDKjvbdQZNAHTSK +EOcLKvbdmoyyVkZC +DoCkKvbdGLErbhMu +EOcLKvbdtvNwjRTA +EObkKvbdFjdsDINV +EOcKjvbdeOdsLUUS +DncKjvbdMtrrKmAX +EObkKvbdBsBCtGWr +EOcLKvbdVBCRTRSZ +DoDKjvbdKQydoFme +DncLKvbdnHFXmOGy +DnbkKvbdGAnqYizm +EOcLKvbdjlakzEfo +EOcKjvbdegkWSOQg +DoCjjvbdtkwwAsaX +EPCkKvbdeKKSWUzn +EObjjvbdrRtjnLBN +EPCkKvbdeATqMxKG +DnbkKvbdZMRdTmlN +DoDKjvbdNsUWGeVQ +EObjjvbdyXiKBpZk +EOcLKvbdJKEAJpHE +DoDKjvbdzQoNJJwA +DoCkKvbdwygeewdr +EObkKvbdsCGNMHKy +EOcLKvbdlhdUQuRa +EObjjvbdyNsHwsIc +DoDLKvbdWRnXbFLc +EObjjvbduCcUvvPP +EOcLKvbdrEEhonWB +EPCjjvbdRjyFtgKs +EPCjjvbdkNCLzFGo +DoCkKvbdRDbaPpcr +DoDKjvbdQdCaQQdS +DncKjvbdwyhFexFS +EPDLKvbdBhjakJGK +EPDKjvbdaNKaruMg +EObkKvbdzQnliJwA +DnbjjvbdptTfrSLU +DoDKjvbdFWZPpNJe +EObkKvbdZxcjOCkr +DoDKjvbdehLWRnQg +EOcLKvbdcSbkUEKB +EObjjvbdbUafxLTh +EObkKvbdBcpAvKNG +DoDLKvbdySmiNSBg +DncLKvbdmIdUQuRa +EPCkKvbduDDUvuoP +DoDLKvbdMtrqjmAX +DoDLKvbdVZHtZkOn +EOcLKvbdiZuGLpnG +EOcKjvbdxmrgxShc +DoCjjvbdMpYQvNfs +EOcKjvbdCIkCKiFj +EPDLKvbdaaVdepPw +EObkKvbdXFyZtAOs +EPDLKvbdbKlFnnDA +DncLKvbdqGEFTuaI +EOcKjvbdqFcdsvAh +EPCkKvbdcSbkUDjB +DncKjvbdrJAJeMoF +EObjjvbdZMRdUNkm +DncKjvbdCEPaVjNG +DnbjjvbdptUHSSLU +EPCkKvbdUtNTekuj +DoCkKvbdVqmwadlD +EObjjvbdCIkBjiFj +EOcLKvbdbVCGwkUI +EObjjvbdFfKSNiTq +EPDKjvbdJXtCHlRQ +EPDKjvbdTvMQJtBR +EPCjjvbdZMRdTnLm +EPCjjvbdemGXGljL +EPDKjvbdxmsHxTJD +EOcKjvbdiVZdvrVC +DnbkKvbdmSZUzSdJ +EPCkKvbdUaCRTRSZ +DncLKvbdoAKztIDn +EObjjvbdHffyyXxH +EPCkKvbdaMjbStmH +EObjjvbdZyDinDMS +DoDKjvbdjlbMZdgP +DncKjvbdQwOEDMHc +DncLKvbdGLFSbgmV +EPCkKvbdjvXOECXw +DoCkKvbdSBceLhyL +DoDLKvbdEvYpPmKF +EOcKjvbdrbFlkfkZ +EPDKjvbdTvMQJsaR +DncLKvbdjvXNcaxX +DnbkKvbdijGIKNXr +EOcLKvbdiHJcZViu +DoCjjvbdlqxuZsDi +DnbkKvbdhuZeXRtb +DncLKvbdACqxJzJQ +EObjjvbdjlbLydgP +EPDKjvbdxZgefXdr +EOcKjvbdSCEFLiYk +EObjjvbdKefICApu +EPDKjvbdjlbLyeGo +DncLKvbdbAvEepQX +EPCkKvbdrSVKnLAm +DncLKvbdZjTHpHBf +DnbkKvbdCWzdIdov +DoDLKvbdxUmFQyLn +DnbkKvbdxVNFRYkn +DoCkKvbdZisHpHCG +DoDKjvbdwkXEHzzG +DoCjjvbdSPtHJedX +EOcLKvbdBiLBkIej +DoCkKvbdiLdcnVCy +DnbkKvbdlhcsqUqa +EPCjjvbdwzIGFxEr +EPCkKvbdySmiNRag +DncLKvbdHEKujCKK +EPDLKvbddeOrCXDK +DoDLKvbdNGbolpUk +EOcLKvbdtlYXBTaX +EOcLKvbdqwQLcIyR +EObjjvbdIrxaSlxM +EObjjvbdbrcKtEKB +EOcKjvbdpxngfqDx +DoDLKvbdKfFhCApu +DoDLKvbdJvUfEEfi +DncKjvbdsQWOibuf +DoCjjvbdHgGyxxXg +DoCkKvbdZHWdAPTJ +DncKjvbdauBgYLTh +DoDLKvbdJYUCIMRQ +DncKjvbdbrbjtEJa +DnbjjvbdemFwHNJk +DnbkKvbdBvzcheQW +EPCkKvbdJqZePGNe +EPCkKvbdSKxeuGkT +EPDLKvbdIryBTMxM +EPCjjvbdwWlAuaVu +EOcLKvbdyTOJNRbH +EPCjjvbdQvmdClID +DnbjjvbdyTOJMqag +DncKjvbdrXQMDJYq +EPCkKvbdGdLVjBij +EOcLKvbdjJehJmXr +DnbkKvbdCJKakJGK +DoCjjvbdLrWlzUpz +EPCkKvbdhzVFlRNf +DoCjjvbdRDcApRES +EObkKvbdzROmJKXA +DncKjvbdxUmFRYlO +EPCkKvbdURQoVVIN +EPDLKvbdVZHtZkPO +DnbkKvbdatafwjsh +EObjjvbdNrtWGdtp +DoDLKvbdBiLCLJFj +EOcKjvbdmgFXmOHZ +EObjjvbdZRMeImEq +DoCjjvbdiMEdNtcZ +DnbjjvbdgFkzNfgA +DnbjjvbdGKdsDHmV +DncLKvbdIxUBhMRQ +DoDLKvbdjSzhrjiz +DoDLKvbdpyPHgRDx +DoDLKvbdqYoIGpdY +DoCkKvbdUQqPUuHm +EPCkKvbdBraDTfXS +DncKjvbdNrtWGeUp +DncKjvbdJqZdnenF +EPCjjvbdCWzdIePv +DoDKjvbdrXPlDIxq +EPDKjvbdauBgYLUI +EPCjjvbdQmXbYnUz +DoCjjvbdGGJqnJUR +EPDLKvbdkVvnEBww +EPCjjvbdTukoitBR +DoCjjvbdRkZFtgLT +DoDKjvbdEuyPpMie +EPCkKvbdSLYfUgLT +DnbjjvbdIwtBglQp +DnbkKvbdznpQeDMY +EOcKjvbdznpRFCkx +EPDLKvbdtumwjQsA +DoDLKvbdBhjajiGK +DoDKjvbdhlFDmuDZ +DnbkKvbdqquKnKaN +DncLKvbdMowqVmfs +EOcKjvbdqrUjnLAm +EObjjvbdqwQMDIyR +EPDKjvbdnCKXYPOV +DnbkKvbdHffyyXxH +DoCjjvbdlZSrTZGt +DoDLKvbdznpRFDMY +EPDKjvbdWWiXvDdg +DoDKjvbdRWnEClID +DnbjjvbdJcKCqKDY +EPDKjvbdJbjDQicY +DncLKvbdhaoDEwRR +DncLKvbdvAdZSoEh +DncLKvbdeEnrCWbj +DoDKjvbdVvhwvDeH +EOcKjvbdVAapsQqy +EPCkKvbdxnTIYSiD +EPCkKvbdrouoJbuf +EObjjvbdePEsKtUS +EPDLKvbdirziSkJz +DnbjjvbdhaoCdvqR +EPCkKvbdGZVVAdYC +DncKjvbdtbbuWuoP +DoCkKvbdLFehCBRV +DoDKjvbdLZRJrztf +EObkKvbdkHflGFmk +EOcKjvbdJYUCIMQp +EPDLKvbduCcVXWOo +EPCkKvbdptTfqqkU +DoDKjvbdGQATWgGZ +DncKjvbdEztQeMCi +EObkKvbdZtJJZETO +DoCjjvbdZsiIyETO +EObkKvbddndrjstS +EOcLKvbddeOqbXDK +DnbkKvbdCTBDUGXS +EPDKjvbdQlwayOUz +EPCjjvbdlqyUzTEJ +DoDLKvbdhtydvrUb +EOcKjvbdlZTSSyGt +EOcKjvbdmJDtQuSB +DnbjjvbdtSqsZZeD +DoDLKvbdUaBpsRSZ +EPDKjvbdLGFhBaRV +DnbkKvbdSBcdkhxk +DoCjjvbdDoDKkXDE +DoDKjvbdwyhFfYFS +EPDKjvbdOEctJIjd +EPCjjvbdEObjkWcE +EPDLKvbdhtzEvquC +EObkKvbdZjShQHCG +EPCjjvbdmIctQuRa +EPCkKvbdVwIwucdg +EOcLKvbdADRxJzJQ +EOcLKvbdWWiXvEEg +EPCjjvbdTAFIhBoE +EPDLKvbdZLqdTnMN +EPDLKvbdZQldhmEq +EOcKjvbdLLBIWAJy +DncLKvbdrMzKYlIJ +EPCjjvbdzitoodSt +EPDLKvbdLFehCAqV +DoCkKvbdrMyiyMHi +EPDKjvbdkVvmcaxX +EOcKjvbdmpZxvKxb +EPCkKvbdliDtRUrB +DncLKvbdkxsRsYft +EPDKjvbdTqROuVHm +EPCjjvbdSQTgJedX +EPDLKvbdHlBznXRL +DncKjvbdQdDBQRDr +EPDLKvbdliDsqVRa +DoDKjvbdjgflFfOL +EPDKjvbdeEoSCWbj +DnbkKvbdfSBWzkcP +EObkKvbdmIcspuSB +EPCjjvbdvAdZTPEh +DoCkKvbdIGfyxwxH +DnbjjvbdWWiYWDeH +EObkKvbdZQleImFR +DncLKvbdQwNdCkgc +EOcLKvbdQdDBPqES +DnbjjvbdrpWPJbuf +DoCkKvbdTulQKTaR +DoDLKvbdeUAUASlv +EPCjjvbdZQmFJNEq +DncLKvbdVBBqSqSZ +EOcKjvbdqceJPmvB +DncLKvbdZtIiYcrn +EOcLKvbdJSxaSmYM +DoCkKvbdqqtkOLBN +EObkKvbdgFkymfgA +DnbjjvbdVqmwadlD +DncLKvbdsBfNMGkZ +EPDKjvbdEPDKjwCd +EObjjvbdHDjvKBjK +DncLKvbdCTAbsevr +EObkKvbdFxuUaEXb +DoCjjvbdcyyQYZQb +EObjjvbdZsiIxdSn +EPDLKvbdZQmEhmEq +DnbkKvbdxnTIXriD +DncKjvbdfHkVrORH +EOcKjvbdddoSCXDK +EPCkKvbdhanbdvpq +EOcKjvbdRyihTDWA +DnbjjvbdajkeoODA +EOcLKvbdlhdTpuSB +EPDLKvbdhgJbxuiu +EPCjjvbdnHFXmNgZ +EPCkKvbdpecdsvAh +DnbkKvbdVZIUZjnn +DncKjvbdbAvFGPpX +DnbjjvbdkMalZeHP +EOcLKvbdYSlAmUOx +DoCjjvbdHDkWKCKK +EPDLKvbdaRecHsek +EPCjjvbdJXsagkqQ +EObjjvbdRMwbZNtz +EPCkKvbdrbGMlHKy +DncLKvbdKfGICApu +EPDLKvbdUtNTfLvK +EPCkKvbdMJCMRYAS +EOcLKvbdCJKbLJFj +DoDKjvbdfpBzvcxI +EObkKvbdYpldhmFR +EOcLKvbdSPsfiecw +DoCjjvbdHEKvKCKK +DnbjjvbdUGzmkwVe +DnbjjvbdfMfXGmJk +DnbkKvbdZoOIeEyj +EObkKvbdZnmhdeZj +EOcKjvbdTkuoBVoJ +EPCjjvbdGKdsChMu +DoDLKvbdJYTahLpp +EPCjjvbdbhmJkFwY +DoDLKvbdkIHMGGOL +EPDKjvbdZsiIxdSn +EPCjjvbdMgCpNQUk +DncLKvbdjblKqGtg +DncLKvbdOYOuzdNt +DncKjvbdTvMPjTaR +EPDLKvbdiiehKNXr +DoCjjvbdZdxGzghb +DoDLKvbdeOdsKssr +DoDLKvbddBsMrAUN +DoCkKvbdxxIjBozL +DoDKjvbddoErkUTr +EOcLKvbdwzIFeweS +DoDLKvbdREDBQRES +EObkKvbdhlEdOUby +DoCjjvbdNPxRWNgT +DoDLKvbdZLqctNlN +EObjjvbdbUbHXkUI +DnbkKvbdhtydwSVC +EPDKjvbdeUAUASmW +EObjjvbdhgKDYvJu +EOcLKvbdZnmhddyj +DoDLKvbdUVlQKUAq +DoDKjvbdDihJvXjA +DnbkKvbdZLrETmlN +EPCjjvbdxxJJbQZk +EPCkKvbdrounjDVf +DoCjjvbddiirVtzn +DoDLKvbdmttyjiqf +DncKjvbdfHjvSNpg +DoCjjvbdmRxuZsEJ +DoCkKvbdjAQGaQGj +DncLKvbdnVUzLJrG +EPCjjvbdLAjgNCXq +DoDLKvbdqmZixlHi +EPDLKvbdVUMsekvK +EPDKjvbdrMzKZMIJ +EPCkKvbdKDKCpicY +EOcLKvbdwtmEqZMO +EPDLKvbdmgFXlnGy +DncKjvbdyTNhlqbH +DncKjvbdnHFXlnHZ +DoDLKvbdTqROuUgm +DoDKjvbdRMwbZOUz +EPDKjvbdRMwbYmtz +DoDKjvbdZnmheEyj +EPCkKvbdbBWEfPow +DoDKjvbdQwNccLgc +DoCjjvbdhtzFWqtb +DoDKjvbdRotHKGEX +DncKjvbdZsiJZETO +EObjjvbdaNKbStlg +DoCkKvbdsZlQTAhO +EObjjvbdjhGlGGNk +EObkKvbdQdDBQQcr +DoDKjvbdMtrrLNAX +EPCjjvbdRotHKGDw +EPCjjvbdqZPIGqDx +EOcLKvbdiGicZViu +DnbjjvbdJvVGEFGi +DoCkKvbdKNAEZfuB +EPDLKvbdLZRJrzuG +DnbkKvbdhytfLpnG +EPDKjvbdRbEEkiYk +EOcLKvbdcJMjLFvx +DncKjvbdFfKRnItR +DoDLKvbdegjurORH +DnbjjvbdEPDKjvcE +EPCjjvbdkHgLeenL +DncLKvbdZnmheEzK +DncKjvbdZjSgpHCG +DoCkKvbdbBVdeoow +DoDLKvbdZQmEhleR +EPDLKvbdpxoHfpcx +EPCkKvbdSPtGjGEX +DncKjvbdRbDeLhxk +EObkKvbdrpWOibvG +DnbjjvbdfIKurNpg +EPDLKvbdZyEKNbkr +DoDLKvbdwXMAvBWV +EOcLKvbdWWiXvDdg +EOcKjvbdelfWfljL +DncLKvbdjuvnEBxX +DncLKvbdliDspuRa +EObjjvbdVTlsekuj +DoCjjvbderAvzlDP +EPDKjvbdNeDtIhkE +Dnbjjvbddwyssqez +EObkKvbdGGKRnItR +DoCkKvbdHbLzEzAD +EPCkKvbdTvMPjUBR +EObjjvbdTAEiIBoE +DoCjjvbdRjxfUgLT +DnbkKvbdnUuZkKRf +EPDLKvbdjmBkydgP +EObkKvbdNeDsiIjd +DncKjvbdrounjDWG +DnbjjvbdrWokbhxq +DoDLKvbdsPvPKDWG +DncKjvbdZdwfzgiC +EOcLKvbdZLqdUNlN +DoCjjvbdkDMLRHVH +EPDKjvbdirziSjiz +EObkKvbduDDUvuno +DoDLKvbdkHgMGGOL +DncLKvbdhkdcmuCy +EObkKvbdCJLCLIej +DnbkKvbdeFPRawCj +DncKjvbdsQVoKDVf +EPDLKvbdRXNccLhD +EObkKvbdFxttaDxC +EObkKvbdqrVKnKaN +EPCjjvbddoEsKtUS +EObjjvbdzaAOffbM +DoCjjvbdWSNxBdlD +EPCjjvbdqlzKYlIJ +EOcLKvbdQdDApRDr +DncKjvbdczZPwyRC +EOcLKvbdtlXwBUBX +EOcKjvbdmgFYNOGy +DoCjjvbdKVtfEFGi +EObkKvbdrNZjZLgi +EOcKjvbdliETqVSB +EOcKjvbdbVBgXkUI +DncLKvbdNHDPmPtk +DnbjjvbdjlakzEfo +EOcKjvbdVUNTfLvK +EPDKjvbdTXjkmzjx +DncLKvbdrylQTBIO +EPCkKvbdJpzEoGOF +DncKjvbdFeiqmhtR +DncLKvbdZnnJFFZj +EPDLKvbdlrZUzTEJ +EPDKjvbdLFfICBRV +EPCjjvbdcyxpXyRC +DoDLKvbdQdCaQQcr +DncLKvbdZsiJZDsO +EObjjvbdzQoNIjXA +DncLKvbdVqmxBdlD +DoDKjvbdRjxfUgLT +EObjjvbdWIYVxHYz +DoCkKvbdIGfzZXxH +DncKjvbdxsNhlqag +DoDKjvbdFWYopNJe +EPDKjvbdVBCRTRSZ +EPDKjvbdwyhFfXeS +DoCjjvbdziuPocsU +EPDKjvbdYSkaNUPY +EObjjvbdznopdcLx +EOcLKvbduMYWaUBX +EPDKjvbdnPzZWKyC +EObkKvbdZxcimbkr +EObkKvbdBhjbKiFj +EOcLKvbdjuwNdBww +EPDKjvbdmbKWxOnV +DoCkKvbdnHFYNNgZ +DoDLKvbdrMzKYkhJ +EOcLKvbdqdFIpNvB +EPDKjvbdcScKtDjB +EOcLKvbdygZMAMdw +EOcLKvbdsCGNLgLZ +DoDLKvbdaMkBsUlg +DncKjvbdlZSqsYft +DnbkKvbdnVUzLKRf +DoCkKvbdnHFXlmgZ +EPDKjvbdxZgfGYFS +DoCkKvbdxwiKCPzL +DnbkKvbdBcpAvKMf +DoCjjvbddZyQXxpb +DncLKvbdzQnmIjXA +EPDKjvbdFWZQQMjF +DnbjjvbdMgDQMpUk +DncLKvbdOFDtIiKd +DoDKjvbdKNAEZfta +EOcKjvbdhyuGMQmf +DnbjjvbdZnmhdeZj +DncLKvbdhbOcFXRR +EOcLKvbdvBEZSoEh +EOcKjvbdYkrEUOLm +EPCkKvbdNrtWGduQ +EPDKjvbdZjSgpHCG +EObkKvbdyzdmrHhh +DoDLKvbdznpQdblY +DncLKvbdZshhyDrn +DnbkKvbdjvWmdCYX +EOcLKvbdAMgxsWzY +DnbjjvbdwzIGGXdr +EPDKjvbdrNZixlIJ +DoDKjvbdsQWOicVf +DoDKjvbdjuvmdBxX +EObkKvbdzHZMANFX +DoDLKvbddjJqutzn +EOcKjvbdwNWAMdFN +DnbkKvbdTqRPUtgm +EOcKjvbdVYgtZkOn +EPDKjvbdNGcPlotk +DnbjjvbdJbjDRJcY +EPDLKvbdZtJIyESn +DoDKjvbdtcCuXVoP +DoCjjvbdZMSETmlN +DoCjjvbdgGLzNfgA +EPDKjvbdxKvcgzyf +EObjjvbdrMzKZMIJ +DncLKvbdMoxQumfs +EPCjjvbdbhlikFvx +DoDLKvbdRadFMJYk +DnbjjvbdHgGzYxYH +EObjjvbdVZHtZkOn +DnbkKvbdakLfPNcA +DoCjjvbdmfeXmOGy +DoDLKvbdrRtjmjaN +DnbjjvbdUxgsyjoO +DnbjjvbdbhlikFvx +EPDLKvbdRbEFMJYk +EOcKjvbdRXNcblHc +DnbkKvbdqmZixlHi +DoCjjvbdrzLpTBIO +DoCjjvbdILaznXRL +EPDLKvbdRjyGVGkT +EOcLKvbdehKurOQg +DncLKvbdYkrDsnLm +DoDKjvbdZisHpGaf +DncLKvbdpyPIGpcx +EOcLKvbdijFhKNYS +EOcKjvbdMuSqkNAX +EObjjvbdajlFnnDA +EOcKjvbduLxXAsaX +DnbjjvbdiiegjMwr +EPCkKvbdiMEdNuCy +EPCkKvbdqTtHSRkU +EPCkKvbdIryBTNXl +DncLKvbdFjdrcHlu +EPDKjvbdZoOIeFZj +DncLKvbdcbTNSATm +DoDKjvbddePSCWcK +DoDKjvbdZsiJYcsO +DoDKjvbdpeceTuaI +EOcKjvbdjhHMGFnL +EOcLKvbdjcLkRGtg +DnbjjvbdCJLCKiFj +EPDLKvbdZsiIxdSn +EObkKvbdVTlsekvK +EObkKvbdCTAcTewS +DoDLKvbdOYOuzcnU +EPCkKvbdiUydwRuC +DncLKvbdGQATXGey +EPDLKvbdDjIJvXjA +DncKjvbdpxoIHQdY +EObkKvbdZMSDsmkm +EOcLKvbdBvzchdov +EOcLKvbdKRZeOenF +DnbkKvbdwzIFfYEr +DnbkKvbdSKyFuHKs +EPDKjvbddCSlrATm +EObkKvbdSCDeMIyL +EPCjjvbdsCFllGjy +DnbjjvbdHgGyyYYH +DncKjvbdjKFgilwr +DncLKvbdEvYoomJe +EObkKvbdlhdTpuSB +DoDKjvbdWWiYVceH +DnbjjvbdLGGHbBQu +EObkKvbdOXoVzcnU +DnbjjvbdbsCjtDjB +DnbjjvbdQwOECkhD +DnbjjvbdMgComQVL +DoCjjvbdRotGjFcw +DnbjjvbdmajWxOmu +EPCkKvbdbPfgDkzd +Dnbjjvbdpxngfpcx +DoCkKvbdBraCtGWr +DncKjvbduDCtwWPP +EPDLKvbdYzcFrKVy +EObjjvbdbVBgXkTh +DnbkKvbdyYIibPyk +DncLKvbdUVlPitAq +EObkKvbdbKlGOnDA +DnbjjvbdrJAKFNPF +EPDLKvbdLAjgMbYR +DoCjjvbdSxLLmzjx +DncKjvbdeEnqawCj +EObkKvbdFWZQPmKF +EOcKjvbdGdKvJbJj +DnbkKvbdjcLjqHUg +EPCjjvbdQvnDcLgc +EPCkKvbddoFTLTtS +DnbkKvbdZtIhyDrn +EPDKjvbdBvzdIdpW +EObjjvbdEYYLstUM +EPCkKvbdyzdnSHiI +EObjjvbdZLqdTmlN +EPDLKvbdIHHZyXwg +DoCkKvbdbVBfxKtI +DnbkKvbdMpYRWOGs +EOcKjvbdczYoxYqC +EPCjjvbddwytTqez +EPCjjvbduaDySoEh +EObkKvbdTJZiqAAl +EObjjvbdmoyyWLYb +EPDKjvbdnPyxukZC +EObjjvbdrWolDJZR +DoCkKvbduCbtvvPP +EPDLKvbdJbicQibx +DncLKvbdHELVibJj +DnbjjvbdKefHbAqV +DncLKvbdsZkpTBHn +DoDKjvbduCcVXWOo +DnbkKvbdidkGtoAO +DnbjjvbdrEFIonWB +EPCkKvbdfpBzwEYI +DncLKvbdwuNFRZMO +EPDLKvbdrounjCvG +DncLKvbdxxJJaoyk +EPCjjvbdJmADzHUa +EPDLKvbdqGEFTvBI +EPDLKvbdyOShYTJD +EPCjjvbdJutecdfi +EPDLKvbdIMBznXQk +DncKjvbdmoyxvKyC +EPDLKvbdrXQMChyR +DoCkKvbddwytUSFz +DncKjvbdZjTHofbG +EPDKjvbdGcjujCJj +EPCkKvbdvBEYsOeI +DncKjvbdCTAcUGWr +EPCkKvbdmbKWwnnV +DnbjjvbdpxnhHREY +EObjjvbdlZTRsYft +DoCjjvbdhkdcmtcZ +EObjjvbdMfcPmPtk +EPCkKvbdJXtCHkpp +DnbjjvbdrSUjmkBN +EOcLKvbdYSlBMtOx +EObjjvbdznopdbkx +DncLKvbdddoSCXDK +DoCjjvbdOXnuzcnU +EPCkKvbdZGwEAOsJ +EOcKjvbdauCGwjtI +EPDLKvbdNHDPmPuL +EOcLKvbdNHCpMpUk +DoCjjvbdmSYtysDi +DncKjvbdFjeTDINV +DncKjvbdNrtWHFUp +EPCjjvbdmJETqUqa +DncKjvbdEzsqEkcJ +EOcLKvbdmoyyVjyC +EOcLKvbdZMSETnMN +EOcLKvbdBsAbtFvr +EPCjjvbdJutfEFHJ +DoCkKvbdiBoDEwRR +EPDLKvbdZQmFImFR +EPDLKvbdpfDdsuaI +DnbkKvbdmbKXYPNu +EObjjvbdjKGHjNXr +EOcLKvbdpssgSRjt +DoDLKvbdKRZePGOF +DnbkKvbdfekymgHA +DoDLKvbdiCOcFWqR +DnbjjvbdiHJbyWKV +DoDKjvbdsCGNMHKy +DoCjjvbdGKeSbgmV +DoDLKvbdkIGkfFnL +DncKjvbdfILWRnRH +DoDKjvbdGLEsChNV +EPCjjvbdVrNxBeMD +EPDKjvbdSLZGVHKs +EPDLKvbdQlxByOUz +EOcLKvbdMgDQNQVL +DoDLKvbdrRtjnLAm +EObjjvbdCIkBjhfK +DncKjvbdDwwlTssl +DoDLKvbdANIYsWzY +DnbjjvbdxVMdqYkn +DoCkKvbdzdynzdzQ +DnbjjvbdxsNhmRag +EObjjvbdzjVQPcrt +DoCkKvbdbBWFFopX +EPDKjvbdhfibxvKV +DnbkKvbdegjvRmqH +EPCjjvbdkNCMZdgP +EOcLKvbdmtuZkJqf +EObjjvbdemFvfljL +DncLKvbdyYIibPyk +EObjjvbdieKftoAO +DncKjvbdvOszqKoU +DncLKvbdVUNTelWK +EOcKjvbdCDoaWKMf +EPCkKvbdbsDKtDjB +EPDLKvbdmSYuZsDi +DncLKvbdwWlBWBWV +EObjjvbdkVwOEBww +EObkKvbdWSNwbFLc +DnbjjvbdZRNFImEq +DoDKjvbdrounjDVf +EPDKjvbdCJKbKhej +DncKjvbdsrrTYyeD +DoCjjvbdQvnEDMHc +DoCkKvbdGQASwGfZ +EOcLKvbdfSBWzkbo +DoDLKvbdRkZGVGkT +EOcKjvbdyXhjCPzL +EPCkKvbdbrbkTdJa +EPDLKvbdsQVnibvG +DnbjjvbdpyOgfpdY +DoDLKvbdtunXiqTA +EPDKjvbdqGDdsvAh +DncKjvbdjEkHUoAO +EPCjjvbdGQATXGfZ +EOcKjvbdKDJcRKCx +DncKjvbdhyuGMQnG +DoCkKvbdYkrDsnMN +DoCjjvbdaNKbSuMg +EOcLKvbdrykpTAhO +DnbkKvbdrSUkNkAm +EPCjjvbdwzHeeweS +DoDLKvbdSBdFMJYk +DnbjjvbdqUUGrRjt +DoDKjvbdzitoocrt +EPDKjvbdxnShXriD +DoCkKvbdVviXvEEg +EObkKvbdFxuUaDxC +EObkKvbdygZMAMeX +DnbjjvbdiifHilxS +EPDKjvbdZxcjODMS +DoDLKvbdWWhxWEFH +EPCjjvbdzoQQeClY +EOcLKvbdptUHRqjt +DoDKjvbdVviXudEg +EPDLKvbdUQpnuVHm +EPCjjvbdwzHfFweS +EOcLKvbdZxcjNbkr +EObkKvbdZnmhddyj +DoDLKvbdvlvANDdm +EOcKjvbdMfbolpVL +EObjjvbdbAvFFpQX +EOcKjvbdBdPaWJlf +DncKjvbdqceIonWB +DoCkKvbdtcDVWvOo +DoCkKvbddoFTKssr +DoDKjvbdaMkBruMg +EPCjjvbdEuyPolie +DnbkKvbdOEcsiJLE +DncKjvbdHlBznWqL +EPDKjvbdbhlijewY +EObjjvbdfoazwDwh +EOcLKvbdaNKbStlg +DoCkKvbdqdEiQOWB +DoCkKvbdTvLpKUBR +DncKjvbdkNBkzFHP +EObkKvbdFkErcHlu +DoCkKvbdZshiYcrn +EObjjvbdEJhJvYKA +DnbkKvbdOTUWHFUp +DoDLKvbdVhXvXfxz +EPDLKvbdBdPaWKMf +EObjjvbdFejRnJTq +EPDLKvbdULvPBVoJ +EPDKjvbdJzpFwdAN +EPDKjvbdqwPkbiZR +EPDLKvbdrEFIomua +EOcLKvbdijFhJlxS +DnbkKvbdYkrEUOLm +DnbkKvbdIMBznXQk +DncKjvbdZisHpHCG +EPDLKvbdzjUopESt +DnbjjvbdzjUpPcrt +EPDKjvbdqZOgfpdY +DoDKjvbduLxXAsaX +EObkKvbdrMyiyMHi +EPCkKvbdqTsfqrKt +DoDKjvbdTfznMXVe +EObkKvbddoErkUTr +EOcLKvbdHELWKCJj +DncLKvbdUVkpJtAq +EPCjjvbdRMxBxmtz +EPDKjvbdjEjftoAO +EOcLKvbdYkrDsmkm +DoDLKvbdajlFoNcA +DoCjjvbdmJDtRUqa +EPDKjvbdTqQoUuIN +DnbkKvbdtcDUvvPP +DncLKvbdrbGMlHLZ +DnbkKvbdKfGHbApu +DncLKvbdGFjRnIsq +EPDLKvbdJzpGYEAN +DoCjjvbdkySrSyHU +EObjjvbdKVtfDdfi +EPDKjvbdNrsugFUp +DoCkKvbdNxOuzcmt +DoDLKvbdDihJuxKA +DnbkKvbdzdzOzdzQ +DncKjvbdmSYuZrci +EOcLKvbdptTfqqkU +EPCkKvbdVUNTfLvK +DoCkKvbdGdKujBjK +DoCjjvbdzitopETU +DoDKjvbdqvokbiYq +EPDLKvbdGFjSOJTq +DoDKjvbdliETqUrB +DoDKjvbdZisIQGbG +DoCjjvbdnQZyWLZC +EOcLKvbdGdKujCJj +EPCkKvbdaRfDIUGL +EOcKjvbdauCHXjtI +DnbkKvbdbQHHDkzd +DoCjjvbddZxpYYpb +EObkKvbdbBWEepPw +DncKjvbdSLYfVGkT +EObkKvbdVgxVxHYz +DoCjjvbdfpBzwEYI +DoDKjvbdmfdxMmfy +DncKjvbdhancEwRR +DnbkKvbdEASJMzXX +EObjjvbdmfdwmNfy +DnbjjvbdhbOcFXQq +DoCjjvbdVgxVxGxz +EPCkKvbdQcbaQQdS +EPCjjvbdhbObeXRR +EPDKjvbdePFSkUTr +EPDLKvbdMoxQumgT +DoCkKvbdIBkydzAD +EOcLKvbdcasMrAUN +DoCkKvbdUQqOttgm +DnbkKvbdelevfljL +EObjjvbdZeXfzgiC +EPCjjvbdQYmAGrrK +EObjjvbdxZhGFxFS +EObjjvbdJuuGEEgJ +DoDLKvbdEARhlyvw +EPDKjvbdZdxGzhJC +DoCkKvbdzRPMhiwA +DoCkKvbdZxcinClS +EOcKjvbdFyVVBEYC +EOcLKvbdtbcUwVoP +DncLKvbdlZSrTYft +EObkKvbdaaVeGPow +DncLKvbdEKIJvXjA +DncLKvbdbhljKfWx +EObkKvbdVhYVxGxz +EPDKjvbdmpZxukZC +DoDLKvbdnBivxOnV +EObjjvbdRbEEkiZL +EPCkKvbdZRNFIleR +DoDLKvbdZyEJmblS +DncKjvbdkIGkefNk +EPDKjvbdRkZGVGjs +DnbkKvbdiHJbyVjV +EPDLKvbdFjeSbglu +DncLKvbdqFcdtVaI +EOcKjvbdGYuVAdYC +DoCjjvbduaEZSneI +DnbjjvbdKWVFdFHJ +EObjjvbdGdLVjCJj +DnbkKvbdpssgSSKt +DoCjjvbdssRryZdc +EPDKjvbdZisIQHCG +EOcKjvbdCIjajhfK +DoDKjvbdrafNMGjy +EObkKvbdgQBzwEXh +DnbjjvbdgQBzwDwh +DncKjvbdCEQAvKMf +EPCkKvbdiCOcFWpq +EPDLKvbdLFfHbBQu +EPCjjvbdJTYaSmXl +EPCjjvbdRjyFuGkT +DoCkKvbdjFKftoAO +DncKjvbdmaiwXoNu +DoCjjvbdVZITyjnn +DoDLKvbdDxYLtUTl +DnbjjvbdqvpLcJYq +EOcLKvbdlqxuZsDi +DoDKjvbdZshhyDsO +DoCjjvbdGFjSOIsq +DnbkKvbdcScKtEKB +EPCjjvbdMpXqVmfs +EPCjjvbduoTzpjoU +DoDLKvbdYkqctNkm +EObkKvbddoErjstS +DnbjjvbduLxWaUAw +DoCkKvbdRXODbkgc +DoCjjvbdwzIGFweS +DoCkKvbdZyEKOClS +EObjjvbdiGjCxvJu +EObkKvbdbiMijewY +DoDKjvbdqrVKmkBN +DoCkKvbdFyUuBEYC +DoDLKvbdNsTufduQ +DoDLKvbdEPCkKvcE +DoDLKvbdNQYRWNgT +DnbjjvbdNrtWGeUp +DoCjjvbdPxmAGrqj +EPDKjvbdKNAEZgVB +EPDKjvbdmttzKjSG +EPDKjvbdssSSxydc +DoCjjvbdTlWPAuni +EObjjvbdDHLegAzc +EObjjvbdXnRAXtvU +EObkKvbdKfFgaaQu +EOcKjvbdhtzFXSUb +EPCkKvbdJTZAsMwl +EOcKjvbdQYmAGsSK +DoCkKvbdjhHLeemk +EOcLKvbdiifIJmYS +EPDKjvbdLrWlzVQz +DoCjjvbdxsOIlrBg +EPDLKvbdNPxQvNfs +DnbkKvbdIGfyxwxH +DoCjjvbdjKFhKMwr +DnbjjvbddjKSVtzn +DoCjjvbdZoNiFEzK +EPCjjvbdeFOqavcK +DoDLKvbdEuxpQMie +EObjjvbdZjShQHCG +DoDLKvbdZMSDsmkm +DoDLKvbdGYtuBEYC +EPCjjvbdUaBprqRy +EOcLKvbdmozZWLZC +DncLKvbdUWLpKUBR +EPCjjvbdqYnhHQcx +DoDLKvbdUaBprpqy +EPDKjvbdrzMQSaHn +DnbjjvbdGdLWKCJj +EObkKvbdfILVrNqH +EPCjjvbdehKvRmqH +EPDKjvbdOSsvGeVQ +DncLKvbdxxJJaozL +EPCjjvbdZLqctNkm +EOcLKvbdZxcinCkr +DncLKvbdkWWmcbXw +DoDLKvbduCcVXWPP +DncLKvbdyTNhlqbH +DncKjvbdYTMAlsoY +DoCkKvbdRosfjFcw +EPDLKvbdDwxLsstM +EOcKjvbdlZTRryHU +DoCjjvbdNGbpMpVL +EOcLKvbdYgWdAOri +DoCjjvbdDxYLstTl +EObjjvbdIwtBglRQ +EOcKjvbdvPTzpkPU +DoCjjvbduLxXAtBX +DoCjjvbdiLeENuCy +DnbjjvbdUaCRSqRy +DnbjjvbdYpmEhleR +EObjjvbdsPvOjDWG +DoCkKvbdLFfICApu +DncKjvbddxZstRez +EPCkKvbdFyVVAdXb +DoCjjvbdFyVVBDxC +DoDLKvbdFeirNiTq +EPCjjvbdxnSgxTIc +EOcKjvbdAMgySwZx +EObkKvbdkyTRryHU +DoCkKvbdMRwMzUpz +DnbjjvbdCWzdJEov +DoCkKvbdUyITzLPO +EPCkKvbdcSbjsdKB +DoCkKvbdqceIonVa +DoCkKvbdjmCMZeGo +DncKjvbdfMewGljL +EObkKvbdpfEEtVaI +DoDLKvbdczZQYYqC +DoDLKvbdRNXbYmtz +EObjjvbdTvLojUBR +EPCkKvbdtbcVXWPP +DncLKvbdmSYuZrdJ +DoDLKvbdTukpKUBR +EPDLKvbdsQVoKCvG +EPDLKvbdBraCtFvr +EPDLKvbdZQmEiNEq +EPCjjvbdrzLosAgn +EPCjjvbdssRsZZdc +DncKjvbdbAudepQX +DncKjvbdcTDKscia +DncLKvbdlqyVZsEJ +EOcLKvbdbVCHXkTh +EObkKvbdYTMBMsnx +DnbjjvbdULvPAuoJ +DoCjjvbddtAUASlv +DoDKjvbdxUmEpxkn +DncKjvbdQwOEDLgc +DoCkKvbdSPsgKGDw +DncKjvbdiCOcFXQq +EPDKjvbdRkYfUfkT +EObkKvbdKCjDRJcY +DoCjjvbdZLqctOMN +EPCjjvbdUWLpKTaR +EPCjjvbdLqwMzVQz +DnbjjvbdnBivxPNu +EObkKvbdRpUHKFdX +EPCjjvbdeATqNXif +DoCjjvbdfILVrOQg +DoDKjvbdNrtVfeUp +EOcLKvbdNUrrKmAX +EPCjjvbdrbFllHLZ +DncKjvbdkDMLQgUg +DoCkKvbdVvhwvDeH +DnbjjvbdKeegaaRV +DoDKjvbdcJMjKfXY +DnbjjvbdZtJJYcrn +DoDLKvbdyqOliJwA +DoDLKvbdMgDPmPuL +DoCkKvbdHffzZXxH +DoCjjvbdZxdKNblS +EPDKjvbdkDLjqGtg +EPDKjvbdYzbeqjVy +DncLKvbdTppnttgm +EObkKvbdVYgtZjnn +EPCjjvbdzaAOgHCM +EOcKjvbdcyxoxZRC +EPDLKvbdxnSgxTJD +EObkKvbdfMfXHNJk +EPDKjvbdunszpjoU +EObkKvbdFfKRmhsq +EOcLKvbdhtydwRtb +DoDLKvbdYkrDsnLm +EPDLKvbdGGKSOItR +EPCkKvbduDCuXVno +EPDLKvbdrEFJQOVa +EPDLKvbdIjEAKQGd +EObjjvbdIryArmYM +DoDLKvbdYkqctOMN +EPCkKvbdiZtekqOG +DncKjvbdzdzOzeZp +DoDLKvbdbiNKLFwY +DnbkKvbdlhcsqUrB +DnbkKvbdKyRJrzuG +DoDKjvbdOFDtIiKd +DnbjjvbdvvlBWBVu +DnbkKvbdlrZUyrdJ +EObkKvbdxZgeewdr +DncKjvbdegkVrNpg +DoCjjvbdrJAJeNPF +EObjjvbdmfeXmOHZ +DoCjjvbdNPwqVmfs +DnbjjvbdnPzYvLZC +EPDKjvbdZshiYcrn +EOcLKvbdhgJcYvJu +DoDLKvbdXrlAmToY +DnbkKvbdwWlAvBVu +DnbkKvbdjvWnEBww +DoDLKvbdTYLLmzjx +EOcKjvbdDihJuxKA +DncLKvbdTfznLvue +DoCjjvbdVgwvXgYz +EObjjvbdsBfMkgKy +EPCjjvbdUaBqTQrZ +DnbjjvbdbhmJkGWx +EPCjjvbdLBLGmCYR +DoDKjvbdwjwEHzyf +EPDLKvbdegkVrNpg +DoCkKvbdJpzEnfOF +EPCkKvbdFejSOItR +DnbjjvbdTqQnuUhN +EOcLKvbdUMVoAvOi +EPCkKvbdSCEFLiZL +EPCkKvbdnCKXYPNu +EPDLKvbdZyEKNbkr +DncLKvbdZisIQGaf +EObjjvbdGLEsDHmV +DoCjjvbdBcpAujNG +EObjjvbdZRNFIleR +DnbjjvbdVrOXaeLc +EPCjjvbdHELViaij +EOcLKvbdqcdhpNvB +EPCkKvbdiZuFkqOG +DoCkKvbdOSsufeVQ +DoDLKvbduoTzpjnt +EOcLKvbdTqRPUuHm +DoDLKvbdCDpAuilf +EOcKjvbdZMSDsnMN +DoDLKvbdYqNFJMeR +DnbkKvbdbAvFFpPw +EOcKjvbdVqmwaeMD +EPCkKvbdUyHsyjnn +EPCjjvbdKeehBaQu +DoCjjvbdZshiYdTO +EObkKvbdTvMQJsaR +EPCjjvbdjblKqHUg +DnbkKvbdYlSDtOMN +EObkKvbdrWpMCiZR +EOcKjvbdUGzmlWue +DncKjvbdFyUuAcwb +EPCkKvbdLZQjSztf +EPCjjvbdfjfzbfAE +DncKjvbdFWZQQMie +DoCjjvbdVgxVxHYz +EOcKjvbdWWhxWEFH +DoDLKvbdUWLoitAq +DoDLKvbdzaAOffbM +EOcLKvbdrXPkbiYq +DoCkKvbdYzberKVy +DncLKvbdIMBznWpk +EPCkKvbdEPCkKwDE +DnbkKvbdWWiYVcdg +DoCkKvbdCWzchdpW +EOcLKvbdjvXNcbYX +EPDLKvbdSxLMNzjx +DnbjjvbdhficYuiu +DncLKvbdvmWAMdEm +EObjjvbduaDyTOdh +DncKjvbdwWlAvBWV +DoDKjvbdVviYWDeH +EOcKjvbdNsUWGdtp +DoCjjvbdzjVPodTU +EPCkKvbdmIcsptqa +EPDLKvbdIHHZxxYH +EPDLKvbdUyIUZkPO +EObkKvbdCDpBWJlf +EPDKjvbdWSNwaeMD +DoCjjvbdACrXjZhp +EPDLKvbdwuMdqYlO +DnbjjvbdHlBznWpk +DnbjjvbduaDyTPEh +DnbjjvbdwuNFRZLn +EObjjvbdajkfOnDA +DnbkKvbdWWiYWEEg +EPDLKvbdffLymgHA +EOcLKvbdkDMKpfuH +EPDLKvbdMoxQvOHT +DnbkKvbdbKkenmcA +DoCjjvbdhytfMRNf +DoCjjvbdIsZAsNXl +DoDKjvbdLiBkqYAS +DncLKvbdyzdmrHiI +DnbjjvbdemFvfmJk +EOcLKvbdSCEEkiYk +DoDKjvbdbiNKKevx +DoDLKvbdaaVdeoow +DnbjjvbdNGcQNPuL +DncLKvbdQYmAGrrK +EPDKjvbdrbGMkfjy +EPCjjvbdZjShPfbG +DnbjjvbdJmADyfuB +DnbjjvbdhtzFWquC +DnbjjvbdQvmdDMID +DncLKvbdjvWnEBww +EPCjjvbdxZgfGXdr +EObkKvbdDihKWXjA +EPCkKvbdZMSETnLm +EPDKjvbdZLqcsnMN +EObkKvbdqwPlDJZR +DoDKjvbdZisIQGaf +EObjjvbdjlalZeGo +DncKjvbdxsOJMqag +DoDKjvbdOFEUIhkE +DoCkKvbdzitoodSt +DncLKvbdVrNwaeMD +DoCjjvbdezuyEiTw +EPDKjvbdiCOcEvpq +DoCjjvbdvvlAvAvV +DnbjjvbdJuuFceHJ +DoCjjvbdlYrrSyGt +EPCkKvbdfILVrNqH +DoDLKvbdxsOJNRbH +DncKjvbdIwtBgkpp +DnbkKvbdOTUWHEtp +EPDKjvbdFejRnIsq +DnbjjvbdVBCRTQrZ +EPCjjvbdiMEcnUcZ +EObkKvbdiZuGMRNf +EOcKjvbdatbHYLTh +DoCkKvbdmSZVZrdJ +DoDKjvbdqTsgRqjt +DoDLKvbdCEQBWKNG +DnbjjvbdZtJJZESn +DncLKvbdIHGzZXwg +EPDLKvbdwtmFRZMO +DoCjjvbdKDJbqJcY +EObkKvbdatbHXkUI +DnbkKvbdYqNEhleR +EObjjvbdNHColotk +EPDKjvbdegkWSNpg +DoDLKvbdRjyFtfjs +DoCjjvbddoEsKtUS +EOcLKvbdsQWOjCvG +DoCkKvbdvAcxsOeI +EObjjvbdbAueGQQX +EOcLKvbdxKwEHzzG +DoDKjvbdqTtHSRkU +EOcKjvbdOAIsUKSA +EPCjjvbdWSNxCElD +EPDLKvbdnCKWwoNu +DncLKvbdEARiMzXX +DoCkKvbdbAvEeoow +EOcKjvbdhgJcYvJu +DnbjjvbdTulPisaR +DnbjjvbdIidAKQGd +EPDKjvbdyOTIXrhc +EPCkKvbdrbFmLgLZ +EPCjjvbddeOqbXDK +DncKjvbdRacdlJZL +EOcLKvbdbsDKtDjB +EPCjjvbdUyHtZkOn +EObkKvbdyTOImSBg +DncKjvbdtbbtwWPP +EPDKjvbdKDKDRJcY +EObjjvbdhanbeXQq +EOcLKvbdvvlAuaWV +EPDLKvbdVYgsyjoO +EPDLKvbdKaKflawq +EOcLKvbdCIjajiFj +EObkKvbdUsmUGMWK +EPDLKvbdIjEAJofd +EOcLKvbdqBJFAWhE +EPCkKvbdEJgivXjA +DnbkKvbdYkqdTmkm +EPCkKvbdliDsqUrB +EObjjvbdKVtfEEfi +EObkKvbdmgFYMmgZ +EObjjvbdEARhlyvw +DncKjvbdaRecHtGL +DnbjjvbdNQYRVmfs +EOcLKvbdFfKRnJTq +DncLKvbdMgDQNQUk +EObkKvbdHgGyyXwg +EPCkKvbdCJKbKiFj +EPCkKvbdBraDUGXS +EPDLKvbdiMEcnVCy +DoDLKvbdkCkkQfuH +EOcLKvbdwtmFRZLn +EPDKjvbdKefHbApu +DnbkKvbdkxrqsZGt +EPCkKvbdfIKvRmqH +EOcKjvbdDnbkLWbd +EPDLKvbdaRebhTek +DoDLKvbdjuwODaxX +DnbjjvbdREDBPpdS +DncLKvbdjuwNcaww +EOcKjvbdbiMjKevx +EPDKjvbdqvpLcIyR +EPCjjvbdijGIKMxS +EPDLKvbdQmYCZNtz +EObjjvbdCDpAvKMf +EOcLKvbdJJdAKPgE +DoDKjvbdUxgszLOn +DnbjjvbdOEcshhjd +DoCjjvbdUaCRSprZ +EPCkKvbdxmrhYTJD +EPDKjvbdICLydzAD +EPCjjvbdKRZdoFme +EObkKvbdNdctJIjd +EPCjjvbdKVuFdEgJ +EObjjvbdrXPlDIyR +DoCkKvbdfMewGmKL +DnbkKvbdIwsahMQp +EOcLKvbdRaceMIxk +EPCkKvbdcyxoxZQb +EObjjvbdRkYeuGkT +DncLKvbdbVBfwkTh +EObjjvbdTppoVUhN +EPCjjvbdhytfMROG +EOcKjvbdUxgszKoO +DoCjjvbdGLEsDHlu +EObkKvbdegkVqmqH +DncKjvbdkMbLyeGo +DncKjvbdyzdmqghh +EPCkKvbdGFiqnIsq +EPDKjvbdpstGqqjt +EPDKjvbdYkrDsmkm +EPCkKvbdKaLGlbXq +DoCkKvbdxwiJbPyk +EPCkKvbdJcKDQibx +EPCkKvbduDCuXWPP +DnbjjvbdiGicZWKV +DoCkKvbdsPunicWG +DnbjjvbdKNAEZgVB +EPDLKvbdnPyxujyC +EObkKvbdJXsagkpp +EObkKvbdNddUIiKd +DnbjjvbdQwOEClID +DnbkKvbdFVxpQMie +EPCkKvbdVrNxBeLc +EPCjjvbdUsmUGLuj +EPDLKvbdGZVVBDwb +DoCjjvbdmRyUyrdJ +DncKjvbddZxoxZQb +DnbjjvbdGKdsDINV +EObjjvbdrafNLgKy +DoCjjvbdJbjCqJbx +DnbjjvbdlYsSTYgU +DoCkKvbdQvnDblID +DoDKjvbdssSTYzFD +DncKjvbdmozZVkZC +EPDKjvbdjbkkRGuH +DoDLKvbdxmrgwriD +DoDKjvbdfHkVrORH +EPCkKvbdJuuFceHJ +DoDKjvbdcbSlrATm +EPCkKvbdeATpmXif +DncLKvbdBiKajhej +EPCkKvbdrNZixlIJ +EPDLKvbdKVteceGi +EObkKvbdzjVPodTU +DoDLKvbdWSNxCEkc +EOcKjvbdZxcimcLr +EOcKjvbdZnnIeEyj +DnbkKvbdmbKWxPOV +EPCkKvbdZLrETmkm +EPDKjvbdnUtyjiqf +DoCkKvbdrWpLcJZR +DoCkKvbdaMkCStmH +DncLKvbdFVxpQMie +EPCjjvbdrpWOicWG +EOcKjvbdyOTIYShc +EObkKvbdqrVLNkBN +EOcLKvbdQvnDbkhD +EOcLKvbdDigiuxKA +DncLKvbddoErkTtS +DoDKjvbdRWmdDLgc +EPCjjvbdiHKDZVjV +DnbkKvbdADSYKZiQ +DnbkKvbdsPunibuf +DoCjjvbdSPsfiedX +EPDKjvbdJmAEZfta +EOcKjvbdZMRcsnLm +DoCkKvbdiLddOUcZ +EObkKvbdqqtkOLAm +DoDLKvbdYpmFImFR +EObjjvbdVhYWXfxz +DnbjjvbdMowqWNfs +EObkKvbdVgwuwgYz +DoDKjvbdDxYLsssl +DnbjjvbdZtIiYcsO +DnbkKvbdxwiKBpZk +DoDKjvbdEuxpPmKF +EOcKjvbdJcKDRKCx +EObkKvbdUtNUFlWK +EOcKjvbdjhHLfFnL +DoCkKvbdSQTgKGDw +DncLKvbdQccBQRDr +DncLKvbdILazmwRL +DoDKjvbdYTMBNUPY +DoDLKvbdKaKfmCXq +EPCjjvbdkIHMGGOL +DnbjjvbdCIjbKhfK +DnbkKvbdVgwuwfxz +EPCjjvbdwtmFQxkn +EPDLKvbdcyyQYZRC +DoDKjvbdPyNAGsRj +EObjjvbdSLYetgLT +DoDLKvbdMRwNZuQz +DncKjvbdFjdrcHlu +DoCjjvbdZyDimbkr +DnbkKvbdRXNdClID +EObjjvbdEYYLtUTl +EObkKvbdVqmxBdlD +DoDLKvbdptTgRqkU +EOcLKvbdBdPaWKMf +EPCjjvbdiBncEvpq +DoDLKvbdzQoNJKXA +DoDKjvbdUQpoUtgm +DnbkKvbdrzLpTBHn +DoCjjvbdunszpkPU +EPDLKvbdSZjHsCvA +DncKjvbdRotHJfDw +DnbkKvbdFejSOItR +EOcKjvbdeFOrBwCj +DoDLKvbdkVwNdCXw +EPCkKvbdeOdrjtTr +EPCjjvbdhuZdwRuC +DnbkKvbdfILVqmqH +DncKjvbdnPzYvLYb +DncKjvbdHgGzZYXg +DncKjvbdkVwNcaxX +DoDLKvbdOAJSsjSA +DncKjvbdOFDtJIjd +EOcLKvbdVgwvYGxz +EObkKvbdsQVnjDWG +DoCjjvbdZjShQHCG +DncKjvbdzoPpeCkx +DoDLKvbdSLZFtfjs +DnbkKvbdBsBCtFvr +EOcLKvbdFyUuAcwb +DnbjjvbdqUTfqrKt +DoCjjvbdZxdJmcLr +DncLKvbdmbJwYPOV +EObjjvbdEObjkXDE +EOcKjvbdaSFcIUGL +EPCkKvbdqYoIHQcx +EOcKjvbdfNGWgMjL +DoCjjvbdbrcKtEKB +EPCkKvbdvBDxsOdh +DnbjjvbdtcCuXVoP +DnbjjvbdrpWPKDVf +EOcKjvbdwyhFfYFS +EPCjjvbdnPyyWLZC +EPDLKvbduMYXBUAw +DoDKjvbduaDySoFI +DoCjjvbdyXiKCPzL +DncLKvbdGFjSOIsq +DoDLKvbdeEoRbXDK +DncLKvbdcTCjtDia +DnbjjvbdnUuZjiqf +DnbjjvbdjlakzFHP +EOcLKvbdwWlBWAvV +DnbkKvbdWWiXuceH +EObkKvbdemGWfmKL +EObkKvbdmuUykJrG +DoCkKvbdmozYvKxb +DncKjvbdQZNAGsSK +EObjjvbdjblKpgUg +DncKjvbdSZigsDWA +EOcLKvbdZyEJmblS +DoCjjvbdnCJwYOmu +EPDKjvbdtkxWaTaX +EPDKjvbdGZUuAcwb +DoCkKvbdyfxlANEw +EPCkKvbdTAFJIBnd +DncKjvbdZLqctOMN +DncKjvbdUMWPBWPJ +EPCkKvbdDwwksstM +EPDKjvbdEObjjvbd +EObjjvbdWXJYWEEg +DnbjjvbdpaIeAXIE +DoCjjvbdqYoIHREY +DnbjjvbdvmWAMceN +EObkKvbdLFfHaaQu +EOcLKvbdpaIeAWgd +EPDLKvbdkCkkQgUg +DnbjjvbdePErkTtS +DnbkKvbdNGbomQVL +DoDLKvbdEPCjkWcE +DoCkKvbdehLWRnRH +EOcKjvbdyXhibQZk +EOcLKvbdZyEKOCkr +DoCjjvbdkDLkRGtg +DoDLKvbdkaNPNALA +EObkKvbdrWpLbiYq +DoDLKvbdfHkVqmqH +DoDLKvbdEOcLKwCd +DoDKjvbdrykpTBHn +DncKjvbdxZgefYFS +DnbkKvbdJpzFPFnF +DoCkKvbdNGcPmPtk +EPCjjvbdhzUelRNf +EObkKvbdVTltFlWK +DoCkKvbduaDxrneI +EObkKvbdSQTgJfEX +EOcKjvbdVhYVxHYz +EOcKjvbdkCkkQgUg +EObkKvbdqUUHSSLU +EOcLKvbduLwwAtAw +EPDKjvbdZLrETnMN +EObkKvbdmttyjjRf +DoDKjvbdYqMdiMdq +DoCkKvbdkNBkzEfo +DncKjvbdiLeDnUcZ +DoDKjvbdZLrDsnLm +EPCkKvbduVnYKRTA +EPCjjvbdCIkCLJFj +EPDKjvbdssRrxyeD +DncKjvbdQwOEClHc +EPCkKvbdwXLaWAuu +EPCkKvbdUyHszKoO +EPCkKvbdJYTagkqQ +DoCkKvbdwuNFRYlO +EPCjjvbdfHkWRmqH +EOcKjvbddeOqbXCj +EObkKvbdhficYujV +EPCkKvbdmSYtzTEJ +EPCjjvbdtkxWaTaX +EPDLKvbdwygfGYEr +EPDKjvbdmpZxvKyC +DoCjjvbdpstGrSLU +EPDKjvbdUtMtGLuj +EOcKjvbdjlbLzFGo +EObkKvbdkyTSTZGt +EOcLKvbdLYpjSzuG +EPDLKvbdyXhibQZk +DncKjvbdptUHSRkU +DnbjjvbdFfKRmhtR +DoCjjvbdtbcUwVoP +EPDKjvbdhyuFkpnG +EPDLKvbdFpASwHFy +EPCjjvbdRbDeLiYk +DncLKvbdXmqAYUut +EObjjvbdqlyjZLgi +DoCjjvbdssSTYydc +DnbkKvbdTIzJqABM +EPCkKvbdxsOJNRag +EPCjjvbdlhcspuSB +EObkKvbdqUTgSRjt +EOcKjvbdOEcshhkE +EObjjvbdzjUpPdTU +DnbkKvbdvwLaVaWV +EPCjjvbdmoyyVkYb +DoCkKvbdOFETiJKd +EPCjjvbdeEnqawCj +EObjjvbdmuUzKjRf +EPDLKvbdVvhxVdFH +EPCkKvbdaSGDHsek +EPCjjvbdkySrTZHU +EObjjvbdtAGqIABS +EObkKvbdZyEJmblS +DncKjvbdyTOJMrCH +DncLKvbdFWYoolie +DoDLKvbdTvMPjUAq +EObjjvbdZLqctOLm +DnbkKvbdmIctQuSB +DoCkKvbdZGvdAPTJ +DoCjjvbdkDMLRGuH +DoDLKvbdnVUykKSG +DoDKjvbdLGFhBaRV +DncLKvbdxwiKBozL +DncLKvbdWIYWXgYz +DncLKvbdFkFSbglu +DoDKjvbdIGgZxxXg +DnbjjvbdEztRFMDJ +DoDLKvbdZQldiNEq +EOcLKvbdwWkaWAvV +DoDKjvbdLBLHMawq +DoDLKvbdkMbLzFGo +EPDKjvbdREDAopcr +DoCkKvbdZoNiEdyj +EPDLKvbddneSkUUS +DnbkKvbdSQUHJecw +DoCjjvbdZshhxcrn +DnbjjvbdRkZFuHLT +EPDKjvbdwuNEqYkn +DoDLKvbdemGXGmJk +EOcLKvbdKWVGDeGi +DoCkKvbdWSOXadkc +EObjjvbdVTmTelWK +DncKjvbdhkeDmuDZ +EPCkKvbdRWnEDMID +DnbjjvbdNQYRVnGs +DnbkKvbdTfzmlWvF +DoCkKvbdFpASvgGZ +DoCjjvbdqTsfqqkU +EObkKvbdUVkpKUAq +DoDLKvbdrRtkNjaN +EPCkKvbdrJAKEmOe +DncKjvbdIGfyyYXg +DnbjjvbdZLrDtNkm +EObjjvbdiMEcmuCy +DncKjvbdkyTSTZHU +DncLKvbdBsAbtFvr +DnbkKvbdrpWPKDWG +DncKjvbdbBWFFoow +DoDLKvbdxmsIXsJD +DnbkKvbdehLWRnRH +EObkKvbdiVZeXRuC +DnbkKvbdOTUVfduQ +DncLKvbdZjTIQHCG +DoDLKvbdOSsugFVQ +DoCjjvbdrafNLgKy +EPDLKvbdNPxRVmgT +EPDKjvbdHlBznXQk +EPCkKvbdCEQBWKMf +EObjjvbdtcDUwWOo +DoCjjvbdZMSDtNlN +DoDLKvbdvAcxrneI +EObjjvbdIxUCILpp +EOcKjvbdfSBWzkbo +EObkKvbdShzKRAAl +DnbjjvbdGZUuBDxC +EObkKvbdqlzKYkhJ +EPDKjvbdZyEKNbkr +DoDLKvbdsrrTYzFD +DoCkKvbdfSAvzkcP +DnbjjvbdqlzKYlHi +EPDKjvbdYTLaNToY +EPCjjvbdjEjgUoAO +EOcKjvbdTJZjRABM +EObkKvbdYORAXtvU +DoDLKvbdGKdrcHmV +DoDLKvbdbrcLUEJa +DncLKvbdqvpLcJZR +DnbkKvbdFeiqnIsq +EPDKjvbdZnnIeEzK +EPCjjvbdnUtzLKRf +DoDLKvbdDxXlUUTl +DoDKjvbdiMEcnUby +EObkKvbdYzbeqjWZ +DncKjvbdTvLojUAq +EOcLKvbdjuvmdBxX +DnbjjvbdzoPpdcMY +DoDKjvbdrovOibuf +DoDKjvbdFWZPomJe +DoDKjvbdqGDeUWBI +DoCkKvbdWWiYVdEg +EObkKvbdtvOXiqTA +DnbjjvbdqZPIGpdY +EObkKvbdLBKgNCYR +DoCjjvbdLBKgNCYR +EObjjvbdZsiJZESn +DoCkKvbdTqROtuIN +EPCjjvbdyfyMAMdw +EOcLKvbdptTgSSLU +DncLKvbdPxmAHTSK +DnbjjvbdRkZFtfkT +EPDLKvbdtlXvaUAw +EPCkKvbdqBJFAWhE +EPCkKvbdIidAJogE +EPDLKvbdKQydoGOF +EObkKvbdauCGwkTh +EPCjjvbdNddUIiKd +DoDLKvbdFfKRmhsq +EPCkKvbdeEnqbXCj +EObkKvbdJvVGDdfi +DoDKjvbdWRmwaeLc +EObkKvbdSCDeLiZL +EPDKjvbdDoDLLWcE +EPDLKvbdiMEcnUby +DnbjjvbdLBLGmBxR +EPCjjvbdZnmiEdyj +EObjjvbdVhXuwgYz +DncLKvbdUtNTfMVj +EPDLKvbdKaKgMaxR +DncKjvbdJcJbpicY +DnbkKvbdSKyGVHLT +DoDKjvbdzROlhjXA +DnbkKvbdlrZUysEJ +DoCkKvbdnQZyWLYb +DoCjjvbdeFOqbWbj +EOcLKvbdjgfkfGOL +EObkKvbdiHJbyWKV +DnbkKvbdGdLVibJj +DoDKjvbdGLErcINV +EPCjjvbdNGcPlpUk +EOcKjvbdjFLGtoAO +EOcKjvbdsBfMlGkZ +EObjjvbdhtydvquC +DoCjjvbdznpRFCkx +DncLKvbdYSkaNUOx +DoCjjvbdVvhxVdFH +EPDLKvbdNeETiJLE +DoDKjvbdcScLTdJa +EOcLKvbdQwNdDLgc +DoDLKvbdUMWPBWPJ +DncKjvbdqFdEtVaI +EObjjvbdhbPCeXRR +DoCjjvbdKeehCApu +DncKjvbdYNqAXuVt +DoDLKvbdjmCLzFGo +DoCkKvbdtlXwBUAw +EObkKvbdwtmEqYlO +EObjjvbdrovOjCvG +EObkKvbdqrVLOLBN +DoCjjvbdSBcdkhxk +DncLKvbdrEEhomua +EObkKvbdtbbtvuno +EPDLKvbdZjShQGaf +EPCjjvbdTAFJHbPE +DnbjjvbdcScLTcia +EObkKvbdbsDLUDia +DnbkKvbdkyTSTYgU +DncKjvbdySmhmSCH +DoCjjvbdnBivxPNu +DncKjvbdEXxLtTtM +EObjjvbdZshhyESn +DoDKjvbdkMbLzEfo +EObjjvbdssRrxyeD +DoDKjvbdcSbkTdKB +EPDLKvbdHDjvJbKK +DncLKvbdsQVnjCvG +DnbjjvbdJSyBTMwl +EOcLKvbddZxpYYqC +EPCjjvbdrXQLcJZR +DoCkKvbdnHEwlmfy +EOcKjvbdGZUuBDwb +EObjjvbdvOszqKnt +EOcLKvbdRosgKFdX +EPCjjvbdMpXqWNfs +EPCkKvbdJbibqJcY +DncKjvbdJvVFdEgJ +EObkKvbdqwPkcIyR +DnbkKvbdDwxMUTtM +DncKjvbdtcDVXVno +EPDLKvbdlZSrSxft +DoCkKvbdKeehCApu +EPDLKvbdQlxCYmtz +EOcLKvbdYqNFJNFR +DoCkKvbdnCKWwoOV +EObjjvbdwzIFfYEr +EOcKjvbdkDMLQfuH +EPCjjvbdrSUjnLBN +EPCkKvbdTfznMXVe +EPCkKvbdZxdKNcMS +DoCjjvbdJXsaglRQ +DoCjjvbdNPwqWNgT +DoCjjvbdLqwMzUpz +EOcKjvbdCDoaWJlf +DnbjjvbdlYsRsZGt +DncKjvbdeOdsLUUS +EOcKjvbdEvZQPmJe +DoCkKvbdqBJFAXHd +DnbjjvbdtkwwBUBX +EObjjvbdLFfHaaQu +DoDLKvbdbLMFoNcA +EPDLKvbdiLdcnUby +DnbkKvbdUQqPVUgm +EOcLKvbdEOcLLXDE +DoDKjvbdrEEhpOWB +DncKjvbdkCkkQftg +DncLKvbdMfbpNQUk +DnbjjvbdTulQKUAq +DoDLKvbdUtNUFkvK +DncKjvbddndsKtTr +EPDKjvbdliDsqVSB +EPCkKvbdhbOcEvqR +DoCkKvbdqceJQNua +DoCkKvbdrWpLcIyR +DncKjvbdrSVLNkAm +DoDLKvbdyOShYTJD +DncKjvbdyYJKBoyk +DnbjjvbdZQldiNFR +EPDLKvbdePEsKstS +EPCjjvbdcScKtDia +DncLKvbdxsOJNRbH +EObjjvbdEYXlUUTl +DoCkKvbdxUldqZMO +EOcKjvbdRjxeuGkT +EOcLKvbdqrVLNjaN +DoCkKvbdDwwktUUM +EOcLKvbdZQmEiNFR +EPCkKvbdMSXMytpz +DnbkKvbdnUtzKiqf +DoCjjvbdREDAoqDr +EPCjjvbdZyDinDMS +EPCjjvbdiCPDEwRR +EPCkKvbdmSZUzSci +DoDKjvbdkWWmdCXw +DnbkKvbdmJDsqVRa +EPDKjvbdhzVGLpnG +DoCkKvbdsPuoKDWG +DoDLKvbdrylPsAgn +EPCjjvbdsPuoJbuf +EOcKjvbdrEFJQOVa +EPCjjvbdEPDLLXCd +DncKjvbdkVwOEBxX +EPCkKvbdqGEFUWAh +DncLKvbdtbcUvuno +EOcKjvbdWIYWYGxz +EPDLKvbdZLqcsmkm +DoDKjvbdmaivwnnV +DoCkKvbdOYPVzcmt +DoCjjvbdVwIwvDeH +DoCjjvbdYkrETmkm +DoDKjvbdLFfHbAqV +EObjjvbdkIHLefOL +EPDKjvbdZjShPfaf +DoCjjvbdehLWSORH +DncLKvbdKfFgbBQu +EObkKvbdsPunjDVf +DncKjvbdiMEdNuCy +DncKjvbdFfKSNhtR +EOcKjvbdFVxpQNKF +DncLKvbdfHkVrORH +EObjjvbdKefIBaQu +EPDKjvbduCbtvuoP +EPCkKvbdGdLWKCKK +DncLKvbdLAkGmBwq +DncLKvbdZshiZESn +DnbjjvbdySmhmSCH +DoDKjvbdACqxJyiQ +DncLKvbdmajXYOmu +DnbjjvbdxVNFRZMO +DnbjjvbdVqmxBdlD +DnbkKvbdIGgZyYXg +DncKjvbdddnrBvcK +EPCjjvbdUGzmkwVe +DncLKvbdaNLCTVNH +DoCkKvbdWWhwucdg +DncKjvbdkWWmcaxX +DoDKjvbdaRfChUGL +EPDLKvbdOEcsiJKd +DoDLKvbdGLFTChMu +EObjjvbdjmBkzFHP +DncLKvbdrWokcJYq +EObjjvbdDHMGHAzc +EObkKvbdRyjITCvA +DnbjjvbdWRnXbElD +DoCjjvbdEARiNZvw +DnbkKvbdRjyFtfjs +DoCkKvbdMgDQNQVL +DoDKjvbdCEPaWJmG +DoCkKvbdUtNTfLuj +DoDKjvbdNGcQMpVL +DoDKjvbdZQmFImEq +EObjjvbdyYIibPyk +DoDLKvbdcSbjtDjB +EPCjjvbdPxmAGsSK +EPCjjvbdnUuZjirG +EPCkKvbddijSVtzn +EOcKjvbdxUmEqYlO +EOcKjvbdxrmiNRag +EPCkKvbdjmBlZeHP +EOcKjvbdvBDySndh +EObjjvbdliDsqVSB +EOcKjvbdTvMQKUBR +DncLKvbdRNXbYnUz +DnbjjvbdyYIiaozL +DoCkKvbdhbPDEwRR +EPDKjvbdptUGrSLU +DoDKjvbdFjeTChMu +DnbkKvbdFVxoomJe +EObkKvbdlYrrSyGt +EPDLKvbdVZHszKnn +DncLKvbdDwwktUUM +DncLKvbdDnbkKvcE +EPCkKvbdjJfHjMwr +EPDKjvbdUtNTfMWK +EObjjvbdbhlikGWx +DncLKvbdKfFhCBQu +DoDKjvbdVgwvXgYz +EPDLKvbdiBoCdwRR +EPDLKvbdzdzOzeZp +EObkKvbdMoxRWNgT +EPDKjvbdjvXNdBww +EObkKvbdUtMsfLuj +EOcLKvbdnUuZjjRf +DnbkKvbduCbtwVoP +EPDLKvbdGGKRmhsq +EObkKvbdePEsLTtS +DoCjjvbdSKyGUgLT +EOcLKvbdRbDdlIyL +DoDLKvbdNxPVzcnU +EObjjvbdkCkkRGtg +DncKjvbdVTmUFkvK +DncKjvbdUsltFkuj +EPDKjvbdSCEElJZL +EOcKjvbdZxcjNcMS +DoCjjvbdEJgjWYKA +DncLKvbdREDBQRDr +DncKjvbddoErjtUS +EPDLKvbdADSYJyiQ +EPDKjvbdatafxKsh +EPDLKvbdkIGkeemk +DoDLKvbdmRxtzSci +DnbkKvbdTlWPAvPJ +DncKjvbdjJegjMwr +DoCkKvbdqTtHSSKt +EOcKjvbdkMakzFHP +DncLKvbddZyPwxpb +DnbkKvbdTppnuUgm +EObkKvbdnPyxukZC +DoDKjvbdbiNJjewY +EPDKjvbdJSyArlwl +EPDLKvbdvvlBVaVu +EOcLKvbdjJfIKMxS +EPDLKvbdliETqVRa +DoCkKvbdWXJXvEFH +DncLKvbdiHKDZWKV +EObkKvbdEXwktUUM +EOcKjvbdRWnDcMID +EPDLKvbdbhljKfWx +DnbkKvbdVTlsfMVj +DnbjjvbdZoOIdeZj +DoDKjvbdDxYLtUTl +EObjjvbdmIdTqUqa +EPCjjvbdiZtekqNf +DoDLKvbdMfcPmPtk +EPDLKvbdKxpirztf +DnbkKvbdEARhlzWw +EOcKjvbdqiAJeMne +DnbjjvbdUsltGMWK +DnbkKvbdMoxRWNfs +EPCjjvbdTqQntuIN +EPDKjvbdLFfHbApu +EOcLKvbdANIZSwZx +DoCjjvbdSLZGUfjs +DoDLKvbdJSyArlxM +EOcLKvbddZxoxZRC +DoDLKvbdRpTfjFcw +EObjjvbdKefHbBRV +EPCkKvbdjlakyeGo +DoDLKvbdiBncFXRR +EObkKvbdkHfkefOL +DnbjjvbdfILVrORH +DnbjjvbdbsDKtDia +DoCjjvbdqiAKElne +EObkKvbdEXxMTtUM +DncKjvbdHfgZxxXg +EPDKjvbdQvnDcMID +DoDKjvbdCSaCsewS +DncLKvbdSZigsDWA +DnbkKvbdiUyeXSUb +DnbkKvbdZRNFJMeR +EPDKjvbdDxXlTstM +EPCjjvbdkNBlZdfo +DnbkKvbdhuZdvqtb +DncLKvbdHDkWJajK +EOcKjvbdhficZWKV +DoDLKvbdxwiKCPyk +EPDLKvbdZQleJMeR +DoDLKvbdLrXMytpz +DncKjvbdcTCjtEJa +DnbkKvbdUMVnaWPJ +DoCjjvbdnBjXYPOV +EObjjvbduWNwjQsA +DoCjjvbdRpUHJecw +DnbkKvbdJYUBglQp +EOcLKvbduoTzqKoU +EObjjvbdZMRctNlN +EObkKvbdziuPpESt +DoDLKvbduLxWaTaX +EOcLKvbdhgKDZWKV +DnbkKvbdZQldhmFR +EOcLKvbdcyyPxZQb +EOcKjvbdRWnDcLgc +DncLKvbdxZgfFweS +EPCkKvbdyqOliJwA +DnbjjvbdsPvPKCuf +DoCjjvbdMgCpNQVL +DncLKvbdOEdTiJKd +EPDKjvbdEARiMyvw +EOcLKvbdJbibqKDY +DoCkKvbdeEnrCWbj +DoCkKvbdGKdrcIMu +DnbkKvbdUMWOaVoJ +DoCkKvbdKaKgNCXq +DnbkKvbdoAKztHdO +EPDKjvbdDxXlUUTl +EOcLKvbdFVxoomJe +EOcKjvbdpyPHfpdY +EPCjjvbdxwiJaoyk +DoCkKvbdlqxtyrci +EOcKjvbdfHkWRmpg +DoCjjvbdkMalZdfo +EPCjjvbdJpyePGOF +DncLKvbdqUUHRqjt +DoDLKvbdziuQPdSt +DoDKjvbdBhjajiGK +EPDKjvbdjcLjpftg +EPDKjvbdVwJYWEFH +DnbjjvbdNdcsiJLE +DoCjjvbdQwODcLgc +EOcLKvbdtkxXAtAw +EPDKjvbdwMvANEEm +DoCjjvbdqFdEsuaI +EObjjvbdrSUjmjaN +DoDLKvbdnGeYMnGy +EOcLKvbdPyNAHTSK +DnbkKvbdMowpvNgT +DoCjjvbdGdLVibKK +DoDLKvbdtcDVXVno +EObkKvbdtlXwBUAw +DoCjjvbdSPsgKGEX +EPCjjvbdURQntuHm +DncLKvbdrMyjZLgi +EPDKjvbdwXMAvBVu +EOcLKvbdRjxfUfkT +DnbkKvbdGFjRnJTq +DoCkKvbdbUbHYLTh +EPDKjvbdoznEKxPA +EPCjjvbdLiBlQxAS +DncKjvbdfVzxPizs +DnbjjvbdSKyFtgLT +EPDKjvbdrXPlCiZR +DncLKvbdhzVGLpnG +EObjjvbdVwJYVdFH +EPDKjvbdwXLaWBVu +EPCjjvbdjhHMGFmk +EObkKvbdKyQjSzuG +DoCjjvbdmfeYNOHZ +DoDLKvbdZirgofaf +EOcLKvbdZoOIdeZj +EPCkKvbdLFfHbApu +EPCkKvbdjvWnEBww +DoDKjvbdcScLUEKB +DoCkKvbdkCkjqHUg +DoDKjvbdyTNhmSBg +DoCkKvbdkHgLfFnL +EPCjjvbdzoQQdcLx +DoCjjvbdOTTvHEtp +EPCkKvbdznopeDLx +EPCkKvbdGFjRmhtR +EPCkKvbdUaCQrpqy +EOcKjvbdnGeXmOHZ +DoDKjvbdiCPDEwRR +DoCjjvbdRbEFLiYk +DncKjvbdRXOECkgc +EPCjjvbdKWUedEgJ +DncKjvbdDjIJvYKA +DoDKjvbdyTOJNRbH +DoCjjvbdePFTKtTr +DoDKjvbdhtyeWrVC +EPCkKvbdqvolCiZR +DoDLKvbdapHHELzd +EObjjvbdlhdUQtrB +EOcKjvbdptUGrRkU +EPCjjvbdqUTfqrLU +EPCkKvbdcJMikGWx +DoDKjvbdlhctRVRa +EOcLKvbdANHyTXZx +EPDKjvbdpssfqrKt +EPCkKvbdFeiqnJTq +DoCkKvbdxZgfGXdr +EOcLKvbdRWmcblHc +DncLKvbdjggMFemk +DoDKjvbdKeegbBQu From 4254270688d93ca8f394b38a79fac42bc774d486 Mon Sep 17 00:00:00 2001 From: Poonam Bajaj Date: Thu, 14 Jun 2012 02:12:46 -0700 Subject: [PATCH 002/160] 6310967: SA: jstack -m produce failures in output While looking for the sender frame check that the frame pointer should not be less than the stack pointer. Reviewed-by: dholmes, sla --- .../share/classes/sun/jvm/hotspot/bugspot/BugSpot.java | 4 ++-- .../jvm/hotspot/debugger/bsd/amd64/BsdAMD64CFrame.java | 10 +++++++--- .../sun/jvm/hotspot/debugger/bsd/x86/BsdX86CFrame.java | 10 +++++++--- .../classes/sun/jvm/hotspot/debugger/cdbg/CFrame.java | 4 ++-- .../hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java | 10 +++++++--- .../jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java | 10 +++++++--- .../hotspot/debugger/linux/amd64/LinuxAMD64CFrame.java | 10 +++++++--- .../hotspot/debugger/linux/sparc/LinuxSPARCCFrame.java | 4 ++-- .../jvm/hotspot/debugger/linux/x86/LinuxX86CFrame.java | 10 +++++++--- .../sun/jvm/hotspot/debugger/proc/ProcCFrame.java | 4 ++-- .../share/classes/sun/jvm/hotspot/tools/PStack.java | 4 ++-- 11 files changed, 52 insertions(+), 28 deletions(-) diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/bugspot/BugSpot.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/bugspot/BugSpot.java index 668fba78372..2ff5308b158 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/bugspot/BugSpot.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/bugspot/BugSpot.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -657,7 +657,7 @@ public class BugSpot extends JPanel { while (fr != null) { trace.add(new StackTraceEntry(fr, getCDebugger())); try { - fr = fr.sender(); + fr = fr.sender(t); } catch (AddressException e) { e.printStackTrace(); showMessageDialog("Error while walking stack; stack trace will be truncated\n(see console for details)", diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/amd64/BsdAMD64CFrame.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/amd64/BsdAMD64CFrame.java index b27a5399009..01d9b06dcd1 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/amd64/BsdAMD64CFrame.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/amd64/BsdAMD64CFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,6 +25,7 @@ package sun.jvm.hotspot.debugger.bsd.amd64; import sun.jvm.hotspot.debugger.*; +import sun.jvm.hotspot.debugger.amd64.*; import sun.jvm.hotspot.debugger.bsd.*; import sun.jvm.hotspot.debugger.cdbg.*; import sun.jvm.hotspot.debugger.cdbg.basic.*; @@ -51,8 +52,11 @@ final public class BsdAMD64CFrame extends BasicCFrame { return rbp; } - public CFrame sender() { - if (rbp == null) { + public CFrame sender(ThreadProxy thread) { + AMD64ThreadContext context = (AMD64ThreadContext) thread.getContext(); + Address rsp = context.getRegisterAsAddress(AMD64ThreadContext.RSP); + + if ( (rbp == null) || rbp.lessThan(rsp) ) { return null; } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/x86/BsdX86CFrame.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/x86/BsdX86CFrame.java index 40292b921e6..237223ed308 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/x86/BsdX86CFrame.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/x86/BsdX86CFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -28,6 +28,7 @@ import sun.jvm.hotspot.debugger.*; import sun.jvm.hotspot.debugger.bsd.*; import sun.jvm.hotspot.debugger.cdbg.*; import sun.jvm.hotspot.debugger.cdbg.basic.*; +import sun.jvm.hotspot.debugger.x86.*; final public class BsdX86CFrame extends BasicCFrame { // package/class internals only @@ -52,8 +53,11 @@ final public class BsdX86CFrame extends BasicCFrame { return ebp; } - public CFrame sender() { - if (ebp == null) { + public CFrame sender(ThreadProxy thread) { + X86ThreadContext context = (X86ThreadContext) thread.getContext(); + Address esp = context.getRegisterAsAddress(X86ThreadContext.ESP); + + if ( (ebp == null) || ebp.lessThan(esp) ) { return null; } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/CFrame.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/CFrame.java index 30ddc298fd9..7640ddaa35e 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/CFrame.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/CFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -34,7 +34,7 @@ import sun.jvm.hotspot.debugger.*; public interface CFrame { /** Returns null when no more frames on stack */ - public CFrame sender(); + public CFrame sender(ThreadProxy th); /** Get the program counter of this frame */ public Address pc(); diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java index 03b5dc572ca..d6ec6b45003 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,6 +25,7 @@ package sun.jvm.hotspot.debugger.cdbg.basic.amd64; import sun.jvm.hotspot.debugger.*; +import sun.jvm.hotspot.debugger.amd64.*; import sun.jvm.hotspot.debugger.cdbg.*; import sun.jvm.hotspot.debugger.cdbg.basic.*; @@ -43,8 +44,11 @@ public class AMD64CFrame extends BasicCFrame { this.pc = pc; } - public CFrame sender() { - if (rbp == null) { + public CFrame sender(ThreadProxy thread) { + AMD64ThreadContext context = (AMD64ThreadContext) thread.getContext(); + Address rsp = context.getRegisterAsAddress(AMD64ThreadContext.RSP); + + if ( (rbp == null) || rbp.lessThan(rsp) ) { return null; } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java index 0764a5da5e9..76b101bef97 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,6 +25,7 @@ package sun.jvm.hotspot.debugger.cdbg.basic.x86; import sun.jvm.hotspot.debugger.*; +import sun.jvm.hotspot.debugger.x86.*; import sun.jvm.hotspot.debugger.cdbg.*; import sun.jvm.hotspot.debugger.cdbg.basic.*; @@ -43,8 +44,11 @@ public class X86CFrame extends BasicCFrame { this.pc = pc; } - public CFrame sender() { - if (ebp == null) { + public CFrame sender(ThreadProxy thread) { + X86ThreadContext context = (X86ThreadContext) thread.getContext(); + Address esp = context.getRegisterAsAddress(X86ThreadContext.ESP); + + if ( (ebp == null) || ebp.lessThan(esp) ) { return null; } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64CFrame.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64CFrame.java index 3fab9a9e1d0..36977f1aeaa 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64CFrame.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/amd64/LinuxAMD64CFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,6 +25,7 @@ package sun.jvm.hotspot.debugger.linux.amd64; import sun.jvm.hotspot.debugger.*; +import sun.jvm.hotspot.debugger.amd64.*; import sun.jvm.hotspot.debugger.linux.*; import sun.jvm.hotspot.debugger.cdbg.*; import sun.jvm.hotspot.debugger.cdbg.basic.*; @@ -51,8 +52,11 @@ final public class LinuxAMD64CFrame extends BasicCFrame { return rbp; } - public CFrame sender() { - if (rbp == null) { + public CFrame sender(ThreadProxy thread) { + AMD64ThreadContext context = (AMD64ThreadContext) thread.getContext(); + Address rsp = context.getRegisterAsAddress(AMD64ThreadContext.RSP); + + if ( (rbp == null) || rbp.lessThan(rsp) ) { return null; } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/sparc/LinuxSPARCCFrame.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/sparc/LinuxSPARCCFrame.java index eb490b284b5..d52f6b35ee0 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/sparc/LinuxSPARCCFrame.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/sparc/LinuxSPARCCFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -57,7 +57,7 @@ final public class LinuxSPARCCFrame extends BasicCFrame { return sp; } - public CFrame sender() { + public CFrame sender(ThreadProxy thread) { if (sp == null) { return null; } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/x86/LinuxX86CFrame.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/x86/LinuxX86CFrame.java index 67074c6533c..8d066720ea2 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/x86/LinuxX86CFrame.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/x86/LinuxX86CFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -28,6 +28,7 @@ import sun.jvm.hotspot.debugger.*; import sun.jvm.hotspot.debugger.linux.*; import sun.jvm.hotspot.debugger.cdbg.*; import sun.jvm.hotspot.debugger.cdbg.basic.*; +import sun.jvm.hotspot.debugger.x86.*; final public class LinuxX86CFrame extends BasicCFrame { // package/class internals only @@ -52,8 +53,11 @@ final public class LinuxX86CFrame extends BasicCFrame { return ebp; } - public CFrame sender() { - if (ebp == null) { + public CFrame sender(ThreadProxy thread) { + X86ThreadContext context = (X86ThreadContext) thread.getContext(); + Address esp = context.getRegisterAsAddress(X86ThreadContext.ESP); + + if ( (ebp == null) || ebp.lessThan(esp) ) { return null; } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcCFrame.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcCFrame.java index 6b508e1e4e8..83d5f677a6e 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcCFrame.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcCFrame.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -37,7 +37,7 @@ final class ProcCFrame extends BasicCFrame { return fp; } - public CFrame sender() { + public CFrame sender(ThreadProxy t) { return sender; } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/PStack.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/PStack.java index 671bfc81125..a087d4aa04e 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/PStack.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/PStack.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -158,7 +158,7 @@ public class PStack extends Tool { printUnknown(out); } } - f = f.sender(); + f = f.sender(th); } } catch (Exception exp) { exp.printStackTrace(); From d1191bb4f4505492fa9b24720fccc5a6c06fa10e Mon Sep 17 00:00:00 2001 From: Vladimir Kozlov Date: Fri, 15 Jun 2012 01:25:19 -0700 Subject: [PATCH 003/160] 7119644: Increase superword's vector size up to 256 bits Increase vector size up to 256-bits for YMM AVX registers on x86. Reviewed-by: never, twisti, roland --- hotspot/src/cpu/sparc/vm/sparc.ad | 665 +++---- hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp | 4 +- hotspot/src/cpu/x86/vm/assembler_x86.cpp | 75 + hotspot/src/cpu/x86/vm/assembler_x86.hpp | 40 +- hotspot/src/cpu/x86/vm/register_x86.cpp | 4 +- hotspot/src/cpu/x86/vm/register_x86.hpp | 6 +- hotspot/src/cpu/x86/vm/vm_version_x86.cpp | 41 +- hotspot/src/cpu/x86/vm/vmreg_x86.cpp | 7 +- hotspot/src/cpu/x86/vm/vmreg_x86.inline.hpp | 6 +- hotspot/src/cpu/x86/vm/x86.ad | 1530 +++++++++++++++++ hotspot/src/cpu/x86/vm/x86_32.ad | 1005 +++++------ hotspot/src/cpu/x86/vm/x86_64.ad | 825 ++------- hotspot/src/share/vm/adlc/adlparse.cpp | 23 +- hotspot/src/share/vm/adlc/archDesc.cpp | 18 +- hotspot/src/share/vm/adlc/forms.cpp | 35 +- hotspot/src/share/vm/adlc/forms.hpp | 5 +- hotspot/src/share/vm/adlc/formsopt.cpp | 13 +- hotspot/src/share/vm/adlc/formssel.cpp | 60 +- hotspot/src/share/vm/adlc/formssel.hpp | 4 +- hotspot/src/share/vm/adlc/main.cpp | 3 +- hotspot/src/share/vm/code/vmreg.cpp | 4 +- hotspot/src/share/vm/opto/c2_globals.hpp | 7 + hotspot/src/share/vm/opto/chaitin.cpp | 171 +- hotspot/src/share/vm/opto/chaitin.hpp | 17 +- hotspot/src/share/vm/opto/classes.hpp | 72 +- hotspot/src/share/vm/opto/compile.cpp | 30 +- hotspot/src/share/vm/opto/ifg.cpp | 31 +- hotspot/src/share/vm/opto/lcm.cpp | 8 +- hotspot/src/share/vm/opto/loopnode.cpp | 6 +- hotspot/src/share/vm/opto/machnode.cpp | 6 +- hotspot/src/share/vm/opto/machnode.hpp | 7 +- hotspot/src/share/vm/opto/matcher.cpp | 98 +- hotspot/src/share/vm/opto/matcher.hpp | 17 +- hotspot/src/share/vm/opto/memnode.cpp | 3 +- hotspot/src/share/vm/opto/mulnode.hpp | 6 +- hotspot/src/share/vm/opto/node.cpp | 5 +- hotspot/src/share/vm/opto/node.hpp | 21 +- hotspot/src/share/vm/opto/opcodes.cpp | 6 +- hotspot/src/share/vm/opto/opcodes.hpp | 6 +- hotspot/src/share/vm/opto/postaloc.cpp | 81 +- hotspot/src/share/vm/opto/reg_split.cpp | 36 +- hotspot/src/share/vm/opto/regmask.cpp | 165 +- hotspot/src/share/vm/opto/regmask.hpp | 61 +- hotspot/src/share/vm/opto/superword.cpp | 500 ++++-- hotspot/src/share/vm/opto/superword.hpp | 16 +- hotspot/src/share/vm/opto/type.cpp | 151 +- hotspot/src/share/vm/opto/type.hpp | 85 +- hotspot/src/share/vm/opto/vectornode.cpp | 458 ++--- hotspot/src/share/vm/opto/vectornode.hpp | 874 ++-------- hotspot/src/share/vm/runtime/vmStructs.cpp | 68 +- .../compiler/7119644/TestBooleanVect.java | 952 ++++++++++ .../compiler/7119644/TestByteDoubleVect.java | 571 ++++++ .../compiler/7119644/TestByteFloatVect.java | 571 ++++++ .../compiler/7119644/TestByteIntVect.java | 571 ++++++ .../compiler/7119644/TestByteLongVect.java | 571 ++++++ .../compiler/7119644/TestByteShortVect.java | 571 ++++++ .../test/compiler/7119644/TestByteVect.java | 953 ++++++++++ .../compiler/7119644/TestCharShortVect.java | 571 ++++++ .../test/compiler/7119644/TestCharVect.java | 953 ++++++++++ .../test/compiler/7119644/TestDoubleVect.java | 953 ++++++++++ .../compiler/7119644/TestFloatDoubleVect.java | 571 ++++++ .../test/compiler/7119644/TestFloatVect.java | 953 ++++++++++ .../compiler/7119644/TestIntDoubleVect.java | 571 ++++++ .../compiler/7119644/TestIntFloatVect.java | 571 ++++++ .../compiler/7119644/TestIntLongVect.java | 571 ++++++ .../test/compiler/7119644/TestIntVect.java | 953 ++++++++++ .../compiler/7119644/TestLongDoubleVect.java | 571 ++++++ .../compiler/7119644/TestLongFloatVect.java | 571 ++++++ .../test/compiler/7119644/TestLongVect.java | 953 ++++++++++ .../compiler/7119644/TestShortDoubleVect.java | 571 ++++++ .../compiler/7119644/TestShortFloatVect.java | 571 ++++++ .../compiler/7119644/TestShortIntVect.java | 571 ++++++ .../compiler/7119644/TestShortLongVect.java | 571 ++++++ .../test/compiler/7119644/TestShortVect.java | 953 ++++++++++ 74 files changed, 20945 insertions(+), 3199 deletions(-) create mode 100644 hotspot/test/compiler/7119644/TestBooleanVect.java create mode 100644 hotspot/test/compiler/7119644/TestByteDoubleVect.java create mode 100644 hotspot/test/compiler/7119644/TestByteFloatVect.java create mode 100644 hotspot/test/compiler/7119644/TestByteIntVect.java create mode 100644 hotspot/test/compiler/7119644/TestByteLongVect.java create mode 100644 hotspot/test/compiler/7119644/TestByteShortVect.java create mode 100644 hotspot/test/compiler/7119644/TestByteVect.java create mode 100644 hotspot/test/compiler/7119644/TestCharShortVect.java create mode 100644 hotspot/test/compiler/7119644/TestCharVect.java create mode 100644 hotspot/test/compiler/7119644/TestDoubleVect.java create mode 100644 hotspot/test/compiler/7119644/TestFloatDoubleVect.java create mode 100644 hotspot/test/compiler/7119644/TestFloatVect.java create mode 100644 hotspot/test/compiler/7119644/TestIntDoubleVect.java create mode 100644 hotspot/test/compiler/7119644/TestIntFloatVect.java create mode 100644 hotspot/test/compiler/7119644/TestIntLongVect.java create mode 100644 hotspot/test/compiler/7119644/TestIntVect.java create mode 100644 hotspot/test/compiler/7119644/TestLongDoubleVect.java create mode 100644 hotspot/test/compiler/7119644/TestLongFloatVect.java create mode 100644 hotspot/test/compiler/7119644/TestLongVect.java create mode 100644 hotspot/test/compiler/7119644/TestShortDoubleVect.java create mode 100644 hotspot/test/compiler/7119644/TestShortFloatVect.java create mode 100644 hotspot/test/compiler/7119644/TestShortIntVect.java create mode 100644 hotspot/test/compiler/7119644/TestShortLongVect.java create mode 100644 hotspot/test/compiler/7119644/TestShortVect.java diff --git a/hotspot/src/cpu/sparc/vm/sparc.ad b/hotspot/src/cpu/sparc/vm/sparc.ad index 43c9976bbde..400df553694 100644 --- a/hotspot/src/cpu/sparc/vm/sparc.ad +++ b/hotspot/src/cpu/sparc/vm/sparc.ad @@ -1,5 +1,5 @@ // -// Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved. +// Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. // DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. // // This code is free software; you can redistribute it and/or modify it @@ -678,18 +678,26 @@ intptr_t get_offset_from_base_2(const MachNode* n, const TypePtr* atype, int dis static inline jdouble replicate_immI(int con, int count, int width) { // Load a constant replicated "count" times with width "width" + assert(count*width == 8 && width <= 4, "sanity"); int bit_width = width * 8; - jlong elt_val = con; - elt_val &= (((jlong) 1) << bit_width) - 1; // mask off sign bits - jlong val = elt_val; + jlong val = con; + val &= (((jlong) 1) << bit_width) - 1; // mask off sign bits for (int i = 0; i < count - 1; i++) { - val <<= bit_width; - val |= elt_val; + val |= (val << bit_width); } jdouble dval = *((jdouble*) &val); // coerce to double type return dval; } +static inline jdouble replicate_immF(float con) { + // Replicate float con 2 times and pack into vector. + int val = *((int*)&con); + jlong lval = val; + lval = (lval << 32) | (lval & 0xFFFFFFFFl); + jdouble dval = *((jdouble*) &lval); // coerce to double type + return dval; +} + // Standard Sparc opcode form2 field breakdown static inline void emit2_19(CodeBuffer &cbuf, int f30, int f29, int f25, int f22, int f20, int f19, int f0 ) { f0 &= (1<<19)-1; // Mask displacement to 19 bits @@ -791,6 +799,7 @@ void emit_form3_mem_reg(CodeBuffer &cbuf, const MachNode* n, int primary, int te case Assembler::stdf_op3: st_op = Op_StoreD; break; case Assembler::ldsb_op3: ld_op = Op_LoadB; break; + case Assembler::ldub_op3: ld_op = Op_LoadUB; break; case Assembler::lduh_op3: ld_op = Op_LoadUS; break; case Assembler::ldsh_op3: ld_op = Op_LoadS; break; case Assembler::ldx_op3: // may become LoadP or stay LoadI @@ -799,7 +808,6 @@ void emit_form3_mem_reg(CodeBuffer &cbuf, const MachNode* n, int primary, int te case Assembler::ldd_op3: ld_op = Op_LoadL; break; case Assembler::ldf_op3: ld_op = Op_LoadF; break; case Assembler::lddf_op3: ld_op = Op_LoadD; break; - case Assembler::ldub_op3: ld_op = Op_LoadB; break; case Assembler::prefetch_op3: ld_op = Op_LoadI; break; default: ShouldNotReachHere(); @@ -840,10 +848,7 @@ void emit_form3_mem_reg(CodeBuffer &cbuf, const MachNode* n, int primary, int te !(n->ideal_Opcode()==Op_PrefetchRead && ld_op==Op_LoadI) && !(n->ideal_Opcode()==Op_PrefetchWrite && ld_op==Op_LoadI) && !(n->ideal_Opcode()==Op_PrefetchAllocation && ld_op==Op_LoadI) && - !(n->ideal_Opcode()==Op_Load2I && ld_op==Op_LoadD) && - !(n->ideal_Opcode()==Op_Load4C && ld_op==Op_LoadD) && - !(n->ideal_Opcode()==Op_Load4S && ld_op==Op_LoadD) && - !(n->ideal_Opcode()==Op_Load8B && ld_op==Op_LoadD) && + !(n->ideal_Opcode()==Op_LoadVector && ld_op==Op_LoadD) && !(n->rule() == loadUB_rule)) { verify_oops_warning(n, n->ideal_Opcode(), ld_op); } @@ -855,9 +860,7 @@ void emit_form3_mem_reg(CodeBuffer &cbuf, const MachNode* n, int primary, int te !(n->ideal_Opcode()==Op_StoreI && st_op==Op_StoreF) && !(n->ideal_Opcode()==Op_StoreF && st_op==Op_StoreI) && !(n->ideal_Opcode()==Op_StoreL && st_op==Op_StoreI) && - !(n->ideal_Opcode()==Op_Store2I && st_op==Op_StoreD) && - !(n->ideal_Opcode()==Op_Store4C && st_op==Op_StoreD) && - !(n->ideal_Opcode()==Op_Store8B && st_op==Op_StoreD) && + !(n->ideal_Opcode()==Op_StoreVector && st_op==Op_StoreD) && !(n->ideal_Opcode()==Op_StoreD && st_op==Op_StoreI && n->rule() == storeD0_rule)) { verify_oops_warning(n, n->ideal_Opcode(), st_op); } @@ -1849,16 +1852,45 @@ int Matcher::regnum_to_fpu_offset(int regnum) { address last_rethrow = NULL; // debugging aid for Rethrow encoding #endif +// Map Types to machine register types +const int Matcher::base2reg[Type::lastype] = { + Node::NotAMachineReg,0,0, Op_RegI, Op_RegL, 0, Op_RegN, + Node::NotAMachineReg, Node::NotAMachineReg, /* tuple, array */ + 0, Op_RegD, 0, 0, /* Vectors */ + Op_RegP, Op_RegP, Op_RegP, Op_RegP, Op_RegP, Op_RegP, /* the pointers */ + 0, 0/*abio*/, + Op_RegP /* Return address */, 0, /* the memories */ + Op_RegF, Op_RegF, Op_RegF, Op_RegD, Op_RegD, Op_RegD, + 0 /*bottom*/ +}; + // Vector width in bytes -const uint Matcher::vector_width_in_bytes(void) { +const int Matcher::vector_width_in_bytes(BasicType bt) { + assert(MaxVectorSize == 8, ""); return 8; } // Vector ideal reg -const uint Matcher::vector_ideal_reg(void) { +const int Matcher::vector_ideal_reg(int size) { + assert(MaxVectorSize == 8, ""); return Op_RegD; } +// Limits on vector size (number of elements) loaded into vector. +const int Matcher::max_vector_size(const BasicType bt) { + assert(is_java_primitive(bt), "only primitive type vectors"); + return vector_width_in_bytes(bt)/type2aelembytes(bt); +} + +const int Matcher::min_vector_size(const BasicType bt) { + return max_vector_size(bt); // Same as max. +} + +// SPARC doesn't support misaligned vectors store/load. +const bool Matcher::misaligned_vectors_ok() { + return false; +} + // USII supports fxtof through the whole range of number, USIII doesn't const bool Matcher::convL2FSupported(void) { return VM_Version::has_fast_fxtof(); @@ -3125,50 +3157,6 @@ enc_class enc_Array_Equals(o0RegP ary1, o1RegP ary2, g3RegP tmp1, notemp_iRegI r __ membar( Assembler::Membar_mask_bits(Assembler::StoreLoad) ); %} - enc_class enc_repl8b( iRegI src, iRegL dst ) %{ - MacroAssembler _masm(&cbuf); - Register src_reg = reg_to_register_object($src$$reg); - Register dst_reg = reg_to_register_object($dst$$reg); - __ sllx(src_reg, 56, dst_reg); - __ srlx(dst_reg, 8, O7); - __ or3 (dst_reg, O7, dst_reg); - __ srlx(dst_reg, 16, O7); - __ or3 (dst_reg, O7, dst_reg); - __ srlx(dst_reg, 32, O7); - __ or3 (dst_reg, O7, dst_reg); - %} - - enc_class enc_repl4b( iRegI src, iRegL dst ) %{ - MacroAssembler _masm(&cbuf); - Register src_reg = reg_to_register_object($src$$reg); - Register dst_reg = reg_to_register_object($dst$$reg); - __ sll(src_reg, 24, dst_reg); - __ srl(dst_reg, 8, O7); - __ or3(dst_reg, O7, dst_reg); - __ srl(dst_reg, 16, O7); - __ or3(dst_reg, O7, dst_reg); - %} - - enc_class enc_repl4s( iRegI src, iRegL dst ) %{ - MacroAssembler _masm(&cbuf); - Register src_reg = reg_to_register_object($src$$reg); - Register dst_reg = reg_to_register_object($dst$$reg); - __ sllx(src_reg, 48, dst_reg); - __ srlx(dst_reg, 16, O7); - __ or3 (dst_reg, O7, dst_reg); - __ srlx(dst_reg, 32, O7); - __ or3 (dst_reg, O7, dst_reg); - %} - - enc_class enc_repl2i( iRegI src, iRegL dst ) %{ - MacroAssembler _masm(&cbuf); - Register src_reg = reg_to_register_object($src$$reg); - Register dst_reg = reg_to_register_object($dst$$reg); - __ sllx(src_reg, 32, dst_reg); - __ srlx(dst_reg, 32, O7); - __ or3 (dst_reg, O7, dst_reg); - %} - %} //----------FRAME-------------------------------------------------------------- @@ -5932,50 +5920,6 @@ instruct loadL_unaligned(iRegL dst, memory mem, o7RegI tmp) %{ ins_pipe(iload_mem); %} -// Load Aligned Packed Byte into a Double Register -instruct loadA8B(regD dst, memory mem) %{ - match(Set dst (Load8B mem)); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "LDDF $mem,$dst\t! packed8B" %} - opcode(Assembler::lddf_op3); - ins_encode(simple_form3_mem_reg( mem, dst ) ); - ins_pipe(floadD_mem); -%} - -// Load Aligned Packed Char into a Double Register -instruct loadA4C(regD dst, memory mem) %{ - match(Set dst (Load4C mem)); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "LDDF $mem,$dst\t! packed4C" %} - opcode(Assembler::lddf_op3); - ins_encode(simple_form3_mem_reg( mem, dst ) ); - ins_pipe(floadD_mem); -%} - -// Load Aligned Packed Short into a Double Register -instruct loadA4S(regD dst, memory mem) %{ - match(Set dst (Load4S mem)); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "LDDF $mem,$dst\t! packed4S" %} - opcode(Assembler::lddf_op3); - ins_encode(simple_form3_mem_reg( mem, dst ) ); - ins_pipe(floadD_mem); -%} - -// Load Aligned Packed Int into a Double Register -instruct loadA2I(regD dst, memory mem) %{ - match(Set dst (Load2I mem)); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "LDDF $mem,$dst\t! packed2I" %} - opcode(Assembler::lddf_op3); - ins_encode(simple_form3_mem_reg( mem, dst ) ); - ins_pipe(floadD_mem); -%} - // Load Range instruct loadRange(iRegI dst, memory mem) %{ match(Set dst (LoadRange mem)); @@ -6599,17 +6543,6 @@ instruct storeF0( memory mem, immF0 src) %{ ins_pipe(fstoreF_mem_zero); %} -// Store Aligned Packed Bytes in Double register to memory -instruct storeA8B(memory mem, regD src) %{ - match(Set mem (Store8B mem src)); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "STDF $src,$mem\t! packed8B" %} - opcode(Assembler::stdf_op3); - ins_encode(simple_form3_mem_reg( mem, src ) ); - ins_pipe(fstoreD_mem_reg); -%} - // Convert oop pointer into compressed form instruct encodeHeapOop(iRegN dst, iRegP src) %{ predicate(n->bottom_type()->make_ptr()->ptr() != TypePtr::NotNull); @@ -6654,62 +6587,6 @@ instruct decodeHeapOop_not_null(iRegP dst, iRegN src) %{ %} -// Store Zero into Aligned Packed Bytes -instruct storeA8B0(memory mem, immI0 zero) %{ - match(Set mem (Store8B mem zero)); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "STX $zero,$mem\t! packed8B" %} - opcode(Assembler::stx_op3); - ins_encode(simple_form3_mem_reg( mem, R_G0 ) ); - ins_pipe(fstoreD_mem_zero); -%} - -// Store Aligned Packed Chars/Shorts in Double register to memory -instruct storeA4C(memory mem, regD src) %{ - match(Set mem (Store4C mem src)); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "STDF $src,$mem\t! packed4C" %} - opcode(Assembler::stdf_op3); - ins_encode(simple_form3_mem_reg( mem, src ) ); - ins_pipe(fstoreD_mem_reg); -%} - -// Store Zero into Aligned Packed Chars/Shorts -instruct storeA4C0(memory mem, immI0 zero) %{ - match(Set mem (Store4C mem (Replicate4C zero))); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "STX $zero,$mem\t! packed4C" %} - opcode(Assembler::stx_op3); - ins_encode(simple_form3_mem_reg( mem, R_G0 ) ); - ins_pipe(fstoreD_mem_zero); -%} - -// Store Aligned Packed Ints in Double register to memory -instruct storeA2I(memory mem, regD src) %{ - match(Set mem (Store2I mem src)); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "STDF $src,$mem\t! packed2I" %} - opcode(Assembler::stdf_op3); - ins_encode(simple_form3_mem_reg( mem, src ) ); - ins_pipe(fstoreD_mem_reg); -%} - -// Store Zero into Aligned Packed Ints -instruct storeA2I0(memory mem, immI0 zero) %{ - match(Set mem (Store2I mem zero)); - ins_cost(MEMORY_REF_COST); - size(4); - format %{ "STX $zero,$mem\t! packed2I" %} - opcode(Assembler::stx_op3); - ins_encode(simple_form3_mem_reg( mem, R_G0 ) ); - ins_pipe(fstoreD_mem_zero); -%} - - //----------MemBar Instructions----------------------------------------------- // Memory barrier flavors @@ -8880,150 +8757,6 @@ instruct shrL_reg_imm6_L2I(iRegI dst, iRegL src, immI_32_63 cnt) %{ ins_pipe(ialu_reg_imm); %} -// Replicate scalar to packed byte values in Double register -instruct Repl8B_reg_helper(iRegL dst, iRegI src) %{ - effect(DEF dst, USE src); - format %{ "SLLX $src,56,$dst\n\t" - "SRLX $dst, 8,O7\n\t" - "OR $dst,O7,$dst\n\t" - "SRLX $dst,16,O7\n\t" - "OR $dst,O7,$dst\n\t" - "SRLX $dst,32,O7\n\t" - "OR $dst,O7,$dst\t! replicate8B" %} - ins_encode( enc_repl8b(src, dst)); - ins_pipe(ialu_reg); -%} - -// Replicate scalar to packed byte values in Double register -instruct Repl8B_reg(stackSlotD dst, iRegI src) %{ - match(Set dst (Replicate8B src)); - expand %{ - iRegL tmp; - Repl8B_reg_helper(tmp, src); - regL_to_stkD(dst, tmp); - %} -%} - -// Replicate scalar constant to packed byte values in Double register -instruct Repl8B_immI(regD dst, immI13 con, o7RegI tmp) %{ - match(Set dst (Replicate8B con)); - effect(KILL tmp); - format %{ "LDDF [$constanttablebase + $constantoffset],$dst\t! load from constant table: Repl8B($con)" %} - ins_encode %{ - // XXX This is a quick fix for 6833573. - //__ ldf(FloatRegisterImpl::D, $constanttablebase, $constantoffset(replicate_immI($con$$constant, 8, 1)), $dst$$FloatRegister); - RegisterOrConstant con_offset = __ ensure_simm13_or_reg($constantoffset(replicate_immI($con$$constant, 8, 1)), $tmp$$Register); - __ ldf(FloatRegisterImpl::D, $constanttablebase, con_offset, as_DoubleFloatRegister($dst$$reg)); - %} - ins_pipe(loadConFD); -%} - -// Replicate scalar to packed char values into stack slot -instruct Repl4C_reg_helper(iRegL dst, iRegI src) %{ - effect(DEF dst, USE src); - format %{ "SLLX $src,48,$dst\n\t" - "SRLX $dst,16,O7\n\t" - "OR $dst,O7,$dst\n\t" - "SRLX $dst,32,O7\n\t" - "OR $dst,O7,$dst\t! replicate4C" %} - ins_encode( enc_repl4s(src, dst) ); - ins_pipe(ialu_reg); -%} - -// Replicate scalar to packed char values into stack slot -instruct Repl4C_reg(stackSlotD dst, iRegI src) %{ - match(Set dst (Replicate4C src)); - expand %{ - iRegL tmp; - Repl4C_reg_helper(tmp, src); - regL_to_stkD(dst, tmp); - %} -%} - -// Replicate scalar constant to packed char values in Double register -instruct Repl4C_immI(regD dst, immI con, o7RegI tmp) %{ - match(Set dst (Replicate4C con)); - effect(KILL tmp); - format %{ "LDDF [$constanttablebase + $constantoffset],$dst\t! load from constant table: Repl4C($con)" %} - ins_encode %{ - // XXX This is a quick fix for 6833573. - //__ ldf(FloatRegisterImpl::D, $constanttablebase, $constantoffset(replicate_immI($con$$constant, 4, 2)), $dst$$FloatRegister); - RegisterOrConstant con_offset = __ ensure_simm13_or_reg($constantoffset(replicate_immI($con$$constant, 4, 2)), $tmp$$Register); - __ ldf(FloatRegisterImpl::D, $constanttablebase, con_offset, as_DoubleFloatRegister($dst$$reg)); - %} - ins_pipe(loadConFD); -%} - -// Replicate scalar to packed short values into stack slot -instruct Repl4S_reg_helper(iRegL dst, iRegI src) %{ - effect(DEF dst, USE src); - format %{ "SLLX $src,48,$dst\n\t" - "SRLX $dst,16,O7\n\t" - "OR $dst,O7,$dst\n\t" - "SRLX $dst,32,O7\n\t" - "OR $dst,O7,$dst\t! replicate4S" %} - ins_encode( enc_repl4s(src, dst) ); - ins_pipe(ialu_reg); -%} - -// Replicate scalar to packed short values into stack slot -instruct Repl4S_reg(stackSlotD dst, iRegI src) %{ - match(Set dst (Replicate4S src)); - expand %{ - iRegL tmp; - Repl4S_reg_helper(tmp, src); - regL_to_stkD(dst, tmp); - %} -%} - -// Replicate scalar constant to packed short values in Double register -instruct Repl4S_immI(regD dst, immI con, o7RegI tmp) %{ - match(Set dst (Replicate4S con)); - effect(KILL tmp); - format %{ "LDDF [$constanttablebase + $constantoffset],$dst\t! load from constant table: Repl4S($con)" %} - ins_encode %{ - // XXX This is a quick fix for 6833573. - //__ ldf(FloatRegisterImpl::D, $constanttablebase, $constantoffset(replicate_immI($con$$constant, 4, 2)), $dst$$FloatRegister); - RegisterOrConstant con_offset = __ ensure_simm13_or_reg($constantoffset(replicate_immI($con$$constant, 4, 2)), $tmp$$Register); - __ ldf(FloatRegisterImpl::D, $constanttablebase, con_offset, as_DoubleFloatRegister($dst$$reg)); - %} - ins_pipe(loadConFD); -%} - -// Replicate scalar to packed int values in Double register -instruct Repl2I_reg_helper(iRegL dst, iRegI src) %{ - effect(DEF dst, USE src); - format %{ "SLLX $src,32,$dst\n\t" - "SRLX $dst,32,O7\n\t" - "OR $dst,O7,$dst\t! replicate2I" %} - ins_encode( enc_repl2i(src, dst)); - ins_pipe(ialu_reg); -%} - -// Replicate scalar to packed int values in Double register -instruct Repl2I_reg(stackSlotD dst, iRegI src) %{ - match(Set dst (Replicate2I src)); - expand %{ - iRegL tmp; - Repl2I_reg_helper(tmp, src); - regL_to_stkD(dst, tmp); - %} -%} - -// Replicate scalar zero constant to packed int values in Double register -instruct Repl2I_immI(regD dst, immI con, o7RegI tmp) %{ - match(Set dst (Replicate2I con)); - effect(KILL tmp); - format %{ "LDDF [$constanttablebase + $constantoffset],$dst\t! load from constant table: Repl2I($con)" %} - ins_encode %{ - // XXX This is a quick fix for 6833573. - //__ ldf(FloatRegisterImpl::D, $constanttablebase, $constantoffset(replicate_immI($con$$constant, 2, 4)), $dst$$FloatRegister); - RegisterOrConstant con_offset = __ ensure_simm13_or_reg($constantoffset(replicate_immI($con$$constant, 2, 4)), $tmp$$Register); - __ ldf(FloatRegisterImpl::D, $constanttablebase, con_offset, as_DoubleFloatRegister($dst$$reg)); - %} - ins_pipe(loadConFD); -%} - //----------Control Flow Instructions------------------------------------------ // Compare Instructions // Compare Integers @@ -10742,6 +10475,308 @@ instruct storeS_reversed(indIndexMemory dst, iRegI src) %{ ins_pipe(istore_mem_reg); %} +// ====================VECTOR INSTRUCTIONS===================================== + +// Load Aligned Packed values into a Double Register +instruct loadV8(regD dst, memory mem) %{ + predicate(n->as_LoadVector()->memory_size() == 8); + match(Set dst (LoadVector mem)); + ins_cost(MEMORY_REF_COST); + size(4); + format %{ "LDDF $mem,$dst\t! load vector (8 bytes)" %} + ins_encode %{ + __ ldf(FloatRegisterImpl::D, $mem$$Address, as_DoubleFloatRegister($dst$$reg)); + %} + ins_pipe(floadD_mem); +%} + +// Store Vector in Double register to memory +instruct storeV8(memory mem, regD src) %{ + predicate(n->as_StoreVector()->memory_size() == 8); + match(Set mem (StoreVector mem src)); + ins_cost(MEMORY_REF_COST); + size(4); + format %{ "STDF $src,$mem\t! store vector (8 bytes)" %} + ins_encode %{ + __ stf(FloatRegisterImpl::D, as_DoubleFloatRegister($src$$reg), $mem$$Address); + %} + ins_pipe(fstoreD_mem_reg); +%} + +// Store Zero into vector in memory +instruct storeV8B_zero(memory mem, immI0 zero) %{ + predicate(n->as_StoreVector()->memory_size() == 8); + match(Set mem (StoreVector mem (ReplicateB zero))); + ins_cost(MEMORY_REF_COST); + size(4); + format %{ "STX $zero,$mem\t! store zero vector (8 bytes)" %} + ins_encode %{ + __ stx(G0, $mem$$Address); + %} + ins_pipe(fstoreD_mem_zero); +%} + +instruct storeV4S_zero(memory mem, immI0 zero) %{ + predicate(n->as_StoreVector()->memory_size() == 8); + match(Set mem (StoreVector mem (ReplicateS zero))); + ins_cost(MEMORY_REF_COST); + size(4); + format %{ "STX $zero,$mem\t! store zero vector (4 shorts)" %} + ins_encode %{ + __ stx(G0, $mem$$Address); + %} + ins_pipe(fstoreD_mem_zero); +%} + +instruct storeV2I_zero(memory mem, immI0 zero) %{ + predicate(n->as_StoreVector()->memory_size() == 8); + match(Set mem (StoreVector mem (ReplicateI zero))); + ins_cost(MEMORY_REF_COST); + size(4); + format %{ "STX $zero,$mem\t! store zero vector (2 ints)" %} + ins_encode %{ + __ stx(G0, $mem$$Address); + %} + ins_pipe(fstoreD_mem_zero); +%} + +instruct storeV2F_zero(memory mem, immF0 zero) %{ + predicate(n->as_StoreVector()->memory_size() == 8); + match(Set mem (StoreVector mem (ReplicateF zero))); + ins_cost(MEMORY_REF_COST); + size(4); + format %{ "STX $zero,$mem\t! store zero vector (2 floats)" %} + ins_encode %{ + __ stx(G0, $mem$$Address); + %} + ins_pipe(fstoreD_mem_zero); +%} + +// Replicate scalar to packed byte values into Double register +instruct Repl8B_reg(regD dst, iRegI src, iRegL tmp, o7RegL tmp2) %{ + predicate(n->as_Vector()->length() == 8 && UseVIS >= 3); + match(Set dst (ReplicateB src)); + effect(DEF dst, USE src, TEMP tmp, KILL tmp2); + format %{ "SLLX $src,56,$tmp\n\t" + "SRLX $tmp, 8,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\n\t" + "SRLX $tmp,16,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\n\t" + "SRLX $tmp,32,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\t! replicate8B\n\t" + "MOVXTOD $tmp,$dst\t! MoveL2D" %} + ins_encode %{ + Register Rsrc = $src$$Register; + Register Rtmp = $tmp$$Register; + Register Rtmp2 = $tmp2$$Register; + __ sllx(Rsrc, 56, Rtmp); + __ srlx(Rtmp, 8, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ srlx(Rtmp, 16, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ srlx(Rtmp, 32, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ movxtod(Rtmp, as_DoubleFloatRegister($dst$$reg)); + %} + ins_pipe(ialu_reg); +%} + +// Replicate scalar to packed byte values into Double stack +instruct Repl8B_stk(stackSlotD dst, iRegI src, iRegL tmp, o7RegL tmp2) %{ + predicate(n->as_Vector()->length() == 8 && UseVIS < 3); + match(Set dst (ReplicateB src)); + effect(DEF dst, USE src, TEMP tmp, KILL tmp2); + format %{ "SLLX $src,56,$tmp\n\t" + "SRLX $tmp, 8,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\n\t" + "SRLX $tmp,16,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\n\t" + "SRLX $tmp,32,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\t! replicate8B\n\t" + "STX $tmp,$dst\t! regL to stkD" %} + ins_encode %{ + Register Rsrc = $src$$Register; + Register Rtmp = $tmp$$Register; + Register Rtmp2 = $tmp2$$Register; + __ sllx(Rsrc, 56, Rtmp); + __ srlx(Rtmp, 8, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ srlx(Rtmp, 16, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ srlx(Rtmp, 32, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ set ($dst$$disp + STACK_BIAS, Rtmp2); + __ stx (Rtmp, Rtmp2, $dst$$base$$Register); + %} + ins_pipe(ialu_reg); +%} + +// Replicate scalar constant to packed byte values in Double register +instruct Repl8B_immI(regD dst, immI13 con, o7RegI tmp) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateB con)); + effect(KILL tmp); + format %{ "LDDF [$constanttablebase + $constantoffset],$dst\t! load from constant table: Repl8B($con)" %} + ins_encode %{ + // XXX This is a quick fix for 6833573. + //__ ldf(FloatRegisterImpl::D, $constanttablebase, $constantoffset(replicate_immI($con$$constant, 8, 1)), $dst$$FloatRegister); + RegisterOrConstant con_offset = __ ensure_simm13_or_reg($constantoffset(replicate_immI($con$$constant, 8, 1)), $tmp$$Register); + __ ldf(FloatRegisterImpl::D, $constanttablebase, con_offset, as_DoubleFloatRegister($dst$$reg)); + %} + ins_pipe(loadConFD); +%} + +// Replicate scalar to packed char/short values into Double register +instruct Repl4S_reg(regD dst, iRegI src, iRegL tmp, o7RegL tmp2) %{ + predicate(n->as_Vector()->length() == 4 && UseVIS >= 3); + match(Set dst (ReplicateS src)); + effect(DEF dst, USE src, TEMP tmp, KILL tmp2); + format %{ "SLLX $src,48,$tmp\n\t" + "SRLX $tmp,16,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\n\t" + "SRLX $tmp,32,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\t! replicate4S\n\t" + "MOVXTOD $tmp,$dst\t! MoveL2D" %} + ins_encode %{ + Register Rsrc = $src$$Register; + Register Rtmp = $tmp$$Register; + Register Rtmp2 = $tmp2$$Register; + __ sllx(Rsrc, 48, Rtmp); + __ srlx(Rtmp, 16, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ srlx(Rtmp, 32, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ movxtod(Rtmp, as_DoubleFloatRegister($dst$$reg)); + %} + ins_pipe(ialu_reg); +%} + +// Replicate scalar to packed char/short values into Double stack +instruct Repl4S_stk(stackSlotD dst, iRegI src, iRegL tmp, o7RegL tmp2) %{ + predicate(n->as_Vector()->length() == 4 && UseVIS < 3); + match(Set dst (ReplicateS src)); + effect(DEF dst, USE src, TEMP tmp, KILL tmp2); + format %{ "SLLX $src,48,$tmp\n\t" + "SRLX $tmp,16,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\n\t" + "SRLX $tmp,32,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\t! replicate4S\n\t" + "STX $tmp,$dst\t! regL to stkD" %} + ins_encode %{ + Register Rsrc = $src$$Register; + Register Rtmp = $tmp$$Register; + Register Rtmp2 = $tmp2$$Register; + __ sllx(Rsrc, 48, Rtmp); + __ srlx(Rtmp, 16, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ srlx(Rtmp, 32, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ set ($dst$$disp + STACK_BIAS, Rtmp2); + __ stx (Rtmp, Rtmp2, $dst$$base$$Register); + %} + ins_pipe(ialu_reg); +%} + +// Replicate scalar constant to packed char/short values in Double register +instruct Repl4S_immI(regD dst, immI con, o7RegI tmp) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateS con)); + effect(KILL tmp); + format %{ "LDDF [$constanttablebase + $constantoffset],$dst\t! load from constant table: Repl4S($con)" %} + ins_encode %{ + // XXX This is a quick fix for 6833573. + //__ ldf(FloatRegisterImpl::D, $constanttablebase, $constantoffset(replicate_immI($con$$constant, 4, 2)), $dst$$FloatRegister); + RegisterOrConstant con_offset = __ ensure_simm13_or_reg($constantoffset(replicate_immI($con$$constant, 4, 2)), $tmp$$Register); + __ ldf(FloatRegisterImpl::D, $constanttablebase, con_offset, as_DoubleFloatRegister($dst$$reg)); + %} + ins_pipe(loadConFD); +%} + +// Replicate scalar to packed int values into Double register +instruct Repl2I_reg(regD dst, iRegI src, iRegL tmp, o7RegL tmp2) %{ + predicate(n->as_Vector()->length() == 2 && UseVIS >= 3); + match(Set dst (ReplicateI src)); + effect(DEF dst, USE src, TEMP tmp, KILL tmp2); + format %{ "SLLX $src,32,$tmp\n\t" + "SRLX $tmp,32,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\t! replicate2I\n\t" + "MOVXTOD $tmp,$dst\t! MoveL2D" %} + ins_encode %{ + Register Rsrc = $src$$Register; + Register Rtmp = $tmp$$Register; + Register Rtmp2 = $tmp2$$Register; + __ sllx(Rsrc, 32, Rtmp); + __ srlx(Rtmp, 32, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ movxtod(Rtmp, as_DoubleFloatRegister($dst$$reg)); + %} + ins_pipe(ialu_reg); +%} + +// Replicate scalar to packed int values into Double stack +instruct Repl2I_stk(stackSlotD dst, iRegI src, iRegL tmp, o7RegL tmp2) %{ + predicate(n->as_Vector()->length() == 2 && UseVIS < 3); + match(Set dst (ReplicateI src)); + effect(DEF dst, USE src, TEMP tmp, KILL tmp2); + format %{ "SLLX $src,32,$tmp\n\t" + "SRLX $tmp,32,$tmp2\n\t" + "OR $tmp,$tmp2,$tmp\t! replicate2I\n\t" + "STX $tmp,$dst\t! regL to stkD" %} + ins_encode %{ + Register Rsrc = $src$$Register; + Register Rtmp = $tmp$$Register; + Register Rtmp2 = $tmp2$$Register; + __ sllx(Rsrc, 32, Rtmp); + __ srlx(Rtmp, 32, Rtmp2); + __ or3 (Rtmp, Rtmp2, Rtmp); + __ set ($dst$$disp + STACK_BIAS, Rtmp2); + __ stx (Rtmp, Rtmp2, $dst$$base$$Register); + %} + ins_pipe(ialu_reg); +%} + +// Replicate scalar zero constant to packed int values in Double register +instruct Repl2I_immI(regD dst, immI con, o7RegI tmp) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateI con)); + effect(KILL tmp); + format %{ "LDDF [$constanttablebase + $constantoffset],$dst\t! load from constant table: Repl2I($con)" %} + ins_encode %{ + // XXX This is a quick fix for 6833573. + //__ ldf(FloatRegisterImpl::D, $constanttablebase, $constantoffset(replicate_immI($con$$constant, 2, 4)), $dst$$FloatRegister); + RegisterOrConstant con_offset = __ ensure_simm13_or_reg($constantoffset(replicate_immI($con$$constant, 2, 4)), $tmp$$Register); + __ ldf(FloatRegisterImpl::D, $constanttablebase, con_offset, as_DoubleFloatRegister($dst$$reg)); + %} + ins_pipe(loadConFD); +%} + +// Replicate scalar to packed float values into Double stack +instruct Repl2F_stk(stackSlotD dst, regF src) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateF src)); + ins_cost(MEMORY_REF_COST*2); + format %{ "STF $src,$dst.hi\t! packed2F\n\t" + "STF $src,$dst.lo" %} + opcode(Assembler::stf_op3); + ins_encode(simple_form3_mem_reg(dst, src), form3_mem_plus_4_reg(dst, src)); + ins_pipe(fstoreF_stk_reg); +%} + +// Replicate scalar zero constant to packed float values in Double register +instruct Repl2F_immF(regD dst, immF con, o7RegI tmp) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateF con)); + effect(KILL tmp); + format %{ "LDDF [$constanttablebase + $constantoffset],$dst\t! load from constant table: Repl2F($con)" %} + ins_encode %{ + // XXX This is a quick fix for 6833573. + //__ ldf(FloatRegisterImpl::D, $constanttablebase, $constantoffset(replicate_immF($con$$constant)), $dst$$FloatRegister); + RegisterOrConstant con_offset = __ ensure_simm13_or_reg($constantoffset(replicate_immF($con$$constant)), $tmp$$Register); + __ ldf(FloatRegisterImpl::D, $constanttablebase, con_offset, as_DoubleFloatRegister($dst$$reg)); + %} + ins_pipe(loadConFD); +%} + //----------PEEPHOLE RULES----------------------------------------------------- // These must follow all instruction definitions as they use the names // defined in the instructions definitions. diff --git a/hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp b/hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp index 1d4966217a0..ce1b0286067 100644 --- a/hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp +++ b/hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -217,6 +217,8 @@ void VM_Version::initialize() { // Currently not supported anywhere. FLAG_SET_DEFAULT(UseFPUForSpilling, false); + MaxVectorSize = 8; + assert((InteriorEntryAlignment % relocInfo::addr_unit()) == 0, "alignment is not a multiple of NOP size"); #endif diff --git a/hotspot/src/cpu/x86/vm/assembler_x86.cpp b/hotspot/src/cpu/x86/vm/assembler_x86.cpp index 8409fd73e18..bc17edba531 100644 --- a/hotspot/src/cpu/x86/vm/assembler_x86.cpp +++ b/hotspot/src/cpu/x86/vm/assembler_x86.cpp @@ -1637,6 +1637,13 @@ void Assembler::movaps(XMMRegister dst, XMMRegister src) { emit_byte(0xC0 | encode); } +void Assembler::movlhps(XMMRegister dst, XMMRegister src) { + NOT_LP64(assert(VM_Version::supports_sse(), "")); + int encode = simd_prefix_and_encode(dst, src, src, VEX_SIMD_NONE); + emit_byte(0x16); + emit_byte(0xC0 | encode); +} + void Assembler::movb(Register dst, Address src) { NOT_LP64(assert(dst->has_byte_register(), "must have byte register")); InstructionMark im(this); @@ -1686,6 +1693,14 @@ void Assembler::movdl(XMMRegister dst, Address src) { emit_operand(dst, src); } +void Assembler::movdl(Address dst, XMMRegister src) { + NOT_LP64(assert(VM_Version::supports_sse2(), "")); + InstructionMark im(this); + simd_prefix(dst, src, VEX_SIMD_66); + emit_byte(0x7E); + emit_operand(src, dst); +} + void Assembler::movdqa(XMMRegister dst, XMMRegister src) { NOT_LP64(assert(VM_Version::supports_sse2(), "")); int encode = simd_prefix_and_encode(dst, src, VEX_SIMD_66); @@ -1716,6 +1731,35 @@ void Assembler::movdqu(Address dst, XMMRegister src) { emit_operand(src, dst); } +// Move Unaligned 256bit Vector +void Assembler::vmovdqu(XMMRegister dst, XMMRegister src) { + assert(UseAVX, ""); + bool vector256 = true; + int encode = vex_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_F3, vector256); + emit_byte(0x6F); + emit_byte(0xC0 | encode); +} + +void Assembler::vmovdqu(XMMRegister dst, Address src) { + assert(UseAVX, ""); + InstructionMark im(this); + bool vector256 = true; + vex_prefix(dst, xnoreg, src, VEX_SIMD_F3, vector256); + emit_byte(0x6F); + emit_operand(dst, src); +} + +void Assembler::vmovdqu(Address dst, XMMRegister src) { + assert(UseAVX, ""); + InstructionMark im(this); + bool vector256 = true; + // swap src<->dst for encoding + assert(src != xnoreg, "sanity"); + vex_prefix(src, xnoreg, dst, VEX_SIMD_F3, vector256); + emit_byte(0x7F); + emit_operand(src, dst); +} + // Uses zero extension on 64bit void Assembler::movl(Register dst, int32_t imm32) { @@ -3112,6 +3156,13 @@ void Assembler::vxorpd(XMMRegister dst, XMMRegister nds, Address src) { emit_operand(dst, src); } +void Assembler::vxorpd(XMMRegister dst, XMMRegister nds, XMMRegister src, bool vector256) { + assert(VM_Version::supports_avx(), ""); + int encode = vex_prefix_and_encode(dst, nds, src, VEX_SIMD_66, vector256); + emit_byte(0x57); + emit_byte(0xC0 | encode); +} + void Assembler::vxorps(XMMRegister dst, XMMRegister nds, Address src) { assert(VM_Version::supports_avx(), ""); InstructionMark im(this); @@ -3120,6 +3171,30 @@ void Assembler::vxorps(XMMRegister dst, XMMRegister nds, Address src) { emit_operand(dst, src); } +void Assembler::vxorps(XMMRegister dst, XMMRegister nds, XMMRegister src, bool vector256) { + assert(VM_Version::supports_avx(), ""); + int encode = vex_prefix_and_encode(dst, nds, src, VEX_SIMD_NONE, vector256); + emit_byte(0x57); + emit_byte(0xC0 | encode); +} + +void Assembler::vinsertf128h(XMMRegister dst, XMMRegister nds, XMMRegister src) { + assert(VM_Version::supports_avx(), ""); + bool vector256 = true; + int encode = vex_prefix_and_encode(dst, nds, src, VEX_SIMD_66, vector256, VEX_OPCODE_0F_3A); + emit_byte(0x18); + emit_byte(0xC0 | encode); + // 0x00 - insert into lower 128 bits + // 0x01 - insert into upper 128 bits + emit_byte(0x01); +} + +void Assembler::vzeroupper() { + assert(VM_Version::supports_avx(), ""); + (void)vex_prefix_and_encode(xmm0, xmm0, xmm0, VEX_SIMD_NONE); + emit_byte(0x77); +} + #ifndef _LP64 // 32bit only pieces of the assembler diff --git a/hotspot/src/cpu/x86/vm/assembler_x86.hpp b/hotspot/src/cpu/x86/vm/assembler_x86.hpp index 2e2fca03354..0746c827124 100644 --- a/hotspot/src/cpu/x86/vm/assembler_x86.hpp +++ b/hotspot/src/cpu/x86/vm/assembler_x86.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -591,8 +591,9 @@ private: void vex_prefix(XMMRegister dst, XMMRegister nds, Address src, VexSimdPrefix pre, bool vector256 = false) { - vex_prefix(src, nds->encoding(), dst->encoding(), - pre, VEX_OPCODE_0F, false, vector256); + int dst_enc = dst->encoding(); + int nds_enc = nds->is_valid() ? nds->encoding() : 0; + vex_prefix(src, nds_enc, dst_enc, pre, VEX_OPCODE_0F, false, vector256); } int vex_prefix_and_encode(int dst_enc, int nds_enc, int src_enc, @@ -600,9 +601,12 @@ private: bool vex_w, bool vector256); int vex_prefix_and_encode(XMMRegister dst, XMMRegister nds, XMMRegister src, - VexSimdPrefix pre, bool vector256 = false) { - return vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), - pre, VEX_OPCODE_0F, false, vector256); + VexSimdPrefix pre, bool vector256 = false, + VexOpcode opc = VEX_OPCODE_0F) { + int src_enc = src->encoding(); + int dst_enc = dst->encoding(); + int nds_enc = nds->is_valid() ? nds->encoding() : 0; + return vex_prefix_and_encode(dst_enc, nds_enc, src_enc, pre, opc, false, vector256); } void simd_prefix(XMMRegister xreg, XMMRegister nds, Address adr, @@ -1261,6 +1265,7 @@ private: void movdl(XMMRegister dst, Register src); void movdl(Register dst, XMMRegister src); void movdl(XMMRegister dst, Address src); + void movdl(Address dst, XMMRegister src); // Move Double Quadword void movdq(XMMRegister dst, Register src); @@ -1274,6 +1279,14 @@ private: void movdqu(XMMRegister dst, Address src); void movdqu(XMMRegister dst, XMMRegister src); + // Move Unaligned 256bit Vector + void vmovdqu(Address dst, XMMRegister src); + void vmovdqu(XMMRegister dst, Address src); + void vmovdqu(XMMRegister dst, XMMRegister src); + + // Move lower 64bit to high 64bit in 128bit register + void movlhps(XMMRegister dst, XMMRegister src); + void movl(Register dst, int32_t imm32); void movl(Address dst, int32_t imm32); void movl(Register dst, Register src); @@ -1615,6 +1628,17 @@ private: void vxorpd(XMMRegister dst, XMMRegister nds, Address src); void vxorps(XMMRegister dst, XMMRegister nds, Address src); + // AVX Vector instrucitons. + void vxorpd(XMMRegister dst, XMMRegister nds, XMMRegister src, bool vector256); + void vxorps(XMMRegister dst, XMMRegister nds, XMMRegister src, bool vector256); + void vinsertf128h(XMMRegister dst, XMMRegister nds, XMMRegister src); + + // AVX instruction which is used to clear upper 128 bits of YMM registers and + // to avoid transaction penalty between AVX and SSE states. There is no + // penalty if legacy SSE instructions are encoded using VEX prefix because + // they always clear upper 128 bits. It should be used before calling + // runtime code and native libraries. + void vzeroupper(); protected: // Next instructions require address alignment 16 bytes SSE mode. @@ -2529,9 +2553,13 @@ public: void vsubss(XMMRegister dst, XMMRegister nds, Address src) { Assembler::vsubss(dst, nds, src); } void vsubss(XMMRegister dst, XMMRegister nds, AddressLiteral src); + // AVX Vector instructions + + void vxorpd(XMMRegister dst, XMMRegister nds, XMMRegister src, bool vector256) { Assembler::vxorpd(dst, nds, src, vector256); } void vxorpd(XMMRegister dst, XMMRegister nds, Address src) { Assembler::vxorpd(dst, nds, src); } void vxorpd(XMMRegister dst, XMMRegister nds, AddressLiteral src); + void vxorps(XMMRegister dst, XMMRegister nds, XMMRegister src, bool vector256) { Assembler::vxorps(dst, nds, src, vector256); } void vxorps(XMMRegister dst, XMMRegister nds, Address src) { Assembler::vxorps(dst, nds, src); } void vxorps(XMMRegister dst, XMMRegister nds, AddressLiteral src); diff --git a/hotspot/src/cpu/x86/vm/register_x86.cpp b/hotspot/src/cpu/x86/vm/register_x86.cpp index a6301eafe4d..a3763a3498f 100644 --- a/hotspot/src/cpu/x86/vm/register_x86.cpp +++ b/hotspot/src/cpu/x86/vm/register_x86.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -35,7 +35,7 @@ const int ConcreteRegisterImpl::max_gpr = RegisterImpl::number_of_registers << 1 const int ConcreteRegisterImpl::max_fpr = ConcreteRegisterImpl::max_gpr + 2 * FloatRegisterImpl::number_of_registers; const int ConcreteRegisterImpl::max_xmm = ConcreteRegisterImpl::max_fpr + - 2 * XMMRegisterImpl::number_of_registers; + 8 * XMMRegisterImpl::number_of_registers; const char* RegisterImpl::name() const { const char* names[number_of_registers] = { #ifndef AMD64 diff --git a/hotspot/src/cpu/x86/vm/register_x86.hpp b/hotspot/src/cpu/x86/vm/register_x86.hpp index 2f4cd0dcac6..680dd900a48 100644 --- a/hotspot/src/cpu/x86/vm/register_x86.hpp +++ b/hotspot/src/cpu/x86/vm/register_x86.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -158,7 +158,7 @@ class XMMRegisterImpl: public AbstractRegisterImpl { XMMRegister successor() const { return as_XMMRegister(encoding() + 1); } // accessors - int encoding() const { assert(is_valid(), "invalid register"); return (intptr_t)this; } + int encoding() const { assert(is_valid(), err_msg("invalid register (%d)", (int)(intptr_t)this )); return (intptr_t)this; } bool is_valid() const { return 0 <= (intptr_t)this && (intptr_t)this < number_of_registers; } const char* name() const; }; @@ -216,7 +216,7 @@ class ConcreteRegisterImpl : public AbstractRegisterImpl { RegisterImpl::number_of_registers + // "H" half of a 64bit register #endif // AMD64 2 * FloatRegisterImpl::number_of_registers + - 2 * XMMRegisterImpl::number_of_registers + + 8 * XMMRegisterImpl::number_of_registers + 1 // eflags }; diff --git a/hotspot/src/cpu/x86/vm/vm_version_x86.cpp b/hotspot/src/cpu/x86/vm/vm_version_x86.cpp index 121be7a2ba7..2cc0231db93 100644 --- a/hotspot/src/cpu/x86/vm/vm_version_x86.cpp +++ b/hotspot/src/cpu/x86/vm/vm_version_x86.cpp @@ -467,6 +467,32 @@ void VM_Version::get_processor_features() { if (!supports_avx ()) // Drop to 0 if no AVX support UseAVX = 0; +#ifdef COMPILER2 + if (UseFPUForSpilling) { + if (UseSSE < 2) { + // Only supported with SSE2+ + FLAG_SET_DEFAULT(UseFPUForSpilling, false); + } + } + if (MaxVectorSize > 0) { + if (!is_power_of_2(MaxVectorSize)) { + warning("MaxVectorSize must be a power of 2"); + FLAG_SET_DEFAULT(MaxVectorSize, 32); + } + if (MaxVectorSize > 32) { + FLAG_SET_DEFAULT(MaxVectorSize, 32); + } + if (MaxVectorSize > 16 && UseAVX == 0) { + // Only supported with AVX+ + FLAG_SET_DEFAULT(MaxVectorSize, 16); + } + if (UseSSE < 2) { + // Only supported with SSE2+ + FLAG_SET_DEFAULT(MaxVectorSize, 0); + } + } +#endif + // On new cpus instructions which update whole XMM register should be used // to prevent partial register stall due to dependencies on high half. // @@ -544,6 +570,12 @@ void VM_Version::get_processor_features() { } } +#ifdef COMPILER2 + if (MaxVectorSize > 16) { + // Limit vectors size to 16 bytes on current AMD cpus. + FLAG_SET_DEFAULT(MaxVectorSize, 16); + } +#endif // COMPILER2 } if( is_intel() ) { // Intel cpus specific settings @@ -606,15 +638,6 @@ void VM_Version::get_processor_features() { FLAG_SET_DEFAULT(UsePopCountInstruction, false); } -#ifdef COMPILER2 - if (UseFPUForSpilling) { - if (UseSSE < 2) { - // Only supported with SSE2+ - FLAG_SET_DEFAULT(UseFPUForSpilling, false); - } - } -#endif - assert(0 <= ReadPrefetchInstr && ReadPrefetchInstr <= 3, "invalid value"); assert(0 <= AllocatePrefetchInstr && AllocatePrefetchInstr <= 3, "invalid value"); diff --git a/hotspot/src/cpu/x86/vm/vmreg_x86.cpp b/hotspot/src/cpu/x86/vm/vmreg_x86.cpp index a0bfe6e69c1..89959771ea2 100644 --- a/hotspot/src/cpu/x86/vm/vmreg_x86.cpp +++ b/hotspot/src/cpu/x86/vm/vmreg_x86.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -48,8 +48,9 @@ void VMRegImpl::set_regName() { XMMRegister xreg = ::as_XMMRegister(0); for ( ; i < ConcreteRegisterImpl::max_xmm ; ) { - regName[i++] = xreg->name(); - regName[i++] = xreg->name(); + for (int j = 0 ; j < 8 ; j++) { + regName[i++] = xreg->name(); + } xreg = xreg->successor(); } for ( ; i < ConcreteRegisterImpl::number_of_registers ; i ++ ) { diff --git a/hotspot/src/cpu/x86/vm/vmreg_x86.inline.hpp b/hotspot/src/cpu/x86/vm/vmreg_x86.inline.hpp index 88201bd3d83..0608d3edbff 100644 --- a/hotspot/src/cpu/x86/vm/vmreg_x86.inline.hpp +++ b/hotspot/src/cpu/x86/vm/vmreg_x86.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -39,7 +39,7 @@ inline VMReg FloatRegisterImpl::as_VMReg() { } inline VMReg XMMRegisterImpl::as_VMReg() { - return VMRegImpl::as_VMReg((encoding() << 1) + ConcreteRegisterImpl::max_fpr); + return VMRegImpl::as_VMReg((encoding() << 3) + ConcreteRegisterImpl::max_fpr); } @@ -75,7 +75,7 @@ inline FloatRegister VMRegImpl::as_FloatRegister() { inline XMMRegister VMRegImpl::as_XMMRegister() { assert( is_XMMRegister() && is_even(value()), "must be" ); // Yuk - return ::as_XMMRegister((value() - ConcreteRegisterImpl::max_fpr) >> 1); + return ::as_XMMRegister((value() - ConcreteRegisterImpl::max_fpr) >> 3); } inline bool VMRegImpl::is_concrete() { diff --git a/hotspot/src/cpu/x86/vm/x86.ad b/hotspot/src/cpu/x86/vm/x86.ad index 6bd91287fc0..faa00d70373 100644 --- a/hotspot/src/cpu/x86/vm/x86.ad +++ b/hotspot/src/cpu/x86/vm/x86.ad @@ -24,6 +24,456 @@ // X86 Common Architecture Description File +//----------REGISTER DEFINITION BLOCK------------------------------------------ +// This information is used by the matcher and the register allocator to +// describe individual registers and classes of registers within the target +// archtecture. + +register %{ +//----------Architecture Description Register Definitions---------------------- +// General Registers +// "reg_def" name ( register save type, C convention save type, +// ideal register type, encoding ); +// Register Save Types: +// +// NS = No-Save: The register allocator assumes that these registers +// can be used without saving upon entry to the method, & +// that they do not need to be saved at call sites. +// +// SOC = Save-On-Call: The register allocator assumes that these registers +// can be used without saving upon entry to the method, +// but that they must be saved at call sites. +// +// SOE = Save-On-Entry: The register allocator assumes that these registers +// must be saved before using them upon entry to the +// method, but they do not need to be saved at call +// sites. +// +// AS = Always-Save: The register allocator assumes that these registers +// must be saved before using them upon entry to the +// method, & that they must be saved at call sites. +// +// Ideal Register Type is used to determine how to save & restore a +// register. Op_RegI will get spilled with LoadI/StoreI, Op_RegP will get +// spilled with LoadP/StoreP. If the register supports both, use Op_RegI. +// +// The encoding number is the actual bit-pattern placed into the opcodes. + +// XMM registers. 256-bit registers or 8 words each, labeled (a)-h. +// Word a in each register holds a Float, words ab hold a Double. +// The whole registers are used in SSE4.2 version intrinsics, +// array copy stubs and superword operations (see UseSSE42Intrinsics, +// UseXMMForArrayCopy and UseSuperword flags). +// XMM8-XMM15 must be encoded with REX (VEX for UseAVX). +// Linux ABI: No register preserved across function calls +// XMM0-XMM7 might hold parameters +// Windows ABI: XMM6-XMM15 preserved across function calls +// XMM0-XMM3 might hold parameters + +reg_def XMM0 ( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()); +reg_def XMM0b( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()->next()); +reg_def XMM0c( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()->next()->next()); +reg_def XMM0d( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()->next()->next()->next()); +reg_def XMM0e( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()->next()->next()->next()->next()); +reg_def XMM0f( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM0g( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM0h( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM1 ( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()); +reg_def XMM1b( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()->next()); +reg_def XMM1c( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()->next()->next()); +reg_def XMM1d( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()->next()->next()->next()); +reg_def XMM1e( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()->next()->next()->next()->next()); +reg_def XMM1f( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM1g( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM1h( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM2 ( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()); +reg_def XMM2b( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()->next()); +reg_def XMM2c( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()->next()->next()); +reg_def XMM2d( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()->next()->next()->next()); +reg_def XMM2e( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()->next()->next()->next()->next()); +reg_def XMM2f( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM2g( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM2h( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM3 ( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()); +reg_def XMM3b( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()->next()); +reg_def XMM3c( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()->next()->next()); +reg_def XMM3d( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()->next()->next()->next()); +reg_def XMM3e( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()->next()->next()->next()->next()); +reg_def XMM3f( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM3g( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM3h( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM4 ( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()); +reg_def XMM4b( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()->next()); +reg_def XMM4c( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()->next()->next()); +reg_def XMM4d( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()->next()->next()->next()); +reg_def XMM4e( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()->next()->next()->next()->next()); +reg_def XMM4f( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM4g( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM4h( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM5 ( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()); +reg_def XMM5b( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()->next()); +reg_def XMM5c( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()->next()->next()); +reg_def XMM5d( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()->next()->next()->next()); +reg_def XMM5e( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()->next()->next()->next()->next()); +reg_def XMM5f( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM5g( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM5h( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +#ifdef _WIN64 + +reg_def XMM6 ( SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()); +reg_def XMM6b( SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()->next()); +reg_def XMM6c( SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()->next()->next()); +reg_def XMM6d( SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()); +reg_def XMM6e( SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()->next()); +reg_def XMM6f( SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM6g( SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM6h( SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM7 ( SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()); +reg_def XMM7b( SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()->next()); +reg_def XMM7c( SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()->next()->next()); +reg_def XMM7d( SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()); +reg_def XMM7e( SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()->next()); +reg_def XMM7f( SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM7g( SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM7h( SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM8 ( SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()); +reg_def XMM8b( SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()->next()); +reg_def XMM8c( SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()->next()->next()); +reg_def XMM8d( SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()); +reg_def XMM8e( SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()->next()); +reg_def XMM8f( SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM8g( SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM8h( SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM9 ( SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()); +reg_def XMM9b( SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()->next()); +reg_def XMM9c( SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()->next()->next()); +reg_def XMM9d( SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()); +reg_def XMM9e( SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()->next()); +reg_def XMM9f( SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM9g( SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM9h( SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM10 ( SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()); +reg_def XMM10b( SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()->next()); +reg_def XMM10c( SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()->next()->next()); +reg_def XMM10d( SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()); +reg_def XMM10e( SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()->next()); +reg_def XMM10f( SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM10g( SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM10h( SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM11 ( SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()); +reg_def XMM11b( SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()->next()); +reg_def XMM11c( SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()->next()->next()); +reg_def XMM11d( SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()); +reg_def XMM11e( SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()->next()); +reg_def XMM11f( SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM11g( SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM11h( SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM12 ( SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()); +reg_def XMM12b( SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()->next()); +reg_def XMM12c( SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()->next()->next()); +reg_def XMM12d( SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()); +reg_def XMM12e( SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()->next()); +reg_def XMM12f( SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM12g( SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM12h( SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM13 ( SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()); +reg_def XMM13b( SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()->next()); +reg_def XMM13c( SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()->next()->next()); +reg_def XMM13d( SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()); +reg_def XMM13e( SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()->next()); +reg_def XMM13f( SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM13g( SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM13h( SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM14 ( SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()); +reg_def XMM14b( SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()->next()); +reg_def XMM14c( SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()->next()->next()); +reg_def XMM14d( SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()); +reg_def XMM14e( SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()->next()); +reg_def XMM14f( SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM14g( SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM14h( SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM15 ( SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()); +reg_def XMM15b( SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()->next()); +reg_def XMM15c( SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()->next()->next()); +reg_def XMM15d( SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()); +reg_def XMM15e( SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()->next()); +reg_def XMM15f( SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM15g( SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM15h( SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +#else // _WIN64 + +reg_def XMM6 ( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()); +reg_def XMM6b( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()->next()); +reg_def XMM6c( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()->next()->next()); +reg_def XMM6d( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()); +reg_def XMM6e( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()->next()); +reg_def XMM6f( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM6g( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM6h( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM7 ( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()); +reg_def XMM7b( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()); +reg_def XMM7c( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()->next()); +reg_def XMM7d( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()); +reg_def XMM7e( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()->next()); +reg_def XMM7f( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM7g( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM7h( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +#ifdef _LP64 + +reg_def XMM8 ( SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()); +reg_def XMM8b( SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()->next()); +reg_def XMM8c( SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()->next()->next()); +reg_def XMM8d( SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()); +reg_def XMM8e( SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()->next()); +reg_def XMM8f( SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM8g( SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM8h( SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM9 ( SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()); +reg_def XMM9b( SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()->next()); +reg_def XMM9c( SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()->next()->next()); +reg_def XMM9d( SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()); +reg_def XMM9e( SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()->next()); +reg_def XMM9f( SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM9g( SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM9h( SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM10 ( SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()); +reg_def XMM10b( SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()->next()); +reg_def XMM10c( SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()->next()->next()); +reg_def XMM10d( SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()); +reg_def XMM10e( SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()->next()); +reg_def XMM10f( SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM10g( SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM10h( SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM11 ( SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()); +reg_def XMM11b( SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()->next()); +reg_def XMM11c( SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()->next()->next()); +reg_def XMM11d( SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()); +reg_def XMM11e( SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()->next()); +reg_def XMM11f( SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM11g( SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM11h( SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM12 ( SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()); +reg_def XMM12b( SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()->next()); +reg_def XMM12c( SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()->next()->next()); +reg_def XMM12d( SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()); +reg_def XMM12e( SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()->next()); +reg_def XMM12f( SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM12g( SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM12h( SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM13 ( SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()); +reg_def XMM13b( SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()->next()); +reg_def XMM13c( SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()->next()->next()); +reg_def XMM13d( SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()); +reg_def XMM13e( SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()->next()); +reg_def XMM13f( SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM13g( SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM13h( SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM14 ( SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()); +reg_def XMM14b( SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()->next()); +reg_def XMM14c( SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()->next()->next()); +reg_def XMM14d( SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()); +reg_def XMM14e( SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()->next()); +reg_def XMM14f( SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM14g( SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM14h( SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +reg_def XMM15 ( SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()); +reg_def XMM15b( SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()->next()); +reg_def XMM15c( SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()->next()->next()); +reg_def XMM15d( SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()); +reg_def XMM15e( SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()->next()); +reg_def XMM15f( SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()->next()->next()); +reg_def XMM15g( SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()->next()->next()->next()); +reg_def XMM15h( SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()->next()->next()->next()->next()->next()->next()->next()); + +#endif // _LP64 + +#endif // _WIN64 + +#ifdef _LP64 +reg_def RFLAGS(SOC, SOC, 0, 16, VMRegImpl::Bad()); +#else +reg_def RFLAGS(SOC, SOC, 0, 8, VMRegImpl::Bad()); +#endif // _LP64 + +alloc_class chunk1(XMM0, XMM0b, XMM0c, XMM0d, XMM0e, XMM0f, XMM0g, XMM0h, + XMM1, XMM1b, XMM1c, XMM1d, XMM1e, XMM1f, XMM1g, XMM1h, + XMM2, XMM2b, XMM2c, XMM2d, XMM2e, XMM2f, XMM2g, XMM2h, + XMM3, XMM3b, XMM3c, XMM3d, XMM3e, XMM3f, XMM3g, XMM3h, + XMM4, XMM4b, XMM4c, XMM4d, XMM4e, XMM4f, XMM4g, XMM4h, + XMM5, XMM5b, XMM5c, XMM5d, XMM5e, XMM5f, XMM5g, XMM5h, + XMM6, XMM6b, XMM6c, XMM6d, XMM6e, XMM6f, XMM6g, XMM6h, + XMM7, XMM7b, XMM7c, XMM7d, XMM7e, XMM7f, XMM7g, XMM7h +#ifdef _LP64 + ,XMM8, XMM8b, XMM8c, XMM8d, XMM8e, XMM8f, XMM8g, XMM8h, + XMM9, XMM9b, XMM9c, XMM9d, XMM9e, XMM9f, XMM9g, XMM9h, + XMM10, XMM10b, XMM10c, XMM10d, XMM10e, XMM10f, XMM10g, XMM10h, + XMM11, XMM11b, XMM11c, XMM11d, XMM11e, XMM11f, XMM11g, XMM11h, + XMM12, XMM12b, XMM12c, XMM12d, XMM12e, XMM12f, XMM12g, XMM12h, + XMM13, XMM13b, XMM13c, XMM13d, XMM13e, XMM13f, XMM13g, XMM13h, + XMM14, XMM14b, XMM14c, XMM14d, XMM14e, XMM14f, XMM14g, XMM14h, + XMM15, XMM15b, XMM15c, XMM15d, XMM15e, XMM15f, XMM15g, XMM15h +#endif + ); + +// flags allocation class should be last. +alloc_class chunk2(RFLAGS); + +// Singleton class for condition codes +reg_class int_flags(RFLAGS); + +// Class for all float registers +reg_class float_reg(XMM0, + XMM1, + XMM2, + XMM3, + XMM4, + XMM5, + XMM6, + XMM7 +#ifdef _LP64 + ,XMM8, + XMM9, + XMM10, + XMM11, + XMM12, + XMM13, + XMM14, + XMM15 +#endif + ); + +// Class for all double registers +reg_class double_reg(XMM0, XMM0b, + XMM1, XMM1b, + XMM2, XMM2b, + XMM3, XMM3b, + XMM4, XMM4b, + XMM5, XMM5b, + XMM6, XMM6b, + XMM7, XMM7b +#ifdef _LP64 + ,XMM8, XMM8b, + XMM9, XMM9b, + XMM10, XMM10b, + XMM11, XMM11b, + XMM12, XMM12b, + XMM13, XMM13b, + XMM14, XMM14b, + XMM15, XMM15b +#endif + ); + +// Class for all 32bit vector registers +reg_class vectors_reg(XMM0, + XMM1, + XMM2, + XMM3, + XMM4, + XMM5, + XMM6, + XMM7 +#ifdef _LP64 + ,XMM8, + XMM9, + XMM10, + XMM11, + XMM12, + XMM13, + XMM14, + XMM15 +#endif + ); + +// Class for all 64bit vector registers +reg_class vectord_reg(XMM0, XMM0b, + XMM1, XMM1b, + XMM2, XMM2b, + XMM3, XMM3b, + XMM4, XMM4b, + XMM5, XMM5b, + XMM6, XMM6b, + XMM7, XMM7b +#ifdef _LP64 + ,XMM8, XMM8b, + XMM9, XMM9b, + XMM10, XMM10b, + XMM11, XMM11b, + XMM12, XMM12b, + XMM13, XMM13b, + XMM14, XMM14b, + XMM15, XMM15b +#endif + ); + +// Class for all 128bit vector registers +reg_class vectorx_reg(XMM0, XMM0b, XMM0c, XMM0d, + XMM1, XMM1b, XMM1c, XMM1d, + XMM2, XMM2b, XMM2c, XMM2d, + XMM3, XMM3b, XMM3c, XMM3d, + XMM4, XMM4b, XMM4c, XMM4d, + XMM5, XMM5b, XMM5c, XMM5d, + XMM6, XMM6b, XMM6c, XMM6d, + XMM7, XMM7b, XMM7c, XMM7d +#ifdef _LP64 + ,XMM8, XMM8b, XMM8c, XMM8d, + XMM9, XMM9b, XMM9c, XMM9d, + XMM10, XMM10b, XMM10c, XMM10d, + XMM11, XMM11b, XMM11c, XMM11d, + XMM12, XMM12b, XMM12c, XMM12d, + XMM13, XMM13b, XMM13c, XMM13d, + XMM14, XMM14b, XMM14c, XMM14d, + XMM15, XMM15b, XMM15c, XMM15d +#endif + ); + +// Class for all 256bit vector registers +reg_class vectory_reg(XMM0, XMM0b, XMM0c, XMM0d, XMM0e, XMM0f, XMM0g, XMM0h, + XMM1, XMM1b, XMM1c, XMM1d, XMM1e, XMM1f, XMM1g, XMM1h, + XMM2, XMM2b, XMM2c, XMM2d, XMM2e, XMM2f, XMM2g, XMM2h, + XMM3, XMM3b, XMM3c, XMM3d, XMM3e, XMM3f, XMM3g, XMM3h, + XMM4, XMM4b, XMM4c, XMM4d, XMM4e, XMM4f, XMM4g, XMM4h, + XMM5, XMM5b, XMM5c, XMM5d, XMM5e, XMM5f, XMM5g, XMM5h, + XMM6, XMM6b, XMM6c, XMM6d, XMM6e, XMM6f, XMM6g, XMM6h, + XMM7, XMM7b, XMM7c, XMM7d, XMM7e, XMM7f, XMM7g, XMM7h +#ifdef _LP64 + ,XMM8, XMM8b, XMM8c, XMM8d, XMM8e, XMM8f, XMM8g, XMM8h, + XMM9, XMM9b, XMM9c, XMM9d, XMM9e, XMM9f, XMM9g, XMM9h, + XMM10, XMM10b, XMM10c, XMM10d, XMM10e, XMM10f, XMM10g, XMM10h, + XMM11, XMM11b, XMM11c, XMM11d, XMM11e, XMM11f, XMM11g, XMM11h, + XMM12, XMM12b, XMM12c, XMM12d, XMM12e, XMM12f, XMM12g, XMM12h, + XMM13, XMM13b, XMM13c, XMM13d, XMM13e, XMM13f, XMM13g, XMM13h, + XMM14, XMM14b, XMM14c, XMM14d, XMM14e, XMM14f, XMM14g, XMM14h, + XMM15, XMM15b, XMM15c, XMM15d, XMM15e, XMM15f, XMM15g, XMM15h +#endif + ); + +%} + source %{ // Float masks come from different places depending on platform. #ifdef _LP64 @@ -38,6 +488,252 @@ source %{ static address double_signflip() { return (address)double_signflip_pool; } #endif +// Map Types to machine register types +const int Matcher::base2reg[Type::lastype] = { + Node::NotAMachineReg,0,0, Op_RegI, Op_RegL, 0, Op_RegN, + Node::NotAMachineReg, Node::NotAMachineReg, /* tuple, array */ + Op_VecS, Op_VecD, Op_VecX, Op_VecY, /* Vectors */ + Op_RegP, Op_RegP, Op_RegP, Op_RegP, Op_RegP, Op_RegP, /* the pointers */ + 0, 0/*abio*/, + Op_RegP /* Return address */, 0, /* the memories */ + Op_RegF, Op_RegF, Op_RegF, Op_RegD, Op_RegD, Op_RegD, + 0 /*bottom*/ +}; + +// Max vector size in bytes. 0 if not supported. +const int Matcher::vector_width_in_bytes(BasicType bt) { + assert(is_java_primitive(bt), "only primitive type vectors"); + if (UseSSE < 2) return 0; + // SSE2 supports 128bit vectors for all types. + // AVX2 supports 256bit vectors for all types. + int size = (UseAVX > 1) ? 32 : 16; + // AVX1 supports 256bit vectors only for FLOAT and DOUBLE. + if (UseAVX > 0 && (bt == T_FLOAT || bt == T_DOUBLE)) + size = 32; + // Use flag to limit vector size. + size = MIN2(size,(int)MaxVectorSize); + // Minimum 2 values in vector (or 4 for bytes). + switch (bt) { + case T_DOUBLE: + case T_LONG: + if (size < 16) return 0; + case T_FLOAT: + case T_INT: + if (size < 8) return 0; + case T_BOOLEAN: + case T_BYTE: + case T_CHAR: + case T_SHORT: + if (size < 4) return 0; + break; + default: + ShouldNotReachHere(); + } + return size; +} + +// Limits on vector size (number of elements) loaded into vector. +const int Matcher::max_vector_size(const BasicType bt) { + return vector_width_in_bytes(bt)/type2aelembytes(bt); +} +const int Matcher::min_vector_size(const BasicType bt) { + int max_size = max_vector_size(bt); + // Min size which can be loaded into vector is 4 bytes. + int size = (type2aelembytes(bt) == 1) ? 4 : 2; + return MIN2(size,max_size); +} + +// Vector ideal reg corresponding to specidied size in bytes +const int Matcher::vector_ideal_reg(int size) { + assert(MaxVectorSize >= size, ""); + switch(size) { + case 4: return Op_VecS; + case 8: return Op_VecD; + case 16: return Op_VecX; + case 32: return Op_VecY; + } + ShouldNotReachHere(); + return 0; +} + +// x86 supports misaligned vectors store/load. +const bool Matcher::misaligned_vectors_ok() { + return !AlignVector; // can be changed by flag +} + +// Helper methods for MachSpillCopyNode::implementation(). +static int vec_mov_helper(CodeBuffer *cbuf, bool do_size, int src_lo, int dst_lo, + int src_hi, int dst_hi, uint ireg, outputStream* st) { + // In 64-bit VM size calculation is very complex. Emitting instructions + // into scratch buffer is used to get size in 64-bit VM. + LP64_ONLY( assert(!do_size, "this method calculates size only for 32-bit VM"); ) + assert(ireg == Op_VecS || // 32bit vector + (src_lo & 1) == 0 && (src_lo + 1) == src_hi && + (dst_lo & 1) == 0 && (dst_lo + 1) == dst_hi, + "no non-adjacent vector moves" ); + if (cbuf) { + MacroAssembler _masm(cbuf); + int offset = __ offset(); + switch (ireg) { + case Op_VecS: // copy whole register + case Op_VecD: + case Op_VecX: + __ movdqu(as_XMMRegister(Matcher::_regEncode[dst_lo]), as_XMMRegister(Matcher::_regEncode[src_lo])); + break; + case Op_VecY: + __ vmovdqu(as_XMMRegister(Matcher::_regEncode[dst_lo]), as_XMMRegister(Matcher::_regEncode[src_lo])); + break; + default: + ShouldNotReachHere(); + } + int size = __ offset() - offset; +#ifdef ASSERT + // VEX_2bytes prefix is used if UseAVX > 0, so it takes the same 2 bytes as SIMD prefix. + assert(!do_size || size == 4, "incorrect size calculattion"); +#endif + return size; +#ifndef PRODUCT + } else if (!do_size) { + switch (ireg) { + case Op_VecS: + case Op_VecD: + case Op_VecX: + st->print("movdqu %s,%s\t# spill",Matcher::regName[dst_lo],Matcher::regName[src_lo]); + break; + case Op_VecY: + st->print("vmovdqu %s,%s\t# spill",Matcher::regName[dst_lo],Matcher::regName[src_lo]); + break; + default: + ShouldNotReachHere(); + } +#endif + } + // VEX_2bytes prefix is used if UseAVX > 0, and it takes the same 2 bytes as SIMD prefix. + return 4; +} + +static int vec_spill_helper(CodeBuffer *cbuf, bool do_size, bool is_load, + int stack_offset, int reg, uint ireg, outputStream* st) { + // In 64-bit VM size calculation is very complex. Emitting instructions + // into scratch buffer is used to get size in 64-bit VM. + LP64_ONLY( assert(!do_size, "this method calculates size only for 32-bit VM"); ) + if (cbuf) { + MacroAssembler _masm(cbuf); + int offset = __ offset(); + if (is_load) { + switch (ireg) { + case Op_VecS: + __ movdl(as_XMMRegister(Matcher::_regEncode[reg]), Address(rsp, stack_offset)); + break; + case Op_VecD: + __ movq(as_XMMRegister(Matcher::_regEncode[reg]), Address(rsp, stack_offset)); + break; + case Op_VecX: + __ movdqu(as_XMMRegister(Matcher::_regEncode[reg]), Address(rsp, stack_offset)); + break; + case Op_VecY: + __ vmovdqu(as_XMMRegister(Matcher::_regEncode[reg]), Address(rsp, stack_offset)); + break; + default: + ShouldNotReachHere(); + } + } else { // store + switch (ireg) { + case Op_VecS: + __ movdl(Address(rsp, stack_offset), as_XMMRegister(Matcher::_regEncode[reg])); + break; + case Op_VecD: + __ movq(Address(rsp, stack_offset), as_XMMRegister(Matcher::_regEncode[reg])); + break; + case Op_VecX: + __ movdqu(Address(rsp, stack_offset), as_XMMRegister(Matcher::_regEncode[reg])); + break; + case Op_VecY: + __ vmovdqu(Address(rsp, stack_offset), as_XMMRegister(Matcher::_regEncode[reg])); + break; + default: + ShouldNotReachHere(); + } + } + int size = __ offset() - offset; +#ifdef ASSERT + int offset_size = (stack_offset == 0) ? 0 : ((stack_offset < 0x80) ? 1 : 4); + // VEX_2bytes prefix is used if UseAVX > 0, so it takes the same 2 bytes as SIMD prefix. + assert(!do_size || size == (5+offset_size), "incorrect size calculattion"); +#endif + return size; +#ifndef PRODUCT + } else if (!do_size) { + if (is_load) { + switch (ireg) { + case Op_VecS: + st->print("movd %s,[rsp + %d]\t# spill", Matcher::regName[reg], stack_offset); + break; + case Op_VecD: + st->print("movq %s,[rsp + %d]\t# spill", Matcher::regName[reg], stack_offset); + break; + case Op_VecX: + st->print("movdqu %s,[rsp + %d]\t# spill", Matcher::regName[reg], stack_offset); + break; + case Op_VecY: + st->print("vmovdqu %s,[rsp + %d]\t# spill", Matcher::regName[reg], stack_offset); + break; + default: + ShouldNotReachHere(); + } + } else { // store + switch (ireg) { + case Op_VecS: + st->print("movd [rsp + %d],%s\t# spill", stack_offset, Matcher::regName[reg]); + break; + case Op_VecD: + st->print("movq [rsp + %d],%s\t# spill", stack_offset, Matcher::regName[reg]); + break; + case Op_VecX: + st->print("movdqu [rsp + %d],%s\t# spill", stack_offset, Matcher::regName[reg]); + break; + case Op_VecY: + st->print("vmovdqu [rsp + %d],%s\t# spill", stack_offset, Matcher::regName[reg]); + break; + default: + ShouldNotReachHere(); + } + } +#endif + } + int offset_size = (stack_offset == 0) ? 0 : ((stack_offset < 0x80) ? 1 : 4); + // VEX_2bytes prefix is used if UseAVX > 0, so it takes the same 2 bytes as SIMD prefix. + return 5+offset_size; +} + +static inline jfloat replicate4_imm(int con, int width) { + // Load a constant of "width" (in bytes) and replicate it to fill 32bit. + assert(width == 1 || width == 2, "only byte or short types here"); + int bit_width = width * 8; + jint val = con; + val &= (1 << bit_width) - 1; // mask off sign bits + while(bit_width < 32) { + val |= (val << bit_width); + bit_width <<= 1; + } + jfloat fval = *((jfloat*) &val); // coerce to float type + return fval; +} + +static inline jdouble replicate8_imm(int con, int width) { + // Load a constant of "width" (in bytes) and replicate it to fill 64bit. + assert(width == 1 || width == 2 || width == 4, "only byte, short or int types here"); + int bit_width = width * 8; + jlong val = con; + val &= (((jlong) 1) << bit_width) - 1; // mask off sign bits + while(bit_width < 64) { + val |= (val << bit_width); + bit_width <<= 1; + } + jdouble dval = *((jdouble*) &val); // coerce to double type + return dval; +} + #ifndef PRODUCT void MachNopNode::format(PhaseRegAlloc*, outputStream* st) const { st->print("nop \t# %d bytes pad for loops and calls", _count); @@ -103,6 +799,46 @@ encode %{ %} + +//----------OPERANDS----------------------------------------------------------- +// Operand definitions must precede instruction definitions for correct parsing +// in the ADLC because operands constitute user defined types which are used in +// instruction definitions. + +// Vectors +operand vecS() %{ + constraint(ALLOC_IN_RC(vectors_reg)); + match(VecS); + + format %{ %} + interface(REG_INTER); +%} + +operand vecD() %{ + constraint(ALLOC_IN_RC(vectord_reg)); + match(VecD); + + format %{ %} + interface(REG_INTER); +%} + +operand vecX() %{ + constraint(ALLOC_IN_RC(vectorx_reg)); + match(VecX); + + format %{ %} + interface(REG_INTER); +%} + +operand vecY() %{ + constraint(ALLOC_IN_RC(vectory_reg)); + match(VecY); + + format %{ %} + interface(REG_INTER); +%} + + // INSTRUCTIONS -- Platform independent definitions (same for 32- and 64-bit) // ============================================================================ @@ -852,3 +1588,797 @@ instruct sqrtD_imm(regD dst, immD con) %{ ins_pipe(pipe_slow); %} + +// ====================VECTOR INSTRUCTIONS===================================== + +// Load vectors (4 bytes long) +instruct loadV4(vecS dst, memory mem) %{ + predicate(n->as_LoadVector()->memory_size() == 4); + match(Set dst (LoadVector mem)); + ins_cost(125); + format %{ "movd $dst,$mem\t! load vector (4 bytes)" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $mem$$Address); + %} + ins_pipe( pipe_slow ); +%} + +// Load vectors (8 bytes long) +instruct loadV8(vecD dst, memory mem) %{ + predicate(n->as_LoadVector()->memory_size() == 8); + match(Set dst (LoadVector mem)); + ins_cost(125); + format %{ "movq $dst,$mem\t! load vector (8 bytes)" %} + ins_encode %{ + __ movq($dst$$XMMRegister, $mem$$Address); + %} + ins_pipe( pipe_slow ); +%} + +// Load vectors (16 bytes long) +instruct loadV16(vecX dst, memory mem) %{ + predicate(n->as_LoadVector()->memory_size() == 16); + match(Set dst (LoadVector mem)); + ins_cost(125); + format %{ "movdqu $dst,$mem\t! load vector (16 bytes)" %} + ins_encode %{ + __ movdqu($dst$$XMMRegister, $mem$$Address); + %} + ins_pipe( pipe_slow ); +%} + +// Load vectors (32 bytes long) +instruct loadV32(vecY dst, memory mem) %{ + predicate(n->as_LoadVector()->memory_size() == 32); + match(Set dst (LoadVector mem)); + ins_cost(125); + format %{ "vmovdqu $dst,$mem\t! load vector (32 bytes)" %} + ins_encode %{ + __ vmovdqu($dst$$XMMRegister, $mem$$Address); + %} + ins_pipe( pipe_slow ); +%} + +// Store vectors +instruct storeV4(memory mem, vecS src) %{ + predicate(n->as_StoreVector()->memory_size() == 4); + match(Set mem (StoreVector mem src)); + ins_cost(145); + format %{ "movd $mem,$src\t! store vector (4 bytes)" %} + ins_encode %{ + __ movdl($mem$$Address, $src$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct storeV8(memory mem, vecD src) %{ + predicate(n->as_StoreVector()->memory_size() == 8); + match(Set mem (StoreVector mem src)); + ins_cost(145); + format %{ "movq $mem,$src\t! store vector (8 bytes)" %} + ins_encode %{ + __ movq($mem$$Address, $src$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct storeV16(memory mem, vecX src) %{ + predicate(n->as_StoreVector()->memory_size() == 16); + match(Set mem (StoreVector mem src)); + ins_cost(145); + format %{ "movdqu $mem,$src\t! store vector (16 bytes)" %} + ins_encode %{ + __ movdqu($mem$$Address, $src$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct storeV32(memory mem, vecY src) %{ + predicate(n->as_StoreVector()->memory_size() == 32); + match(Set mem (StoreVector mem src)); + ins_cost(145); + format %{ "vmovdqu $mem,$src\t! store vector (32 bytes)" %} + ins_encode %{ + __ vmovdqu($mem$$Address, $src$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate byte scalar to be vector +instruct Repl4B(vecS dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateB src)); + format %{ "movd $dst,$src\n\t" + "punpcklbw $dst,$dst\n\t" + "pshuflw $dst,$dst,0x00\t! replicate4B" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ punpcklbw($dst$$XMMRegister, $dst$$XMMRegister); + __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl8B(vecD dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateB src)); + format %{ "movd $dst,$src\n\t" + "punpcklbw $dst,$dst\n\t" + "pshuflw $dst,$dst,0x00\t! replicate8B" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ punpcklbw($dst$$XMMRegister, $dst$$XMMRegister); + __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl16B(vecX dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 16); + match(Set dst (ReplicateB src)); + format %{ "movd $dst,$src\n\t" + "punpcklbw $dst,$dst\n\t" + "pshuflw $dst,$dst,0x00\n\t" + "movlhps $dst,$dst\t! replicate16B" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ punpcklbw($dst$$XMMRegister, $dst$$XMMRegister); + __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl32B(vecY dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 32); + match(Set dst (ReplicateB src)); + format %{ "movd $dst,$src\n\t" + "punpcklbw $dst,$dst\n\t" + "pshuflw $dst,$dst,0x00\n\t" + "movlhps $dst,$dst\n\t" + "vinsertf128h $dst,$dst,$dst\t! replicate32B" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ punpcklbw($dst$$XMMRegister, $dst$$XMMRegister); + __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate byte scalar immediate to be vector by loading from const table. +instruct Repl4B_imm(vecS dst, immI con) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateB con)); + format %{ "movss $dst,[$constantaddress]\t! replicate4B($con)" %} + ins_encode %{ + __ movflt($dst$$XMMRegister, $constantaddress(replicate4_imm($con$$constant, 1))); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl8B_imm(vecD dst, immI con) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateB con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate8B($con)" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress(replicate8_imm($con$$constant, 1))); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl16B_imm(vecX dst, immI con) %{ + predicate(n->as_Vector()->length() == 16); + match(Set dst (ReplicateB con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate16B($con)\n\t" + "movlhps $dst,$dst" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress(replicate8_imm($con$$constant, 1))); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl32B_imm(vecY dst, immI con) %{ + predicate(n->as_Vector()->length() == 32); + match(Set dst (ReplicateB con)); + format %{ "movsd $dst,[$constantaddress]\t! lreplicate32B($con)\n\t" + "movlhps $dst,$dst\n\t" + "vinsertf128h $dst,$dst,$dst" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress(replicate8_imm($con$$constant, 1))); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate byte scalar zero to be vector +instruct Repl4B_zero(vecS dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateB zero)); + format %{ "pxor $dst,$dst\t! replicate4B zero" %} + ins_encode %{ + __ pxor($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl8B_zero(vecD dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateB zero)); + format %{ "pxor $dst,$dst\t! replicate8B zero" %} + ins_encode %{ + __ pxor($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl16B_zero(vecX dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 16); + match(Set dst (ReplicateB zero)); + format %{ "pxor $dst,$dst\t! replicate16B zero" %} + ins_encode %{ + __ pxor($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl32B_zero(vecY dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 32); + match(Set dst (ReplicateB zero)); + format %{ "vxorpd $dst,$dst,$dst\t! replicate32B zero" %} + ins_encode %{ + // Use vxorpd since AVX does not have vpxor for 256-bit (AVX2 will have it). + bool vector256 = true; + __ vxorpd($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister, vector256); + %} + ins_pipe( fpu_reg_reg ); +%} + +// Replicate char/short (2 byte) scalar to be vector +instruct Repl2S(vecS dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateS src)); + format %{ "movd $dst,$src\n\t" + "pshuflw $dst,$dst,0x00\t! replicate2S" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4S(vecD dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateS src)); + format %{ "movd $dst,$src\n\t" + "pshuflw $dst,$dst,0x00\t! replicate4S" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl8S(vecX dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateS src)); + format %{ "movd $dst,$src\n\t" + "pshuflw $dst,$dst,0x00\n\t" + "movlhps $dst,$dst\t! replicate8S" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl16S(vecY dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 16); + match(Set dst (ReplicateS src)); + format %{ "movd $dst,$src\n\t" + "pshuflw $dst,$dst,0x00\n\t" + "movlhps $dst,$dst\n\t" + "vinsertf128h $dst,$dst,$dst\t! replicate16S" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate char/short (2 byte) scalar immediate to be vector by loading from const table. +instruct Repl2S_imm(vecS dst, immI con) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateS con)); + format %{ "movss $dst,[$constantaddress]\t! replicate2S($con)" %} + ins_encode %{ + __ movflt($dst$$XMMRegister, $constantaddress(replicate4_imm($con$$constant, 2))); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4S_imm(vecD dst, immI con) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateS con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate4S($con)" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress(replicate8_imm($con$$constant, 2))); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl8S_imm(vecX dst, immI con) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateS con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate8S($con)\n\t" + "movlhps $dst,$dst" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress(replicate8_imm($con$$constant, 2))); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl16S_imm(vecY dst, immI con) %{ + predicate(n->as_Vector()->length() == 16); + match(Set dst (ReplicateS con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate16S($con)\n\t" + "movlhps $dst,$dst\n\t" + "vinsertf128h $dst,$dst,$dst" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress(replicate8_imm($con$$constant, 2))); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate char/short (2 byte) scalar zero to be vector +instruct Repl2S_zero(vecS dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateS zero)); + format %{ "pxor $dst,$dst\t! replicate2S zero" %} + ins_encode %{ + __ pxor($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4S_zero(vecD dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateS zero)); + format %{ "pxor $dst,$dst\t! replicate4S zero" %} + ins_encode %{ + __ pxor($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl8S_zero(vecX dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateS zero)); + format %{ "pxor $dst,$dst\t! replicate8S zero" %} + ins_encode %{ + __ pxor($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl16S_zero(vecY dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 16); + match(Set dst (ReplicateS zero)); + format %{ "vxorpd $dst,$dst,$dst\t! replicate16S zero" %} + ins_encode %{ + // Use vxorpd since AVX does not have vpxor for 256-bit (AVX2 will have it). + bool vector256 = true; + __ vxorpd($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister, vector256); + %} + ins_pipe( fpu_reg_reg ); +%} + +// Replicate integer (4 byte) scalar to be vector +instruct Repl2I(vecD dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateI src)); + format %{ "movd $dst,$src\n\t" + "pshufd $dst,$dst,0x00\t! replicate2I" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ pshufd($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4I(vecX dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateI src)); + format %{ "movd $dst,$src\n\t" + "pshufd $dst,$dst,0x00\t! replicate4I" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ pshufd($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl8I(vecY dst, rRegI src) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateI src)); + format %{ "movd $dst,$src\n\t" + "pshufd $dst,$dst,0x00\n\t" + "vinsertf128h $dst,$dst,$dst\t! replicate8I" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ pshufd($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate integer (4 byte) scalar immediate to be vector by loading from const table. +instruct Repl2I_imm(vecD dst, immI con) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateI con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate2I($con)" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress(replicate8_imm($con$$constant, 4))); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4I_imm(vecX dst, immI con) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateI con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate4I($con)\n\t" + "movlhps $dst,$dst" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress(replicate8_imm($con$$constant, 4))); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl8I_imm(vecY dst, immI con) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateI con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate8I($con)\n\t" + "movlhps $dst,$dst\n\t" + "vinsertf128h $dst,$dst,$dst" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress(replicate8_imm($con$$constant, 4))); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Integer could be loaded into xmm register directly from memory. +instruct Repl2I_mem(vecD dst, memory mem) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateI mem)); + format %{ "movd $dst,$mem\n\t" + "pshufd $dst,$dst,0x00\t! replicate2I" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $mem$$Address); + __ pshufd($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4I_mem(vecX dst, memory mem) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateI mem)); + format %{ "movd $dst,$mem\n\t" + "pshufd $dst,$dst,0x00\t! replicate4I" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $mem$$Address); + __ pshufd($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl8I_mem(vecY dst, memory mem) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateI mem)); + format %{ "movd $dst,$mem\n\t" + "pshufd $dst,$dst,0x00\n\t" + "vinsertf128h $dst,$dst,$dst\t! replicate8I" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $mem$$Address); + __ pshufd($dst$$XMMRegister, $dst$$XMMRegister, 0x00); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate integer (4 byte) scalar zero to be vector +instruct Repl2I_zero(vecD dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateI zero)); + format %{ "pxor $dst,$dst\t! replicate2I" %} + ins_encode %{ + __ pxor($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4I_zero(vecX dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateI zero)); + format %{ "pxor $dst,$dst\t! replicate4I zero)" %} + ins_encode %{ + __ pxor($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl8I_zero(vecY dst, immI0 zero) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateI zero)); + format %{ "vxorpd $dst,$dst,$dst\t! replicate8I zero" %} + ins_encode %{ + // Use vxorpd since AVX does not have vpxor for 256-bit (AVX2 will have it). + bool vector256 = true; + __ vxorpd($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister, vector256); + %} + ins_pipe( fpu_reg_reg ); +%} + +// Replicate long (8 byte) scalar to be vector +#ifdef _LP64 +instruct Repl2L(vecX dst, rRegL src) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateL src)); + format %{ "movdq $dst,$src\n\t" + "movlhps $dst,$dst\t! replicate2L" %} + ins_encode %{ + __ movdq($dst$$XMMRegister, $src$$Register); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl4L(vecY dst, rRegL src) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateL src)); + format %{ "movdq $dst,$src\n\t" + "movlhps $dst,$dst\n\t" + "vinsertf128h $dst,$dst,$dst\t! replicate4L" %} + ins_encode %{ + __ movdq($dst$$XMMRegister, $src$$Register); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} +#else // _LP64 +instruct Repl2L(vecX dst, eRegL src, regD tmp) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateL src)); + effect(TEMP dst, USE src, TEMP tmp); + format %{ "movdl $dst,$src.lo\n\t" + "movdl $tmp,$src.hi\n\t" + "punpckldq $dst,$tmp\n\t" + "movlhps $dst,$dst\t! replicate2L"%} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ movdl($tmp$$XMMRegister, HIGH_FROM_LOW($src$$Register)); + __ punpckldq($dst$$XMMRegister, $tmp$$XMMRegister); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl4L(vecY dst, eRegL src, regD tmp) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateL src)); + effect(TEMP dst, USE src, TEMP tmp); + format %{ "movdl $dst,$src.lo\n\t" + "movdl $tmp,$src.hi\n\t" + "punpckldq $dst,$tmp\n\t" + "movlhps $dst,$dst\n\t" + "vinsertf128h $dst,$dst,$dst\t! replicate4L" %} + ins_encode %{ + __ movdl($dst$$XMMRegister, $src$$Register); + __ movdl($tmp$$XMMRegister, HIGH_FROM_LOW($src$$Register)); + __ punpckldq($dst$$XMMRegister, $tmp$$XMMRegister); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} +#endif // _LP64 + +// Replicate long (8 byte) scalar immediate to be vector by loading from const table. +instruct Repl2L_imm(vecX dst, immL con) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateL con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate2L($con)\n\t" + "movlhps $dst,$dst" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress($con)); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl4L_imm(vecY dst, immL con) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateL con)); + format %{ "movsd $dst,[$constantaddress]\t! replicate4L($con)\n\t" + "movlhps $dst,$dst\n\t" + "vinsertf128h $dst,$dst,$dst" %} + ins_encode %{ + __ movdbl($dst$$XMMRegister, $constantaddress($con)); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Long could be loaded into xmm register directly from memory. +instruct Repl2L_mem(vecX dst, memory mem) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateL mem)); + format %{ "movq $dst,$mem\n\t" + "movlhps $dst,$dst\t! replicate2L" %} + ins_encode %{ + __ movq($dst$$XMMRegister, $mem$$Address); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl4L_mem(vecY dst, memory mem) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateL mem)); + format %{ "movq $dst,$mem\n\t" + "movlhps $dst,$dst\n\t" + "vinsertf128h $dst,$dst,$dst\t! replicate4L" %} + ins_encode %{ + __ movq($dst$$XMMRegister, $mem$$Address); + __ movlhps($dst$$XMMRegister, $dst$$XMMRegister); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate long (8 byte) scalar zero to be vector +instruct Repl2L_zero(vecX dst, immL0 zero) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateL zero)); + format %{ "pxor $dst,$dst\t! replicate2L zero" %} + ins_encode %{ + __ pxor($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4L_zero(vecY dst, immL0 zero) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateL zero)); + format %{ "vxorpd $dst,$dst,$dst\t! replicate4L zero" %} + ins_encode %{ + // Use vxorpd since AVX does not have vpxor for 256-bit (AVX2 will have it). + bool vector256 = true; + __ vxorpd($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister, vector256); + %} + ins_pipe( fpu_reg_reg ); +%} + +// Replicate float (4 byte) scalar to be vector +instruct Repl2F(vecD dst, regF src) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateF src)); + format %{ "pshufd $dst,$dst,0x00\t! replicate2F" %} + ins_encode %{ + __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0x00); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4F(vecX dst, regF src) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateF src)); + format %{ "pshufd $dst,$dst,0x00\t! replicate4F" %} + ins_encode %{ + __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0x00); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl8F(vecY dst, regF src) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateF src)); + format %{ "pshufd $dst,$src,0x00\n\t" + "vinsertf128h $dst,$dst,$dst\t! replicate8F" %} + ins_encode %{ + __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0x00); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate float (4 byte) scalar zero to be vector +instruct Repl2F_zero(vecD dst, immF0 zero) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateF zero)); + format %{ "xorps $dst,$dst\t! replicate2F zero" %} + ins_encode %{ + __ xorps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4F_zero(vecX dst, immF0 zero) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateF zero)); + format %{ "xorps $dst,$dst\t! replicate4F zero" %} + ins_encode %{ + __ xorps($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl8F_zero(vecY dst, immF0 zero) %{ + predicate(n->as_Vector()->length() == 8); + match(Set dst (ReplicateF zero)); + format %{ "vxorps $dst,$dst,$dst\t! replicate8F zero" %} + ins_encode %{ + bool vector256 = true; + __ vxorps($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister, vector256); + %} + ins_pipe( fpu_reg_reg ); +%} + +// Replicate double (8 bytes) scalar to be vector +instruct Repl2D(vecX dst, regD src) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateD src)); + format %{ "pshufd $dst,$src,0x44\t! replicate2D" %} + ins_encode %{ + __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0x44); + %} + ins_pipe( pipe_slow ); +%} + +instruct Repl4D(vecY dst, regD src) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateD src)); + format %{ "pshufd $dst,$src,0x44\n\t" + "vinsertf128h $dst,$dst,$dst\t! replicate4D" %} + ins_encode %{ + __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0x44); + __ vinsertf128h($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( pipe_slow ); +%} + +// Replicate double (8 byte) scalar zero to be vector +instruct Repl2D_zero(vecX dst, immD0 zero) %{ + predicate(n->as_Vector()->length() == 2); + match(Set dst (ReplicateD zero)); + format %{ "xorpd $dst,$dst\t! replicate2D zero" %} + ins_encode %{ + __ xorpd($dst$$XMMRegister, $dst$$XMMRegister); + %} + ins_pipe( fpu_reg_reg ); +%} + +instruct Repl4D_zero(vecY dst, immD0 zero) %{ + predicate(n->as_Vector()->length() == 4); + match(Set dst (ReplicateD zero)); + format %{ "vxorpd $dst,$dst,$dst,vect256\t! replicate4D zero" %} + ins_encode %{ + bool vector256 = true; + __ vxorpd($dst$$XMMRegister, $dst$$XMMRegister, $dst$$XMMRegister, vector256); + %} + ins_pipe( fpu_reg_reg ); +%} + diff --git a/hotspot/src/cpu/x86/vm/x86_32.ad b/hotspot/src/cpu/x86/vm/x86_32.ad index 300903954d2..b46d3d68843 100644 --- a/hotspot/src/cpu/x86/vm/x86_32.ad +++ b/hotspot/src/cpu/x86/vm/x86_32.ad @@ -74,9 +74,6 @@ reg_def EDX(SOC, SOC, Op_RegI, 2, rdx->as_VMReg()); reg_def EAX(SOC, SOC, Op_RegI, 0, rax->as_VMReg()); reg_def ESP( NS, NS, Op_RegI, 4, rsp->as_VMReg()); -// Special Registers -reg_def EFLAGS(SOC, SOC, 0, 8, VMRegImpl::Bad()); - // Float registers. We treat TOS/FPR0 special. It is invisible to the // allocator, and only shows up in the encodings. reg_def FPR0L( SOC, SOC, Op_RegF, 0, VMRegImpl::Bad()); @@ -105,27 +102,6 @@ reg_def FPR6H( SOC, SOC, Op_RegF, 6, as_FloatRegister(5)->as_VMReg()->next()); reg_def FPR7L( SOC, SOC, Op_RegF, 7, as_FloatRegister(6)->as_VMReg()); reg_def FPR7H( SOC, SOC, Op_RegF, 7, as_FloatRegister(6)->as_VMReg()->next()); -// XMM registers. 128-bit registers or 4 words each, labeled a-d. -// Word a in each register holds a Float, words ab hold a Double. -// We currently do not use the SIMD capabilities, so registers cd -// are unused at the moment. -reg_def XMM0a( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()); -reg_def XMM0b( SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()->next()); -reg_def XMM1a( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()); -reg_def XMM1b( SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()->next()); -reg_def XMM2a( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()); -reg_def XMM2b( SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()->next()); -reg_def XMM3a( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()); -reg_def XMM3b( SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()->next()); -reg_def XMM4a( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()); -reg_def XMM4b( SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()->next()); -reg_def XMM5a( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()); -reg_def XMM5b( SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()->next()); -reg_def XMM6a( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()); -reg_def XMM6b( SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()->next()); -reg_def XMM7a( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()); -reg_def XMM7b( SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()); - // Specify priority of register selection within phases of register // allocation. Highest priority is first. A useful heuristic is to // give registers a low priority when they are required by machine @@ -138,15 +114,6 @@ alloc_class chunk0( ECX, EBX, EBP, EDI, EAX, EDX, ESI, ESP, FPR3L, FPR3H, FPR4L, FPR4H, FPR5L, FPR5H, FPR6L, FPR6H, FPR7L, FPR7H ); -alloc_class chunk1( XMM0a, XMM0b, - XMM1a, XMM1b, - XMM2a, XMM2b, - XMM3a, XMM3b, - XMM4a, XMM4b, - XMM5a, XMM5b, - XMM6a, XMM6b, - XMM7a, XMM7b, EFLAGS); - //----------Architecture Description Register Classes-------------------------- // Several register classes are automatically defined based upon information in @@ -159,12 +126,12 @@ alloc_class chunk1( XMM0a, XMM0b, // Class for all registers reg_class any_reg(EAX, EDX, EBP, EDI, ESI, ECX, EBX, ESP); // Class for general registers -reg_class e_reg(EAX, EDX, EBP, EDI, ESI, ECX, EBX); +reg_class int_reg(EAX, EDX, EBP, EDI, ESI, ECX, EBX); // Class for general registers which may be used for implicit null checks on win95 // Also safe for use by tailjump. We don't want to allocate in rbp, -reg_class e_reg_no_rbp(EAX, EDX, EDI, ESI, ECX, EBX); +reg_class int_reg_no_rbp(EAX, EDX, EDI, ESI, ECX, EBX); // Class of "X" registers -reg_class x_reg(EBX, ECX, EDX, EAX); +reg_class int_x_reg(EBX, ECX, EDX, EAX); // Class of registers that can appear in an address with no offset. // EBP and ESP require an extra instruction byte for zero offset. // Used in fast-unlock @@ -193,8 +160,6 @@ reg_class ebp_reg(EBP); reg_class sp_reg(ESP); // Singleton class for instruction pointer // reg_class ip_reg(EIP); -// Singleton class for condition codes -reg_class int_flags(EFLAGS); // Class of integer register pairs reg_class long_reg( EAX,EDX, ECX,EBX, EBP,EDI ); // Class of integer register pairs that aligns with calling convention @@ -206,29 +171,18 @@ reg_class nadx_reg( EBX,ECX,ESI,EDI,EBP ); // Floating point registers. Notice FPR0 is not a choice. // FPR0 is not ever allocated; we use clever encodings to fake // a 2-address instructions out of Intels FP stack. -reg_class flt_reg( FPR1L,FPR2L,FPR3L,FPR4L,FPR5L,FPR6L,FPR7L ); +reg_class fp_flt_reg( FPR1L,FPR2L,FPR3L,FPR4L,FPR5L,FPR6L,FPR7L ); -// make a register class for SSE registers -reg_class xmm_reg(XMM0a, XMM1a, XMM2a, XMM3a, XMM4a, XMM5a, XMM6a, XMM7a); +reg_class fp_dbl_reg( FPR1L,FPR1H, FPR2L,FPR2H, FPR3L,FPR3H, + FPR4L,FPR4H, FPR5L,FPR5H, FPR6L,FPR6H, + FPR7L,FPR7H ); -// make a double register class for SSE2 registers -reg_class xdb_reg(XMM0a,XMM0b, XMM1a,XMM1b, XMM2a,XMM2b, XMM3a,XMM3b, - XMM4a,XMM4b, XMM5a,XMM5b, XMM6a,XMM6b, XMM7a,XMM7b ); +reg_class fp_flt_reg0( FPR1L ); +reg_class fp_dbl_reg0( FPR1L,FPR1H ); +reg_class fp_dbl_reg1( FPR2L,FPR2H ); +reg_class fp_dbl_notreg0( FPR2L,FPR2H, FPR3L,FPR3H, FPR4L,FPR4H, + FPR5L,FPR5H, FPR6L,FPR6H, FPR7L,FPR7H ); -reg_class dbl_reg( FPR1L,FPR1H, FPR2L,FPR2H, FPR3L,FPR3H, - FPR4L,FPR4H, FPR5L,FPR5H, FPR6L,FPR6H, - FPR7L,FPR7H ); - -reg_class flt_reg0( FPR1L ); -reg_class dbl_reg0( FPR1L,FPR1H ); -reg_class dbl_reg1( FPR2L,FPR2H ); -reg_class dbl_notreg0( FPR2L,FPR2H, FPR3L,FPR3H, FPR4L,FPR4H, - FPR5L,FPR5H, FPR6L,FPR6H, FPR7L,FPR7H ); - -// XMM6 and XMM7 could be used as temporary registers for long, float and -// double values for SSE2. -reg_class xdb_reg6( XMM6a,XMM6b ); -reg_class xdb_reg7( XMM7a,XMM7b ); %} @@ -412,7 +366,7 @@ void store_to_stackslot(CodeBuffer &cbuf, int opcode, int rm_field, int disp) { } } - // eRegI ereg, memory mem) %{ // emit_reg_mem + // rRegI ereg, memory mem) %{ // emit_reg_mem void encode_RegMem( CodeBuffer &cbuf, int reg_encoding, int base, int index, int scale, int displace, bool displace_is_oop ) { // There is no index & no scale, use form without SIB byte if ((index == 0x4) && @@ -787,7 +741,7 @@ static int impl_x_helper( CodeBuffer *cbuf, bool do_size, bool is_load, #endif } int offset_size = (offset == 0) ? 0 : ((offset <= 127) ? 1 : 4); - // VEX_2bytes prefix is used if UseAVX > 0, so it takes the same 2 bytes. + // VEX_2bytes prefix is used if UseAVX > 0, so it takes the same 2 bytes as SIMD prefix. return size+5+offset_size; } @@ -821,7 +775,7 @@ static int impl_movx_helper( CodeBuffer *cbuf, bool do_size, int src_lo, int dst } #endif } - // VEX_2bytes prefix is used if UseAVX > 0, and it takes the same 2 bytes. + // VEX_2bytes prefix is used if UseAVX > 0, and it takes the same 2 bytes as SIMD prefix. // Only MOVAPS SSE prefix uses 1 byte. int sz = 4; if (!(src_lo+1 == src_hi && dst_lo+1 == dst_hi) && @@ -903,6 +857,108 @@ static int impl_fp_store_helper( CodeBuffer *cbuf, bool do_size, int src_lo, int return impl_helper(cbuf,do_size,false,offset,st_op,op,op_str,size, st); } +// Next two methods are shared by 32- and 64-bit VM. They are defined in x86.ad. +static int vec_mov_helper(CodeBuffer *cbuf, bool do_size, int src_lo, int dst_lo, + int src_hi, int dst_hi, uint ireg, outputStream* st); + +static int vec_spill_helper(CodeBuffer *cbuf, bool do_size, bool is_load, + int stack_offset, int reg, uint ireg, outputStream* st); + +static int vec_stack_to_stack_helper(CodeBuffer *cbuf, bool do_size, int src_offset, + int dst_offset, uint ireg, outputStream* st) { + int calc_size = 0; + int src_offset_size = (src_offset == 0) ? 0 : ((src_offset < 0x80) ? 1 : 4); + int dst_offset_size = (dst_offset == 0) ? 0 : ((dst_offset < 0x80) ? 1 : 4); + switch (ireg) { + case Op_VecS: + calc_size = 3+src_offset_size + 3+dst_offset_size; + break; + case Op_VecD: + calc_size = 3+src_offset_size + 3+dst_offset_size; + src_offset += 4; + dst_offset += 4; + src_offset_size = (src_offset == 0) ? 0 : ((src_offset < 0x80) ? 1 : 4); + dst_offset_size = (dst_offset == 0) ? 0 : ((dst_offset < 0x80) ? 1 : 4); + calc_size += 3+src_offset_size + 3+dst_offset_size; + break; + case Op_VecX: + calc_size = 6 + 6 + 5+src_offset_size + 5+dst_offset_size; + break; + case Op_VecY: + calc_size = 6 + 6 + 5+src_offset_size + 5+dst_offset_size; + break; + default: + ShouldNotReachHere(); + } + if (cbuf) { + MacroAssembler _masm(cbuf); + int offset = __ offset(); + switch (ireg) { + case Op_VecS: + __ pushl(Address(rsp, src_offset)); + __ popl (Address(rsp, dst_offset)); + break; + case Op_VecD: + __ pushl(Address(rsp, src_offset)); + __ popl (Address(rsp, dst_offset)); + __ pushl(Address(rsp, src_offset+4)); + __ popl (Address(rsp, dst_offset+4)); + break; + case Op_VecX: + __ movdqu(Address(rsp, -16), xmm0); + __ movdqu(xmm0, Address(rsp, src_offset)); + __ movdqu(Address(rsp, dst_offset), xmm0); + __ movdqu(xmm0, Address(rsp, -16)); + break; + case Op_VecY: + __ vmovdqu(Address(rsp, -32), xmm0); + __ vmovdqu(xmm0, Address(rsp, src_offset)); + __ vmovdqu(Address(rsp, dst_offset), xmm0); + __ vmovdqu(xmm0, Address(rsp, -32)); + break; + default: + ShouldNotReachHere(); + } + int size = __ offset() - offset; + assert(size == calc_size, "incorrect size calculattion"); + return size; +#ifndef PRODUCT + } else if (!do_size) { + switch (ireg) { + case Op_VecS: + st->print("pushl [rsp + #%d]\t# 32-bit mem-mem spill\n\t" + "popl [rsp + #%d]", + src_offset, dst_offset); + break; + case Op_VecD: + st->print("pushl [rsp + #%d]\t# 64-bit mem-mem spill\n\t" + "popq [rsp + #%d]\n\t" + "pushl [rsp + #%d]\n\t" + "popq [rsp + #%d]", + src_offset, dst_offset, src_offset+4, dst_offset+4); + break; + case Op_VecX: + st->print("movdqu [rsp - #16], xmm0\t# 128-bit mem-mem spill\n\t" + "movdqu xmm0, [rsp + #%d]\n\t" + "movdqu [rsp + #%d], xmm0\n\t" + "movdqu xmm0, [rsp - #16]", + src_offset, dst_offset); + break; + case Op_VecY: + st->print("vmovdqu [rsp - #32], xmm0\t# 256-bit mem-mem spill\n\t" + "vmovdqu xmm0, [rsp + #%d]\n\t" + "vmovdqu [rsp + #%d], xmm0\n\t" + "vmovdqu xmm0, [rsp - #32]", + src_offset, dst_offset); + break; + default: + ShouldNotReachHere(); + } +#endif + } + return calc_size; +} + uint MachSpillCopyNode::implementation( CodeBuffer *cbuf, PhaseRegAlloc *ra_, bool do_size, outputStream* st ) const { // Get registers to move OptoReg::Name src_second = ra_->get_reg_second(in(1)); @@ -923,6 +979,29 @@ uint MachSpillCopyNode::implementation( CodeBuffer *cbuf, PhaseRegAlloc *ra_, bo if( src_first == dst_first && src_second == dst_second ) return size; // Self copy, no move + if (bottom_type()->isa_vect() != NULL) { + uint ireg = ideal_reg(); + assert((src_first_rc != rc_int && dst_first_rc != rc_int), "sanity"); + assert((src_first_rc != rc_float && dst_first_rc != rc_float), "sanity"); + assert((ireg == Op_VecS || ireg == Op_VecD || ireg == Op_VecX || ireg == Op_VecY), "sanity"); + if( src_first_rc == rc_stack && dst_first_rc == rc_stack ) { + // mem -> mem + int src_offset = ra_->reg2offset(src_first); + int dst_offset = ra_->reg2offset(dst_first); + return vec_stack_to_stack_helper(cbuf, do_size, src_offset, dst_offset, ireg, st); + } else if (src_first_rc == rc_xmm && dst_first_rc == rc_xmm ) { + return vec_mov_helper(cbuf, do_size, src_first, dst_first, src_second, dst_second, ireg, st); + } else if (src_first_rc == rc_xmm && dst_first_rc == rc_stack ) { + int stack_offset = ra_->reg2offset(dst_first); + return vec_spill_helper(cbuf, do_size, false, stack_offset, src_first, ireg, st); + } else if (src_first_rc == rc_stack && dst_first_rc == rc_xmm ) { + int stack_offset = ra_->reg2offset(src_first); + return vec_spill_helper(cbuf, do_size, true, stack_offset, dst_first, ireg, st); + } else { + ShouldNotReachHere(); + } + } + // -------------------------------------- // Check for mem-mem move. push/pop to move. if( src_first_rc == rc_stack && dst_first_rc == rc_stack ) { @@ -1313,16 +1392,6 @@ const bool Matcher::convL2FSupported(void) { return true; } -// Vector width in bytes -const uint Matcher::vector_width_in_bytes(void) { - return UseSSE >= 2 ? 8 : 0; -} - -// Vector ideal reg -const uint Matcher::vector_ideal_reg(void) { - return Op_RegD; -} - // Is this branch offset short enough that a short branch can be used? // // NOTE: If the platform does not provide any short branch variants, then @@ -1452,7 +1521,7 @@ const bool Matcher::int_in_long = false; // arguments in those registers not be available to the callee. bool Matcher::can_be_java_arg( int reg ) { if( reg == ECX_num || reg == EDX_num ) return true; - if( (reg == XMM0a_num || reg == XMM1a_num) && UseSSE>=1 ) return true; + if( (reg == XMM0_num || reg == XMM1_num ) && UseSSE>=1 ) return true; if( (reg == XMM0b_num || reg == XMM1b_num) && UseSSE>=2 ) return true; return false; } @@ -1565,16 +1634,16 @@ encode %{ emit_opcode(cbuf,0x66); %} - enc_class RegReg (eRegI dst, eRegI src) %{ // RegReg(Many) + enc_class RegReg (rRegI dst, rRegI src) %{ // RegReg(Many) emit_rm(cbuf, 0x3, $dst$$reg, $src$$reg); %} - enc_class OpcRegReg (immI opcode, eRegI dst, eRegI src) %{ // OpcRegReg(Many) + enc_class OpcRegReg (immI opcode, rRegI dst, rRegI src) %{ // OpcRegReg(Many) emit_opcode(cbuf,$opcode$$constant); emit_rm(cbuf, 0x3, $dst$$reg, $src$$reg); %} - enc_class mov_r32_imm0( eRegI dst ) %{ + enc_class mov_r32_imm0( rRegI dst ) %{ emit_opcode( cbuf, 0xB8 + $dst$$reg ); // 0xB8+ rd -- MOV r32 ,imm32 emit_d32 ( cbuf, 0x0 ); // imm32==0x0 %} @@ -1621,7 +1690,7 @@ encode %{ %} // Dense encoding for older common ops - enc_class Opc_plus(immI opcode, eRegI reg) %{ + enc_class Opc_plus(immI opcode, rRegI reg) %{ emit_opcode(cbuf, $opcode$$constant + $reg$$reg); %} @@ -1637,7 +1706,7 @@ encode %{ } %} - enc_class OpcSErm (eRegI dst, immI imm) %{ // OpcSEr/m + enc_class OpcSErm (rRegI dst, immI imm) %{ // OpcSEr/m // Emit primary opcode and set sign-extend bit // Check for 8-bit immediate, and set sign extend bit in opcode if (($imm$$constant >= -128) && ($imm$$constant <= 127)) { @@ -1682,7 +1751,7 @@ encode %{ else emit_d32(cbuf,con); %} - enc_class OpcSReg (eRegI dst) %{ // BSWAP + enc_class OpcSReg (rRegI dst) %{ // BSWAP emit_cc(cbuf, $secondary, $dst$$reg ); %} @@ -1700,7 +1769,7 @@ encode %{ emit_rm(cbuf, 0x3, destlo, desthi); %} - enc_class RegOpc (eRegI div) %{ // IDIV, IMOD, JMP indirect, ... + enc_class RegOpc (rRegI div) %{ // IDIV, IMOD, JMP indirect, ... emit_rm(cbuf, 0x3, $secondary, $div$$reg ); %} @@ -1891,20 +1960,20 @@ encode %{ // runtime_call_Relocation::spec(), RELOC_IMM32 ); // %} - enc_class RegOpcImm (eRegI dst, immI8 shift) %{ // SHL, SAR, SHR + enc_class RegOpcImm (rRegI dst, immI8 shift) %{ // SHL, SAR, SHR $$$emit8$primary; emit_rm(cbuf, 0x3, $secondary, $dst$$reg); $$$emit8$shift$$constant; %} - enc_class LdImmI (eRegI dst, immI src) %{ // Load Immediate + enc_class LdImmI (rRegI dst, immI src) %{ // Load Immediate // Load immediate does not have a zero or sign extended version // for 8-bit immediates emit_opcode(cbuf, 0xB8 + $dst$$reg); $$$emit32$src$$constant; %} - enc_class LdImmP (eRegI dst, immI src) %{ // Load Immediate + enc_class LdImmP (rRegI dst, immI src) %{ // Load Immediate // Load immediate does not have a zero or sign extended version // for 8-bit immediates emit_opcode(cbuf, $primary + $dst$$reg); @@ -1943,15 +2012,15 @@ encode %{ // Encode a reg-reg copy. If it is useless, then empty encoding. - enc_class enc_Copy( eRegI dst, eRegI src ) %{ + enc_class enc_Copy( rRegI dst, rRegI src ) %{ encode_Copy( cbuf, $dst$$reg, $src$$reg ); %} - enc_class enc_CopyL_Lo( eRegI dst, eRegL src ) %{ + enc_class enc_CopyL_Lo( rRegI dst, eRegL src ) %{ encode_Copy( cbuf, $dst$$reg, $src$$reg ); %} - enc_class RegReg (eRegI dst, eRegI src) %{ // RegReg(Many) + enc_class RegReg (rRegI dst, rRegI src) %{ // RegReg(Many) emit_rm(cbuf, 0x3, $dst$$reg, $src$$reg); %} @@ -1973,7 +2042,7 @@ encode %{ emit_rm(cbuf, 0x3, HIGH_FROM_LOW($dst$$reg), HIGH_FROM_LOW($src$$reg)); %} - enc_class RegReg_HiLo( eRegL src, eRegI dst ) %{ + enc_class RegReg_HiLo( eRegL src, rRegI dst ) %{ emit_rm(cbuf, 0x3, $dst$$reg, HIGH_FROM_LOW($src$$reg)); %} @@ -2068,7 +2137,7 @@ encode %{ cbuf.set_insts_mark(); // Mark start of opcode for reloc info in mem operand %} - enc_class RegMem (eRegI ereg, memory mem) %{ // emit_reg_mem + enc_class RegMem (rRegI ereg, memory mem) %{ // emit_reg_mem int reg_encoding = $ereg$$reg; int base = $mem$$base; int index = $mem$$index; @@ -2132,7 +2201,7 @@ encode %{ // Clone of RegMem but accepts an extra parameter to access each // half of a double in memory; it never needs relocation info. - enc_class Mov_MemD_half_to_Reg (immI opcode, memory mem, immI disp_for_half, eRegI rm_reg) %{ + enc_class Mov_MemD_half_to_Reg (immI opcode, memory mem, immI disp_for_half, rRegI rm_reg) %{ emit_opcode(cbuf,$opcode$$constant); int reg_encoding = $rm_reg$$reg; int base = $mem$$base; @@ -2168,7 +2237,7 @@ encode %{ encode_RegMem(cbuf, rm_byte_opcode, base, index, scale, displace, disp_is_oop); %} - enc_class RegLea (eRegI dst, eRegI src0, immI src1 ) %{ // emit_reg_lea + enc_class RegLea (rRegI dst, rRegI src0, immI src1 ) %{ // emit_reg_lea int reg_encoding = $dst$$reg; int base = $src0$$reg; // 0xFFFFFFFF indicates no base int index = 0x04; // 0x04 indicates no index @@ -2178,7 +2247,7 @@ encode %{ encode_RegMem(cbuf, reg_encoding, base, index, scale, displace, disp_is_oop); %} - enc_class min_enc (eRegI dst, eRegI src) %{ // MIN + enc_class min_enc (rRegI dst, rRegI src) %{ // MIN // Compare dst,src emit_opcode(cbuf,0x3B); emit_rm(cbuf, 0x3, $dst$$reg, $src$$reg); @@ -2190,7 +2259,7 @@ encode %{ emit_rm(cbuf, 0x3, $dst$$reg, $src$$reg); %} - enc_class max_enc (eRegI dst, eRegI src) %{ // MAX + enc_class max_enc (rRegI dst, rRegI src) %{ // MAX // Compare dst,src emit_opcode(cbuf,0x3B); emit_rm(cbuf, 0x3, $dst$$reg, $src$$reg); @@ -2221,7 +2290,7 @@ encode %{ encode_RegMem(cbuf, reg_encoding, base, index, scale, displace, disp_is_oop); %} - enc_class neg_reg(eRegI dst) %{ + enc_class neg_reg(rRegI dst) %{ // NEG $dst emit_opcode(cbuf,0xF7); emit_rm(cbuf, 0x3, 0x03, $dst$$reg ); @@ -2251,7 +2320,7 @@ encode %{ emit_rm(cbuf, 0x3, $p$$reg, tmpReg); %} - enc_class enc_cmpLTP_mem(eRegI p, eRegI q, memory mem, eCXRegI tmp) %{ // cadd_cmpLT + enc_class enc_cmpLTP_mem(rRegI p, rRegI q, memory mem, eCXRegI tmp) %{ // cadd_cmpLT int tmpReg = $tmp$$reg; // SUB $p,$q @@ -2390,12 +2459,12 @@ encode %{ %} // Special case for moving an integer register to a stack slot. - enc_class OpcPRegSS( stackSlotI dst, eRegI src ) %{ // RegSS + enc_class OpcPRegSS( stackSlotI dst, rRegI src ) %{ // RegSS store_to_stackslot( cbuf, $primary, $src$$reg, $dst$$disp ); %} // Special case for moving a register to a stack slot. - enc_class RegSS( stackSlotI dst, eRegI src ) %{ // RegSS + enc_class RegSS( stackSlotI dst, rRegI src ) %{ // RegSS // Opcode already emitted emit_rm( cbuf, 0x02, $src$$reg, ESP_enc ); // R/M byte emit_rm( cbuf, 0x00, ESP_enc, ESP_enc); // SIB byte @@ -2640,7 +2709,7 @@ encode %{ // equal_result = 0; // nan_result = -1; - enc_class CmpF_Result(eRegI dst) %{ + enc_class CmpF_Result(rRegI dst) %{ // fnstsw_ax(); emit_opcode( cbuf, 0xDF); emit_opcode( cbuf, 0xE0); @@ -2685,7 +2754,7 @@ encode %{ // done: %} - enc_class convert_int_long( regL dst, eRegI src ) %{ + enc_class convert_int_long( regL dst, rRegI src ) %{ // mov $dst.lo,$src int dst_encoding = $dst$$reg; int src_encoding = $src$$reg; @@ -2754,7 +2823,7 @@ encode %{ emit_rm( cbuf, 0x3, 0x4, $src$$reg); %} - enc_class long_multiply( eADXRegL dst, eRegL src, eRegI tmp ) %{ + enc_class long_multiply( eADXRegL dst, eRegL src, rRegI tmp ) %{ // Basic idea: lo(result) = lo(x_lo * y_lo) // hi(result) = hi(x_lo * y_lo) + lo(x_hi * y_lo) + lo(x_lo * y_hi) // MOV $tmp,$src.lo @@ -2780,7 +2849,7 @@ encode %{ emit_rm( cbuf, 0x3, HIGH_FROM_LOW($dst$$reg), $tmp$$reg ); %} - enc_class long_multiply_con( eADXRegL dst, immL_127 src, eRegI tmp ) %{ + enc_class long_multiply_con( eADXRegL dst, immL_127 src, rRegI tmp ) %{ // Basic idea: lo(result) = lo(src * y_lo) // hi(result) = hi(src * y_lo) + lo(src * y_hi) // IMUL $tmp,EDX,$src @@ -2836,7 +2905,7 @@ encode %{ emit_d8(cbuf, 4*4); %} - enc_class long_cmp_flags0( eRegL src, eRegI tmp ) %{ + enc_class long_cmp_flags0( eRegL src, rRegI tmp ) %{ // MOV $tmp,$src.lo emit_opcode(cbuf, 0x8B); emit_rm(cbuf, 0x3, $tmp$$reg, $src$$reg); @@ -2857,7 +2926,7 @@ encode %{ emit_rm(cbuf, 0x3, HIGH_FROM_LOW($src1$$reg), HIGH_FROM_LOW($src2$$reg) ); %} - enc_class long_cmp_flags2( eRegL src1, eRegL src2, eRegI tmp ) %{ + enc_class long_cmp_flags2( eRegL src1, eRegL src2, rRegI tmp ) %{ // CMP $src1.lo,$src2.lo\t! Long compare; set flags for low bits emit_opcode( cbuf, 0x3B ); emit_rm(cbuf, 0x3, $src1$$reg, $src2$$reg ); @@ -2869,7 +2938,7 @@ encode %{ emit_rm(cbuf, 0x3, $tmp$$reg, HIGH_FROM_LOW($src2$$reg) ); %} - enc_class long_cmp_flags3( eRegL src, eRegI tmp ) %{ + enc_class long_cmp_flags3( eRegL src, rRegI tmp ) %{ // XOR $tmp,$tmp emit_opcode(cbuf,0x33); // XOR emit_rm(cbuf,0x3, $tmp$$reg, $tmp$$reg); @@ -3762,9 +3831,9 @@ frame %{ // in SSE2+ mode we want to keep the FPU stack clean so pretend // that C functions return float and double results in XMM0. if( ideal_reg == Op_RegD && UseSSE>=2 ) - return OptoRegPair(XMM0b_num,XMM0a_num); + return OptoRegPair(XMM0b_num,XMM0_num); if( ideal_reg == Op_RegF && UseSSE>=2 ) - return OptoRegPair(OptoReg::Bad,XMM0a_num); + return OptoRegPair(OptoReg::Bad,XMM0_num); return OptoRegPair(hi[ideal_reg],lo[ideal_reg]); %} @@ -3775,9 +3844,9 @@ frame %{ static int lo[Op_RegL+1] = { 0, 0, OptoReg::Bad, EAX_num, EAX_num, FPR1L_num, FPR1L_num, EAX_num }; static int hi[Op_RegL+1] = { 0, 0, OptoReg::Bad, OptoReg::Bad, OptoReg::Bad, OptoReg::Bad, FPR1H_num, EDX_num }; if( ideal_reg == Op_RegD && UseSSE>=2 ) - return OptoRegPair(XMM0b_num,XMM0a_num); + return OptoRegPair(XMM0b_num,XMM0_num); if( ideal_reg == Op_RegF && UseSSE>=1 ) - return OptoRegPair(OptoReg::Bad,XMM0a_num); + return OptoRegPair(OptoReg::Bad,XMM0_num); return OptoRegPair(hi[ideal_reg],lo[ideal_reg]); %} @@ -4147,8 +4216,8 @@ operand immI_65535() %{ // Register Operands // Integer Register -operand eRegI() %{ - constraint(ALLOC_IN_RC(e_reg)); +operand rRegI() %{ + constraint(ALLOC_IN_RC(int_reg)); match(RegI); match(xRegI); match(eAXRegI); @@ -4163,8 +4232,8 @@ operand eRegI() %{ %} // Subset of Integer Register -operand xRegI(eRegI reg) %{ - constraint(ALLOC_IN_RC(x_reg)); +operand xRegI(rRegI reg) %{ + constraint(ALLOC_IN_RC(int_x_reg)); match(reg); match(eAXRegI); match(eBXRegI); @@ -4179,7 +4248,7 @@ operand xRegI(eRegI reg) %{ operand eAXRegI(xRegI reg) %{ constraint(ALLOC_IN_RC(eax_reg)); match(reg); - match(eRegI); + match(rRegI); format %{ "EAX" %} interface(REG_INTER); @@ -4189,7 +4258,7 @@ operand eAXRegI(xRegI reg) %{ operand eBXRegI(xRegI reg) %{ constraint(ALLOC_IN_RC(ebx_reg)); match(reg); - match(eRegI); + match(rRegI); format %{ "EBX" %} interface(REG_INTER); @@ -4198,7 +4267,7 @@ operand eBXRegI(xRegI reg) %{ operand eCXRegI(xRegI reg) %{ constraint(ALLOC_IN_RC(ecx_reg)); match(reg); - match(eRegI); + match(rRegI); format %{ "ECX" %} interface(REG_INTER); @@ -4207,7 +4276,7 @@ operand eCXRegI(xRegI reg) %{ operand eDXRegI(xRegI reg) %{ constraint(ALLOC_IN_RC(edx_reg)); match(reg); - match(eRegI); + match(rRegI); format %{ "EDX" %} interface(REG_INTER); @@ -4216,7 +4285,7 @@ operand eDXRegI(xRegI reg) %{ operand eDIRegI(xRegI reg) %{ constraint(ALLOC_IN_RC(edi_reg)); match(reg); - match(eRegI); + match(rRegI); format %{ "EDI" %} interface(REG_INTER); @@ -4263,7 +4332,7 @@ operand ncxRegI() %{ operand eSIRegI(xRegI reg) %{ constraint(ALLOC_IN_RC(esi_reg)); match(reg); - match(eRegI); + match(rRegI); format %{ "ESI" %} interface(REG_INTER); @@ -4284,7 +4353,7 @@ operand anyRegP() %{ %} operand eRegP() %{ - constraint(ALLOC_IN_RC(e_reg)); + constraint(ALLOC_IN_RC(int_reg)); match(RegP); match(eAXRegP); match(eBXRegP); @@ -4297,7 +4366,7 @@ operand eRegP() %{ // On windows95, EBP is not safe to use for implicit null tests. operand eRegP_no_EBP() %{ - constraint(ALLOC_IN_RC(e_reg_no_rbp)); + constraint(ALLOC_IN_RC(int_reg_no_rbp)); match(RegP); match(eAXRegP); match(eBXRegP); @@ -4477,7 +4546,7 @@ operand flagsReg_long_LEGT() %{ // Float register operands operand regDPR() %{ predicate( UseSSE < 2 ); - constraint(ALLOC_IN_RC(dbl_reg)); + constraint(ALLOC_IN_RC(fp_dbl_reg)); match(RegD); match(regDPR1); match(regDPR2); @@ -4487,7 +4556,7 @@ operand regDPR() %{ operand regDPR1(regDPR reg) %{ predicate( UseSSE < 2 ); - constraint(ALLOC_IN_RC(dbl_reg0)); + constraint(ALLOC_IN_RC(fp_dbl_reg0)); match(reg); format %{ "FPR1" %} interface(REG_INTER); @@ -4495,7 +4564,7 @@ operand regDPR1(regDPR reg) %{ operand regDPR2(regDPR reg) %{ predicate( UseSSE < 2 ); - constraint(ALLOC_IN_RC(dbl_reg1)); + constraint(ALLOC_IN_RC(fp_dbl_reg1)); match(reg); format %{ "FPR2" %} interface(REG_INTER); @@ -4503,45 +4572,16 @@ operand regDPR2(regDPR reg) %{ operand regnotDPR1(regDPR reg) %{ predicate( UseSSE < 2 ); - constraint(ALLOC_IN_RC(dbl_notreg0)); + constraint(ALLOC_IN_RC(fp_dbl_notreg0)); match(reg); format %{ %} interface(REG_INTER); %} -// XMM Double register operands -operand regD() %{ - predicate( UseSSE>=2 ); - constraint(ALLOC_IN_RC(xdb_reg)); - match(RegD); - match(regD6); - match(regD7); - format %{ %} - interface(REG_INTER); -%} - -// XMM6 double register operands -operand regD6(regD reg) %{ - predicate( UseSSE>=2 ); - constraint(ALLOC_IN_RC(xdb_reg6)); - match(reg); - format %{ "XMM6" %} - interface(REG_INTER); -%} - -// XMM7 double register operands -operand regD7(regD reg) %{ - predicate( UseSSE>=2 ); - constraint(ALLOC_IN_RC(xdb_reg7)); - match(reg); - format %{ "XMM7" %} - interface(REG_INTER); -%} - // Float register operands operand regFPR() %{ predicate( UseSSE < 2 ); - constraint(ALLOC_IN_RC(flt_reg)); + constraint(ALLOC_IN_RC(fp_flt_reg)); match(RegF); match(regFPR1); format %{ %} @@ -4551,21 +4591,30 @@ operand regFPR() %{ // Float register operands operand regFPR1(regFPR reg) %{ predicate( UseSSE < 2 ); - constraint(ALLOC_IN_RC(flt_reg0)); + constraint(ALLOC_IN_RC(fp_flt_reg0)); match(reg); format %{ "FPR1" %} interface(REG_INTER); %} -// XMM register operands +// XMM Float register operands operand regF() %{ predicate( UseSSE>=1 ); - constraint(ALLOC_IN_RC(xmm_reg)); + constraint(ALLOC_IN_RC(float_reg)); match(RegF); format %{ %} interface(REG_INTER); %} +// XMM Double register operands +operand regD() %{ + predicate( UseSSE>=2 ); + constraint(ALLOC_IN_RC(double_reg)); + match(RegD); + format %{ %} + interface(REG_INTER); +%} + //----------Memory Operands---------------------------------------------------- // Direct Memory Operand @@ -4583,7 +4632,7 @@ operand direct(immP addr) %{ // Indirect Memory Operand operand indirect(eRegP reg) %{ - constraint(ALLOC_IN_RC(e_reg)); + constraint(ALLOC_IN_RC(int_reg)); match(reg); format %{ "[$reg]" %} @@ -4622,7 +4671,7 @@ operand indOffset32(eRegP reg, immI off) %{ %} // Indirect Memory Plus Long Offset Operand -operand indOffset32X(eRegI reg, immP off) %{ +operand indOffset32X(rRegI reg, immP off) %{ match(AddP off reg); format %{ "[$reg + $off]" %} @@ -4635,7 +4684,7 @@ operand indOffset32X(eRegI reg, immP off) %{ %} // Indirect Memory Plus Index Register Plus Offset Operand -operand indIndexOffset(eRegP reg, eRegI ireg, immI off) %{ +operand indIndexOffset(eRegP reg, rRegI ireg, immI off) %{ match(AddP (AddP reg ireg) off); op_cost(10); @@ -4649,7 +4698,7 @@ operand indIndexOffset(eRegP reg, eRegI ireg, immI off) %{ %} // Indirect Memory Plus Index Register Plus Offset Operand -operand indIndex(eRegP reg, eRegI ireg) %{ +operand indIndex(eRegP reg, rRegI ireg) %{ match(AddP reg ireg); op_cost(10); @@ -4667,7 +4716,7 @@ operand indIndex(eRegP reg, eRegI ireg) %{ // // ------------------------------------------------------------------------- // // Scaled Memory Operands // // Indirect Memory Times Scale Plus Offset Operand -// operand indScaleOffset(immP off, eRegI ireg, immI2 scale) %{ +// operand indScaleOffset(immP off, rRegI ireg, immI2 scale) %{ // match(AddP off (LShiftI ireg scale)); // // op_cost(10); @@ -4681,7 +4730,7 @@ operand indIndex(eRegP reg, eRegI ireg) %{ // %} // Indirect Memory Times Scale Plus Index Register -operand indIndexScale(eRegP reg, eRegI ireg, immI2 scale) %{ +operand indIndexScale(eRegP reg, rRegI ireg, immI2 scale) %{ match(AddP reg (LShiftI ireg scale)); op_cost(10); @@ -4695,7 +4744,7 @@ operand indIndexScale(eRegP reg, eRegI ireg, immI2 scale) %{ %} // Indirect Memory Times Scale Plus Index Register Plus Offset Operand -operand indIndexScaleOffset(eRegP reg, immI off, eRegI ireg, immI2 scale) %{ +operand indIndexScaleOffset(eRegP reg, immI off, rRegI ireg, immI2 scale) %{ match(AddP (AddP reg (LShiftI ireg scale)) off); op_cost(10); @@ -4823,7 +4872,7 @@ operand stackSlotL(sRegL reg) %{ // Indirect Memory Operand operand indirect_win95_safe(eRegP_no_EBP reg) %{ - constraint(ALLOC_IN_RC(e_reg)); + constraint(ALLOC_IN_RC(int_reg)); match(reg); op_cost(100); @@ -4867,7 +4916,7 @@ operand indOffset32_win95_safe(eRegP_no_EBP reg, immI off) %} // Indirect Memory Plus Index Register Plus Offset Operand -operand indIndexOffset_win95_safe(eRegP_no_EBP reg, eRegI ireg, immI off) +operand indIndexOffset_win95_safe(eRegP_no_EBP reg, rRegI ireg, immI off) %{ match(AddP (AddP reg ireg) off); @@ -4882,7 +4931,7 @@ operand indIndexOffset_win95_safe(eRegP_no_EBP reg, eRegI ireg, immI off) %} // Indirect Memory Times Scale Plus Index Register -operand indIndexScale_win95_safe(eRegP_no_EBP reg, eRegI ireg, immI2 scale) +operand indIndexScale_win95_safe(eRegP_no_EBP reg, rRegI ireg, immI2 scale) %{ match(AddP reg (LShiftI ireg scale)); @@ -4897,7 +4946,7 @@ operand indIndexScale_win95_safe(eRegP_no_EBP reg, eRegI ireg, immI2 scale) %} // Indirect Memory Times Scale Plus Index Register Plus Offset Operand -operand indIndexScaleOffset_win95_safe(eRegP_no_EBP reg, immI off, eRegI ireg, immI2 scale) +operand indIndexScaleOffset_win95_safe(eRegP_no_EBP reg, immI off, rRegI ireg, immI2 scale) %{ match(AddP (AddP reg (LShiftI ireg scale)) off); @@ -5086,7 +5135,7 @@ pipe_desc(S0, S1, S2, S3, S4, S5); // Or: _mem if it requires the big decoder and a memory unit. // Integer ALU reg operation -pipe_class ialu_reg(eRegI dst) %{ +pipe_class ialu_reg(rRegI dst) %{ single_instruction; dst : S4(write); dst : S3(read); @@ -5104,7 +5153,7 @@ pipe_class ialu_reg_long(eRegL dst) %{ %} // Integer ALU reg operation using big decoder -pipe_class ialu_reg_fat(eRegI dst) %{ +pipe_class ialu_reg_fat(rRegI dst) %{ single_instruction; dst : S4(write); dst : S3(read); @@ -5122,7 +5171,7 @@ pipe_class ialu_reg_long_fat(eRegL dst) %{ %} // Integer ALU reg-reg operation -pipe_class ialu_reg_reg(eRegI dst, eRegI src) %{ +pipe_class ialu_reg_reg(rRegI dst, rRegI src) %{ single_instruction; dst : S4(write); src : S3(read); @@ -5140,7 +5189,7 @@ pipe_class ialu_reg_reg_long(eRegL dst, eRegL src) %{ %} // Integer ALU reg-reg operation -pipe_class ialu_reg_reg_fat(eRegI dst, memory src) %{ +pipe_class ialu_reg_reg_fat(rRegI dst, memory src) %{ single_instruction; dst : S4(write); src : S3(read); @@ -5158,7 +5207,7 @@ pipe_class ialu_reg_reg_long_fat(eRegL dst, eRegL src) %{ %} // Integer ALU reg-mem operation -pipe_class ialu_reg_mem(eRegI dst, memory mem) %{ +pipe_class ialu_reg_mem(rRegI dst, memory mem) %{ single_instruction; dst : S5(write); mem : S3(read); @@ -5187,7 +5236,7 @@ pipe_class ialu_mem(memory mem) %} // Integer Store to Memory -pipe_class ialu_mem_reg(memory mem, eRegI src) %{ +pipe_class ialu_mem_reg(memory mem, rRegI src) %{ single_instruction; mem : S3(read); src : S5(read); @@ -5216,7 +5265,7 @@ pipe_class ialu_mem_imm(memory mem) %{ %} // Integer ALU0 reg-reg operation -pipe_class ialu_reg_reg_alu0(eRegI dst, eRegI src) %{ +pipe_class ialu_reg_reg_alu0(rRegI dst, rRegI src) %{ single_instruction; dst : S4(write); src : S3(read); @@ -5225,7 +5274,7 @@ pipe_class ialu_reg_reg_alu0(eRegI dst, eRegI src) %{ %} // Integer ALU0 reg-mem operation -pipe_class ialu_reg_mem_alu0(eRegI dst, memory mem) %{ +pipe_class ialu_reg_mem_alu0(rRegI dst, memory mem) %{ single_instruction; dst : S5(write); mem : S3(read); @@ -5235,7 +5284,7 @@ pipe_class ialu_reg_mem_alu0(eRegI dst, memory mem) %{ %} // Integer ALU reg-reg operation -pipe_class ialu_cr_reg_reg(eFlagsReg cr, eRegI src1, eRegI src2) %{ +pipe_class ialu_cr_reg_reg(eFlagsReg cr, rRegI src1, rRegI src2) %{ single_instruction; cr : S4(write); src1 : S3(read); @@ -5245,7 +5294,7 @@ pipe_class ialu_cr_reg_reg(eFlagsReg cr, eRegI src1, eRegI src2) %{ %} // Integer ALU reg-imm operation -pipe_class ialu_cr_reg_imm(eFlagsReg cr, eRegI src1) %{ +pipe_class ialu_cr_reg_imm(eFlagsReg cr, rRegI src1) %{ single_instruction; cr : S4(write); src1 : S3(read); @@ -5254,7 +5303,7 @@ pipe_class ialu_cr_reg_imm(eFlagsReg cr, eRegI src1) %{ %} // Integer ALU reg-mem operation -pipe_class ialu_cr_reg_mem(eFlagsReg cr, eRegI src1, memory src2) %{ +pipe_class ialu_cr_reg_mem(eFlagsReg cr, rRegI src1, memory src2) %{ single_instruction; cr : S4(write); src1 : S3(read); @@ -5265,7 +5314,7 @@ pipe_class ialu_cr_reg_mem(eFlagsReg cr, eRegI src1, memory src2) %{ %} // Conditional move reg-reg -pipe_class pipe_cmplt( eRegI p, eRegI q, eRegI y ) %{ +pipe_class pipe_cmplt( rRegI p, rRegI q, rRegI y ) %{ instruction_count(4); y : S4(read); q : S3(read); @@ -5274,7 +5323,7 @@ pipe_class pipe_cmplt( eRegI p, eRegI q, eRegI y ) %{ %} // Conditional move reg-reg -pipe_class pipe_cmov_reg( eRegI dst, eRegI src, eFlagsReg cr ) %{ +pipe_class pipe_cmov_reg( rRegI dst, rRegI src, eFlagsReg cr ) %{ single_instruction; dst : S4(write); src : S3(read); @@ -5283,7 +5332,7 @@ pipe_class pipe_cmov_reg( eRegI dst, eRegI src, eFlagsReg cr ) %{ %} // Conditional move reg-mem -pipe_class pipe_cmov_mem( eFlagsReg cr, eRegI dst, memory src) %{ +pipe_class pipe_cmov_mem( eFlagsReg cr, rRegI dst, memory src) %{ single_instruction; dst : S4(write); src : S3(read); @@ -5534,7 +5583,7 @@ define %{ // in the encode section of the architecture description. //----------BSWAP-Instruction-------------------------------------------------- -instruct bytes_reverse_int(eRegI dst) %{ +instruct bytes_reverse_int(rRegI dst) %{ match(Set dst (ReverseBytesI dst)); format %{ "BSWAP $dst" %} @@ -5555,7 +5604,7 @@ instruct bytes_reverse_long(eRegL dst) %{ ins_pipe( ialu_reg_reg); %} -instruct bytes_reverse_unsigned_short(eRegI dst, eFlagsReg cr) %{ +instruct bytes_reverse_unsigned_short(rRegI dst, eFlagsReg cr) %{ match(Set dst (ReverseBytesUS dst)); effect(KILL cr); @@ -5568,7 +5617,7 @@ instruct bytes_reverse_unsigned_short(eRegI dst, eFlagsReg cr) %{ ins_pipe( ialu_reg ); %} -instruct bytes_reverse_short(eRegI dst, eFlagsReg cr) %{ +instruct bytes_reverse_short(rRegI dst, eFlagsReg cr) %{ match(Set dst (ReverseBytesS dst)); effect(KILL cr); @@ -5584,7 +5633,7 @@ instruct bytes_reverse_short(eRegI dst, eFlagsReg cr) %{ //---------- Zeros Count Instructions ------------------------------------------ -instruct countLeadingZerosI(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct countLeadingZerosI(rRegI dst, rRegI src, eFlagsReg cr) %{ predicate(UseCountLeadingZerosInstruction); match(Set dst (CountLeadingZerosI src)); effect(KILL cr); @@ -5596,7 +5645,7 @@ instruct countLeadingZerosI(eRegI dst, eRegI src, eFlagsReg cr) %{ ins_pipe(ialu_reg); %} -instruct countLeadingZerosI_bsr(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct countLeadingZerosI_bsr(rRegI dst, rRegI src, eFlagsReg cr) %{ predicate(!UseCountLeadingZerosInstruction); match(Set dst (CountLeadingZerosI src)); effect(KILL cr); @@ -5621,7 +5670,7 @@ instruct countLeadingZerosI_bsr(eRegI dst, eRegI src, eFlagsReg cr) %{ ins_pipe(ialu_reg); %} -instruct countLeadingZerosL(eRegI dst, eRegL src, eFlagsReg cr) %{ +instruct countLeadingZerosL(rRegI dst, eRegL src, eFlagsReg cr) %{ predicate(UseCountLeadingZerosInstruction); match(Set dst (CountLeadingZerosL src)); effect(TEMP dst, KILL cr); @@ -5644,7 +5693,7 @@ instruct countLeadingZerosL(eRegI dst, eRegL src, eFlagsReg cr) %{ ins_pipe(ialu_reg); %} -instruct countLeadingZerosL_bsr(eRegI dst, eRegL src, eFlagsReg cr) %{ +instruct countLeadingZerosL_bsr(rRegI dst, eRegL src, eFlagsReg cr) %{ predicate(!UseCountLeadingZerosInstruction); match(Set dst (CountLeadingZerosL src)); effect(TEMP dst, KILL cr); @@ -5680,7 +5729,7 @@ instruct countLeadingZerosL_bsr(eRegI dst, eRegL src, eFlagsReg cr) %{ ins_pipe(ialu_reg); %} -instruct countTrailingZerosI(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct countTrailingZerosI(rRegI dst, rRegI src, eFlagsReg cr) %{ match(Set dst (CountTrailingZerosI src)); effect(KILL cr); @@ -5699,7 +5748,7 @@ instruct countTrailingZerosI(eRegI dst, eRegI src, eFlagsReg cr) %{ ins_pipe(ialu_reg); %} -instruct countTrailingZerosL(eRegI dst, eRegL src, eFlagsReg cr) %{ +instruct countTrailingZerosL(rRegI dst, eRegL src, eFlagsReg cr) %{ match(Set dst (CountTrailingZerosL src)); effect(TEMP dst, KILL cr); @@ -5731,7 +5780,7 @@ instruct countTrailingZerosL(eRegI dst, eRegL src, eFlagsReg cr) %{ //---------- Population Count Instructions ------------------------------------- -instruct popCountI(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct popCountI(rRegI dst, rRegI src, eFlagsReg cr) %{ predicate(UsePopCountInstruction); match(Set dst (PopCountI src)); effect(KILL cr); @@ -5743,7 +5792,7 @@ instruct popCountI(eRegI dst, eRegI src, eFlagsReg cr) %{ ins_pipe(ialu_reg); %} -instruct popCountI_mem(eRegI dst, memory mem, eFlagsReg cr) %{ +instruct popCountI_mem(rRegI dst, memory mem, eFlagsReg cr) %{ predicate(UsePopCountInstruction); match(Set dst (PopCountI (LoadI mem))); effect(KILL cr); @@ -5756,7 +5805,7 @@ instruct popCountI_mem(eRegI dst, memory mem, eFlagsReg cr) %{ %} // Note: Long.bitCount(long) returns an int. -instruct popCountL(eRegI dst, eRegL src, eRegI tmp, eFlagsReg cr) %{ +instruct popCountL(rRegI dst, eRegL src, rRegI tmp, eFlagsReg cr) %{ predicate(UsePopCountInstruction); match(Set dst (PopCountL src)); effect(KILL cr, TEMP tmp, TEMP dst); @@ -5773,7 +5822,7 @@ instruct popCountL(eRegI dst, eRegL src, eRegI tmp, eFlagsReg cr) %{ %} // Note: Long.bitCount(long) returns an int. -instruct popCountL_mem(eRegI dst, memory mem, eRegI tmp, eFlagsReg cr) %{ +instruct popCountL_mem(rRegI dst, memory mem, rRegI tmp, eFlagsReg cr) %{ predicate(UsePopCountInstruction); match(Set dst (PopCountL (LoadL mem))); effect(KILL cr, TEMP tmp, TEMP dst); @@ -5877,7 +5926,7 @@ instruct loadUB2L_immI8(eRegL dst, memory mem, immI8 mask, eFlagsReg cr) %{ %} // Load Short (16bit signed) -instruct loadS(eRegI dst, memory mem) %{ +instruct loadS(rRegI dst, memory mem) %{ match(Set dst (LoadS mem)); ins_cost(125); @@ -5891,7 +5940,7 @@ instruct loadS(eRegI dst, memory mem) %{ %} // Load Short (16 bit signed) to Byte (8 bit signed) -instruct loadS2B(eRegI dst, memory mem, immI_24 twentyfour) %{ +instruct loadS2B(rRegI dst, memory mem, immI_24 twentyfour) %{ match(Set dst (RShiftI (LShiftI (LoadS mem) twentyfour) twentyfour)); ins_cost(125); @@ -5922,7 +5971,7 @@ instruct loadS2L(eRegL dst, memory mem, eFlagsReg cr) %{ %} // Load Unsigned Short/Char (16bit unsigned) -instruct loadUS(eRegI dst, memory mem) %{ +instruct loadUS(rRegI dst, memory mem) %{ match(Set dst (LoadUS mem)); ins_cost(125); @@ -5936,7 +5985,7 @@ instruct loadUS(eRegI dst, memory mem) %{ %} // Load Unsigned Short/Char (16 bit UNsigned) to Byte (8 bit signed) -instruct loadUS2B(eRegI dst, memory mem, immI_24 twentyfour) %{ +instruct loadUS2B(rRegI dst, memory mem, immI_24 twentyfour) %{ match(Set dst (RShiftI (LShiftI (LoadUS mem) twentyfour) twentyfour)); ins_cost(125); @@ -5997,7 +6046,7 @@ instruct loadUS2L_immI16(eRegL dst, memory mem, immI16 mask, eFlagsReg cr) %{ %} // Load Integer -instruct loadI(eRegI dst, memory mem) %{ +instruct loadI(rRegI dst, memory mem) %{ match(Set dst (LoadI mem)); ins_cost(125); @@ -6011,7 +6060,7 @@ instruct loadI(eRegI dst, memory mem) %{ %} // Load Integer (32 bit signed) to Byte (8 bit signed) -instruct loadI2B(eRegI dst, memory mem, immI_24 twentyfour) %{ +instruct loadI2B(rRegI dst, memory mem, immI_24 twentyfour) %{ match(Set dst (RShiftI (LShiftI (LoadI mem) twentyfour) twentyfour)); ins_cost(125); @@ -6023,7 +6072,7 @@ instruct loadI2B(eRegI dst, memory mem, immI_24 twentyfour) %{ %} // Load Integer (32 bit signed) to Unsigned Byte (8 bit UNsigned) -instruct loadI2UB(eRegI dst, memory mem, immI_255 mask) %{ +instruct loadI2UB(rRegI dst, memory mem, immI_255 mask) %{ match(Set dst (AndI (LoadI mem) mask)); ins_cost(125); @@ -6035,7 +6084,7 @@ instruct loadI2UB(eRegI dst, memory mem, immI_255 mask) %{ %} // Load Integer (32 bit signed) to Short (16 bit signed) -instruct loadI2S(eRegI dst, memory mem, immI_16 sixteen) %{ +instruct loadI2S(rRegI dst, memory mem, immI_16 sixteen) %{ match(Set dst (RShiftI (LShiftI (LoadI mem) sixteen) sixteen)); ins_cost(125); @@ -6047,7 +6096,7 @@ instruct loadI2S(eRegI dst, memory mem, immI_16 sixteen) %{ %} // Load Integer (32 bit signed) to Unsigned Short/Char (16 bit UNsigned) -instruct loadI2US(eRegI dst, memory mem, immI_65535 mask) %{ +instruct loadI2US(rRegI dst, memory mem, immI_65535 mask) %{ match(Set dst (AndI (LoadI mem) mask)); ins_cost(125); @@ -6208,7 +6257,7 @@ instruct loadLX_reg_volatile(eRegL dst, memory mem, regD tmp) %{ %} // Load Range -instruct loadRange(eRegI dst, memory mem) %{ +instruct loadRange(rRegI dst, memory mem) %{ match(Set dst (LoadRange mem)); ins_cost(125); @@ -6305,66 +6354,6 @@ instruct loadFPR(regFPR dst, memory mem) %{ ins_pipe( fpu_reg_mem ); %} -// Load Aligned Packed Byte to XMM register -instruct loadA8B(regD dst, memory mem) %{ - predicate(UseSSE>=1); - match(Set dst (Load8B mem)); - ins_cost(125); - format %{ "MOVQ $dst,$mem\t! packed8B" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - -// Load Aligned Packed Short to XMM register -instruct loadA4S(regD dst, memory mem) %{ - predicate(UseSSE>=1); - match(Set dst (Load4S mem)); - ins_cost(125); - format %{ "MOVQ $dst,$mem\t! packed4S" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - -// Load Aligned Packed Char to XMM register -instruct loadA4C(regD dst, memory mem) %{ - predicate(UseSSE>=1); - match(Set dst (Load4C mem)); - ins_cost(125); - format %{ "MOVQ $dst,$mem\t! packed4C" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - -// Load Aligned Packed Integer to XMM register -instruct load2IU(regD dst, memory mem) %{ - predicate(UseSSE>=1); - match(Set dst (Load2I mem)); - ins_cost(125); - format %{ "MOVQ $dst,$mem\t! packed2I" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - -// Load Aligned Packed Single to XMM -instruct loadA2F(regD dst, memory mem) %{ - predicate(UseSSE>=1); - match(Set dst (Load2F mem)); - ins_cost(145); - format %{ "MOVQ $dst,$mem\t! packed2F" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - // Load Effective Address instruct leaP8(eRegP dst, indOffset8 mem) %{ match(Set dst mem); @@ -6417,7 +6406,7 @@ instruct leaPIdxScaleOff(eRegP dst, indIndexScaleOffset mem) %{ %} // Load Constant -instruct loadConI(eRegI dst, immI src) %{ +instruct loadConI(rRegI dst, immI src) %{ match(Set dst src); format %{ "MOV $dst,$src" %} @@ -6426,7 +6415,7 @@ instruct loadConI(eRegI dst, immI src) %{ %} // Load Constant zero -instruct loadConI0(eRegI dst, immI0 src, eFlagsReg cr) %{ +instruct loadConI0(rRegI dst, immI0 src, eFlagsReg cr) %{ match(Set dst src); effect(KILL cr); @@ -6594,7 +6583,7 @@ instruct loadConD0(regD dst, immD0 src) %{ %} // Load Stack Slot -instruct loadSSI(eRegI dst, stackSlotI src) %{ +instruct loadSSI(rRegI dst, stackSlotI src) %{ match(Set dst src); ins_cost(125); @@ -6821,7 +6810,7 @@ instruct storeB(memory mem, xRegI src) %{ %} // Store Char/Short -instruct storeC(memory mem, eRegI src) %{ +instruct storeC(memory mem, rRegI src) %{ match(Set mem (StoreC mem src)); ins_cost(125); @@ -6832,7 +6821,7 @@ instruct storeC(memory mem, eRegI src) %{ %} // Store Integer -instruct storeI(memory mem, eRegI src) %{ +instruct storeI(memory mem, rRegI src) %{ match(Set mem (StoreI mem src)); ins_cost(125); @@ -6976,42 +6965,6 @@ instruct storeImmB(memory mem, immI8 src) %{ ins_pipe( ialu_mem_imm ); %} -// Store Aligned Packed Byte XMM register to memory -instruct storeA8B(memory mem, regD src) %{ - predicate(UseSSE>=1); - match(Set mem (Store8B mem src)); - ins_cost(145); - format %{ "MOVQ $mem,$src\t! packed8B" %} - ins_encode %{ - __ movq($mem$$Address, $src$$XMMRegister); - %} - ins_pipe( pipe_slow ); -%} - -// Store Aligned Packed Char/Short XMM register to memory -instruct storeA4C(memory mem, regD src) %{ - predicate(UseSSE>=1); - match(Set mem (Store4C mem src)); - ins_cost(145); - format %{ "MOVQ $mem,$src\t! packed4C" %} - ins_encode %{ - __ movq($mem$$Address, $src$$XMMRegister); - %} - ins_pipe( pipe_slow ); -%} - -// Store Aligned Packed Integer XMM register to memory -instruct storeA2I(memory mem, regD src) %{ - predicate(UseSSE>=1); - match(Set mem (Store2I mem src)); - ins_cost(145); - format %{ "MOVQ $mem,$src\t! packed2I" %} - ins_encode %{ - __ movq($mem$$Address, $src$$XMMRegister); - %} - ins_pipe( pipe_slow ); -%} - // Store CMS card-mark Immediate instruct storeImmCM(memory mem, immI8 src) %{ match(Set mem (StoreCM mem src)); @@ -7073,18 +7026,6 @@ instruct storeF(memory mem, regF src) %{ ins_pipe( pipe_slow ); %} -// Store Aligned Packed Single Float XMM register to memory -instruct storeA2F(memory mem, regD src) %{ - predicate(UseSSE>=1); - match(Set mem (Store2F mem src)); - ins_cost(145); - format %{ "MOVQ $mem,$src\t! packed2F" %} - ins_encode %{ - __ movq($mem$$Address, $src$$XMMRegister); - %} - ins_pipe( pipe_slow ); -%} - // Store Float instruct storeFPR( memory mem, regFPR1 src) %{ predicate(UseSSE==0); @@ -7146,7 +7087,7 @@ instruct storeF_imm( memory mem, immF src) %{ %} // Store Integer to stack slot -instruct storeSSI(stackSlotI dst, eRegI src) %{ +instruct storeSSI(stackSlotI dst, rRegI src) %{ match(Set dst src); ins_cost(100); @@ -7271,7 +7212,7 @@ instruct castX2P(eAXRegP dst, eAXRegI src) %{ ins_pipe(empty); %} -instruct castP2X(eRegI dst, eRegP src ) %{ +instruct castP2X(rRegI dst, eRegP src ) %{ match(Set dst (CastP2X src)); ins_cost(50); format %{ "MOV $dst, $src\t# CastP2X" %} @@ -7281,7 +7222,7 @@ instruct castP2X(eRegI dst, eRegP src ) %{ //----------Conditional Move--------------------------------------------------- // Conditional move -instruct jmovI_reg(cmpOp cop, eFlagsReg cr, eRegI dst, eRegI src) %{ +instruct jmovI_reg(cmpOp cop, eFlagsReg cr, rRegI dst, rRegI src) %{ predicate(!VM_Version::supports_cmov() ); match(Set dst (CMoveI (Binary cop cr) (Binary dst src))); ins_cost(200); @@ -7298,7 +7239,7 @@ instruct jmovI_reg(cmpOp cop, eFlagsReg cr, eRegI dst, eRegI src) %{ ins_pipe( pipe_cmov_reg ); %} -instruct jmovI_regU(cmpOpU cop, eFlagsRegU cr, eRegI dst, eRegI src) %{ +instruct jmovI_regU(cmpOpU cop, eFlagsRegU cr, rRegI dst, rRegI src) %{ predicate(!VM_Version::supports_cmov() ); match(Set dst (CMoveI (Binary cop cr) (Binary dst src))); ins_cost(200); @@ -7315,7 +7256,7 @@ instruct jmovI_regU(cmpOpU cop, eFlagsRegU cr, eRegI dst, eRegI src) %{ ins_pipe( pipe_cmov_reg ); %} -instruct cmovI_reg(eRegI dst, eRegI src, eFlagsReg cr, cmpOp cop ) %{ +instruct cmovI_reg(rRegI dst, rRegI src, eFlagsReg cr, cmpOp cop ) %{ predicate(VM_Version::supports_cmov() ); match(Set dst (CMoveI (Binary cop cr) (Binary dst src))); ins_cost(200); @@ -7325,7 +7266,7 @@ instruct cmovI_reg(eRegI dst, eRegI src, eFlagsReg cr, cmpOp cop ) %{ ins_pipe( pipe_cmov_reg ); %} -instruct cmovI_regU( cmpOpU cop, eFlagsRegU cr, eRegI dst, eRegI src ) %{ +instruct cmovI_regU( cmpOpU cop, eFlagsRegU cr, rRegI dst, rRegI src ) %{ predicate(VM_Version::supports_cmov() ); match(Set dst (CMoveI (Binary cop cr) (Binary dst src))); ins_cost(200); @@ -7335,7 +7276,7 @@ instruct cmovI_regU( cmpOpU cop, eFlagsRegU cr, eRegI dst, eRegI src ) %{ ins_pipe( pipe_cmov_reg ); %} -instruct cmovI_regUCF( cmpOpUCF cop, eFlagsRegUCF cr, eRegI dst, eRegI src ) %{ +instruct cmovI_regUCF( cmpOpUCF cop, eFlagsRegUCF cr, rRegI dst, rRegI src ) %{ predicate(VM_Version::supports_cmov() ); match(Set dst (CMoveI (Binary cop cr) (Binary dst src))); ins_cost(200); @@ -7345,7 +7286,7 @@ instruct cmovI_regUCF( cmpOpUCF cop, eFlagsRegUCF cr, eRegI dst, eRegI src ) %{ %} // Conditional move -instruct cmovI_mem(cmpOp cop, eFlagsReg cr, eRegI dst, memory src) %{ +instruct cmovI_mem(cmpOp cop, eFlagsReg cr, rRegI dst, memory src) %{ predicate(VM_Version::supports_cmov() ); match(Set dst (CMoveI (Binary cop cr) (Binary dst (LoadI src)))); ins_cost(250); @@ -7356,7 +7297,7 @@ instruct cmovI_mem(cmpOp cop, eFlagsReg cr, eRegI dst, memory src) %{ %} // Conditional move -instruct cmovI_memU(cmpOpU cop, eFlagsRegU cr, eRegI dst, memory src) %{ +instruct cmovI_memU(cmpOpU cop, eFlagsRegU cr, rRegI dst, memory src) %{ predicate(VM_Version::supports_cmov() ); match(Set dst (CMoveI (Binary cop cr) (Binary dst (LoadI src)))); ins_cost(250); @@ -7366,7 +7307,7 @@ instruct cmovI_memU(cmpOpU cop, eFlagsRegU cr, eRegI dst, memory src) %{ ins_pipe( pipe_cmov_mem ); %} -instruct cmovI_memUCF(cmpOpUCF cop, eFlagsRegUCF cr, eRegI dst, memory src) %{ +instruct cmovI_memUCF(cmpOpUCF cop, eFlagsRegUCF cr, rRegI dst, memory src) %{ predicate(VM_Version::supports_cmov() ); match(Set dst (CMoveI (Binary cop cr) (Binary dst (LoadI src)))); ins_cost(250); @@ -7620,7 +7561,7 @@ instruct cmovL_regUCF(cmpOpUCF cop, eFlagsRegUCF cr, eRegL dst, eRegL src) %{ //----------Arithmetic Instructions-------------------------------------------- //----------Addition Instructions---------------------------------------------- // Integer Addition Instructions -instruct addI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct addI_eReg(rRegI dst, rRegI src, eFlagsReg cr) %{ match(Set dst (AddI dst src)); effect(KILL cr); @@ -7631,7 +7572,7 @@ instruct addI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ ins_pipe( ialu_reg_reg ); %} -instruct addI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ +instruct addI_eReg_imm(rRegI dst, immI src, eFlagsReg cr) %{ match(Set dst (AddI dst src)); effect(KILL cr); @@ -7641,7 +7582,7 @@ instruct addI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ ins_pipe( ialu_reg ); %} -instruct incI_eReg(eRegI dst, immI1 src, eFlagsReg cr) %{ +instruct incI_eReg(rRegI dst, immI1 src, eFlagsReg cr) %{ predicate(UseIncDec); match(Set dst (AddI dst src)); effect(KILL cr); @@ -7653,7 +7594,7 @@ instruct incI_eReg(eRegI dst, immI1 src, eFlagsReg cr) %{ ins_pipe( ialu_reg ); %} -instruct leaI_eReg_immI(eRegI dst, eRegI src0, immI src1) %{ +instruct leaI_eReg_immI(rRegI dst, rRegI src0, immI src1) %{ match(Set dst (AddI src0 src1)); ins_cost(110); @@ -7673,7 +7614,7 @@ instruct leaP_eReg_immI(eRegP dst, eRegP src0, immI src1) %{ ins_pipe( ialu_reg_reg ); %} -instruct decI_eReg(eRegI dst, immI_M1 src, eFlagsReg cr) %{ +instruct decI_eReg(rRegI dst, immI_M1 src, eFlagsReg cr) %{ predicate(UseIncDec); match(Set dst (AddI dst src)); effect(KILL cr); @@ -7685,7 +7626,7 @@ instruct decI_eReg(eRegI dst, immI_M1 src, eFlagsReg cr) %{ ins_pipe( ialu_reg ); %} -instruct addP_eReg(eRegP dst, eRegI src, eFlagsReg cr) %{ +instruct addP_eReg(eRegP dst, rRegI src, eFlagsReg cr) %{ match(Set dst (AddP dst src)); effect(KILL cr); @@ -7707,7 +7648,7 @@ instruct addP_eReg_imm(eRegP dst, immI src, eFlagsReg cr) %{ ins_pipe( ialu_reg ); %} -instruct addI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ +instruct addI_eReg_mem(rRegI dst, memory src, eFlagsReg cr) %{ match(Set dst (AddI dst (LoadI src))); effect(KILL cr); @@ -7718,7 +7659,7 @@ instruct addI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ ins_pipe( ialu_reg_mem ); %} -instruct addI_mem_eReg(memory dst, eRegI src, eFlagsReg cr) %{ +instruct addI_mem_eReg(memory dst, rRegI src, eFlagsReg cr) %{ match(Set dst (StoreI dst (AddI (LoadI dst) src))); effect(KILL cr); @@ -7780,7 +7721,7 @@ instruct castPP( eRegP dst ) %{ ins_pipe( empty ); %} -instruct castII( eRegI dst ) %{ +instruct castII( rRegI dst ) %{ match(Set dst (CastII dst)); format %{ "#castII of $dst" %} ins_encode( /*empty encoding*/ ); @@ -7814,7 +7755,7 @@ instruct storePConditional( memory heap_top_ptr, eAXRegP oldval, eRegP newval, e // Conditional-store of an int value. // ZF flag is set on success, reset otherwise. Implemented with a CMPXCHG on Intel. -instruct storeIConditional( memory mem, eAXRegI oldval, eRegI newval, eFlagsReg cr ) %{ +instruct storeIConditional( memory mem, eAXRegI oldval, rRegI newval, eFlagsReg cr ) %{ match(Set cr (StoreIConditional mem (Binary oldval newval))); effect(KILL oldval); format %{ "CMPXCHG $mem,$newval\t# If EAX==$mem Then store $newval into $mem" %} @@ -7847,7 +7788,7 @@ instruct storeLConditional( memory mem, eADXRegL oldval, eBCXRegL newval, eFlags // No flag versions for CompareAndSwap{P,I,L} because matcher can't match them -instruct compareAndSwapL( eRegI res, eSIRegP mem_ptr, eADXRegL oldval, eBCXRegL newval, eFlagsReg cr ) %{ +instruct compareAndSwapL( rRegI res, eSIRegP mem_ptr, eADXRegL oldval, eBCXRegL newval, eFlagsReg cr ) %{ match(Set res (CompareAndSwapL mem_ptr (Binary oldval newval))); effect(KILL cr, KILL oldval); format %{ "CMPXCHG8 [$mem_ptr],$newval\t# If EDX:EAX==[$mem_ptr] Then store $newval into [$mem_ptr]\n\t" @@ -7860,7 +7801,7 @@ instruct compareAndSwapL( eRegI res, eSIRegP mem_ptr, eADXRegL oldval, eBCXRegL ins_pipe( pipe_cmpxchg ); %} -instruct compareAndSwapP( eRegI res, pRegP mem_ptr, eAXRegP oldval, eCXRegP newval, eFlagsReg cr) %{ +instruct compareAndSwapP( rRegI res, pRegP mem_ptr, eAXRegP oldval, eCXRegP newval, eFlagsReg cr) %{ match(Set res (CompareAndSwapP mem_ptr (Binary oldval newval))); effect(KILL cr, KILL oldval); format %{ "CMPXCHG [$mem_ptr],$newval\t# If EAX==[$mem_ptr] Then store $newval into [$mem_ptr]\n\t" @@ -7872,7 +7813,7 @@ instruct compareAndSwapP( eRegI res, pRegP mem_ptr, eAXRegP oldval, eCXRegP new ins_pipe( pipe_cmpxchg ); %} -instruct compareAndSwapI( eRegI res, pRegP mem_ptr, eAXRegI oldval, eCXRegI newval, eFlagsReg cr) %{ +instruct compareAndSwapI( rRegI res, pRegP mem_ptr, eAXRegI oldval, eCXRegI newval, eFlagsReg cr) %{ match(Set res (CompareAndSwapI mem_ptr (Binary oldval newval))); effect(KILL cr, KILL oldval); format %{ "CMPXCHG [$mem_ptr],$newval\t# If EAX==[$mem_ptr] Then store $newval into [$mem_ptr]\n\t" @@ -7886,7 +7827,7 @@ instruct compareAndSwapI( eRegI res, pRegP mem_ptr, eAXRegI oldval, eCXRegI newv //----------Subtraction Instructions------------------------------------------- // Integer Subtraction Instructions -instruct subI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct subI_eReg(rRegI dst, rRegI src, eFlagsReg cr) %{ match(Set dst (SubI dst src)); effect(KILL cr); @@ -7897,7 +7838,7 @@ instruct subI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ ins_pipe( ialu_reg_reg ); %} -instruct subI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ +instruct subI_eReg_imm(rRegI dst, immI src, eFlagsReg cr) %{ match(Set dst (SubI dst src)); effect(KILL cr); @@ -7908,7 +7849,7 @@ instruct subI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ ins_pipe( ialu_reg ); %} -instruct subI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ +instruct subI_eReg_mem(rRegI dst, memory src, eFlagsReg cr) %{ match(Set dst (SubI dst (LoadI src))); effect(KILL cr); @@ -7919,7 +7860,7 @@ instruct subI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ ins_pipe( ialu_reg_mem ); %} -instruct subI_mem_eReg(memory dst, eRegI src, eFlagsReg cr) %{ +instruct subI_mem_eReg(memory dst, rRegI src, eFlagsReg cr) %{ match(Set dst (StoreI dst (SubI (LoadI dst) src))); effect(KILL cr); @@ -7931,7 +7872,7 @@ instruct subI_mem_eReg(memory dst, eRegI src, eFlagsReg cr) %{ %} // Subtract from a pointer -instruct subP_eReg(eRegP dst, eRegI src, immI0 zero, eFlagsReg cr) %{ +instruct subP_eReg(eRegP dst, rRegI src, immI0 zero, eFlagsReg cr) %{ match(Set dst (AddP dst (SubI zero src))); effect(KILL cr); @@ -7942,7 +7883,7 @@ instruct subP_eReg(eRegP dst, eRegI src, immI0 zero, eFlagsReg cr) %{ ins_pipe( ialu_reg_reg ); %} -instruct negI_eReg(eRegI dst, immI0 zero, eFlagsReg cr) %{ +instruct negI_eReg(rRegI dst, immI0 zero, eFlagsReg cr) %{ match(Set dst (SubI zero dst)); effect(KILL cr); @@ -7957,7 +7898,7 @@ instruct negI_eReg(eRegI dst, immI0 zero, eFlagsReg cr) %{ //----------Multiplication/Division Instructions------------------------------- // Integer Multiplication Instructions // Multiply Register -instruct mulI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct mulI_eReg(rRegI dst, rRegI src, eFlagsReg cr) %{ match(Set dst (MulI dst src)); effect(KILL cr); @@ -7970,7 +7911,7 @@ instruct mulI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ %} // Multiply 32-bit Immediate -instruct mulI_eReg_imm(eRegI dst, eRegI src, immI imm, eFlagsReg cr) %{ +instruct mulI_eReg_imm(rRegI dst, rRegI src, immI imm, eFlagsReg cr) %{ match(Set dst (MulI src imm)); effect(KILL cr); @@ -8026,7 +7967,7 @@ instruct mulI_imm_RShift_high(eDXRegI dst, nadxRegI src1, eADXRegL_low_only src2 %} // Multiply Memory 32-bit Immediate -instruct mulI_mem_imm(eRegI dst, memory src, immI imm, eFlagsReg cr) %{ +instruct mulI_mem_imm(rRegI dst, memory src, immI imm, eFlagsReg cr) %{ match(Set dst (MulI (LoadI src) imm)); effect(KILL cr); @@ -8038,7 +7979,7 @@ instruct mulI_mem_imm(eRegI dst, memory src, immI imm, eFlagsReg cr) %{ %} // Multiply Memory -instruct mulI(eRegI dst, memory src, eFlagsReg cr) %{ +instruct mulI(rRegI dst, memory src, eFlagsReg cr) %{ match(Set dst (MulI dst (LoadI src))); effect(KILL cr); @@ -8075,7 +8016,7 @@ instruct mulIS_eReg(eADXRegL dst, immL_32bits mask, eFlagsReg flags, eAXRegI src %} // Multiply Register Long -instruct mulL_eReg(eADXRegL dst, eRegL src, eRegI tmp, eFlagsReg cr) %{ +instruct mulL_eReg(eADXRegL dst, eRegL src, rRegI tmp, eFlagsReg cr) %{ match(Set dst (MulL dst src)); effect(KILL cr, TEMP tmp); ins_cost(4*100+3*400); @@ -8093,7 +8034,7 @@ instruct mulL_eReg(eADXRegL dst, eRegL src, eRegI tmp, eFlagsReg cr) %{ %} // Multiply Register Long where the left operand's high 32 bits are zero -instruct mulL_eReg_lhi0(eADXRegL dst, eRegL src, eRegI tmp, eFlagsReg cr) %{ +instruct mulL_eReg_lhi0(eADXRegL dst, eRegL src, rRegI tmp, eFlagsReg cr) %{ predicate(is_operand_hi32_zero(n->in(1))); match(Set dst (MulL dst src)); effect(KILL cr, TEMP tmp); @@ -8114,7 +8055,7 @@ instruct mulL_eReg_lhi0(eADXRegL dst, eRegL src, eRegI tmp, eFlagsReg cr) %{ %} // Multiply Register Long where the right operand's high 32 bits are zero -instruct mulL_eReg_rhi0(eADXRegL dst, eRegL src, eRegI tmp, eFlagsReg cr) %{ +instruct mulL_eReg_rhi0(eADXRegL dst, eRegL src, rRegI tmp, eFlagsReg cr) %{ predicate(is_operand_hi32_zero(n->in(2))); match(Set dst (MulL dst src)); effect(KILL cr, TEMP tmp); @@ -8150,7 +8091,7 @@ instruct mulL_eReg_hi0(eADXRegL dst, eRegL src, eFlagsReg cr) %{ %} // Multiply Register Long by small constant -instruct mulL_eReg_con(eADXRegL dst, immL_127 src, eRegI tmp, eFlagsReg cr) %{ +instruct mulL_eReg_con(eADXRegL dst, immL_127 src, rRegI tmp, eFlagsReg cr) %{ match(Set dst (MulL dst src)); effect(KILL cr, TEMP tmp); ins_cost(2*100+2*400); @@ -8248,7 +8189,7 @@ instruct modL_eReg( eADXRegL dst, eRegL src1, eRegL src2, eFlagsReg cr, eCXRegI %} // Divide Register Long (no special case since divisor != -1) -instruct divL_eReg_imm32( eADXRegL dst, immL32 imm, eRegI tmp, eRegI tmp2, eFlagsReg cr ) %{ +instruct divL_eReg_imm32( eADXRegL dst, immL32 imm, rRegI tmp, rRegI tmp2, eFlagsReg cr ) %{ match(Set dst (DivL dst imm)); effect( TEMP tmp, TEMP tmp2, KILL cr ); ins_cost(1000); @@ -8319,7 +8260,7 @@ instruct divL_eReg_imm32( eADXRegL dst, immL32 imm, eRegI tmp, eRegI tmp2, eFlag %} // Remainder Register Long (remainder fit into 32 bits) -instruct modL_eReg_imm32( eADXRegL dst, immL32 imm, eRegI tmp, eRegI tmp2, eFlagsReg cr ) %{ +instruct modL_eReg_imm32( eADXRegL dst, immL32 imm, rRegI tmp, rRegI tmp2, eFlagsReg cr ) %{ match(Set dst (ModL dst imm)); effect( TEMP tmp, TEMP tmp2, KILL cr ); ins_cost(1000); @@ -8387,7 +8328,7 @@ instruct modL_eReg_imm32( eADXRegL dst, immL32 imm, eRegI tmp, eRegI tmp2, eFlag // Integer Shift Instructions // Shift Left by one -instruct shlI_eReg_1(eRegI dst, immI1 shift, eFlagsReg cr) %{ +instruct shlI_eReg_1(rRegI dst, immI1 shift, eFlagsReg cr) %{ match(Set dst (LShiftI dst shift)); effect(KILL cr); @@ -8399,7 +8340,7 @@ instruct shlI_eReg_1(eRegI dst, immI1 shift, eFlagsReg cr) %{ %} // Shift Left by 8-bit immediate -instruct salI_eReg_imm(eRegI dst, immI8 shift, eFlagsReg cr) %{ +instruct salI_eReg_imm(rRegI dst, immI8 shift, eFlagsReg cr) %{ match(Set dst (LShiftI dst shift)); effect(KILL cr); @@ -8411,7 +8352,7 @@ instruct salI_eReg_imm(eRegI dst, immI8 shift, eFlagsReg cr) %{ %} // Shift Left by variable -instruct salI_eReg_CL(eRegI dst, eCXRegI shift, eFlagsReg cr) %{ +instruct salI_eReg_CL(rRegI dst, eCXRegI shift, eFlagsReg cr) %{ match(Set dst (LShiftI dst shift)); effect(KILL cr); @@ -8423,7 +8364,7 @@ instruct salI_eReg_CL(eRegI dst, eCXRegI shift, eFlagsReg cr) %{ %} // Arithmetic shift right by one -instruct sarI_eReg_1(eRegI dst, immI1 shift, eFlagsReg cr) %{ +instruct sarI_eReg_1(rRegI dst, immI1 shift, eFlagsReg cr) %{ match(Set dst (RShiftI dst shift)); effect(KILL cr); @@ -8445,7 +8386,7 @@ instruct sarI_mem_1(memory dst, immI1 shift, eFlagsReg cr) %{ %} // Arithmetic Shift Right by 8-bit immediate -instruct sarI_eReg_imm(eRegI dst, immI8 shift, eFlagsReg cr) %{ +instruct sarI_eReg_imm(rRegI dst, immI8 shift, eFlagsReg cr) %{ match(Set dst (RShiftI dst shift)); effect(KILL cr); @@ -8468,7 +8409,7 @@ instruct sarI_mem_imm(memory dst, immI8 shift, eFlagsReg cr) %{ %} // Arithmetic Shift Right by variable -instruct sarI_eReg_CL(eRegI dst, eCXRegI shift, eFlagsReg cr) %{ +instruct sarI_eReg_CL(rRegI dst, eCXRegI shift, eFlagsReg cr) %{ match(Set dst (RShiftI dst shift)); effect(KILL cr); @@ -8480,7 +8421,7 @@ instruct sarI_eReg_CL(eRegI dst, eCXRegI shift, eFlagsReg cr) %{ %} // Logical shift right by one -instruct shrI_eReg_1(eRegI dst, immI1 shift, eFlagsReg cr) %{ +instruct shrI_eReg_1(rRegI dst, immI1 shift, eFlagsReg cr) %{ match(Set dst (URShiftI dst shift)); effect(KILL cr); @@ -8492,7 +8433,7 @@ instruct shrI_eReg_1(eRegI dst, immI1 shift, eFlagsReg cr) %{ %} // Logical Shift Right by 8-bit immediate -instruct shrI_eReg_imm(eRegI dst, immI8 shift, eFlagsReg cr) %{ +instruct shrI_eReg_imm(rRegI dst, immI8 shift, eFlagsReg cr) %{ match(Set dst (URShiftI dst shift)); effect(KILL cr); @@ -8506,7 +8447,7 @@ instruct shrI_eReg_imm(eRegI dst, immI8 shift, eFlagsReg cr) %{ // Logical Shift Right by 24, followed by Arithmetic Shift Left by 24. // This idiom is used by the compiler for the i2b bytecode. -instruct i2b(eRegI dst, xRegI src, immI_24 twentyfour) %{ +instruct i2b(rRegI dst, xRegI src, immI_24 twentyfour) %{ match(Set dst (RShiftI (LShiftI src twentyfour) twentyfour)); size(3); @@ -8519,7 +8460,7 @@ instruct i2b(eRegI dst, xRegI src, immI_24 twentyfour) %{ // Logical Shift Right by 16, followed by Arithmetic Shift Left by 16. // This idiom is used by the compiler the i2s bytecode. -instruct i2s(eRegI dst, xRegI src, immI_16 sixteen) %{ +instruct i2s(rRegI dst, xRegI src, immI_16 sixteen) %{ match(Set dst (RShiftI (LShiftI src sixteen) sixteen)); size(3); @@ -8532,7 +8473,7 @@ instruct i2s(eRegI dst, xRegI src, immI_16 sixteen) %{ // Logical Shift Right by variable -instruct shrI_eReg_CL(eRegI dst, eCXRegI shift, eFlagsReg cr) %{ +instruct shrI_eReg_CL(rRegI dst, eCXRegI shift, eFlagsReg cr) %{ match(Set dst (URShiftI dst shift)); effect(KILL cr); @@ -8548,7 +8489,7 @@ instruct shrI_eReg_CL(eRegI dst, eCXRegI shift, eFlagsReg cr) %{ //----------Integer Logical Instructions--------------------------------------- // And Instructions // And Register with Register -instruct andI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct andI_eReg(rRegI dst, rRegI src, eFlagsReg cr) %{ match(Set dst (AndI dst src)); effect(KILL cr); @@ -8560,7 +8501,7 @@ instruct andI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ %} // And Register with Immediate -instruct andI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ +instruct andI_eReg_imm(rRegI dst, immI src, eFlagsReg cr) %{ match(Set dst (AndI dst src)); effect(KILL cr); @@ -8572,7 +8513,7 @@ instruct andI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ %} // And Register with Memory -instruct andI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ +instruct andI_eReg_mem(rRegI dst, memory src, eFlagsReg cr) %{ match(Set dst (AndI dst (LoadI src))); effect(KILL cr); @@ -8584,7 +8525,7 @@ instruct andI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ %} // And Memory with Register -instruct andI_mem_eReg(memory dst, eRegI src, eFlagsReg cr) %{ +instruct andI_mem_eReg(memory dst, rRegI src, eFlagsReg cr) %{ match(Set dst (StoreI dst (AndI (LoadI dst) src))); effect(KILL cr); @@ -8610,7 +8551,7 @@ instruct andI_mem_imm(memory dst, immI src, eFlagsReg cr) %{ // Or Instructions // Or Register with Register -instruct orI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct orI_eReg(rRegI dst, rRegI src, eFlagsReg cr) %{ match(Set dst (OrI dst src)); effect(KILL cr); @@ -8621,7 +8562,7 @@ instruct orI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ ins_pipe( ialu_reg_reg ); %} -instruct orI_eReg_castP2X(eRegI dst, eRegP src, eFlagsReg cr) %{ +instruct orI_eReg_castP2X(rRegI dst, eRegP src, eFlagsReg cr) %{ match(Set dst (OrI dst (CastP2X src))); effect(KILL cr); @@ -8634,7 +8575,7 @@ instruct orI_eReg_castP2X(eRegI dst, eRegP src, eFlagsReg cr) %{ // Or Register with Immediate -instruct orI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ +instruct orI_eReg_imm(rRegI dst, immI src, eFlagsReg cr) %{ match(Set dst (OrI dst src)); effect(KILL cr); @@ -8646,7 +8587,7 @@ instruct orI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ %} // Or Register with Memory -instruct orI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ +instruct orI_eReg_mem(rRegI dst, memory src, eFlagsReg cr) %{ match(Set dst (OrI dst (LoadI src))); effect(KILL cr); @@ -8658,7 +8599,7 @@ instruct orI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ %} // Or Memory with Register -instruct orI_mem_eReg(memory dst, eRegI src, eFlagsReg cr) %{ +instruct orI_mem_eReg(memory dst, rRegI src, eFlagsReg cr) %{ match(Set dst (StoreI dst (OrI (LoadI dst) src))); effect(KILL cr); @@ -8684,7 +8625,7 @@ instruct orI_mem_imm(memory dst, immI src, eFlagsReg cr) %{ // ROL/ROR // ROL expand -instruct rolI_eReg_imm1(eRegI dst, immI1 shift, eFlagsReg cr) %{ +instruct rolI_eReg_imm1(rRegI dst, immI1 shift, eFlagsReg cr) %{ effect(USE_DEF dst, USE shift, KILL cr); format %{ "ROL $dst, $shift" %} @@ -8693,7 +8634,7 @@ instruct rolI_eReg_imm1(eRegI dst, immI1 shift, eFlagsReg cr) %{ ins_pipe( ialu_reg ); %} -instruct rolI_eReg_imm8(eRegI dst, immI8 shift, eFlagsReg cr) %{ +instruct rolI_eReg_imm8(rRegI dst, immI8 shift, eFlagsReg cr) %{ effect(USE_DEF dst, USE shift, KILL cr); format %{ "ROL $dst, $shift" %} @@ -8713,7 +8654,7 @@ instruct rolI_eReg_CL(ncxRegI dst, eCXRegI shift, eFlagsReg cr) %{ // end of ROL expand // ROL 32bit by one once -instruct rolI_eReg_i1(eRegI dst, immI1 lshift, immI_M1 rshift, eFlagsReg cr) %{ +instruct rolI_eReg_i1(rRegI dst, immI1 lshift, immI_M1 rshift, eFlagsReg cr) %{ match(Set dst ( OrI (LShiftI dst lshift) (URShiftI dst rshift))); expand %{ @@ -8722,7 +8663,7 @@ instruct rolI_eReg_i1(eRegI dst, immI1 lshift, immI_M1 rshift, eFlagsReg cr) %{ %} // ROL 32bit var by imm8 once -instruct rolI_eReg_i8(eRegI dst, immI8 lshift, immI8 rshift, eFlagsReg cr) %{ +instruct rolI_eReg_i8(rRegI dst, immI8 lshift, immI8 rshift, eFlagsReg cr) %{ predicate( 0 == ((n->in(1)->in(2)->get_int() + n->in(2)->in(2)->get_int()) & 0x1f)); match(Set dst ( OrI (LShiftI dst lshift) (URShiftI dst rshift))); @@ -8750,7 +8691,7 @@ instruct rolI_eReg_Var_C32(ncxRegI dst, eCXRegI shift, immI_32 c32, eFlagsReg cr %} // ROR expand -instruct rorI_eReg_imm1(eRegI dst, immI1 shift, eFlagsReg cr) %{ +instruct rorI_eReg_imm1(rRegI dst, immI1 shift, eFlagsReg cr) %{ effect(USE_DEF dst, USE shift, KILL cr); format %{ "ROR $dst, $shift" %} @@ -8759,7 +8700,7 @@ instruct rorI_eReg_imm1(eRegI dst, immI1 shift, eFlagsReg cr) %{ ins_pipe( ialu_reg ); %} -instruct rorI_eReg_imm8(eRegI dst, immI8 shift, eFlagsReg cr) %{ +instruct rorI_eReg_imm8(rRegI dst, immI8 shift, eFlagsReg cr) %{ effect (USE_DEF dst, USE shift, KILL cr); format %{ "ROR $dst, $shift" %} @@ -8779,7 +8720,7 @@ instruct rorI_eReg_CL(ncxRegI dst, eCXRegI shift, eFlagsReg cr)%{ // end of ROR expand // ROR right once -instruct rorI_eReg_i1(eRegI dst, immI1 rshift, immI_M1 lshift, eFlagsReg cr) %{ +instruct rorI_eReg_i1(rRegI dst, immI1 rshift, immI_M1 lshift, eFlagsReg cr) %{ match(Set dst ( OrI (URShiftI dst rshift) (LShiftI dst lshift))); expand %{ @@ -8788,7 +8729,7 @@ instruct rorI_eReg_i1(eRegI dst, immI1 rshift, immI_M1 lshift, eFlagsReg cr) %{ %} // ROR 32bit by immI8 once -instruct rorI_eReg_i8(eRegI dst, immI8 rshift, immI8 lshift, eFlagsReg cr) %{ +instruct rorI_eReg_i8(rRegI dst, immI8 rshift, immI8 lshift, eFlagsReg cr) %{ predicate( 0 == ((n->in(1)->in(2)->get_int() + n->in(2)->in(2)->get_int()) & 0x1f)); match(Set dst ( OrI (URShiftI dst rshift) (LShiftI dst lshift))); @@ -8817,7 +8758,7 @@ instruct rorI_eReg_Var_C32(ncxRegI dst, eCXRegI shift, immI_32 c32, eFlagsReg cr // Xor Instructions // Xor Register with Register -instruct xorI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ +instruct xorI_eReg(rRegI dst, rRegI src, eFlagsReg cr) %{ match(Set dst (XorI dst src)); effect(KILL cr); @@ -8829,7 +8770,7 @@ instruct xorI_eReg(eRegI dst, eRegI src, eFlagsReg cr) %{ %} // Xor Register with Immediate -1 -instruct xorI_eReg_im1(eRegI dst, immI_M1 imm) %{ +instruct xorI_eReg_im1(rRegI dst, immI_M1 imm) %{ match(Set dst (XorI dst imm)); size(2); @@ -8841,7 +8782,7 @@ instruct xorI_eReg_im1(eRegI dst, immI_M1 imm) %{ %} // Xor Register with Immediate -instruct xorI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ +instruct xorI_eReg_imm(rRegI dst, immI src, eFlagsReg cr) %{ match(Set dst (XorI dst src)); effect(KILL cr); @@ -8853,7 +8794,7 @@ instruct xorI_eReg_imm(eRegI dst, immI src, eFlagsReg cr) %{ %} // Xor Register with Memory -instruct xorI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ +instruct xorI_eReg_mem(rRegI dst, memory src, eFlagsReg cr) %{ match(Set dst (XorI dst (LoadI src))); effect(KILL cr); @@ -8865,7 +8806,7 @@ instruct xorI_eReg_mem(eRegI dst, memory src, eFlagsReg cr) %{ %} // Xor Memory with Register -instruct xorI_mem_eReg(memory dst, eRegI src, eFlagsReg cr) %{ +instruct xorI_mem_eReg(memory dst, rRegI src, eFlagsReg cr) %{ match(Set dst (StoreI dst (XorI (LoadI dst) src))); effect(KILL cr); @@ -8890,14 +8831,14 @@ instruct xorI_mem_imm(memory dst, immI src, eFlagsReg cr) %{ //----------Convert Int to Boolean--------------------------------------------- -instruct movI_nocopy(eRegI dst, eRegI src) %{ +instruct movI_nocopy(rRegI dst, rRegI src) %{ effect( DEF dst, USE src ); format %{ "MOV $dst,$src" %} ins_encode( enc_Copy( dst, src) ); ins_pipe( ialu_reg_reg ); %} -instruct ci2b( eRegI dst, eRegI src, eFlagsReg cr ) %{ +instruct ci2b( rRegI dst, rRegI src, eFlagsReg cr ) %{ effect( USE_DEF dst, USE src, KILL cr ); size(4); @@ -8908,7 +8849,7 @@ instruct ci2b( eRegI dst, eRegI src, eFlagsReg cr ) %{ ins_pipe( ialu_reg_reg_long ); %} -instruct convI2B( eRegI dst, eRegI src, eFlagsReg cr ) %{ +instruct convI2B( rRegI dst, rRegI src, eFlagsReg cr ) %{ match(Set dst (Conv2B src)); expand %{ @@ -8917,14 +8858,14 @@ instruct convI2B( eRegI dst, eRegI src, eFlagsReg cr ) %{ %} %} -instruct movP_nocopy(eRegI dst, eRegP src) %{ +instruct movP_nocopy(rRegI dst, eRegP src) %{ effect( DEF dst, USE src ); format %{ "MOV $dst,$src" %} ins_encode( enc_Copy( dst, src) ); ins_pipe( ialu_reg_reg ); %} -instruct cp2b( eRegI dst, eRegP src, eFlagsReg cr ) %{ +instruct cp2b( rRegI dst, eRegP src, eFlagsReg cr ) %{ effect( USE_DEF dst, USE src, KILL cr ); format %{ "NEG $dst\n\t" "ADC $dst,$src" %} @@ -8933,7 +8874,7 @@ instruct cp2b( eRegI dst, eRegP src, eFlagsReg cr ) %{ ins_pipe( ialu_reg_reg_long ); %} -instruct convP2B( eRegI dst, eRegP src, eFlagsReg cr ) %{ +instruct convP2B( rRegI dst, eRegP src, eFlagsReg cr ) %{ match(Set dst (Conv2B src)); expand %{ @@ -8958,7 +8899,7 @@ instruct cmpLTMask( eCXRegI dst, ncxRegI p, ncxRegI q, eFlagsReg cr ) %{ ins_pipe( pipe_slow ); %} -instruct cmpLTMask0( eRegI dst, immI0 zero, eFlagsReg cr ) %{ +instruct cmpLTMask0( rRegI dst, immI0 zero, eFlagsReg cr ) %{ match(Set dst (CmpLTMask dst zero)); effect( DEF dst, KILL cr ); ins_cost(100); @@ -9430,7 +9371,7 @@ instruct cmpDPR_cc(eFlagsRegU cr, regDPR src1, regDPR src2, eAXRegI rax) %{ %} // Compare vs zero into -1,0,1 -instruct cmpDPR_0(eRegI dst, regDPR src1, immDPR0 zero, eAXRegI rax, eFlagsReg cr) %{ +instruct cmpDPR_0(rRegI dst, regDPR src1, immDPR0 zero, eAXRegI rax, eFlagsReg cr) %{ predicate(UseSSE<=1); match(Set dst (CmpD3 src1 zero)); effect(KILL cr, KILL rax); @@ -9444,7 +9385,7 @@ instruct cmpDPR_0(eRegI dst, regDPR src1, immDPR0 zero, eAXRegI rax, eFlagsReg c %} // Compare into -1,0,1 -instruct cmpDPR_reg(eRegI dst, regDPR src1, regDPR src2, eAXRegI rax, eFlagsReg cr) %{ +instruct cmpDPR_reg(rRegI dst, regDPR src1, regDPR src2, eAXRegI rax, eFlagsReg cr) %{ predicate(UseSSE<=1); match(Set dst (CmpD3 src1 src2)); effect(KILL cr, KILL rax); @@ -10222,7 +10163,7 @@ instruct cmpFPR_cc(eFlagsRegU cr, regFPR src1, regFPR src2, eAXRegI rax) %{ %} // Compare vs zero into -1,0,1 -instruct cmpFPR_0(eRegI dst, regFPR src1, immFPR0 zero, eAXRegI rax, eFlagsReg cr) %{ +instruct cmpFPR_0(rRegI dst, regFPR src1, immFPR0 zero, eAXRegI rax, eFlagsReg cr) %{ predicate(UseSSE == 0); match(Set dst (CmpF3 src1 zero)); effect(KILL cr, KILL rax); @@ -10236,7 +10177,7 @@ instruct cmpFPR_0(eRegI dst, regFPR src1, immFPR0 zero, eAXRegI rax, eFlagsReg c %} // Compare into -1,0,1 -instruct cmpFPR_reg(eRegI dst, regFPR src1, regFPR src2, eAXRegI rax, eFlagsReg cr) %{ +instruct cmpFPR_reg(rRegI dst, regFPR src1, regFPR src2, eAXRegI rax, eFlagsReg cr) %{ predicate(UseSSE == 0); match(Set dst (CmpF3 src1 src2)); effect(KILL cr, KILL rax); @@ -11156,7 +11097,7 @@ instruct convI2DPR_reg(regDPR dst, stackSlotI src) %{ ins_pipe( fpu_reg_mem ); %} -instruct convI2D_reg(regD dst, eRegI src) %{ +instruct convI2D_reg(regD dst, rRegI src) %{ predicate( UseSSE>=2 && !UseXmmI2D ); match(Set dst (ConvI2D src)); format %{ "CVTSI2SD $dst,$src" %} @@ -11176,7 +11117,7 @@ instruct convI2D_mem(regD dst, memory mem) %{ ins_pipe( pipe_slow ); %} -instruct convXI2D_reg(regD dst, eRegI src) +instruct convXI2D_reg(regD dst, rRegI src) %{ predicate( UseSSE>=2 && UseXmmI2D ); match(Set dst (ConvI2D src)); @@ -11264,7 +11205,7 @@ instruct convI2FPR_mem(regFPR dst, memory mem) %{ %} // Convert an int to a float in xmm; no rounding step needed. -instruct convI2F_reg(regF dst, eRegI src) %{ +instruct convI2F_reg(regF dst, rRegI src) %{ predicate( UseSSE==1 || UseSSE>=2 && !UseXmmI2F ); match(Set dst (ConvI2F src)); format %{ "CVTSI2SS $dst, $src" %} @@ -11274,7 +11215,7 @@ instruct convI2F_reg(regF dst, eRegI src) %{ ins_pipe( pipe_slow ); %} - instruct convXI2F_reg(regF dst, eRegI src) + instruct convXI2F_reg(regF dst, rRegI src) %{ predicate( UseSSE>=2 && UseXmmI2F ); match(Set dst (ConvI2F src)); @@ -11288,7 +11229,7 @@ instruct convI2F_reg(regF dst, eRegI src) %{ ins_pipe(pipe_slow); // XXX %} -instruct convI2L_reg( eRegL dst, eRegI src, eFlagsReg cr) %{ +instruct convI2L_reg( eRegL dst, rRegI src, eFlagsReg cr) %{ match(Set dst (ConvI2L src)); effect(KILL cr); ins_cost(375); @@ -11300,7 +11241,7 @@ instruct convI2L_reg( eRegL dst, eRegI src, eFlagsReg cr) %{ %} // Zero-extend convert int to long -instruct convI2L_reg_zex(eRegL dst, eRegI src, immL_32bits mask, eFlagsReg flags ) %{ +instruct convI2L_reg_zex(eRegL dst, rRegI src, immL_32bits mask, eFlagsReg flags ) %{ match(Set dst (AndL (ConvI2L src) mask) ); effect( KILL flags ); ins_cost(250); @@ -11380,7 +11321,7 @@ instruct convL2FPR_reg( stackSlotF dst, eRegL src, eFlagsReg cr) %{ ins_pipe( pipe_slow ); %} -instruct convL2I_reg( eRegI dst, eRegL src ) %{ +instruct convL2I_reg( rRegI dst, eRegL src ) %{ match(Set dst (ConvL2I src)); effect( DEF dst, USE src ); format %{ "MOV $dst,$src.lo" %} @@ -11389,7 +11330,7 @@ instruct convL2I_reg( eRegI dst, eRegL src ) %{ %} -instruct MoveF2I_stack_reg(eRegI dst, stackSlotF src) %{ +instruct MoveF2I_stack_reg(rRegI dst, stackSlotF src) %{ match(Set dst (MoveF2I src)); effect( DEF dst, USE src ); ins_cost(100); @@ -11424,7 +11365,7 @@ instruct MoveF2I_reg_stack_sse(stackSlotI dst, regF src) %{ ins_pipe( pipe_slow ); %} -instruct MoveF2I_reg_reg_sse(eRegI dst, regF src) %{ +instruct MoveF2I_reg_reg_sse(rRegI dst, regF src) %{ predicate(UseSSE>=2); match(Set dst (MoveF2I src)); effect( DEF dst, USE src ); @@ -11436,7 +11377,7 @@ instruct MoveF2I_reg_reg_sse(eRegI dst, regF src) %{ ins_pipe( pipe_slow ); %} -instruct MoveI2F_reg_stack(stackSlotF dst, eRegI src) %{ +instruct MoveI2F_reg_stack(stackSlotF dst, rRegI src) %{ match(Set dst (MoveI2F src)); effect( DEF dst, USE src ); @@ -11476,7 +11417,7 @@ instruct MoveI2F_stack_reg_sse(regF dst, stackSlotI src) %{ ins_pipe( pipe_slow ); %} -instruct MoveI2F_reg_reg_sse(regF dst, eRegI src) %{ +instruct MoveI2F_reg_reg_sse(regF dst, rRegI src) %{ predicate(UseSSE>=2); match(Set dst (MoveI2F src)); effect( DEF dst, USE src ); @@ -11610,186 +11551,6 @@ instruct MoveL2D_reg_reg_sse(regD dst, eRegL src, regD tmp) %{ ins_pipe( pipe_slow ); %} -// Replicate scalar to packed byte (1 byte) values in xmm -instruct Repl8B_reg(regD dst, regD src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate8B src)); - format %{ "MOVDQA $dst,$src\n\t" - "PUNPCKLBW $dst,$dst\n\t" - "PSHUFLW $dst,$dst,0x00\t! replicate8B" %} - ins_encode %{ - if ($dst$$reg != $src$$reg) { - __ movdqa($dst$$XMMRegister, $src$$XMMRegister); - } - __ punpcklbw($dst$$XMMRegister, $dst$$XMMRegister); - __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( pipe_slow ); -%} - -// Replicate scalar to packed byte (1 byte) values in xmm -instruct Repl8B_eRegI(regD dst, eRegI src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate8B src)); - format %{ "MOVD $dst,$src\n\t" - "PUNPCKLBW $dst,$dst\n\t" - "PSHUFLW $dst,$dst,0x00\t! replicate8B" %} - ins_encode %{ - __ movdl($dst$$XMMRegister, $src$$Register); - __ punpcklbw($dst$$XMMRegister, $dst$$XMMRegister); - __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( pipe_slow ); -%} - -// Replicate scalar zero to packed byte (1 byte) values in xmm -instruct Repl8B_immI0(regD dst, immI0 zero) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate8B zero)); - format %{ "PXOR $dst,$dst\t! replicate8B" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed shore (2 byte) values in xmm -instruct Repl4S_reg(regD dst, regD src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate4S src)); - format %{ "PSHUFLW $dst,$src,0x00\t! replicate4S" %} - ins_encode %{ - __ pshuflw($dst$$XMMRegister, $src$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed shore (2 byte) values in xmm -instruct Repl4S_eRegI(regD dst, eRegI src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate4S src)); - format %{ "MOVD $dst,$src\n\t" - "PSHUFLW $dst,$dst,0x00\t! replicate4S" %} - ins_encode %{ - __ movdl($dst$$XMMRegister, $src$$Register); - __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar zero to packed short (2 byte) values in xmm -instruct Repl4S_immI0(regD dst, immI0 zero) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate4S zero)); - format %{ "PXOR $dst,$dst\t! replicate4S" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed char (2 byte) values in xmm -instruct Repl4C_reg(regD dst, regD src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate4C src)); - format %{ "PSHUFLW $dst,$src,0x00\t! replicate4C" %} - ins_encode %{ - __ pshuflw($dst$$XMMRegister, $src$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed char (2 byte) values in xmm -instruct Repl4C_eRegI(regD dst, eRegI src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate4C src)); - format %{ "MOVD $dst,$src\n\t" - "PSHUFLW $dst,$dst,0x00\t! replicate4C" %} - ins_encode %{ - __ movdl($dst$$XMMRegister, $src$$Register); - __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar zero to packed char (2 byte) values in xmm -instruct Repl4C_immI0(regD dst, immI0 zero) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate4C zero)); - format %{ "PXOR $dst,$dst\t! replicate4C" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed integer (4 byte) values in xmm -instruct Repl2I_reg(regD dst, regD src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate2I src)); - format %{ "PSHUFD $dst,$src,0x00\t! replicate2I" %} - ins_encode %{ - __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed integer (4 byte) values in xmm -instruct Repl2I_eRegI(regD dst, eRegI src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate2I src)); - format %{ "MOVD $dst,$src\n\t" - "PSHUFD $dst,$dst,0x00\t! replicate2I" %} - ins_encode %{ - __ movdl($dst$$XMMRegister, $src$$Register); - __ pshufd($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar zero to packed integer (2 byte) values in xmm -instruct Repl2I_immI0(regD dst, immI0 zero) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate2I zero)); - format %{ "PXOR $dst,$dst\t! replicate2I" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed single precision floating point values in xmm -instruct Repl2F_reg(regD dst, regD src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate2F src)); - format %{ "PSHUFD $dst,$src,0xe0\t! replicate2F" %} - ins_encode %{ - __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0xe0); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed single precision floating point values in xmm -instruct Repl2F_regF(regD dst, regF src) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate2F src)); - format %{ "PSHUFD $dst,$src,0xe0\t! replicate2F" %} - ins_encode %{ - __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0xe0); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed single precision floating point values in xmm -instruct Repl2F_immF0(regD dst, immF0 zero) %{ - predicate(UseSSE>=2); - match(Set dst (Replicate2F zero)); - format %{ "PXOR $dst,$dst\t! replicate2F" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} // ======================================================================= // fast clearing of an array @@ -11898,7 +11659,7 @@ instruct array_equals(eDIRegP ary1, eSIRegP ary2, eAXRegI result, //----------Control Flow Instructions------------------------------------------ // Signed compare Instructions -instruct compI_eReg(eFlagsReg cr, eRegI op1, eRegI op2) %{ +instruct compI_eReg(eFlagsReg cr, rRegI op1, rRegI op2) %{ match(Set cr (CmpI op1 op2)); effect( DEF cr, USE op1, USE op2 ); format %{ "CMP $op1,$op2" %} @@ -11907,7 +11668,7 @@ instruct compI_eReg(eFlagsReg cr, eRegI op1, eRegI op2) %{ ins_pipe( ialu_cr_reg_reg ); %} -instruct compI_eReg_imm(eFlagsReg cr, eRegI op1, immI op2) %{ +instruct compI_eReg_imm(eFlagsReg cr, rRegI op1, immI op2) %{ match(Set cr (CmpI op1 op2)); effect( DEF cr, USE op1 ); format %{ "CMP $op1,$op2" %} @@ -11918,7 +11679,7 @@ instruct compI_eReg_imm(eFlagsReg cr, eRegI op1, immI op2) %{ %} // Cisc-spilled version of cmpI_eReg -instruct compI_eReg_mem(eFlagsReg cr, eRegI op1, memory op2) %{ +instruct compI_eReg_mem(eFlagsReg cr, rRegI op1, memory op2) %{ match(Set cr (CmpI op1 (LoadI op2))); format %{ "CMP $op1,$op2" %} @@ -11928,7 +11689,7 @@ instruct compI_eReg_mem(eFlagsReg cr, eRegI op1, memory op2) %{ ins_pipe( ialu_cr_reg_mem ); %} -instruct testI_reg( eFlagsReg cr, eRegI src, immI0 zero ) %{ +instruct testI_reg( eFlagsReg cr, rRegI src, immI0 zero ) %{ match(Set cr (CmpI src zero)); effect( DEF cr, USE src ); @@ -11938,7 +11699,7 @@ instruct testI_reg( eFlagsReg cr, eRegI src, immI0 zero ) %{ ins_pipe( ialu_cr_reg_imm ); %} -instruct testI_reg_imm( eFlagsReg cr, eRegI src, immI con, immI0 zero ) %{ +instruct testI_reg_imm( eFlagsReg cr, rRegI src, immI con, immI0 zero ) %{ match(Set cr (CmpI (AndI src con) zero)); format %{ "TEST $src,$con" %} @@ -11947,7 +11708,7 @@ instruct testI_reg_imm( eFlagsReg cr, eRegI src, immI con, immI0 zero ) %{ ins_pipe( ialu_cr_reg_imm ); %} -instruct testI_reg_mem( eFlagsReg cr, eRegI src, memory mem, immI0 zero ) %{ +instruct testI_reg_mem( eFlagsReg cr, rRegI src, memory mem, immI0 zero ) %{ match(Set cr (CmpI (AndI src mem) zero)); format %{ "TEST $src,$mem" %} @@ -11958,7 +11719,7 @@ instruct testI_reg_mem( eFlagsReg cr, eRegI src, memory mem, immI0 zero ) %{ // Unsigned compare Instructions; really, same as signed except they // produce an eFlagsRegU instead of eFlagsReg. -instruct compU_eReg(eFlagsRegU cr, eRegI op1, eRegI op2) %{ +instruct compU_eReg(eFlagsRegU cr, rRegI op1, rRegI op2) %{ match(Set cr (CmpU op1 op2)); format %{ "CMPu $op1,$op2" %} @@ -11967,7 +11728,7 @@ instruct compU_eReg(eFlagsRegU cr, eRegI op1, eRegI op2) %{ ins_pipe( ialu_cr_reg_reg ); %} -instruct compU_eReg_imm(eFlagsRegU cr, eRegI op1, immI op2) %{ +instruct compU_eReg_imm(eFlagsRegU cr, rRegI op1, immI op2) %{ match(Set cr (CmpU op1 op2)); format %{ "CMPu $op1,$op2" %} @@ -11977,7 +11738,7 @@ instruct compU_eReg_imm(eFlagsRegU cr, eRegI op1, immI op2) %{ %} // // Cisc-spilled version of cmpU_eReg -instruct compU_eReg_mem(eFlagsRegU cr, eRegI op1, memory op2) %{ +instruct compU_eReg_mem(eFlagsRegU cr, rRegI op1, memory op2) %{ match(Set cr (CmpU op1 (LoadI op2))); format %{ "CMPu $op1,$op2" %} @@ -11988,7 +11749,7 @@ instruct compU_eReg_mem(eFlagsRegU cr, eRegI op1, memory op2) %{ %} // // Cisc-spilled version of cmpU_eReg -//instruct compU_mem_eReg(eFlagsRegU cr, memory op1, eRegI op2) %{ +//instruct compU_mem_eReg(eFlagsRegU cr, memory op1, rRegI op2) %{ // match(Set cr (CmpU (LoadI op1) op2)); // // format %{ "CMPu $op1,$op2" %} @@ -11997,7 +11758,7 @@ instruct compU_eReg_mem(eFlagsRegU cr, eRegI op1, memory op2) %{ // ins_encode( OpcP, RegMem( op1, op2) ); //%} -instruct testU_reg( eFlagsRegU cr, eRegI src, immI0 zero ) %{ +instruct testU_reg( eFlagsRegU cr, rRegI src, immI0 zero ) %{ match(Set cr (CmpU src zero)); format %{ "TESTu $src,$src" %} @@ -12093,7 +11854,7 @@ instruct testP_Reg_mem( eFlagsReg cr, memory op, immI0 zero ) %{ // *** Min and Max using the conditional move are slower than the // *** branch version on a Pentium III. // // Conditional move for min -//instruct cmovI_reg_lt( eRegI op2, eRegI op1, eFlagsReg cr ) %{ +//instruct cmovI_reg_lt( rRegI op2, rRegI op1, eFlagsReg cr ) %{ // effect( USE_DEF op2, USE op1, USE cr ); // format %{ "CMOVlt $op2,$op1\t! min" %} // opcode(0x4C,0x0F); @@ -12102,7 +11863,7 @@ instruct testP_Reg_mem( eFlagsReg cr, memory op, immI0 zero ) %{ //%} // //// Min Register with Register (P6 version) -//instruct minI_eReg_p6( eRegI op1, eRegI op2 ) %{ +//instruct minI_eReg_p6( rRegI op1, rRegI op2 ) %{ // predicate(VM_Version::supports_cmov() ); // match(Set op2 (MinI op1 op2)); // ins_cost(200); @@ -12114,7 +11875,7 @@ instruct testP_Reg_mem( eFlagsReg cr, memory op, immI0 zero ) %{ //%} // Min Register with Register (generic version) -instruct minI_eReg(eRegI dst, eRegI src, eFlagsReg flags) %{ +instruct minI_eReg(rRegI dst, rRegI src, eFlagsReg flags) %{ match(Set dst (MinI dst src)); effect(KILL flags); ins_cost(300); @@ -12129,7 +11890,7 @@ instruct minI_eReg(eRegI dst, eRegI src, eFlagsReg flags) %{ // *** Min and Max using the conditional move are slower than the // *** branch version on a Pentium III. // // Conditional move for max -//instruct cmovI_reg_gt( eRegI op2, eRegI op1, eFlagsReg cr ) %{ +//instruct cmovI_reg_gt( rRegI op2, rRegI op1, eFlagsReg cr ) %{ // effect( USE_DEF op2, USE op1, USE cr ); // format %{ "CMOVgt $op2,$op1\t! max" %} // opcode(0x4F,0x0F); @@ -12138,7 +11899,7 @@ instruct minI_eReg(eRegI dst, eRegI src, eFlagsReg flags) %{ //%} // // // Max Register with Register (P6 version) -//instruct maxI_eReg_p6( eRegI op1, eRegI op2 ) %{ +//instruct maxI_eReg_p6( rRegI op1, rRegI op2 ) %{ // predicate(VM_Version::supports_cmov() ); // match(Set op2 (MaxI op1 op2)); // ins_cost(200); @@ -12150,7 +11911,7 @@ instruct minI_eReg(eRegI dst, eRegI src, eFlagsReg flags) %{ //%} // Max Register with Register (generic version) -instruct maxI_eReg(eRegI dst, eRegI src, eFlagsReg flags) %{ +instruct maxI_eReg(rRegI dst, rRegI src, eFlagsReg flags) %{ match(Set dst (MaxI dst src)); effect(KILL flags); ins_cost(300); @@ -12211,7 +11972,7 @@ instruct loopLimit_eReg(eAXRegI limit, nadxRegI init, immI stride, eDXRegI limit // ============================================================================ // Branch Instructions // Jump Table -instruct jumpXtnd(eRegI switch_val) %{ +instruct jumpXtnd(rRegI switch_val) %{ match(Jump switch_val); ins_cost(350); format %{ "JMP [$constantaddress](,$switch_val,1)\n\t" %} @@ -12629,7 +12390,7 @@ instruct cmpL_zero_flags_LTGE( flagsReg_long_LTGE flags, eRegL src, immL0 zero ) // Manifest a CmpL result in the normal flags. Only good for LT or GE // compares. Can be used for LE or GT compares by reversing arguments. // NOT GOOD FOR EQ/NE tests. -instruct cmpL_reg_flags_LTGE( flagsReg_long_LTGE flags, eRegL src1, eRegL src2, eRegI tmp ) %{ +instruct cmpL_reg_flags_LTGE( flagsReg_long_LTGE flags, eRegL src1, eRegL src2, rRegI tmp ) %{ match( Set flags (CmpL src1 src2 )); effect( TEMP tmp ); ins_cost(300); @@ -12675,7 +12436,7 @@ instruct cmovLL_mem_LTGE(cmpOp cmp, flagsReg_long_LTGE flags, eRegL dst, load_lo %} // Compare 2 longs and CMOVE ints. -instruct cmovII_reg_LTGE(cmpOp cmp, flagsReg_long_LTGE flags, eRegI dst, eRegI src) %{ +instruct cmovII_reg_LTGE(cmpOp cmp, flagsReg_long_LTGE flags, rRegI dst, rRegI src) %{ predicate(VM_Version::supports_cmov() && ( _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::lt || _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::ge )); match(Set dst (CMoveI (Binary cmp flags) (Binary dst src))); ins_cost(200); @@ -12685,7 +12446,7 @@ instruct cmovII_reg_LTGE(cmpOp cmp, flagsReg_long_LTGE flags, eRegI dst, eRegI s ins_pipe( pipe_cmov_reg ); %} -instruct cmovII_mem_LTGE(cmpOp cmp, flagsReg_long_LTGE flags, eRegI dst, memory src) %{ +instruct cmovII_mem_LTGE(cmpOp cmp, flagsReg_long_LTGE flags, rRegI dst, memory src) %{ predicate(VM_Version::supports_cmov() && ( _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::lt || _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::ge )); match(Set dst (CMoveI (Binary cmp flags) (Binary dst (LoadI src)))); ins_cost(250); @@ -12746,7 +12507,7 @@ instruct cmovFF_reg_LTGE(cmpOp cmp, flagsReg_long_LTGE flags, regF dst, regF src //====== // Manifest a CmpL result in the normal flags. Only good for EQ/NE compares. -instruct cmpL_zero_flags_EQNE( flagsReg_long_EQNE flags, eRegL src, immL0 zero, eRegI tmp ) %{ +instruct cmpL_zero_flags_EQNE( flagsReg_long_EQNE flags, eRegL src, immL0 zero, rRegI tmp ) %{ match( Set flags (CmpL src zero )); effect(TEMP tmp); ins_cost(200); @@ -12803,7 +12564,7 @@ instruct cmovLL_mem_EQNE(cmpOp cmp, flagsReg_long_EQNE flags, eRegL dst, load_lo %} // Compare 2 longs and CMOVE ints. -instruct cmovII_reg_EQNE(cmpOp cmp, flagsReg_long_EQNE flags, eRegI dst, eRegI src) %{ +instruct cmovII_reg_EQNE(cmpOp cmp, flagsReg_long_EQNE flags, rRegI dst, rRegI src) %{ predicate(VM_Version::supports_cmov() && ( _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::eq || _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::ne )); match(Set dst (CMoveI (Binary cmp flags) (Binary dst src))); ins_cost(200); @@ -12813,7 +12574,7 @@ instruct cmovII_reg_EQNE(cmpOp cmp, flagsReg_long_EQNE flags, eRegI dst, eRegI s ins_pipe( pipe_cmov_reg ); %} -instruct cmovII_mem_EQNE(cmpOp cmp, flagsReg_long_EQNE flags, eRegI dst, memory src) %{ +instruct cmovII_mem_EQNE(cmpOp cmp, flagsReg_long_EQNE flags, rRegI dst, memory src) %{ predicate(VM_Version::supports_cmov() && ( _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::eq || _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::ne )); match(Set dst (CMoveI (Binary cmp flags) (Binary dst (LoadI src)))); ins_cost(250); @@ -12875,7 +12636,7 @@ instruct cmovFF_reg_EQNE(cmpOp cmp, flagsReg_long_EQNE flags, regF dst, regF src //====== // Manifest a CmpL result in the normal flags. Only good for LE or GT compares. // Same as cmpL_reg_flags_LEGT except must negate src -instruct cmpL_zero_flags_LEGT( flagsReg_long_LEGT flags, eRegL src, immL0 zero, eRegI tmp ) %{ +instruct cmpL_zero_flags_LEGT( flagsReg_long_LEGT flags, eRegL src, immL0 zero, rRegI tmp ) %{ match( Set flags (CmpL src zero )); effect( TEMP tmp ); ins_cost(300); @@ -12889,7 +12650,7 @@ instruct cmpL_zero_flags_LEGT( flagsReg_long_LEGT flags, eRegL src, immL0 zero, // Manifest a CmpL result in the normal flags. Only good for LE or GT compares. // Same as cmpL_reg_flags_LTGE except operands swapped. Swapping operands // requires a commuted test to get the same result. -instruct cmpL_reg_flags_LEGT( flagsReg_long_LEGT flags, eRegL src1, eRegL src2, eRegI tmp ) %{ +instruct cmpL_reg_flags_LEGT( flagsReg_long_LEGT flags, eRegL src1, eRegL src2, rRegI tmp ) %{ match( Set flags (CmpL src1 src2 )); effect( TEMP tmp ); ins_cost(300); @@ -12936,7 +12697,7 @@ instruct cmovLL_mem_LEGT(cmpOp_commute cmp, flagsReg_long_LEGT flags, eRegL dst, %} // Compare 2 longs and CMOVE ints. -instruct cmovII_reg_LEGT(cmpOp_commute cmp, flagsReg_long_LEGT flags, eRegI dst, eRegI src) %{ +instruct cmovII_reg_LEGT(cmpOp_commute cmp, flagsReg_long_LEGT flags, rRegI dst, rRegI src) %{ predicate(VM_Version::supports_cmov() && ( _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::le || _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::gt )); match(Set dst (CMoveI (Binary cmp flags) (Binary dst src))); ins_cost(200); @@ -12946,7 +12707,7 @@ instruct cmovII_reg_LEGT(cmpOp_commute cmp, flagsReg_long_LEGT flags, eRegI dst, ins_pipe( pipe_cmov_reg ); %} -instruct cmovII_mem_LEGT(cmpOp_commute cmp, flagsReg_long_LEGT flags, eRegI dst, memory src) %{ +instruct cmovII_mem_LEGT(cmpOp_commute cmp, flagsReg_long_LEGT flags, rRegI dst, memory src) %{ predicate(VM_Version::supports_cmov() && ( _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::le || _kids[0]->_kids[0]->_leaf->as_Bool()->_test._test == BoolTest::gt )); match(Set dst (CMoveI (Binary cmp flags) (Binary dst (LoadI src)))); ins_cost(250); @@ -13275,11 +13036,11 @@ instruct tlsLoadP(eRegP dst, eFlagsReg cr) %{ // ---------EXAMPLE---------------------------------------------------------- // // // pertinent parts of existing instructions in architecture description -// instruct movI(eRegI dst, eRegI src) %{ +// instruct movI(rRegI dst, rRegI src) %{ // match(Set dst (CopyI src)); // %} // -// instruct incI_eReg(eRegI dst, immI1 src, eFlagsReg cr) %{ +// instruct incI_eReg(rRegI dst, immI1 src, eFlagsReg cr) %{ // match(Set dst (AddI dst src)); // effect(KILL cr); // %} @@ -13324,11 +13085,11 @@ instruct tlsLoadP(eRegP dst, eFlagsReg cr) %{ // %} // // Change load of spilled value to only a spill -// instruct storeI(memory mem, eRegI src) %{ +// instruct storeI(memory mem, rRegI src) %{ // match(Set mem (StoreI mem src)); // %} // -// instruct loadI(eRegI dst, memory mem) %{ +// instruct loadI(rRegI dst, memory mem) %{ // match(Set dst (LoadI mem)); // %} // diff --git a/hotspot/src/cpu/x86/vm/x86_64.ad b/hotspot/src/cpu/x86/vm/x86_64.ad index 1a5e1c86c6c..68c6d354012 100644 --- a/hotspot/src/cpu/x86/vm/x86_64.ad +++ b/hotspot/src/cpu/x86/vm/x86_64.ad @@ -131,102 +131,6 @@ reg_def R15_H(SOC, SOE, Op_RegI, 15, r15->as_VMReg()->next()); // Floating Point Registers -// XMM registers. 128-bit registers or 4 words each, labeled (a)-d. -// Word a in each register holds a Float, words ab hold a Double. We -// currently do not use the SIMD capabilities, so registers cd are -// unused at the moment. -// XMM8-XMM15 must be encoded with REX. -// Linux ABI: No register preserved across function calls -// XMM0-XMM7 might hold parameters -// Windows ABI: XMM6-XMM15 preserved across function calls -// XMM0-XMM3 might hold parameters - -reg_def XMM0 (SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()); -reg_def XMM0_H (SOC, SOC, Op_RegF, 0, xmm0->as_VMReg()->next()); - -reg_def XMM1 (SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()); -reg_def XMM1_H (SOC, SOC, Op_RegF, 1, xmm1->as_VMReg()->next()); - -reg_def XMM2 (SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()); -reg_def XMM2_H (SOC, SOC, Op_RegF, 2, xmm2->as_VMReg()->next()); - -reg_def XMM3 (SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()); -reg_def XMM3_H (SOC, SOC, Op_RegF, 3, xmm3->as_VMReg()->next()); - -reg_def XMM4 (SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()); -reg_def XMM4_H (SOC, SOC, Op_RegF, 4, xmm4->as_VMReg()->next()); - -reg_def XMM5 (SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()); -reg_def XMM5_H (SOC, SOC, Op_RegF, 5, xmm5->as_VMReg()->next()); - -#ifdef _WIN64 - -reg_def XMM6 (SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()); -reg_def XMM6_H (SOC, SOE, Op_RegF, 6, xmm6->as_VMReg()->next()); - -reg_def XMM7 (SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()); -reg_def XMM7_H (SOC, SOE, Op_RegF, 7, xmm7->as_VMReg()->next()); - -reg_def XMM8 (SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()); -reg_def XMM8_H (SOC, SOE, Op_RegF, 8, xmm8->as_VMReg()->next()); - -reg_def XMM9 (SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()); -reg_def XMM9_H (SOC, SOE, Op_RegF, 9, xmm9->as_VMReg()->next()); - -reg_def XMM10 (SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()); -reg_def XMM10_H(SOC, SOE, Op_RegF, 10, xmm10->as_VMReg()->next()); - -reg_def XMM11 (SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()); -reg_def XMM11_H(SOC, SOE, Op_RegF, 11, xmm11->as_VMReg()->next()); - -reg_def XMM12 (SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()); -reg_def XMM12_H(SOC, SOE, Op_RegF, 12, xmm12->as_VMReg()->next()); - -reg_def XMM13 (SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()); -reg_def XMM13_H(SOC, SOE, Op_RegF, 13, xmm13->as_VMReg()->next()); - -reg_def XMM14 (SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()); -reg_def XMM14_H(SOC, SOE, Op_RegF, 14, xmm14->as_VMReg()->next()); - -reg_def XMM15 (SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()); -reg_def XMM15_H(SOC, SOE, Op_RegF, 15, xmm15->as_VMReg()->next()); - -#else - -reg_def XMM6 (SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()); -reg_def XMM6_H (SOC, SOC, Op_RegF, 6, xmm6->as_VMReg()->next()); - -reg_def XMM7 (SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()); -reg_def XMM7_H (SOC, SOC, Op_RegF, 7, xmm7->as_VMReg()->next()); - -reg_def XMM8 (SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()); -reg_def XMM8_H (SOC, SOC, Op_RegF, 8, xmm8->as_VMReg()->next()); - -reg_def XMM9 (SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()); -reg_def XMM9_H (SOC, SOC, Op_RegF, 9, xmm9->as_VMReg()->next()); - -reg_def XMM10 (SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()); -reg_def XMM10_H(SOC, SOC, Op_RegF, 10, xmm10->as_VMReg()->next()); - -reg_def XMM11 (SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()); -reg_def XMM11_H(SOC, SOC, Op_RegF, 11, xmm11->as_VMReg()->next()); - -reg_def XMM12 (SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()); -reg_def XMM12_H(SOC, SOC, Op_RegF, 12, xmm12->as_VMReg()->next()); - -reg_def XMM13 (SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()); -reg_def XMM13_H(SOC, SOC, Op_RegF, 13, xmm13->as_VMReg()->next()); - -reg_def XMM14 (SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()); -reg_def XMM14_H(SOC, SOC, Op_RegF, 14, xmm14->as_VMReg()->next()); - -reg_def XMM15 (SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()); -reg_def XMM15_H(SOC, SOC, Op_RegF, 15, xmm15->as_VMReg()->next()); - -#endif // _WIN64 - -reg_def RFLAGS(SOC, SOC, 0, 16, VMRegImpl::Bad()); - // Specify priority of register selection within phases of register // allocation. Highest priority is first. A useful heuristic is to // give registers a low priority when they are required by machine @@ -252,26 +156,6 @@ alloc_class chunk0(R10, R10_H, R15, R15_H, RSP, RSP_H); -// XXX probably use 8-15 first on Linux -alloc_class chunk1(XMM0, XMM0_H, - XMM1, XMM1_H, - XMM2, XMM2_H, - XMM3, XMM3_H, - XMM4, XMM4_H, - XMM5, XMM5_H, - XMM6, XMM6_H, - XMM7, XMM7_H, - XMM8, XMM8_H, - XMM9, XMM9_H, - XMM10, XMM10_H, - XMM11, XMM11_H, - XMM12, XMM12_H, - XMM13, XMM13_H, - XMM14, XMM14_H, - XMM15, XMM15_H); - -alloc_class chunk2(RFLAGS); - //----------Architecture Description Register Classes-------------------------- // Several register classes are automatically defined based upon information in @@ -501,47 +385,8 @@ reg_class int_rdi_reg(RDI); // Singleton class for instruction pointer // reg_class ip_reg(RIP); -// Singleton class for condition codes -reg_class int_flags(RFLAGS); - -// Class for all float registers -reg_class float_reg(XMM0, - XMM1, - XMM2, - XMM3, - XMM4, - XMM5, - XMM6, - XMM7, - XMM8, - XMM9, - XMM10, - XMM11, - XMM12, - XMM13, - XMM14, - XMM15); - -// Class for all double registers -reg_class double_reg(XMM0, XMM0_H, - XMM1, XMM1_H, - XMM2, XMM2_H, - XMM3, XMM3_H, - XMM4, XMM4_H, - XMM5, XMM5_H, - XMM6, XMM6_H, - XMM7, XMM7_H, - XMM8, XMM8_H, - XMM9, XMM9_H, - XMM10, XMM10_H, - XMM11, XMM11_H, - XMM12, XMM12_H, - XMM13, XMM13_H, - XMM14, XMM14_H, - XMM15, XMM15_H); %} - //----------SOURCE BLOCK------------------------------------------------------- // This is a block of C++ code which provides values, functions, and // definitions necessary in the rest of the architecture description @@ -1027,12 +872,84 @@ static enum RC rc_class(OptoReg::Name reg) return rc_float; } +// Next two methods are shared by 32- and 64-bit VM. They are defined in x86.ad. +static int vec_mov_helper(CodeBuffer *cbuf, bool do_size, int src_lo, int dst_lo, + int src_hi, int dst_hi, uint ireg, outputStream* st); + +static int vec_spill_helper(CodeBuffer *cbuf, bool do_size, bool is_load, + int stack_offset, int reg, uint ireg, outputStream* st); + +static void vec_stack_to_stack_helper(CodeBuffer *cbuf, int src_offset, + int dst_offset, uint ireg, outputStream* st) { + if (cbuf) { + MacroAssembler _masm(cbuf); + switch (ireg) { + case Op_VecS: + __ movq(Address(rsp, -8), rax); + __ movl(rax, Address(rsp, src_offset)); + __ movl(Address(rsp, dst_offset), rax); + __ movq(rax, Address(rsp, -8)); + break; + case Op_VecD: + __ pushq(Address(rsp, src_offset)); + __ popq (Address(rsp, dst_offset)); + break; + case Op_VecX: + __ pushq(Address(rsp, src_offset)); + __ popq (Address(rsp, dst_offset)); + __ pushq(Address(rsp, src_offset+8)); + __ popq (Address(rsp, dst_offset+8)); + break; + case Op_VecY: + __ vmovdqu(Address(rsp, -32), xmm0); + __ vmovdqu(xmm0, Address(rsp, src_offset)); + __ vmovdqu(Address(rsp, dst_offset), xmm0); + __ vmovdqu(xmm0, Address(rsp, -32)); + break; + default: + ShouldNotReachHere(); + } +#ifndef PRODUCT + } else { + switch (ireg) { + case Op_VecS: + st->print("movq [rsp - #8], rax\t# 32-bit mem-mem spill\n\t" + "movl rax, [rsp + #%d]\n\t" + "movl [rsp + #%d], rax\n\t" + "movq rax, [rsp - #8]", + src_offset, dst_offset); + break; + case Op_VecD: + st->print("pushq [rsp + #%d]\t# 64-bit mem-mem spill\n\t" + "popq [rsp + #%d]", + src_offset, dst_offset); + break; + case Op_VecX: + st->print("pushq [rsp + #%d]\t# 128-bit mem-mem spill\n\t" + "popq [rsp + #%d]\n\t" + "pushq [rsp + #%d]\n\t" + "popq [rsp + #%d]", + src_offset, dst_offset, src_offset+8, dst_offset+8); + break; + case Op_VecY: + st->print("vmovdqu [rsp - #32], xmm0\t# 256-bit mem-mem spill\n\t" + "vmovdqu xmm0, [rsp + #%d]\n\t" + "vmovdqu [rsp + #%d], xmm0\n\t" + "vmovdqu xmm0, [rsp - #32]", + src_offset, dst_offset); + break; + default: + ShouldNotReachHere(); + } +#endif + } +} + uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, PhaseRegAlloc* ra_, bool do_size, - outputStream* st) const -{ - + outputStream* st) const { + assert(cbuf != NULL || st != NULL, "sanity"); // Get registers to move OptoReg::Name src_second = ra_->get_reg_second(in(1)); OptoReg::Name src_first = ra_->get_reg_first(in(1)); @@ -1050,7 +967,30 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, if (src_first == dst_first && src_second == dst_second) { // Self copy, no move return 0; - } else if (src_first_rc == rc_stack) { + } + if (bottom_type()->isa_vect() != NULL) { + uint ireg = ideal_reg(); + assert((src_first_rc != rc_int && dst_first_rc != rc_int), "sanity"); + assert((ireg == Op_VecS || ireg == Op_VecD || ireg == Op_VecX || ireg == Op_VecY), "sanity"); + if( src_first_rc == rc_stack && dst_first_rc == rc_stack ) { + // mem -> mem + int src_offset = ra_->reg2offset(src_first); + int dst_offset = ra_->reg2offset(dst_first); + vec_stack_to_stack_helper(cbuf, src_offset, dst_offset, ireg, st); + } else if (src_first_rc == rc_float && dst_first_rc == rc_float ) { + vec_mov_helper(cbuf, false, src_first, dst_first, src_second, dst_second, ireg, st); + } else if (src_first_rc == rc_float && dst_first_rc == rc_stack ) { + int stack_offset = ra_->reg2offset(dst_first); + vec_spill_helper(cbuf, false, false, stack_offset, src_first, ireg, st); + } else if (src_first_rc == rc_stack && dst_first_rc == rc_float ) { + int stack_offset = ra_->reg2offset(src_first); + vec_spill_helper(cbuf, false, true, stack_offset, dst_first, ireg, st); + } else { + ShouldNotReachHere(); + } + return 0; + } + if (src_first_rc == rc_stack) { // mem -> if (dst_first_rc == rc_stack) { // mem -> mem @@ -1061,23 +1001,16 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, int src_offset = ra_->reg2offset(src_first); int dst_offset = ra_->reg2offset(dst_first); if (cbuf) { - emit_opcode(*cbuf, 0xFF); - encode_RegMem(*cbuf, RSI_enc, RSP_enc, 0x4, 0, src_offset, false); - - emit_opcode(*cbuf, 0x8F); - encode_RegMem(*cbuf, RAX_enc, RSP_enc, 0x4, 0, dst_offset, false); - + MacroAssembler _masm(cbuf); + __ pushq(Address(rsp, src_offset)); + __ popq (Address(rsp, dst_offset)); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("pushq [rsp + #%d]\t# 64-bit mem-mem spill\n\t" - "popq [rsp + #%d]", - src_offset, - dst_offset); + "popq [rsp + #%d]", + src_offset, dst_offset); #endif } - return - 3 + ((src_offset == 0) ? 0 : (src_offset < 0x80 ? 1 : 4)) + - 3 + ((dst_offset == 0) ? 0 : (dst_offset < 0x80 ? 1 : 4)); } else { // 32-bit assert(!((src_first & 1) == 0 && src_first + 1 == src_second), "no transform"); @@ -1086,46 +1019,22 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, int src_offset = ra_->reg2offset(src_first); int dst_offset = ra_->reg2offset(dst_first); if (cbuf) { - emit_opcode(*cbuf, Assembler::REX_W); - emit_opcode(*cbuf, 0x89); - emit_opcode(*cbuf, 0x44); - emit_opcode(*cbuf, 0x24); - emit_opcode(*cbuf, 0xF8); - - emit_opcode(*cbuf, 0x8B); - encode_RegMem(*cbuf, - RAX_enc, - RSP_enc, 0x4, 0, src_offset, - false); - - emit_opcode(*cbuf, 0x89); - encode_RegMem(*cbuf, - RAX_enc, - RSP_enc, 0x4, 0, dst_offset, - false); - - emit_opcode(*cbuf, Assembler::REX_W); - emit_opcode(*cbuf, 0x8B); - emit_opcode(*cbuf, 0x44); - emit_opcode(*cbuf, 0x24); - emit_opcode(*cbuf, 0xF8); - + MacroAssembler _masm(cbuf); + __ movq(Address(rsp, -8), rax); + __ movl(rax, Address(rsp, src_offset)); + __ movl(Address(rsp, dst_offset), rax); + __ movq(rax, Address(rsp, -8)); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movq [rsp - #8], rax\t# 32-bit mem-mem spill\n\t" - "movl rax, [rsp + #%d]\n\t" - "movl [rsp + #%d], rax\n\t" - "movq rax, [rsp - #8]", - src_offset, - dst_offset); + "movl rax, [rsp + #%d]\n\t" + "movl [rsp + #%d], rax\n\t" + "movq rax, [rsp - #8]", + src_offset, dst_offset); #endif } - return - 5 + // movq - 3 + ((src_offset == 0) ? 0 : (src_offset < 0x80 ? 1 : 4)) + // movl - 3 + ((dst_offset == 0) ? 0 : (dst_offset < 0x80 ? 1 : 4)) + // movl - 5; // movq } + return 0; } else if (dst_first_rc == rc_int) { // mem -> gpr if ((src_first & 1) == 0 && src_first + 1 == src_second && @@ -1133,52 +1042,32 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, // 64-bit int offset = ra_->reg2offset(src_first); if (cbuf) { - if (Matcher::_regEncode[dst_first] < 8) { - emit_opcode(*cbuf, Assembler::REX_W); - } else { - emit_opcode(*cbuf, Assembler::REX_WR); - } - emit_opcode(*cbuf, 0x8B); - encode_RegMem(*cbuf, - Matcher::_regEncode[dst_first], - RSP_enc, 0x4, 0, offset, - false); + MacroAssembler _masm(cbuf); + __ movq(as_Register(Matcher::_regEncode[dst_first]), Address(rsp, offset)); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movq %s, [rsp + #%d]\t# spill", Matcher::regName[dst_first], offset); #endif } - return - ((offset == 0) ? 0 : (offset < 0x80 ? 1 : 4)) + 4; // REX } else { // 32-bit assert(!((src_first & 1) == 0 && src_first + 1 == src_second), "no transform"); assert(!((dst_first & 1) == 0 && dst_first + 1 == dst_second), "no transform"); int offset = ra_->reg2offset(src_first); if (cbuf) { - if (Matcher::_regEncode[dst_first] >= 8) { - emit_opcode(*cbuf, Assembler::REX_R); - } - emit_opcode(*cbuf, 0x8B); - encode_RegMem(*cbuf, - Matcher::_regEncode[dst_first], - RSP_enc, 0x4, 0, offset, - false); + MacroAssembler _masm(cbuf); + __ movl(as_Register(Matcher::_regEncode[dst_first]), Address(rsp, offset)); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movl %s, [rsp + #%d]\t# spill", Matcher::regName[dst_first], offset); #endif } - return - ((offset == 0) ? 0 : (offset < 0x80 ? 1 : 4)) + - ((Matcher::_regEncode[dst_first] < 8) - ? 3 - : 4); // REX } + return 0; } else if (dst_first_rc == rc_float) { // mem-> xmm if ((src_first & 1) == 0 && src_first + 1 == src_second && @@ -1189,18 +1078,13 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movdbl( as_XMMRegister(Matcher::_regEncode[dst_first]), Address(rsp, offset)); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("%s %s, [rsp + #%d]\t# spill", UseXmmLoadAndClearUpper ? "movsd " : "movlpd", Matcher::regName[dst_first], offset); #endif } - return - ((offset == 0) ? 0 : (offset < 0x80 ? 1 : 4)) + - ((Matcher::_regEncode[dst_first] >= 8) - ? 6 - : (5 + ((UseAVX>0)?1:0))); // REX } else { // 32-bit assert(!((src_first & 1) == 0 && src_first + 1 == src_second), "no transform"); @@ -1210,18 +1094,14 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movflt( as_XMMRegister(Matcher::_regEncode[dst_first]), Address(rsp, offset)); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movss %s, [rsp + #%d]\t# spill", Matcher::regName[dst_first], offset); #endif } - return - ((offset == 0) ? 0 : (offset < 0x80 ? 1 : 4)) + - ((Matcher::_regEncode[dst_first] >= 8) - ? 6 - : (5 + ((UseAVX>0)?1:0))); // REX } + return 0; } } else if (src_first_rc == rc_int) { // gpr -> @@ -1232,113 +1112,65 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, // 64-bit int offset = ra_->reg2offset(dst_first); if (cbuf) { - if (Matcher::_regEncode[src_first] < 8) { - emit_opcode(*cbuf, Assembler::REX_W); - } else { - emit_opcode(*cbuf, Assembler::REX_WR); - } - emit_opcode(*cbuf, 0x89); - encode_RegMem(*cbuf, - Matcher::_regEncode[src_first], - RSP_enc, 0x4, 0, offset, - false); + MacroAssembler _masm(cbuf); + __ movq(Address(rsp, offset), as_Register(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movq [rsp + #%d], %s\t# spill", offset, Matcher::regName[src_first]); #endif } - return ((offset == 0) ? 0 : (offset < 0x80 ? 1 : 4)) + 4; // REX } else { // 32-bit assert(!((src_first & 1) == 0 && src_first + 1 == src_second), "no transform"); assert(!((dst_first & 1) == 0 && dst_first + 1 == dst_second), "no transform"); int offset = ra_->reg2offset(dst_first); if (cbuf) { - if (Matcher::_regEncode[src_first] >= 8) { - emit_opcode(*cbuf, Assembler::REX_R); - } - emit_opcode(*cbuf, 0x89); - encode_RegMem(*cbuf, - Matcher::_regEncode[src_first], - RSP_enc, 0x4, 0, offset, - false); + MacroAssembler _masm(cbuf); + __ movl(Address(rsp, offset), as_Register(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movl [rsp + #%d], %s\t# spill", offset, Matcher::regName[src_first]); #endif } - return - ((offset == 0) ? 0 : (offset < 0x80 ? 1 : 4)) + - ((Matcher::_regEncode[src_first] < 8) - ? 3 - : 4); // REX } + return 0; } else if (dst_first_rc == rc_int) { // gpr -> gpr if ((src_first & 1) == 0 && src_first + 1 == src_second && (dst_first & 1) == 0 && dst_first + 1 == dst_second) { // 64-bit if (cbuf) { - if (Matcher::_regEncode[dst_first] < 8) { - if (Matcher::_regEncode[src_first] < 8) { - emit_opcode(*cbuf, Assembler::REX_W); - } else { - emit_opcode(*cbuf, Assembler::REX_WB); - } - } else { - if (Matcher::_regEncode[src_first] < 8) { - emit_opcode(*cbuf, Assembler::REX_WR); - } else { - emit_opcode(*cbuf, Assembler::REX_WRB); - } - } - emit_opcode(*cbuf, 0x8B); - emit_rm(*cbuf, 0x3, - Matcher::_regEncode[dst_first] & 7, - Matcher::_regEncode[src_first] & 7); + MacroAssembler _masm(cbuf); + __ movq(as_Register(Matcher::_regEncode[dst_first]), + as_Register(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movq %s, %s\t# spill", Matcher::regName[dst_first], Matcher::regName[src_first]); #endif } - return 3; // REX + return 0; } else { // 32-bit assert(!((src_first & 1) == 0 && src_first + 1 == src_second), "no transform"); assert(!((dst_first & 1) == 0 && dst_first + 1 == dst_second), "no transform"); if (cbuf) { - if (Matcher::_regEncode[dst_first] < 8) { - if (Matcher::_regEncode[src_first] >= 8) { - emit_opcode(*cbuf, Assembler::REX_B); - } - } else { - if (Matcher::_regEncode[src_first] < 8) { - emit_opcode(*cbuf, Assembler::REX_R); - } else { - emit_opcode(*cbuf, Assembler::REX_RB); - } - } - emit_opcode(*cbuf, 0x8B); - emit_rm(*cbuf, 0x3, - Matcher::_regEncode[dst_first] & 7, - Matcher::_regEncode[src_first] & 7); + MacroAssembler _masm(cbuf); + __ movl(as_Register(Matcher::_regEncode[dst_first]), + as_Register(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movl %s, %s\t# spill", Matcher::regName[dst_first], Matcher::regName[src_first]); #endif } - return - (Matcher::_regEncode[src_first] < 8 && Matcher::_regEncode[dst_first] < 8) - ? 2 - : 3; // REX + return 0; } } else if (dst_first_rc == rc_float) { // gpr -> xmm @@ -1349,13 +1181,12 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movdq( as_XMMRegister(Matcher::_regEncode[dst_first]), as_Register(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movdq %s, %s\t# spill", Matcher::regName[dst_first], Matcher::regName[src_first]); #endif } - return 5; // REX } else { // 32-bit assert(!((src_first & 1) == 0 && src_first + 1 == src_second), "no transform"); @@ -1364,17 +1195,14 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movdl( as_XMMRegister(Matcher::_regEncode[dst_first]), as_Register(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movdl %s, %s\t# spill", Matcher::regName[dst_first], Matcher::regName[src_first]); #endif } - return - (Matcher::_regEncode[src_first] >= 8 || Matcher::_regEncode[dst_first] >= 8) - ? 5 - : (4 + ((UseAVX>0)?1:0)); // REX } + return 0; } } else if (src_first_rc == rc_float) { // xmm -> @@ -1388,17 +1216,12 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movdbl( Address(rsp, offset), as_XMMRegister(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movsd [rsp + #%d], %s\t# spill", offset, Matcher::regName[src_first]); #endif } - return - ((offset == 0) ? 0 : (offset < 0x80 ? 1 : 4)) + - ((Matcher::_regEncode[src_first] >= 8) - ? 6 - : (5 + ((UseAVX>0)?1:0))); // REX } else { // 32-bit assert(!((src_first & 1) == 0 && src_first + 1 == src_second), "no transform"); @@ -1408,18 +1231,14 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movflt(Address(rsp, offset), as_XMMRegister(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movss [rsp + #%d], %s\t# spill", offset, Matcher::regName[src_first]); #endif } - return - ((offset == 0) ? 0 : (offset < 0x80 ? 1 : 4)) + - ((Matcher::_regEncode[src_first] >=8) - ? 6 - : (5 + ((UseAVX>0)?1:0))); // REX } + return 0; } else if (dst_first_rc == rc_int) { // xmm -> gpr if ((src_first & 1) == 0 && src_first + 1 == src_second && @@ -1429,13 +1248,12 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movdq( as_Register(Matcher::_regEncode[dst_first]), as_XMMRegister(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movdq %s, %s\t# spill", Matcher::regName[dst_first], Matcher::regName[src_first]); #endif } - return 5; // REX } else { // 32-bit assert(!((src_first & 1) == 0 && src_first + 1 == src_second), "no transform"); @@ -1444,17 +1262,14 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movdl( as_Register(Matcher::_regEncode[dst_first]), as_XMMRegister(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("movdl %s, %s\t# spill", Matcher::regName[dst_first], Matcher::regName[src_first]); #endif } - return - (Matcher::_regEncode[src_first] >= 8 || Matcher::_regEncode[dst_first] >= 8) - ? 5 - : (4 + ((UseAVX>0)?1:0)); // REX } + return 0; } else if (dst_first_rc == rc_float) { // xmm -> xmm if ((src_first & 1) == 0 && src_first + 1 == src_second && @@ -1464,17 +1279,13 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movdbl( as_XMMRegister(Matcher::_regEncode[dst_first]), as_XMMRegister(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("%s %s, %s\t# spill", UseXmmRegToRegMoveAll ? "movapd" : "movsd ", Matcher::regName[dst_first], Matcher::regName[src_first]); #endif } - return - (Matcher::_regEncode[src_first] >= 8 || Matcher::_regEncode[dst_first] >= 8) - ? 5 - : (4 + ((UseAVX>0)?1:0)); // REX } else { // 32-bit assert(!((src_first & 1) == 0 && src_first + 1 == src_second), "no transform"); @@ -1483,42 +1294,35 @@ uint MachSpillCopyNode::implementation(CodeBuffer* cbuf, MacroAssembler _masm(cbuf); __ movflt( as_XMMRegister(Matcher::_regEncode[dst_first]), as_XMMRegister(Matcher::_regEncode[src_first])); #ifndef PRODUCT - } else if (!do_size) { + } else { st->print("%s %s, %s\t# spill", UseXmmRegToRegMoveAll ? "movaps" : "movss ", Matcher::regName[dst_first], Matcher::regName[src_first]); #endif } - return ((UseAVX>0) ? 5: - ((Matcher::_regEncode[src_first] >= 8 || Matcher::_regEncode[dst_first] >= 8) - ? (UseXmmRegToRegMoveAll ? 4 : 5) - : (UseXmmRegToRegMoveAll ? 3 : 4))); // REX } + return 0; } } assert(0," foo "); Unimplemented(); - return 0; } #ifndef PRODUCT -void MachSpillCopyNode::format(PhaseRegAlloc *ra_, outputStream* st) const -{ +void MachSpillCopyNode::format(PhaseRegAlloc *ra_, outputStream* st) const { implementation(NULL, ra_, false, st); } #endif -void MachSpillCopyNode::emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const -{ +void MachSpillCopyNode::emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const { implementation(&cbuf, ra_, false, NULL); } -uint MachSpillCopyNode::size(PhaseRegAlloc *ra_) const -{ - return implementation(NULL, ra_, true, NULL); +uint MachSpillCopyNode::size(PhaseRegAlloc *ra_) const { + return MachNode::size(ra_); } //============================================================================= @@ -1735,16 +1539,6 @@ const bool Matcher::convL2FSupported(void) { return true; } -// Vector width in bytes -const uint Matcher::vector_width_in_bytes(void) { - return 8; -} - -// Vector ideal reg -const uint Matcher::vector_ideal_reg(void) { - return Op_RegD; -} - // Is this branch offset short enough that a short branch can be used? // // NOTE: If the platform does not provide any short branch variants, then @@ -1831,21 +1625,21 @@ const bool Matcher::int_in_long = true; bool Matcher::can_be_java_arg(int reg) { return - reg == RDI_num || reg == RDI_H_num || - reg == RSI_num || reg == RSI_H_num || - reg == RDX_num || reg == RDX_H_num || - reg == RCX_num || reg == RCX_H_num || - reg == R8_num || reg == R8_H_num || - reg == R9_num || reg == R9_H_num || - reg == R12_num || reg == R12_H_num || - reg == XMM0_num || reg == XMM0_H_num || - reg == XMM1_num || reg == XMM1_H_num || - reg == XMM2_num || reg == XMM2_H_num || - reg == XMM3_num || reg == XMM3_H_num || - reg == XMM4_num || reg == XMM4_H_num || - reg == XMM5_num || reg == XMM5_H_num || - reg == XMM6_num || reg == XMM6_H_num || - reg == XMM7_num || reg == XMM7_H_num; + reg == RDI_num || reg == RDI_H_num || + reg == RSI_num || reg == RSI_H_num || + reg == RDX_num || reg == RDX_H_num || + reg == RCX_num || reg == RCX_H_num || + reg == R8_num || reg == R8_H_num || + reg == R9_num || reg == R9_H_num || + reg == R12_num || reg == R12_H_num || + reg == XMM0_num || reg == XMM0b_num || + reg == XMM1_num || reg == XMM1b_num || + reg == XMM2_num || reg == XMM2b_num || + reg == XMM3_num || reg == XMM3b_num || + reg == XMM4_num || reg == XMM4b_num || + reg == XMM5_num || reg == XMM5b_num || + reg == XMM6_num || reg == XMM6b_num || + reg == XMM7_num || reg == XMM7b_num; } bool Matcher::is_spillable_arg(int reg) @@ -3220,10 +3014,11 @@ frame OptoReg::Bad, // Op_RegI RAX_H_num, // Op_RegP OptoReg::Bad, // Op_RegF - XMM0_H_num, // Op_RegD + XMM0b_num, // Op_RegD RAX_H_num // Op_RegL }; - assert(ARRAY_SIZE(hi) == _last_machine_leaf - 1, "missing type"); + // Excluded flags and vector registers. + assert(ARRAY_SIZE(hi) == _last_machine_leaf - 5, "missing type"); return OptoRegPair(hi[ideal_reg], lo[ideal_reg]); %} %} @@ -3985,7 +3780,6 @@ operand regD() interface(REG_INTER); %} - //----------Memory Operands---------------------------------------------------- // Direct Memory Operand // operand direct(immP addr) @@ -5416,61 +5210,6 @@ instruct loadD(regD dst, memory mem) ins_pipe(pipe_slow); // XXX %} -// Load Aligned Packed Byte to XMM register -instruct loadA8B(regD dst, memory mem) %{ - match(Set dst (Load8B mem)); - ins_cost(125); - format %{ "MOVQ $dst,$mem\t! packed8B" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - -// Load Aligned Packed Short to XMM register -instruct loadA4S(regD dst, memory mem) %{ - match(Set dst (Load4S mem)); - ins_cost(125); - format %{ "MOVQ $dst,$mem\t! packed4S" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - -// Load Aligned Packed Char to XMM register -instruct loadA4C(regD dst, memory mem) %{ - match(Set dst (Load4C mem)); - ins_cost(125); - format %{ "MOVQ $dst,$mem\t! packed4C" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - -// Load Aligned Packed Integer to XMM register -instruct load2IU(regD dst, memory mem) %{ - match(Set dst (Load2I mem)); - ins_cost(125); - format %{ "MOVQ $dst,$mem\t! packed2I" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - -// Load Aligned Packed Single to XMM -instruct loadA2F(regD dst, memory mem) %{ - match(Set dst (Load2F mem)); - ins_cost(125); - format %{ "MOVQ $dst,$mem\t! packed2F" %} - ins_encode %{ - __ movq($dst$$XMMRegister, $mem$$Address); - %} - ins_pipe( pipe_slow ); -%} - // Load Effective Address instruct leaP8(rRegP dst, indOffset8 mem) %{ @@ -6200,39 +5939,6 @@ instruct storeImmB(memory mem, immI8 src) ins_pipe(ialu_mem_imm); %} -// Store Aligned Packed Byte XMM register to memory -instruct storeA8B(memory mem, regD src) %{ - match(Set mem (Store8B mem src)); - ins_cost(145); - format %{ "MOVQ $mem,$src\t! packed8B" %} - ins_encode %{ - __ movq($mem$$Address, $src$$XMMRegister); - %} - ins_pipe( pipe_slow ); -%} - -// Store Aligned Packed Char/Short XMM register to memory -instruct storeA4C(memory mem, regD src) %{ - match(Set mem (Store4C mem src)); - ins_cost(145); - format %{ "MOVQ $mem,$src\t! packed4C" %} - ins_encode %{ - __ movq($mem$$Address, $src$$XMMRegister); - %} - ins_pipe( pipe_slow ); -%} - -// Store Aligned Packed Integer XMM register to memory -instruct storeA2I(memory mem, regD src) %{ - match(Set mem (Store2I mem src)); - ins_cost(145); - format %{ "MOVQ $mem,$src\t! packed2I" %} - ins_encode %{ - __ movq($mem$$Address, $src$$XMMRegister); - %} - ins_pipe( pipe_slow ); -%} - // Store CMS card-mark Immediate instruct storeImmCM0_reg(memory mem, immI0 zero) %{ @@ -6258,17 +5964,6 @@ instruct storeImmCM0(memory mem, immI0 src) ins_pipe(ialu_mem_imm); %} -// Store Aligned Packed Single Float XMM register to memory -instruct storeA2F(memory mem, regD src) %{ - match(Set mem (Store2F mem src)); - ins_cost(145); - format %{ "MOVQ $mem,$src\t! packed2F" %} - ins_encode %{ - __ movq($mem$$Address, $src$$XMMRegister); - %} - ins_pipe( pipe_slow ); -%} - // Store Float instruct storeF(memory mem, regF src) %{ @@ -10377,172 +10072,6 @@ instruct MoveL2D_reg_reg(regD dst, rRegL src) %{ ins_pipe( pipe_slow ); %} -// Replicate scalar to packed byte (1 byte) values in xmm -instruct Repl8B_reg(regD dst, regD src) %{ - match(Set dst (Replicate8B src)); - format %{ "MOVDQA $dst,$src\n\t" - "PUNPCKLBW $dst,$dst\n\t" - "PSHUFLW $dst,$dst,0x00\t! replicate8B" %} - ins_encode %{ - if ($dst$$reg != $src$$reg) { - __ movdqa($dst$$XMMRegister, $src$$XMMRegister); - } - __ punpcklbw($dst$$XMMRegister, $dst$$XMMRegister); - __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( pipe_slow ); -%} - -// Replicate scalar to packed byte (1 byte) values in xmm -instruct Repl8B_rRegI(regD dst, rRegI src) %{ - match(Set dst (Replicate8B src)); - format %{ "MOVD $dst,$src\n\t" - "PUNPCKLBW $dst,$dst\n\t" - "PSHUFLW $dst,$dst,0x00\t! replicate8B" %} - ins_encode %{ - __ movdl($dst$$XMMRegister, $src$$Register); - __ punpcklbw($dst$$XMMRegister, $dst$$XMMRegister); - __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( pipe_slow ); -%} - -// Replicate scalar zero to packed byte (1 byte) values in xmm -instruct Repl8B_immI0(regD dst, immI0 zero) %{ - match(Set dst (Replicate8B zero)); - format %{ "PXOR $dst,$dst\t! replicate8B" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed shore (2 byte) values in xmm -instruct Repl4S_reg(regD dst, regD src) %{ - match(Set dst (Replicate4S src)); - format %{ "PSHUFLW $dst,$src,0x00\t! replicate4S" %} - ins_encode %{ - __ pshuflw($dst$$XMMRegister, $src$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed shore (2 byte) values in xmm -instruct Repl4S_rRegI(regD dst, rRegI src) %{ - match(Set dst (Replicate4S src)); - format %{ "MOVD $dst,$src\n\t" - "PSHUFLW $dst,$dst,0x00\t! replicate4S" %} - ins_encode %{ - __ movdl($dst$$XMMRegister, $src$$Register); - __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar zero to packed short (2 byte) values in xmm -instruct Repl4S_immI0(regD dst, immI0 zero) %{ - match(Set dst (Replicate4S zero)); - format %{ "PXOR $dst,$dst\t! replicate4S" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed char (2 byte) values in xmm -instruct Repl4C_reg(regD dst, regD src) %{ - match(Set dst (Replicate4C src)); - format %{ "PSHUFLW $dst,$src,0x00\t! replicate4C" %} - ins_encode %{ - __ pshuflw($dst$$XMMRegister, $src$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed char (2 byte) values in xmm -instruct Repl4C_rRegI(regD dst, rRegI src) %{ - match(Set dst (Replicate4C src)); - format %{ "MOVD $dst,$src\n\t" - "PSHUFLW $dst,$dst,0x00\t! replicate4C" %} - ins_encode %{ - __ movdl($dst$$XMMRegister, $src$$Register); - __ pshuflw($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar zero to packed char (2 byte) values in xmm -instruct Repl4C_immI0(regD dst, immI0 zero) %{ - match(Set dst (Replicate4C zero)); - format %{ "PXOR $dst,$dst\t! replicate4C" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed integer (4 byte) values in xmm -instruct Repl2I_reg(regD dst, regD src) %{ - match(Set dst (Replicate2I src)); - format %{ "PSHUFD $dst,$src,0x00\t! replicate2I" %} - ins_encode %{ - __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed integer (4 byte) values in xmm -instruct Repl2I_rRegI(regD dst, rRegI src) %{ - match(Set dst (Replicate2I src)); - format %{ "MOVD $dst,$src\n\t" - "PSHUFD $dst,$dst,0x00\t! replicate2I" %} - ins_encode %{ - __ movdl($dst$$XMMRegister, $src$$Register); - __ pshufd($dst$$XMMRegister, $dst$$XMMRegister, 0x00); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar zero to packed integer (2 byte) values in xmm -instruct Repl2I_immI0(regD dst, immI0 zero) %{ - match(Set dst (Replicate2I zero)); - format %{ "PXOR $dst,$dst\t! replicate2I" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed single precision floating point values in xmm -instruct Repl2F_reg(regD dst, regD src) %{ - match(Set dst (Replicate2F src)); - format %{ "PSHUFD $dst,$src,0xe0\t! replicate2F" %} - ins_encode %{ - __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0xe0); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed single precision floating point values in xmm -instruct Repl2F_regF(regD dst, regF src) %{ - match(Set dst (Replicate2F src)); - format %{ "PSHUFD $dst,$src,0xe0\t! replicate2F" %} - ins_encode %{ - __ pshufd($dst$$XMMRegister, $src$$XMMRegister, 0xe0); - %} - ins_pipe( fpu_reg_reg ); -%} - -// Replicate scalar to packed single precision floating point values in xmm -instruct Repl2F_immF0(regD dst, immF0 zero) %{ - match(Set dst (Replicate2F zero)); - format %{ "PXOR $dst,$dst\t! replicate2F" %} - ins_encode %{ - __ pxor($dst$$XMMRegister, $dst$$XMMRegister); - %} - ins_pipe( fpu_reg_reg ); -%} - // ======================================================================= // fast clearing of an array diff --git a/hotspot/src/share/vm/adlc/adlparse.cpp b/hotspot/src/share/vm/adlc/adlparse.cpp index ec31e36279b..ff486733efc 100644 --- a/hotspot/src/share/vm/adlc/adlparse.cpp +++ b/hotspot/src/share/vm/adlc/adlparse.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -115,6 +115,12 @@ void ADLParser::parse() { parse_err(SYNERR, "expected one of - instruct, operand, ins_attrib, op_attrib, source, register, pipeline, encode\n Found %s",ident); } } + // Add reg_class spill_regs after parsing. + RegisterForm *regBlock = _AD.get_registers(); + if (regBlock == NULL) { + parse_err(SEMERR, "Did not declare 'register' definitions"); + } + regBlock->addSpillRegClass(); // Done with parsing, check consistency. @@ -768,11 +774,12 @@ void ADLParser::source_hpp_parse(void) { //------------------------------reg_parse-------------------------------------- void ADLParser::reg_parse(void) { - - // Create the RegisterForm for the architecture description. - RegisterForm *regBlock = new RegisterForm(); // Build new Source object - regBlock->_linenum = linenum(); - _AD.addForm(regBlock); + RegisterForm *regBlock = _AD.get_registers(); // Information about registers encoding + if (regBlock == NULL) { + // Create the RegisterForm for the architecture description. + regBlock = new RegisterForm(); // Build new Source object + _AD.addForm(regBlock); + } skipws(); // Skip leading whitespace if (_curchar == '%' && *(_ptr+1) == '{') { @@ -796,15 +803,11 @@ void ADLParser::reg_parse(void) { parse_err(SYNERR, "Missing %c{ ... %c} block after register keyword.\n",'%','%'); return; } - - // Add reg_class spill_regs - regBlock->addSpillRegClass(); } //------------------------------encode_parse----------------------------------- void ADLParser::encode_parse(void) { EncodeForm *encBlock; // Information about instruction/operand encoding - char *desc = NULL; // String representation of encode rule _AD.getForm(&encBlock); if ( encBlock == NULL) { diff --git a/hotspot/src/share/vm/adlc/archDesc.cpp b/hotspot/src/share/vm/adlc/archDesc.cpp index 294e88c148e..23cbb1e007b 100644 --- a/hotspot/src/share/vm/adlc/archDesc.cpp +++ b/hotspot/src/share/vm/adlc/archDesc.cpp @@ -1,5 +1,5 @@ // -// Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. +// Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. // DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. // // This code is free software; you can redistribute it and/or modify it @@ -911,12 +911,24 @@ const char *ArchDesc::getIdealType(const char *idealOp) { // Find last character in idealOp, it specifies the type char last_char = 0; const char *ptr = idealOp; - for( ; *ptr != '\0'; ++ptr) { + for (; *ptr != '\0'; ++ptr) { last_char = *ptr; } + // Match Vector types. + if (strncmp(idealOp, "Vec",3)==0) { + switch(last_char) { + case 'S': return "TypeVect::VECTS"; + case 'D': return "TypeVect::VECTD"; + case 'X': return "TypeVect::VECTX"; + case 'Y': return "TypeVect::VECTY"; + default: + internal_err("Vector type %s with unrecognized type\n",idealOp); + } + } + // !!!!! - switch( last_char ) { + switch(last_char) { case 'I': return "TypeInt::INT"; case 'P': return "TypePtr::BOTTOM"; case 'N': return "TypeNarrowOop::BOTTOM"; diff --git a/hotspot/src/share/vm/adlc/forms.cpp b/hotspot/src/share/vm/adlc/forms.cpp index 372ef5dd508..70b8bd96253 100644 --- a/hotspot/src/share/vm/adlc/forms.cpp +++ b/hotspot/src/share/vm/adlc/forms.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -265,47 +265,22 @@ Form::DataType Form::is_load_from_memory(const char *opType) const { if( strcmp(opType,"LoadN")==0 ) return Form::idealN; if( strcmp(opType,"LoadRange")==0 ) return Form::idealI; if( strcmp(opType,"LoadS")==0 ) return Form::idealS; - if( strcmp(opType,"Load16B")==0 ) return Form::idealB; - if( strcmp(opType,"Load8B")==0 ) return Form::idealB; - if( strcmp(opType,"Load4B")==0 ) return Form::idealB; - if( strcmp(opType,"Load8C")==0 ) return Form::idealC; - if( strcmp(opType,"Load4C")==0 ) return Form::idealC; - if( strcmp(opType,"Load2C")==0 ) return Form::idealC; - if( strcmp(opType,"Load8S")==0 ) return Form::idealS; - if( strcmp(opType,"Load4S")==0 ) return Form::idealS; - if( strcmp(opType,"Load2S")==0 ) return Form::idealS; - if( strcmp(opType,"Load2D")==0 ) return Form::idealD; - if( strcmp(opType,"Load4F")==0 ) return Form::idealF; - if( strcmp(opType,"Load2F")==0 ) return Form::idealF; - if( strcmp(opType,"Load4I")==0 ) return Form::idealI; - if( strcmp(opType,"Load2I")==0 ) return Form::idealI; - if( strcmp(opType,"Load2L")==0 ) return Form::idealL; + if( strcmp(opType,"LoadVector")==0 ) return Form::idealV; assert( strcmp(opType,"Load") != 0, "Must type Loads" ); return Form::none; } Form::DataType Form::is_store_to_memory(const char *opType) const { if( strcmp(opType,"StoreB")==0) return Form::idealB; - if( strcmp(opType,"StoreCM")==0) return Form::idealB; + if( strcmp(opType,"StoreCM")==0) return Form::idealB; if( strcmp(opType,"StoreC")==0) return Form::idealC; if( strcmp(opType,"StoreD")==0) return Form::idealD; if( strcmp(opType,"StoreF")==0) return Form::idealF; if( strcmp(opType,"StoreI")==0) return Form::idealI; if( strcmp(opType,"StoreL")==0) return Form::idealL; if( strcmp(opType,"StoreP")==0) return Form::idealP; - if( strcmp(opType,"StoreN")==0) return Form::idealN; - if( strcmp(opType,"Store16B")==0) return Form::idealB; - if( strcmp(opType,"Store8B")==0) return Form::idealB; - if( strcmp(opType,"Store4B")==0) return Form::idealB; - if( strcmp(opType,"Store8C")==0) return Form::idealC; - if( strcmp(opType,"Store4C")==0) return Form::idealC; - if( strcmp(opType,"Store2C")==0) return Form::idealC; - if( strcmp(opType,"Store2D")==0) return Form::idealD; - if( strcmp(opType,"Store4F")==0) return Form::idealF; - if( strcmp(opType,"Store2F")==0) return Form::idealF; - if( strcmp(opType,"Store4I")==0) return Form::idealI; - if( strcmp(opType,"Store2I")==0) return Form::idealI; - if( strcmp(opType,"Store2L")==0) return Form::idealL; + if( strcmp(opType,"StoreN")==0) return Form::idealN; + if( strcmp(opType,"StoreVector")==0 ) return Form::idealV; assert( strcmp(opType,"Store") != 0, "Must type Stores" ); return Form::none; } diff --git a/hotspot/src/share/vm/adlc/forms.hpp b/hotspot/src/share/vm/adlc/forms.hpp index 3132c6a3f92..aa13845d38f 100644 --- a/hotspot/src/share/vm/adlc/forms.hpp +++ b/hotspot/src/share/vm/adlc/forms.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -172,7 +172,8 @@ public: idealB = 6, // Byte type idealC = 7, // Char type idealS = 8, // String type - idealN = 9 // Narrow oop types + idealN = 9, // Narrow oop types + idealV = 10 // Vector type }; // Convert ideal name to a DataType, return DataType::none if not a 'ConX' Form::DataType ideal_to_const_type(const char *ideal_type_name) const; diff --git a/hotspot/src/share/vm/adlc/formsopt.cpp b/hotspot/src/share/vm/adlc/formsopt.cpp index 302cd84afe4..07d70fc6c6e 100644 --- a/hotspot/src/share/vm/adlc/formsopt.cpp +++ b/hotspot/src/share/vm/adlc/formsopt.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -66,7 +66,7 @@ AllocClass *RegisterForm::addAllocClass(char *className) { // for spill-slots/regs. void RegisterForm::addSpillRegClass() { // Stack slots start at the next available even register number. - _reg_ctr = (_reg_ctr+1) & ~1; + _reg_ctr = (_reg_ctr+7) & ~7; const char *rc_name = "stack_slots"; RegClass *reg_class = new RegClass(rc_name); reg_class->_stack_or_reg = true; @@ -150,9 +150,14 @@ bool RegisterForm::verify() { int RegisterForm::RegMask_Size() { // Need at least this many words int words_for_regs = (_reg_ctr + 31)>>5; - // Add a few for incoming & outgoing arguments to calls. + // The array of Register Mask bits should be large enough to cover + // all the machine registers and all parameters that need to be passed + // on the stack (stack registers) up to some interesting limit. Methods + // that need more parameters will NOT be compiled. On Intel, the limit + // is something like 90+ parameters. + // Add a few (3 words == 96 bits) for incoming & outgoing arguments to calls. // Round up to the next doubleword size. - return (words_for_regs + 2 + 1) & ~1; + return (words_for_regs + 3 + 1) & ~1; } void RegisterForm::dump() { // Debug printer diff --git a/hotspot/src/share/vm/adlc/formssel.cpp b/hotspot/src/share/vm/adlc/formssel.cpp index e92b8f89ec9..1b009707ac8 100644 --- a/hotspot/src/share/vm/adlc/formssel.cpp +++ b/hotspot/src/share/vm/adlc/formssel.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -432,6 +432,14 @@ Form::DataType InstructForm::is_ideal_store() const { return _matrule->is_ideal_store(); } +// Return 'true' if this instruction matches an ideal vector node +bool InstructForm::is_vector() const { + if( _matrule == NULL ) return false; + + return _matrule->is_vector(); +} + + // Return the input register that must match the output register // If this is not required, return 0 uint InstructForm::two_address(FormDict &globals) { @@ -751,6 +759,9 @@ bool InstructForm::captures_bottom_type(FormDict &globals) const { if (needs_base_oop_edge(globals)) return true; + if (is_vector()) return true; + if (is_mach_constant()) return true; + return false; } @@ -3381,11 +3392,8 @@ int MatchNode::needs_ideal_memory_edge(FormDict &globals) const { "StoreI","StoreL","StoreP","StoreN","StoreD","StoreF" , "StoreB","StoreC","Store" ,"StoreFP", "LoadI", "LoadUI2L", "LoadL", "LoadP" ,"LoadN", "LoadD" ,"LoadF" , - "LoadB" , "LoadUB", "LoadUS" ,"LoadS" ,"Load" , - "Store4I","Store2I","Store2L","Store2D","Store4F","Store2F","Store16B", - "Store8B","Store4B","Store8C","Store4C","Store2C", - "Load4I" ,"Load2I" ,"Load2L" ,"Load2D" ,"Load4F" ,"Load2F" ,"Load16B" , - "Load8B" ,"Load4B" ,"Load8C" ,"Load4C" ,"Load2C" ,"Load8S", "Load4S","Load2S", + "LoadB" , "LoadUB", "LoadUS" ,"LoadS" ,"Load" , + "StoreVector", "LoadVector", "LoadRange", "LoadKlass", "LoadNKlass", "LoadL_unaligned", "LoadD_unaligned", "LoadPLocked", "StorePConditional", "StoreIConditional", "StoreLConditional", @@ -3822,6 +3830,10 @@ bool MatchRule::is_base_register(FormDict &globals) const { strcmp(opType,"RegL")==0 || strcmp(opType,"RegF")==0 || strcmp(opType,"RegD")==0 || + strcmp(opType,"VecS")==0 || + strcmp(opType,"VecD")==0 || + strcmp(opType,"VecX")==0 || + strcmp(opType,"VecY")==0 || strcmp(opType,"Reg" )==0) ) { return 1; } @@ -3938,19 +3950,12 @@ int MatchRule::is_expensive() const { strcmp(opType,"ReverseBytesL")==0 || strcmp(opType,"ReverseBytesUS")==0 || strcmp(opType,"ReverseBytesS")==0 || - strcmp(opType,"Replicate16B")==0 || - strcmp(opType,"Replicate8B")==0 || - strcmp(opType,"Replicate4B")==0 || - strcmp(opType,"Replicate8C")==0 || - strcmp(opType,"Replicate4C")==0 || - strcmp(opType,"Replicate8S")==0 || - strcmp(opType,"Replicate4S")==0 || - strcmp(opType,"Replicate4I")==0 || - strcmp(opType,"Replicate2I")==0 || - strcmp(opType,"Replicate2L")==0 || - strcmp(opType,"Replicate4F")==0 || - strcmp(opType,"Replicate2F")==0 || - strcmp(opType,"Replicate2D")==0 || + strcmp(opType,"ReplicateB")==0 || + strcmp(opType,"ReplicateS")==0 || + strcmp(opType,"ReplicateI")==0 || + strcmp(opType,"ReplicateL")==0 || + strcmp(opType,"ReplicateF")==0 || + strcmp(opType,"ReplicateD")==0 || 0 /* 0 to line up columns nicely */ ) return 1; } @@ -4034,6 +4039,23 @@ Form::DataType MatchRule::is_ideal_load() const { return ideal_load; } +bool MatchRule::is_vector() const { + if( _rChild ) { + const char *opType = _rChild->_opType; + if( strcmp(opType,"ReplicateB")==0 || + strcmp(opType,"ReplicateS")==0 || + strcmp(opType,"ReplicateI")==0 || + strcmp(opType,"ReplicateL")==0 || + strcmp(opType,"ReplicateF")==0 || + strcmp(opType,"ReplicateD")==0 || + strcmp(opType,"LoadVector")==0 || + strcmp(opType,"StoreVector")==0 || + 0 /* 0 to line up columns nicely */ ) + return true; + } + return false; +} + bool MatchRule::skip_antidep_check() const { // Some loads operate on what is effectively immutable memory so we diff --git a/hotspot/src/share/vm/adlc/formssel.hpp b/hotspot/src/share/vm/adlc/formssel.hpp index b2d3ec74d46..93b43b1f08b 100644 --- a/hotspot/src/share/vm/adlc/formssel.hpp +++ b/hotspot/src/share/vm/adlc/formssel.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -160,6 +160,7 @@ public: virtual bool is_ideal_safepoint() const; // node matches 'SafePoint' virtual bool is_ideal_nop() const; // node matches 'Nop' virtual bool is_ideal_control() const; // control node + virtual bool is_vector() const; // vector instruction virtual Form::CallType is_ideal_call() const; // matches ideal 'Call' virtual Form::DataType is_ideal_load() const; // node matches ideal 'LoadXNode' @@ -1011,6 +1012,7 @@ public: bool is_ideal_goto() const; // node matches ideal 'Goto' bool is_ideal_loopEnd() const; // node matches ideal 'LoopEnd' bool is_ideal_bool() const; // node matches ideal 'Bool' + bool is_vector() const; // vector instruction Form::DataType is_ideal_load() const;// node matches ideal 'LoadXNode' // Should antidep checks be disabled for this rule // See definition of MatchRule::skip_antidep_check diff --git a/hotspot/src/share/vm/adlc/main.cpp b/hotspot/src/share/vm/adlc/main.cpp index 47e207a4b13..a963cdaf5bc 100644 --- a/hotspot/src/share/vm/adlc/main.cpp +++ b/hotspot/src/share/vm/adlc/main.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -250,6 +250,7 @@ int main(int argc, char *argv[]) AD.addInclude(AD._HPP_file, "opto/node.hpp"); AD.addInclude(AD._HPP_file, "opto/regalloc.hpp"); AD.addInclude(AD._HPP_file, "opto/subnode.hpp"); + AD.addInclude(AD._HPP_file, "opto/vectornode.hpp"); AD.addInclude(AD._CPP_CLONE_file, "precompiled.hpp"); AD.addInclude(AD._CPP_CLONE_file, "adfiles", get_basename(AD._HPP_file._name)); AD.addInclude(AD._CPP_EXPAND_file, "precompiled.hpp"); diff --git a/hotspot/src/share/vm/code/vmreg.cpp b/hotspot/src/share/vm/code/vmreg.cpp index dd5945503b2..c56be87f108 100644 --- a/hotspot/src/share/vm/code/vmreg.cpp +++ b/hotspot/src/share/vm/code/vmreg.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,7 +27,7 @@ #include "code/vmreg.hpp" // First VMReg value that could refer to a stack slot -VMReg VMRegImpl::stack0 = (VMReg)(intptr_t)((ConcreteRegisterImpl::number_of_registers + 1) & ~1); +VMReg VMRegImpl::stack0 = (VMReg)(intptr_t)((ConcreteRegisterImpl::number_of_registers + 7) & ~7); // VMRegs are 4 bytes wide on all platforms const int VMRegImpl::stack_slot_size = 4; diff --git a/hotspot/src/share/vm/opto/c2_globals.hpp b/hotspot/src/share/vm/opto/c2_globals.hpp index 4d5424da5f7..947d806a34a 100644 --- a/hotspot/src/share/vm/opto/c2_globals.hpp +++ b/hotspot/src/share/vm/opto/c2_globals.hpp @@ -81,6 +81,13 @@ product(intx, MaxLoopPad, (OptoLoopAlignment-1), \ "Align a loop if padding size in bytes is less or equal to this value") \ \ + product(intx, MaxVectorSize, 32, \ + "Max vector size in bytes, " \ + "actual size could be less depending on elements type") \ + \ + product(bool, AlignVector, false, \ + "Perform vector store/load alignment in loop") \ + \ product(intx, NumberOfLoopInstrToAlign, 4, \ "Number of first instructions in a loop to align") \ \ diff --git a/hotspot/src/share/vm/opto/chaitin.cpp b/hotspot/src/share/vm/opto/chaitin.cpp index a74114add85..0ed9b962724 100644 --- a/hotspot/src/share/vm/opto/chaitin.cpp +++ b/hotspot/src/share/vm/opto/chaitin.cpp @@ -75,6 +75,7 @@ void LRG::dump( ) const { // Flags if( _is_oop ) tty->print("Oop "); if( _is_float ) tty->print("Float "); + if( _is_vector ) tty->print("Vector "); if( _was_spilled1 ) tty->print("Spilled "); if( _was_spilled2 ) tty->print("Spilled2 "); if( _direct_conflict ) tty->print("Direct_conflict "); @@ -479,16 +480,18 @@ void PhaseChaitin::Register_Allocate() { // Move important info out of the live_arena to longer lasting storage. alloc_node_regs(_names.Size()); - for( uint i=0; i < _names.Size(); i++ ) { - if( _names[i] ) { // Live range associated with Node? - LRG &lrg = lrgs( _names[i] ); - if( lrg.num_regs() == 1 ) { - _node_regs[i].set1( lrg.reg() ); + for (uint i=0; i < _names.Size(); i++) { + if (_names[i]) { // Live range associated with Node? + LRG &lrg = lrgs(_names[i]); + if (!lrg.alive()) { + _node_regs[i].set_bad(); + } else if (lrg.num_regs() == 1) { + _node_regs[i].set1(lrg.reg()); } else { // Must be a register-pair - if( !lrg._fat_proj ) { // Must be aligned adjacent register pair + if (!lrg._fat_proj) { // Must be aligned adjacent register pair // Live ranges record the highest register in their mask. // We want the low register for the AD file writer's convenience. - _node_regs[i].set2( OptoReg::add(lrg.reg(),-1) ); + _node_regs[i].set2( OptoReg::add(lrg.reg(),(1-lrg.num_regs())) ); } else { // Misaligned; extract 2 bits OptoReg::Name hi = lrg.reg(); // Get hi register lrg.Remove(hi); // Yank from mask @@ -568,7 +571,7 @@ void PhaseChaitin::gather_lrg_masks( bool after_aggressive ) { // Check for float-vs-int live range (used in register-pressure // calculations) const Type *n_type = n->bottom_type(); - if( n_type->is_floatingpoint() ) + if (n_type->is_floatingpoint()) lrg._is_float = 1; // Check for twice prior spilling. Once prior spilling might have @@ -599,18 +602,28 @@ void PhaseChaitin::gather_lrg_masks( bool after_aggressive ) { // Limit result register mask to acceptable registers const RegMask &rm = n->out_RegMask(); lrg.AND( rm ); - // Check for bound register masks - const RegMask &lrgmask = lrg.mask(); - if( lrgmask.is_bound1() || lrgmask.is_bound2() ) - lrg._is_bound = 1; - - // Check for maximum frequency value - if( lrg._maxfreq < b->_freq ) - lrg._maxfreq = b->_freq; int ireg = n->ideal_reg(); assert( !n->bottom_type()->isa_oop_ptr() || ireg == Op_RegP, "oops must be in Op_RegP's" ); + + // Check for vector live range (only if vector register is used). + // On SPARC vector uses RegD which could be misaligned so it is not + // processes as vector in RA. + if (RegMask::is_vector(ireg)) + lrg._is_vector = 1; + assert(n_type->isa_vect() == NULL || lrg._is_vector || ireg == Op_RegD, + "vector must be in vector registers"); + + // Check for bound register masks + const RegMask &lrgmask = lrg.mask(); + if (lrgmask.is_bound(ireg)) + lrg._is_bound = 1; + + // Check for maximum frequency value + if (lrg._maxfreq < b->_freq) + lrg._maxfreq = b->_freq; + // Check for oop-iness, or long/double // Check for multi-kill projection switch( ireg ) { @@ -689,7 +702,7 @@ void PhaseChaitin::gather_lrg_masks( bool after_aggressive ) { // AND changes how we count interferences. A mis-aligned // double can interfere with TWO aligned pairs, or effectively // FOUR registers! - if( rm.is_misaligned_Pair() ) { + if (rm.is_misaligned_pair()) { lrg._fat_proj = 1; lrg._is_bound = 1; } @@ -706,6 +719,33 @@ void PhaseChaitin::gather_lrg_masks( bool after_aggressive ) { lrg.set_reg_pressure(1); #endif break; + case Op_VecS: + assert(Matcher::vector_size_supported(T_BYTE,4), "sanity"); + assert(RegMask::num_registers(Op_VecS) == RegMask::SlotsPerVecS, "sanity"); + lrg.set_num_regs(RegMask::SlotsPerVecS); + lrg.set_reg_pressure(1); + break; + case Op_VecD: + assert(Matcher::vector_size_supported(T_FLOAT,RegMask::SlotsPerVecD), "sanity"); + assert(RegMask::num_registers(Op_VecD) == RegMask::SlotsPerVecD, "sanity"); + assert(lrgmask.is_aligned_sets(RegMask::SlotsPerVecD), "vector should be aligned"); + lrg.set_num_regs(RegMask::SlotsPerVecD); + lrg.set_reg_pressure(1); + break; + case Op_VecX: + assert(Matcher::vector_size_supported(T_FLOAT,RegMask::SlotsPerVecX), "sanity"); + assert(RegMask::num_registers(Op_VecX) == RegMask::SlotsPerVecX, "sanity"); + assert(lrgmask.is_aligned_sets(RegMask::SlotsPerVecX), "vector should be aligned"); + lrg.set_num_regs(RegMask::SlotsPerVecX); + lrg.set_reg_pressure(1); + break; + case Op_VecY: + assert(Matcher::vector_size_supported(T_FLOAT,RegMask::SlotsPerVecY), "sanity"); + assert(RegMask::num_registers(Op_VecY) == RegMask::SlotsPerVecY, "sanity"); + assert(lrgmask.is_aligned_sets(RegMask::SlotsPerVecY), "vector should be aligned"); + lrg.set_num_regs(RegMask::SlotsPerVecY); + lrg.set_reg_pressure(1); + break; default: ShouldNotReachHere(); } @@ -763,24 +803,38 @@ void PhaseChaitin::gather_lrg_masks( bool after_aggressive ) { } else { lrg.AND( rm ); } + // Check for bound register masks const RegMask &lrgmask = lrg.mask(); - if( lrgmask.is_bound1() || lrgmask.is_bound2() ) + int kreg = n->in(k)->ideal_reg(); + bool is_vect = RegMask::is_vector(kreg); + assert(n->in(k)->bottom_type()->isa_vect() == NULL || + is_vect || kreg == Op_RegD, + "vector must be in vector registers"); + if (lrgmask.is_bound(kreg)) lrg._is_bound = 1; + // If this use of a double forces a mis-aligned double, // flag as '_fat_proj' - really flag as allowing misalignment // AND changes how we count interferences. A mis-aligned // double can interfere with TWO aligned pairs, or effectively // FOUR registers! - if( lrg.num_regs() == 2 && !lrg._fat_proj && rm.is_misaligned_Pair() ) { +#ifdef ASSERT + if (is_vect) { + assert(lrgmask.is_aligned_sets(lrg.num_regs()), "vector should be aligned"); + assert(!lrg._fat_proj, "sanity"); + assert(RegMask::num_registers(kreg) == lrg.num_regs(), "sanity"); + } +#endif + if (!is_vect && lrg.num_regs() == 2 && !lrg._fat_proj && rm.is_misaligned_pair()) { lrg._fat_proj = 1; lrg._is_bound = 1; } // if the LRG is an unaligned pair, we will have to spill // so clear the LRG's register mask if it is not already spilled - if ( !n->is_SpillCopy() && - (lrg._def == NULL || lrg.is_multidef() || !lrg._def->is_SpillCopy()) && - lrgmask.is_misaligned_Pair()) { + if (!is_vect && !n->is_SpillCopy() && + (lrg._def == NULL || lrg.is_multidef() || !lrg._def->is_SpillCopy()) && + lrgmask.is_misaligned_pair()) { lrg.Clear(); } @@ -793,12 +847,14 @@ void PhaseChaitin::gather_lrg_masks( bool after_aggressive ) { } // end for all blocks // Final per-liverange setup - for( uint i2=0; i2<_maxlrg; i2++ ) { + for (uint i2=0; i2<_maxlrg; i2++) { LRG &lrg = lrgs(i2); - if( lrg.num_regs() == 2 && !lrg._fat_proj ) - lrg.ClearToPairs(); + assert(!lrg._is_vector || !lrg._fat_proj, "sanity"); + if (lrg.num_regs() > 1 && !lrg._fat_proj) { + lrg.clear_to_sets(); + } lrg.compute_set_mask_size(); - if( lrg.not_free() ) { // Handle case where we lose from the start + if (lrg.not_free()) { // Handle case where we lose from the start lrg.set_reg(OptoReg::Name(LRG::SPILL_REG)); lrg._direct_conflict = 1; } @@ -1104,22 +1160,17 @@ OptoReg::Name PhaseChaitin::bias_color( LRG &lrg, int chunk ) { // Choose a color which is legal for him RegMask tempmask = lrg.mask(); tempmask.AND(lrgs(copy_lrg).mask()); - OptoReg::Name reg; - if( lrg.num_regs() == 1 ) { - reg = tempmask.find_first_elem(); - } else { - tempmask.ClearToPairs(); - reg = tempmask.find_first_pair(); - } - if( OptoReg::is_valid(reg) ) + tempmask.clear_to_sets(lrg.num_regs()); + OptoReg::Name reg = tempmask.find_first_set(lrg.num_regs()); + if (OptoReg::is_valid(reg)) return reg; } } // If no bias info exists, just go with the register selection ordering - if( lrg.num_regs() == 2 ) { - // Find an aligned pair - return OptoReg::add(lrg.mask().find_first_pair(),chunk); + if (lrg._is_vector || lrg.num_regs() == 2) { + // Find an aligned set + return OptoReg::add(lrg.mask().find_first_set(lrg.num_regs()),chunk); } // CNC - Fun hack. Alternate 1st and 2nd selection. Enables post-allocate @@ -1149,6 +1200,7 @@ OptoReg::Name PhaseChaitin::choose_color( LRG &lrg, int chunk ) { // Use a heuristic to "bias" the color choice return bias_color(lrg, chunk); + assert(!lrg._is_vector, "should be not vector here" ); assert( lrg.num_regs() >= 2, "dead live ranges do not color" ); // Fat-proj case or misaligned double argument. @@ -1238,14 +1290,16 @@ uint PhaseChaitin::Select( ) { } //assert(is_allstack == lrg->mask().is_AllStack(), "nbrs must not change AllStackedness"); // Aligned pairs need aligned masks - if( lrg->num_regs() == 2 && !lrg->_fat_proj ) - lrg->ClearToPairs(); + assert(!lrg->_is_vector || !lrg->_fat_proj, "sanity"); + if (lrg->num_regs() > 1 && !lrg->_fat_proj) { + lrg->clear_to_sets(); + } // Check if a color is available and if so pick the color OptoReg::Name reg = choose_color( *lrg, chunk ); #ifdef SPARC debug_only(lrg->compute_set_mask_size()); - assert(lrg->num_regs() != 2 || lrg->is_bound() || is_even(reg-1), "allocate all doubles aligned"); + assert(lrg->num_regs() < 2 || lrg->is_bound() || is_even(reg-1), "allocate all doubles aligned"); #endif //--------------- @@ -1277,17 +1331,16 @@ uint PhaseChaitin::Select( ) { // If the live range is not bound, then we actually had some choices // to make. In this case, the mask has more bits in it than the colors // chosen. Restrict the mask to just what was picked. - if( lrg->num_regs() == 1 ) { // Size 1 live range + int n_regs = lrg->num_regs(); + assert(!lrg->_is_vector || !lrg->_fat_proj, "sanity"); + if (n_regs == 1 || !lrg->_fat_proj) { + assert(!lrg->_is_vector || n_regs <= RegMask::SlotsPerVecY, "sanity"); lrg->Clear(); // Clear the mask lrg->Insert(reg); // Set regmask to match selected reg - lrg->set_mask_size(1); - } else if( !lrg->_fat_proj ) { - // For pairs, also insert the low bit of the pair - assert( lrg->num_regs() == 2, "unbound fatproj???" ); - lrg->Clear(); // Clear the mask - lrg->Insert(reg); // Set regmask to match selected reg - lrg->Insert(OptoReg::add(reg,-1)); - lrg->set_mask_size(2); + // For vectors and pairs, also insert the low bit of the pair + for (int i = 1; i < n_regs; i++) + lrg->Insert(OptoReg::add(reg,-i)); + lrg->set_mask_size(n_regs); } else { // Else fatproj // mask must be equal to fatproj bits, by definition } @@ -1860,12 +1913,20 @@ char *PhaseChaitin::dump_register( const Node *n, char *buf ) const { sprintf(buf,"L%d",lidx); // No register binding yet } else if( !lidx ) { // Special, not allocated value strcpy(buf,"Special"); - } else if( (lrgs(lidx).num_regs() == 1) - ? !lrgs(lidx).mask().is_bound1() - : !lrgs(lidx).mask().is_bound2() ) { - sprintf(buf,"L%d",lidx); // No register binding yet - } else { // Hah! We have a bound machine register - print_reg( lrgs(lidx).reg(), this, buf ); + } else { + if (lrgs(lidx)._is_vector) { + if (lrgs(lidx).mask().is_bound_set(lrgs(lidx).num_regs())) + print_reg( lrgs(lidx).reg(), this, buf ); // a bound machine register + else + sprintf(buf,"L%d",lidx); // No register binding yet + } else if( (lrgs(lidx).num_regs() == 1) + ? lrgs(lidx).mask().is_bound1() + : lrgs(lidx).mask().is_bound_pair() ) { + // Hah! We have a bound machine register + print_reg( lrgs(lidx).reg(), this, buf ); + } else { + sprintf(buf,"L%d",lidx); // No register binding yet + } } } return buf+strlen(buf); diff --git a/hotspot/src/share/vm/opto/chaitin.hpp b/hotspot/src/share/vm/opto/chaitin.hpp index 1e6be63c452..c10f18d742e 100644 --- a/hotspot/src/share/vm/opto/chaitin.hpp +++ b/hotspot/src/share/vm/opto/chaitin.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -99,8 +99,15 @@ public: void set_mask_size( int size ) { assert((size == 65535) || (size == (int)_mask.Size()), ""); _mask_size = size; - debug_only(_msize_valid=1;) - debug_only( if( _num_regs == 2 && !_fat_proj ) _mask.VerifyPairs(); ) +#ifdef ASSERT + _msize_valid=1; + if (_is_vector) { + assert(!_fat_proj, "sanity"); + _mask.verify_sets(_num_regs); + } else if (_num_regs == 2 && !_fat_proj) { + _mask.verify_pairs(); + } +#endif } void compute_set_mask_size() { set_mask_size(compute_mask_size()); } int mask_size() const { assert( _msize_valid, "mask size not valid" ); @@ -116,7 +123,8 @@ public: void Set_All() { _mask.Set_All(); debug_only(_msize_valid=1); _mask_size = RegMask::CHUNK_SIZE; } void Insert( OptoReg::Name reg ) { _mask.Insert(reg); debug_only(_msize_valid=0;) } void Remove( OptoReg::Name reg ) { _mask.Remove(reg); debug_only(_msize_valid=0;) } - void ClearToPairs() { _mask.ClearToPairs(); debug_only(_msize_valid=0;) } + void clear_to_pairs() { _mask.clear_to_pairs(); debug_only(_msize_valid=0;) } + void clear_to_sets() { _mask.clear_to_sets(_num_regs); debug_only(_msize_valid=0;) } // Number of registers this live range uses when it colors private: @@ -150,6 +158,7 @@ public: uint _is_oop:1, // Live-range holds an oop _is_float:1, // True if in float registers + _is_vector:1, // True if in vector registers _was_spilled1:1, // True if prior spilling on def _was_spilled2:1, // True if twice prior spilling on def _is_bound:1, // live range starts life with no diff --git a/hotspot/src/share/vm/opto/classes.hpp b/hotspot/src/share/vm/opto/classes.hpp index 03b5107c3e4..bdf18b51f32 100644 --- a/hotspot/src/share/vm/opto/classes.hpp +++ b/hotspot/src/share/vm/opto/classes.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -245,14 +245,12 @@ macro(XorI) macro(XorL) macro(Vector) macro(AddVB) -macro(AddVC) macro(AddVS) macro(AddVI) macro(AddVL) macro(AddVF) macro(AddVD) macro(SubVB) -macro(SubVC) macro(SubVS) macro(SubVI) macro(SubVL) @@ -263,74 +261,36 @@ macro(MulVD) macro(DivVF) macro(DivVD) macro(LShiftVB) -macro(LShiftVC) macro(LShiftVS) macro(LShiftVI) -macro(URShiftVB) -macro(URShiftVC) -macro(URShiftVS) -macro(URShiftVI) +macro(RShiftVB) +macro(RShiftVS) +macro(RShiftVI) macro(AndV) macro(OrV) macro(XorV) -macro(VectorLoad) -macro(Load16B) -macro(Load8B) -macro(Load4B) -macro(Load8C) -macro(Load4C) -macro(Load2C) -macro(Load8S) -macro(Load4S) -macro(Load2S) -macro(Load4I) -macro(Load2I) -macro(Load2L) -macro(Load4F) -macro(Load2F) -macro(Load2D) -macro(VectorStore) -macro(Store16B) -macro(Store8B) -macro(Store4B) -macro(Store8C) -macro(Store4C) -macro(Store2C) -macro(Store4I) -macro(Store2I) -macro(Store2L) -macro(Store4F) -macro(Store2F) -macro(Store2D) +macro(LoadVector) +macro(StoreVector) macro(Pack) macro(PackB) macro(PackS) -macro(PackC) macro(PackI) macro(PackL) macro(PackF) macro(PackD) -macro(Pack2x1B) -macro(Pack2x2B) -macro(Replicate16B) -macro(Replicate8B) -macro(Replicate4B) -macro(Replicate8S) -macro(Replicate4S) -macro(Replicate2S) -macro(Replicate8C) -macro(Replicate4C) -macro(Replicate2C) -macro(Replicate4I) -macro(Replicate2I) -macro(Replicate2L) -macro(Replicate4F) -macro(Replicate2F) -macro(Replicate2D) +macro(Pack2L) +macro(Pack2D) +macro(ReplicateB) +macro(ReplicateS) +macro(ReplicateI) +macro(ReplicateL) +macro(ReplicateF) +macro(ReplicateD) macro(Extract) macro(ExtractB) -macro(ExtractS) +macro(ExtractUB) macro(ExtractC) +macro(ExtractS) macro(ExtractI) macro(ExtractL) macro(ExtractF) diff --git a/hotspot/src/share/vm/opto/compile.cpp b/hotspot/src/share/vm/opto/compile.cpp index 5c4b5145ab7..5331d033fe2 100644 --- a/hotspot/src/share/vm/opto/compile.cpp +++ b/hotspot/src/share/vm/opto/compile.cpp @@ -2591,38 +2591,12 @@ static void final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc ) { } break; - case Op_Load16B: - case Op_Load8B: - case Op_Load4B: - case Op_Load8S: - case Op_Load4S: - case Op_Load2S: - case Op_Load8C: - case Op_Load4C: - case Op_Load2C: - case Op_Load4I: - case Op_Load2I: - case Op_Load2L: - case Op_Load4F: - case Op_Load2F: - case Op_Load2D: - case Op_Store16B: - case Op_Store8B: - case Op_Store4B: - case Op_Store8C: - case Op_Store4C: - case Op_Store2C: - case Op_Store4I: - case Op_Store2I: - case Op_Store2L: - case Op_Store4F: - case Op_Store2F: - case Op_Store2D: + case Op_LoadVector: + case Op_StoreVector: break; case Op_PackB: case Op_PackS: - case Op_PackC: case Op_PackI: case Op_PackF: case Op_PackL: diff --git a/hotspot/src/share/vm/opto/ifg.cpp b/hotspot/src/share/vm/opto/ifg.cpp index 3a225456503..4827a17d8df 100644 --- a/hotspot/src/share/vm/opto/ifg.cpp +++ b/hotspot/src/share/vm/opto/ifg.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -416,6 +416,7 @@ uint PhaseChaitin::count_int_pressure( IndexSet *liveout ) { if( lrgs(lidx).mask().is_UP() && lrgs(lidx).mask_size() && !lrgs(lidx)._is_float && + !lrgs(lidx)._is_vector && lrgs(lidx).mask().overlap(*Matcher::idealreg2regmask[Op_RegI]) ) cnt += lrgs(lidx).reg_pressure(); } @@ -430,7 +431,7 @@ uint PhaseChaitin::count_float_pressure( IndexSet *liveout ) { while ((lidx = elements.next()) != 0) { if( lrgs(lidx).mask().is_UP() && lrgs(lidx).mask_size() && - lrgs(lidx)._is_float ) + (lrgs(lidx)._is_float || lrgs(lidx)._is_vector)) cnt += lrgs(lidx).reg_pressure(); } return cnt; @@ -439,8 +440,8 @@ uint PhaseChaitin::count_float_pressure( IndexSet *liveout ) { //------------------------------lower_pressure--------------------------------- // Adjust register pressure down by 1. Capture last hi-to-low transition, static void lower_pressure( LRG *lrg, uint where, Block *b, uint *pressure, uint *hrp_index ) { - if( lrg->mask().is_UP() && lrg->mask_size() ) { - if( lrg->_is_float ) { + if (lrg->mask().is_UP() && lrg->mask_size()) { + if (lrg->_is_float || lrg->_is_vector) { pressure[1] -= lrg->reg_pressure(); if( pressure[1] == (uint)FLOATPRESSURE ) { hrp_index[1] = where; @@ -522,8 +523,8 @@ uint PhaseChaitin::build_ifg_physical( ResourceArea *a ) { LRG &lrg = lrgs(lidx); lrg._area += cost; // Compute initial register pressure - if( lrg.mask().is_UP() && lrg.mask_size() ) { - if( lrg._is_float ) { // Count float pressure + if (lrg.mask().is_UP() && lrg.mask_size()) { + if (lrg._is_float || lrg._is_vector) { // Count float pressure pressure[1] += lrg.reg_pressure(); #ifdef EXACT_PRESSURE if( pressure[1] > b->_freg_pressure ) @@ -681,13 +682,10 @@ uint PhaseChaitin::build_ifg_physical( ResourceArea *a ) { // according to its bindings. const RegMask &rmask = lrgs(r).mask(); if( lrgs(r).is_bound() && !(n->rematerialize()) && rmask.is_NotEmpty() ) { - // Smear odd bits; leave only aligned pairs of bits. - RegMask r2mask = rmask; - r2mask.SmearToPairs(); // Check for common case int r_size = lrgs(r).num_regs(); OptoReg::Name r_reg = (r_size == 1) ? rmask.find_first_elem() : OptoReg::Physical; - + // Smear odd bits IndexSetIterator elements(&liveout); uint l; while ((l = elements.next()) != 0) { @@ -701,10 +699,15 @@ uint PhaseChaitin::build_ifg_physical( ResourceArea *a ) { // Remove the bits from LRG 'r' from LRG 'l' so 'l' no // longer interferes with 'r'. If 'l' requires aligned // adjacent pairs, subtract out bit pairs. - if( lrg.num_regs() == 2 && !lrg._fat_proj ) { + assert(!lrg._is_vector || !lrg._fat_proj, "sanity"); + if (lrg.num_regs() > 1 && !lrg._fat_proj) { + RegMask r2mask = rmask; + // Leave only aligned set of bits. + r2mask.smear_to_sets(lrg.num_regs()); + // It includes vector case. lrg.SUBTRACT( r2mask ); lrg.compute_set_mask_size(); - } else if( r_size != 1 ) { + } else if( r_size != 1 ) { // fat proj lrg.SUBTRACT( rmask ); lrg.compute_set_mask_size(); } else { // Common case: size 1 bound removal @@ -763,8 +766,8 @@ uint PhaseChaitin::build_ifg_physical( ResourceArea *a ) { // Newly live things assumed live from here to top of block lrg._area += cost; // Adjust register pressure - if( lrg.mask().is_UP() && lrg.mask_size() ) { - if( lrg._is_float ) { + if (lrg.mask().is_UP() && lrg.mask_size()) { + if (lrg._is_float || lrg._is_vector) { pressure[1] += lrg.reg_pressure(); #ifdef EXACT_PRESSURE if( pressure[1] > b->_freg_pressure ) diff --git a/hotspot/src/share/vm/opto/lcm.cpp b/hotspot/src/share/vm/opto/lcm.cpp index 1ad9f0b1f0c..2f272eb55c7 100644 --- a/hotspot/src/share/vm/opto/lcm.cpp +++ b/hotspot/src/share/vm/opto/lcm.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -139,6 +139,7 @@ void Block::implicit_null_check(PhaseCFG *cfg, Node *proj, Node *val, int allowe int iop = mach->ideal_Opcode(); switch( iop ) { case Op_LoadB: + case Op_LoadUB: case Op_LoadUS: case Op_LoadD: case Op_LoadF: @@ -445,6 +446,11 @@ Node *Block::select(PhaseCFG *cfg, Node_List &worklist, GrowableArray &read if( e->is_MachNullCheck() && e->in(1) == n ) continue; + // Schedule IV increment last. + if (e->is_Mach() && e->as_Mach()->ideal_Opcode() == Op_CountedLoopEnd && + e->in(1)->in(1) == n && n->is_iteratively_computed()) + continue; + uint n_choice = 2; // See if this instruction is consumed by a branch. If so, then (as the diff --git a/hotspot/src/share/vm/opto/loopnode.cpp b/hotspot/src/share/vm/opto/loopnode.cpp index afd96045aa7..43def731478 100644 --- a/hotspot/src/share/vm/opto/loopnode.cpp +++ b/hotspot/src/share/vm/opto/loopnode.cpp @@ -2751,7 +2751,8 @@ int PhaseIdealLoop::build_loop_tree_impl( Node *n, int pre_order ) { // Do not count uncommon calls if( !n->is_CallStaticJava() || !n->as_CallStaticJava()->_name ) { Node *iff = n->in(0)->in(0); - if( !iff->is_If() || + // No any calls for vectorized loops. + if( UseSuperWord || !iff->is_If() || (n->in(0)->Opcode() == Op_IfFalse && (1.0 - iff->as_If()->_prob) >= 0.01) || (iff->as_If()->_prob >= 0.01) ) @@ -3216,7 +3217,8 @@ void PhaseIdealLoop::build_loop_late_post( Node *n ) { case Op_ModF: case Op_ModD: case Op_LoadB: // Same with Loads; they can sink - case Op_LoadUS: // during loop optimizations. + case Op_LoadUB: // during loop optimizations. + case Op_LoadUS: case Op_LoadD: case Op_LoadF: case Op_LoadI: diff --git a/hotspot/src/share/vm/opto/machnode.cpp b/hotspot/src/share/vm/opto/machnode.cpp index 7bc5877854c..88bb23b370f 100644 --- a/hotspot/src/share/vm/opto/machnode.cpp +++ b/hotspot/src/share/vm/opto/machnode.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -439,9 +439,9 @@ bool MachNode::rematerialize() const { // Don't remateralize somebody with bound inputs - it stretches a // fixed register lifetime. uint idx = oper_input_base(); - if( req() > idx ) { + if (req() > idx) { const RegMask &rm = in_RegMask(idx); - if( rm.is_bound1() || rm.is_bound2() ) + if (rm.is_bound(ideal_reg())) return false; } diff --git a/hotspot/src/share/vm/opto/machnode.hpp b/hotspot/src/share/vm/opto/machnode.hpp index 566e031d1a1..4db1154e8df 100644 --- a/hotspot/src/share/vm/opto/machnode.hpp +++ b/hotspot/src/share/vm/opto/machnode.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -319,6 +319,7 @@ public: class MachTypeNode : public MachNode { virtual uint size_of() const { return sizeof(*this); } // Size is bigger public: + MachTypeNode( ) {} const Type *_bottom_type; virtual const class Type *bottom_type() const { return _bottom_type; } @@ -370,12 +371,12 @@ public: //------------------------------MachConstantNode------------------------------- // Machine node that holds a constant which is stored in the constant table. -class MachConstantNode : public MachNode { +class MachConstantNode : public MachTypeNode { protected: Compile::Constant _constant; // This node's constant. public: - MachConstantNode() : MachNode() { + MachConstantNode() : MachTypeNode() { init_class_id(Class_MachConstant); } diff --git a/hotspot/src/share/vm/opto/matcher.cpp b/hotspot/src/share/vm/opto/matcher.cpp index 397385670d2..f6bb30769cd 100644 --- a/hotspot/src/share/vm/opto/matcher.cpp +++ b/hotspot/src/share/vm/opto/matcher.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -35,6 +35,7 @@ #include "opto/rootnode.hpp" #include "opto/runtime.hpp" #include "opto/type.hpp" +#include "opto/vectornode.hpp" #include "runtime/atomic.hpp" #include "runtime/os.hpp" #ifdef TARGET_ARCH_MODEL_x86_32 @@ -58,18 +59,6 @@ OptoReg::Name OptoReg::c_frame_pointer; - - -const int Matcher::base2reg[Type::lastype] = { - Node::NotAMachineReg,0,0, Op_RegI, Op_RegL, 0, Op_RegN, - Node::NotAMachineReg, Node::NotAMachineReg, /* tuple, array */ - Op_RegP, Op_RegP, Op_RegP, Op_RegP, Op_RegP, Op_RegP, /* the pointers */ - 0, 0/*abio*/, - Op_RegP /* Return address */, 0, /* the memories */ - Op_RegF, Op_RegF, Op_RegF, Op_RegD, Op_RegD, Op_RegD, - 0 /*bottom*/ -}; - const RegMask *Matcher::idealreg2regmask[_last_machine_leaf]; RegMask Matcher::mreg2regmask[_last_Mach_Reg]; RegMask Matcher::STACK_ONLY_mask; @@ -107,6 +96,10 @@ Matcher::Matcher( Node_List &proj_list ) : idealreg2spillmask [Op_RegF] = NULL; idealreg2spillmask [Op_RegD] = NULL; idealreg2spillmask [Op_RegP] = NULL; + idealreg2spillmask [Op_VecS] = NULL; + idealreg2spillmask [Op_VecD] = NULL; + idealreg2spillmask [Op_VecX] = NULL; + idealreg2spillmask [Op_VecY] = NULL; idealreg2debugmask [Op_RegI] = NULL; idealreg2debugmask [Op_RegN] = NULL; @@ -114,6 +107,10 @@ Matcher::Matcher( Node_List &proj_list ) : idealreg2debugmask [Op_RegF] = NULL; idealreg2debugmask [Op_RegD] = NULL; idealreg2debugmask [Op_RegP] = NULL; + idealreg2debugmask [Op_VecS] = NULL; + idealreg2debugmask [Op_VecD] = NULL; + idealreg2debugmask [Op_VecX] = NULL; + idealreg2debugmask [Op_VecY] = NULL; idealreg2mhdebugmask[Op_RegI] = NULL; idealreg2mhdebugmask[Op_RegN] = NULL; @@ -121,6 +118,10 @@ Matcher::Matcher( Node_List &proj_list ) : idealreg2mhdebugmask[Op_RegF] = NULL; idealreg2mhdebugmask[Op_RegD] = NULL; idealreg2mhdebugmask[Op_RegP] = NULL; + idealreg2mhdebugmask[Op_VecS] = NULL; + idealreg2mhdebugmask[Op_VecD] = NULL; + idealreg2mhdebugmask[Op_VecX] = NULL; + idealreg2mhdebugmask[Op_VecY] = NULL; debug_only(_mem_node = NULL;) // Ideal memory node consumed by mach node } @@ -134,7 +135,7 @@ OptoReg::Name Matcher::warp_incoming_stk_arg( VMReg reg ) { warped = OptoReg::add(warped, C->out_preserve_stack_slots()); if( warped >= _in_arg_limit ) _in_arg_limit = OptoReg::add(warped, 1); // Bump max stack slot seen - if (!RegMask::can_represent(warped)) { + if (!RegMask::can_represent_arg(warped)) { // the compiler cannot represent this method's calling sequence C->record_method_not_compilable_all_tiers("unsupported incoming calling sequence"); return OptoReg::Bad; @@ -302,7 +303,7 @@ void Matcher::match( ) { _out_arg_limit = OptoReg::add(_new_SP, C->out_preserve_stack_slots()); assert( is_even(_out_arg_limit), "out_preserve must be even" ); - if (!RegMask::can_represent(OptoReg::add(_out_arg_limit,-1))) { + if (!RegMask::can_represent_arg(OptoReg::add(_out_arg_limit,-1))) { // the compiler cannot represent this method's calling sequence C->record_method_not_compilable("must be able to represent all call arguments in reg mask"); } @@ -428,7 +429,7 @@ static RegMask *init_input_masks( uint size, RegMask &ret_adr, RegMask &fp ) { void Matcher::init_first_stack_mask() { // Allocate storage for spill masks as masks for the appropriate load type. - RegMask *rms = (RegMask*)C->comp_arena()->Amalloc_D(sizeof(RegMask) * 3*6); + RegMask *rms = (RegMask*)C->comp_arena()->Amalloc_D(sizeof(RegMask) * (3*6+4)); idealreg2spillmask [Op_RegN] = &rms[0]; idealreg2spillmask [Op_RegI] = &rms[1]; @@ -451,6 +452,11 @@ void Matcher::init_first_stack_mask() { idealreg2mhdebugmask[Op_RegD] = &rms[16]; idealreg2mhdebugmask[Op_RegP] = &rms[17]; + idealreg2spillmask [Op_VecS] = &rms[18]; + idealreg2spillmask [Op_VecD] = &rms[19]; + idealreg2spillmask [Op_VecX] = &rms[20]; + idealreg2spillmask [Op_VecY] = &rms[21]; + OptoReg::Name i; // At first, start with the empty mask @@ -462,7 +468,7 @@ void Matcher::init_first_stack_mask() { C->FIRST_STACK_mask().Insert(i); // Add in all bits past the outgoing argument area - guarantee(RegMask::can_represent(OptoReg::add(_out_arg_limit,-1)), + guarantee(RegMask::can_represent_arg(OptoReg::add(_out_arg_limit,-1)), "must be able to represent all call arguments in reg mask"); init = _out_arg_limit; for (i = init; RegMask::can_represent(i); i = OptoReg::add(i,1)) @@ -472,21 +478,48 @@ void Matcher::init_first_stack_mask() { C->FIRST_STACK_mask().set_AllStack(); // Make spill masks. Registers for their class, plus FIRST_STACK_mask. + RegMask aligned_stack_mask = C->FIRST_STACK_mask(); + // Keep spill masks aligned. + aligned_stack_mask.clear_to_pairs(); + assert(aligned_stack_mask.is_AllStack(), "should be infinite stack"); + + *idealreg2spillmask[Op_RegP] = *idealreg2regmask[Op_RegP]; #ifdef _LP64 *idealreg2spillmask[Op_RegN] = *idealreg2regmask[Op_RegN]; idealreg2spillmask[Op_RegN]->OR(C->FIRST_STACK_mask()); + idealreg2spillmask[Op_RegP]->OR(aligned_stack_mask); +#else + idealreg2spillmask[Op_RegP]->OR(C->FIRST_STACK_mask()); #endif *idealreg2spillmask[Op_RegI] = *idealreg2regmask[Op_RegI]; idealreg2spillmask[Op_RegI]->OR(C->FIRST_STACK_mask()); *idealreg2spillmask[Op_RegL] = *idealreg2regmask[Op_RegL]; - idealreg2spillmask[Op_RegL]->OR(C->FIRST_STACK_mask()); + idealreg2spillmask[Op_RegL]->OR(aligned_stack_mask); *idealreg2spillmask[Op_RegF] = *idealreg2regmask[Op_RegF]; idealreg2spillmask[Op_RegF]->OR(C->FIRST_STACK_mask()); *idealreg2spillmask[Op_RegD] = *idealreg2regmask[Op_RegD]; - idealreg2spillmask[Op_RegD]->OR(C->FIRST_STACK_mask()); - *idealreg2spillmask[Op_RegP] = *idealreg2regmask[Op_RegP]; - idealreg2spillmask[Op_RegP]->OR(C->FIRST_STACK_mask()); + idealreg2spillmask[Op_RegD]->OR(aligned_stack_mask); + if (Matcher::vector_size_supported(T_BYTE,4)) { + *idealreg2spillmask[Op_VecS] = *idealreg2regmask[Op_VecS]; + idealreg2spillmask[Op_VecS]->OR(C->FIRST_STACK_mask()); + } + if (Matcher::vector_size_supported(T_FLOAT,2)) { + *idealreg2spillmask[Op_VecD] = *idealreg2regmask[Op_VecD]; + idealreg2spillmask[Op_VecD]->OR(aligned_stack_mask); + } + if (Matcher::vector_size_supported(T_FLOAT,4)) { + aligned_stack_mask.clear_to_sets(RegMask::SlotsPerVecX); + assert(aligned_stack_mask.is_AllStack(), "should be infinite stack"); + *idealreg2spillmask[Op_VecX] = *idealreg2regmask[Op_VecX]; + idealreg2spillmask[Op_VecX]->OR(aligned_stack_mask); + } + if (Matcher::vector_size_supported(T_FLOAT,8)) { + aligned_stack_mask.clear_to_sets(RegMask::SlotsPerVecY); + assert(aligned_stack_mask.is_AllStack(), "should be infinite stack"); + *idealreg2spillmask[Op_VecY] = *idealreg2regmask[Op_VecY]; + idealreg2spillmask[Op_VecY]->OR(aligned_stack_mask); + } if (UseFPUForSpilling) { // This mask logic assumes that the spill operations are // symmetric and that the registers involved are the same size. @@ -807,6 +840,25 @@ void Matcher::init_spill_mask( Node *ret ) { idealreg2regmask[Op_RegF] = &spillF->out_RegMask(); idealreg2regmask[Op_RegD] = &spillD->out_RegMask(); idealreg2regmask[Op_RegP] = &spillP->out_RegMask(); + + // Vector regmasks. + if (Matcher::vector_size_supported(T_BYTE,4)) { + TypeVect::VECTS = TypeVect::make(T_BYTE, 4); + MachNode *spillVectS = match_tree(new (C, 3) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTS)); + idealreg2regmask[Op_VecS] = &spillVectS->out_RegMask(); + } + if (Matcher::vector_size_supported(T_FLOAT,2)) { + MachNode *spillVectD = match_tree(new (C, 3) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTD)); + idealreg2regmask[Op_VecD] = &spillVectD->out_RegMask(); + } + if (Matcher::vector_size_supported(T_FLOAT,4)) { + MachNode *spillVectX = match_tree(new (C, 3) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTX)); + idealreg2regmask[Op_VecX] = &spillVectX->out_RegMask(); + } + if (Matcher::vector_size_supported(T_FLOAT,8)) { + MachNode *spillVectY = match_tree(new (C, 3) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTY)); + idealreg2regmask[Op_VecY] = &spillVectY->out_RegMask(); + } } #ifdef ASSERT @@ -1063,7 +1115,7 @@ OptoReg::Name Matcher::warp_outgoing_stk_arg( VMReg reg, OptoReg::Name begin_out // that is killed by the call. if( warped >= out_arg_limit_per_call ) out_arg_limit_per_call = OptoReg::add(warped,1); - if (!RegMask::can_represent(warped)) { + if (!RegMask::can_represent_arg(warped)) { C->record_method_not_compilable_all_tiers("unsupported calling sequence"); return OptoReg::Bad; } @@ -1251,7 +1303,7 @@ MachNode *Matcher::match_sfpt( SafePointNode *sfpt ) { // this killed area. uint r_cnt = mcall->tf()->range()->cnt(); MachProjNode *proj = new (C, 1) MachProjNode( mcall, r_cnt+10000, RegMask::Empty, MachProjNode::fat_proj ); - if (!RegMask::can_represent(OptoReg::Name(out_arg_limit_per_call-1))) { + if (!RegMask::can_represent_arg(OptoReg::Name(out_arg_limit_per_call-1))) { C->record_method_not_compilable_all_tiers("unsupported outgoing calling sequence"); } else { for (int i = begin_out_arg_area; i < out_arg_limit_per_call; i++) diff --git a/hotspot/src/share/vm/opto/matcher.hpp b/hotspot/src/share/vm/opto/matcher.hpp index e6aae28b317..0597cb54345 100644 --- a/hotspot/src/share/vm/opto/matcher.hpp +++ b/hotspot/src/share/vm/opto/matcher.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -250,10 +250,21 @@ public: static const bool convL2FSupported(void); // Vector width in bytes - static const uint vector_width_in_bytes(void); + static const int vector_width_in_bytes(BasicType bt); + + // Limits on vector size (number of elements). + static const int max_vector_size(const BasicType bt); + static const int min_vector_size(const BasicType bt); + static const bool vector_size_supported(const BasicType bt, int size) { + return (Matcher::max_vector_size(bt) >= size && + Matcher::min_vector_size(bt) <= size); + } // Vector ideal reg - static const uint vector_ideal_reg(void); + static const int vector_ideal_reg(int len); + + // CPU supports misaligned vectors store/load. + static const bool misaligned_vectors_ok(); // Used to determine a "low complexity" 64-bit constant. (Zero is simple.) // The standard of comparison is one (StoreL ConL) vs. two (StoreI ConI). diff --git a/hotspot/src/share/vm/opto/memnode.cpp b/hotspot/src/share/vm/opto/memnode.cpp index e28e09226ad..799c2ba14d0 100644 --- a/hotspot/src/share/vm/opto/memnode.cpp +++ b/hotspot/src/share/vm/opto/memnode.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -1543,6 +1543,7 @@ const Type *LoadNode::Value( PhaseTransform *phase ) const { // had an original form like p1:(AddP x x (LShiftL quux 3)), where the // expression (LShiftL quux 3) independently optimized to the constant 8. if ((t->isa_int() == NULL) && (t->isa_long() == NULL) + && (_type->isa_vect() == NULL) && Opcode() != Op_LoadKlass && Opcode() != Op_LoadNKlass) { // t might actually be lower than _type, if _type is a unique // concrete subclass of abstract class t. diff --git a/hotspot/src/share/vm/opto/mulnode.hpp b/hotspot/src/share/vm/opto/mulnode.hpp index 11cc77145a5..c3adc433fda 100644 --- a/hotspot/src/share/vm/opto/mulnode.hpp +++ b/hotspot/src/share/vm/opto/mulnode.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -41,7 +41,9 @@ class PhaseTransform; class MulNode : public Node { virtual uint hash() const; public: - MulNode( Node *in1, Node *in2 ): Node(0,in1,in2) {} + MulNode( Node *in1, Node *in2 ): Node(0,in1,in2) { + init_class_id(Class_Mul); + } // Handle algebraic identities here. If we have an identity, return the Node // we are equivalent to. We look for "add of zero" as an identity. diff --git a/hotspot/src/share/vm/opto/node.cpp b/hotspot/src/share/vm/opto/node.cpp index 4bd752feda5..2cb44ad0e55 100644 --- a/hotspot/src/share/vm/opto/node.cpp +++ b/hotspot/src/share/vm/opto/node.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -1576,6 +1576,9 @@ void Node::dump() const { } else { tty->print("no type"); } + } else if (t->isa_vect() && this->is_MachSpillCopy()) { + // Dump MachSpillcopy vector type. + t->dump(); } if (is_new) { debug_only(dump_orig(debug_orig())); diff --git a/hotspot/src/share/vm/opto/node.hpp b/hotspot/src/share/vm/opto/node.hpp index 5ddae2f0b19..f63a967b6f2 100644 --- a/hotspot/src/share/vm/opto/node.hpp +++ b/hotspot/src/share/vm/opto/node.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -100,6 +100,7 @@ class MemBarNode; class MemBarStoreStoreNode; class MemNode; class MergeMemNode; +class MulNode; class MultiNode; class MultiBranchNode; class NeverBranchNode; @@ -133,8 +134,8 @@ class Type; class TypeNode; class UnlockNode; class VectorNode; -class VectorLoadNode; -class VectorStoreNode; +class LoadVectorNode; +class StoreVectorNode; class VectorSet; typedef void (*NFunc)(Node&,void*); extern "C" { @@ -609,9 +610,9 @@ public: DEFINE_CLASS_ID(Mem, Node, 4) DEFINE_CLASS_ID(Load, Mem, 0) - DEFINE_CLASS_ID(VectorLoad, Load, 0) + DEFINE_CLASS_ID(LoadVector, Load, 0) DEFINE_CLASS_ID(Store, Mem, 1) - DEFINE_CLASS_ID(VectorStore, Store, 0) + DEFINE_CLASS_ID(StoreVector, Store, 0) DEFINE_CLASS_ID(LoadStore, Mem, 2) DEFINE_CLASS_ID(Region, Node, 5) @@ -629,8 +630,9 @@ public: DEFINE_CLASS_ID(AddP, Node, 9) DEFINE_CLASS_ID(BoxLock, Node, 10) DEFINE_CLASS_ID(Add, Node, 11) - DEFINE_CLASS_ID(Vector, Node, 12) - DEFINE_CLASS_ID(ClearArray, Node, 13) + DEFINE_CLASS_ID(Mul, Node, 12) + DEFINE_CLASS_ID(Vector, Node, 13) + DEFINE_CLASS_ID(ClearArray, Node, 14) _max_classes = ClassMask_ClearArray }; @@ -752,6 +754,7 @@ public: DEFINE_CLASS_QUERY(MemBar) DEFINE_CLASS_QUERY(MemBarStoreStore) DEFINE_CLASS_QUERY(MergeMem) + DEFINE_CLASS_QUERY(Mul) DEFINE_CLASS_QUERY(Multi) DEFINE_CLASS_QUERY(MultiBranch) DEFINE_CLASS_QUERY(Parm) @@ -767,8 +770,8 @@ public: DEFINE_CLASS_QUERY(Sub) DEFINE_CLASS_QUERY(Type) DEFINE_CLASS_QUERY(Vector) - DEFINE_CLASS_QUERY(VectorLoad) - DEFINE_CLASS_QUERY(VectorStore) + DEFINE_CLASS_QUERY(LoadVector) + DEFINE_CLASS_QUERY(StoreVector) DEFINE_CLASS_QUERY(Unlock) #undef DEFINE_CLASS_QUERY diff --git a/hotspot/src/share/vm/opto/opcodes.cpp b/hotspot/src/share/vm/opto/opcodes.cpp index 58489db0adb..83310568b50 100644 --- a/hotspot/src/share/vm/opto/opcodes.cpp +++ b/hotspot/src/share/vm/opto/opcodes.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -38,6 +38,10 @@ const char *NodeClassNames[] = { "RegD", "RegL", "RegFlags", + "VecS", + "VecD", + "VecX", + "VecY", "_last_machine_leaf", #include "classes.hpp" "_last_class_name", diff --git a/hotspot/src/share/vm/opto/opcodes.hpp b/hotspot/src/share/vm/opto/opcodes.hpp index 9eb5b8a7ccc..4baec83feca 100644 --- a/hotspot/src/share/vm/opto/opcodes.hpp +++ b/hotspot/src/share/vm/opto/opcodes.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -36,6 +36,10 @@ enum Opcodes { macro(RegF) // Machine float register macro(RegD) // Machine double register macro(RegL) // Machine long register + macro(VecS) // Machine vectors register + macro(VecD) // Machine vectord register + macro(VecX) // Machine vectorx register + macro(VecY) // Machine vectory register macro(RegFlags) // Machine flags register _last_machine_leaf, // Split between regular opcodes and machine #include "classes.hpp" diff --git a/hotspot/src/share/vm/opto/postaloc.cpp b/hotspot/src/share/vm/opto/postaloc.cpp index 1a7553bc5cd..8e24d353d8d 100644 --- a/hotspot/src/share/vm/opto/postaloc.cpp +++ b/hotspot/src/share/vm/opto/postaloc.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,13 +27,15 @@ #include "opto/chaitin.hpp" #include "opto/machnode.hpp" -// see if this register kind does not requires two registers -static bool is_single_register(uint x) { -#ifdef _LP64 - return (x != Op_RegD && x != Op_RegL && x != Op_RegP); -#else - return (x != Op_RegD && x != Op_RegL); -#endif +// See if this register (or pairs, or vector) already contains the value. +static bool register_contains_value(Node* val, OptoReg::Name reg, int n_regs, + Node_List& value) { + for (int i = 0; i < n_regs; i++) { + OptoReg::Name nreg = OptoReg::add(reg,-i); + if (value[nreg] != val) + return false; + } + return true; } //---------------------------may_be_copy_of_callee----------------------------- @@ -167,9 +169,11 @@ int PhaseChaitin::use_prior_register( Node *n, uint idx, Node *def, Block *curre const RegMask &use_mask = n->in_RegMask(idx); bool can_use = ( RegMask::can_represent(def_reg) ? (use_mask.Member(def_reg) != 0) : (use_mask.is_AllStack() != 0)); - // Check for a copy to or from a misaligned pair. - can_use = can_use && !use_mask.is_misaligned_Pair() && !def_lrg.mask().is_misaligned_Pair(); - + if (!RegMask::is_vector(def->ideal_reg())) { + // Check for a copy to or from a misaligned pair. + // It is workaround for a sparc with misaligned pairs. + can_use = can_use && !use_mask.is_misaligned_pair() && !def_lrg.mask().is_misaligned_pair(); + } if (!can_use) return 0; @@ -263,18 +267,16 @@ int PhaseChaitin::elide_copy( Node *n, int k, Block *current_block, Node_List &v val = skip_copies(n->in(k)); } - if( val == x ) return blk_adjust; // No progress? + if (val == x) return blk_adjust; // No progress? - bool single = is_single_register(val->ideal_reg()); + int n_regs = RegMask::num_registers(val->ideal_reg()); uint val_idx = n2lidx(val); OptoReg::Name val_reg = lrgs(val_idx).reg(); // See if it happens to already be in the correct register! // (either Phi's direct register, or the common case of the name // never-clobbered original-def register) - if( value[val_reg] == val && - // Doubles check both halves - ( single || value[val_reg-1] == val ) ) { + if (register_contains_value(val, val_reg, n_regs, value)) { blk_adjust += use_prior_register(n,k,regnd[val_reg],current_block,value,regnd); if( n->in(k) == regnd[val_reg] ) // Success! Quit trying return blk_adjust; @@ -306,7 +308,7 @@ int PhaseChaitin::elide_copy( Node *n, int k, Block *current_block, Node_List &v } Node *vv = value[reg]; - if( !single ) { // Doubles check for aligned-adjacent pair + if (n_regs > 1) { // Doubles check for aligned-adjacent pair if( (reg&1)==0 ) continue; // Wrong half of a pair if( vv != value[reg-1] ) continue; // Not a complete pair } @@ -526,8 +528,9 @@ void PhaseChaitin::post_allocate_copy_removal() { if( pidx ) { value.map(preg,phi); regnd.map(preg,phi); - OptoReg::Name preg_lo = OptoReg::add(preg,-1); - if( !is_single_register(phi->ideal_reg()) ) { + int n_regs = RegMask::num_registers(phi->ideal_reg()); + for (int l = 1; l < n_regs; l++) { + OptoReg::Name preg_lo = OptoReg::add(preg,-l); value.map(preg_lo,phi); regnd.map(preg_lo,phi); } @@ -568,13 +571,17 @@ void PhaseChaitin::post_allocate_copy_removal() { value.map(ureg,valdef); // record improved reaching-def info regnd.map(ureg, def); // Record other half of doubles - OptoReg::Name ureg_lo = OptoReg::add(ureg,-1); - if( !is_single_register(def->ideal_reg()) && - ( !RegMask::can_represent(ureg_lo) || - lrgs(useidx).mask().Member(ureg_lo) ) && // Nearly always adjacent - !value[ureg_lo] ) { - value.map(ureg_lo,valdef); // record improved reaching-def info - regnd.map(ureg_lo, def); + uint def_ideal_reg = def->ideal_reg(); + int n_regs = RegMask::num_registers(def_ideal_reg); + bool is_vec = RegMask::is_vector(def_ideal_reg); + for (int l = 1; l < n_regs; l++) { + OptoReg::Name ureg_lo = OptoReg::add(ureg,-l); + if (!value[ureg_lo] && + (!RegMask::can_represent(ureg_lo) || + lrgs(useidx).mask().Member(ureg_lo))) { // Nearly always adjacent + value.map(ureg_lo,valdef); // record improved reaching-def info + regnd.map(ureg_lo, def); + } } } } @@ -607,7 +614,8 @@ void PhaseChaitin::post_allocate_copy_removal() { } uint n_ideal_reg = n->ideal_reg(); - if( is_single_register(n_ideal_reg) ) { + int n_regs = RegMask::num_registers(n_ideal_reg); + if (n_regs == 1) { // If Node 'n' does not change the value mapped by the register, // then 'n' is a useless copy. Do not update the register->node // mapping so 'n' will go dead. @@ -625,6 +633,25 @@ void PhaseChaitin::post_allocate_copy_removal() { assert( n->is_Copy(), "" ); j -= replace_and_yank_if_dead(n, nreg, b, value, regnd); } + } else if (RegMask::is_vector(n_ideal_reg)) { + // If Node 'n' does not change the value mapped by the register, + // then 'n' is a useless copy. Do not update the register->node + // mapping so 'n' will go dead. + if (!register_contains_value(val, nreg, n_regs, value)) { + // Update the mapping: record new Node defined by the register + regnd.map(nreg,n); + // Update mapping for defined *value*, which is the defined + // Node after skipping all copies. + value.map(nreg,val); + for (int l = 1; l < n_regs; l++) { + OptoReg::Name nreg_lo = OptoReg::add(nreg,-l); + regnd.map(nreg_lo, n ); + value.map(nreg_lo,val); + } + } else if (n->is_Copy()) { + // Note: vector can't be constant and can't be copy of calee. + j -= replace_and_yank_if_dead(n, nreg, b, value, regnd); + } } else { // If the value occupies a register pair, record same info // in both registers. diff --git a/hotspot/src/share/vm/opto/reg_split.cpp b/hotspot/src/share/vm/opto/reg_split.cpp index 63a11fe8f0f..cae363bea7a 100644 --- a/hotspot/src/share/vm/opto/reg_split.cpp +++ b/hotspot/src/share/vm/opto/reg_split.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -74,12 +74,13 @@ Node *PhaseChaitin::get_spillcopy_wide( Node *def, Node *use, uint uidx ) { const RegMask *w_i_mask = w_mask->overlap( *i_mask ) ? w_mask : i_mask; const RegMask *w_o_mask; + int num_regs = RegMask::num_registers(ireg); + bool is_vect = RegMask::is_vector(ireg); if( w_mask->overlap( *o_mask ) && // Overlap AND - ((ireg != Op_RegL && ireg != Op_RegD // Single use or aligned -#ifdef _LP64 - && ireg != Op_RegP -#endif - ) || o_mask->is_aligned_Pairs()) ) { + ((num_regs == 1) // Single use or aligned + || is_vect // or vector + || !is_vect && o_mask->is_aligned_pairs()) ) { + assert(!is_vect || o_mask->is_aligned_sets(num_regs), "vectors are aligned"); // Don't come here for mis-aligned doubles w_o_mask = w_mask; } else { // wide ideal mask does not overlap with o_mask @@ -400,15 +401,17 @@ bool PhaseChaitin::is_high_pressure( Block *b, LRG *lrg, uint insidx ) { // CNC - Turned off 7/8/99, causes too much spilling // if( lrg->_is_bound ) return false; + // Use float pressure numbers for vectors. + bool is_float_or_vector = lrg->_is_float || lrg->_is_vector; // Not yet reached the high-pressure cutoff point, so low pressure - uint hrp_idx = lrg->_is_float ? b->_fhrp_index : b->_ihrp_index; + uint hrp_idx = is_float_or_vector ? b->_fhrp_index : b->_ihrp_index; if( insidx < hrp_idx ) return false; // Register pressure for the block as a whole depends on reg class - int block_pres = lrg->_is_float ? b->_freg_pressure : b->_reg_pressure; + int block_pres = is_float_or_vector ? b->_freg_pressure : b->_reg_pressure; // Bound live ranges will split at the binding points first; // Intermediate splits should assume the live range's register set // got "freed up" and that num_regs will become INT_PRESSURE. - int bound_pres = lrg->_is_float ? FLOATPRESSURE : INTPRESSURE; + int bound_pres = is_float_or_vector ? FLOATPRESSURE : INTPRESSURE; // Effective register pressure limit. int lrg_pres = (lrg->get_invalid_mask_size() > lrg->num_regs()) ? (lrg->get_invalid_mask_size() >> (lrg->num_regs()-1)) : bound_pres; @@ -794,12 +797,15 @@ uint PhaseChaitin::Split( uint maxlrg ) { if( i < n->req() ) break; insert_point--; } + uint orig_eidx = b->end_idx(); maxlrg = split_DEF( n1, b, insert_point, maxlrg, Reachblock, debug_defs, splits, slidx); // If it wasn't split bail if (!maxlrg) { return 0; } - insidx++; + // Spill of NULL check mem op goes into the following block. + if (b->end_idx() > orig_eidx) + insidx++; } // This is a new DEF, so update UP UPblock[slidx] = false; @@ -960,7 +966,7 @@ uint PhaseChaitin::Split( uint maxlrg ) { // Grab register mask info const RegMask &dmask = def->out_RegMask(); const RegMask &umask = n->in_RegMask(inpidx); - + bool is_vect = RegMask::is_vector(def->ideal_reg()); assert(inpidx < oopoff, "cannot use-split oop map info"); bool dup = UPblock[slidx]; @@ -972,7 +978,7 @@ uint PhaseChaitin::Split( uint maxlrg ) { if( !umask.is_AllStack() && (int)umask.Size() <= lrgs(useidx).num_regs() && (!def->rematerialize() || - umask.is_misaligned_Pair())) { + !is_vect && umask.is_misaligned_pair())) { // These need a Split regardless of overlap or pressure // SPLIT - NO DEF - NO CISC SPILL maxlrg = split_USE(def,b,n,inpidx,maxlrg,dup,false, splits,slidx); @@ -1123,10 +1129,12 @@ uint PhaseChaitin::Split( uint maxlrg ) { // Grab UP info for DEF const RegMask &dmask = n->out_RegMask(); bool defup = dmask.is_UP(); + int ireg = n->ideal_reg(); + bool is_vect = RegMask::is_vector(ireg); // Only split at Def if this is a HRP block or bound (and spilled once) if( !n->rematerialize() && - (((dmask.is_bound1() || dmask.is_bound2() || dmask.is_misaligned_Pair()) && - (deflrg._direct_conflict || deflrg._must_spill)) || + (((dmask.is_bound(ireg) || !is_vect && dmask.is_misaligned_pair()) && + (deflrg._direct_conflict || deflrg._must_spill)) || // Check for LRG being up in a register and we are inside a high // pressure area. Spill it down immediately. (defup && is_high_pressure(b,&deflrg,insidx))) ) { diff --git a/hotspot/src/share/vm/opto/regmask.cpp b/hotspot/src/share/vm/opto/regmask.cpp index ce220f01be9..59413388ca7 100644 --- a/hotspot/src/share/vm/opto/regmask.cpp +++ b/hotspot/src/share/vm/opto/regmask.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -129,11 +129,34 @@ const RegMask RegMask::Empty( 0 ); +//============================================================================= +bool RegMask::is_vector(uint ireg) { + return (ireg == Op_VecS || ireg == Op_VecD || ireg == Op_VecX || ireg == Op_VecY); +} + +int RegMask::num_registers(uint ireg) { + switch(ireg) { + case Op_VecY: + return 8; + case Op_VecX: + return 4; + case Op_VecD: + case Op_RegD: + case Op_RegL: +#ifdef _LP64 + case Op_RegP: +#endif + return 2; + } + // Op_VecS and the rest ideal registers. + return 1; +} + //------------------------------find_first_pair-------------------------------- // Find the lowest-numbered register pair in the mask. Return the // HIGHEST register number in the pair, or BAD if no pairs. OptoReg::Name RegMask::find_first_pair() const { - VerifyPairs(); + verify_pairs(); for( int i = 0; i < RM_SIZE; i++ ) { if( _A[i] ) { // Found some bits int bit = _A[i] & -_A[i]; // Extract low bit @@ -146,30 +169,30 @@ OptoReg::Name RegMask::find_first_pair() const { //------------------------------ClearToPairs----------------------------------- // Clear out partial bits; leave only bit pairs -void RegMask::ClearToPairs() { +void RegMask::clear_to_pairs() { for( int i = 0; i < RM_SIZE; i++ ) { int bits = _A[i]; bits &= ((bits & 0x55555555)<<1); // 1 hi-bit set for each pair bits |= (bits>>1); // Smear 1 hi-bit into a pair _A[i] = bits; } - VerifyPairs(); + verify_pairs(); } //------------------------------SmearToPairs----------------------------------- // Smear out partial bits; leave only bit pairs -void RegMask::SmearToPairs() { +void RegMask::smear_to_pairs() { for( int i = 0; i < RM_SIZE; i++ ) { int bits = _A[i]; bits |= ((bits & 0x55555555)<<1); // Smear lo bit hi per pair bits |= ((bits & 0xAAAAAAAA)>>1); // Smear hi bit lo per pair _A[i] = bits; } - VerifyPairs(); + verify_pairs(); } //------------------------------is_aligned_pairs------------------------------- -bool RegMask::is_aligned_Pairs() const { +bool RegMask::is_aligned_pairs() const { // Assert that the register mask contains only bit pairs. for( int i = 0; i < RM_SIZE; i++ ) { int bits = _A[i]; @@ -204,7 +227,7 @@ int RegMask::is_bound1() const { //------------------------------is_bound2-------------------------------------- // Return TRUE if the mask contains an adjacent pair of bits and no other bits. -int RegMask::is_bound2() const { +int RegMask::is_bound_pair() const { if( is_AllStack() ) return false; int bit = -1; // Set to hold the one bit allowed @@ -226,6 +249,132 @@ int RegMask::is_bound2() const { return true; } +static int low_bits[3] = { 0x55555555, 0x11111111, 0x01010101 }; +//------------------------------find_first_set--------------------------------- +// Find the lowest-numbered register set in the mask. Return the +// HIGHEST register number in the set, or BAD if no sets. +// Works also for size 1. +OptoReg::Name RegMask::find_first_set(int size) const { + verify_sets(size); + for (int i = 0; i < RM_SIZE; i++) { + if (_A[i]) { // Found some bits + int bit = _A[i] & -_A[i]; // Extract low bit + // Convert to bit number, return hi bit in pair + return OptoReg::Name((i<<_LogWordBits)+find_lowest_bit(bit)+(size-1)); + } + } + return OptoReg::Bad; +} + +//------------------------------clear_to_sets---------------------------------- +// Clear out partial bits; leave only aligned adjacent bit pairs +void RegMask::clear_to_sets(int size) { + if (size == 1) return; + assert(2 <= size && size <= 8, "update low bits table"); + assert(is_power_of_2(size), "sanity"); + int low_bits_mask = low_bits[size>>2]; + for (int i = 0; i < RM_SIZE; i++) { + int bits = _A[i]; + int sets = (bits & low_bits_mask); + for (int j = 1; j < size; j++) { + sets = (bits & (sets<<1)); // filter bits which produce whole sets + } + sets |= (sets>>1); // Smear 1 hi-bit into a set + if (size > 2) { + sets |= (sets>>2); // Smear 2 hi-bits into a set + if (size > 4) { + sets |= (sets>>4); // Smear 4 hi-bits into a set + } + } + _A[i] = sets; + } + verify_sets(size); +} + +//------------------------------smear_to_sets---------------------------------- +// Smear out partial bits to aligned adjacent bit sets +void RegMask::smear_to_sets(int size) { + if (size == 1) return; + assert(2 <= size && size <= 8, "update low bits table"); + assert(is_power_of_2(size), "sanity"); + int low_bits_mask = low_bits[size>>2]; + for (int i = 0; i < RM_SIZE; i++) { + int bits = _A[i]; + int sets = 0; + for (int j = 0; j < size; j++) { + sets |= (bits & low_bits_mask); // collect partial bits + bits = bits>>1; + } + sets |= (sets<<1); // Smear 1 lo-bit into a set + if (size > 2) { + sets |= (sets<<2); // Smear 2 lo-bits into a set + if (size > 4) { + sets |= (sets<<4); // Smear 4 lo-bits into a set + } + } + _A[i] = sets; + } + verify_sets(size); +} + +//------------------------------is_aligned_set-------------------------------- +bool RegMask::is_aligned_sets(int size) const { + if (size == 1) return true; + assert(2 <= size && size <= 8, "update low bits table"); + assert(is_power_of_2(size), "sanity"); + int low_bits_mask = low_bits[size>>2]; + // Assert that the register mask contains only bit sets. + for (int i = 0; i < RM_SIZE; i++) { + int bits = _A[i]; + while (bits) { // Check bits for pairing + int bit = bits & -bits; // Extract low bit + // Low bit is not odd means its mis-aligned. + if ((bit & low_bits_mask) == 0) return false; + // Do extra work since (bit << size) may overflow. + int hi_bit = bit << (size-1); // high bit + int set = hi_bit + ((hi_bit-1) & ~(bit-1)); + // Check for aligned adjacent bits in this set + if ((bits & set) != set) return false; + bits -= set; // Remove this set + } + } + return true; +} + +//------------------------------is_bound_set----------------------------------- +// Return TRUE if the mask contains one adjacent set of bits and no other bits. +// Works also for size 1. +int RegMask::is_bound_set(int size) const { + if( is_AllStack() ) return false; + assert(1 <= size && size <= 8, "update low bits table"); + int bit = -1; // Set to hold the one bit allowed + for (int i = 0; i < RM_SIZE; i++) { + if (_A[i] ) { // Found some bits + if (bit != -1) + return false; // Already had bits, so fail + bit = _A[i] & -_A[i]; // Extract 1 bit from mask + int hi_bit = bit << (size-1); // high bit + if (hi_bit != 0) { // Bit set stays in same word? + int set = hi_bit + ((hi_bit-1) & ~(bit-1)); + if (set != _A[i]) + return false; // Require adjacent bit set and no more bits + } else { // Else its a split-set case + if (((-1) & ~(bit-1)) != _A[i]) + return false; // Found many bits, so fail + i++; // Skip iteration forward and check high part + assert(size <= 8, "update next code"); + // The lower 24 bits should be 0 since it is split case and size <= 8. + int set = bit>>24; + set = set & -set; // Remove sign extension. + set = (((set << size) - 1) >> 8); + if (_A[i] != set) return false; // Require 1 lo bit in next word + } + } + } + // True for both the empty mask and for a bit set + return true; +} + //------------------------------is_UP------------------------------------------ // UP means register only, Register plus stack, or stack only is DOWN bool RegMask::is_UP() const { diff --git a/hotspot/src/share/vm/opto/regmask.hpp b/hotspot/src/share/vm/opto/regmask.hpp index e50ff84ca16..e4c31dcefb2 100644 --- a/hotspot/src/share/vm/opto/regmask.hpp +++ b/hotspot/src/share/vm/opto/regmask.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -113,7 +113,11 @@ public: // the controlling alignment constraint. Note that this alignment // requirement is internal to the allocator, and independent of any // particular platform. - enum { SlotsPerLong = 2 }; + enum { SlotsPerLong = 2, + SlotsPerVecS = 1, + SlotsPerVecD = 2, + SlotsPerVecX = 4, + SlotsPerVecY = 8 }; // A constructor only used by the ADLC output. All mask fields are filled // in directly. Calls to this look something like RM(1,2,3,4); @@ -193,20 +197,53 @@ public: OptoReg::Name find_first_pair() const; // Clear out partial bits; leave only aligned adjacent bit pairs. - void ClearToPairs(); + void clear_to_pairs(); // Smear out partial bits; leave only aligned adjacent bit pairs. - void SmearToPairs(); + void smear_to_pairs(); // Verify that the mask contains only aligned adjacent bit pairs - void VerifyPairs() const { assert( is_aligned_Pairs(), "mask is not aligned, adjacent pairs" ); } + void verify_pairs() const { assert( is_aligned_pairs(), "mask is not aligned, adjacent pairs" ); } // Test that the mask contains only aligned adjacent bit pairs - bool is_aligned_Pairs() const; + bool is_aligned_pairs() const; // mask is a pair of misaligned registers - bool is_misaligned_Pair() const { return Size()==2 && !is_aligned_Pairs();} + bool is_misaligned_pair() const { return Size()==2 && !is_aligned_pairs(); } // Test for single register int is_bound1() const; // Test for a single adjacent pair - int is_bound2() const; + int is_bound_pair() const; + // Test for a single adjacent set of ideal register's size. + int is_bound(uint ireg) const { + if (is_vector(ireg)) { + if (is_bound_set(num_registers(ireg))) + return true; + } else if (is_bound1() || is_bound_pair()) { + return true; + } + return false; + } + + // Find the lowest-numbered register set in the mask. Return the + // HIGHEST register number in the set, or BAD if no sets. + // Assert that the mask contains only bit sets. + OptoReg::Name find_first_set(int size) const; + + // Clear out partial bits; leave only aligned adjacent bit sets of size. + void clear_to_sets(int size); + // Smear out partial bits to aligned adjacent bit sets. + void smear_to_sets(int size); + // Verify that the mask contains only aligned adjacent bit sets + void verify_sets(int size) const { assert(is_aligned_sets(size), "mask is not aligned, adjacent sets"); } + // Test that the mask contains only aligned adjacent bit sets + bool is_aligned_sets(int size) const; + + // mask is a set of misaligned registers + bool is_misaligned_set(int size) const { return (int)Size()==size && !is_aligned_sets(size);} + + // Test for a single adjacent set + int is_bound_set(int size) const; + + static bool is_vector(uint ireg); + static int num_registers(uint ireg); // Fast overlap test. Non-zero if any registers in common. int overlap( const RegMask &rm ) const { @@ -280,9 +317,15 @@ public: static bool can_represent(OptoReg::Name reg) { // NOTE: -1 in computation reflects the usage of the last - // bit of the regmask as an infinite stack flag. + // bit of the regmask as an infinite stack flag and + // -7 is to keep mask aligned for largest value (VecY). return (int)reg < (int)(CHUNK_SIZE-1); } + static bool can_represent_arg(OptoReg::Name reg) { + // NOTE: -SlotsPerVecY in computation reflects the need + // to keep mask aligned for largest value (VecY). + return (int)reg < (int)(CHUNK_SIZE-SlotsPerVecY); + } }; // Do not use this constant directly in client code! diff --git a/hotspot/src/share/vm/opto/superword.cpp b/hotspot/src/share/vm/opto/superword.cpp index ae46e7f17c8..78db4b5ba16 100644 --- a/hotspot/src/share/vm/opto/superword.cpp +++ b/hotspot/src/share/vm/opto/superword.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -67,6 +67,10 @@ SuperWord::SuperWord(PhaseIdealLoop* phase) : //------------------------------transform_loop--------------------------- void SuperWord::transform_loop(IdealLoopTree* lpt) { + assert(UseSuperWord, "should be"); + // Do vectors exist on this architecture? + if (Matcher::vector_width_in_bytes(T_BYTE) < 2) return; + assert(lpt->_head->is_CountedLoop(), "must be"); CountedLoopNode *cl = lpt->_head->as_CountedLoop(); @@ -89,15 +93,12 @@ void SuperWord::transform_loop(IdealLoopTree* lpt) { Node *pre_opaq1 = pre_end->limit(); if (pre_opaq1->Opcode() != Op_Opaque1) return; - // Do vectors exist on this architecture? - if (vector_width_in_bytes() == 0) return; - init(); // initialize data structures set_lpt(lpt); set_lp(cl); - // For now, define one block which is the entire loop body + // For now, define one block which is the entire loop body set_bb(cl); assert(_packset.length() == 0, "packset must be empty"); @@ -177,7 +178,7 @@ void SuperWord::find_adjacent_refs() { Node_List memops; for (int i = 0; i < _block.length(); i++) { Node* n = _block.at(i); - if (n->is_Mem() && in_bb(n) && + if (n->is_Mem() && !n->is_LoadStore() && in_bb(n) && is_java_primitive(n->as_Mem()->memory_type())) { int align = memory_alignment(n->as_Mem(), 0); if (align != bottom_align) { @@ -185,54 +186,130 @@ void SuperWord::find_adjacent_refs() { } } } - if (memops.size() == 0) return; - // Find a memory reference to align to. The pre-loop trip count - // is modified to align this reference to a vector-aligned address - find_align_to_ref(memops); - if (align_to_ref() == NULL) return; + Node_List align_to_refs; + int best_iv_adjustment = 0; + MemNode* best_align_to_mem_ref = NULL; - SWPointer align_to_ref_p(align_to_ref(), this); - int offset = align_to_ref_p.offset_in_bytes(); - int scale = align_to_ref_p.scale_in_bytes(); - int vw = vector_width_in_bytes(); - int stride_sign = (scale * iv_stride()) > 0 ? 1 : -1; - int iv_adjustment = (stride_sign * vw - (offset % vw)) % vw; + while (memops.size() != 0) { + // Find a memory reference to align to. + MemNode* mem_ref = find_align_to_ref(memops); + if (mem_ref == NULL) break; + align_to_refs.push(mem_ref); + int iv_adjustment = get_iv_adjustment(mem_ref); -#ifndef PRODUCT - if (TraceSuperWord) - tty->print_cr("\noffset = %d iv_adjustment = %d elt_align = %d scale = %d iv_stride = %d", - offset, iv_adjustment, align_to_ref_p.memory_size(), align_to_ref_p.scale_in_bytes(), iv_stride()); -#endif - - // Set alignment relative to "align_to_ref" - for (int i = memops.size() - 1; i >= 0; i--) { - MemNode* s = memops.at(i)->as_Mem(); - SWPointer p2(s, this); - if (p2.comparable(align_to_ref_p)) { - int align = memory_alignment(s, iv_adjustment); - set_alignment(s, align); - } else { - memops.remove(i); + if (best_align_to_mem_ref == NULL) { + // Set memory reference which is the best from all memory operations + // to be used for alignment. The pre-loop trip count is modified to align + // this reference to a vector-aligned address. + best_align_to_mem_ref = mem_ref; + best_iv_adjustment = iv_adjustment; } - } - // Create initial pack pairs of memory operations - for (uint i = 0; i < memops.size(); i++) { - Node* s1 = memops.at(i); - for (uint j = 0; j < memops.size(); j++) { - Node* s2 = memops.at(j); - if (s1 != s2 && are_adjacent_refs(s1, s2)) { - int align = alignment(s1); - if (stmts_can_pack(s1, s2, align)) { - Node_List* pair = new Node_List(); - pair->push(s1); - pair->push(s2); - _packset.append(pair); + SWPointer align_to_ref_p(mem_ref, this); + // Set alignment relative to "align_to_ref" for all related memory operations. + for (int i = memops.size() - 1; i >= 0; i--) { + MemNode* s = memops.at(i)->as_Mem(); + if (isomorphic(s, mem_ref)) { + SWPointer p2(s, this); + if (p2.comparable(align_to_ref_p)) { + int align = memory_alignment(s, iv_adjustment); + set_alignment(s, align); } } } - } + + // Create initial pack pairs of memory operations for which + // alignment is set and vectors will be aligned. + bool create_pack = true; + if (memory_alignment(mem_ref, best_iv_adjustment) != 0) { + if (same_velt_type(mem_ref, best_align_to_mem_ref)) { + // Can't allow vectorization of unaligned memory accesses with the + // same type since it could be overlapped accesses to the same array. + create_pack = false; + } else { + // Allow independent (different type) unaligned memory operations + // if HW supports them. + if (!Matcher::misaligned_vectors_ok()) { + create_pack = false; + } else { + // Check if packs of the same memory type but + // with a different alignment were created before. + for (uint i = 0; i < align_to_refs.size(); i++) { + MemNode* mr = align_to_refs.at(i)->as_Mem(); + if (same_velt_type(mr, mem_ref) && + memory_alignment(mr, iv_adjustment) != 0) + create_pack = false; + } + } + } + } + if (create_pack) { + for (uint i = 0; i < memops.size(); i++) { + Node* s1 = memops.at(i); + int align = alignment(s1); + if (align == top_align) continue; + for (uint j = 0; j < memops.size(); j++) { + Node* s2 = memops.at(j); + if (alignment(s2) == top_align) continue; + if (s1 != s2 && are_adjacent_refs(s1, s2)) { + if (stmts_can_pack(s1, s2, align)) { + Node_List* pair = new Node_List(); + pair->push(s1); + pair->push(s2); + _packset.append(pair); + } + } + } + } + } else { // Don't create unaligned pack + // First, remove remaining memory ops of the same type from the list. + for (int i = memops.size() - 1; i >= 0; i--) { + MemNode* s = memops.at(i)->as_Mem(); + if (same_velt_type(s, mem_ref)) { + memops.remove(i); + } + } + + // Second, remove already constructed packs of the same type. + for (int i = _packset.length() - 1; i >= 0; i--) { + Node_List* p = _packset.at(i); + MemNode* s = p->at(0)->as_Mem(); + if (same_velt_type(s, mem_ref)) { + remove_pack_at(i); + } + } + + // If needed find the best memory reference for loop alignment again. + if (same_velt_type(mem_ref, best_align_to_mem_ref)) { + // Put memory ops from remaining packs back on memops list for + // the best alignment search. + uint orig_msize = memops.size(); + for (int i = 0; i < _packset.length(); i++) { + Node_List* p = _packset.at(i); + MemNode* s = p->at(0)->as_Mem(); + assert(!same_velt_type(s, mem_ref), "sanity"); + memops.push(s); + } + MemNode* best_align_to_mem_ref = find_align_to_ref(memops); + if (best_align_to_mem_ref == NULL) break; + best_iv_adjustment = get_iv_adjustment(best_align_to_mem_ref); + // Restore list. + while (memops.size() > orig_msize) + (void)memops.pop(); + } + } // unaligned memory accesses + + // Remove used mem nodes. + for (int i = memops.size() - 1; i >= 0; i--) { + MemNode* m = memops.at(i)->as_Mem(); + if (alignment(m) != top_align) { + memops.remove(i); + } + } + + } // while (memops.size() != 0 + set_align_to_ref(best_align_to_mem_ref); #ifndef PRODUCT if (TraceSuperWord) { @@ -246,7 +323,7 @@ void SuperWord::find_adjacent_refs() { // Find a memory reference to align the loop induction variable to. // Looks first at stores then at loads, looking for a memory reference // with the largest number of references similar to it. -void SuperWord::find_align_to_ref(Node_List &memops) { +MemNode* SuperWord::find_align_to_ref(Node_List &memops) { GrowableArray cmp_ct(arena(), memops.size(), memops.size(), 0); // Count number of comparable memory ops @@ -270,20 +347,28 @@ void SuperWord::find_align_to_ref(Node_List &memops) { } } - // Find Store (or Load) with the greatest number of "comparable" references + // Find Store (or Load) with the greatest number of "comparable" references, + // biggest vector size, smallest data size and smallest iv offset. int max_ct = 0; + int max_vw = 0; int max_idx = -1; int min_size = max_jint; int min_iv_offset = max_jint; for (uint j = 0; j < memops.size(); j++) { MemNode* s = memops.at(j)->as_Mem(); if (s->is_Store()) { + int vw = vector_width_in_bytes(velt_basic_type(s)); + assert(vw > 1, "sanity"); SWPointer p(s, this); - if (cmp_ct.at(j) > max_ct || - cmp_ct.at(j) == max_ct && (data_size(s) < min_size || - data_size(s) == min_size && - p.offset_in_bytes() < min_iv_offset)) { + if (cmp_ct.at(j) > max_ct || + cmp_ct.at(j) == max_ct && + (vw > max_vw || + vw == max_vw && + (data_size(s) < min_size || + data_size(s) == min_size && + (p.offset_in_bytes() < min_iv_offset)))) { max_ct = cmp_ct.at(j); + max_vw = vw; max_idx = j; min_size = data_size(s); min_iv_offset = p.offset_in_bytes(); @@ -295,12 +380,18 @@ void SuperWord::find_align_to_ref(Node_List &memops) { for (uint j = 0; j < memops.size(); j++) { MemNode* s = memops.at(j)->as_Mem(); if (s->is_Load()) { + int vw = vector_width_in_bytes(velt_basic_type(s)); + assert(vw > 1, "sanity"); SWPointer p(s, this); - if (cmp_ct.at(j) > max_ct || - cmp_ct.at(j) == max_ct && (data_size(s) < min_size || - data_size(s) == min_size && - p.offset_in_bytes() < min_iv_offset)) { + if (cmp_ct.at(j) > max_ct || + cmp_ct.at(j) == max_ct && + (vw > max_vw || + vw == max_vw && + (data_size(s) < min_size || + data_size(s) == min_size && + (p.offset_in_bytes() < min_iv_offset)))) { max_ct = cmp_ct.at(j); + max_vw = vw; max_idx = j; min_size = data_size(s); min_iv_offset = p.offset_in_bytes(); @@ -309,10 +400,7 @@ void SuperWord::find_align_to_ref(Node_List &memops) { } } - if (max_ct > 0) - set_align_to_ref(memops.at(max_idx)->as_Mem()); - -#ifndef PRODUCT +#ifdef ASSERT if (TraceSuperWord && Verbose) { tty->print_cr("\nVector memops after find_align_to_refs"); for (uint i = 0; i < memops.size(); i++) { @@ -321,6 +409,17 @@ void SuperWord::find_align_to_ref(Node_List &memops) { } } #endif + + if (max_ct > 0) { +#ifdef ASSERT + if (TraceSuperWord) { + tty->print("\nVector align to node: "); + memops.at(max_idx)->as_Mem()->dump(); + } +#endif + return memops.at(max_idx)->as_Mem(); + } + return NULL; } //------------------------------ref_is_alignable--------------------------- @@ -341,7 +440,9 @@ bool SuperWord::ref_is_alignable(SWPointer& p) { // If initial offset from start of object is computable, // compute alignment within the vector. - int vw = vector_width_in_bytes(); + BasicType bt = velt_basic_type(p.mem()); + int vw = vector_width_in_bytes(bt); + assert(vw > 1, "sanity"); if (vw % span == 0) { Node* init_nd = pre_end->init_trip(); if (init_nd->is_Con() && p.invar() == NULL) { @@ -361,6 +462,26 @@ bool SuperWord::ref_is_alignable(SWPointer& p) { return false; } +//---------------------------get_iv_adjustment--------------------------- +// Calculate loop's iv adjustment for this memory ops. +int SuperWord::get_iv_adjustment(MemNode* mem_ref) { + SWPointer align_to_ref_p(mem_ref, this); + int offset = align_to_ref_p.offset_in_bytes(); + int scale = align_to_ref_p.scale_in_bytes(); + BasicType bt = velt_basic_type(mem_ref); + int vw = vector_width_in_bytes(bt); + assert(vw > 1, "sanity"); + int stride_sign = (scale * iv_stride()) > 0 ? 1 : -1; + int iv_adjustment = (stride_sign * vw - (offset % vw)) % vw; + +#ifndef PRODUCT + if (TraceSuperWord) + tty->print_cr("\noffset = %d iv_adjust = %d elt_size = %d scale = %d iv_stride = %d vect_size %d", + offset, iv_adjustment, align_to_ref_p.memory_size(), scale, iv_stride(), vw); +#endif + return iv_adjustment; +} + //---------------------------dependence_graph--------------------------- // Construct dependency graph. // Add dependence edges to load/store nodes for memory dependence @@ -488,9 +609,13 @@ void SuperWord::mem_slice_preds(Node* start, Node* stop, GrowableArray &p bool SuperWord::stmts_can_pack(Node* s1, Node* s2, int align) { // Do not use superword for non-primitives - if((s1->is_Mem() && !is_java_primitive(s1->as_Mem()->memory_type())) || - (s2->is_Mem() && !is_java_primitive(s2->as_Mem()->memory_type()))) + BasicType bt1 = velt_basic_type(s1); + BasicType bt2 = velt_basic_type(s2); + if(!is_java_primitive(bt1) || !is_java_primitive(bt2)) return false; + if (Matcher::max_vector_size(bt1) < 2) { + return false; // No vectors for this type + } if (isomorphic(s1, s2)) { if (independent(s1, s2)) { @@ -552,7 +677,7 @@ bool SuperWord::isomorphic(Node* s1, Node* s2) { if (s1->Opcode() != s2->Opcode()) return false; if (s1->req() != s2->req()) return false; if (s1->in(0) != s2->in(0)) return false; - if (velt_type(s1) != velt_type(s2)) return false; + if (!same_velt_type(s1, s2)) return false; return true; } @@ -595,14 +720,16 @@ bool SuperWord::independent_path(Node* shallow, Node* deep, uint dp) { //------------------------------set_alignment--------------------------- void SuperWord::set_alignment(Node* s1, Node* s2, int align) { set_alignment(s1, align); - set_alignment(s2, align + data_size(s1)); + if (align == top_align || align == bottom_align) { + set_alignment(s2, align); + } else { + set_alignment(s2, align + data_size(s1)); + } } //------------------------------data_size--------------------------- int SuperWord::data_size(Node* s) { - const Type* t = velt_type(s); - BasicType bt = t->array_element_basic_type(); - int bsize = type2aelembytes(bt); + int bsize = type2aelembytes(velt_basic_type(s)); assert(bsize != 0, "valid size"); return bsize; } @@ -631,9 +758,9 @@ void SuperWord::extend_packlist() { //------------------------------follow_use_defs--------------------------- // Extend the packset by visiting operand definitions of nodes in pack p bool SuperWord::follow_use_defs(Node_List* p) { + assert(p->size() == 2, "just checking"); Node* s1 = p->at(0); Node* s2 = p->at(1); - assert(p->size() == 2, "just checking"); assert(s1->req() == s2->req(), "just checking"); assert(alignment(s1) + data_size(s1) == alignment(s2), "just checking"); @@ -718,7 +845,12 @@ bool SuperWord::opnd_positions_match(Node* d1, Node* u1, Node* d2, Node* u2) { for (i1++; i1 < ct; i1++) if (u1->in(i1) == d1) break; for (i2++; i2 < ct; i2++) if (u2->in(i2) == d2) break; if (i1 != i2) { - return false; + if ((i1 == (3-i2)) && (u2->is_Add() || u2->is_Mul())) { + // Further analysis relies on operands position matching. + u2->swap_edges(i1, i2); + } else { + return false; + } } } while (i1 < ct); return true; @@ -727,7 +859,7 @@ bool SuperWord::opnd_positions_match(Node* d1, Node* u1, Node* d2, Node* u2) { //------------------------------est_savings--------------------------- // Estimate the savings from executing s1 and s2 as a pack int SuperWord::est_savings(Node* s1, Node* s2) { - int save = 2 - 1; // 2 operations per instruction in packed form + int save_in = 2 - 1; // 2 operations per instruction in packed form // inputs for (uint i = 1; i < s1->req(); i++) { @@ -735,17 +867,18 @@ int SuperWord::est_savings(Node* s1, Node* s2) { Node* x2 = s2->in(i); if (x1 != x2) { if (are_adjacent_refs(x1, x2)) { - save += adjacent_profit(x1, x2); + save_in += adjacent_profit(x1, x2); } else if (!in_packset(x1, x2)) { - save -= pack_cost(2); + save_in -= pack_cost(2); } else { - save += unpack_cost(2); + save_in += unpack_cost(2); } } } // uses of result uint ct = 0; + int save_use = 0; for (DUIterator_Fast imax, i = s1->fast_outs(imax); i < imax; i++) { Node* s1_use = s1->fast_out(i); for (int j = 0; j < _packset.length(); j++) { @@ -756,7 +889,7 @@ int SuperWord::est_savings(Node* s1, Node* s2) { if (p->at(p->size()-1) == s2_use) { ct++; if (are_adjacent_refs(s1_use, s2_use)) { - save += adjacent_profit(s1_use, s2_use); + save_use += adjacent_profit(s1_use, s2_use); } } } @@ -764,10 +897,10 @@ int SuperWord::est_savings(Node* s1, Node* s2) { } } - if (ct < s1->outcnt()) save += unpack_cost(1); - if (ct < s2->outcnt()) save += unpack_cost(1); + if (ct < s1->outcnt()) save_use += unpack_cost(1); + if (ct < s2->outcnt()) save_use += unpack_cost(1); - return save; + return MAX2(save_in, save_use); } //------------------------------costs--------------------------- @@ -778,8 +911,9 @@ int SuperWord::unpack_cost(int ct) { return ct; } //------------------------------combine_packs--------------------------- // Combine packs A and B with A.last == B.first into A.first..,A.last,B.second,..B.last void SuperWord::combine_packs() { - bool changed; - do { + bool changed = true; + // Combine packs regardless max vector size. + while (changed) { changed = false; for (int i = 0; i < _packset.length(); i++) { Node_List* p1 = _packset.at(i); @@ -787,6 +921,7 @@ void SuperWord::combine_packs() { for (int j = 0; j < _packset.length(); j++) { Node_List* p2 = _packset.at(j); if (p2 == NULL) continue; + if (i == j) continue; if (p1->at(p1->size()-1) == p2->at(0)) { for (uint k = 1; k < p2->size(); k++) { p1->push(p2->at(k)); @@ -796,8 +931,39 @@ void SuperWord::combine_packs() { } } } - } while (changed); + } + // Split packs which have size greater then max vector size. + for (int i = 0; i < _packset.length(); i++) { + Node_List* p1 = _packset.at(i); + if (p1 != NULL) { + BasicType bt = velt_basic_type(p1->at(0)); + uint max_vlen = Matcher::max_vector_size(bt); // Max elements in vector + assert(is_power_of_2(max_vlen), "sanity"); + uint psize = p1->size(); + if (!is_power_of_2(psize)) { + // Skip pack which can't be vector. + // case1: for(...) { a[i] = i; } elements values are different (i+x) + // case2: for(...) { a[i] = b[i+1]; } can't align both, load and store + _packset.at_put(i, NULL); + continue; + } + if (psize > max_vlen) { + Node_List* pack = new Node_List(); + for (uint j = 0; j < psize; j++) { + pack->push(p1->at(j)); + if (pack->size() >= max_vlen) { + assert(is_power_of_2(pack->size()), "sanity"); + _packset.append(pack); + pack = new Node_List(); + } + } + _packset.at_put(i, NULL); + } + } + } + + // Compress list. for (int i = _packset.length() - 1; i >= 0; i--) { Node_List* p1 = _packset.at(i); if (p1 == NULL) { @@ -880,8 +1046,7 @@ void SuperWord::filter_packs() { // Can code be generated for pack p? bool SuperWord::implemented(Node_List* p) { Node* p0 = p->at(0); - int vopc = VectorNode::opcode(p0->Opcode(), p->size(), velt_type(p0)); - return vopc > 0 && Matcher::has_match_rule(vopc); + return VectorNode::implemented(p0->Opcode(), p->size(), velt_basic_type(p0)); } //------------------------------profitable--------------------------- @@ -939,36 +1104,36 @@ void SuperWord::schedule() { } //-------------------------------remove_and_insert------------------- -//remove "current" from its current position in the memory graph and insert -//it after the appropriate insertion point (lip or uip) +// Remove "current" from its current position in the memory graph and insert +// it after the appropriate insertion point (lip or uip). void SuperWord::remove_and_insert(MemNode *current, MemNode *prev, MemNode *lip, Node *uip, Unique_Node_List &sched_before) { Node* my_mem = current->in(MemNode::Memory); - _igvn.rehash_node_delayed(current); - _igvn.hash_delete(my_mem); + bool sched_up = sched_before.member(current); - //remove current_store from its current position in the memmory graph + // remove current_store from its current position in the memmory graph for (DUIterator i = current->outs(); current->has_out(i); i++) { Node* use = current->out(i); if (use->is_Mem()) { assert(use->in(MemNode::Memory) == current, "must be"); - _igvn.rehash_node_delayed(use); if (use == prev) { // connect prev to my_mem - use->set_req(MemNode::Memory, my_mem); + _igvn.replace_input_of(use, MemNode::Memory, my_mem); + --i; //deleted this edge; rescan position } else if (sched_before.member(use)) { - _igvn.hash_delete(uip); - use->set_req(MemNode::Memory, uip); + if (!sched_up) { // Will be moved together with current + _igvn.replace_input_of(use, MemNode::Memory, uip); + --i; //deleted this edge; rescan position + } } else { - _igvn.hash_delete(lip); - use->set_req(MemNode::Memory, lip); + if (sched_up) { // Will be moved together with current + _igvn.replace_input_of(use, MemNode::Memory, lip); + --i; //deleted this edge; rescan position + } } - --i; //deleted this edge; rescan position } } - bool sched_up = sched_before.member(current); Node *insert_pt = sched_up ? uip : lip; - _igvn.hash_delete(insert_pt); // all uses of insert_pt's memory state should use current's instead for (DUIterator i = insert_pt->outs(); insert_pt->has_out(i); i++) { @@ -988,7 +1153,7 @@ void SuperWord::remove_and_insert(MemNode *current, MemNode *prev, MemNode *lip, } //connect current to insert_pt - current->set_req(MemNode::Memory, insert_pt); + _igvn.replace_input_of(current, MemNode::Memory, insert_pt); } //------------------------------co_locate_pack---------------------------------- @@ -1025,7 +1190,7 @@ void SuperWord::co_locate_pack(Node_List* pk) { if (use->is_Mem() && use != previous) memops.push(use); } - if(current == first) break; + if (current == first) break; previous = current; current = current->in(MemNode::Memory)->as_Mem(); } @@ -1038,27 +1203,37 @@ void SuperWord::co_locate_pack(Node_List* pk) { Node *s2 = memops.at(j); if (!independent(s1, s2)) { if (in_pack(s2, pk) || schedule_before_pack.member(s2)) { - schedule_before_pack.push(s1); //s1 must be scheduled before + schedule_before_pack.push(s1); // s1 must be scheduled before Node_List* mem_pk = my_pack(s1); if (mem_pk != NULL) { for (uint ii = 0; ii < mem_pk->size(); ii++) { - Node* s = mem_pk->at(ii); // follow partner + Node* s = mem_pk->at(ii); // follow partner if (memops.member(s) && !schedule_before_pack.member(s)) schedule_before_pack.push(s); } } + break; } } } } } - MemNode* lower_insert_pt = last; Node* upper_insert_pt = first->in(MemNode::Memory); + // Following code moves loads connected to upper_insert_pt below aliased stores. + // Collect such loads here and reconnect them back to upper_insert_pt later. + memops.clear(); + for (DUIterator i = upper_insert_pt->outs(); upper_insert_pt->has_out(i); i++) { + Node* use = upper_insert_pt->out(i); + if (!use->is_Store()) + memops.push(use); + } + + MemNode* lower_insert_pt = last; previous = last; //previous store in pk current = last->in(MemNode::Memory)->as_Mem(); - //start scheduling from "last" to "first" + // start scheduling from "last" to "first" while (true) { assert(in_bb(current), "stay in block"); assert(in_pack(previous, pk), "previous stays in pack"); @@ -1066,16 +1241,13 @@ void SuperWord::co_locate_pack(Node_List* pk) { if (in_pack(current, pk)) { // Forward users of my memory state (except "previous) to my input memory state - _igvn.hash_delete(current); for (DUIterator i = current->outs(); current->has_out(i); i++) { Node* use = current->out(i); if (use->is_Mem() && use != previous) { assert(use->in(MemNode::Memory) == current, "must be"); if (schedule_before_pack.member(use)) { - _igvn.hash_delete(upper_insert_pt); _igvn.replace_input_of(use, MemNode::Memory, upper_insert_pt); } else { - _igvn.hash_delete(lower_insert_pt); _igvn.replace_input_of(use, MemNode::Memory, lower_insert_pt); } --i; // deleted this edge; rescan position @@ -1089,6 +1261,14 @@ void SuperWord::co_locate_pack(Node_List* pk) { if (current == first) break; current = my_mem->as_Mem(); } // end while + + // Reconnect loads back to upper_insert_pt. + for (uint i = 0; i < memops.size(); i++) { + Node *ld = memops.at(i); + if (ld->in(MemNode::Memory) != upper_insert_pt) { + _igvn.replace_input_of(ld, MemNode::Memory, upper_insert_pt); + } + } } else if (pk->at(0)->is_Load()) { //load // all loads in the pack should have the same memory state. By default, // we use the memory state of the last load. However, if any load could @@ -1149,35 +1329,30 @@ void SuperWord::output() { Node* vn = NULL; Node* low_adr = p->at(0); Node* first = executed_first(p); + int opc = n->Opcode(); if (n->is_Load()) { - int opc = n->Opcode(); Node* ctl = n->in(MemNode::Control); Node* mem = first->in(MemNode::Memory); Node* adr = low_adr->in(MemNode::Address); const TypePtr* atyp = n->adr_type(); - vn = VectorLoadNode::make(_phase->C, opc, ctl, mem, adr, atyp, vlen); - + vn = LoadVectorNode::make(_phase->C, opc, ctl, mem, adr, atyp, vlen, velt_basic_type(n)); } else if (n->is_Store()) { // Promote value to be stored to vector Node* val = vector_opd(p, MemNode::ValueIn); - - int opc = n->Opcode(); Node* ctl = n->in(MemNode::Control); Node* mem = first->in(MemNode::Memory); Node* adr = low_adr->in(MemNode::Address); const TypePtr* atyp = n->adr_type(); - vn = VectorStoreNode::make(_phase->C, opc, ctl, mem, adr, atyp, val, vlen); - + vn = StoreVectorNode::make(_phase->C, opc, ctl, mem, adr, atyp, val, vlen); } else if (n->req() == 3) { // Promote operands to vector Node* in1 = vector_opd(p, 1); Node* in2 = vector_opd(p, 2); - vn = VectorNode::make(_phase->C, n->Opcode(), in1, in2, vlen, velt_type(n)); - + vn = VectorNode::make(_phase->C, opc, in1, in2, vlen, velt_basic_type(n)); } else { ShouldNotReachHere(); } - + assert(vn != NULL, "sanity"); _phase->_igvn.register_new_node_with_optimizer(vn); _phase->set_ctrl(vn, _phase->get_ctrl(p->at(0))); for (uint j = 0; j < p->size(); j++) { @@ -1185,6 +1360,12 @@ void SuperWord::output() { _igvn.replace_node(pm, vn); } _igvn._worklist.push(vn); +#ifdef ASSERT + if (TraceSuperWord) { + tty->print("new Vector node: "); + vn->dump(); + } +#endif } } } @@ -1207,10 +1388,10 @@ Node* SuperWord::vector_opd(Node_List* p, int opd_idx) { } if (same_opd) { - if (opd->is_Vector() || opd->is_VectorLoad()) { + if (opd->is_Vector() || opd->is_LoadVector()) { return opd; // input is matching vector } - assert(!opd->is_VectorStore(), "such vector is not expected here"); + assert(!opd->is_StoreVector(), "such vector is not expected here"); // Convert scalar input to vector with the same number of elements as // p0's vector. Use p0's type because size of operand's container in // vector should match p0's size regardless operand's size. @@ -1219,12 +1400,18 @@ Node* SuperWord::vector_opd(Node_List* p, int opd_idx) { _phase->_igvn.register_new_node_with_optimizer(vn); _phase->set_ctrl(vn, _phase->get_ctrl(opd)); +#ifdef ASSERT + if (TraceSuperWord) { + tty->print("new Vector node: "); + vn->dump(); + } +#endif return vn; } // Insert pack operation - const Type* p0_t = velt_type(p0); - PackNode* pk = PackNode::make(_phase->C, opd, p0_t); + BasicType bt = velt_basic_type(p0); + PackNode* pk = PackNode::make(_phase->C, opd, vlen, bt); DEBUG_ONLY( const BasicType opd_bt = opd->bottom_type()->basic_type(); ) for (uint i = 1; i < vlen; i++) { @@ -1232,10 +1419,16 @@ Node* SuperWord::vector_opd(Node_List* p, int opd_idx) { Node* in = pi->in(opd_idx); assert(my_pack(in) == NULL, "Should already have been unpacked"); assert(opd_bt == in->bottom_type()->basic_type(), "all same type"); - pk->add_opd(in); + pk->add_opd(i, in); } _phase->_igvn.register_new_node_with_optimizer(pk); _phase->set_ctrl(pk, _phase->get_ctrl(opd)); +#ifdef ASSERT + if (TraceSuperWord) { + tty->print("new Pack node: "); + pk->dump(); + } +#endif return pk; } @@ -1273,16 +1466,15 @@ void SuperWord::insert_extracts(Node_List* p) { // Insert extract operation _igvn.hash_delete(def); int def_pos = alignment(def) / data_size(def); - const Type* def_t = velt_type(def); - Node* ex = ExtractNode::make(_phase->C, def, def_pos, def_t); + Node* ex = ExtractNode::make(_phase->C, def, def_pos, velt_basic_type(def)); _phase->_igvn.register_new_node_with_optimizer(ex); _phase->set_ctrl(ex, _phase->get_ctrl(def)); _igvn.replace_input_of(use, idx, ex); _igvn._worklist.push(def); bb_insert_after(ex, bb_idx(def)); - set_velt_type(ex, def_t); + set_velt_type(ex, velt_type(def)); } } @@ -1509,10 +1701,7 @@ void SuperWord::compute_vector_element_type() { // Initial type for (int i = 0; i < _block.length(); i++) { Node* n = _block.at(i); - const Type* t = n->is_Mem() ? Type::get_const_basic_type(n->as_Mem()->memory_type()) - : _igvn.type(n); - const Type* vt = container_type(t); - set_velt_type(n, vt); + set_velt_type(n, container_type(n)); } // Propagate narrowed type backwards through operations @@ -1543,7 +1732,7 @@ void SuperWord::compute_vector_element_type() { bool same_type = true; for (DUIterator_Fast kmax, k = in->fast_outs(kmax); k < kmax; k++) { Node *use = in->fast_out(k); - if (!in_bb(use) || velt_type(use) != vt) { + if (!in_bb(use) || !same_velt_type(use, n)) { same_type = false; break; } @@ -1575,20 +1764,24 @@ int SuperWord::memory_alignment(MemNode* s, int iv_adjust_in_bytes) { if (!p.valid()) { return bottom_align; } + int vw = vector_width_in_bytes(velt_basic_type(s)); + if (vw < 2) { + return bottom_align; // No vectors for this type + } int offset = p.offset_in_bytes(); offset += iv_adjust_in_bytes; - int off_rem = offset % vector_width_in_bytes(); - int off_mod = off_rem >= 0 ? off_rem : off_rem + vector_width_in_bytes(); + int off_rem = offset % vw; + int off_mod = off_rem >= 0 ? off_rem : off_rem + vw; return off_mod; } //---------------------------container_type--------------------------- // Smallest type containing range of values -const Type* SuperWord::container_type(const Type* t) { - const Type* tp = t->make_ptr(); - if (tp && tp->isa_aryptr()) { - t = tp->is_aryptr()->elem(); +const Type* SuperWord::container_type(Node* n) { + if (n->is_Mem()) { + return Type::get_const_basic_type(n->as_Mem()->memory_type()); } + const Type* t = _igvn.type(n); if (t->basic_type() == T_INT) { if (t->higher_equal(TypeInt::BOOL)) return TypeInt::BOOL; if (t->higher_equal(TypeInt::BYTE)) return TypeInt::BYTE; @@ -1599,11 +1792,22 @@ const Type* SuperWord::container_type(const Type* t) { return t; } +bool SuperWord::same_velt_type(Node* n1, Node* n2) { + const Type* vt1 = velt_type(n1); + const Type* vt2 = velt_type(n1); + if (vt1->basic_type() == T_INT && vt2->basic_type() == T_INT) { + // Compare vectors element sizes for integer types. + return data_size(n1) == data_size(n2); + } + return vt1 == vt2; +} + //-------------------------vector_opd_range----------------------- // (Start, end] half-open range defining which operands are vector void SuperWord::vector_opd_range(Node* n, uint* start, uint* end) { switch (n->Opcode()) { - case Op_LoadB: case Op_LoadUS: + case Op_LoadB: case Op_LoadUB: + case Op_LoadS: case Op_LoadUS: case Op_LoadI: case Op_LoadL: case Op_LoadF: case Op_LoadD: case Op_LoadP: @@ -1721,6 +1925,7 @@ void SuperWord::align_initial_loop_index(MemNode* align_to_ref) { assert(orig_limit != NULL && _igvn.type(orig_limit) != Type::TOP, ""); SWPointer align_to_ref_p(align_to_ref, this); + assert(align_to_ref_p.valid(), "sanity"); // Given: // lim0 == original pre loop limit @@ -1773,10 +1978,12 @@ void SuperWord::align_initial_loop_index(MemNode* align_to_ref) { // N = (V - (e - lim0)) % V // lim = lim0 - (V - (e - lim0)) % V + int vw = vector_width_in_bytes(velt_basic_type(align_to_ref)); + assert(vw > 1, "sanity"); int stride = iv_stride(); int scale = align_to_ref_p.scale_in_bytes(); int elt_size = align_to_ref_p.memory_size(); - int v_align = vector_width_in_bytes() / elt_size; + int v_align = vw / elt_size; int k = align_to_ref_p.offset_in_bytes() / elt_size; Node *kn = _igvn.intcon(k); @@ -1796,6 +2003,25 @@ void SuperWord::align_initial_loop_index(MemNode* align_to_ref) { _phase->_igvn.register_new_node_with_optimizer(e); _phase->set_ctrl(e, pre_ctrl); } + if (vw > ObjectAlignmentInBytes) { + // incorporate base e +/- base && Mask >>> log2(elt) + Node* mask = _igvn.MakeConX(~(-1 << exact_log2(vw))); + Node* xbase = new(_phase->C, 2) CastP2XNode(NULL, align_to_ref_p.base()); + _phase->_igvn.register_new_node_with_optimizer(xbase); + Node* masked_xbase = new (_phase->C, 3) AndXNode(xbase, mask); + _phase->_igvn.register_new_node_with_optimizer(masked_xbase); +#ifdef _LP64 + masked_xbase = new (_phase->C, 2) ConvL2INode(masked_xbase); + _phase->_igvn.register_new_node_with_optimizer(masked_xbase); +#endif + Node* log2_elt = _igvn.intcon(exact_log2(elt_size)); + Node* bref = new (_phase->C, 3) URShiftINode(masked_xbase, log2_elt); + _phase->_igvn.register_new_node_with_optimizer(bref); + _phase->set_ctrl(bref, pre_ctrl); + e = new (_phase->C, 3) AddINode(e, bref); + _phase->_igvn.register_new_node_with_optimizer(e); + _phase->set_ctrl(e, pre_ctrl); + } // compute e +/- lim0 if (scale < 0) { diff --git a/hotspot/src/share/vm/opto/superword.hpp b/hotspot/src/share/vm/opto/superword.hpp index 50937671265..97224e4d7bd 100644 --- a/hotspot/src/share/vm/opto/superword.hpp +++ b/hotspot/src/share/vm/opto/superword.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -264,7 +264,10 @@ class SuperWord : public ResourceObj { _iv = lp->as_CountedLoop()->phi()->as_Phi(); } int iv_stride() { return lp()->as_CountedLoop()->stride_con(); } - int vector_width_in_bytes() { return Matcher::vector_width_in_bytes(); } + int vector_width_in_bytes(BasicType bt) { + return MIN2(ABS(iv_stride())*type2aelembytes(bt), + Matcher::vector_width_in_bytes(bt)); + } MemNode* align_to_ref() { return _align_to_ref; } void set_align_to_ref(MemNode* m) { _align_to_ref = m; } @@ -298,7 +301,9 @@ class SuperWord : public ResourceObj { // vector element type const Type* velt_type(Node* n) { return _node_info.adr_at(bb_idx(n))->_velt_type; } + BasicType velt_basic_type(Node* n) { return velt_type(n)->array_element_basic_type(); } void set_velt_type(Node* n, const Type* t) { int i = bb_idx(n); grow_node_info(i); _node_info.adr_at(i)->_velt_type = t; } + bool same_velt_type(Node* n1, Node* n2); // my_pack Node_List* my_pack(Node* n) { return !in_bb(n) ? NULL : _node_info.adr_at(bb_idx(n))->_my_pack; } @@ -311,7 +316,9 @@ class SuperWord : public ResourceObj { // Find the adjacent memory references and create pack pairs for them. void find_adjacent_refs(); // Find a memory reference to align the loop induction variable to. - void find_align_to_ref(Node_List &memops); + MemNode* find_align_to_ref(Node_List &memops); + // Calculate loop's iv adjustment for this memory ops. + int get_iv_adjustment(MemNode* mem); // Can the preloop align the reference to position zero in the vector? bool ref_is_alignable(SWPointer& p); // Construct dependency graph. @@ -394,7 +401,7 @@ class SuperWord : public ResourceObj { // (Start, end] half-open range defining which operands are vector void vector_opd_range(Node* n, uint* start, uint* end); // Smallest type containing range of values - static const Type* container_type(const Type* t); + const Type* container_type(Node* n); // Adjust pre-loop limit so that in main loop, a load/store reference // to align_to_ref will be a position zero in the vector. void align_initial_loop_index(MemNode* align_to_ref); @@ -462,6 +469,7 @@ class SWPointer VALUE_OBJ_CLASS_SPEC { Node* base() { return _base; } Node* adr() { return _adr; } + MemNode* mem() { return _mem; } int scale_in_bytes() { return _scale; } Node* invar() { return _invar; } bool negate_invar() { return _negate_invar; } diff --git a/hotspot/src/share/vm/opto/type.cpp b/hotspot/src/share/vm/opto/type.cpp index af118139e2b..30ec5695939 100644 --- a/hotspot/src/share/vm/opto/type.cpp +++ b/hotspot/src/share/vm/opto/type.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -60,6 +60,10 @@ const BasicType Type::_basic_type[Type::lastype] = { T_ILLEGAL, // Tuple T_ARRAY, // Array + T_ILLEGAL, // VectorS + T_ILLEGAL, // VectorD + T_ILLEGAL, // VectorX + T_ILLEGAL, // VectorY T_ADDRESS, // AnyPtr // shows up in factory methods for NULL_PTR T_ADDRESS, // RawPtr @@ -414,6 +418,24 @@ void Type::Initialize_shared(Compile* current) { // get_zero_type() should not happen for T_CONFLICT _zero_type[T_CONFLICT]= NULL; + // Vector predefined types, it needs initialized _const_basic_type[]. + if (Matcher::vector_size_supported(T_BYTE,4)) { + TypeVect::VECTS = TypeVect::make(T_BYTE,4); + } + if (Matcher::vector_size_supported(T_FLOAT,2)) { + TypeVect::VECTD = TypeVect::make(T_FLOAT,2); + } + if (Matcher::vector_size_supported(T_FLOAT,4)) { + TypeVect::VECTX = TypeVect::make(T_FLOAT,4); + } + if (Matcher::vector_size_supported(T_FLOAT,8)) { + TypeVect::VECTY = TypeVect::make(T_FLOAT,8); + } + mreg2type[Op_VecS] = TypeVect::VECTS; + mreg2type[Op_VecD] = TypeVect::VECTD; + mreg2type[Op_VecX] = TypeVect::VECTX; + mreg2type[Op_VecY] = TypeVect::VECTY; + // Restore working type arena. current->set_type_arena(save); current->set_type_dict(NULL); @@ -668,6 +690,10 @@ const Type::TYPES Type::dual_type[Type::lastype] = { Bad, // Tuple - handled in v-call Bad, // Array - handled in v-call + Bad, // VectorS - handled in v-call + Bad, // VectorD - handled in v-call + Bad, // VectorX - handled in v-call + Bad, // VectorY - handled in v-call Bad, // AnyPtr - handled in v-call Bad, // RawPtr - handled in v-call @@ -728,8 +754,8 @@ void Type::dump_on(outputStream *st) const { //------------------------------data------------------------------------------- const char * const Type::msg[Type::lastype] = { "bad","control","top","int:","long:","half", "narrowoop:", - "tuple:", "aryptr", - "anyptr:", "rawptr:", "java:", "inst:", "ary:", "klass:", + "tuple:", "array:", "vectors:", "vectord:", "vectorx:", "vectory:", + "anyptr:", "rawptr:", "java:", "inst:", "aryptr:", "klass:", "func", "abIO", "return_address", "memory", "float_top", "ftcon:", "float", "double_top", "dblcon:", "double", @@ -790,7 +816,7 @@ void Type::typerr( const Type *t ) const { //------------------------------isa_oop_ptr------------------------------------ // Return true if type is an oop pointer type. False for raw pointers. static char isa_oop_ptr_tbl[Type::lastype] = { - 0,0,0,0,0,0,0/*narrowoop*/,0/*tuple*/, 0/*ary*/, + 0,0,0,0,0,0,0/*narrowoop*/,0/*tuple*/, 0/*array*/, 0, 0, 0, 0/*vector*/, 0/*anyptr*/,0/*rawptr*/,1/*OopPtr*/,1/*InstPtr*/,1/*AryPtr*/,1/*KlassPtr*/, 0/*func*/,0,0/*return_address*/,0, /*floats*/0,0,0, /*doubles*/0,0,0, @@ -1926,6 +1952,121 @@ bool TypeAry::ary_must_be_exact() const { return false; } +//==============================TypeVect======================================= +// Convenience common pre-built types. +const TypeVect *TypeVect::VECTS = NULL; // 32-bit vectors +const TypeVect *TypeVect::VECTD = NULL; // 64-bit vectors +const TypeVect *TypeVect::VECTX = NULL; // 128-bit vectors +const TypeVect *TypeVect::VECTY = NULL; // 256-bit vectors + +//------------------------------make------------------------------------------- +const TypeVect* TypeVect::make(const Type *elem, uint length) { + BasicType elem_bt = elem->array_element_basic_type(); + assert(is_java_primitive(elem_bt), "only primitive types in vector"); + assert(length > 1 && is_power_of_2(length), "vector length is power of 2"); + assert(Matcher::vector_size_supported(elem_bt, length), "length in range"); + int size = length * type2aelembytes(elem_bt); + switch (Matcher::vector_ideal_reg(size)) { + case Op_VecS: + return (TypeVect*)(new TypeVectS(elem, length))->hashcons(); + case Op_VecD: + case Op_RegD: + return (TypeVect*)(new TypeVectD(elem, length))->hashcons(); + case Op_VecX: + return (TypeVect*)(new TypeVectX(elem, length))->hashcons(); + case Op_VecY: + return (TypeVect*)(new TypeVectY(elem, length))->hashcons(); + } + ShouldNotReachHere(); + return NULL; +} + +//------------------------------meet------------------------------------------- +// Compute the MEET of two types. It returns a new Type object. +const Type *TypeVect::xmeet( const Type *t ) const { + // Perform a fast test for common case; meeting the same types together. + if( this == t ) return this; // Meeting same type-rep? + + // Current "this->_base" is Vector + switch (t->base()) { // switch on original type + + case Bottom: // Ye Olde Default + return t; + + default: // All else is a mistake + typerr(t); + + case VectorS: + case VectorD: + case VectorX: + case VectorY: { // Meeting 2 vectors? + const TypeVect* v = t->is_vect(); + assert( base() == v->base(), ""); + assert(length() == v->length(), ""); + assert(element_basic_type() == v->element_basic_type(), ""); + return TypeVect::make(_elem->xmeet(v->_elem), _length); + } + case Top: + break; + } + return this; +} + +//------------------------------xdual------------------------------------------ +// Dual: compute field-by-field dual +const Type *TypeVect::xdual() const { + return new TypeVect(base(), _elem->dual(), _length); +} + +//------------------------------eq--------------------------------------------- +// Structural equality check for Type representations +bool TypeVect::eq(const Type *t) const { + const TypeVect *v = t->is_vect(); + return (_elem == v->_elem) && (_length == v->_length); +} + +//------------------------------hash------------------------------------------- +// Type-specific hashing function. +int TypeVect::hash(void) const { + return (intptr_t)_elem + (intptr_t)_length; +} + +//------------------------------singleton-------------------------------------- +// TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple +// constants (Ldi nodes). Vector is singleton if all elements are the same +// constant value (when vector is created with Replicate code). +bool TypeVect::singleton(void) const { +// There is no Con node for vectors yet. +// return _elem->singleton(); + return false; +} + +bool TypeVect::empty(void) const { + return _elem->empty(); +} + +//------------------------------dump2------------------------------------------ +#ifndef PRODUCT +void TypeVect::dump2(Dict &d, uint depth, outputStream *st) const { + switch (base()) { + case VectorS: + st->print("vectors["); break; + case VectorD: + st->print("vectord["); break; + case VectorX: + st->print("vectorx["); break; + case VectorY: + st->print("vectory["); break; + default: + ShouldNotReachHere(); + } + st->print("%d]:{", _length); + _elem->dump2(d, depth, st); + st->print("}"); +} +#endif + + //============================================================================= // Convenience common pre-built types. const TypePtr *TypePtr::NULL_PTR; @@ -4140,7 +4281,7 @@ void TypeFunc::dump2( Dict &d, uint depth, outputStream *st ) const { // Print a 'flattened' signature static const char * const flat_type_msg[Type::lastype] = { "bad","control","top","int","long","_", "narrowoop", - "tuple:", "array:", + "tuple:", "array:", "vectors:", "vectord:", "vectorx:", "vectory:", "ptr", "rawptr", "ptr", "ptr", "ptr", "ptr", "func", "abIO", "return_address", "mem", "float_top", "ftcon:", "flt", diff --git a/hotspot/src/share/vm/opto/type.hpp b/hotspot/src/share/vm/opto/type.hpp index 133ce78f061..a4b5487d78b 100644 --- a/hotspot/src/share/vm/opto/type.hpp +++ b/hotspot/src/share/vm/opto/type.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -51,6 +51,11 @@ class TypeLong; class TypeNarrowOop; class TypeAry; class TypeTuple; +class TypeVect; +class TypeVectS; +class TypeVectD; +class TypeVectX; +class TypeVectY; class TypePtr; class TypeRawPtr; class TypeOopPtr; @@ -78,6 +83,10 @@ public: Tuple, // Method signature or object layout Array, // Array types + VectorS, // 32bit Vector types + VectorD, // 64bit Vector types + VectorX, // 128bit Vector types + VectorY, // 256bit Vector types AnyPtr, // Any old raw, klass, inst, or array pointer RawPtr, // Raw (non-oop) pointers @@ -222,6 +231,8 @@ public: const TypeF *isa_float_constant() const; // Returns NULL if not a FloatCon const TypeTuple *is_tuple() const; // Collection of fields, NOT a pointer const TypeAry *is_ary() const; // Array, NOT array pointer + const TypeVect *is_vect() const; // Vector + const TypeVect *isa_vect() const; // Returns NULL if not a Vector const TypePtr *is_ptr() const; // Asserts it is a ptr type const TypePtr *isa_ptr() const; // Returns NULL if not ptr type const TypeRawPtr *isa_rawptr() const; // NOT Java oop @@ -574,6 +585,69 @@ public: #endif }; +//------------------------------TypeVect--------------------------------------- +// Class of Vector Types +class TypeVect : public Type { + const Type* _elem; // Vector's element type + const uint _length; // Elements in vector (power of 2) + +protected: + TypeVect(TYPES t, const Type* elem, uint length) : Type(t), + _elem(elem), _length(length) {} + +public: + const Type* element_type() const { return _elem; } + BasicType element_basic_type() const { return _elem->array_element_basic_type(); } + uint length() const { return _length; } + uint length_in_bytes() const { + return _length * type2aelembytes(element_basic_type()); + } + + virtual bool eq(const Type *t) const; + virtual int hash() const; // Type specific hashing + virtual bool singleton(void) const; // TRUE if type is a singleton + virtual bool empty(void) const; // TRUE if type is vacuous + + static const TypeVect *make(const BasicType elem_bt, uint length) { + // Use bottom primitive type. + return make(get_const_basic_type(elem_bt), length); + } + // Used directly by Replicate nodes to construct singleton vector. + static const TypeVect *make(const Type* elem, uint length); + + virtual const Type *xmeet( const Type *t) const; + virtual const Type *xdual() const; // Compute dual right now. + + static const TypeVect *VECTS; + static const TypeVect *VECTD; + static const TypeVect *VECTX; + static const TypeVect *VECTY; + +#ifndef PRODUCT + virtual void dump2(Dict &d, uint, outputStream *st) const; // Specialized per-Type dumping +#endif +}; + +class TypeVectS : public TypeVect { + friend class TypeVect; + TypeVectS(const Type* elem, uint length) : TypeVect(VectorS, elem, length) {} +}; + +class TypeVectD : public TypeVect { + friend class TypeVect; + TypeVectD(const Type* elem, uint length) : TypeVect(VectorD, elem, length) {} +}; + +class TypeVectX : public TypeVect { + friend class TypeVect; + TypeVectX(const Type* elem, uint length) : TypeVect(VectorX, elem, length) {} +}; + +class TypeVectY : public TypeVect { + friend class TypeVect; + TypeVectY(const Type* elem, uint length) : TypeVect(VectorY, elem, length) {} +}; + //------------------------------TypePtr---------------------------------------- // Class of machine Pointer Types: raw data, instances or arrays. // If the _base enum is AnyPtr, then this refers to all of the above. @@ -1113,6 +1187,15 @@ inline const TypeAry *Type::is_ary() const { return (TypeAry*)this; } +inline const TypeVect *Type::is_vect() const { + assert( _base >= VectorS && _base <= VectorY, "Not a Vector" ); + return (TypeVect*)this; +} + +inline const TypeVect *Type::isa_vect() const { + return (_base >= VectorS && _base <= VectorY) ? (TypeVect*)this : NULL; +} + inline const TypePtr *Type::is_ptr() const { // AnyPtr is the first Ptr and KlassPtr the last, with no non-ptrs between. assert(_base >= AnyPtr && _base <= KlassPtr, "Not a pointer"); diff --git a/hotspot/src/share/vm/opto/vectornode.cpp b/hotspot/src/share/vm/opto/vectornode.cpp index 885a1c89839..c786754cd08 100644 --- a/hotspot/src/share/vm/opto/vectornode.cpp +++ b/hotspot/src/share/vm/opto/vectornode.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -28,147 +28,16 @@ //------------------------------VectorNode-------------------------------------- -// Return vector type for an element type and vector length. -const Type* VectorNode::vect_type(BasicType elt_bt, uint len) { - assert(len <= VectorNode::max_vlen(elt_bt), "len in range"); - switch(elt_bt) { - case T_BOOLEAN: - case T_BYTE: - switch(len) { - case 2: return TypeInt::CHAR; - case 4: return TypeInt::INT; - case 8: return TypeLong::LONG; - } - break; - case T_CHAR: - case T_SHORT: - switch(len) { - case 2: return TypeInt::INT; - case 4: return TypeLong::LONG; - } - break; - case T_INT: - switch(len) { - case 2: return TypeLong::LONG; - } - break; - case T_LONG: - break; - case T_FLOAT: - switch(len) { - case 2: return Type::DOUBLE; - } - break; - case T_DOUBLE: - break; - } - ShouldNotReachHere(); - return NULL; -} - -// Scalar promotion -VectorNode* VectorNode::scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t) { - BasicType bt = opd_t->array_element_basic_type(); - assert(vlen <= VectorNode::max_vlen(bt), "vlen in range"); - switch (bt) { - case T_BOOLEAN: - case T_BYTE: - if (vlen == 16) return new (C, 2) Replicate16BNode(s); - if (vlen == 8) return new (C, 2) Replicate8BNode(s); - if (vlen == 4) return new (C, 2) Replicate4BNode(s); - break; - case T_CHAR: - if (vlen == 8) return new (C, 2) Replicate8CNode(s); - if (vlen == 4) return new (C, 2) Replicate4CNode(s); - if (vlen == 2) return new (C, 2) Replicate2CNode(s); - break; - case T_SHORT: - if (vlen == 8) return new (C, 2) Replicate8SNode(s); - if (vlen == 4) return new (C, 2) Replicate4SNode(s); - if (vlen == 2) return new (C, 2) Replicate2SNode(s); - break; - case T_INT: - if (vlen == 4) return new (C, 2) Replicate4INode(s); - if (vlen == 2) return new (C, 2) Replicate2INode(s); - break; - case T_LONG: - if (vlen == 2) return new (C, 2) Replicate2LNode(s); - break; - case T_FLOAT: - if (vlen == 4) return new (C, 2) Replicate4FNode(s); - if (vlen == 2) return new (C, 2) Replicate2FNode(s); - break; - case T_DOUBLE: - if (vlen == 2) return new (C, 2) Replicate2DNode(s); - break; - } - ShouldNotReachHere(); - return NULL; -} - -// Return initial Pack node. Additional operands added with add_opd() calls. -PackNode* PackNode::make(Compile* C, Node* s, const Type* opd_t) { - BasicType bt = opd_t->array_element_basic_type(); - switch (bt) { - case T_BOOLEAN: - case T_BYTE: - return new (C, 2) PackBNode(s); - case T_CHAR: - return new (C, 2) PackCNode(s); - case T_SHORT: - return new (C, 2) PackSNode(s); - case T_INT: - return new (C, 2) PackINode(s); - case T_LONG: - return new (C, 2) PackLNode(s); - case T_FLOAT: - return new (C, 2) PackFNode(s); - case T_DOUBLE: - return new (C, 2) PackDNode(s); - } - ShouldNotReachHere(); - return NULL; -} - -// Create a binary tree form for Packs. [lo, hi) (half-open) range -Node* PackNode::binaryTreePack(Compile* C, int lo, int hi) { - int ct = hi - lo; - assert(is_power_of_2(ct), "power of 2"); - int mid = lo + ct/2; - Node* n1 = ct == 2 ? in(lo) : binaryTreePack(C, lo, mid); - Node* n2 = ct == 2 ? in(lo+1) : binaryTreePack(C, mid, hi ); - int rslt_bsize = ct * type2aelembytes(elt_basic_type()); - if (bottom_type()->is_floatingpoint()) { - switch (rslt_bsize) { - case 8: return new (C, 3) PackFNode(n1, n2); - case 16: return new (C, 3) PackDNode(n1, n2); - } - } else { - assert(bottom_type()->isa_int() || bottom_type()->isa_long(), "int or long"); - switch (rslt_bsize) { - case 2: return new (C, 3) Pack2x1BNode(n1, n2); - case 4: return new (C, 3) Pack2x2BNode(n1, n2); - case 8: return new (C, 3) PackINode(n1, n2); - case 16: return new (C, 3) PackLNode(n1, n2); - } - } - ShouldNotReachHere(); - return NULL; -} - // Return the vector operator for the specified scalar operation -// and vector length. One use is to check if the code generator +// and vector length. Also used to check if the code generator // supports the vector operation. -int VectorNode::opcode(int sopc, uint vlen, const Type* opd_t) { - BasicType bt = opd_t->array_element_basic_type(); - if (!(is_power_of_2(vlen) && vlen <= max_vlen(bt))) - return 0; // unimplemented +int VectorNode::opcode(int sopc, uint vlen, BasicType bt) { switch (sopc) { case Op_AddI: switch (bt) { case T_BOOLEAN: case T_BYTE: return Op_AddVB; - case T_CHAR: return Op_AddVC; + case T_CHAR: case T_SHORT: return Op_AddVS; case T_INT: return Op_AddVI; } @@ -186,7 +55,7 @@ int VectorNode::opcode(int sopc, uint vlen, const Type* opd_t) { switch (bt) { case T_BOOLEAN: case T_BYTE: return Op_SubVB; - case T_CHAR: return Op_SubVC; + case T_CHAR: case T_SHORT: return Op_SubVS; case T_INT: return Op_SubVI; } @@ -216,18 +85,18 @@ int VectorNode::opcode(int sopc, uint vlen, const Type* opd_t) { switch (bt) { case T_BOOLEAN: case T_BYTE: return Op_LShiftVB; - case T_CHAR: return Op_LShiftVC; + case T_CHAR: case T_SHORT: return Op_LShiftVS; case T_INT: return Op_LShiftVI; } ShouldNotReachHere(); - case Op_URShiftI: + case Op_RShiftI: switch (bt) { case T_BOOLEAN: - case T_BYTE: return Op_URShiftVB; - case T_CHAR: return Op_URShiftVC; - case T_SHORT: return Op_URShiftVS; - case T_INT: return Op_URShiftVI; + case T_BYTE: return Op_RShiftVB; + case T_CHAR: + case T_SHORT: return Op_RShiftVS; + case T_INT: return Op_RShiftVI; } ShouldNotReachHere(); case Op_AndI: @@ -241,13 +110,14 @@ int VectorNode::opcode(int sopc, uint vlen, const Type* opd_t) { return Op_XorV; case Op_LoadB: + case Op_LoadUB: case Op_LoadUS: case Op_LoadS: case Op_LoadI: case Op_LoadL: case Op_LoadF: case Op_LoadD: - return VectorLoadNode::opcode(sopc, vlen); + return Op_LoadVector; case Op_StoreB: case Op_StoreC: @@ -255,211 +125,170 @@ int VectorNode::opcode(int sopc, uint vlen, const Type* opd_t) { case Op_StoreL: case Op_StoreF: case Op_StoreD: - return VectorStoreNode::opcode(sopc, vlen); + return Op_StoreVector; } return 0; // Unimplemented } -// Helper for above. -int VectorLoadNode::opcode(int sopc, uint vlen) { - switch (sopc) { - case Op_LoadB: - switch (vlen) { - case 2: return 0; // Unimplemented - case 4: return Op_Load4B; - case 8: return Op_Load8B; - case 16: return Op_Load16B; - } - break; - case Op_LoadUS: - switch (vlen) { - case 2: return Op_Load2C; - case 4: return Op_Load4C; - case 8: return Op_Load8C; - } - break; - case Op_LoadS: - switch (vlen) { - case 2: return Op_Load2S; - case 4: return Op_Load4S; - case 8: return Op_Load8S; - } - break; - case Op_LoadI: - switch (vlen) { - case 2: return Op_Load2I; - case 4: return Op_Load4I; - } - break; - case Op_LoadL: - if (vlen == 2) return Op_Load2L; - break; - case Op_LoadF: - switch (vlen) { - case 2: return Op_Load2F; - case 4: return Op_Load4F; - } - break; - case Op_LoadD: - if (vlen == 2) return Op_Load2D; - break; +bool VectorNode::implemented(int opc, uint vlen, BasicType bt) { + if (is_java_primitive(bt) && + (vlen > 1) && is_power_of_2(vlen) && + Matcher::vector_size_supported(bt, vlen)) { + int vopc = VectorNode::opcode(opc, vlen, bt); + return vopc > 0 && Matcher::has_match_rule(vopc); } - return 0; // Unimplemented -} - -// Helper for above -int VectorStoreNode::opcode(int sopc, uint vlen) { - switch (sopc) { - case Op_StoreB: - switch (vlen) { - case 2: return 0; // Unimplemented - case 4: return Op_Store4B; - case 8: return Op_Store8B; - case 16: return Op_Store16B; - } - break; - case Op_StoreC: - switch (vlen) { - case 2: return Op_Store2C; - case 4: return Op_Store4C; - case 8: return Op_Store8C; - } - break; - case Op_StoreI: - switch (vlen) { - case 2: return Op_Store2I; - case 4: return Op_Store4I; - } - break; - case Op_StoreL: - if (vlen == 2) return Op_Store2L; - break; - case Op_StoreF: - switch (vlen) { - case 2: return Op_Store2F; - case 4: return Op_Store4F; - } - break; - case Op_StoreD: - if (vlen == 2) return Op_Store2D; - break; - } - return 0; // Unimplemented + return false; } // Return the vector version of a scalar operation node. -VectorNode* VectorNode::make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* opd_t) { - int vopc = opcode(sopc, vlen, opd_t); +VectorNode* VectorNode::make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt) { + const TypeVect* vt = TypeVect::make(bt, vlen); + int vopc = VectorNode::opcode(opc, vlen, bt); switch (vopc) { - case Op_AddVB: return new (C, 3) AddVBNode(n1, n2, vlen); - case Op_AddVC: return new (C, 3) AddVCNode(n1, n2, vlen); - case Op_AddVS: return new (C, 3) AddVSNode(n1, n2, vlen); - case Op_AddVI: return new (C, 3) AddVINode(n1, n2, vlen); - case Op_AddVL: return new (C, 3) AddVLNode(n1, n2, vlen); - case Op_AddVF: return new (C, 3) AddVFNode(n1, n2, vlen); - case Op_AddVD: return new (C, 3) AddVDNode(n1, n2, vlen); + case Op_AddVB: return new (C, 3) AddVBNode(n1, n2, vt); + case Op_AddVS: return new (C, 3) AddVSNode(n1, n2, vt); + case Op_AddVI: return new (C, 3) AddVINode(n1, n2, vt); + case Op_AddVL: return new (C, 3) AddVLNode(n1, n2, vt); + case Op_AddVF: return new (C, 3) AddVFNode(n1, n2, vt); + case Op_AddVD: return new (C, 3) AddVDNode(n1, n2, vt); - case Op_SubVB: return new (C, 3) SubVBNode(n1, n2, vlen); - case Op_SubVC: return new (C, 3) SubVCNode(n1, n2, vlen); - case Op_SubVS: return new (C, 3) SubVSNode(n1, n2, vlen); - case Op_SubVI: return new (C, 3) SubVINode(n1, n2, vlen); - case Op_SubVL: return new (C, 3) SubVLNode(n1, n2, vlen); - case Op_SubVF: return new (C, 3) SubVFNode(n1, n2, vlen); - case Op_SubVD: return new (C, 3) SubVDNode(n1, n2, vlen); + case Op_SubVB: return new (C, 3) SubVBNode(n1, n2, vt); + case Op_SubVS: return new (C, 3) SubVSNode(n1, n2, vt); + case Op_SubVI: return new (C, 3) SubVINode(n1, n2, vt); + case Op_SubVL: return new (C, 3) SubVLNode(n1, n2, vt); + case Op_SubVF: return new (C, 3) SubVFNode(n1, n2, vt); + case Op_SubVD: return new (C, 3) SubVDNode(n1, n2, vt); - case Op_MulVF: return new (C, 3) MulVFNode(n1, n2, vlen); - case Op_MulVD: return new (C, 3) MulVDNode(n1, n2, vlen); + case Op_MulVF: return new (C, 3) MulVFNode(n1, n2, vt); + case Op_MulVD: return new (C, 3) MulVDNode(n1, n2, vt); - case Op_DivVF: return new (C, 3) DivVFNode(n1, n2, vlen); - case Op_DivVD: return new (C, 3) DivVDNode(n1, n2, vlen); + case Op_DivVF: return new (C, 3) DivVFNode(n1, n2, vt); + case Op_DivVD: return new (C, 3) DivVDNode(n1, n2, vt); - case Op_LShiftVB: return new (C, 3) LShiftVBNode(n1, n2, vlen); - case Op_LShiftVC: return new (C, 3) LShiftVCNode(n1, n2, vlen); - case Op_LShiftVS: return new (C, 3) LShiftVSNode(n1, n2, vlen); - case Op_LShiftVI: return new (C, 3) LShiftVINode(n1, n2, vlen); + case Op_LShiftVB: return new (C, 3) LShiftVBNode(n1, n2, vt); + case Op_LShiftVS: return new (C, 3) LShiftVSNode(n1, n2, vt); + case Op_LShiftVI: return new (C, 3) LShiftVINode(n1, n2, vt); - case Op_URShiftVB: return new (C, 3) URShiftVBNode(n1, n2, vlen); - case Op_URShiftVC: return new (C, 3) URShiftVCNode(n1, n2, vlen); - case Op_URShiftVS: return new (C, 3) URShiftVSNode(n1, n2, vlen); - case Op_URShiftVI: return new (C, 3) URShiftVINode(n1, n2, vlen); + case Op_RShiftVB: return new (C, 3) RShiftVBNode(n1, n2, vt); + case Op_RShiftVS: return new (C, 3) RShiftVSNode(n1, n2, vt); + case Op_RShiftVI: return new (C, 3) RShiftVINode(n1, n2, vt); - case Op_AndV: return new (C, 3) AndVNode(n1, n2, vlen, opd_t->array_element_basic_type()); - case Op_OrV: return new (C, 3) OrVNode (n1, n2, vlen, opd_t->array_element_basic_type()); - case Op_XorV: return new (C, 3) XorVNode(n1, n2, vlen, opd_t->array_element_basic_type()); + case Op_AndV: return new (C, 3) AndVNode(n1, n2, vt); + case Op_OrV: return new (C, 3) OrVNode (n1, n2, vt); + case Op_XorV: return new (C, 3) XorVNode(n1, n2, vt); } ShouldNotReachHere(); return NULL; + +} + +// Scalar promotion +VectorNode* VectorNode::scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t) { + BasicType bt = opd_t->array_element_basic_type(); + const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen) + : TypeVect::make(bt, vlen); + switch (bt) { + case T_BOOLEAN: + case T_BYTE: + return new (C, 2) ReplicateBNode(s, vt); + case T_CHAR: + case T_SHORT: + return new (C, 2) ReplicateSNode(s, vt); + case T_INT: + return new (C, 2) ReplicateINode(s, vt); + case T_LONG: + return new (C, 2) ReplicateLNode(s, vt); + case T_FLOAT: + return new (C, 2) ReplicateFNode(s, vt); + case T_DOUBLE: + return new (C, 2) ReplicateDNode(s, vt); + } + ShouldNotReachHere(); + return NULL; +} + +// Return initial Pack node. Additional operands added with add_opd() calls. +PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) { + const TypeVect* vt = TypeVect::make(bt, vlen); + switch (bt) { + case T_BOOLEAN: + case T_BYTE: + return new (C, vlen+1) PackBNode(s, vt); + case T_CHAR: + case T_SHORT: + return new (C, vlen+1) PackSNode(s, vt); + case T_INT: + return new (C, vlen+1) PackINode(s, vt); + case T_LONG: + return new (C, vlen+1) PackLNode(s, vt); + case T_FLOAT: + return new (C, vlen+1) PackFNode(s, vt); + case T_DOUBLE: + return new (C, vlen+1) PackDNode(s, vt); + } + ShouldNotReachHere(); + return NULL; +} + +// Create a binary tree form for Packs. [lo, hi) (half-open) range +Node* PackNode::binaryTreePack(Compile* C, int lo, int hi) { + int ct = hi - lo; + assert(is_power_of_2(ct), "power of 2"); + if (ct == 2) { + PackNode* pk = PackNode::make(C, in(lo), 2, vect_type()->element_basic_type()); + pk->add_opd(1, in(lo+1)); + return pk; + + } else { + int mid = lo + ct/2; + Node* n1 = binaryTreePack(C, lo, mid); + Node* n2 = binaryTreePack(C, mid, hi ); + + BasicType bt = vect_type()->element_basic_type(); + switch (bt) { + case T_BOOLEAN: + case T_BYTE: + return new (C, 3) PackSNode(n1, n2, TypeVect::make(T_SHORT, 2)); + case T_CHAR: + case T_SHORT: + return new (C, 3) PackINode(n1, n2, TypeVect::make(T_INT, 2)); + case T_INT: + return new (C, 3) PackLNode(n1, n2, TypeVect::make(T_LONG, 2)); + case T_LONG: + return new (C, 3) Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2)); + case T_FLOAT: + return new (C, 3) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); + case T_DOUBLE: + return new (C, 3) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); + } + ShouldNotReachHere(); + } + return NULL; } // Return the vector version of a scalar load node. -VectorLoadNode* VectorLoadNode::make(Compile* C, int opc, Node* ctl, Node* mem, - Node* adr, const TypePtr* atyp, uint vlen) { - int vopc = opcode(opc, vlen); - - switch(vopc) { - case Op_Load16B: return new (C, 3) Load16BNode(ctl, mem, adr, atyp); - case Op_Load8B: return new (C, 3) Load8BNode(ctl, mem, adr, atyp); - case Op_Load4B: return new (C, 3) Load4BNode(ctl, mem, adr, atyp); - - case Op_Load8C: return new (C, 3) Load8CNode(ctl, mem, adr, atyp); - case Op_Load4C: return new (C, 3) Load4CNode(ctl, mem, adr, atyp); - case Op_Load2C: return new (C, 3) Load2CNode(ctl, mem, adr, atyp); - - case Op_Load8S: return new (C, 3) Load8SNode(ctl, mem, adr, atyp); - case Op_Load4S: return new (C, 3) Load4SNode(ctl, mem, adr, atyp); - case Op_Load2S: return new (C, 3) Load2SNode(ctl, mem, adr, atyp); - - case Op_Load4I: return new (C, 3) Load4INode(ctl, mem, adr, atyp); - case Op_Load2I: return new (C, 3) Load2INode(ctl, mem, adr, atyp); - - case Op_Load2L: return new (C, 3) Load2LNode(ctl, mem, adr, atyp); - - case Op_Load4F: return new (C, 3) Load4FNode(ctl, mem, adr, atyp); - case Op_Load2F: return new (C, 3) Load2FNode(ctl, mem, adr, atyp); - - case Op_Load2D: return new (C, 3) Load2DNode(ctl, mem, adr, atyp); - } - ShouldNotReachHere(); +LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, + Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) { + const TypeVect* vt = TypeVect::make(bt, vlen); + return new (C, 3) LoadVectorNode(ctl, mem, adr, atyp, vt); return NULL; } // Return the vector version of a scalar store node. -VectorStoreNode* VectorStoreNode::make(Compile* C, int opc, Node* ctl, Node* mem, +StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, Node* adr, const TypePtr* atyp, Node* val, uint vlen) { - int vopc = opcode(opc, vlen); - - switch(vopc) { - case Op_Store16B: return new (C, 4) Store16BNode(ctl, mem, adr, atyp, val); - case Op_Store8B: return new (C, 4) Store8BNode(ctl, mem, adr, atyp, val); - case Op_Store4B: return new (C, 4) Store4BNode(ctl, mem, adr, atyp, val); - - case Op_Store8C: return new (C, 4) Store8CNode(ctl, mem, adr, atyp, val); - case Op_Store4C: return new (C, 4) Store4CNode(ctl, mem, adr, atyp, val); - case Op_Store2C: return new (C, 4) Store2CNode(ctl, mem, adr, atyp, val); - - case Op_Store4I: return new (C, 4) Store4INode(ctl, mem, adr, atyp, val); - case Op_Store2I: return new (C, 4) Store2INode(ctl, mem, adr, atyp, val); - - case Op_Store2L: return new (C, 4) Store2LNode(ctl, mem, adr, atyp, val); - - case Op_Store4F: return new (C, 4) Store4FNode(ctl, mem, adr, atyp, val); - case Op_Store2F: return new (C, 4) Store2FNode(ctl, mem, adr, atyp, val); - - case Op_Store2D: return new (C, 4) Store2DNode(ctl, mem, adr, atyp, val); - } - ShouldNotReachHere(); - return NULL; + return new (C, 4) StoreVectorNode(ctl, mem, adr, atyp, val); } // Extract a scalar element of vector. -Node* ExtractNode::make(Compile* C, Node* v, uint position, const Type* opd_t) { - BasicType bt = opd_t->array_element_basic_type(); - assert(position < VectorNode::max_vlen(bt), "pos in range"); +Node* ExtractNode::make(Compile* C, Node* v, uint position, BasicType bt) { + assert((int)position < Matcher::max_vector_size(bt), "pos in range"); ConINode* pos = ConINode::make(C, (int)position); switch (bt) { case T_BOOLEAN: + return new (C, 3) ExtractUBNode(v, pos); case T_BYTE: return new (C, 3) ExtractBNode(v, pos); case T_CHAR: @@ -478,3 +307,4 @@ Node* ExtractNode::make(Compile* C, Node* v, uint position, const Type* opd_t) { ShouldNotReachHere(); return NULL; } + diff --git a/hotspot/src/share/vm/opto/vectornode.hpp b/hotspot/src/share/vm/opto/vectornode.hpp index 7d1905c7fb5..602ee94c54c 100644 --- a/hotspot/src/share/vm/opto/vectornode.hpp +++ b/hotspot/src/share/vm/opto/vectornode.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -31,48 +31,32 @@ //------------------------------VectorNode-------------------------------------- // Vector Operation -class VectorNode : public Node { - virtual uint size_of() const { return sizeof(*this); } - protected: - uint _length; // vector length - virtual BasicType elt_basic_type() const = 0; // Vector element basic type - - static const Type* vect_type(BasicType elt_bt, uint len); - static const Type* vect_type(const Type* elt_type, uint len) { - return vect_type(elt_type->array_element_basic_type(), len); - } - +class VectorNode : public TypeNode { public: - friend class VectorLoadNode; // For vect_type - friend class VectorStoreNode; // ditto. - VectorNode(Node* n1, uint vlen) : Node(NULL, n1), _length(vlen) { + VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) { init_class_id(Class_Vector); + init_req(1, n1); } - VectorNode(Node* n1, Node* n2, uint vlen) : Node(NULL, n1, n2), _length(vlen) { + VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) { init_class_id(Class_Vector); + init_req(1, n1); + init_req(2, n2); } + + const TypeVect* vect_type() const { return type()->is_vect(); } + uint length() const { return vect_type()->length(); } // Vector length + virtual int Opcode() const; - uint length() const { return _length; } // Vector length - - static uint max_vlen(BasicType bt) { // max vector length - return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes(bt)); - } - - // Element and vector type - const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); } - const Type* vect_type() const { return vect_type(elt_basic_type(), length()); } - - virtual const Type *bottom_type() const { return vect_type(); } - virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); } - - // Vector opcode from scalar opcode - static int opcode(int sopc, uint vlen, const Type* opd_t); + virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); } static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t); - static VectorNode* make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* elt_t); + static VectorNode* make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt); + + static int opcode(int opc, uint vlen, BasicType bt); + static bool implemented(int opc, uint vlen, BasicType bt); }; @@ -81,981 +65,393 @@ class VectorNode : public Node { //------------------------------AddVBNode--------------------------------------- // Vector add byte class AddVBNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } public: - AddVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} - virtual int Opcode() const; -}; - -//------------------------------AddVCNode--------------------------------------- -// Vector add char -class AddVCNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - AddVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------AddVSNode--------------------------------------- -// Vector add short +// Vector add char/short class AddVSNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } public: - AddVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------AddVINode--------------------------------------- // Vector add int class AddVINode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } public: - AddVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------AddVLNode--------------------------------------- // Vector add long class AddVLNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_LONG; } public: - AddVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------AddVFNode--------------------------------------- // Vector add float class AddVFNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } public: - AddVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------AddVDNode--------------------------------------- // Vector add double class AddVDNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_DOUBLE; } public: - AddVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------SubVBNode--------------------------------------- // Vector subtract byte class SubVBNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } public: - SubVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} - virtual int Opcode() const; -}; - -//------------------------------SubVCNode--------------------------------------- -// Vector subtract char -class SubVCNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - SubVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------SubVSNode--------------------------------------- // Vector subtract short class SubVSNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } public: - SubVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------SubVINode--------------------------------------- // Vector subtract int class SubVINode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } public: - SubVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------SubVLNode--------------------------------------- // Vector subtract long class SubVLNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_LONG; } public: - SubVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------SubVFNode--------------------------------------- // Vector subtract float class SubVFNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } public: - SubVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------SubVDNode--------------------------------------- // Vector subtract double class SubVDNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_DOUBLE; } public: - SubVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------MulVFNode--------------------------------------- // Vector multiply float class MulVFNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } public: - MulVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------MulVDNode--------------------------------------- // Vector multiply double class MulVDNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_DOUBLE; } public: - MulVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------DivVFNode--------------------------------------- // Vector divide float class DivVFNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } public: - DivVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------DivVDNode--------------------------------------- // Vector Divide double class DivVDNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_DOUBLE; } public: - DivVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------LShiftVBNode--------------------------------------- // Vector lshift byte class LShiftVBNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } public: - LShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} - virtual int Opcode() const; -}; - -//------------------------------LShiftVCNode--------------------------------------- -// Vector lshift chars -class LShiftVCNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - LShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------LShiftVSNode--------------------------------------- // Vector lshift shorts class LShiftVSNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } public: - LShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------LShiftVINode--------------------------------------- // Vector lshift ints class LShiftVINode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } public: - LShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------URShiftVBNode--------------------------------------- // Vector urshift bytes -class URShiftVBNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } +class RShiftVBNode : public VectorNode { public: - URShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} - virtual int Opcode() const; -}; - -//------------------------------URShiftVCNode--------------------------------------- -// Vector urshift char -class URShiftVCNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } - public: - URShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------URShiftVSNode--------------------------------------- // Vector urshift shorts -class URShiftVSNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } +class RShiftVSNode : public VectorNode { public: - URShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------URShiftVINode--------------------------------------- // Vector urshift ints -class URShiftVINode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } +class RShiftVINode : public VectorNode { public: - URShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} + RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------AndVNode--------------------------------------- // Vector and class AndVNode : public VectorNode { - protected: - BasicType _bt; - virtual BasicType elt_basic_type() const { return _bt; } public: - AndVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {} + AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------OrVNode--------------------------------------- // Vector or class OrVNode : public VectorNode { - protected: - BasicType _bt; - virtual BasicType elt_basic_type() const { return _bt; } public: - OrVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {} + OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; //------------------------------XorVNode--------------------------------------- // Vector xor class XorVNode : public VectorNode { - protected: - BasicType _bt; - virtual BasicType elt_basic_type() const { return _bt; } public: - XorVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {} + XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} virtual int Opcode() const; }; -//================================= M E M O R Y ================================== - - -//------------------------------VectorLoadNode-------------------------------------- -// Vector Load from memory -class VectorLoadNode : public LoadNode { - virtual uint size_of() const { return sizeof(*this); } - - protected: - virtual BasicType elt_basic_type() const = 0; // Vector element basic type - // For use in constructor - static const Type* vect_type(const Type* elt_type, uint len) { - return VectorNode::vect_type(elt_type, len); - } +//================================= M E M O R Y =============================== +//------------------------------LoadVectorNode--------------------------------- +// Load Vector from memory +class LoadVectorNode : public LoadNode { public: - VectorLoadNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *rt) - : LoadNode(c,mem,adr,at,rt) { - init_class_id(Class_VectorLoad); + LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt) + : LoadNode(c, mem, adr, at, vt) { + init_class_id(Class_LoadVector); } + + const TypeVect* vect_type() const { return type()->is_vect(); } + uint length() const { return vect_type()->length(); } // Vector length + virtual int Opcode() const; - virtual uint length() const = 0; // Vector length - - // Element and vector type - const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); } - const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); } - - virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); } + virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); } virtual BasicType memory_type() const { return T_VOID; } - virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); } + virtual int memory_size() const { return vect_type()->length_in_bytes(); } - // Vector opcode from scalar opcode - static int opcode(int sopc, uint vlen); + virtual int store_Opcode() const { return Op_StoreVector; } - static VectorLoadNode* make(Compile* C, int opc, Node* ctl, Node* mem, - Node* adr, const TypePtr* atyp, uint vlen); + static LoadVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem, + Node* adr, const TypePtr* atyp, uint vlen, BasicType bt); }; -//------------------------------Load16BNode-------------------------------------- -// Vector load of 16 bytes (8bits signed) from memory -class Load16BNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } +//------------------------------StoreVectorNode-------------------------------- +// Store Vector to memory +class StoreVectorNode : public StoreNode { public: - Load16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,16)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store16B; } - virtual uint length() const { return 16; } -}; - -//------------------------------Load8BNode-------------------------------------- -// Vector load of 8 bytes (8bits signed) from memory -class Load8BNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } - public: - Load8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store8B; } - virtual uint length() const { return 8; } -}; - -//------------------------------Load4BNode-------------------------------------- -// Vector load of 4 bytes (8bits signed) from memory -class Load4BNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } - public: - Load4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store4B; } - virtual uint length() const { return 4; } -}; - -//------------------------------Load8CNode-------------------------------------- -// Vector load of 8 chars (16bits unsigned) from memory -class Load8CNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - Load8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store8C; } - virtual uint length() const { return 8; } -}; - -//------------------------------Load4CNode-------------------------------------- -// Vector load of 4 chars (16bits unsigned) from memory -class Load4CNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - Load4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store4C; } - virtual uint length() const { return 4; } -}; - -//------------------------------Load2CNode-------------------------------------- -// Vector load of 2 chars (16bits unsigned) from memory -class Load2CNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - Load2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store2C; } - virtual uint length() const { return 2; } -}; - -//------------------------------Load8SNode-------------------------------------- -// Vector load of 8 shorts (16bits signed) from memory -class Load8SNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } - public: - Load8SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store8C; } - virtual uint length() const { return 8; } -}; - -//------------------------------Load4SNode-------------------------------------- -// Vector load of 4 shorts (16bits signed) from memory -class Load4SNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } - public: - Load4SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store4C; } - virtual uint length() const { return 4; } -}; - -//------------------------------Load2SNode-------------------------------------- -// Vector load of 2 shorts (16bits signed) from memory -class Load2SNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } - public: - Load2SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store2C; } - virtual uint length() const { return 2; } -}; - -//------------------------------Load4INode-------------------------------------- -// Vector load of 4 integers (32bits signed) from memory -class Load4INode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } - public: - Load4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store4I; } - virtual uint length() const { return 4; } -}; - -//------------------------------Load2INode-------------------------------------- -// Vector load of 2 integers (32bits signed) from memory -class Load2INode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } - public: - Load2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT) - : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store2I; } - virtual uint length() const { return 2; } -}; - -//------------------------------Load2LNode-------------------------------------- -// Vector load of 2 longs (64bits signed) from memory -class Load2LNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_LONG; } - public: - Load2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeLong *tl = TypeLong::LONG) - : VectorLoadNode(c,mem,adr,at,vect_type(tl,2)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store2L; } - virtual uint length() const { return 2; } -}; - -//------------------------------Load4FNode-------------------------------------- -// Vector load of 4 floats (32bits) from memory -class Load4FNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } - public: - Load4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT) - : VectorLoadNode(c,mem,adr,at,vect_type(t,4)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store4F; } - virtual uint length() const { return 4; } -}; - -//------------------------------Load2FNode-------------------------------------- -// Vector load of 2 floats (32bits) from memory -class Load2FNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } - public: - Load2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT) - : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store2F; } - virtual uint length() const { return 2; } -}; - -//------------------------------Load2DNode-------------------------------------- -// Vector load of 2 doubles (64bits) from memory -class Load2DNode : public VectorLoadNode { - protected: - virtual BasicType elt_basic_type() const { return T_DOUBLE; } - public: - Load2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::DOUBLE) - : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_Store2D; } - virtual uint length() const { return 2; } -}; - - -//------------------------------VectorStoreNode-------------------------------------- -// Vector Store to memory -class VectorStoreNode : public StoreNode { - virtual uint size_of() const { return sizeof(*this); } - - protected: - virtual BasicType elt_basic_type() const = 0; // Vector element basic type - - public: - VectorStoreNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : StoreNode(c,mem,adr,at,val) { - init_class_id(Class_VectorStore); + StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) + : StoreNode(c, mem, adr, at, val) { + assert(val->is_Vector() || val->is_LoadVector(), "sanity"); + init_class_id(Class_StoreVector); } + + const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); } + uint length() const { return vect_type()->length(); } // Vector length + virtual int Opcode() const; - virtual uint length() const = 0; // Vector length - - // Element and vector type - const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); } - const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); } - - virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); } + virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); } virtual BasicType memory_type() const { return T_VOID; } - virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); } + virtual int memory_size() const { return vect_type()->length_in_bytes(); } - // Vector opcode from scalar opcode - static int opcode(int sopc, uint vlen); - - static VectorStoreNode* make(Compile* C, int opc, Node* ctl, Node* mem, + static StoreVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem, Node* adr, const TypePtr* atyp, Node* val, uint vlen); }; -//------------------------------Store16BNode-------------------------------------- -// Vector store of 16 bytes (8bits signed) to memory -class Store16BNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } - public: - Store16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 16; } -}; -//------------------------------Store8BNode-------------------------------------- -// Vector store of 8 bytes (8bits signed) to memory -class Store8BNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } - public: - Store8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 8; } -}; +//=========================Promote_Scalar_to_Vector============================ -//------------------------------Store4BNode-------------------------------------- -// Vector store of 4 bytes (8bits signed) to memory -class Store4BNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } +//------------------------------ReplicateBNode--------------------------------- +// Replicate byte scalar to be vector +class ReplicateBNode : public VectorNode { public: - Store4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 4; } -}; - -//------------------------------Store8CNode-------------------------------------- -// Vector store of 8 chars (16bits signed/unsigned) to memory -class Store8CNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - Store8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 8; } -}; - -//------------------------------Store4CNode-------------------------------------- -// Vector store of 4 chars (16bits signed/unsigned) to memory -class Store4CNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - Store4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 4; } -}; - -//------------------------------Store2CNode-------------------------------------- -// Vector store of 2 chars (16bits signed/unsigned) to memory -class Store2CNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - Store2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 2; } -}; - -//------------------------------Store4INode-------------------------------------- -// Vector store of 4 integers (32bits signed) to memory -class Store4INode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } - public: - Store4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 4; } -}; - -//------------------------------Store2INode-------------------------------------- -// Vector store of 2 integers (32bits signed) to memory -class Store2INode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } - public: - Store2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 2; } -}; - -//------------------------------Store2LNode-------------------------------------- -// Vector store of 2 longs (64bits signed) to memory -class Store2LNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_LONG; } - public: - Store2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 2; } -}; - -//------------------------------Store4FNode-------------------------------------- -// Vector store of 4 floats (32bits) to memory -class Store4FNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } - public: - Store4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 4; } -}; - -//------------------------------Store2FNode-------------------------------------- -// Vector store of 2 floats (32bits) to memory -class Store2FNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } - public: - Store2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 2; } -}; - -//------------------------------Store2DNode-------------------------------------- -// Vector store of 2 doubles (64bits) to memory -class Store2DNode : public VectorStoreNode { - protected: - virtual BasicType elt_basic_type() const { return T_DOUBLE; } - public: - Store2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) - : VectorStoreNode(c,mem,adr,at,val) {} - virtual int Opcode() const; - virtual uint length() const { return 2; } -}; - -//=========================Promote_Scalar_to_Vector==================================== - -//------------------------------Replicate16BNode--------------------------------------- -// Replicate byte scalar to be vector of 16 bytes -class Replicate16BNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } - public: - Replicate16BNode(Node* in1) : VectorNode(in1, 16) {} + ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} virtual int Opcode() const; }; -//------------------------------Replicate8BNode--------------------------------------- -// Replicate byte scalar to be vector of 8 bytes -class Replicate8BNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } +//------------------------------ReplicateSNode--------------------------------- +// Replicate short scalar to be vector +class ReplicateSNode : public VectorNode { public: - Replicate8BNode(Node* in1) : VectorNode(in1, 8) {} + ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} virtual int Opcode() const; }; -//------------------------------Replicate4BNode--------------------------------------- -// Replicate byte scalar to be vector of 4 bytes -class Replicate4BNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } +//------------------------------ReplicateINode--------------------------------- +// Replicate int scalar to be vector +class ReplicateINode : public VectorNode { public: - Replicate4BNode(Node* in1) : VectorNode(in1, 4) {} + ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} virtual int Opcode() const; }; -//------------------------------Replicate8CNode--------------------------------------- -// Replicate char scalar to be vector of 8 chars -class Replicate8CNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } +//------------------------------ReplicateLNode--------------------------------- +// Replicate long scalar to be vector +class ReplicateLNode : public VectorNode { public: - Replicate8CNode(Node* in1) : VectorNode(in1, 8) {} + ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} virtual int Opcode() const; }; -//------------------------------Replicate4CNode--------------------------------------- -// Replicate char scalar to be vector of 4 chars -class Replicate4CNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } +//------------------------------ReplicateFNode--------------------------------- +// Replicate float scalar to be vector +class ReplicateFNode : public VectorNode { public: - Replicate4CNode(Node* in1) : VectorNode(in1, 4) {} + ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} virtual int Opcode() const; }; -//------------------------------Replicate2CNode--------------------------------------- -// Replicate char scalar to be vector of 2 chars -class Replicate2CNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } +//------------------------------ReplicateDNode--------------------------------- +// Replicate double scalar to be vector +class ReplicateDNode : public VectorNode { public: - Replicate2CNode(Node* in1) : VectorNode(in1, 2) {} + ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} virtual int Opcode() const; }; -//------------------------------Replicate8SNode--------------------------------------- -// Replicate short scalar to be vector of 8 shorts -class Replicate8SNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } - public: - Replicate8SNode(Node* in1) : VectorNode(in1, 8) {} - virtual int Opcode() const; -}; - -//------------------------------Replicate4SNode--------------------------------------- -// Replicate short scalar to be vector of 4 shorts -class Replicate4SNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } - public: - Replicate4SNode(Node* in1) : VectorNode(in1, 4) {} - virtual int Opcode() const; -}; - -//------------------------------Replicate2SNode--------------------------------------- -// Replicate short scalar to be vector of 2 shorts -class Replicate2SNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } - public: - Replicate2SNode(Node* in1) : VectorNode(in1, 2) {} - virtual int Opcode() const; -}; - -//------------------------------Replicate4INode--------------------------------------- -// Replicate int scalar to be vector of 4 ints -class Replicate4INode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } - public: - Replicate4INode(Node* in1) : VectorNode(in1, 4) {} - virtual int Opcode() const; -}; - -//------------------------------Replicate2INode--------------------------------------- -// Replicate int scalar to be vector of 2 ints -class Replicate2INode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } - public: - Replicate2INode(Node* in1) : VectorNode(in1, 2) {} - virtual int Opcode() const; -}; - -//------------------------------Replicate2LNode--------------------------------------- -// Replicate long scalar to be vector of 2 longs -class Replicate2LNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_LONG; } - public: - Replicate2LNode(Node* in1) : VectorNode(in1, 2) {} - virtual int Opcode() const; -}; - -//------------------------------Replicate4FNode--------------------------------------- -// Replicate float scalar to be vector of 4 floats -class Replicate4FNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } - public: - Replicate4FNode(Node* in1) : VectorNode(in1, 4) {} - virtual int Opcode() const; -}; - -//------------------------------Replicate2FNode--------------------------------------- -// Replicate float scalar to be vector of 2 floats -class Replicate2FNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } - public: - Replicate2FNode(Node* in1) : VectorNode(in1, 2) {} - virtual int Opcode() const; -}; - -//------------------------------Replicate2DNode--------------------------------------- -// Replicate double scalar to be vector of 2 doubles -class Replicate2DNode : public VectorNode { - protected: - virtual BasicType elt_basic_type() const { return T_DOUBLE; } - public: - Replicate2DNode(Node* in1) : VectorNode(in1, 2) {} - virtual int Opcode() const; -}; - -//========================Pack_Scalars_into_a_Vector============================== +//========================Pack_Scalars_into_a_Vector=========================== //------------------------------PackNode--------------------------------------- // Pack parent class (not for code generation). class PackNode : public VectorNode { public: - PackNode(Node* in1) : VectorNode(in1, 1) {} - PackNode(Node* in1, Node* n2) : VectorNode(in1, n2, 2) {} + PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} + PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {} virtual int Opcode() const; - void add_opd(Node* n) { - add_req(n); - _length++; - assert(_length == req() - 1, "vector length matches edge count"); + void add_opd(uint i, Node* n) { + init_req(i+1, n); } // Create a binary tree form for Packs. [lo, hi) (half-open) range Node* binaryTreePack(Compile* C, int lo, int hi); - static PackNode* make(Compile* C, Node* s, const Type* elt_t); + static PackNode* make(Compile* C, Node* s, uint vlen, BasicType bt); }; //------------------------------PackBNode--------------------------------------- // Pack byte scalars into vector class PackBNode : public PackNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } public: - PackBNode(Node* in1) : PackNode(in1) {} - virtual int Opcode() const; -}; - -//------------------------------PackCNode--------------------------------------- -// Pack char scalars into vector -class PackCNode : public PackNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - PackCNode(Node* in1) : PackNode(in1) {} + PackBNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} virtual int Opcode() const; }; //------------------------------PackSNode--------------------------------------- // Pack short scalars into a vector class PackSNode : public PackNode { - protected: - virtual BasicType elt_basic_type() const { return T_SHORT; } public: - PackSNode(Node* in1) : PackNode(in1) {} + PackSNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} + PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} virtual int Opcode() const; }; //------------------------------PackINode--------------------------------------- // Pack integer scalars into a vector class PackINode : public PackNode { - protected: - virtual BasicType elt_basic_type() const { return T_INT; } public: - PackINode(Node* in1) : PackNode(in1) {} - PackINode(Node* in1, Node* in2) : PackNode(in1, in2) {} + PackINode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} + PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} virtual int Opcode() const; }; //------------------------------PackLNode--------------------------------------- // Pack long scalars into a vector class PackLNode : public PackNode { - protected: - virtual BasicType elt_basic_type() const { return T_LONG; } public: - PackLNode(Node* in1) : PackNode(in1) {} - PackLNode(Node* in1, Node* in2) : PackNode(in1, in2) {} + PackLNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} + PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} + virtual int Opcode() const; +}; + +//------------------------------Pack2LNode-------------------------------------- +// Pack 2 long scalars into a vector +class Pack2LNode : public PackNode { + public: + Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} virtual int Opcode() const; }; //------------------------------PackFNode--------------------------------------- // Pack float scalars into vector class PackFNode : public PackNode { - protected: - virtual BasicType elt_basic_type() const { return T_FLOAT; } public: - PackFNode(Node* in1) : PackNode(in1) {} - PackFNode(Node* in1, Node* in2) : PackNode(in1, in2) {} + PackFNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} + PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} virtual int Opcode() const; }; //------------------------------PackDNode--------------------------------------- // Pack double scalars into a vector class PackDNode : public PackNode { - protected: - virtual BasicType elt_basic_type() const { return T_DOUBLE; } public: - PackDNode(Node* in1) : PackNode(in1) {} - PackDNode(Node* in1, Node* in2) : PackNode(in1, in2) {} + PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} + PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} virtual int Opcode() const; }; -// The Pack2xN nodes assist code generation. They are created from -// Pack4C, etc. nodes in final_graph_reshape in the form of a -// balanced, binary tree. - -//------------------------------Pack2x1BNode----------------------------------------- -// Pack 2 1-byte integers into vector of 2 bytes -class Pack2x1BNode : public PackNode { - protected: - virtual BasicType elt_basic_type() const { return T_BYTE; } +//------------------------------Pack2DNode-------------------------------------- +// Pack 2 double scalars into a vector +class Pack2DNode : public PackNode { public: - Pack2x1BNode(Node *in1, Node* in2) : PackNode(in1, in2) {} + Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} virtual int Opcode() const; - virtual uint ideal_reg() const { return Op_RegI; } }; -//------------------------------Pack2x2BNode--------------------------------------- -// Pack 2 2-byte integers into vector of 4 bytes -class Pack2x2BNode : public PackNode { - protected: - virtual BasicType elt_basic_type() const { return T_CHAR; } - public: - Pack2x2BNode(Node *in1, Node* in2) : PackNode(in1, in2) {} - virtual int Opcode() const; - virtual uint ideal_reg() const { return Op_RegI; } -}; //========================Extract_Scalar_from_Vector=============================== @@ -1069,7 +465,7 @@ class ExtractNode : public Node { virtual int Opcode() const; uint pos() const { return in(2)->get_int(); } - static Node* make(Compile* C, Node* v, uint position, const Type* opd_t); + static Node* make(Compile* C, Node* v, uint position, BasicType bt); }; //------------------------------ExtractBNode--------------------------------------- @@ -1082,6 +478,16 @@ class ExtractBNode : public ExtractNode { virtual uint ideal_reg() const { return Op_RegI; } }; +//------------------------------ExtractUBNode-------------------------------------- +// Extract a boolean from a vector at position "pos" +class ExtractUBNode : public ExtractNode { + public: + ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} + virtual int Opcode() const; + virtual const Type *bottom_type() const { return TypeInt::INT; } + virtual uint ideal_reg() const { return Op_RegI; } +}; + //------------------------------ExtractCNode--------------------------------------- // Extract a char from a vector at position "pos" class ExtractCNode : public ExtractNode { diff --git a/hotspot/src/share/vm/runtime/vmStructs.cpp b/hotspot/src/share/vm/runtime/vmStructs.cpp index 7045fa8b3ce..67d3391da22 100644 --- a/hotspot/src/share/vm/runtime/vmStructs.cpp +++ b/hotspot/src/share/vm/runtime/vmStructs.cpp @@ -1944,14 +1944,12 @@ static inline uint64_t cast_uint64_t(size_t x) declare_c2_type(ReverseBytesLNode, Node) \ declare_c2_type(VectorNode, Node) \ declare_c2_type(AddVBNode, VectorNode) \ - declare_c2_type(AddVCNode, VectorNode) \ declare_c2_type(AddVSNode, VectorNode) \ declare_c2_type(AddVINode, VectorNode) \ declare_c2_type(AddVLNode, VectorNode) \ declare_c2_type(AddVFNode, VectorNode) \ declare_c2_type(AddVDNode, VectorNode) \ declare_c2_type(SubVBNode, VectorNode) \ - declare_c2_type(SubVCNode, VectorNode) \ declare_c2_type(SubVSNode, VectorNode) \ declare_c2_type(SubVINode, VectorNode) \ declare_c2_type(SubVLNode, VectorNode) \ @@ -1962,73 +1960,33 @@ static inline uint64_t cast_uint64_t(size_t x) declare_c2_type(DivVFNode, VectorNode) \ declare_c2_type(DivVDNode, VectorNode) \ declare_c2_type(LShiftVBNode, VectorNode) \ - declare_c2_type(LShiftVCNode, VectorNode) \ declare_c2_type(LShiftVSNode, VectorNode) \ declare_c2_type(LShiftVINode, VectorNode) \ - declare_c2_type(URShiftVBNode, VectorNode) \ - declare_c2_type(URShiftVCNode, VectorNode) \ - declare_c2_type(URShiftVSNode, VectorNode) \ - declare_c2_type(URShiftVINode, VectorNode) \ + declare_c2_type(RShiftVBNode, VectorNode) \ + declare_c2_type(RShiftVSNode, VectorNode) \ + declare_c2_type(RShiftVINode, VectorNode) \ declare_c2_type(AndVNode, VectorNode) \ declare_c2_type(OrVNode, VectorNode) \ declare_c2_type(XorVNode, VectorNode) \ - declare_c2_type(VectorLoadNode, LoadNode) \ - declare_c2_type(Load16BNode, VectorLoadNode) \ - declare_c2_type(Load8BNode, VectorLoadNode) \ - declare_c2_type(Load4BNode, VectorLoadNode) \ - declare_c2_type(Load8CNode, VectorLoadNode) \ - declare_c2_type(Load4CNode, VectorLoadNode) \ - declare_c2_type(Load2CNode, VectorLoadNode) \ - declare_c2_type(Load8SNode, VectorLoadNode) \ - declare_c2_type(Load4SNode, VectorLoadNode) \ - declare_c2_type(Load2SNode, VectorLoadNode) \ - declare_c2_type(Load4INode, VectorLoadNode) \ - declare_c2_type(Load2INode, VectorLoadNode) \ - declare_c2_type(Load2LNode, VectorLoadNode) \ - declare_c2_type(Load4FNode, VectorLoadNode) \ - declare_c2_type(Load2FNode, VectorLoadNode) \ - declare_c2_type(Load2DNode, VectorLoadNode) \ - declare_c2_type(VectorStoreNode, StoreNode) \ - declare_c2_type(Store16BNode, VectorStoreNode) \ - declare_c2_type(Store8BNode, VectorStoreNode) \ - declare_c2_type(Store4BNode, VectorStoreNode) \ - declare_c2_type(Store8CNode, VectorStoreNode) \ - declare_c2_type(Store4CNode, VectorStoreNode) \ - declare_c2_type(Store2CNode, VectorStoreNode) \ - declare_c2_type(Store4INode, VectorStoreNode) \ - declare_c2_type(Store2INode, VectorStoreNode) \ - declare_c2_type(Store2LNode, VectorStoreNode) \ - declare_c2_type(Store4FNode, VectorStoreNode) \ - declare_c2_type(Store2FNode, VectorStoreNode) \ - declare_c2_type(Store2DNode, VectorStoreNode) \ - declare_c2_type(Replicate16BNode, VectorNode) \ - declare_c2_type(Replicate8BNode, VectorNode) \ - declare_c2_type(Replicate4BNode, VectorNode) \ - declare_c2_type(Replicate8CNode, VectorNode) \ - declare_c2_type(Replicate4CNode, VectorNode) \ - declare_c2_type(Replicate2CNode, VectorNode) \ - declare_c2_type(Replicate8SNode, VectorNode) \ - declare_c2_type(Replicate4SNode, VectorNode) \ - declare_c2_type(Replicate2SNode, VectorNode) \ - declare_c2_type(Replicate4INode, VectorNode) \ - declare_c2_type(Replicate2INode, VectorNode) \ - declare_c2_type(Replicate2LNode, VectorNode) \ - declare_c2_type(Replicate4FNode, VectorNode) \ - declare_c2_type(Replicate2FNode, VectorNode) \ - declare_c2_type(Replicate2DNode, VectorNode) \ + declare_c2_type(LoadVectorNode, LoadNode) \ + declare_c2_type(StoreVectorNode, StoreNode) \ + declare_c2_type(ReplicateBNode, VectorNode) \ + declare_c2_type(ReplicateSNode, VectorNode) \ + declare_c2_type(ReplicateINode, VectorNode) \ + declare_c2_type(ReplicateLNode, VectorNode) \ + declare_c2_type(ReplicateFNode, VectorNode) \ + declare_c2_type(ReplicateDNode, VectorNode) \ declare_c2_type(PackNode, VectorNode) \ declare_c2_type(PackBNode, PackNode) \ - declare_c2_type(PackCNode, PackNode) \ declare_c2_type(PackSNode, PackNode) \ declare_c2_type(PackINode, PackNode) \ declare_c2_type(PackLNode, PackNode) \ declare_c2_type(PackFNode, PackNode) \ declare_c2_type(PackDNode, PackNode) \ - declare_c2_type(Pack2x1BNode, PackNode) \ - declare_c2_type(Pack2x2BNode, PackNode) \ + declare_c2_type(Pack2LNode, PackNode) \ + declare_c2_type(Pack2DNode, PackNode) \ declare_c2_type(ExtractNode, Node) \ declare_c2_type(ExtractBNode, ExtractNode) \ - declare_c2_type(ExtractCNode, ExtractNode) \ declare_c2_type(ExtractSNode, ExtractNode) \ declare_c2_type(ExtractINode, ExtractNode) \ declare_c2_type(ExtractLNode, ExtractNode) \ diff --git a/hotspot/test/compiler/7119644/TestBooleanVect.java b/hotspot/test/compiler/7119644/TestBooleanVect.java new file mode 100644 index 00000000000..d4e3ad68d5f --- /dev/null +++ b/hotspot/test/compiler/7119644/TestBooleanVect.java @@ -0,0 +1,952 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestBooleanVect + */ + +public class TestBooleanVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Boolean vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + boolean[] a1 = new boolean[ARRLEN]; + boolean[] a2 = new boolean[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0); + } + for (int i=ALIGN_OFF; i 0); + errn += verify("test_cp_alndst_overlap: a1", i, a1[i], v); + } + for (int i=0; i 0); + errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], v); + } + for (int i=0; i 0); + } + for (int i=UNALIGN_OFF; i 0); + errn += verify("test_cp_unalndst_overlap: a1", i, a1[i], v); + } + for (int i=0; i 0); + errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], v); + } + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = false; + } + } + static void test_vi_neg(boolean[] a, boolean b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b; + } + } + static void test_cp_neg(boolean[] a, boolean[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + } + } + static void test_2ci_neg(boolean[] a, boolean[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = false; + b[i] = false; + } + } + static void test_2vi_neg(boolean[] a, boolean[] b, boolean c, boolean d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_ci_oppos(boolean[] a) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = false; + } + } + static void test_vi_oppos(boolean[] a, boolean b) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[limit-i] = b; + } + } + static void test_cp_oppos(boolean[] a, boolean[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + } + } + static void test_2ci_oppos(boolean[] a, boolean[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = false; + b[i] = false; + } + } + static void test_2vi_oppos(boolean[] a, boolean[] b, boolean c, boolean d) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_ci_off(boolean[] a) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = false; + } + } + static void test_vi_off(boolean[] a, boolean b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b; + } + } + static void test_cp_off(boolean[] a, boolean[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b[i+OFFSET]; + } + } + static void test_2ci_off(boolean[] a, boolean[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = false; + b[i+OFFSET] = false; + } + } + static void test_2vi_off(boolean[] a, boolean[] b, boolean c, boolean d) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = c; + b[i+OFFSET] = d; + } + } + static void test_ci_inv(boolean[] a, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = false; + } + } + static void test_vi_inv(boolean[] a, boolean b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b; + } + } + static void test_cp_inv(boolean[] a, boolean[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b[i+k]; + } + } + static void test_2ci_inv(boolean[] a, boolean[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = false; + b[i+k] = false; + } + } + static void test_2vi_inv(boolean[] a, boolean[] b, boolean c, boolean d, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = c; + b[i+k] = d; + } + } + static void test_ci_scl(boolean[] a) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = false; + } + } + static void test_vi_scl(boolean[] a, boolean b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b; + } + } + static void test_cp_scl(boolean[] a, boolean[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b[i*SCALE]; + } + } + static void test_2ci_scl(boolean[] a, boolean[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = false; + b[i*SCALE] = false; + } + } + static void test_2vi_scl(boolean[] a, boolean[] b, boolean c, boolean d) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = c; + b[i*SCALE] = d; + } + } + static void test_cp_alndst(boolean[] a, boolean[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + } + } + static void test_cp_alnsrc(boolean[] a, boolean[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + } + } + static void test_2ci_aln(boolean[] a, boolean[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = false; + b[i] = false; + } + } + static void test_2vi_aln(boolean[] a, boolean[] b, boolean c, boolean d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_unalndst(boolean[] a, boolean[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + } + } + static void test_cp_unalnsrc(boolean[] a, boolean[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + } + } + static void test_2ci_unaln(boolean[] a, boolean[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = false; + b[i] = false; + } + } + static void test_2vi_unaln(boolean[] a, boolean[] b, boolean c, boolean d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + + static int verify(String text, int i, boolean elem, boolean val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestByteDoubleVect.java b/hotspot/test/compiler/7119644/TestByteDoubleVect.java new file mode 100644 index 00000000000..acf71bf218b --- /dev/null +++ b/hotspot/test/compiler/7119644/TestByteDoubleVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestByteDoubleVect + */ + +public class TestByteDoubleVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Byte + Double vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + byte[] a1 = new byte[ARRLEN]; + byte[] a2 = new byte[ARRLEN]; + double[] b1 = new double[ARRLEN]; + double[] b2 = new double[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103.; + } + } + static void test_vi_neg(byte[] a, double[] b, byte c, double d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(byte[] a, byte[] b, double[] c, double[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(byte[] a, double[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103.; + } + } + static void test_vi_oppos(byte[] a, double[] b, byte c, double d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(byte[] a, byte[] b, double[] c, double[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(byte[] a, double[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103.; + } + } + static void test_vi_aln(byte[] a, double[] b, byte c, double d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(byte[] a, byte[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(byte[] a, byte[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(byte[] a, double[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103.; + } + } + static void test_vi_unaln(byte[] a, double[] b, byte c, double d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(byte[] a, byte[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(byte[] a, byte[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, byte elem, byte val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, double elem, double val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestByteFloatVect.java b/hotspot/test/compiler/7119644/TestByteFloatVect.java new file mode 100644 index 00000000000..45fe34e9577 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestByteFloatVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestByteFloatVect + */ + +public class TestByteFloatVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Byte + Float vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + byte[] a1 = new byte[ARRLEN]; + byte[] a2 = new byte[ARRLEN]; + float[] b1 = new float[ARRLEN]; + float[] b2 = new float[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103.f; + } + } + static void test_vi_neg(byte[] a, float[] b, byte c, float d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(byte[] a, byte[] b, float[] c, float[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(byte[] a, float[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103.f; + } + } + static void test_vi_oppos(byte[] a, float[] b, byte c, float d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(byte[] a, byte[] b, float[] c, float[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(byte[] a, float[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103.f; + } + } + static void test_vi_aln(byte[] a, float[] b, byte c, float d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(byte[] a, byte[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(byte[] a, byte[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(byte[] a, float[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103.f; + } + } + static void test_vi_unaln(byte[] a, float[] b, byte c, float d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(byte[] a, byte[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(byte[] a, byte[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, byte elem, byte val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, float elem, float val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestByteIntVect.java b/hotspot/test/compiler/7119644/TestByteIntVect.java new file mode 100644 index 00000000000..8d9aa6a808b --- /dev/null +++ b/hotspot/test/compiler/7119644/TestByteIntVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestByteIntVect + */ + +public class TestByteIntVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Byte + Integer vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + byte[] a1 = new byte[ARRLEN]; + byte[] a2 = new byte[ARRLEN]; + int[] b1 = new int[ARRLEN]; + int[] b2 = new int[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_vi_neg(byte[] a, int[] b, byte c, int d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(byte[] a, byte[] b, int[] c, int[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(byte[] a, int[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_vi_oppos(byte[] a, int[] b, byte c, int d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(byte[] a, byte[] b, int[] c, int[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(byte[] a, int[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_aln(byte[] a, int[] b, byte c, int d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(byte[] a, byte[] b, int[] c, int[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(byte[] a, byte[] b, int[] c, int[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(byte[] a, int[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_unaln(byte[] a, int[] b, byte c, int d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(byte[] a, byte[] b, int[] c, int[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(byte[] a, byte[] b, int[] c, int[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, byte elem, byte val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, int elem, int val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestByteLongVect.java b/hotspot/test/compiler/7119644/TestByteLongVect.java new file mode 100644 index 00000000000..c2d439057d9 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestByteLongVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestByteLongVect + */ + +public class TestByteLongVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Byte + Long vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + byte[] a1 = new byte[ARRLEN]; + byte[] a2 = new byte[ARRLEN]; + long[] b1 = new long[ARRLEN]; + long[] b2 = new long[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_vi_neg(byte[] a, long[] b, byte c, long d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(byte[] a, byte[] b, long[] c, long[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(byte[] a, long[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_vi_oppos(byte[] a, long[] b, byte c, long d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(byte[] a, byte[] b, long[] c, long[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(byte[] a, long[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_aln(byte[] a, long[] b, byte c, long d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(byte[] a, byte[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(byte[] a, byte[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(byte[] a, long[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_unaln(byte[] a, long[] b, byte c, long d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(byte[] a, byte[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(byte[] a, byte[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, byte elem, byte val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, long elem, long val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestByteShortVect.java b/hotspot/test/compiler/7119644/TestByteShortVect.java new file mode 100644 index 00000000000..ee1a206c1f2 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestByteShortVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestByteShortVect + */ + +public class TestByteShortVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Byte + Short vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + byte[] a1 = new byte[ARRLEN]; + byte[] a2 = new byte[ARRLEN]; + short[] b1 = new short[ARRLEN]; + short[] b2 = new short[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_vi_neg(byte[] a, short[] b, byte c, short d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(byte[] a, byte[] b, short[] c, short[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(byte[] a, short[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_vi_oppos(byte[] a, short[] b, byte c, short d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(byte[] a, byte[] b, short[] c, short[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(byte[] a, short[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_aln(byte[] a, short[] b, byte c, short d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(byte[] a, byte[] b, short[] c, short[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(byte[] a, byte[] b, short[] c, short[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(byte[] a, short[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_unaln(byte[] a, short[] b, byte c, short d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(byte[] a, byte[] b, short[] c, short[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(byte[] a, byte[] b, short[] c, short[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, byte elem, byte val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, short elem, short val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestByteVect.java b/hotspot/test/compiler/7119644/TestByteVect.java new file mode 100644 index 00000000000..6167678acf9 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestByteVect.java @@ -0,0 +1,953 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestByteVect + */ + +public class TestByteVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Byte vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + byte[] a1 = new byte[ARRLEN]; + byte[] a2 = new byte[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + } + } + static void test_vi_neg(byte[] a, byte b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b; + } + } + static void test_cp_neg(byte[] a, byte[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + } + } + static void test_2ci_neg(byte[] a, byte[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_2vi_neg(byte[] a, byte[] b, byte c, byte d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_ci_oppos(byte[] a) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + } + } + static void test_vi_oppos(byte[] a, byte b) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[limit-i] = b; + } + } + static void test_cp_oppos(byte[] a, byte[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + } + } + static void test_2ci_oppos(byte[] a, byte[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_2vi_oppos(byte[] a, byte[] b, byte c, byte d) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_ci_off(byte[] a) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123; + } + } + static void test_vi_off(byte[] a, byte b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b; + } + } + static void test_cp_off(byte[] a, byte[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b[i+OFFSET]; + } + } + static void test_2ci_off(byte[] a, byte[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123; + b[i+OFFSET] = -103; + } + } + static void test_2vi_off(byte[] a, byte[] b, byte c, byte d) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = c; + b[i+OFFSET] = d; + } + } + static void test_ci_inv(byte[] a, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123; + } + } + static void test_vi_inv(byte[] a, byte b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b; + } + } + static void test_cp_inv(byte[] a, byte[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b[i+k]; + } + } + static void test_2ci_inv(byte[] a, byte[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123; + b[i+k] = -103; + } + } + static void test_2vi_inv(byte[] a, byte[] b, byte c, byte d, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = c; + b[i+k] = d; + } + } + static void test_ci_scl(byte[] a) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123; + } + } + static void test_vi_scl(byte[] a, byte b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b; + } + } + static void test_cp_scl(byte[] a, byte[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b[i*SCALE]; + } + } + static void test_2ci_scl(byte[] a, byte[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123; + b[i*SCALE] = -103; + } + } + static void test_2vi_scl(byte[] a, byte[] b, byte c, byte d) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = c; + b[i*SCALE] = d; + } + } + static void test_cp_alndst(byte[] a, byte[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + } + } + static void test_cp_alnsrc(byte[] a, byte[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + } + } + static void test_2ci_aln(byte[] a, byte[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_2vi_aln(byte[] a, byte[] b, byte c, byte d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_unalndst(byte[] a, byte[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + } + } + static void test_cp_unalnsrc(byte[] a, byte[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + } + } + static void test_2ci_unaln(byte[] a, byte[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_2vi_unaln(byte[] a, byte[] b, byte c, byte d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + + static int verify(String text, int i, byte elem, byte val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestCharShortVect.java b/hotspot/test/compiler/7119644/TestCharShortVect.java new file mode 100644 index 00000000000..55f8e03b772 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestCharShortVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestCharShortVect + */ + +public class TestCharShortVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Char + Short vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + char[] a1 = new char[ARRLEN]; + char[] a2 = new char[ARRLEN]; + short[] b1 = new short[ARRLEN]; + short[] b2 = new short[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = (char)-123; + b[i] = (short)-103; + } + } + static void test_vi_neg(char[] a, short[] b, char c, short d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(char[] a, char[] b, short[] c, short[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(char[] a, short[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = (char)-123; + b[i] = (short)-103; + } + } + static void test_vi_oppos(char[] a, short[] b, char c, short d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(char[] a, char[] b, short[] c, short[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(char[] a, short[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = (char)-123; + b[i] = (short)-103; + } + } + static void test_vi_aln(char[] a, short[] b, char c, short d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(char[] a, char[] b, short[] c, short[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(char[] a, char[] b, short[] c, short[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(char[] a, short[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = (char)-123; + b[i] = (short)-103; + } + } + static void test_vi_unaln(char[] a, short[] b, char c, short d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(char[] a, char[] b, short[] c, short[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(char[] a, char[] b, short[] c, short[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, char elem, char val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, short elem, short val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestCharVect.java b/hotspot/test/compiler/7119644/TestCharVect.java new file mode 100644 index 00000000000..d05ed4d1ccd --- /dev/null +++ b/hotspot/test/compiler/7119644/TestCharVect.java @@ -0,0 +1,953 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestCharVect + */ + +public class TestCharVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Char vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + char[] a1 = new char[ARRLEN]; + char[] a2 = new char[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = (char)-123; + } + } + static void test_vi_neg(char[] a, char b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b; + } + } + static void test_cp_neg(char[] a, char[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + } + } + static void test_2ci_neg(char[] a, char[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = (char)-123; + b[i] = (char)-103; + } + } + static void test_2vi_neg(char[] a, char[] b, char c, char d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_ci_oppos(char[] a) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = (char)-123; + } + } + static void test_vi_oppos(char[] a, char b) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[limit-i] = b; + } + } + static void test_cp_oppos(char[] a, char[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + } + } + static void test_2ci_oppos(char[] a, char[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = (char)-123; + b[i] = (char)-103; + } + } + static void test_2vi_oppos(char[] a, char[] b, char c, char d) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_ci_off(char[] a) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = (char)-123; + } + } + static void test_vi_off(char[] a, char b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b; + } + } + static void test_cp_off(char[] a, char[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b[i+OFFSET]; + } + } + static void test_2ci_off(char[] a, char[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = (char)-123; + b[i+OFFSET] = (char)-103; + } + } + static void test_2vi_off(char[] a, char[] b, char c, char d) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = c; + b[i+OFFSET] = d; + } + } + static void test_ci_inv(char[] a, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = (char)-123; + } + } + static void test_vi_inv(char[] a, char b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b; + } + } + static void test_cp_inv(char[] a, char[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b[i+k]; + } + } + static void test_2ci_inv(char[] a, char[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = (char)-123; + b[i+k] = (char)-103; + } + } + static void test_2vi_inv(char[] a, char[] b, char c, char d, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = c; + b[i+k] = d; + } + } + static void test_ci_scl(char[] a) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = (char)-123; + } + } + static void test_vi_scl(char[] a, char b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b; + } + } + static void test_cp_scl(char[] a, char[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b[i*SCALE]; + } + } + static void test_2ci_scl(char[] a, char[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = (char)-123; + b[i*SCALE] = (char)-103; + } + } + static void test_2vi_scl(char[] a, char[] b, char c, char d) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = c; + b[i*SCALE] = d; + } + } + static void test_cp_alndst(char[] a, char[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + } + } + static void test_cp_alnsrc(char[] a, char[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + } + } + static void test_2ci_aln(char[] a, char[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = (char)-123; + b[i] = (char)-103; + } + } + static void test_2vi_aln(char[] a, char[] b, char c, char d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_unalndst(char[] a, char[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + } + } + static void test_cp_unalnsrc(char[] a, char[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + } + } + static void test_2ci_unaln(char[] a, char[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = (char)-123; + b[i] = (char)-103; + } + } + static void test_2vi_unaln(char[] a, char[] b, char c, char d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + + static int verify(String text, int i, char elem, char val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestDoubleVect.java b/hotspot/test/compiler/7119644/TestDoubleVect.java new file mode 100644 index 00000000000..385a64d5a2f --- /dev/null +++ b/hotspot/test/compiler/7119644/TestDoubleVect.java @@ -0,0 +1,953 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestDoubleVect + */ + +public class TestDoubleVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Double vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + double[] a1 = new double[ARRLEN]; + double[] a2 = new double[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123.; + } + } + static void test_vi_neg(double[] a, double b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b; + } + } + static void test_cp_neg(double[] a, double[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + } + } + static void test_2ci_neg(double[] a, double[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = -123.; + b[i] = -103.; + } + } + static void test_2vi_neg(double[] a, double[] b, double c, double d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_ci_oppos(double[] a) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123.; + } + } + static void test_vi_oppos(double[] a, double b) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[limit-i] = b; + } + } + static void test_cp_oppos(double[] a, double[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + } + } + static void test_2ci_oppos(double[] a, double[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123.; + b[i] = -103.; + } + } + static void test_2vi_oppos(double[] a, double[] b, double c, double d) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_ci_off(double[] a) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123.; + } + } + static void test_vi_off(double[] a, double b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b; + } + } + static void test_cp_off(double[] a, double[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b[i+OFFSET]; + } + } + static void test_2ci_off(double[] a, double[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123.; + b[i+OFFSET] = -103.; + } + } + static void test_2vi_off(double[] a, double[] b, double c, double d) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = c; + b[i+OFFSET] = d; + } + } + static void test_ci_inv(double[] a, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123.; + } + } + static void test_vi_inv(double[] a, double b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b; + } + } + static void test_cp_inv(double[] a, double[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b[i+k]; + } + } + static void test_2ci_inv(double[] a, double[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123.; + b[i+k] = -103.; + } + } + static void test_2vi_inv(double[] a, double[] b, double c, double d, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = c; + b[i+k] = d; + } + } + static void test_ci_scl(double[] a) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123.; + } + } + static void test_vi_scl(double[] a, double b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b; + } + } + static void test_cp_scl(double[] a, double[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b[i*SCALE]; + } + } + static void test_2ci_scl(double[] a, double[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123.; + b[i*SCALE] = -103.; + } + } + static void test_2vi_scl(double[] a, double[] b, double c, double d) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = c; + b[i*SCALE] = d; + } + } + static void test_cp_alndst(double[] a, double[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + } + } + static void test_cp_alnsrc(double[] a, double[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + } + } + static void test_2ci_aln(double[] a, double[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123.; + b[i] = -103.; + } + } + static void test_2vi_aln(double[] a, double[] b, double c, double d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_unalndst(double[] a, double[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + } + } + static void test_cp_unalnsrc(double[] a, double[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + } + } + static void test_2ci_unaln(double[] a, double[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123.; + b[i] = -103.; + } + } + static void test_2vi_unaln(double[] a, double[] b, double c, double d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + + static int verify(String text, int i, double elem, double val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestFloatDoubleVect.java b/hotspot/test/compiler/7119644/TestFloatDoubleVect.java new file mode 100644 index 00000000000..827ecdb4615 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestFloatDoubleVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestFloatDoubleVect + */ + +public class TestFloatDoubleVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Float + Double vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + float[] a1 = new float[ARRLEN]; + float[] a2 = new float[ARRLEN]; + double[] b1 = new double[ARRLEN]; + double[] b2 = new double[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123.f; + b[i] = -103.; + } + } + static void test_vi_neg(float[] a, double[] b, float c, double d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(float[] a, float[] b, double[] c, double[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(float[] a, double[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123.f; + b[i] = -103.; + } + } + static void test_vi_oppos(float[] a, double[] b, float c, double d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(float[] a, float[] b, double[] c, double[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(float[] a, double[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123.f; + b[i] = -103.; + } + } + static void test_vi_aln(float[] a, double[] b, float c, double d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(float[] a, float[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(float[] a, float[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(float[] a, double[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123.f; + b[i] = -103.; + } + } + static void test_vi_unaln(float[] a, double[] b, float c, double d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(float[] a, float[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(float[] a, float[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, float elem, float val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, double elem, double val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestFloatVect.java b/hotspot/test/compiler/7119644/TestFloatVect.java new file mode 100644 index 00000000000..825fffed64c --- /dev/null +++ b/hotspot/test/compiler/7119644/TestFloatVect.java @@ -0,0 +1,953 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestFloatVect + */ + +public class TestFloatVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Float vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + float[] a1 = new float[ARRLEN]; + float[] a2 = new float[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123.f; + } + } + static void test_vi_neg(float[] a, float b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b; + } + } + static void test_cp_neg(float[] a, float[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + } + } + static void test_2ci_neg(float[] a, float[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = -123.f; + b[i] = -103.f; + } + } + static void test_2vi_neg(float[] a, float[] b, float c, float d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_ci_oppos(float[] a) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123.f; + } + } + static void test_vi_oppos(float[] a, float b) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[limit-i] = b; + } + } + static void test_cp_oppos(float[] a, float[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + } + } + static void test_2ci_oppos(float[] a, float[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123.f; + b[i] = -103.f; + } + } + static void test_2vi_oppos(float[] a, float[] b, float c, float d) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_ci_off(float[] a) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123.f; + } + } + static void test_vi_off(float[] a, float b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b; + } + } + static void test_cp_off(float[] a, float[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b[i+OFFSET]; + } + } + static void test_2ci_off(float[] a, float[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123.f; + b[i+OFFSET] = -103.f; + } + } + static void test_2vi_off(float[] a, float[] b, float c, float d) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = c; + b[i+OFFSET] = d; + } + } + static void test_ci_inv(float[] a, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123.f; + } + } + static void test_vi_inv(float[] a, float b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b; + } + } + static void test_cp_inv(float[] a, float[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b[i+k]; + } + } + static void test_2ci_inv(float[] a, float[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123.f; + b[i+k] = -103.f; + } + } + static void test_2vi_inv(float[] a, float[] b, float c, float d, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = c; + b[i+k] = d; + } + } + static void test_ci_scl(float[] a) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123.f; + } + } + static void test_vi_scl(float[] a, float b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b; + } + } + static void test_cp_scl(float[] a, float[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b[i*SCALE]; + } + } + static void test_2ci_scl(float[] a, float[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123.f; + b[i*SCALE] = -103.f; + } + } + static void test_2vi_scl(float[] a, float[] b, float c, float d) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = c; + b[i*SCALE] = d; + } + } + static void test_cp_alndst(float[] a, float[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + } + } + static void test_cp_alnsrc(float[] a, float[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + } + } + static void test_2ci_aln(float[] a, float[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123.f; + b[i] = -103.f; + } + } + static void test_2vi_aln(float[] a, float[] b, float c, float d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_unalndst(float[] a, float[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + } + } + static void test_cp_unalnsrc(float[] a, float[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + } + } + static void test_2ci_unaln(float[] a, float[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123.f; + b[i] = -103.f; + } + } + static void test_2vi_unaln(float[] a, float[] b, float c, float d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + + static int verify(String text, int i, float elem, float val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestIntDoubleVect.java b/hotspot/test/compiler/7119644/TestIntDoubleVect.java new file mode 100644 index 00000000000..fc6e32dce05 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestIntDoubleVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestIntDoubleVect + */ + +public class TestIntDoubleVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Integer + Double vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + int[] a1 = new int[ARRLEN]; + int[] a2 = new int[ARRLEN]; + double[] b1 = new double[ARRLEN]; + double[] b2 = new double[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103.; + } + } + static void test_vi_neg(int[] a, double[] b, int c, double d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(int[] a, int[] b, double[] c, double[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(int[] a, double[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103.; + } + } + static void test_vi_oppos(int[] a, double[] b, int c, double d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(int[] a, int[] b, double[] c, double[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(int[] a, double[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103.; + } + } + static void test_vi_aln(int[] a, double[] b, int c, double d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(int[] a, int[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(int[] a, int[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(int[] a, double[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103.; + } + } + static void test_vi_unaln(int[] a, double[] b, int c, double d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(int[] a, int[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(int[] a, int[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, int elem, int val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, double elem, double val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestIntFloatVect.java b/hotspot/test/compiler/7119644/TestIntFloatVect.java new file mode 100644 index 00000000000..e698c890d69 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestIntFloatVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestIntFloatVect + */ + +public class TestIntFloatVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Integer + Float vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + int[] a1 = new int[ARRLEN]; + int[] a2 = new int[ARRLEN]; + float[] b1 = new float[ARRLEN]; + float[] b2 = new float[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103.f; + } + } + static void test_vi_neg(int[] a, float[] b, int c, float d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(int[] a, int[] b, float[] c, float[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(int[] a, float[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103.f; + } + } + static void test_vi_oppos(int[] a, float[] b, int c, float d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(int[] a, int[] b, float[] c, float[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(int[] a, float[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103.f; + } + } + static void test_vi_aln(int[] a, float[] b, int c, float d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(int[] a, int[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(int[] a, int[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(int[] a, float[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103.f; + } + } + static void test_vi_unaln(int[] a, float[] b, int c, float d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(int[] a, int[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(int[] a, int[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, int elem, int val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, float elem, float val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestIntLongVect.java b/hotspot/test/compiler/7119644/TestIntLongVect.java new file mode 100644 index 00000000000..def0d9b1bc2 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestIntLongVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestIntLongVect + */ + +public class TestIntLongVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Integer + Long vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + int[] a1 = new int[ARRLEN]; + int[] a2 = new int[ARRLEN]; + long[] b1 = new long[ARRLEN]; + long[] b2 = new long[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_vi_neg(int[] a, long[] b, int c, long d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(int[] a, int[] b, long[] c, long[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(int[] a, long[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_vi_oppos(int[] a, long[] b, int c, long d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(int[] a, int[] b, long[] c, long[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(int[] a, long[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_aln(int[] a, long[] b, int c, long d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(int[] a, int[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(int[] a, int[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(int[] a, long[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_unaln(int[] a, long[] b, int c, long d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(int[] a, int[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(int[] a, int[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, int elem, int val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, long elem, long val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestIntVect.java b/hotspot/test/compiler/7119644/TestIntVect.java new file mode 100644 index 00000000000..9d3f4e53920 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestIntVect.java @@ -0,0 +1,953 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestIntVect + */ + +public class TestIntVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Integer vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + int[] a1 = new int[ARRLEN]; + int[] a2 = new int[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + } + } + static void test_vi_neg(int[] a, int b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b; + } + } + static void test_cp_neg(int[] a, int[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + } + } + static void test_2ci_neg(int[] a, int[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_2vi_neg(int[] a, int[] b, int c, int d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_ci_oppos(int[] a) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + } + } + static void test_vi_oppos(int[] a, int b) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[limit-i] = b; + } + } + static void test_cp_oppos(int[] a, int[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + } + } + static void test_2ci_oppos(int[] a, int[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_2vi_oppos(int[] a, int[] b, int c, int d) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_ci_off(int[] a) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123; + } + } + static void test_vi_off(int[] a, int b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b; + } + } + static void test_cp_off(int[] a, int[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b[i+OFFSET]; + } + } + static void test_2ci_off(int[] a, int[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123; + b[i+OFFSET] = -103; + } + } + static void test_2vi_off(int[] a, int[] b, int c, int d) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = c; + b[i+OFFSET] = d; + } + } + static void test_ci_inv(int[] a, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123; + } + } + static void test_vi_inv(int[] a, int b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b; + } + } + static void test_cp_inv(int[] a, int[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b[i+k]; + } + } + static void test_2ci_inv(int[] a, int[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123; + b[i+k] = -103; + } + } + static void test_2vi_inv(int[] a, int[] b, int c, int d, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = c; + b[i+k] = d; + } + } + static void test_ci_scl(int[] a) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123; + } + } + static void test_vi_scl(int[] a, int b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b; + } + } + static void test_cp_scl(int[] a, int[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b[i*SCALE]; + } + } + static void test_2ci_scl(int[] a, int[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123; + b[i*SCALE] = -103; + } + } + static void test_2vi_scl(int[] a, int[] b, int c, int d) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = c; + b[i*SCALE] = d; + } + } + static void test_cp_alndst(int[] a, int[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + } + } + static void test_cp_alnsrc(int[] a, int[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + } + } + static void test_2ci_aln(int[] a, int[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_2vi_aln(int[] a, int[] b, int c, int d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_unalndst(int[] a, int[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + } + } + static void test_cp_unalnsrc(int[] a, int[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + } + } + static void test_2ci_unaln(int[] a, int[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_2vi_unaln(int[] a, int[] b, int c, int d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + + static int verify(String text, int i, int elem, int val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestLongDoubleVect.java b/hotspot/test/compiler/7119644/TestLongDoubleVect.java new file mode 100644 index 00000000000..344e3a980bb --- /dev/null +++ b/hotspot/test/compiler/7119644/TestLongDoubleVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestLongDoubleVect + */ + +public class TestLongDoubleVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Long + Double vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + long[] a1 = new long[ARRLEN]; + long[] a2 = new long[ARRLEN]; + double[] b1 = new double[ARRLEN]; + double[] b2 = new double[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103.; + } + } + static void test_vi_neg(long[] a, double[] b, long c, double d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(long[] a, long[] b, double[] c, double[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(long[] a, double[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103.; + } + } + static void test_vi_oppos(long[] a, double[] b, long c, double d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(long[] a, long[] b, double[] c, double[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(long[] a, double[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103.; + } + } + static void test_vi_aln(long[] a, double[] b, long c, double d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(long[] a, long[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(long[] a, long[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(long[] a, double[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103.; + } + } + static void test_vi_unaln(long[] a, double[] b, long c, double d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(long[] a, long[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(long[] a, long[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, long elem, long val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, double elem, double val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestLongFloatVect.java b/hotspot/test/compiler/7119644/TestLongFloatVect.java new file mode 100644 index 00000000000..714f6c83687 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestLongFloatVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestLongFloatVect + */ + +public class TestLongFloatVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Long + Float vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + long[] a1 = new long[ARRLEN]; + long[] a2 = new long[ARRLEN]; + float[] b1 = new float[ARRLEN]; + float[] b2 = new float[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103.f; + } + } + static void test_vi_neg(long[] a, float[] b, long c, float d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(long[] a, long[] b, float[] c, float[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(long[] a, float[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103.f; + } + } + static void test_vi_oppos(long[] a, float[] b, long c, float d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(long[] a, long[] b, float[] c, float[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(long[] a, float[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103.f; + } + } + static void test_vi_aln(long[] a, float[] b, long c, float d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(long[] a, long[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(long[] a, long[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(long[] a, float[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103.f; + } + } + static void test_vi_unaln(long[] a, float[] b, long c, float d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(long[] a, long[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(long[] a, long[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, long elem, long val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, float elem, float val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestLongVect.java b/hotspot/test/compiler/7119644/TestLongVect.java new file mode 100644 index 00000000000..6f0365bb5c1 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestLongVect.java @@ -0,0 +1,953 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestLongVect + */ + +public class TestLongVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Long vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + long[] a1 = new long[ARRLEN]; + long[] a2 = new long[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + } + } + static void test_vi_neg(long[] a, long b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b; + } + } + static void test_cp_neg(long[] a, long[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + } + } + static void test_2ci_neg(long[] a, long[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_2vi_neg(long[] a, long[] b, long c, long d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_ci_oppos(long[] a) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + } + } + static void test_vi_oppos(long[] a, long b) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[limit-i] = b; + } + } + static void test_cp_oppos(long[] a, long[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + } + } + static void test_2ci_oppos(long[] a, long[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_2vi_oppos(long[] a, long[] b, long c, long d) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_ci_off(long[] a) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123; + } + } + static void test_vi_off(long[] a, long b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b; + } + } + static void test_cp_off(long[] a, long[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b[i+OFFSET]; + } + } + static void test_2ci_off(long[] a, long[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123; + b[i+OFFSET] = -103; + } + } + static void test_2vi_off(long[] a, long[] b, long c, long d) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = c; + b[i+OFFSET] = d; + } + } + static void test_ci_inv(long[] a, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123; + } + } + static void test_vi_inv(long[] a, long b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b; + } + } + static void test_cp_inv(long[] a, long[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b[i+k]; + } + } + static void test_2ci_inv(long[] a, long[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123; + b[i+k] = -103; + } + } + static void test_2vi_inv(long[] a, long[] b, long c, long d, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = c; + b[i+k] = d; + } + } + static void test_ci_scl(long[] a) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123; + } + } + static void test_vi_scl(long[] a, long b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b; + } + } + static void test_cp_scl(long[] a, long[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b[i*SCALE]; + } + } + static void test_2ci_scl(long[] a, long[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123; + b[i*SCALE] = -103; + } + } + static void test_2vi_scl(long[] a, long[] b, long c, long d) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = c; + b[i*SCALE] = d; + } + } + static void test_cp_alndst(long[] a, long[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + } + } + static void test_cp_alnsrc(long[] a, long[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + } + } + static void test_2ci_aln(long[] a, long[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_2vi_aln(long[] a, long[] b, long c, long d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_unalndst(long[] a, long[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + } + } + static void test_cp_unalnsrc(long[] a, long[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + } + } + static void test_2ci_unaln(long[] a, long[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_2vi_unaln(long[] a, long[] b, long c, long d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + + static int verify(String text, int i, long elem, long val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestShortDoubleVect.java b/hotspot/test/compiler/7119644/TestShortDoubleVect.java new file mode 100644 index 00000000000..c21037e4c87 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestShortDoubleVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestShortDoubleVect + */ + +public class TestShortDoubleVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Short + Double vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + short[] a1 = new short[ARRLEN]; + short[] a2 = new short[ARRLEN]; + double[] b1 = new double[ARRLEN]; + double[] b2 = new double[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103.; + } + } + static void test_vi_neg(short[] a, double[] b, short c, double d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(short[] a, short[] b, double[] c, double[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(short[] a, double[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103.; + } + } + static void test_vi_oppos(short[] a, double[] b, short c, double d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(short[] a, short[] b, double[] c, double[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(short[] a, double[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103.; + } + } + static void test_vi_aln(short[] a, double[] b, short c, double d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(short[] a, short[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(short[] a, short[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(short[] a, double[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103.; + } + } + static void test_vi_unaln(short[] a, double[] b, short c, double d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(short[] a, short[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(short[] a, short[] b, double[] c, double[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, short elem, short val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, double elem, double val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestShortFloatVect.java b/hotspot/test/compiler/7119644/TestShortFloatVect.java new file mode 100644 index 00000000000..05b4dddd980 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestShortFloatVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestShortFloatVect + */ + +public class TestShortFloatVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Short + Float vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + short[] a1 = new short[ARRLEN]; + short[] a2 = new short[ARRLEN]; + float[] b1 = new float[ARRLEN]; + float[] b2 = new float[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103.f; + } + } + static void test_vi_neg(short[] a, float[] b, short c, float d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(short[] a, short[] b, float[] c, float[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(short[] a, float[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103.f; + } + } + static void test_vi_oppos(short[] a, float[] b, short c, float d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(short[] a, short[] b, float[] c, float[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(short[] a, float[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103.f; + } + } + static void test_vi_aln(short[] a, float[] b, short c, float d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(short[] a, short[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(short[] a, short[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(short[] a, float[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103.f; + } + } + static void test_vi_unaln(short[] a, float[] b, short c, float d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(short[] a, short[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(short[] a, short[] b, float[] c, float[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, short elem, short val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, float elem, float val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestShortIntVect.java b/hotspot/test/compiler/7119644/TestShortIntVect.java new file mode 100644 index 00000000000..bf180940856 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestShortIntVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestShortIntVect + */ + +public class TestShortIntVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Short + Integer vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + short[] a1 = new short[ARRLEN]; + short[] a2 = new short[ARRLEN]; + int[] b1 = new int[ARRLEN]; + int[] b2 = new int[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_vi_neg(short[] a, int[] b, short c, int d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(short[] a, short[] b, int[] c, int[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(short[] a, int[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_vi_oppos(short[] a, int[] b, short c, int d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(short[] a, short[] b, int[] c, int[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(short[] a, int[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_aln(short[] a, int[] b, short c, int d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(short[] a, short[] b, int[] c, int[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(short[] a, short[] b, int[] c, int[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(short[] a, int[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_unaln(short[] a, int[] b, short c, int d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(short[] a, short[] b, int[] c, int[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(short[] a, short[] b, int[] c, int[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, short elem, short val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, int elem, int val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestShortLongVect.java b/hotspot/test/compiler/7119644/TestShortLongVect.java new file mode 100644 index 00000000000..d4c121f8716 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestShortLongVect.java @@ -0,0 +1,571 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestShortLongVect + */ + +public class TestShortLongVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Short + Long vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + short[] a1 = new short[ARRLEN]; + short[] a2 = new short[ARRLEN]; + long[] b1 = new long[ARRLEN]; + long[] b2 = new long[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_vi_neg(short[] a, long[] b, short c, long d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_cp_neg(short[] a, short[] b, long[] c, long[] d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + c[i] = d[i]; + } + } + static void test_ci_oppos(short[] a, long[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_vi_oppos(short[] a, long[] b, short c, long d) { + int limit = a.length-1; + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_cp_oppos(short[] a, short[] b, long[] c, long[] d) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + c[limit-i] = d[i]; + } + } + static void test_ci_aln(short[] a, long[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_aln(short[] a, long[] b, short c, long d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_alndst(short[] a, short[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + c[i+ALIGN_OFF] = d[i]; + } + } + static void test_cp_alnsrc(short[] a, short[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + c[i] = d[i+ALIGN_OFF]; + } + } + static void test_ci_unaln(short[] a, long[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_vi_unaln(short[] a, long[] b, short c, long d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + static void test_cp_unalndst(short[] a, short[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + c[i+UNALIGN_OFF] = d[i]; + } + } + static void test_cp_unalnsrc(short[] a, short[] b, long[] c, long[] d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + c[i] = d[i+UNALIGN_OFF]; + } + } + + static int verify(String text, int i, short elem, short val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } + static int verify(String text, int i, long elem, long val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} diff --git a/hotspot/test/compiler/7119644/TestShortVect.java b/hotspot/test/compiler/7119644/TestShortVect.java new file mode 100644 index 00000000000..d4583832158 --- /dev/null +++ b/hotspot/test/compiler/7119644/TestShortVect.java @@ -0,0 +1,953 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7119644 + * @summary Increase superword's vector size up to 256 bits + * + * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestShortVect + */ + +public class TestShortVect { + private static final int ARRLEN = 997; + private static final int ITERS = 11000; + private static final int OFFSET = 3; + private static final int SCALE = 2; + private static final int ALIGN_OFF = 8; + private static final int UNALIGN_OFF = 5; + + public static void main(String args[]) { + System.out.println("Testing Short vectors"); + int errn = test(); + if (errn > 0) { + System.err.println("FAILED: " + errn + " errors"); + System.exit(97); + } + System.out.println("PASSED"); + } + + static int test() { + short[] a1 = new short[ARRLEN]; + short[] a2 = new short[ARRLEN]; + System.out.println("Warmup"); + for (int i=0; i 0) + return errn; + + System.out.println("Time"); + long start, end; + start = System.currentTimeMillis(); + for (int i=0; i= 0; i-=1) { + a[i] = -123; + } + } + static void test_vi_neg(short[] a, short b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b; + } + } + static void test_cp_neg(short[] a, short[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = b[i]; + } + } + static void test_2ci_neg(short[] a, short[] b) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = -123; + b[i] = -103; + } + } + static void test_2vi_neg(short[] a, short[] b, short c, short d) { + for (int i = a.length-1; i >= 0; i-=1) { + a[i] = c; + b[i] = d; + } + } + static void test_ci_oppos(short[] a) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + } + } + static void test_vi_oppos(short[] a, short b) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[limit-i] = b; + } + } + static void test_cp_oppos(short[] a, short[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[i] = b[limit-i]; + } + } + static void test_2ci_oppos(short[] a, short[] b) { + int limit = a.length-1; + for (int i = 0; i < a.length; i+=1) { + a[limit-i] = -123; + b[i] = -103; + } + } + static void test_2vi_oppos(short[] a, short[] b, short c, short d) { + int limit = a.length-1; + for (int i = limit; i >= 0; i-=1) { + a[i] = c; + b[limit-i] = d; + } + } + static void test_ci_off(short[] a) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123; + } + } + static void test_vi_off(short[] a, short b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b; + } + } + static void test_cp_off(short[] a, short[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = b[i+OFFSET]; + } + } + static void test_2ci_off(short[] a, short[] b) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = -123; + b[i+OFFSET] = -103; + } + } + static void test_2vi_off(short[] a, short[] b, short c, short d) { + for (int i = 0; i < a.length-OFFSET; i+=1) { + a[i+OFFSET] = c; + b[i+OFFSET] = d; + } + } + static void test_ci_inv(short[] a, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123; + } + } + static void test_vi_inv(short[] a, short b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b; + } + } + static void test_cp_inv(short[] a, short[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = b[i+k]; + } + } + static void test_2ci_inv(short[] a, short[] b, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = -123; + b[i+k] = -103; + } + } + static void test_2vi_inv(short[] a, short[] b, short c, short d, int k) { + for (int i = 0; i < a.length-k; i+=1) { + a[i+k] = c; + b[i+k] = d; + } + } + static void test_ci_scl(short[] a) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123; + } + } + static void test_vi_scl(short[] a, short b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b; + } + } + static void test_cp_scl(short[] a, short[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = b[i*SCALE]; + } + } + static void test_2ci_scl(short[] a, short[] b) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = -123; + b[i*SCALE] = -103; + } + } + static void test_2vi_scl(short[] a, short[] b, short c, short d) { + for (int i = 0; i*SCALE < a.length; i+=1) { + a[i*SCALE] = c; + b[i*SCALE] = d; + } + } + static void test_cp_alndst(short[] a, short[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = b[i]; + } + } + static void test_cp_alnsrc(short[] a, short[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = b[i+ALIGN_OFF]; + } + } + static void test_2ci_aln(short[] a, short[] b) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i+ALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_2vi_aln(short[] a, short[] b, short c, short d) { + for (int i = 0; i < a.length-ALIGN_OFF; i+=1) { + a[i] = c; + b[i+ALIGN_OFF] = d; + } + } + static void test_cp_unalndst(short[] a, short[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = b[i]; + } + } + static void test_cp_unalnsrc(short[] a, short[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = b[i+UNALIGN_OFF]; + } + } + static void test_2ci_unaln(short[] a, short[] b) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i+UNALIGN_OFF] = -123; + b[i] = -103; + } + } + static void test_2vi_unaln(short[] a, short[] b, short c, short d) { + for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) { + a[i] = c; + b[i+UNALIGN_OFF] = d; + } + } + + static int verify(String text, int i, short elem, short val) { + if (elem != val) { + System.err.println(text + "[" + i + "] = " + elem + " != " + val); + return 1; + } + return 0; + } +} From 90c19a99071eae897ed73137cd456541e75d4aa4 Mon Sep 17 00:00:00 2001 From: Coleen Phillimore Date: Fri, 15 Jun 2012 07:51:37 -0400 Subject: [PATCH 004/160] 7177307: fix fo CR7158800 doesn't contain Test7158800.sh Forgot to hg add it Reviewed-by: pbk, kamg, dlong, kvn, fparain --- hotspot/test/runtime/7158800/Test7158800.sh | 91 +++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 hotspot/test/runtime/7158800/Test7158800.sh diff --git a/hotspot/test/runtime/7158800/Test7158800.sh b/hotspot/test/runtime/7158800/Test7158800.sh new file mode 100644 index 00000000000..2a502346a0b --- /dev/null +++ b/hotspot/test/runtime/7158800/Test7158800.sh @@ -0,0 +1,91 @@ +#!/bin/sh +# +# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# +# +# Run test for InternTest.java +# + +if [ "${TESTSRC}" = "" ] +then TESTSRC=. +fi + +if [ "${TESTJAVA}" = "" ] +then + PARENT=`dirname \`which java\`` + TESTJAVA=`dirname ${PARENT}` + echo "TESTJAVA not set, selecting " ${TESTJAVA} + echo "If this is incorrect, try setting the variable manually." +fi + +if [ "${TESTCLASSES}" = "" ] +then + echo "TESTCLASSES not set. Test cannot execute. Failed." + exit 1 +fi + +# set platform-dependent variables +OS=`uname -s` +case "$OS" in + SunOS | Linux ) + NULL=/dev/null + PS=":" + FS="/" + ;; + Windows_* ) + NULL=NUL + PS=";" + FS="\\" + ;; + * ) + echo "Unrecognized system!" + exit 1; + ;; +esac + +JEMMYPATH=${CPAPPEND} +CLASSPATH=.${PS}${TESTCLASSES}${PS}${JEMMYPATH} ; export CLASSPATH + +THIS_DIR=`pwd` + +${TESTJAVA}${FS}bin${FS}java -fullversion + +${TESTJAVA}${FS}bin${FS}javac -d . ${TESTSRC}${FS}InternTest.java + +cp ${TESTSRC}${FS}badstrings.txt . + +${TESTJAVA}${FS}bin${FS}java -XX:+PrintStringTableStatistics -XX:+TraceSafepointCleanupTime InternTest bad > test.out 2>&1 & +C_PID=$! + +sleep 60 + +ps | grep ${C_PID} | grep -v grep + +if [ $? = 0 ] +then + kill -9 ${C_PID} + echo "Test Failed" + exit 1 +else + echo "Test Passed" + exit 0 +fi From 18fce99e636f0c1fb2f2efd101d682aa9cc4bf6d Mon Sep 17 00:00:00 2001 From: Alejandro Murillo Date: Fri, 15 Jun 2012 14:17:28 -0700 Subject: [PATCH 005/160] 7175515: new hotspot build - hs24-b15 Reviewed-by: jcoomes --- hotspot/make/hotspot_version | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hotspot/make/hotspot_version b/hotspot/make/hotspot_version index 76b61ffa403..44b5cbc8375 100644 --- a/hotspot/make/hotspot_version +++ b/hotspot/make/hotspot_version @@ -35,7 +35,7 @@ HOTSPOT_VM_COPYRIGHT=Copyright 2012 HS_MAJOR_VER=24 HS_MINOR_VER=0 -HS_BUILD_NUMBER=14 +HS_BUILD_NUMBER=15 JDK_MAJOR_VER=1 JDK_MINOR_VER=8 From 118f552a6ef35ba73fab295bc738769a84698f3b Mon Sep 17 00:00:00 2001 From: Roland Westrelin Date: Mon, 18 Jun 2012 09:52:31 +0200 Subject: [PATCH 006/160] 7174363: Arrays.copyOfRange leads to VM crash with -Xcomp -server if executed by testing framework Arrays.copyOfRange(original, from, to) with from > original.length tries to do a copy with a negative length. Reviewed-by: kvn, twisti --- hotspot/src/share/vm/opto/library_call.cpp | 10 ++-- .../test/compiler/7174363/Test7174363.java | 49 +++++++++++++++++++ 2 files changed, 56 insertions(+), 3 deletions(-) create mode 100644 hotspot/test/compiler/7174363/Test7174363.java diff --git a/hotspot/src/share/vm/opto/library_call.cpp b/hotspot/src/share/vm/opto/library_call.cpp index f9d740efd7b..785f5a0ae1d 100644 --- a/hotspot/src/share/vm/opto/library_call.cpp +++ b/hotspot/src/share/vm/opto/library_call.cpp @@ -3592,8 +3592,10 @@ bool LibraryCallKit::inline_array_copyOf(bool is_copyOfRange) { } // Bail out if length is negative. - // ...Not needed, since the new_array will throw the right exception. - //generate_negative_guard(length, bailout, &length); + // Without this the new_array would throw + // NegativeArraySizeException but IllegalArgumentException is what + // should be thrown + generate_negative_guard(length, bailout, &length); if (bailout->req() > 1) { PreserveJVMState pjvms(this); @@ -3617,7 +3619,9 @@ bool LibraryCallKit::inline_array_copyOf(bool is_copyOfRange) { // Extreme case: Arrays.copyOf((Integer[])x, 10, String[].class). // This will fail a store-check if x contains any non-nulls. bool disjoint_bases = true; - bool length_never_negative = true; + // if start > orig_length then the length of the copy may be + // negative. + bool length_never_negative = !is_copyOfRange; generate_arraycopy(TypeAryPtr::OOPS, T_OBJECT, original, start, newcopy, intcon(0), moved, disjoint_bases, length_never_negative); diff --git a/hotspot/test/compiler/7174363/Test7174363.java b/hotspot/test/compiler/7174363/Test7174363.java new file mode 100644 index 00000000000..50f784da1eb --- /dev/null +++ b/hotspot/test/compiler/7174363/Test7174363.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 7174363 + * @summary crash with Arrays.copyOfRange(original, from, to) when from > original.length + * + * @run main/othervm -XX:-BackgroundCompilation Test7174363 + */ + +import java.util.*; + +public class Test7174363 { + + static Object[] m(Object[] original, int from, int to) { + return Arrays.copyOfRange(original, from, to, Object[].class); + } + + static public void main(String[] args) { + Object[] orig = new Object[10]; + for (int i = 0; i < 20000; i++) { + try { + m(orig, 15, 20); + } catch(ArrayIndexOutOfBoundsException excp) {} + } + } +} From 3927b8d331bc1cc51714de3e4ee8af933b3f0860 Mon Sep 17 00:00:00 2001 From: Krystal Mok Date: Mon, 18 Jun 2012 12:29:21 -0700 Subject: [PATCH 007/160] 7176856: add the JRE name to the error log Reviewed-by: coleenp, jrose, kvn, twisti --- hotspot/src/share/vm/classfile/vmSymbols.hpp | 4 +++ hotspot/src/share/vm/runtime/java.cpp | 1 + hotspot/src/share/vm/runtime/java.hpp | 8 ++++++ hotspot/src/share/vm/runtime/thread.cpp | 26 ++++++++++++++++++++ hotspot/src/share/vm/utilities/vmError.cpp | 4 ++- 5 files changed, 42 insertions(+), 1 deletion(-) diff --git a/hotspot/src/share/vm/classfile/vmSymbols.hpp b/hotspot/src/share/vm/classfile/vmSymbols.hpp index 2814b1d3668..4f926c7a8d2 100644 --- a/hotspot/src/share/vm/classfile/vmSymbols.hpp +++ b/hotspot/src/share/vm/classfile/vmSymbols.hpp @@ -111,6 +111,10 @@ template(getBootClassPathEntryForClass_name, "getBootClassPathEntryForClass") \ template(sun_misc_PostVMInitHook, "sun/misc/PostVMInitHook") \ \ + /* Java runtime version access */ \ + template(sun_misc_Version, "sun/misc/Version") \ + template(java_runtime_name_name, "java_runtime_name") \ + \ /* class file format tags */ \ template(tag_source_file, "SourceFile") \ template(tag_inner_classes, "InnerClasses") \ diff --git a/hotspot/src/share/vm/runtime/java.cpp b/hotspot/src/share/vm/runtime/java.cpp index f256e515e9c..7e013e5d2bd 100644 --- a/hotspot/src/share/vm/runtime/java.cpp +++ b/hotspot/src/share/vm/runtime/java.cpp @@ -660,6 +660,7 @@ void vm_shutdown_during_initialization(const char* error, const char* message) { } JDK_Version JDK_Version::_current; +const char* JDK_Version::_runtime_name; void JDK_Version::initialize() { jdk_version_info info; diff --git a/hotspot/src/share/vm/runtime/java.hpp b/hotspot/src/share/vm/runtime/java.hpp index 102fd6b7acd..1d2b45b6967 100644 --- a/hotspot/src/share/vm/runtime/java.hpp +++ b/hotspot/src/share/vm/runtime/java.hpp @@ -74,6 +74,7 @@ class JDK_Version VALUE_OBJ_CLASS_SPEC { private: static JDK_Version _current; + static const char* _runtime_name; // In this class, we promote the minor version of release to be the // major version for releases >= 5 in anticipation of the JDK doing the @@ -181,6 +182,13 @@ class JDK_Version VALUE_OBJ_CLASS_SPEC { void to_string(char* buffer, size_t buflen) const; + static const char* runtime_name() { + return _runtime_name; + } + static void set_runtime_name(const char* name) { + _runtime_name = name; + } + // Convenience methods for queries on the current major/minor version static bool is_jdk12x_version() { return current().compare_major(2) == 0; diff --git a/hotspot/src/share/vm/runtime/thread.cpp b/hotspot/src/share/vm/runtime/thread.cpp index 76865f6ff2c..0179e5c2d4e 100644 --- a/hotspot/src/share/vm/runtime/thread.cpp +++ b/hotspot/src/share/vm/runtime/thread.cpp @@ -996,6 +996,29 @@ static void call_initializeSystemClass(TRAPS) { vmSymbols::void_method_signature(), CHECK); } +char java_runtime_name[128] = ""; + +// extract the JRE name from sun.misc.Version.java_runtime_name +static const char* get_java_runtime_name(TRAPS) { + klassOop k = SystemDictionary::find(vmSymbols::sun_misc_Version(), + Handle(), Handle(), CHECK_AND_CLEAR_NULL); + fieldDescriptor fd; + bool found = k != NULL && + instanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_name_name(), + vmSymbols::string_signature(), &fd); + if (found) { + oop name_oop = k->java_mirror()->obj_field(fd.offset()); + if (name_oop == NULL) + return NULL; + const char* name = java_lang_String::as_utf8_string(name_oop, + java_runtime_name, + sizeof(java_runtime_name)); + return name; + } else { + return NULL; + } +} + // General purpose hook into Java code, run once when the VM is initialized. // The Java library method itself may be changed independently from the VM. static void call_postVMInitHook(TRAPS) { @@ -3352,6 +3375,9 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { // The VM creates & returns objects of this class. Make sure it's initialized. initialize_class(vmSymbols::java_lang_Class(), CHECK_0); call_initializeSystemClass(CHECK_0); + + // get the Java runtime name after java.lang.System is initialized + JDK_Version::set_runtime_name(get_java_runtime_name(THREAD)); } else { warning("java.lang.System not initialized"); } diff --git a/hotspot/src/share/vm/utilities/vmError.cpp b/hotspot/src/share/vm/utilities/vmError.cpp index e450676fa7a..fd81cca2983 100644 --- a/hotspot/src/share/vm/utilities/vmError.cpp +++ b/hotspot/src/share/vm/utilities/vmError.cpp @@ -450,7 +450,9 @@ void VMError::report(outputStream* st) { // VM version st->print_cr("#"); JDK_Version::current().to_string(buf, sizeof(buf)); - st->print_cr("# JRE version: %s", buf); + const char* runtime_name = JDK_Version::runtime_name() != NULL ? + JDK_Version::runtime_name() : ""; + st->print_cr("# JRE version: %s (%s)", runtime_name, buf); st->print_cr("# Java VM: %s (%s %s %s %s)", Abstract_VM_Version::vm_name(), Abstract_VM_Version::vm_release(), From ed2051c8615315b2cc6727978e385b958bf176e2 Mon Sep 17 00:00:00 2001 From: Christian Thalinger Date: Mon, 18 Jun 2012 15:17:30 -0700 Subject: [PATCH 008/160] 7157365: jruby/bench.bench_timeout crashes with JVM internal error Reviewed-by: jrose, kvn --- hotspot/src/share/vm/memory/universe.hpp | 2 +- hotspot/src/share/vm/opto/callGenerator.cpp | 53 ++++++++++++--------- hotspot/src/share/vm/opto/chaitin.cpp | 2 +- hotspot/src/share/vm/opto/type.cpp | 36 +++++++------- 4 files changed, 53 insertions(+), 40 deletions(-) diff --git a/hotspot/src/share/vm/memory/universe.hpp b/hotspot/src/share/vm/memory/universe.hpp index 073a5c2ca75..9f400aa60b5 100644 --- a/hotspot/src/share/vm/memory/universe.hpp +++ b/hotspot/src/share/vm/memory/universe.hpp @@ -273,7 +273,7 @@ class Universe: AllStatic { } static klassOop typeArrayKlassObj(BasicType t) { - assert((uint)t < T_VOID+1, "range check"); + assert((uint)t < T_VOID+1, err_msg("range check for type: %s", type2name(t))); assert(_typeArrayKlassObjs[t] != NULL, "domain check"); return _typeArrayKlassObjs[t]; } diff --git a/hotspot/src/share/vm/opto/callGenerator.cpp b/hotspot/src/share/vm/opto/callGenerator.cpp index 26153217d07..1fef941d9b5 100644 --- a/hotspot/src/share/vm/opto/callGenerator.cpp +++ b/hotspot/src/share/vm/opto/callGenerator.cpp @@ -172,9 +172,11 @@ public: JVMState* DynamicCallGenerator::generate(JVMState* jvms) { GraphKit kit(jvms); + Compile* C = kit.C; + PhaseGVN& gvn = kit.gvn(); - if (kit.C->log() != NULL) { - kit.C->log()->elem("dynamic_call bci='%d'", jvms->bci()); + if (C->log() != NULL) { + C->log()->elem("dynamic_call bci='%d'", jvms->bci()); } // Get the constant pool cache from the caller class. @@ -190,18 +192,21 @@ JVMState* DynamicCallGenerator::generate(JVMState* jvms) { size_t call_site_offset = cpcache->get_f1_offset(index); // Load the CallSite object from the constant pool cache. - const TypeOopPtr* cpcache_ptr = TypeOopPtr::make_from_constant(cpcache); - Node* cpcache_adr = kit.makecon(cpcache_ptr); - Node* call_site_adr = kit.basic_plus_adr(cpcache_adr, cpcache_adr, call_site_offset); - Node* call_site = kit.make_load(kit.control(), call_site_adr, TypeInstPtr::BOTTOM, T_OBJECT, Compile::AliasIdxRaw); + const TypeOopPtr* cpcache_type = TypeOopPtr::make_from_constant(cpcache); // returns TypeAryPtr of type T_OBJECT + const TypeOopPtr* call_site_type = TypeOopPtr::make_from_klass(C->env()->CallSite_klass()); + Node* cpcache_adr = kit.makecon(cpcache_type); + Node* call_site_adr = kit.basic_plus_adr(cpcache_adr, call_site_offset); + // The oops in the constant pool cache are not compressed; load then as raw pointers. + Node* call_site = kit.make_load(kit.control(), call_site_adr, call_site_type, T_ADDRESS, Compile::AliasIdxRaw); // Load the target MethodHandle from the CallSite object. - Node* target_mh_adr = kit.basic_plus_adr(call_site, call_site, java_lang_invoke_CallSite::target_offset_in_bytes()); - Node* target_mh = kit.make_load(kit.control(), target_mh_adr, TypeInstPtr::BOTTOM, T_OBJECT); + const TypeOopPtr* target_type = TypeOopPtr::make_from_klass(C->env()->MethodHandle_klass()); + Node* target_mh_adr = kit.basic_plus_adr(call_site, java_lang_invoke_CallSite::target_offset_in_bytes()); + Node* target_mh = kit.make_load(kit.control(), target_mh_adr, target_type, T_OBJECT); address resolve_stub = SharedRuntime::get_resolve_opt_virtual_call_stub(); - CallStaticJavaNode *call = new (kit.C, tf()->domain()->cnt()) CallStaticJavaNode(tf(), resolve_stub, method(), kit.bci()); + CallStaticJavaNode* call = new (C, tf()->domain()->cnt()) CallStaticJavaNode(tf(), resolve_stub, method(), kit.bci()); // invokedynamic is treated as an optimized invokevirtual. call->set_optimized_virtual(true); // Take extra care (in the presence of argument motion) not to trash the SP: @@ -785,9 +790,10 @@ CallGenerator* CallGenerator::for_invokedynamic_inline(ciCallSite* call_site, JV JVMState* PredictedDynamicCallGenerator::generate(JVMState* jvms) { GraphKit kit(jvms); + Compile* C = kit.C; PhaseGVN& gvn = kit.gvn(); - CompileLog* log = kit.C->log(); + CompileLog* log = C->log(); if (log != NULL) { log->elem("predicted_dynamic_call bci='%d'", jvms->bci()); } @@ -803,8 +809,8 @@ JVMState* PredictedDynamicCallGenerator::generate(JVMState* jvms) { Node* receiver = kit.argument(0); // Check if the MethodHandle is the expected one - Node* cmp = gvn.transform(new(kit.C, 3) CmpPNode(receiver, predicted_mh)); - bol = gvn.transform(new(kit.C, 2) BoolNode(cmp, BoolTest::eq) ); + Node* cmp = gvn.transform(new (C, 3) CmpPNode(receiver, predicted_mh)); + bol = gvn.transform(new (C, 2) BoolNode(cmp, BoolTest::eq) ); } else { // Get the constant pool cache from the caller class. ciMethod* caller_method = jvms->method(); @@ -818,22 +824,25 @@ JVMState* PredictedDynamicCallGenerator::generate(JVMState* jvms) { size_t call_site_offset = cpcache->get_f1_offset(index); // Load the CallSite object from the constant pool cache. - const TypeOopPtr* cpcache_ptr = TypeOopPtr::make_from_constant(cpcache); - Node* cpcache_adr = kit.makecon(cpcache_ptr); - Node* call_site_adr = kit.basic_plus_adr(cpcache_adr, cpcache_adr, call_site_offset); - Node* call_site = kit.make_load(kit.control(), call_site_adr, TypeInstPtr::BOTTOM, T_OBJECT, Compile::AliasIdxRaw); + const TypeOopPtr* cpcache_type = TypeOopPtr::make_from_constant(cpcache); // returns TypeAryPtr of type T_OBJECT + const TypeOopPtr* call_site_type = TypeOopPtr::make_from_klass(C->env()->CallSite_klass()); + Node* cpcache_adr = kit.makecon(cpcache_type); + Node* call_site_adr = kit.basic_plus_adr(cpcache_adr, call_site_offset); + // The oops in the constant pool cache are not compressed; load then as raw pointers. + Node* call_site = kit.make_load(kit.control(), call_site_adr, call_site_type, T_ADDRESS, Compile::AliasIdxRaw); // Load the target MethodHandle from the CallSite object. + const TypeOopPtr* target_type = TypeOopPtr::make_from_klass(C->env()->MethodHandle_klass()); Node* target_adr = kit.basic_plus_adr(call_site, call_site, java_lang_invoke_CallSite::target_offset_in_bytes()); - Node* target_mh = kit.make_load(kit.control(), target_adr, TypeInstPtr::BOTTOM, T_OBJECT); + Node* target_mh = kit.make_load(kit.control(), target_adr, target_type, T_OBJECT); // Check if the MethodHandle is still the same. - Node* cmp = gvn.transform(new(kit.C, 3) CmpPNode(target_mh, predicted_mh)); - bol = gvn.transform(new(kit.C, 2) BoolNode(cmp, BoolTest::eq) ); + Node* cmp = gvn.transform(new (C, 3) CmpPNode(target_mh, predicted_mh)); + bol = gvn.transform(new (C, 2) BoolNode(cmp, BoolTest::eq) ); } IfNode* iff = kit.create_and_xform_if(kit.control(), bol, _hit_prob, COUNT_UNKNOWN); - kit.set_control( gvn.transform(new(kit.C, 1) IfTrueNode (iff))); - Node* slow_ctl = gvn.transform(new(kit.C, 1) IfFalseNode(iff)); + kit.set_control( gvn.transform(new (C, 1) IfTrueNode (iff))); + Node* slow_ctl = gvn.transform(new (C, 1) IfFalseNode(iff)); SafePointNode* slow_map = NULL; JVMState* slow_jvms; @@ -882,7 +891,7 @@ JVMState* PredictedDynamicCallGenerator::generate(JVMState* jvms) { // Finish the diamond. kit.C->set_has_split_ifs(true); // Has chance for split-if optimization - RegionNode* region = new (kit.C, 3) RegionNode(3); + RegionNode* region = new (C, 3) RegionNode(3); region->init_req(1, kit.control()); region->init_req(2, slow_map->control()); kit.set_control(gvn.transform(region)); diff --git a/hotspot/src/share/vm/opto/chaitin.cpp b/hotspot/src/share/vm/opto/chaitin.cpp index 0ed9b962724..00cabcf237f 100644 --- a/hotspot/src/share/vm/opto/chaitin.cpp +++ b/hotspot/src/share/vm/opto/chaitin.cpp @@ -1536,7 +1536,7 @@ Node *PhaseChaitin::find_base_for_derived( Node **derived_base_map, Node *derive // Check for AddP-related opcodes if( !derived->is_Phi() ) { - assert( derived->as_Mach()->ideal_Opcode() == Op_AddP, "" ); + assert(derived->as_Mach()->ideal_Opcode() == Op_AddP, err_msg("but is: %s", derived->Name())); Node *base = derived->in(AddPNode::Base); derived_base_map[derived->_idx] = base; return base; diff --git a/hotspot/src/share/vm/opto/type.cpp b/hotspot/src/share/vm/opto/type.cpp index 30ec5695939..b796307c1e7 100644 --- a/hotspot/src/share/vm/opto/type.cpp +++ b/hotspot/src/share/vm/opto/type.cpp @@ -2613,18 +2613,26 @@ const TypeOopPtr* TypeOopPtr::make_from_klass_common(ciKlass *klass, bool klass_ //------------------------------make_from_constant----------------------------- // Make a java pointer from an oop constant const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o, bool require_constant) { - if (o->is_method_data() || o->is_method() || o->is_cpcache()) { + if (o->is_method_data() || o->is_method()) { // Treat much like a typeArray of bytes, like below, but fake the type... - const Type* etype = (Type*)get_const_basic_type(T_BYTE); + const BasicType bt = T_BYTE; + const Type* etype = get_const_basic_type(bt); const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS); - ciKlass *klass = ciTypeArrayKlass::make((BasicType) T_BYTE); - assert(o->can_be_constant(), "method data oops should be tenured"); - const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); - return arr; + ciKlass* klass = ciArrayKlass::make(ciType::make(bt)); + assert(o->can_be_constant(), "should be tenured"); + return TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); + } else if (o->is_cpcache()) { + // Treat much like a objArray, like below, but fake the type... + const BasicType bt = T_OBJECT; + const Type* etype = get_const_basic_type(bt); + const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS); + ciKlass* klass = ciArrayKlass::make(ciType::make(bt)); + assert(o->can_be_constant(), "should be tenured"); + return TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); } else { assert(o->is_java_object(), "must be java language object"); assert(!o->is_null_object(), "null object not yet handled here."); - ciKlass *klass = o->klass(); + ciKlass* klass = o->klass(); if (klass->is_instance_klass()) { // Element is an instance if (require_constant) { @@ -2635,8 +2643,7 @@ const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o, bool require_const return TypeInstPtr::make(o); } else if (klass->is_obj_array_klass()) { // Element is an object array. Recursively call ourself. - const Type *etype = - TypeOopPtr::make_from_klass_raw(klass->as_obj_array_klass()->element_klass()); + const Type *etype = make_from_klass_raw(klass->as_obj_array_klass()->element_klass()); const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length())); // We used to pass NotNull in here, asserting that the sub-arrays // are all not-null. This is not true in generally, as code can @@ -2646,12 +2653,10 @@ const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o, bool require_const } else if (!o->should_be_constant()) { return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0); } - const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); - return arr; + return TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); } else if (klass->is_type_array_klass()) { // Element is an typeArray - const Type* etype = - (Type*)get_const_basic_type(klass->as_type_array_klass()->element_type()); + const Type* etype = get_const_basic_type(klass->as_type_array_klass()->element_type()); const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length())); // We used to pass NotNull in here, asserting that the array pointer // is not-null. That was not true in general. @@ -2660,12 +2665,11 @@ const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o, bool require_const } else if (!o->should_be_constant()) { return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0); } - const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); - return arr; + return TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); } } - ShouldNotReachHere(); + fatal("unhandled object type"); return NULL; } From b5b10846c23d0c1b1953632625506b2fa5663f67 Mon Sep 17 00:00:00 2001 From: Vladimir Kozlov Date: Tue, 19 Jun 2012 15:12:56 -0700 Subject: [PATCH 009/160] 7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear() Disable vectorization of a memory access with more elements per vector than one which is used for alignment on sparc Reviewed-by: twisti --- hotspot/src/cpu/x86/vm/x86.ad | 10 +++---- hotspot/src/share/vm/opto/c2_globals.hpp | 5 +++- hotspot/src/share/vm/opto/superword.cpp | 37 +++++++++++++++--------- hotspot/src/share/vm/opto/superword.hpp | 11 ++++--- 4 files changed, 39 insertions(+), 24 deletions(-) diff --git a/hotspot/src/cpu/x86/vm/x86.ad b/hotspot/src/cpu/x86/vm/x86.ad index faa00d70373..af5b5f0b099 100644 --- a/hotspot/src/cpu/x86/vm/x86.ad +++ b/hotspot/src/cpu/x86/vm/x86.ad @@ -2061,7 +2061,7 @@ instruct Repl8I_imm(vecY dst, immI con) %{ // Integer could be loaded into xmm register directly from memory. instruct Repl2I_mem(vecD dst, memory mem) %{ predicate(n->as_Vector()->length() == 2); - match(Set dst (ReplicateI mem)); + match(Set dst (ReplicateI (LoadVector mem))); format %{ "movd $dst,$mem\n\t" "pshufd $dst,$dst,0x00\t! replicate2I" %} ins_encode %{ @@ -2073,7 +2073,7 @@ instruct Repl2I_mem(vecD dst, memory mem) %{ instruct Repl4I_mem(vecX dst, memory mem) %{ predicate(n->as_Vector()->length() == 4); - match(Set dst (ReplicateI mem)); + match(Set dst (ReplicateI (LoadVector mem))); format %{ "movd $dst,$mem\n\t" "pshufd $dst,$dst,0x00\t! replicate4I" %} ins_encode %{ @@ -2085,7 +2085,7 @@ instruct Repl4I_mem(vecX dst, memory mem) %{ instruct Repl8I_mem(vecY dst, memory mem) %{ predicate(n->as_Vector()->length() == 8); - match(Set dst (ReplicateI mem)); + match(Set dst (ReplicateI (LoadVector mem))); format %{ "movd $dst,$mem\n\t" "pshufd $dst,$dst,0x00\n\t" "vinsertf128h $dst,$dst,$dst\t! replicate8I" %} @@ -2225,7 +2225,7 @@ instruct Repl4L_imm(vecY dst, immL con) %{ // Long could be loaded into xmm register directly from memory. instruct Repl2L_mem(vecX dst, memory mem) %{ predicate(n->as_Vector()->length() == 2); - match(Set dst (ReplicateL mem)); + match(Set dst (ReplicateL (LoadVector mem))); format %{ "movq $dst,$mem\n\t" "movlhps $dst,$dst\t! replicate2L" %} ins_encode %{ @@ -2237,7 +2237,7 @@ instruct Repl2L_mem(vecX dst, memory mem) %{ instruct Repl4L_mem(vecY dst, memory mem) %{ predicate(n->as_Vector()->length() == 4); - match(Set dst (ReplicateL mem)); + match(Set dst (ReplicateL (LoadVector mem))); format %{ "movq $dst,$mem\n\t" "movlhps $dst,$dst\n\t" "vinsertf128h $dst,$dst,$dst\t! replicate4L" %} diff --git a/hotspot/src/share/vm/opto/c2_globals.hpp b/hotspot/src/share/vm/opto/c2_globals.hpp index 947d806a34a..cc72fc0a1cf 100644 --- a/hotspot/src/share/vm/opto/c2_globals.hpp +++ b/hotspot/src/share/vm/opto/c2_globals.hpp @@ -299,9 +299,12 @@ develop(bool, SuperWordRTDepCheck, false, \ "Enable runtime dependency checks.") \ \ - product(bool, TraceSuperWord, false, \ + notproduct(bool, TraceSuperWord, false, \ "Trace superword transforms") \ \ + notproduct(bool, TraceNewVectors, false, \ + "Trace creation of Vector nodes") \ + \ product_pd(bool, OptoBundling, \ "Generate nops to fill i-cache lines") \ \ diff --git a/hotspot/src/share/vm/opto/superword.cpp b/hotspot/src/share/vm/opto/superword.cpp index 78db4b5ba16..cfeb47e507b 100644 --- a/hotspot/src/share/vm/opto/superword.cpp +++ b/hotspot/src/share/vm/opto/superword.cpp @@ -222,7 +222,18 @@ void SuperWord::find_adjacent_refs() { // Create initial pack pairs of memory operations for which // alignment is set and vectors will be aligned. bool create_pack = true; - if (memory_alignment(mem_ref, best_iv_adjustment) != 0) { + if (memory_alignment(mem_ref, best_iv_adjustment) == 0) { + if (!Matcher::misaligned_vectors_ok()) { + int vw = vector_width(mem_ref); + int vw_best = vector_width(best_align_to_mem_ref); + if (vw > vw_best) { + // Do not vectorize a memory access with more elements per vector + // if unaligned memory access is not allowed because number of + // iterations in pre-loop will be not enough to align it. + create_pack = false; + } + } + } else { if (same_velt_type(mem_ref, best_align_to_mem_ref)) { // Can't allow vectorization of unaligned memory accesses with the // same type since it could be overlapped accesses to the same array. @@ -357,7 +368,7 @@ MemNode* SuperWord::find_align_to_ref(Node_List &memops) { for (uint j = 0; j < memops.size(); j++) { MemNode* s = memops.at(j)->as_Mem(); if (s->is_Store()) { - int vw = vector_width_in_bytes(velt_basic_type(s)); + int vw = vector_width_in_bytes(s); assert(vw > 1, "sanity"); SWPointer p(s, this); if (cmp_ct.at(j) > max_ct || @@ -380,7 +391,7 @@ MemNode* SuperWord::find_align_to_ref(Node_List &memops) { for (uint j = 0; j < memops.size(); j++) { MemNode* s = memops.at(j)->as_Mem(); if (s->is_Load()) { - int vw = vector_width_in_bytes(velt_basic_type(s)); + int vw = vector_width_in_bytes(s); assert(vw > 1, "sanity"); SWPointer p(s, this); if (cmp_ct.at(j) > max_ct || @@ -440,8 +451,7 @@ bool SuperWord::ref_is_alignable(SWPointer& p) { // If initial offset from start of object is computable, // compute alignment within the vector. - BasicType bt = velt_basic_type(p.mem()); - int vw = vector_width_in_bytes(bt); + int vw = vector_width_in_bytes(p.mem()); assert(vw > 1, "sanity"); if (vw % span == 0) { Node* init_nd = pre_end->init_trip(); @@ -468,8 +478,7 @@ int SuperWord::get_iv_adjustment(MemNode* mem_ref) { SWPointer align_to_ref_p(mem_ref, this); int offset = align_to_ref_p.offset_in_bytes(); int scale = align_to_ref_p.scale_in_bytes(); - BasicType bt = velt_basic_type(mem_ref); - int vw = vector_width_in_bytes(bt); + int vw = vector_width_in_bytes(mem_ref); assert(vw > 1, "sanity"); int stride_sign = (scale * iv_stride()) > 0 ? 1 : -1; int iv_adjustment = (stride_sign * vw - (offset % vw)) % vw; @@ -1361,7 +1370,7 @@ void SuperWord::output() { } _igvn._worklist.push(vn); #ifdef ASSERT - if (TraceSuperWord) { + if (TraceNewVectors) { tty->print("new Vector node: "); vn->dump(); } @@ -1401,7 +1410,7 @@ Node* SuperWord::vector_opd(Node_List* p, int opd_idx) { _phase->_igvn.register_new_node_with_optimizer(vn); _phase->set_ctrl(vn, _phase->get_ctrl(opd)); #ifdef ASSERT - if (TraceSuperWord) { + if (TraceNewVectors) { tty->print("new Vector node: "); vn->dump(); } @@ -1424,8 +1433,8 @@ Node* SuperWord::vector_opd(Node_List* p, int opd_idx) { _phase->_igvn.register_new_node_with_optimizer(pk); _phase->set_ctrl(pk, _phase->get_ctrl(opd)); #ifdef ASSERT - if (TraceSuperWord) { - tty->print("new Pack node: "); + if (TraceNewVectors) { + tty->print("new Vector node: "); pk->dump(); } #endif @@ -1764,7 +1773,7 @@ int SuperWord::memory_alignment(MemNode* s, int iv_adjust_in_bytes) { if (!p.valid()) { return bottom_align; } - int vw = vector_width_in_bytes(velt_basic_type(s)); + int vw = vector_width_in_bytes(s); if (vw < 2) { return bottom_align; // No vectors for this type } @@ -1978,12 +1987,12 @@ void SuperWord::align_initial_loop_index(MemNode* align_to_ref) { // N = (V - (e - lim0)) % V // lim = lim0 - (V - (e - lim0)) % V - int vw = vector_width_in_bytes(velt_basic_type(align_to_ref)); - assert(vw > 1, "sanity"); + int vw = vector_width_in_bytes(align_to_ref); int stride = iv_stride(); int scale = align_to_ref_p.scale_in_bytes(); int elt_size = align_to_ref_p.memory_size(); int v_align = vw / elt_size; + assert(v_align > 1, "sanity"); int k = align_to_ref_p.offset_in_bytes() / elt_size; Node *kn = _igvn.intcon(k); diff --git a/hotspot/src/share/vm/opto/superword.hpp b/hotspot/src/share/vm/opto/superword.hpp index 97224e4d7bd..050ce9ea2df 100644 --- a/hotspot/src/share/vm/opto/superword.hpp +++ b/hotspot/src/share/vm/opto/superword.hpp @@ -264,11 +264,14 @@ class SuperWord : public ResourceObj { _iv = lp->as_CountedLoop()->phi()->as_Phi(); } int iv_stride() { return lp()->as_CountedLoop()->stride_con(); } - int vector_width_in_bytes(BasicType bt) { - return MIN2(ABS(iv_stride())*type2aelembytes(bt), - Matcher::vector_width_in_bytes(bt)); + int vector_width(Node* n) { + BasicType bt = velt_basic_type(n); + return MIN2(ABS(iv_stride()), Matcher::max_vector_size(bt)); + } + int vector_width_in_bytes(Node* n) { + BasicType bt = velt_basic_type(n); + return vector_width(n)*type2aelembytes(bt); } - MemNode* align_to_ref() { return _align_to_ref; } void set_align_to_ref(MemNode* m) { _align_to_ref = m; } From 8b20e7af5390199e9d5fe42211eaf58c4a5fa431 Mon Sep 17 00:00:00 2001 From: Gary Collins Date: Tue, 19 Jun 2012 21:16:20 -0700 Subject: [PATCH 010/160] 7178113: build environment change Simple change to enable proper builds of arm target Reviewed-by: ohair, dholmes --- hotspot/make/jprt.properties | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/hotspot/make/jprt.properties b/hotspot/make/jprt.properties index b49573ca37f..0010f8f85ff 100644 --- a/hotspot/make/jprt.properties +++ b/hotspot/make/jprt.properties @@ -102,6 +102,11 @@ jprt.my.linux.armvfp.jdk7=linux_armvfp_2.6 jprt.my.linux.armvfp.jdk7u6=${jprt.my.linux.armvfp.jdk7} jprt.my.linux.armvfp=${jprt.my.linux.armvfp.${jprt.tools.default.release}} +jprt.my.linux.armv6.jdk8=linux_armv6_2.6 +jprt.my.linux.armv6.jdk7=linux_armv6_2.6 +jprt.my.linux.armv6.jdk7u6=${jprt.my.linux.armv6.jdk7} +jprt.my.linux.armv6=${jprt.my.linux.armv6.${jprt.tools.default.release}} + jprt.my.linux.armsflt.jdk8=linux_armsflt_2.6 jprt.my.linux.armsflt.jdk7=linux_armsflt_2.6 jprt.my.linux.armsflt.jdk7u6=${jprt.my.linux.armsflt.jdk7} @@ -134,7 +139,7 @@ jprt.build.targets.standard= \ ${jprt.my.macosx.x64}-{product|fastdebug|debug}, \ ${jprt.my.windows.i586}-{product|fastdebug|debug}, \ ${jprt.my.windows.x64}-{product|fastdebug|debug}, \ - ${jprt.my.linux.armvfp}-{product|fastdebug} + ${jprt.my.linux.armv6}-{product|fastdebug} jprt.build.targets.open= \ ${jprt.my.solaris.i586}-{productOpen}, \ From 4189d0802f65d834f104559c04c6274e68cb33b2 Mon Sep 17 00:00:00 2001 From: "Daniel D. Daugherty" Date: Wed, 20 Jun 2012 14:18:25 -0700 Subject: [PATCH 011/160] 7175255: symlinks are wrong, which caused jdk8-promote-2 to fail (client/64/64 directories in debuginfo zips) Fix bad paths in client/64 and server/64 debug info and symlink creation Reviewed-by: ohair, dholmes --- .../solaris/makefiles/add_gnu_debuglink.make | 7 ++- hotspot/make/solaris/makefiles/dtrace.make | 49 +++++++++++-------- .../makefiles/fix_empty_sec_hdr_flags.make | 7 ++- 3 files changed, 39 insertions(+), 24 deletions(-) diff --git a/hotspot/make/solaris/makefiles/add_gnu_debuglink.make b/hotspot/make/solaris/makefiles/add_gnu_debuglink.make index b89a4c443ea..ee75722fa99 100644 --- a/hotspot/make/solaris/makefiles/add_gnu_debuglink.make +++ b/hotspot/make/solaris/makefiles/add_gnu_debuglink.make @@ -24,8 +24,11 @@ # Rules to build add_gnu_debuglink, used by vm.make on Solaris -GENERATED = ../generated -ADD_GNU_DEBUGLINK = $(GENERATED)/add_gnu_debuglink +# Allow $(ADD_GNU_DEBUGLINK) to be called from any directory. +# We don't set or use the GENERATED macro to avoid affecting +# other HotSpot Makefiles. +TOPDIR = $(shell echo `pwd`) +ADD_GNU_DEBUGLINK = $(TOPDIR)/../generated/add_gnu_debuglink ADD_GNU_DEBUGLINK_DIR = $(GAMMADIR)/src/os/solaris/add_gnu_debuglink ADD_GNU_DEBUGLINK_SRC = $(ADD_GNU_DEBUGLINK_DIR)/add_gnu_debuglink.c diff --git a/hotspot/make/solaris/makefiles/dtrace.make b/hotspot/make/solaris/makefiles/dtrace.make index d8dc58b8135..1a5726520f9 100644 --- a/hotspot/make/solaris/makefiles/dtrace.make +++ b/hotspot/make/solaris/makefiles/dtrace.make @@ -94,23 +94,24 @@ ISA = $(subst i386,i486,$(shell isainfo -n)) # Making 64/libjvm_db.so: 64-bit version of libjvm_db.so which handles 32-bit libjvm.so ifneq ("${ISA}","${BUILDARCH}") -XLIBJVM_DB = 64/$(LIBJVM_DB) -XLIBJVM_DB_G = 64/$(LIBJVM_DB_G) -XLIBJVM_DTRACE = 64/$(LIBJVM_DTRACE) -XLIBJVM_DTRACE_G = 64/$(LIBJVM_DTRACE_G) +XLIBJVM_DIR = 64 +XLIBJVM_DB = $(XLIBJVM_DIR)/$(LIBJVM_DB) +XLIBJVM_DB_G = $(XLIBJVM_DIR)/$(LIBJVM_DB_G) +XLIBJVM_DTRACE = $(XLIBJVM_DIR)/$(LIBJVM_DTRACE) +XLIBJVM_DTRACE_G = $(XLIBJVM_DIR)/$(LIBJVM_DTRACE_G) -XLIBJVM_DB_DEBUGINFO = 64/$(LIBJVM_DB_DEBUGINFO) -XLIBJVM_DB_DIZ = 64/$(LIBJVM_DB_DIZ) -XLIBJVM_DB_G_DEBUGINFO = 64/$(LIBJVM_DB_G_DEBUGINFO) -XLIBJVM_DB_G_DIZ = 64/$(LIBJVM_DB_G_DIZ) -XLIBJVM_DTRACE_DEBUGINFO = 64/$(LIBJVM_DTRACE_DEBUGINFO) -XLIBJVM_DTRACE_DIZ = 64/$(LIBJVM_DTRACE_DIZ) -XLIBJVM_DTRACE_G_DEBUGINFO = 64/$(LIBJVM_DTRACE_G_DEBUGINFO) -XLIBJVM_DTRACE_G_DIZ = 64/$(LIBJVM_DTRACE_G_DIZ) +XLIBJVM_DB_DEBUGINFO = $(XLIBJVM_DIR)/$(LIBJVM_DB_DEBUGINFO) +XLIBJVM_DB_DIZ = $(XLIBJVM_DIR)/$(LIBJVM_DB_DIZ) +XLIBJVM_DB_G_DEBUGINFO = $(XLIBJVM_DIR)/$(LIBJVM_DB_G_DEBUGINFO) +XLIBJVM_DB_G_DIZ = $(XLIBJVM_DIR)/$(LIBJVM_DB_G_DIZ) +XLIBJVM_DTRACE_DEBUGINFO = $(XLIBJVM_DIR)/$(LIBJVM_DTRACE_DEBUGINFO) +XLIBJVM_DTRACE_DIZ = $(XLIBJVM_DIR)/$(LIBJVM_DTRACE_DIZ) +XLIBJVM_DTRACE_G_DEBUGINFO = $(XLIBJVM_DIR)/$(LIBJVM_DTRACE_G_DEBUGINFO) +XLIBJVM_DTRACE_G_DIZ = $(XLIBJVM_DIR)/$(LIBJVM_DTRACE_G_DIZ) $(XLIBJVM_DB): $(ADD_GNU_DEBUGLINK) $(FIX_EMPTY_SEC_HDR_FLAGS) $(DTRACE_SRCDIR)/$(JVM_DB).c $(JVMOFFS).h $(LIBJVM_DB_MAPFILE) @echo Making $@ - $(QUIETLY) mkdir -p 64/ ; \ + $(QUIETLY) mkdir -p $(XLIBJVM_DIR) ; \ $(CC) $(SYMFLAG) $(ARCHFLAG/$(ISA)) -D$(TYPE) -I. -I$(GENERATED) \ $(SHARED_FLAG) $(LFLAGS_JVM_DB) -o $@ $(DTRACE_SRCDIR)/$(JVM_DB).c -lc [ -f $(XLIBJVM_DB_G) ] || { ln -s $(LIBJVM_DB) $(XLIBJVM_DB_G); } @@ -124,8 +125,10 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) $(QUIETLY) $(OBJCOPY) --only-keep-debug $@ $(XLIBJVM_DB_DEBUGINFO) # $(OBJCOPY) --add-gnu-debuglink=... corrupts SUNW_* sections. # Use $(ADD_GNU_DEBUGLINK) until a fixed $(OBJCOPY) is available. -# $(QUIETLY) $(OBJCOPY) --add-gnu-debuglink=$(XLIBJVM_DB_DEBUGINFO) $@ - $(QUIETLY) $(ADD_GNU_DEBUGLINK) $(XLIBJVM_DB_DEBUGINFO) $@ +# $(OBJCOPY) --add-gnu-debuglink=$(LIBJVM_DB_DEBUGINFO) $(LIBJVM_DB) ; +# Do this part in the $(XLIBJVM_DIR) subdir so $(XLIBJVM_DIR) is not +# in the link name: + ( cd $(XLIBJVM_DIR) && $(ADD_GNU_DEBUGLINK) $(LIBJVM_DB_DEBUGINFO) $(LIBJVM_DB) ) ifeq ($(STRIP_POLICY),all_strip) $(QUIETLY) $(STRIP) $@ else @@ -136,7 +139,9 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) endif [ -f $(XLIBJVM_DB_G_DEBUGINFO) ] || { ln -s $(XLIBJVM_DB_DEBUGINFO) $(XLIBJVM_DB_G_DEBUGINFO); } ifeq ($(ZIP_DEBUGINFO_FILES),1) - $(ZIPEXE) -q -y $(XLIBJVM_DB_DIZ) $(XLIBJVM_DB_DEBUGINFO) $(XLIBJVM_DB_G_DEBUGINFO) +# Do this part in the $(XLIBJVM_DIR) subdir so $(XLIBJVM_DIR) is not +# in the archived name: + ( cd $(XLIBJVM_DIR) && $(ZIPEXE) -q -y $(LIBJVM_DB_DIZ) $(LIBJVM_DB_DEBUGINFO) $(LIBJVM_DB_G_DEBUGINFO) ) $(RM) $(XLIBJVM_DB_DEBUGINFO) $(XLIBJVM_DB_G_DEBUGINFO) [ -f $(XLIBJVM_DB_G_DIZ) ] || { ln -s $(XLIBJVM_DB_DIZ) $(XLIBJVM_DB_G_DIZ); } endif @@ -144,7 +149,7 @@ endif $(XLIBJVM_DTRACE): $(ADD_GNU_DEBUGLINK) $(FIX_EMPTY_SEC_HDR_FLAGS) $(DTRACE_SRCDIR)/$(JVM_DTRACE).c $(DTRACE_SRCDIR)/$(JVM_DTRACE).h $(LIBJVM_DTRACE_MAPFILE) @echo Making $@ - $(QUIETLY) mkdir -p 64/ ; \ + $(QUIETLY) mkdir -p $(XLIBJVM_DIR) ; \ $(CC) $(SYMFLAG) $(ARCHFLAG/$(ISA)) -D$(TYPE) -I. \ $(SHARED_FLAG) $(LFLAGS_JVM_DTRACE) -o $@ $(DTRACE_SRCDIR)/$(JVM_DTRACE).c -lc -lthread -ldoor [ -f $(XLIBJVM_DTRACE_G) ] || { ln -s $(LIBJVM_DTRACE) $(XLIBJVM_DTRACE_G); } @@ -153,8 +158,10 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) $(QUIETLY) $(FIX_EMPTY_SEC_HDR_FLAGS) $@ $(QUIETLY) $(OBJCOPY) --only-keep-debug $@ $(XLIBJVM_DTRACE_DEBUGINFO) # $(OBJCOPY) --add-gnu-debuglink=... corrupts SUNW_* sections. -# $(QUIETLY) $(OBJCOPY) --add-gnu-debuglink=$(XLIBJVM_DTRACE_DEBUGINFO) $@ - $(QUIETLY) $(ADD_GNU_DEBUGLINK) $(XLIBJVM_DTRACE_DEBUGINFO) $@ +# $(OBJCOPY) --add-gnu-debuglink=$(LIBJVM_DTRACE_DEBUGINFO) $(LIBJVM_DTRACE) ; +# Do this part in the $(XLIBJVM_DIR) subdir so $(XLIBJVM_DIR) is not +# in the link name: + ( cd $(XLIBJVM_DIR) && $(ADD_GNU_DEBUGLINK) $(LIBJVM_DTRACE_DEBUGINFO) $(LIBJVM_DTRACE) ) ifeq ($(STRIP_POLICY),all_strip) $(QUIETLY) $(STRIP) $@ else @@ -165,7 +172,9 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) endif [ -f $(XLIBJVM_DTRACE_G_DEBUGINFO) ] || { ln -s $(XLIBJVM_DTRACE_DEBUGINFO) $(XLIBJVM_DTRACE_G_DEBUGINFO); } ifeq ($(ZIP_DEBUGINFO_FILES),1) - $(ZIPEXE) -q -y $(XLIBJVM_DTRACE_DIZ) $(XLIBJVM_DTRACE_DEBUGINFO) $(XLIBJVM_DTRACE_G_DEBUGINFO) +# Do this part in the $(XLIBJVM_DIR) subdir so $(XLIBJVM_DIR) is not +# in the archived name: + ( cd $(XLIBJVM_DIR) && $(ZIPEXE) -q -y $(LIBJVM_DTRACE_DIZ) $(LIBJVM_DTRACE_DEBUGINFO) $(LIBJVM_DTRACE_G_DEBUGINFO) ) $(RM) $(XLIBJVM_DTRACE_DEBUGINFO) $(XLIBJVM_DTRACE_G_DEBUGINFO) [ -f $(XLIBJVM_DTRACE_G_DIZ) ] || { ln -s $(XLIBJVM_DTRACE_DIZ) $(XLIBJVM_DTRACE_G_DIZ); } endif diff --git a/hotspot/make/solaris/makefiles/fix_empty_sec_hdr_flags.make b/hotspot/make/solaris/makefiles/fix_empty_sec_hdr_flags.make index 75e15bf193e..bd763904480 100644 --- a/hotspot/make/solaris/makefiles/fix_empty_sec_hdr_flags.make +++ b/hotspot/make/solaris/makefiles/fix_empty_sec_hdr_flags.make @@ -24,8 +24,11 @@ # Rules to build fix_empty_sec_hdr_flags, used by vm.make on Solaris -GENERATED = ../generated -FIX_EMPTY_SEC_HDR_FLAGS = $(GENERATED)/fix_empty_sec_hdr_flags +# Allow $(FIX_EMPTY_SEC_HDR_FLAGS) to be called from any directory. +# We don't set or use the GENERATED macro to avoid affecting +# other HotSpot Makefiles. +TOPDIR = $(shell echo `pwd`) +FIX_EMPTY_SEC_HDR_FLAGS = $(TOPDIR)/../generated/fix_empty_sec_hdr_flags FIX_EMPTY_SEC_HDR_FLAGS_DIR = $(GAMMADIR)/src/os/solaris/fix_empty_sec_hdr_flags FIX_EMPTY_SEC_HDR_FLAGS_SRC = $(FIX_EMPTY_SEC_HDR_FLAGS_DIR)/fix_empty_sec_hdr_flags.c From 470db77b36b5352d644eb8801d09605b82f608a7 Mon Sep 17 00:00:00 2001 From: Roland Westrelin Date: Thu, 21 Jun 2012 09:52:38 +0200 Subject: [PATCH 012/160] 7129715: MAC: SIGBUS in nsk stress test StackOverflowError may get lost on OSX. Reviewed-by: kvn, dcubed --- hotspot/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/hotspot/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp b/hotspot/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp index 2806e79ea4a..c6d31ab4f9a 100644 --- a/hotspot/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp +++ b/hotspot/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp @@ -516,7 +516,12 @@ JVM_handle_bsd_signal(int sig, } } - if (thread->thread_state() == _thread_in_Java) { + // We test if stub is already set (by the stack overflow code + // above) so it is not overwritten by the code that follows. This + // check is not required on other platforms, because on other + // platforms we check for SIGSEGV only or SIGBUS only, where here + // we have to check for both SIGSEGV and SIGBUS. + if (thread->thread_state() == _thread_in_Java && stub == NULL) { // Java thread running in Java code => find exception handler if any // a fault inside compiled code, the interpreter, or a stub From 6bc673930fe9d453ece2c42d96b3504b0a7d85c8 Mon Sep 17 00:00:00 2001 From: Vladimir Kozlov Date: Fri, 22 Jun 2012 10:40:48 -0700 Subject: [PATCH 013/160] 7178280: Failed new vector regression tests When looking for the same value in an other register check that all parts of that register has the same value. Reviewed-by: johnc, twisti --- hotspot/src/share/vm/opto/postaloc.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/hotspot/src/share/vm/opto/postaloc.cpp b/hotspot/src/share/vm/opto/postaloc.cpp index 8e24d353d8d..912e07704e7 100644 --- a/hotspot/src/share/vm/opto/postaloc.cpp +++ b/hotspot/src/share/vm/opto/postaloc.cpp @@ -308,9 +308,10 @@ int PhaseChaitin::elide_copy( Node *n, int k, Block *current_block, Node_List &v } Node *vv = value[reg]; - if (n_regs > 1) { // Doubles check for aligned-adjacent pair - if( (reg&1)==0 ) continue; // Wrong half of a pair - if( vv != value[reg-1] ) continue; // Not a complete pair + if (n_regs > 1) { // Doubles and vectors check for aligned-adjacent set + uint last = (n_regs-1); // Looking for the last part of a set + if ((reg&last) != last) continue; // Wrong part of a set + if (!register_contains_value(vv, reg, n_regs, value)) continue; // Different value } if( vv == val || // Got a direct hit? (t && vv && vv->bottom_type() == t && vv->is_Mach() && @@ -573,7 +574,6 @@ void PhaseChaitin::post_allocate_copy_removal() { // Record other half of doubles uint def_ideal_reg = def->ideal_reg(); int n_regs = RegMask::num_registers(def_ideal_reg); - bool is_vec = RegMask::is_vector(def_ideal_reg); for (int l = 1; l < n_regs; l++) { OptoReg::Name ureg_lo = OptoReg::add(ureg,-l); if (!value[ureg_lo] && From 1a35ed23d9d678e90b7b789158e01cb094386bc8 Mon Sep 17 00:00:00 2001 From: Jiangli Zhou Date: Fri, 22 Jun 2012 14:00:39 -0400 Subject: [PATCH 014/160] 7177409: Perf regression in JVM_GetClassDeclaredFields after generic signature changes In fieldDescriptor::generic_signature() returns NULL immediately if the field has no generic signature. Reviewed-by: dholmes, coleenp, jcoomes --- hotspot/src/share/vm/runtime/fieldDescriptor.cpp | 4 ++++ hotspot/src/share/vm/runtime/fieldDescriptor.hpp | 1 + hotspot/src/share/vm/runtime/reflection.cpp | 2 +- 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/hotspot/src/share/vm/runtime/fieldDescriptor.cpp b/hotspot/src/share/vm/runtime/fieldDescriptor.cpp index fc26d9cd09e..3d5213f03a2 100644 --- a/hotspot/src/share/vm/runtime/fieldDescriptor.cpp +++ b/hotspot/src/share/vm/runtime/fieldDescriptor.cpp @@ -39,6 +39,10 @@ oop fieldDescriptor::loader() const { } Symbol* fieldDescriptor::generic_signature() const { + if (!has_generic_signature()) { + return NULL; + } + int idx = 0; instanceKlass* ik = instanceKlass::cast(field_holder()); for (AllFieldStream fs(ik); !fs.done(); fs.next()) { diff --git a/hotspot/src/share/vm/runtime/fieldDescriptor.hpp b/hotspot/src/share/vm/runtime/fieldDescriptor.hpp index f2cdbadbab9..ff6649cdad4 100644 --- a/hotspot/src/share/vm/runtime/fieldDescriptor.hpp +++ b/hotspot/src/share/vm/runtime/fieldDescriptor.hpp @@ -100,6 +100,7 @@ class fieldDescriptor VALUE_OBJ_CLASS_SPEC { bool is_field_access_watched() const { return access_flags().is_field_access_watched(); } bool is_field_modification_watched() const { return access_flags().is_field_modification_watched(); } + bool has_generic_signature() const { return access_flags().field_has_generic_signature(); } void set_is_field_access_watched(const bool value) { _access_flags.set_is_field_access_watched(value); diff --git a/hotspot/src/share/vm/runtime/reflection.cpp b/hotspot/src/share/vm/runtime/reflection.cpp index 04b896722d1..001d87b2853 100644 --- a/hotspot/src/share/vm/runtime/reflection.cpp +++ b/hotspot/src/share/vm/runtime/reflection.cpp @@ -829,7 +829,7 @@ oop Reflection::new_field(fieldDescriptor* fd, bool intern_name, TRAPS) { java_lang_reflect_Field::set_modifiers(rh(), fd->access_flags().as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS); java_lang_reflect_Field::set_override(rh(), false); if (java_lang_reflect_Field::has_signature_field() && - fd->generic_signature() != NULL) { + fd->has_generic_signature()) { Symbol* gs = fd->generic_signature(); Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL); java_lang_reflect_Field::set_signature(rh(), sig()); From f4fdc03167bf96619e878e49857caa50c639186e Mon Sep 17 00:00:00 2001 From: Yumin Qi Date: Fri, 22 Jun 2012 15:35:30 -0700 Subject: [PATCH 015/160] 7175133: jinfo failed to get system properties after 6924259 String offset and count fields as fix of 6924259 were removed, and become optional. SA still use offset and count fields to read String contents and failed. Fix if they exist, use them other then use value field only to read, this keeps consistent with the changes in 6924259. Reviewed-by: dholmes, mikael --- .../sun/jvm/hotspot/oops/OopUtilities.java | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/OopUtilities.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/OopUtilities.java index edd8a806442..a42d8be68b5 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/OopUtilities.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/OopUtilities.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -141,18 +141,19 @@ public class OopUtilities implements /* imports */ JVMTIThreadState { public static String stringOopToString(Oop stringOop) { if (offsetField == null) { InstanceKlass k = (InstanceKlass) stringOop.getKlass(); - offsetField = (IntField) k.findField("offset", "I"); - countField = (IntField) k.findField("count", "I"); + offsetField = (IntField) k.findField("offset", "I"); // optional + countField = (IntField) k.findField("count", "I"); // optional valueField = (OopField) k.findField("value", "[C"); if (Assert.ASSERTS_ENABLED) { - Assert.that(offsetField != null && - countField != null && - valueField != null, "must find all java.lang.String fields"); + Assert.that(valueField != null, "Field \'value\' of java.lang.String not found"); } } - return charArrayToString((TypeArray) valueField.getValue(stringOop), - offsetField.getValue(stringOop), - countField.getValue(stringOop)); + if (offsetField != null && countField != null) { + return charArrayToString((TypeArray) valueField.getValue(stringOop), + offsetField.getValue(stringOop), + countField.getValue(stringOop)); + } + return charArrayToString((TypeArray) valueField.getValue(stringOop)); } public static String stringOopToEscapedString(Oop stringOop) { From e742ae2157d2b41861975fa35d8de5483210a801 Mon Sep 17 00:00:00 2001 From: Yumin Qi Date: Fri, 22 Jun 2012 15:39:16 -0700 Subject: [PATCH 016/160] 7177128: SA cannot get correct system properties after 7126277 Bug fix of 7126277 changed hashing algorithm and also changed key as final field, this led SA unable to set correct value for key. Solution by reading key/value and insert them into the new table. Reviewed-by: dholmes, mikael --- .../jvm/hotspot/utilities/ObjectReader.java | 128 ++++++++++++++++-- 1 file changed, 118 insertions(+), 10 deletions(-) diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/ObjectReader.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/ObjectReader.java index 55cb2995621..1f17a7fdb63 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/ObjectReader.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/ObjectReader.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2007, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -85,6 +85,21 @@ public class ObjectReader { this(new ProcImageClassLoader()); } + static void debugPrintln(String msg) { + if (DEBUG) { + System.err.println("DEBUG>" + msg); + } + } + + static void debugPrintStackTrace(Exception exp) { + if (DEBUG) { + StackTraceElement[] els = exp.getStackTrace(); + for (int i = 0; i < els.length; i++) { + System.err.println("DEBUG>" + els[i].toString()); + } + } + } + public Object readObject(Oop oop) throws ClassNotFoundException { if (oop instanceof Instance) { return readInstance((Instance) oop); @@ -120,13 +135,96 @@ public class ObjectReader { } protected Symbol javaLangString; + protected Symbol javaUtilHashtableEntry; + protected Symbol javaUtilHashtable; + protected Symbol javaUtilProperties; + + protected Symbol getVMSymbol(String name) { + return VM.getVM().getSymbolTable().probe(name); + } + protected Symbol javaLangString() { if (javaLangString == null) { - javaLangString = VM.getVM().getSymbolTable().probe("java/lang/String"); + javaLangString = getVMSymbol("java/lang/String"); } return javaLangString; } + protected Symbol javaUtilHashtableEntry() { + if (javaUtilHashtableEntry == null) { + javaUtilHashtableEntry = getVMSymbol("java/util/Hashtable$Entry"); + } + return javaUtilHashtableEntry; + } + + protected Symbol javaUtilHashtable() { + if (javaUtilHashtable == null) { + javaUtilHashtable = getVMSymbol("java/util/Hashtable"); + } + return javaUtilHashtable; + } + + protected Symbol javaUtilProperties() { + if (javaUtilProperties == null) { + javaUtilProperties = getVMSymbol("java/util/Properties"); + } + return javaUtilProperties; + } + + private void setHashtableEntry(java.util.Hashtable p, Oop oop) { + InstanceKlass ik = (InstanceKlass)oop.getKlass(); + OopField keyField = (OopField)ik.findField("key", "Ljava/lang/Object;"); + OopField valueField = (OopField)ik.findField("value", "Ljava/lang/Object;"); + OopField nextField = (OopField)ik.findField("next", "Ljava/util/Hashtable$Entry;"); + if (DEBUG) { + if (Assert.ASSERTS_ENABLED) { + Assert.that(ik.getName().equals(javaUtilHashtableEntry()), "Not a Hashtable$Entry?"); + Assert.that(keyField != null && valueField != null && nextField != null, "Invalid fields!"); + } + } + + Object key = null; + Object value = null; + Oop next = null; + try { + key = readObject(keyField.getValue(oop)); + value = readObject(valueField.getValue(oop)); + next = (Oop)nextField.getValue(oop); + // For Properties, should use setProperty(k, v). Since it only runs in SA + // using put(k, v) should be OK. + p.put(key, value); + if (next != null) { + setHashtableEntry(p, next); + } + } catch (ClassNotFoundException ce) { + if( DEBUG) { + debugPrintln("Class not found " + ce); + debugPrintStackTrace(ce); + } + } + } + + protected Object getHashtable(Instance oop, boolean isProperties) { + InstanceKlass k = (InstanceKlass)oop.getKlass(); + OopField tableField = (OopField)k.findField("table", "[Ljava/util/Hashtable$Entry;"); + if (tableField == null) { + debugPrintln("Could not find field of [Ljava/util/Hashtable$Entry;"); + return null; + } + java.util.Hashtable table = (isProperties) ? new java.util.Properties() + : new java.util.Hashtable(); + ObjArray kvs = (ObjArray)tableField.getValue(oop); + long size = kvs.getLength(); + debugPrintln("Hashtable$Entry Size = " + size); + for (long i=0; i Date: Mon, 25 Jun 2012 14:34:35 +0200 Subject: [PATCH 017/160] 7178846: IterateThroughHeap: heap_iteration_callback passes a negative size Missing cast caused integer overflow Reviewed-by: rbackman, dholmes --- hotspot/src/share/vm/prims/jvmtiTagMap.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hotspot/src/share/vm/prims/jvmtiTagMap.cpp b/hotspot/src/share/vm/prims/jvmtiTagMap.cpp index a425430bf61..3b58f0f087e 100644 --- a/hotspot/src/share/vm/prims/jvmtiTagMap.cpp +++ b/hotspot/src/share/vm/prims/jvmtiTagMap.cpp @@ -585,7 +585,7 @@ class CallbackWrapper : public StackObj { _o = klassOop_if_java_lang_Class(o); // object size - _obj_size = _o->size() * wordSize; + _obj_size = (jlong)_o->size() * wordSize; // record the context _tag_map = tag_map; From 97cc5e6c4453e2264568abfa7cf23d75038a3ae5 Mon Sep 17 00:00:00 2001 From: Dean Long Date: Mon, 25 Jun 2012 15:34:06 -0400 Subject: [PATCH 018/160] 7156729: PPC: R_PPC_REL24 relocation error related to some libraries built without -fPIC Build powerpc with -fPIC Reviewed-by: mikael, vladidan, roland --- hotspot/make/pic.make | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/hotspot/make/pic.make b/hotspot/make/pic.make index 4c1e6b1a1b9..79b2ea2f093 100644 --- a/hotspot/make/pic.make +++ b/hotspot/make/pic.make @@ -1,5 +1,5 @@ # -# Copyright (c) 2006, 2007, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -30,6 +30,13 @@ include $(GAMMADIR)/make/scm.make ifneq ($(OSNAME), windows) ifndef LP64 + PARTIAL_NONPIC=1 + endif + PIC_ARCH = ppc + ifneq ("$(filter $(PIC_ARCH),$(BUILDARCH))","") + PARTIAL_NONPIC=0 + endif + ifeq ($(PARTIAL_NONPIC),1) NONPIC_DIRS = memory oops gc_implementation gc_interface NONPIC_DIRS := $(foreach dir,$(NONPIC_DIRS), $(GAMMADIR)/src/share/vm/$(dir)) # Look for source files under NONPIC_DIRS From 79ee0ab0c240550149075227e3659386ff31743e Mon Sep 17 00:00:00 2001 From: Thomas Schatzl Date: Mon, 25 Jun 2012 16:00:55 -0700 Subject: [PATCH 019/160] 6921087: G1: remove per-GC-thread expansion tables from the fine-grain remembered sets Remove the per-thread expansion tables (PosParPRT) and associated expansion and compaction from the fine grain RSet entries. This code has been unused for a while. Reviewed-by: johnc, brutisso --- .../gc_implementation/g1/g1CollectedHeap.cpp | 3 - .../vm/gc_implementation/g1/g1_globals.hpp | 3 + .../gc_implementation/g1/heapRegionRemSet.cpp | 590 ++++-------------- .../gc_implementation/g1/heapRegionRemSet.hpp | 65 +- 4 files changed, 135 insertions(+), 526 deletions(-) diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp index fdd82c5c9c6..99f95cbb93b 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @@ -4750,9 +4750,6 @@ public: _g1h->g1_policy()->record_thread_age_table(pss.age_table()); _g1h->update_surviving_young_words(pss.surviving_young_words()+1); - // Clean up any par-expanded rem sets. - HeapRegionRemSet::par_cleanup(); - if (ParallelGCVerbose) { MutexLocker x(stats_lock()); pss.print_termination_stats(worker_id); diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp index 0378688c015..a589739f7d4 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp @@ -53,6 +53,9 @@ develop(bool, G1TraceMarkStackOverflow, false, \ "If true, extra debugging code for CM restart for ovflw.") \ \ + develop(bool, G1TraceHeapRegionRememberedSet, false, \ + "Enables heap region remembered set debug logs") \ + \ diagnostic(bool, G1SummarizeConcMark, false, \ "Summarize concurrent mark info") \ \ diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp index fc275a6edae..7859b591988 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp @@ -30,13 +30,10 @@ #include "gc_implementation/g1/heapRegionSeq.inline.hpp" #include "memory/allocation.hpp" #include "memory/space.inline.hpp" +#include "oops/oop.inline.hpp" #include "utilities/bitMap.inline.hpp" #include "utilities/globalDefinitions.hpp" -#define HRRS_VERBOSE 0 - -#define PRT_COUNT_OCCUPIED 1 - // OtherRegionsTable class PerRegionTable: public CHeapObj { @@ -45,14 +42,10 @@ class PerRegionTable: public CHeapObj { HeapRegion* _hr; BitMap _bm; -#if PRT_COUNT_OCCUPIED jint _occupied; -#endif - PerRegionTable* _next_free; - - PerRegionTable* next_free() { return _next_free; } - void set_next_free(PerRegionTable* prt) { _next_free = prt; } + // next pointer for free/allocated lis + PerRegionTable* _next; static PerRegionTable* _free_list; @@ -69,63 +62,25 @@ protected: // We need access in order to union things into the base table. BitMap* bm() { return &_bm; } -#if PRT_COUNT_OCCUPIED void recount_occupied() { _occupied = (jint) bm()->count_one_bits(); } -#endif PerRegionTable(HeapRegion* hr) : _hr(hr), -#if PRT_COUNT_OCCUPIED _occupied(0), -#endif _bm(HeapRegion::CardsPerRegion, false /* in-resource-area */) {} - static void free(PerRegionTable* prt) { - while (true) { - PerRegionTable* fl = _free_list; - prt->set_next_free(fl); - PerRegionTable* res = - (PerRegionTable*) - Atomic::cmpxchg_ptr(prt, &_free_list, fl); - if (res == fl) return; - } - ShouldNotReachHere(); - } - - static PerRegionTable* alloc(HeapRegion* hr) { - PerRegionTable* fl = _free_list; - while (fl != NULL) { - PerRegionTable* nxt = fl->next_free(); - PerRegionTable* res = - (PerRegionTable*) - Atomic::cmpxchg_ptr(nxt, &_free_list, fl); - if (res == fl) { - fl->init(hr); - return fl; - } else { - fl = _free_list; - } - } - assert(fl == NULL, "Loop condition."); - return new PerRegionTable(hr); - } - void add_card_work(CardIdx_t from_card, bool par) { if (!_bm.at(from_card)) { if (par) { if (_bm.par_at_put(from_card, 1)) { -#if PRT_COUNT_OCCUPIED Atomic::inc(&_occupied); -#endif } } else { _bm.at_put(from_card, 1); -#if PRT_COUNT_OCCUPIED _occupied++; -#endif } } } @@ -134,10 +89,13 @@ protected: // Must make this robust in case "from" is not in "_hr", because of // concurrency. -#if HRRS_VERBOSE - gclog_or_tty->print_cr(" PRT::Add_reference_work(" PTR_FORMAT "->" PTR_FORMAT").", - from, *from); -#endif + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print_cr(" PRT::Add_reference_work(" PTR_FORMAT "->" PTR_FORMAT").", + from, + UseCompressedOops + ? oopDesc::load_decode_heap_oop((narrowOop*)from) + : oopDesc::load_decode_heap_oop((oop*)from)); + } HeapRegion* loc_hr = hr(); // If the test below fails, then this table was reused concurrently @@ -162,23 +120,16 @@ public: HeapRegion* hr() const { return _hr; } -#if PRT_COUNT_OCCUPIED jint occupied() const { // Overkill, but if we ever need it... // guarantee(_occupied == _bm.count_one_bits(), "Check"); return _occupied; } -#else - jint occupied() const { - return _bm.count_one_bits(); - } -#endif void init(HeapRegion* hr) { _hr = hr; -#if PRT_COUNT_OCCUPIED + _next = NULL; _occupied = 0; -#endif _bm.clear(); } @@ -194,9 +145,7 @@ public: HeapWord* hr_bot = hr()->bottom(); size_t hr_first_card_index = ctbs->index_for(hr_bot); bm()->set_intersection_at_offset(*card_bm, hr_first_card_index); -#if PRT_COUNT_OCCUPIED recount_occupied(); -#endif } void add_card(CardIdx_t from_card_index) { @@ -218,16 +167,6 @@ public: return sizeof(this) + _bm.size_in_words() * HeapWordSize; } - static size_t fl_mem_size() { - PerRegionTable* cur = _free_list; - size_t res = 0; - while (cur != NULL) { - res += sizeof(PerRegionTable); - cur = cur->next_free(); - } - return res; - } - // Requires "from" to be in "hr()". bool contains_reference(OopOrNarrowOopStar from) const { assert(hr()->is_in_reserved(from), "Precondition."); @@ -235,122 +174,29 @@ public: CardTableModRefBS::card_size); return _bm.at(card_ind); } -}; -PerRegionTable* PerRegionTable::_free_list = NULL; + PerRegionTable* next() const { return _next; } + void set_next(PerRegionTable* nxt) { _next = nxt; } + PerRegionTable** next_addr() { return &_next; } - -#define COUNT_PAR_EXPANDS 0 - -#if COUNT_PAR_EXPANDS -static jint n_par_expands = 0; -static jint n_par_contracts = 0; -static jint par_expand_list_len = 0; -static jint max_par_expand_list_len = 0; - -static void print_par_expand() { - Atomic::inc(&n_par_expands); - Atomic::inc(&par_expand_list_len); - if (par_expand_list_len > max_par_expand_list_len) { - max_par_expand_list_len = par_expand_list_len; - } - if ((n_par_expands % 10) == 0) { - gclog_or_tty->print_cr("\n\n%d par expands: %d contracts, " - "len = %d, max_len = %d\n.", - n_par_expands, n_par_contracts, par_expand_list_len, - max_par_expand_list_len); - } -} -#endif - -class PosParPRT: public PerRegionTable { - PerRegionTable** _par_tables; - - enum SomePrivateConstants { - ReserveParTableExpansion = 1 - }; - - void par_contract() { - assert(_par_tables != NULL, "Precondition."); - int n = HeapRegionRemSet::num_par_rem_sets()-1; - for (int i = 0; i < n; i++) { - _par_tables[i]->union_bitmap_into(bm()); - PerRegionTable::free(_par_tables[i]); - _par_tables[i] = NULL; - } -#if PRT_COUNT_OCCUPIED - // We must recount the "occupied." - recount_occupied(); -#endif - FREE_C_HEAP_ARRAY(PerRegionTable*, _par_tables); - _par_tables = NULL; -#if COUNT_PAR_EXPANDS - Atomic::inc(&n_par_contracts); - Atomic::dec(&par_expand_list_len); -#endif - } - - static PerRegionTable** _par_table_fl; - - PosParPRT* _next; - - static PosParPRT* _free_list; - - PerRegionTable** par_tables() const { - assert(uintptr_t(NULL) == 0, "Assumption."); - if (uintptr_t(_par_tables) <= ReserveParTableExpansion) - return NULL; - else - return _par_tables; - } - - PosParPRT* _next_par_expanded; - PosParPRT* next_par_expanded() { return _next_par_expanded; } - void set_next_par_expanded(PosParPRT* ppprt) { _next_par_expanded = ppprt; } - static PosParPRT* _par_expanded_list; - -public: - - PosParPRT(HeapRegion* hr) : PerRegionTable(hr), _par_tables(NULL) {} - - jint occupied() const { - jint res = PerRegionTable::occupied(); - if (par_tables() != NULL) { - for (int i = 0; i < HeapRegionRemSet::num_par_rem_sets()-1; i++) { - res += par_tables()[i]->occupied(); - } - } - return res; - } - - void init(HeapRegion* hr) { - PerRegionTable::init(hr); - _next = NULL; - if (par_tables() != NULL) { - for (int i = 0; i < HeapRegionRemSet::num_par_rem_sets()-1; i++) { - par_tables()[i]->init(hr); - } - } - } - - static void free(PosParPRT* prt) { + static void free(PerRegionTable* prt) { while (true) { - PosParPRT* fl = _free_list; + PerRegionTable* fl = _free_list; prt->set_next(fl); - PosParPRT* res = - (PosParPRT*) + PerRegionTable* res = + (PerRegionTable*) Atomic::cmpxchg_ptr(prt, &_free_list, fl); if (res == fl) return; } ShouldNotReachHere(); } - static PosParPRT* alloc(HeapRegion* hr) { - PosParPRT* fl = _free_list; + static PerRegionTable* alloc(HeapRegion* hr) { + PerRegionTable* fl = _free_list; while (fl != NULL) { - PosParPRT* nxt = fl->next(); - PosParPRT* res = - (PosParPRT*) + PerRegionTable* nxt = fl->next(); + PerRegionTable* res = + (PerRegionTable*) Atomic::cmpxchg_ptr(nxt, &_free_list, fl); if (res == fl) { fl->init(hr); @@ -360,148 +206,26 @@ public: } } assert(fl == NULL, "Loop condition."); - return new PosParPRT(hr); - } - - PosParPRT* next() const { return _next; } - void set_next(PosParPRT* nxt) { _next = nxt; } - PosParPRT** next_addr() { return &_next; } - - bool should_expand(int tid) { - // Given that we now defer RSet updates for after a GC we don't - // really need to expand the tables any more. This code should be - // cleaned up in the future (see CR 6921087). - return false; - } - - void par_expand() { - int n = HeapRegionRemSet::num_par_rem_sets()-1; - if (n <= 0) return; - if (_par_tables == NULL) { - PerRegionTable* res = - (PerRegionTable*) - Atomic::cmpxchg_ptr((PerRegionTable*)ReserveParTableExpansion, - &_par_tables, NULL); - if (res != NULL) return; - // Otherwise, we reserved the right to do the expansion. - - PerRegionTable** ptables = NEW_C_HEAP_ARRAY(PerRegionTable*, n); - for (int i = 0; i < n; i++) { - PerRegionTable* ptable = PerRegionTable::alloc(hr()); - ptables[i] = ptable; - } - // Here we do not need an atomic. - _par_tables = ptables; -#if COUNT_PAR_EXPANDS - print_par_expand(); -#endif - // We must put this table on the expanded list. - PosParPRT* exp_head = _par_expanded_list; - while (true) { - set_next_par_expanded(exp_head); - PosParPRT* res = - (PosParPRT*) - Atomic::cmpxchg_ptr(this, &_par_expanded_list, exp_head); - if (res == exp_head) return; - // Otherwise. - exp_head = res; - } - ShouldNotReachHere(); - } - } - - void add_reference(OopOrNarrowOopStar from, int tid) { - // Expand if necessary. - PerRegionTable** pt = par_tables(); - if (pt != NULL) { - // We always have to assume that mods to table 0 are in parallel, - // because of the claiming scheme in parallel expansion. A thread - // with tid != 0 that finds the table to be NULL, but doesn't succeed - // in claiming the right of expanding it, will end up in the else - // clause of the above if test. That thread could be delayed, and a - // thread 0 add reference could see the table expanded, and come - // here. Both threads would be adding in parallel. But we get to - // not use atomics for tids > 0. - if (tid == 0) { - PerRegionTable::add_reference(from); - } else { - pt[tid-1]->seq_add_reference(from); - } - } else { - // Not expanded -- add to the base table. - PerRegionTable::add_reference(from); - } - } - - void scrub(CardTableModRefBS* ctbs, BitMap* card_bm) { - assert(_par_tables == NULL, "Precondition"); - PerRegionTable::scrub(ctbs, card_bm); - } - - size_t mem_size() const { - size_t res = - PerRegionTable::mem_size() + sizeof(this) - sizeof(PerRegionTable); - if (_par_tables != NULL) { - for (int i = 0; i < HeapRegionRemSet::num_par_rem_sets()-1; i++) { - res += _par_tables[i]->mem_size(); - } - } - return res; + return new PerRegionTable(hr); } static size_t fl_mem_size() { - PosParPRT* cur = _free_list; + PerRegionTable* cur = _free_list; size_t res = 0; while (cur != NULL) { - res += sizeof(PosParPRT); + res += sizeof(PerRegionTable); cur = cur->next(); } return res; } - - bool contains_reference(OopOrNarrowOopStar from) const { - if (PerRegionTable::contains_reference(from)) return true; - if (_par_tables != NULL) { - for (int i = 0; i < HeapRegionRemSet::num_par_rem_sets()-1; i++) { - if (_par_tables[i]->contains_reference(from)) return true; - } - } - return false; - } - - static void par_contract_all(); }; -void PosParPRT::par_contract_all() { - PosParPRT* hd = _par_expanded_list; - while (hd != NULL) { - PosParPRT* nxt = hd->next_par_expanded(); - PosParPRT* res = - (PosParPRT*) - Atomic::cmpxchg_ptr(nxt, &_par_expanded_list, hd); - if (res == hd) { - // We claimed the right to contract this table. - hd->set_next_par_expanded(NULL); - hd->par_contract(); - hd = _par_expanded_list; - } else { - hd = res; - } - } -} - -PosParPRT* PosParPRT::_free_list = NULL; -PosParPRT* PosParPRT::_par_expanded_list = NULL; - -jint OtherRegionsTable::_cache_probes = 0; -jint OtherRegionsTable::_cache_hits = 0; +PerRegionTable* PerRegionTable::_free_list = NULL; size_t OtherRegionsTable::_max_fine_entries = 0; size_t OtherRegionsTable::_mod_max_fine_entries_mask = 0; -#if SAMPLE_FOR_EVICTION size_t OtherRegionsTable::_fine_eviction_stride = 0; size_t OtherRegionsTable::_fine_eviction_sample_size = 0; -#endif OtherRegionsTable::OtherRegionsTable(HeapRegion* hr) : _g1h(G1CollectedHeap::heap()), @@ -511,34 +235,36 @@ OtherRegionsTable::OtherRegionsTable(HeapRegion* hr) : false /* in-resource-area */), _fine_grain_regions(NULL), _n_fine_entries(0), _n_coarse_entries(0), -#if SAMPLE_FOR_EVICTION _fine_eviction_start(0), -#endif _sparse_table(hr) { - typedef PosParPRT* PosParPRTPtr; + typedef PerRegionTable* PerRegionTablePtr; + if (_max_fine_entries == 0) { assert(_mod_max_fine_entries_mask == 0, "Both or none."); size_t max_entries_log = (size_t)log2_long((jlong)G1RSetRegionEntries); _max_fine_entries = (size_t)(1 << max_entries_log); _mod_max_fine_entries_mask = _max_fine_entries - 1; -#if SAMPLE_FOR_EVICTION + assert(_fine_eviction_sample_size == 0 && _fine_eviction_stride == 0, "All init at same time."); _fine_eviction_sample_size = MAX2((size_t)4, max_entries_log); _fine_eviction_stride = _max_fine_entries / _fine_eviction_sample_size; -#endif } - _fine_grain_regions = new PosParPRTPtr[_max_fine_entries]; - if (_fine_grain_regions == NULL) + + _fine_grain_regions = new PerRegionTablePtr[_max_fine_entries]; + + if (_fine_grain_regions == NULL) { vm_exit_out_of_memory(sizeof(void*)*_max_fine_entries, "Failed to allocate _fine_grain_entries."); + } + for (size_t i = 0; i < _max_fine_entries; i++) { _fine_grain_regions[i] = NULL; } } -int** OtherRegionsTable::_from_card_cache = NULL; +int** OtherRegionsTable::_from_card_cache = NULL; size_t OtherRegionsTable::_from_card_cache_max_regions = 0; size_t OtherRegionsTable::_from_card_cache_mem_size = 0; @@ -579,38 +305,26 @@ void OtherRegionsTable::print_from_card_cache() { void OtherRegionsTable::add_reference(OopOrNarrowOopStar from, int tid) { size_t cur_hrs_ind = (size_t) hr()->hrs_index(); -#if HRRS_VERBOSE - gclog_or_tty->print_cr("ORT::add_reference_work(" PTR_FORMAT "->" PTR_FORMAT ").", - from, - UseCompressedOops - ? oopDesc::load_decode_heap_oop((narrowOop*)from) - : oopDesc::load_decode_heap_oop((oop*)from)); -#endif + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print_cr("ORT::add_reference_work(" PTR_FORMAT "->" PTR_FORMAT ").", + from, + UseCompressedOops + ? oopDesc::load_decode_heap_oop((narrowOop*)from) + : oopDesc::load_decode_heap_oop((oop*)from)); + } int from_card = (int)(uintptr_t(from) >> CardTableModRefBS::card_shift); -#if HRRS_VERBOSE - gclog_or_tty->print_cr("Table for [" PTR_FORMAT "...): card %d (cache = %d)", - hr()->bottom(), from_card, - _from_card_cache[tid][cur_hrs_ind]); -#endif - -#define COUNT_CACHE 0 -#if COUNT_CACHE - jint p = Atomic::add(1, &_cache_probes); - if ((p % 10000) == 0) { - jint hits = _cache_hits; - gclog_or_tty->print_cr("%d/%d = %5.2f%% RS cache hits.", - _cache_hits, p, 100.0* (float)hits/(float)p); + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print_cr("Table for [" PTR_FORMAT "...): card %d (cache = %d)", + hr()->bottom(), from_card, + _from_card_cache[tid][cur_hrs_ind]); } -#endif + if (from_card == _from_card_cache[tid][cur_hrs_ind]) { -#if HRRS_VERBOSE - gclog_or_tty->print_cr(" from-card cache hit."); -#endif -#if COUNT_CACHE - Atomic::inc(&_cache_hits); -#endif + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print_cr(" from-card cache hit."); + } assert(contains_reference(from), "We just added it!"); return; } else { @@ -623,16 +337,16 @@ void OtherRegionsTable::add_reference(OopOrNarrowOopStar from, int tid) { // If the region is already coarsened, return. if (_coarse_map.at(from_hrs_ind)) { -#if HRRS_VERBOSE - gclog_or_tty->print_cr(" coarse map hit."); -#endif + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print_cr(" coarse map hit."); + } assert(contains_reference(from), "We just added it!"); return; } // Otherwise find a per-region table to add it to. size_t ind = from_hrs_ind & _mod_max_fine_entries_mask; - PosParPRT* prt = find_region_table(ind, from_hr); + PerRegionTable* prt = find_region_table(ind, from_hr); if (prt == NULL) { MutexLockerEx x(&_m, Mutex::_no_safepoint_check_flag); // Confirm that it's really not there... @@ -649,35 +363,35 @@ void OtherRegionsTable::add_reference(OopOrNarrowOopStar from, int tid) { _sparse_table.add_card(from_hrs_ind, card_index)) { if (G1RecordHRRSOops) { HeapRegionRemSet::record(hr(), from); -#if HRRS_VERBOSE - gclog_or_tty->print(" Added card " PTR_FORMAT " to region " - "[" PTR_FORMAT "...) for ref " PTR_FORMAT ".\n", - align_size_down(uintptr_t(from), - CardTableModRefBS::card_size), - hr()->bottom(), from); -#endif + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print(" Added card " PTR_FORMAT " to region " + "[" PTR_FORMAT "...) for ref " PTR_FORMAT ".\n", + align_size_down(uintptr_t(from), + CardTableModRefBS::card_size), + hr()->bottom(), from); + } + } + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print_cr(" added card to sparse table."); } -#if HRRS_VERBOSE - gclog_or_tty->print_cr(" added card to sparse table."); -#endif assert(contains_reference_locked(from), "We just added it!"); return; } else { -#if HRRS_VERBOSE - gclog_or_tty->print_cr(" [tid %d] sparse table entry " - "overflow(f: %d, t: %d)", - tid, from_hrs_ind, cur_hrs_ind); -#endif + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print_cr(" [tid %d] sparse table entry " + "overflow(f: %d, t: %d)", + tid, from_hrs_ind, cur_hrs_ind); + } } if (_n_fine_entries == _max_fine_entries) { prt = delete_region_table(); } else { - prt = PosParPRT::alloc(from_hr); + prt = PerRegionTable::alloc(from_hr); } prt->init(from_hr); - PosParPRT* first_prt = _fine_grain_regions[ind]; + PerRegionTable* first_prt = _fine_grain_regions[ind]; prt->set_next(first_prt); // XXX Maybe move to init? _fine_grain_regions[ind] = prt; _n_fine_entries++; @@ -704,38 +418,25 @@ void OtherRegionsTable::add_reference(OopOrNarrowOopStar from, int tid) { // OtherRegionsTable for why this is OK. assert(prt != NULL, "Inv"); - if (prt->should_expand(tid)) { - MutexLockerEx x(&_m, Mutex::_no_safepoint_check_flag); - HeapRegion* prt_hr = prt->hr(); - if (prt_hr == from_hr) { - // Make sure the table still corresponds to the same region - prt->par_expand(); - prt->add_reference(from, tid); - } - // else: The table has been concurrently coarsened, evicted, and - // the table data structure re-used for another table. So, we - // don't need to add the reference any more given that the table - // has been coarsened and the whole region will be scanned anyway. - } else { - prt->add_reference(from, tid); - } + prt->add_reference(from); + if (G1RecordHRRSOops) { HeapRegionRemSet::record(hr(), from); -#if HRRS_VERBOSE - gclog_or_tty->print("Added card " PTR_FORMAT " to region " - "[" PTR_FORMAT "...) for ref " PTR_FORMAT ".\n", - align_size_down(uintptr_t(from), - CardTableModRefBS::card_size), - hr()->bottom(), from); -#endif + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print("Added card " PTR_FORMAT " to region " + "[" PTR_FORMAT "...) for ref " PTR_FORMAT ".\n", + align_size_down(uintptr_t(from), + CardTableModRefBS::card_size), + hr()->bottom(), from); + } } assert(contains_reference(from), "We just added it!"); } -PosParPRT* +PerRegionTable* OtherRegionsTable::find_region_table(size_t ind, HeapRegion* hr) const { assert(0 <= ind && ind < _max_fine_entries, "Preconditions."); - PosParPRT* prt = _fine_grain_regions[ind]; + PerRegionTable* prt = _fine_grain_regions[ind]; while (prt != NULL && prt->hr() != hr) { prt = prt->next(); } @@ -743,32 +444,16 @@ OtherRegionsTable::find_region_table(size_t ind, HeapRegion* hr) const { return prt; } - -#define DRT_CENSUS 0 - -#if DRT_CENSUS -static const int HistoSize = 6; -static int global_histo[HistoSize] = { 0, 0, 0, 0, 0, 0 }; -static int coarsenings = 0; -static int occ_sum = 0; -#endif - jint OtherRegionsTable::_n_coarsenings = 0; -PosParPRT* OtherRegionsTable::delete_region_table() { -#if DRT_CENSUS - int histo[HistoSize] = { 0, 0, 0, 0, 0, 0 }; - const int histo_limits[] = { 1, 4, 16, 64, 256, 2048 }; -#endif - +PerRegionTable* OtherRegionsTable::delete_region_table() { assert(_m.owned_by_self(), "Precondition"); assert(_n_fine_entries == _max_fine_entries, "Precondition"); - PosParPRT* max = NULL; + PerRegionTable* max = NULL; jint max_occ = 0; - PosParPRT** max_prev; + PerRegionTable** max_prev; size_t max_ind; -#if SAMPLE_FOR_EVICTION size_t i = _fine_eviction_start; for (size_t k = 0; k < _fine_eviction_sample_size; k++) { size_t ii = i; @@ -778,8 +463,8 @@ PosParPRT* OtherRegionsTable::delete_region_table() { if (ii == _max_fine_entries) ii = 0; guarantee(ii != i, "We must find one."); } - PosParPRT** prev = &_fine_grain_regions[ii]; - PosParPRT* cur = *prev; + PerRegionTable** prev = &_fine_grain_regions[ii]; + PerRegionTable* cur = *prev; while (cur != NULL) { jint cur_occ = cur->occupied(); if (max == NULL || cur_occ > max_occ) { @@ -794,64 +479,27 @@ PosParPRT* OtherRegionsTable::delete_region_table() { i = i + _fine_eviction_stride; if (i >= _n_fine_entries) i = i - _n_fine_entries; } + _fine_eviction_start++; - if (_fine_eviction_start >= _n_fine_entries) + + if (_fine_eviction_start >= _n_fine_entries) { _fine_eviction_start -= _n_fine_entries; -#else - for (int i = 0; i < _max_fine_entries; i++) { - PosParPRT** prev = &_fine_grain_regions[i]; - PosParPRT* cur = *prev; - while (cur != NULL) { - jint cur_occ = cur->occupied(); -#if DRT_CENSUS - for (int k = 0; k < HistoSize; k++) { - if (cur_occ <= histo_limits[k]) { - histo[k]++; global_histo[k]++; break; - } - } -#endif - if (max == NULL || cur_occ > max_occ) { - max = cur; - max_prev = prev; - max_ind = i; - max_occ = cur_occ; - } - prev = cur->next_addr(); - cur = cur->next(); - } } -#endif - // XXX + guarantee(max != NULL, "Since _n_fine_entries > 0"); -#if DRT_CENSUS - gclog_or_tty->print_cr("In a coarsening: histo of occs:"); - for (int k = 0; k < HistoSize; k++) { - gclog_or_tty->print_cr(" <= %4d: %5d.", histo_limits[k], histo[k]); - } - coarsenings++; - occ_sum += max_occ; - if ((coarsenings % 100) == 0) { - gclog_or_tty->print_cr("\ncoarsenings = %d; global summary:", coarsenings); - for (int k = 0; k < HistoSize; k++) { - gclog_or_tty->print_cr(" <= %4d: %5d.", histo_limits[k], global_histo[k]); - } - gclog_or_tty->print_cr("Avg occ of deleted region = %6.2f.", - (float)occ_sum/(float)coarsenings); - } -#endif // Set the corresponding coarse bit. size_t max_hrs_index = (size_t) max->hr()->hrs_index(); if (!_coarse_map.at(max_hrs_index)) { _coarse_map.at_put(max_hrs_index, true); _n_coarse_entries++; -#if 0 - gclog_or_tty->print("Coarsened entry in region [" PTR_FORMAT "...] " - "for region [" PTR_FORMAT "...] (%d coarse entries).\n", - hr()->bottom(), - max->hr()->bottom(), - _n_coarse_entries); -#endif + if (G1TraceHeapRegionRememberedSet) { + gclog_or_tty->print("Coarsened entry in region [" PTR_FORMAT "...] " + "for region [" PTR_FORMAT "...] (%d coarse entries).\n", + hr()->bottom(), + max->hr()->bottom(), + _n_coarse_entries); + } } // Unsplice. @@ -883,10 +531,10 @@ void OtherRegionsTable::scrub(CardTableModRefBS* ctbs, // Now do the fine-grained maps. for (size_t i = 0; i < _max_fine_entries; i++) { - PosParPRT* cur = _fine_grain_regions[i]; - PosParPRT** prev = &_fine_grain_regions[i]; + PerRegionTable* cur = _fine_grain_regions[i]; + PerRegionTable** prev = &_fine_grain_regions[i]; while (cur != NULL) { - PosParPRT* nxt = cur->next(); + PerRegionTable* nxt = cur->next(); // If the entire region is dead, eliminate. if (G1RSScrubVerbose) { gclog_or_tty->print_cr(" For other region %u:", @@ -899,7 +547,7 @@ void OtherRegionsTable::scrub(CardTableModRefBS* ctbs, if (G1RSScrubVerbose) { gclog_or_tty->print_cr(" deleted via region map."); } - PosParPRT::free(cur); + PerRegionTable::free(cur); } else { // Do fine-grain elimination. if (G1RSScrubVerbose) { @@ -914,7 +562,7 @@ void OtherRegionsTable::scrub(CardTableModRefBS* ctbs, *prev = nxt; cur->set_next(NULL); _n_fine_entries--; - PosParPRT::free(cur); + PerRegionTable::free(cur); } else { prev = cur->next_addr(); } @@ -940,7 +588,7 @@ size_t OtherRegionsTable::occupied() const { size_t OtherRegionsTable::occ_fine() const { size_t sum = 0; for (size_t i = 0; i < _max_fine_entries; i++) { - PosParPRT* cur = _fine_grain_regions[i]; + PerRegionTable* cur = _fine_grain_regions[i]; while (cur != NULL) { sum += cur->occupied(); cur = cur->next(); @@ -962,13 +610,13 @@ size_t OtherRegionsTable::mem_size() const { MutexLockerEx x((Mutex*)&_m, Mutex::_no_safepoint_check_flag); size_t sum = 0; for (size_t i = 0; i < _max_fine_entries; i++) { - PosParPRT* cur = _fine_grain_regions[i]; + PerRegionTable* cur = _fine_grain_regions[i]; while (cur != NULL) { sum += cur->mem_size(); cur = cur->next(); } } - sum += (sizeof(PosParPRT*) * _max_fine_entries); + sum += (sizeof(PerRegionTable*) * _max_fine_entries); sum += (_coarse_map.size_in_words() * HeapWordSize); sum += (_sparse_table.mem_size()); sum += sizeof(*this) - sizeof(_sparse_table); // Avoid double counting above. @@ -980,7 +628,7 @@ size_t OtherRegionsTable::static_mem_size() { } size_t OtherRegionsTable::fl_mem_size() { - return PerRegionTable::fl_mem_size() + PosParPRT::fl_mem_size(); + return PerRegionTable::fl_mem_size(); } void OtherRegionsTable::clear_fcc() { @@ -992,10 +640,10 @@ void OtherRegionsTable::clear_fcc() { void OtherRegionsTable::clear() { MutexLockerEx x(&_m, Mutex::_no_safepoint_check_flag); for (size_t i = 0; i < _max_fine_entries; i++) { - PosParPRT* cur = _fine_grain_regions[i]; + PerRegionTable* cur = _fine_grain_regions[i]; while (cur != NULL) { - PosParPRT* nxt = cur->next(); - PosParPRT::free(cur); + PerRegionTable* nxt = cur->next(); + PerRegionTable::free(cur); cur = nxt; } _fine_grain_regions[i] = NULL; @@ -1035,8 +683,8 @@ void OtherRegionsTable::clear_incoming_entry(HeapRegion* from_hr) { bool OtherRegionsTable::del_single_region_table(size_t ind, HeapRegion* hr) { assert(0 <= ind && ind < _max_fine_entries, "Preconditions."); - PosParPRT** prev_addr = &_fine_grain_regions[ind]; - PosParPRT* prt = *prev_addr; + PerRegionTable** prev_addr = &_fine_grain_regions[ind]; + PerRegionTable* prt = *prev_addr; while (prt != NULL && prt->hr() != hr) { prev_addr = prt->next_addr(); prt = prt->next(); @@ -1044,7 +692,7 @@ bool OtherRegionsTable::del_single_region_table(size_t ind, if (prt != NULL) { assert(prt->hr() == hr, "Loop postcondition."); *prev_addr = prt->next(); - PosParPRT::free(prt); + PerRegionTable::free(prt); _n_fine_entries--; return true; } else { @@ -1065,7 +713,7 @@ bool OtherRegionsTable::contains_reference_locked(OopOrNarrowOopStar from) const // Is this region in the coarse map? if (_coarse_map.at(hr_ind)) return true; - PosParPRT* prt = find_region_table(hr_ind & _mod_max_fine_entries_mask, + PerRegionTable* prt = find_region_table(hr_ind & _mod_max_fine_entries_mask, hr); if (prt != NULL) { return prt->contains_reference(from); @@ -1145,7 +793,7 @@ void HeapRegionRemSet::print() const { G1CollectedHeap::heap()->bot_shared()->address_for_index(card_index); gclog_or_tty->print_cr(" Card " PTR_FORMAT, card_start); } - // XXX + if (iter.n_yielded() != occupied()) { gclog_or_tty->print_cr("Yielded disagrees with occupied:"); gclog_or_tty->print_cr(" %6d yielded (%6d coarse, %6d fine).", @@ -1163,10 +811,6 @@ void HeapRegionRemSet::cleanup() { SparsePRT::cleanup_all(); } -void HeapRegionRemSet::par_cleanup() { - PosParPRT::par_contract_all(); -} - void HeapRegionRemSet::clear() { _other_regions.clear(); assert(occupied() == 0, "Should be clear."); diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp index 504afa2ef04..2a922aca5b2 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -35,7 +35,7 @@ class G1CollectedHeap; class G1BlockOffsetSharedArray; class HeapRegion; class HeapRegionRemSetIterator; -class PosParPRT; +class PerRegionTable; class SparsePRT; // Essentially a wrapper around SparsePRTCleanupTask. See @@ -79,15 +79,14 @@ class OtherRegionsTable VALUE_OBJ_CLASS_SPEC { size_t _n_coarse_entries; static jint _n_coarsenings; - PosParPRT** _fine_grain_regions; - size_t _n_fine_entries; + PerRegionTable** _fine_grain_regions; + size_t _n_fine_entries; -#define SAMPLE_FOR_EVICTION 1 -#if SAMPLE_FOR_EVICTION + // Used to sample a subset of the fine grain PRTs to determine which + // PRT to evict and coarsen. size_t _fine_eviction_start; static size_t _fine_eviction_stride; static size_t _fine_eviction_sample_size; -#endif SparsePRT _sparse_table; @@ -98,21 +97,18 @@ class OtherRegionsTable VALUE_OBJ_CLASS_SPEC { // Requires "prt" to be the first element of the bucket list appropriate // for "hr". If this list contains an entry for "hr", return it, // otherwise return "NULL". - PosParPRT* find_region_table(size_t ind, HeapRegion* hr) const; + PerRegionTable* find_region_table(size_t ind, HeapRegion* hr) const; - // Find, delete, and return a candidate PosParPRT, if any exists, + // Find, delete, and return a candidate PerRegionTable, if any exists, // adding the deleted region to the coarse bitmap. Requires the caller // to hold _m, and the fine-grain table to be full. - PosParPRT* delete_region_table(); + PerRegionTable* delete_region_table(); // If a PRT for "hr" is in the bucket list indicated by "ind" (which must // be the correct index for "hr"), delete it and return true; else return // false. bool del_single_region_table(size_t ind, HeapRegion* hr); - static jint _cache_probes; - static jint _cache_hits; - // Indexed by thread X heap region, to minimize thread contention. static int** _from_card_cache; static size_t _from_card_cache_max_regions; @@ -127,10 +123,6 @@ public: // sense. void add_reference(OopOrNarrowOopStar from, int tid); - void add_reference(OopOrNarrowOopStar from) { - return add_reference(from, 0); - } - // Removes any entries shown by the given bitmaps to contain only dead // objects. void scrub(CardTableModRefBS* ctbs, BitMap* region_bm, BitMap* card_bm); @@ -233,14 +225,12 @@ public: static jint n_coarsenings() { return OtherRegionsTable::n_coarsenings(); } - /* Used in the sequential case. Returns "true" iff this addition causes - the size limit to be reached. */ + // Used in the sequential case. void add_reference(OopOrNarrowOopStar from) { - _other_regions.add_reference(from); + _other_regions.add_reference(from, 0); } - /* Used in the parallel case. Returns "true" iff this addition causes - the size limit to be reached. */ + // Used in the parallel case. void add_reference(OopOrNarrowOopStar from, int tid) { _other_regions.add_reference(from, tid); } @@ -253,15 +243,6 @@ public: // entries for this region in other remsets. void clear(); - // Forget any entries due to pointers from "from_hr". - void clear_incoming_entry(HeapRegion* from_hr) { - _other_regions.clear_incoming_entry(from_hr); - } - -#if 0 - virtual void cleanup() = 0; -#endif - // Attempt to claim the region. Returns true iff this call caused an // atomic transition from Unclaimed to Claimed. bool claim_iter(); @@ -290,12 +271,6 @@ public: // Initialize the given iterator to iterate over this rem set. void init_iterator(HeapRegionRemSetIterator* iter) const; -#if 0 - // Apply the "do_card" method to the start address of every card in the - // rem set. Returns false if some application of the closure aborted. - virtual bool card_iterate(CardClosure* iter) = 0; -#endif - // The actual # of bytes this hr_remset takes up. size_t mem_size() { return _other_regions.mem_size() @@ -322,10 +297,7 @@ public: void print() const; // Called during a stop-world phase to perform any deferred cleanups. - // The second version may be called by parallel threads after then finish - // collection work. static void cleanup(); - static void par_cleanup(); // Declare the heap size (in # of regions) to the HeapRegionRemSet(s). // (Uses it to initialize from_card_cache). @@ -367,7 +339,7 @@ class HeapRegionRemSetIterator : public CHeapObj { // Local caching of HRRS fields. const BitMap* _coarse_map; - PosParPRT** _fine_grain_regions; + PerRegionTable** _fine_grain_regions; G1BlockOffsetSharedArray* _bosa; G1CollectedHeap* _g1h; @@ -404,8 +376,9 @@ class HeapRegionRemSetIterator : public CHeapObj { // Index of bucket-list we're working on. int _fine_array_index; + // Per Region Table we're doing within current bucket list. - PosParPRT* _fine_cur_prt; + PerRegionTable* _fine_cur_prt; /* SparsePRT::*/ SparsePRTIter _sparse_iter; @@ -435,12 +408,4 @@ public: } }; -#if 0 -class CardClosure: public Closure { -public: - virtual void do_card(HeapWord* card_start) = 0; -}; - -#endif - #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONREMSET_HPP From dc5fe663cbb6a532a72a8348a54f7799d20746e6 Mon Sep 17 00:00:00 2001 From: Coleen Phillimore Date: Mon, 25 Jun 2012 21:33:35 -0400 Subject: [PATCH 020/160] 7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table Cannot delete _buckets and HashtableEntries in shared space (CDS) Reviewed-by: acorn, kvn, dlong, dcubed, kamg --- .../src/share/vm/classfile/symbolTable.cpp | 151 ++++++++++++------ .../src/share/vm/classfile/symbolTable.hpp | 4 +- hotspot/src/share/vm/utilities/hashtable.cpp | 22 +++ hotspot/src/share/vm/utilities/hashtable.hpp | 7 +- 4 files changed, 128 insertions(+), 56 deletions(-) diff --git a/hotspot/src/share/vm/classfile/symbolTable.cpp b/hotspot/src/share/vm/classfile/symbolTable.cpp index fabe679f3a8..3b6ec7ceb34 100644 --- a/hotspot/src/share/vm/classfile/symbolTable.cpp +++ b/hotspot/src/share/vm/classfile/symbolTable.cpp @@ -46,11 +46,8 @@ bool SymbolTable::_needs_rehashing = false; jint SymbolTable::_seed = 0; Symbol* SymbolTable::allocate_symbol(const u1* name, int len, bool c_heap, TRAPS) { - // Don't allow symbols to be created which cannot fit in a Symbol*. - if (len > Symbol::max_length()) { - THROW_MSG_0(vmSymbols::java_lang_InternalError(), - "name is too long to represent"); - } + assert (len <= Symbol::max_length(), "should be checked by caller"); + Symbol* sym; // Allocate symbols in the C heap when dumping shared spaces in case there // are temporary symbols we can remove. @@ -95,9 +92,14 @@ void SymbolTable::unlink() { int total = 0; size_t memory_total = 0; for (int i = 0; i < the_table()->table_size(); ++i) { - for (HashtableEntry** p = the_table()->bucket_addr(i); *p != NULL; ) { - HashtableEntry* entry = *p; - if (entry->is_shared()) { + HashtableEntry** p = the_table()->bucket_addr(i); + HashtableEntry* entry = the_table()->bucket(i); + while (entry != NULL) { + // Shared entries are normally at the end of the bucket and if we run into + // a shared entry, then there is nothing more to remove. However, if we + // have rehashed the table, then the shared entries are no longer at the + // end of the bucket. + if (entry->is_shared() && !use_alternate_hashcode()) { break; } Symbol* s = entry->literal(); @@ -106,6 +108,7 @@ void SymbolTable::unlink() { assert(s != NULL, "just checking"); // If reference count is zero, remove. if (s->refcount() == 0) { + assert(!entry->is_shared(), "shared entries should be kept live"); delete s; removed++; *p = entry->next(); @@ -113,6 +116,8 @@ void SymbolTable::unlink() { } else { p = entry->next_addr(); } + // get next entry + entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); } } symbols_removed += removed; @@ -135,7 +140,8 @@ unsigned int SymbolTable::new_hash(Symbol* sym) { // with the existing strings. Set flag to use the alternate hash code afterwards. void SymbolTable::rehash_table() { assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); - assert(!DumpSharedSpaces, "this should never happen with -Xshare:dump"); + // This should never happen with -Xshare:dump but it might in testing mode. + if (DumpSharedSpaces) return; // Create a new symbol table SymbolTable* new_table = new SymbolTable(); @@ -176,12 +182,11 @@ Symbol* SymbolTable::lookup(int index, const char* name, return NULL; } -// Pick hashing algorithm, but return value already given if not using a new -// hash algorithm. -unsigned int SymbolTable::hash_symbol(const char* s, int len, unsigned int hashValue) { +// Pick hashing algorithm. +unsigned int SymbolTable::hash_symbol(const char* s, int len) { return use_alternate_hashcode() ? AltHashing::murmur3_32(seed(), (const jbyte*)s, len) : - (hashValue != 0 ? hashValue : java_lang_String::to_hash(s, len)); + java_lang_String::to_hash(s, len); } @@ -201,6 +206,9 @@ Symbol* SymbolTable::lookup(const char* name, int len, TRAPS) { // Found if (s != NULL) return s; + // Grab SymbolTable_lock first. + MutexLocker ml(SymbolTable_lock, THREAD); + // Otherwise, add to symbol to table return the_table()->basic_add(index, (u1*)name, len, hashValue, true, CHECK_NULL); } @@ -238,6 +246,9 @@ Symbol* SymbolTable::lookup(const Symbol* sym, int begin, int end, TRAPS) { // We can't include the code in No_Safepoint_Verifier because of the // ResourceMark. + // Grab SymbolTable_lock first. + MutexLocker ml(SymbolTable_lock, THREAD); + return the_table()->basic_add(index, (u1*)buffer, len, hashValue, true, CHECK_NULL); } @@ -306,6 +317,9 @@ void SymbolTable::add(Handle class_loader, constantPoolHandle cp, int names_count, const char** names, int* lengths, int* cp_indices, unsigned int* hashValues, TRAPS) { + // Grab SymbolTable_lock first. + MutexLocker ml(SymbolTable_lock, THREAD); + SymbolTable* table = the_table(); bool added = table->basic_add(class_loader, cp, names_count, names, lengths, cp_indices, hashValues, CHECK); @@ -326,22 +340,39 @@ Symbol* SymbolTable::new_permanent_symbol(const char* name, TRAPS) { if (result != NULL) { return result; } + // Grab SymbolTable_lock first. + MutexLocker ml(SymbolTable_lock, THREAD); + SymbolTable* table = the_table(); int index = table->hash_to_index(hash); return table->basic_add(index, (u1*)name, (int)strlen(name), hash, false, THREAD); } -Symbol* SymbolTable::basic_add(int index, u1 *name, int len, +Symbol* SymbolTable::basic_add(int index_arg, u1 *name, int len, unsigned int hashValue_arg, bool c_heap, TRAPS) { assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(), "proposed name of symbol must be stable"); - // Grab SymbolTable_lock first. - MutexLocker ml(SymbolTable_lock, THREAD); + // Don't allow symbols to be created which cannot fit in a Symbol*. + if (len > Symbol::max_length()) { + THROW_MSG_0(vmSymbols::java_lang_InternalError(), + "name is too long to represent"); + } + + // Cannot hit a safepoint in this function because the "this" pointer can move. + No_Safepoint_Verifier nsv; // Check if the symbol table has been rehashed, if so, need to recalculate - // the hash value. - unsigned int hashValue = hash_symbol((const char*)name, len, hashValue_arg); + // the hash value and index. + unsigned int hashValue; + int index; + if (use_alternate_hashcode()) { + hashValue = hash_symbol((const char*)name, len); + index = hash_to_index(hashValue); + } else { + hashValue = hashValue_arg; + index = index_arg; + } // Since look-up was done lock-free, we need to check if another // thread beat us in the race to insert the symbol. @@ -377,13 +408,18 @@ bool SymbolTable::basic_add(Handle class_loader, constantPoolHandle cp, } } - // Hold SymbolTable_lock through the symbol creation - MutexLocker ml(SymbolTable_lock, THREAD); + // Cannot hit a safepoint in this function because the "this" pointer can move. + No_Safepoint_Verifier nsv; for (int i=0; iis_in_reserved(name) || GC_locker::is_active(), - "proposed name of symbol must be stable"); - - Handle string; - // try to reuse the string if possible - if (!string_or_null.is_null() && (!JavaObjectsInPerm || string_or_null()->is_perm())) { - string = string_or_null; - } else { - string = java_lang_String::create_tenured_from_unicode(name, len, CHECK_NULL); - } - - // Allocation must be done before grapping the SymbolTable_lock lock - MutexLocker ml(StringTable_lock, THREAD); assert(java_lang_String::equals(string(), name, len), "string must be properly initialized"); + // Cannot hit a safepoint in this function because the "this" pointer can move. + No_Safepoint_Verifier nsv; // Check if the symbol table has been rehashed, if so, need to recalculate - // the hash value before second lookup. - unsigned int hashValue = hash_string(name, len, hashValue_arg); + // the hash value and index before second lookup. + unsigned int hashValue; + int index; + if (use_alternate_hashcode()) { + hashValue = hash_string(name, len); + index = hash_to_index(hashValue); + } else { + hashValue = hashValue_arg; + index = index_arg; + } // Since look-up was done lock-free, we need to check if another // thread beat us in the race to insert the symbol. @@ -664,13 +696,29 @@ oop StringTable::intern(Handle string_or_null, jchar* name, int len, TRAPS) { unsigned int hashValue = hash_string(name, len); int index = the_table()->hash_to_index(hashValue); - oop string = the_table()->lookup(index, name, len, hashValue); + oop found_string = the_table()->lookup(index, name, len, hashValue); // Found - if (string != NULL) return string; + if (found_string != NULL) return found_string; + + debug_only(StableMemoryChecker smc(name, len * sizeof(name[0]))); + assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(), + "proposed name of symbol must be stable"); + + Handle string; + // try to reuse the string if possible + if (!string_or_null.is_null() && (!JavaObjectsInPerm || string_or_null()->is_perm())) { + string = string_or_null; + } else { + string = java_lang_String::create_tenured_from_unicode(name, len, CHECK_NULL); + } + + // Grab the StringTable_lock before getting the_table() because it could + // change at safepoint. + MutexLocker ml(StringTable_lock, THREAD); // Otherwise, add to symbol to table - return the_table()->basic_add(index, string_or_null, name, len, + return the_table()->basic_add(index, string, name, len, hashValue, CHECK_NULL); } @@ -713,18 +761,24 @@ void StringTable::unlink(BoolObjectClosure* is_alive) { // entries at a safepoint. assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); for (int i = 0; i < the_table()->table_size(); ++i) { - for (HashtableEntry** p = the_table()->bucket_addr(i); *p != NULL; ) { - HashtableEntry* entry = *p; - if (entry->is_shared()) { + HashtableEntry** p = the_table()->bucket_addr(i); + HashtableEntry* entry = the_table()->bucket(i); + while (entry != NULL) { + // Shared entries are normally at the end of the bucket and if we run into + // a shared entry, then there is nothing more to remove. However, if we + // have rehashed the table, then the shared entries are no longer at the + // end of the bucket. + if (entry->is_shared() && !use_alternate_hashcode()) { break; } assert(entry->literal() != NULL, "just checking"); - if (is_alive->do_object_b(entry->literal())) { + if (entry->is_shared() || is_alive->do_object_b(entry->literal())) { p = entry->next_addr(); } else { *p = entry->next(); the_table()->free_entry(entry); } + entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); } } } @@ -795,7 +849,8 @@ unsigned int StringTable::new_hash(oop string) { // with the existing strings. Set flag to use the alternate hash code afterwards. void StringTable::rehash_table() { assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); - assert(!DumpSharedSpaces, "this should never happen with -Xshare:dump"); + // This should never happen with -Xshare:dump but it might in testing mode. + if (DumpSharedSpaces) return; StringTable* new_table = new StringTable(); // Initialize new global seed for hashing. diff --git a/hotspot/src/share/vm/classfile/symbolTable.hpp b/hotspot/src/share/vm/classfile/symbolTable.hpp index 6afc2524498..6e5782cd7ea 100644 --- a/hotspot/src/share/vm/classfile/symbolTable.hpp +++ b/hotspot/src/share/vm/classfile/symbolTable.hpp @@ -156,7 +156,7 @@ public: initialize_symbols(); } - static unsigned int hash_symbol(const char* s, int len, unsigned int hashValue = 0); + static unsigned int hash_symbol(const char* s, int len); static Symbol* lookup(const char* name, int len, TRAPS); // lookup only, won't add. Also calculate hash. @@ -294,7 +294,7 @@ public: // Hashing algorithm, used as the hash value used by the // StringTable for bucket selection and comparison (stored in the // HashtableEntry structures). This is used in the String.intern() method. - static unsigned int hash_string(const jchar* s, int len, unsigned int hashValue = 0); + static unsigned int hash_string(const jchar* s, int len); // Internal test. static void test_alt_hash() PRODUCT_RETURN; diff --git a/hotspot/src/share/vm/utilities/hashtable.cpp b/hotspot/src/share/vm/utilities/hashtable.cpp index 1b722195d8b..877e89533c2 100644 --- a/hotspot/src/share/vm/utilities/hashtable.cpp +++ b/hotspot/src/share/vm/utilities/hashtable.cpp @@ -24,6 +24,7 @@ #include "precompiled.hpp" #include "memory/allocation.inline.hpp" +#include "memory/filemap.hpp" #include "memory/resourceArea.hpp" #include "oops/oop.inline.hpp" #include "runtime/safepoint.hpp" @@ -119,8 +120,16 @@ template void Hashtable::move_to(Hashtable* new_table) { // Get a new index relative to the new table (can also change size) int index = new_table->hash_to_index(hashValue); p->set_hash(hashValue); + // Keep the shared bit in the Hashtable entry to indicate that this entry + // can't be deleted. The shared bit is the LSB in the _next field so + // walking the hashtable past these entries requires + // BasicHashtableEntry::make_ptr() call. + bool keep_shared = p->is_shared(); unlink_entry(p); new_table->add_entry(index, p); + if (keep_shared) { + p->set_shared(); + } p = next; } } @@ -135,6 +144,19 @@ template void Hashtable::move_to(Hashtable* new_table) { free_buckets(); } +void BasicHashtable::free_buckets() { + if (NULL != _buckets) { + // Don't delete the buckets in the shared space. They aren't + // allocated by os::malloc + if (!UseSharedSpaces || + !FileMapInfo::current_info()->is_in_shared_space(_buckets)) { + FREE_C_HEAP_ARRAY(HashtableBucket, _buckets); + } + _buckets = NULL; + } +} + + // Reverse the order of elements in the hash buckets. void BasicHashtable::reverse() { diff --git a/hotspot/src/share/vm/utilities/hashtable.hpp b/hotspot/src/share/vm/utilities/hashtable.hpp index 46b9c1bbe62..d31c0ff9484 100644 --- a/hotspot/src/share/vm/utilities/hashtable.hpp +++ b/hotspot/src/share/vm/utilities/hashtable.hpp @@ -217,12 +217,7 @@ protected: } // Free the buckets in this hashtable - void free_buckets() { - if (NULL != _buckets) { - FREE_C_HEAP_ARRAY(HashtableBucket, _buckets); - _buckets = NULL; - } - } + void free_buckets(); public: int table_size() { return _table_size; } From 9e9ac093ae4d2447a5f487341f219521d01d731b Mon Sep 17 00:00:00 2001 From: Sergey Bylokhov Date: Tue, 26 Jun 2012 13:46:09 +0400 Subject: [PATCH 021/160] 7142091: [macosx] RFE: Refactoring of peer initialization/disposing Reviewed-by: anthony, art --- .../classes/sun/lwawt/LWButtonPeer.java | 4 +- .../classes/sun/lwawt/LWCheckboxPeer.java | 4 +- .../classes/sun/lwawt/LWChoicePeer.java | 4 +- .../classes/sun/lwawt/LWComponentPeer.java | 80 +++++++++--------- .../macosx/classes/sun/lwawt/LWLabelPeer.java | 4 +- .../macosx/classes/sun/lwawt/LWListPeer.java | 4 +- .../classes/sun/lwawt/LWScrollBarPeer.java | 4 +- .../classes/sun/lwawt/LWScrollPanePeer.java | 4 +- .../classes/sun/lwawt/LWTextAreaPeer.java | 4 +- .../sun/lwawt/LWTextComponentPeer.java | 4 +- .../classes/sun/lwawt/LWTextFieldPeer.java | 4 +- .../classes/sun/lwawt/LWWindowPeer.java | 84 ++++++++----------- .../sun/lwawt/macosx/CPlatformWindow.java | 24 +----- jdk/src/macosx/native/sun/awt/AWTWindow.m | 21 ----- 14 files changed, 100 insertions(+), 149 deletions(-) diff --git a/jdk/src/macosx/classes/sun/lwawt/LWButtonPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWButtonPeer.java index f0cd54d93b3..e5f8838c8cd 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWButtonPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWButtonPeer.java @@ -47,8 +47,8 @@ final class LWButtonPeer extends LWComponentPeer } @Override - public void initialize() { - super.initialize(); + void initializeImpl() { + super.initializeImpl(); setLabel(getTarget().getLabel()); synchronized (getDelegateLock()) { getDelegate().addActionListener(this); diff --git a/jdk/src/macosx/classes/sun/lwawt/LWCheckboxPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWCheckboxPeer.java index b639e6c2903..69bce89adae 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWCheckboxPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWCheckboxPeer.java @@ -61,8 +61,8 @@ final class LWCheckboxPeer } @Override - public void initialize() { - super.initialize(); + void initializeImpl() { + super.initializeImpl(); setLabel(getTarget().getLabel()); setState(getTarget().getState()); setCheckboxGroup(getTarget().getCheckboxGroup()); diff --git a/jdk/src/macosx/classes/sun/lwawt/LWChoicePeer.java b/jdk/src/macosx/classes/sun/lwawt/LWChoicePeer.java index b0ab9d0e3f0..dc781d3d682 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWChoicePeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWChoicePeer.java @@ -55,8 +55,8 @@ final class LWChoicePeer extends LWComponentPeer> } @Override - public void initialize() { - super.initialize(); + void initializeImpl() { + super.initializeImpl(); final Choice choice = getTarget(); final JComboBox combo = getDelegate(); synchronized (getDelegateLock()) { diff --git a/jdk/src/macosx/classes/sun/lwawt/LWComponentPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWComponentPeer.java index 035cfe1596b..61d0dd060c4 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWComponentPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWComponentPeer.java @@ -81,19 +81,10 @@ public abstract class LWComponentPeer // lock is not used as there are many peers related ops // to be done on the toolkit thread, and we don't want to // depend on a public lock on this thread - private final static Object peerTreeLock = + private static final Object peerTreeLock = new StringBuilder("LWComponentPeer.peerTreeLock"); - /** - * A custom tree-lock used for the hierarchy of the delegate Swing - * components. - * The lock synchronizes access to the delegate - * internal state. Think of it as a 'virtual EDT'. - */ -// private final Object delegateTreeLock = -// new StringBuilder("LWComponentPeer.delegateTreeLock"); - - private T target; + private final T target; // Container peer. It may not be the peer of the target's direct // parent, for example, in the case of hw/lw mixing. However, @@ -108,10 +99,10 @@ public abstract class LWComponentPeer // be updated when the component is reparented to another container private LWWindowPeer windowPeer; - private AtomicBoolean disposed = new AtomicBoolean(false); + private final AtomicBoolean disposed = new AtomicBoolean(false); // Bounds are relative to parent peer - private Rectangle bounds = new Rectangle(); + private final Rectangle bounds = new Rectangle(); private Region region; // Component state. Should be accessed under the state lock @@ -122,9 +113,11 @@ public abstract class LWComponentPeer private Color foreground; private Font font; - // Paint area to coalesce all the paint events and store - // the target dirty area - private RepaintArea targetPaintArea; + /** + * Paint area to coalesce all the paint events and store the target dirty + * area. + */ + private final RepaintArea targetPaintArea; // private volatile boolean paintPending; private volatile boolean isLayouting; @@ -137,7 +130,7 @@ public abstract class LWComponentPeer private int fNumDropTargets = 0; private CDropTarget fDropTarget = null; - private PlatformComponent platformComponent; + private final PlatformComponent platformComponent; private final class DelegateContainer extends Container { { @@ -175,6 +168,7 @@ public abstract class LWComponentPeer } public LWComponentPeer(T target, PlatformComponent platformComponent) { + targetPaintArea = new LWRepaintArea(); this.target = target; this.platformComponent = platformComponent; @@ -201,10 +195,13 @@ public abstract class LWComponentPeer synchronized (getDelegateLock()) { delegate = createDelegate(); if (delegate != null) { + delegate.setVisible(false); delegateContainer = new DelegateContainer(); delegateContainer.add(delegate); delegateContainer.addNotify(); delegate.addNotify(); + resetColorsAndFont(delegate); + delegate.setOpaque(true); } else { return; } @@ -278,27 +275,28 @@ public abstract class LWComponentPeer return getDelegate(); } - /* - * Initializes this peer by fetching all the properties from the target. - * The call to initialize() is not placed to LWComponentPeer ctor to - * let the subclass ctor to finish completely first. Instead, it's the - * LWToolkit object who is responsible for initialization. + /** + * Initializes this peer. The call to initialize() is not placed to + * LWComponentPeer ctor to let the subclass ctor to finish completely first. + * Instead, it's the LWToolkit object who is responsible for initialization. + * Note that we call setVisible() at the end of initialization. */ - public void initialize() { + public final void initialize() { platformComponent.initialize(target, this, getPlatformWindow()); - targetPaintArea = new LWRepaintArea(); - if (getDelegate() != null) { - synchronized (getDelegateLock()) { - resetColorsAndFont(delegate); - getDelegate().setOpaque(true); - } - } + initializeImpl(); + setVisible(target.isVisible()); + } + + /** + * Fetching general properties from the target. Should be overridden in + * subclasses to initialize specific peers properties. + */ + void initializeImpl() { setBackground(target.getBackground()); setForeground(target.getForeground()); setFont(target.getFont()); setBounds(target.getBounds()); setEnabled(target.isEnabled()); - setVisible(target.isVisible()); } private static void resetColorsAndFont(final Container c) { @@ -314,15 +312,18 @@ public abstract class LWComponentPeer return stateLock; } - // Synchronize all operations with the Swing delegates under - // AWT tree lock, using a new separate lock to synchronize - // access to delegates may lead deadlocks + /** + * Synchronize all operations with the Swing delegates under AWT tree lock, + * using a new separate lock to synchronize access to delegates may lead + * deadlocks. Think of it as a 'virtual EDT'. + * + * @return DelegateLock + */ final Object getDelegateLock() { - //return delegateTreeLock; return getTarget().getTreeLock(); } - protected final static Object getPeerTreeLock() { + protected static final Object getPeerTreeLock() { return peerTreeLock; } @@ -758,14 +759,17 @@ public abstract class LWComponentPeer } @Override - public void setVisible(boolean v) { + public void setVisible(final boolean v) { synchronized (getStateLock()) { if (visible == v) { return; } visible = v; } + setVisibleImpl(v); + } + protected void setVisibleImpl(final boolean v) { final D delegate = getDelegate(); if (delegate != null) { @@ -1355,7 +1359,7 @@ public abstract class LWComponentPeer * * @see #isVisible() */ - protected boolean isShowing() { + protected final boolean isShowing() { synchronized (getPeerTreeLock()) { if (isVisible()) { final LWContainerPeer container = getContainerPeer(); diff --git a/jdk/src/macosx/classes/sun/lwawt/LWLabelPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWLabelPeer.java index 7577007fa7f..f8c764364cc 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWLabelPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWLabelPeer.java @@ -60,8 +60,8 @@ final class LWLabelPeer extends LWComponentPeer } @Override - public void initialize() { - super.initialize(); + void initializeImpl() { + super.initializeImpl(); setText(getTarget().getText()); setAlignment(getTarget().getAlignment()); } diff --git a/jdk/src/macosx/classes/sun/lwawt/LWListPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWListPeer.java index df705fd5068..1e6154fd64f 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWListPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWListPeer.java @@ -49,8 +49,8 @@ final class LWListPeer } @Override - public void initialize() { - super.initialize(); + void initializeImpl() { + super.initializeImpl(); setMultipleMode(getTarget().isMultipleMode()); final int[] selectedIndices = getTarget().getSelectedIndexes(); synchronized (getDelegateLock()) { diff --git a/jdk/src/macosx/classes/sun/lwawt/LWScrollBarPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWScrollBarPeer.java index d376a6b1d82..688f9e96f16 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWScrollBarPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWScrollBarPeer.java @@ -54,8 +54,8 @@ final class LWScrollBarPeer extends LWComponentPeer } @Override - public void initialize() { - super.initialize(); + void initializeImpl() { + super.initializeImpl(); final Scrollbar target = getTarget(); setValues(target.getValue(), target.getVisibleAmount(), target.getMinimum(), target.getMaximum()); diff --git a/jdk/src/macosx/classes/sun/lwawt/LWScrollPanePeer.java b/jdk/src/macosx/classes/sun/lwawt/LWScrollPanePeer.java index 1b1bdf5369e..1e386f25725 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWScrollPanePeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWScrollPanePeer.java @@ -70,8 +70,8 @@ final class LWScrollPanePeer extends LWContainerPeer } @Override - public void initialize() { - super.initialize(); + void initializeImpl() { + super.initializeImpl(); final int policy = getTarget().getScrollbarDisplayPolicy(); synchronized (getDelegateLock()) { getDelegate().getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE); diff --git a/jdk/src/macosx/classes/sun/lwawt/LWTextAreaPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWTextAreaPeer.java index ebe97745d49..8517313b741 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWTextAreaPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWTextAreaPeer.java @@ -59,8 +59,8 @@ final class LWTextAreaPeer } @Override - public void initialize() { - super.initialize(); + void initializeImpl() { + super.initializeImpl(); final int visibility = getTarget().getScrollbarVisibility(); synchronized (getDelegateLock()) { setScrollBarVisibility(visibility); diff --git a/jdk/src/macosx/classes/sun/lwawt/LWTextComponentPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWTextComponentPeer.java index 01de62b6c96..f0215d40f75 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWTextComponentPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWTextComponentPeer.java @@ -63,8 +63,8 @@ abstract class LWTextComponentPeer Date: Tue, 26 Jun 2012 16:46:00 +0400 Subject: [PATCH 022/160] 7024749: JDK7 b131---a crash in: Java_sun_awt_windows_ThemeReader_isGetThemeTransitionDurationDefined+0x75 Reviewed-by: art, ant --- .../native/sun/windows/awt_Component.cpp | 37 +++++++----- .../native/sun/windows/awt_Component.h | 2 +- .../native/sun/windows/awt_FileDialog.cpp | 1 + .../windows/native/sun/windows/awt_Frame.cpp | 2 - .../native/sun/windows/awt_TextComponent.cpp | 4 +- .../java/awt/Frame/7024749/bug7024749.java | 59 +++++++++++++++++++ 6 files changed, 85 insertions(+), 20 deletions(-) create mode 100644 jdk/test/java/awt/Frame/7024749/bug7024749.java diff --git a/jdk/src/windows/native/sun/windows/awt_Component.cpp b/jdk/src/windows/native/sun/windows/awt_Component.cpp index 9cc2f76e90b..d7b265c44e3 100644 --- a/jdk/src/windows/native/sun/windows/awt_Component.cpp +++ b/jdk/src/windows/native/sun/windows/awt_Component.cpp @@ -1474,9 +1474,7 @@ LRESULT AwtComponent::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) ::GetClientRect( GetHWnd(), &r ); mr = WmSize(static_cast(wParam), r.right - r.left, r.bottom - r.top); //mr = WmSize(wParam, LOWORD(lParam), HIWORD(lParam)); - if (ImmGetContext() != NULL) { - SetCompositionWindow(r); - } + SetCompositionWindow(r); break; } case WM_SIZING: @@ -1535,7 +1533,10 @@ LRESULT AwtComponent::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) // When the window is deactivated, send WM_IME_ENDCOMPOSITION // message to deactivate the composition window so that // it won't receive keyboard input focus. - if (ImmGetContext() != NULL) { + HIMC hIMC; + HWND hwnd = ImmGetHWnd(); + if ((hIMC = ImmGetContext(hwnd)) != NULL) { + ImmReleaseContext(hwnd, hIMC); DefWindowProc(WM_IME_ENDCOMPOSITION, 0, 0); } } @@ -1718,11 +1719,9 @@ LRESULT AwtComponent::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) case WM_IME_SETCONTEXT: // lParam is passed as pointer and it can be modified. mr = WmImeSetContext(static_cast(wParam), &lParam); - CallProxyDefWindowProc(message, wParam, lParam, retValue, mr); break; case WM_IME_NOTIFY: mr = WmImeNotify(wParam, lParam); - CallProxyDefWindowProc(message, wParam, lParam, retValue, mr); break; case WM_IME_STARTCOMPOSITION: mr = WmImeStartComposition(); @@ -3723,12 +3722,14 @@ MsgRouting AwtComponent::WmPaste() // support IME Composition messages void AwtComponent::SetCompositionWindow(RECT& r) { - HIMC hIMC = ImmGetContext(); + HWND hwnd = ImmGetHWnd(); + HIMC hIMC = ImmGetContext(hwnd); if (hIMC == NULL) { return; } COMPOSITIONFORM cf = {CFS_DEFAULT, {0, 0}, {0, 0, 0, 0}}; ImmSetCompositionWindow(hIMC, &cf); + ImmReleaseContext(hwnd, hIMC); } void AwtComponent::OpenCandidateWindow(int x, int y) @@ -3742,16 +3743,16 @@ void AwtComponent::OpenCandidateWindow(int x, int y) SetCandidateWindow(iCandType, x-rc.left, y-rc.top); } if (m_bitsCandType != 0) { - HWND proxy = GetProxyFocusOwner(); // REMIND: is there any chance GetProxyFocusOwner() returns NULL here? - ::DefWindowProc((proxy != NULL) ? proxy : GetHWnd(), + ::DefWindowProc(ImmGetHWnd(), WM_IME_NOTIFY, IMN_OPENCANDIDATE, m_bitsCandType); } } void AwtComponent::SetCandidateWindow(int iCandType, int x, int y) { - HIMC hIMC = ImmGetContext(); + HWND hwnd = ImmGetHWnd(); + HIMC hIMC = ImmGetContext(hwnd); CANDIDATEFORM cf; cf.dwIndex = iCandType; cf.dwStyle = CFS_CANDIDATEPOS; @@ -3759,17 +3760,20 @@ void AwtComponent::SetCandidateWindow(int iCandType, int x, int y) cf.ptCurrentPos.y = y; ImmSetCandidateWindow(hIMC, &cf); + ImmReleaseContext(hwnd, hIMC); } MsgRouting AwtComponent::WmImeSetContext(BOOL fSet, LPARAM *lplParam) { // If the Windows input context is disabled, do not let Windows // display any UIs. - HIMC hIMC = ImmGetContext(); + HWND hwnd = ImmGetHWnd(); + HIMC hIMC = ImmGetContext(hwnd); if (hIMC == NULL) { *lplParam = 0; return mrDoDefault; } + ImmReleaseContext(hwnd, hIMC); if (fSet) { LPARAM lParam = *lplParam; @@ -3824,11 +3828,13 @@ MsgRouting AwtComponent::WmImeComposition(WORD wChar, LPARAM flags) AwtInputTextInfor* textInfor = NULL; try { - HIMC hIMC = ImmGetContext(); + HWND hwnd = ImmGetHWnd(); + HIMC hIMC = ImmGetContext(hwnd); DASSERT(hIMC!=0); textInfor = new AwtInputTextInfor; textInfor->GetContextData(hIMC, flags); + ImmReleaseContext(hwnd, hIMC); jstring jtextString = textInfor->GetText(); /* The conditions to send the input method event to AWT EDT are: @@ -4012,16 +4018,15 @@ void AwtComponent::InquireCandidatePosition() DASSERT(!safe_ExceptionOccurred(env)); } -HIMC AwtComponent::ImmGetContext() +HWND AwtComponent::ImmGetHWnd() { HWND proxy = GetProxyFocusOwner(); - return ::ImmGetContext((proxy != NULL) ? proxy : GetHWnd()); + return (proxy != NULL) ? proxy : GetHWnd(); } HIMC AwtComponent::ImmAssociateContext(HIMC himc) { - HWND proxy = GetProxyFocusOwner(); - return ::ImmAssociateContext((proxy != NULL) ? proxy : GetHWnd(), himc); + return ::ImmAssociateContext(ImmGetHWnd(), himc); } HWND AwtComponent::GetProxyFocusOwner() diff --git a/jdk/src/windows/native/sun/windows/awt_Component.h b/jdk/src/windows/native/sun/windows/awt_Component.h index 3257c517516..75c1b3c9384 100644 --- a/jdk/src/windows/native/sun/windows/awt_Component.h +++ b/jdk/src/windows/native/sun/windows/awt_Component.h @@ -464,7 +464,7 @@ public: int caretPos, int visiblePos); void InquireCandidatePosition(); INLINE LPARAM GetCandidateType() { return m_bitsCandType; } - HIMC ImmGetContext(); + HWND ImmGetHWnd(); HIMC ImmAssociateContext(HIMC himc); HWND GetProxyFocusOwner(); diff --git a/jdk/src/windows/native/sun/windows/awt_FileDialog.cpp b/jdk/src/windows/native/sun/windows/awt_FileDialog.cpp index abd6e120451..d60fbd329b1 100644 --- a/jdk/src/windows/native/sun/windows/awt_FileDialog.cpp +++ b/jdk/src/windows/native/sun/windows/awt_FileDialog.cpp @@ -156,6 +156,7 @@ FileDialogHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam) HIMC hIMC = ::ImmGetContext(hdlg); if (hIMC != NULL) { ::ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0); + ::ImmReleaseContext(hdlg, hIMC); } WNDPROC lpfnWndProc = (WNDPROC)(::GetProp(parent, NativeDialogWndProcProp)); diff --git a/jdk/src/windows/native/sun/windows/awt_Frame.cpp b/jdk/src/windows/native/sun/windows/awt_Frame.cpp index 76811dfec03..da1df839535 100644 --- a/jdk/src/windows/native/sun/windows/awt_Frame.cpp +++ b/jdk/src/windows/native/sun/windows/awt_Frame.cpp @@ -319,8 +319,6 @@ LRESULT AwtFrame::ProxyWindowProc(UINT message, WPARAM wParam, LPARAM lParam, Ms case WM_IME_STARTCOMPOSITION: case WM_IME_ENDCOMPOSITION: case WM_IME_COMPOSITION: - case WM_IME_SETCONTEXT: - case WM_IME_NOTIFY: case WM_IME_CONTROL: case WM_IME_COMPOSITIONFULL: case WM_IME_SELECT: diff --git a/jdk/src/windows/native/sun/windows/awt_TextComponent.cpp b/jdk/src/windows/native/sun/windows/awt_TextComponent.cpp index 17d7c68088c..5ba2efca861 100644 --- a/jdk/src/windows/native/sun/windows/awt_TextComponent.cpp +++ b/jdk/src/windows/native/sun/windows/awt_TextComponent.cpp @@ -336,7 +336,8 @@ AwtTextComponent::WmPaste() //im --- override to over the spot composition void AwtTextComponent::SetCompositionWindow(RECT& rc) { - HIMC hIMC = ImmGetContext(); + HWND hwnd = ImmGetHWnd(); + HIMC hIMC = ImmGetContext(hwnd); // rc is not used for text component. COMPOSITIONFORM cf = { CFS_FORCE_POSITION, {0,0}, {0,0,0,0} }; GetCaretPos(&(cf.ptCurrentPos)); @@ -348,6 +349,7 @@ void AwtTextComponent::SetCompositionWindow(RECT& rc) LOGFONT lf; GetObject(m_hFont, sizeof(LOGFONT), &lf); ImmSetCompositionFont(hIMC, &lf); + ImmReleaseContext(hwnd, hIMC); } //im --- end diff --git a/jdk/test/java/awt/Frame/7024749/bug7024749.java b/jdk/test/java/awt/Frame/7024749/bug7024749.java new file mode 100644 index 00000000000..5eb28b6723d --- /dev/null +++ b/jdk/test/java/awt/Frame/7024749/bug7024749.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7024749 + * @summary JDK7 b131---a crash in: Java_sun_awt_windows_ThemeReader_isGetThemeTransitionDurationDefined+0x75 + * @library ../../../regtesthelpers + * @build Util + * @author Oleg Pekhovskiy: area=awt.toplevel + @run main bug7024749 + */ + +import java.awt.*; +import test.java.awt.regtesthelpers.Util; + +public class bug7024749 { + public static void main(String[] args) { + final Frame f = new Frame("F"); + f.setBounds(0,0,200,200); + f.setEnabled(false); // <- disable the top-level + f.setVisible(true); + + Window w = new Window(f); + w.setBounds(300,300,300,300); + w.add(new TextField(20)); + w.setVisible(true); + + Robot robot = Util.createRobot(); + robot.setAutoDelay(1000); + Util.waitForIdle(robot); + robot.delay(1000); + Util.clickOnTitle(f, robot); + Util.waitForIdle(robot); + + f.dispose(); + System.out.println("Test passed!"); + } +} From 98dba02e885b9a1393a1b6c848a685e8c9a0fe8b Mon Sep 17 00:00:00 2001 From: Anthony Petrov Date: Tue, 26 Jun 2012 17:29:10 +0400 Subject: [PATCH 023/160] 7124326: [macosx] An issue similar to autoshutdown one in two AppContexts situation Don't add SystemTrayPeer to the peers map Reviewed-by: art, leonidr --- jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java | 1 - 1 file changed, 1 deletion(-) diff --git a/jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java b/jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java index d3565b845ad..524abddcf4f 100644 --- a/jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java +++ b/jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java @@ -216,7 +216,6 @@ public class LWCToolkit extends LWToolkit { @Override public SystemTrayPeer createSystemTray(SystemTray target) { SystemTrayPeer peer = new CSystemTray(); - targetCreatedPeer(target, peer); return peer; } From 8c4cefaa96fa51f417abdc4a08996f9aec4e3125 Mon Sep 17 00:00:00 2001 From: Vladimir Kozlov Date: Tue, 26 Jun 2012 09:06:16 -0700 Subject: [PATCH 024/160] 7179138: Incorrect result with String concatenation optimization Check for and skip diamond shaped NULL check code for the result of toString() Reviewed-by: twisti, roland --- hotspot/src/share/vm/opto/stringopts.cpp | 126 ++++++++++++------ .../test/compiler/7179138/Test7179138_1.java | 66 +++++++++ .../test/compiler/7179138/Test7179138_2.java | 66 +++++++++ 3 files changed, 216 insertions(+), 42 deletions(-) create mode 100644 hotspot/test/compiler/7179138/Test7179138_1.java create mode 100644 hotspot/test/compiler/7179138/Test7179138_2.java diff --git a/hotspot/src/share/vm/opto/stringopts.cpp b/hotspot/src/share/vm/opto/stringopts.cpp index 99498ea9598..d606a7fdad6 100644 --- a/hotspot/src/share/vm/opto/stringopts.cpp +++ b/hotspot/src/share/vm/opto/stringopts.cpp @@ -112,6 +112,7 @@ class StringConcat : public ResourceObj { _arguments->ins_req(0, value); _mode.insert_before(0, mode); } + void push_string(Node* value) { push(value, StringMode); } @@ -125,9 +126,56 @@ class StringConcat : public ResourceObj { push(value, CharMode); } + static bool is_SB_toString(Node* call) { + if (call->is_CallStaticJava()) { + CallStaticJavaNode* csj = call->as_CallStaticJava(); + ciMethod* m = csj->method(); + if (m != NULL && + (m->intrinsic_id() == vmIntrinsics::_StringBuilder_toString || + m->intrinsic_id() == vmIntrinsics::_StringBuffer_toString)) { + return true; + } + } + return false; + } + + static Node* skip_string_null_check(Node* value) { + // Look for a diamond shaped Null check of toString() result + // (could be code from String.valueOf()): + // (Proj == NULL) ? "null":"CastPP(Proj)#NotNULL + if (value->is_Phi()) { + int true_path = value->as_Phi()->is_diamond_phi(); + if (true_path != 0) { + // phi->region->if_proj->ifnode->bool + BoolNode* b = value->in(0)->in(1)->in(0)->in(1)->as_Bool(); + Node* cmp = b->in(1); + Node* v1 = cmp->in(1); + Node* v2 = cmp->in(2); + // Null check of the return of toString which can simply be skipped. + if (b->_test._test == BoolTest::ne && + v2->bottom_type() == TypePtr::NULL_PTR && + value->in(true_path)->Opcode() == Op_CastPP && + value->in(true_path)->in(1) == v1 && + v1->is_Proj() && is_SB_toString(v1->in(0))) { + return v1; + } + } + } + return value; + } + Node* argument(int i) { return _arguments->in(i); } + Node* argument_uncast(int i) { + Node* arg = argument(i); + int amode = mode(i); + if (amode == StringConcat::StringMode || + amode == StringConcat::StringNullCheckMode) { + arg = skip_string_null_check(arg); + } + return arg; + } void set_argument(int i, Node* value) { _arguments->set_req(i, value); } @@ -206,9 +254,11 @@ class StringConcat : public ResourceObj { void StringConcat::eliminate_unneeded_control() { - eliminate_initialize(begin()->initialization()); for (uint i = 0; i < _control.size(); i++) { Node* n = _control.at(i); + if (n->is_Allocate()) { + eliminate_initialize(n->as_Allocate()->initialization()); + } if (n->is_Call()) { if (n != _end) { eliminate_call(n->as_Call()); @@ -239,14 +289,15 @@ StringConcat* StringConcat::merge(StringConcat* other, Node* arg) { assert(result->_control.contains(other->_end), "what?"); assert(result->_control.contains(_begin), "what?"); for (int x = 0; x < num_arguments(); x++) { - if (argument(x) == arg) { + Node* argx = argument_uncast(x); + if (argx == arg) { // replace the toString result with the all the arguments that // made up the other StringConcat for (int y = 0; y < other->num_arguments(); y++) { result->append(other->argument(y), other->mode(y)); } } else { - result->append(argument(x), mode(x)); + result->append(argx, mode(x)); } } result->set_allocation(other->_begin); @@ -327,14 +378,9 @@ Node_List PhaseStringOpts::collect_toString_calls() { while (worklist.size() > 0) { Node* ctrl = worklist.pop(); - if (ctrl->is_CallStaticJava()) { + if (StringConcat::is_SB_toString(ctrl)) { CallStaticJavaNode* csj = ctrl->as_CallStaticJava(); - ciMethod* m = csj->method(); - if (m != NULL && - (m->intrinsic_id() == vmIntrinsics::_StringBuffer_toString || - m->intrinsic_id() == vmIntrinsics::_StringBuilder_toString)) { - string_calls.push(csj); - } + string_calls.push(csj); } if (ctrl->in(0) != NULL && !_visited.test_set(ctrl->in(0)->_idx)) { worklist.push(ctrl->in(0)); @@ -550,44 +596,40 @@ PhaseStringOpts::PhaseStringOpts(PhaseGVN* gvn, Unique_Node_List*): for (int c = 0; c < concats.length(); c++) { StringConcat* sc = concats.at(c); for (int i = 0; i < sc->num_arguments(); i++) { - Node* arg = sc->argument(i); - if (arg->is_Proj() && arg->in(0)->is_CallStaticJava()) { + Node* arg = sc->argument_uncast(i); + if (arg->is_Proj() && StringConcat::is_SB_toString(arg->in(0))) { CallStaticJavaNode* csj = arg->in(0)->as_CallStaticJava(); - if (csj->method() != NULL && - (csj->method()->intrinsic_id() == vmIntrinsics::_StringBuilder_toString || - csj->method()->intrinsic_id() == vmIntrinsics::_StringBuffer_toString)) { - for (int o = 0; o < concats.length(); o++) { - if (c == o) continue; - StringConcat* other = concats.at(o); - if (other->end() == csj) { + for (int o = 0; o < concats.length(); o++) { + if (c == o) continue; + StringConcat* other = concats.at(o); + if (other->end() == csj) { #ifndef PRODUCT - if (PrintOptimizeStringConcat) { - tty->print_cr("considering stacked concats"); - } + if (PrintOptimizeStringConcat) { + tty->print_cr("considering stacked concats"); + } #endif - StringConcat* merged = sc->merge(other, arg); - if (merged->validate_control_flow()) { + StringConcat* merged = sc->merge(other, arg); + if (merged->validate_control_flow()) { #ifndef PRODUCT - if (PrintOptimizeStringConcat) { - tty->print_cr("stacking would succeed"); - } -#endif - if (c < o) { - concats.remove_at(o); - concats.at_put(c, merged); - } else { - concats.remove_at(c); - concats.at_put(o, merged); - } - goto restart; - } else { -#ifndef PRODUCT - if (PrintOptimizeStringConcat) { - tty->print_cr("stacking would fail"); - } -#endif + if (PrintOptimizeStringConcat) { + tty->print_cr("stacking would succeed"); } +#endif + if (c < o) { + concats.remove_at(o); + concats.at_put(c, merged); + } else { + concats.remove_at(c); + concats.at_put(o, merged); + } + goto restart; + } else { +#ifndef PRODUCT + if (PrintOptimizeStringConcat) { + tty->print_cr("stacking would fail"); + } +#endif } } } diff --git a/hotspot/test/compiler/7179138/Test7179138_1.java b/hotspot/test/compiler/7179138/Test7179138_1.java new file mode 100644 index 00000000000..afa830731e3 --- /dev/null +++ b/hotspot/test/compiler/7179138/Test7179138_1.java @@ -0,0 +1,66 @@ +/* + * Copyright 2012 Skip Balk. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7179138 + * @summary Incorrect result with String concatenation optimization + * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation Test7179138_1 + * + * @author Skip Balk + */ + +public class Test7179138_1 { + public static void main(String[] args) throws Exception { + System.out.println("Java Version: " + System.getProperty("java.vm.version")); + long[] durations = new long[60]; + for (int i = 0; i < 100000; i++) { + // this empty for-loop is required to reproduce this bug + for (long duration : durations) { + // do nothing + } + { + String s = "test"; + int len = s.length(); + + s = new StringBuilder(String.valueOf(s)).append(s).toString(); + len = len + len; + + s = new StringBuilder(String.valueOf(s)).append(s).toString(); + len = len + len; + + s = new StringBuilder(String.valueOf(s)).append(s).toString(); + len = len + len; + + if (s.length() != len) { + System.out.println("Failed at iteration: " + i); + System.out.println("Length mismatch: " + s.length() + " <> " + len); + System.out.println("Expected: \"" + "test" + "test" + "test" + "test" + "test" + "test" + "test" + "test" + "\""); + System.out.println("Actual: \"" + s + "\""); + System.exit(97); + } + } + } + } +} + diff --git a/hotspot/test/compiler/7179138/Test7179138_2.java b/hotspot/test/compiler/7179138/Test7179138_2.java new file mode 100644 index 00000000000..615c614fc30 --- /dev/null +++ b/hotspot/test/compiler/7179138/Test7179138_2.java @@ -0,0 +1,66 @@ +/* + * Copyright 2012 Skip Balk. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7179138 + * @summary Incorrect result with String concatenation optimization + * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation Test7179138_2 + * + * @author Skip Balk + */ + +public class Test7179138_2 { + public static void main(String[] args) throws Exception { + System.out.println("Java Version: " + System.getProperty("java.vm.version")); + long[] durations = new long[60]; + for (int i = 0; i < 100000; i++) { + // this empty for-loop is required to reproduce this bug + for (long duration : durations) { + // do nothing + } + { + String s = "test"; + int len = s.length(); + + s = s + s; + len = len + len; + + s = s + s; + len = len + len; + + s = s + s; + len = len + len; + + if (s.length() != len) { + System.out.println("Failed at iteration: " + i); + System.out.println("Length mismatch: " + s.length() + " <> " + len); + System.out.println("Expected: \"" + "test" + "test" + "test" + "test" + "test" + "test" + "test" + "test" + "\""); + System.out.println("Actual: \"" + s + "\""); + System.exit(0); + } + } + } + } +} + From c7ff53f5c1137de26e82da1610a0f9f6929b87d4 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Tue, 26 Jun 2012 09:38:25 -0700 Subject: [PATCH 025/160] 7145771: [macosx] CreateFont/Register.java test fails because of cached results of getAllFonts() Reviewed-by: igor, flar --- .../classes/sun/awt/CGraphicsEnvironment.java | 30 ++++++++----------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/jdk/src/macosx/classes/sun/awt/CGraphicsEnvironment.java b/jdk/src/macosx/classes/sun/awt/CGraphicsEnvironment.java index 15ed911dee7..ab435a93fac 100644 --- a/jdk/src/macosx/classes/sun/awt/CGraphicsEnvironment.java +++ b/jdk/src/macosx/classes/sun/awt/CGraphicsEnvironment.java @@ -200,29 +200,25 @@ public class CGraphicsEnvironment extends SunGraphicsEnvironment { return true; } - private Font[] allFontsWithLogical; static String[] sLogicalFonts = { "Serif", "SansSerif", "Monospaced", "Dialog", "DialogInput" }; @Override public Font[] getAllFonts() { - if (allFontsWithLogical == null) + + Font[] newFonts; + Font[] superFonts = super.getAllFonts(); + + int numLogical = sLogicalFonts.length; + int numOtherFonts = superFonts.length; + + newFonts = new Font[numOtherFonts + numLogical]; + System.arraycopy(superFonts,0,newFonts,numLogical,numOtherFonts); + + for (int i = 0; i < numLogical; i++) { - Font[] newFonts; - Font[] superFonts = super.getAllFonts(); - - int numLogical = sLogicalFonts.length; - int numOtherFonts = superFonts.length; - - newFonts = new Font[numOtherFonts + numLogical]; - System.arraycopy(superFonts,0,newFonts,numLogical,numOtherFonts); - - for (int i = 0; i < numLogical; i++) - { - newFonts[i] = new Font(sLogicalFonts[i], Font.PLAIN, 1); - } - allFontsWithLogical = newFonts; + newFonts[i] = new Font(sLogicalFonts[i], Font.PLAIN, 1); } - return java.util.Arrays.copyOf(allFontsWithLogical, allFontsWithLogical.length); + return newFonts; } } From 514f24864dbb9f4d43671c6113e87f65b324ce65 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Tue, 26 Jun 2012 09:53:27 -0700 Subject: [PATCH 026/160] 7176447: Lunix/Solaris fontpath.c : double free(family) Reviewed-by: igor, flar --- jdk/src/solaris/native/sun/awt/fontpath.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jdk/src/solaris/native/sun/awt/fontpath.c b/jdk/src/solaris/native/sun/awt/fontpath.c index 214ecd0b073..412c6317a1c 100644 --- a/jdk/src/solaris/native/sun/awt/fontpath.c +++ b/jdk/src/solaris/native/sun/awt/fontpath.c @@ -1240,7 +1240,7 @@ Java_sun_font_FontConfigManager_getFontConfig FC_CHARSET, 0, &charset); if (result != FcResultMatch) { free(family); - free(family); + free(fullname); free(styleStr); free(file); (*FcPatternDestroy)(pattern); From 79d14ef96a9875b0df6c632c5c940b82e88b5ed4 Mon Sep 17 00:00:00 2001 From: Phil Race Date: Tue, 26 Jun 2012 09:54:29 -0700 Subject: [PATCH 027/160] 7164282: check for NULL return from malloc is testing wrong variable name Reviewed-by: igor, flar --- jdk/src/windows/native/sun/font/lcdglyph.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jdk/src/windows/native/sun/font/lcdglyph.c b/jdk/src/windows/native/sun/font/lcdglyph.c index f909c4de2f2..4f408d17021 100644 --- a/jdk/src/windows/native/sun/font/lcdglyph.c +++ b/jdk/src/windows/native/sun/font/lcdglyph.c @@ -409,7 +409,7 @@ Java_sun_font_FileFontStrike__1getGlyphImageFromWindows */ imageSize = bytesWidth*height; glyphInfo = (GlyphInfo*)malloc(sizeof(GlyphInfo)+imageSize); - if (malloc == NULL) { + if (glyphInfo == NULL) { FREE_AND_RETURN; } glyphInfo->cellInfo = NULL; From 6b5a5ca0e2569f716958e931b32a2eb2c7ec429e Mon Sep 17 00:00:00 2001 From: Joe Wang Date: Tue, 26 Jun 2012 15:28:21 -0700 Subject: [PATCH 028/160] 7166896: DocumentBuilder.parse(String uri) is not IPv6 enabled. It throws MalformedURLException Skip the added international character handling for general paths Reviewed-by: lancea --- .../xerces/internal/impl/XMLEntityManager.java | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java b/jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java index 7f3295d1479..58c1b34018d 100644 --- a/jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java +++ b/jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java @@ -2609,6 +2609,18 @@ protected static final String PARSER_SETTINGS = if (str == null) { return str; } + int len = str.length(), i=0, ch; + for (; i < len; i++) { + ch = str.charAt(i); + // if it's not an ASCII 7 character, break here, and use UTF-8 encoding + if (ch >= 128) + break; + } + + // we saw no non-ascii-7 character + if (i == len) { + return str; + } // get UTF-8 bytes for the string StringBuffer buffer = new StringBuffer(); @@ -2620,11 +2632,11 @@ protected static final String PARSER_SETTINGS = // should never happen return str; } - int len = bytes.length; - int ch; + + len = bytes.length; // for each byte - for (int i = 0; i < len; i++) { + for (i = 0; i < len; i++) { b = bytes[i]; // for non-ascii character: make it positive, then escape if (b < 0) { From 56df3bd48d9f55242c20ce2e02b4453c9ba81369 Mon Sep 17 00:00:00 2001 From: Jiangli Zhou Date: Tue, 26 Jun 2012 19:08:44 -0400 Subject: [PATCH 029/160] 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table Change constMethodOop::_exception_table to optionally inlined u2 table. Reviewed-by: bdelsart, coleenp, kamg --- .../sun/jvm/hotspot/oops/ConstMethod.java | 67 +++++++-- .../hotspot/oops/ExceptionTableElement.java | 81 ++++++++++ .../sun/jvm/hotspot/oops/GenerateOopMap.java | 42 +++--- .../classes/sun/jvm/hotspot/oops/Method.java | 9 +- .../jvm/hotspot/tools/jcore/ClassWriter.java | 27 ++-- .../ui/classbrowser/HTMLGenerator.java | 60 ++++---- hotspot/src/share/vm/ci/ciMethod.cpp | 15 +- .../share/vm/classfile/classFileParser.cpp | 74 +++++----- .../share/vm/classfile/classFileParser.hpp | 4 +- .../share/vm/classfile/systemDictionary.cpp | 1 - hotspot/src/share/vm/classfile/verifier.cpp | 138 +++++++++--------- .../vm/interpreter/interpreterRuntime.cpp | 3 +- hotspot/src/share/vm/memory/dump.cpp | 3 - hotspot/src/share/vm/memory/oopFactory.cpp | 7 +- hotspot/src/share/vm/memory/oopFactory.hpp | 2 + .../src/share/vm/oops/constMethodKlass.cpp | 37 +++-- .../src/share/vm/oops/constMethodKlass.hpp | 3 +- hotspot/src/share/vm/oops/constMethodOop.cpp | 46 +++++- hotspot/src/share/vm/oops/constMethodOop.hpp | 48 +++--- hotspot/src/share/vm/oops/generateOopMap.cpp | 37 +++-- hotspot/src/share/vm/oops/methodOop.cpp | 27 ++-- hotspot/src/share/vm/oops/methodOop.hpp | 70 ++++++++- hotspot/src/share/vm/prims/jvm.cpp | 13 +- .../vm/prims/jvmtiClassFileReconstituter.cpp | 19 ++- .../share/vm/prims/jvmtiRedefineClasses.cpp | 18 +-- .../src/share/vm/prims/methodHandleWalk.cpp | 7 +- hotspot/src/share/vm/runtime/relocator.cpp | 20 +-- hotspot/src/share/vm/runtime/vmStructs.cpp | 7 +- 28 files changed, 568 insertions(+), 317 deletions(-) create mode 100644 hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ExceptionTableElement.java diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ConstMethod.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ConstMethod.java index d19dc93cfae..241cba1f9bb 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ConstMethod.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ConstMethod.java @@ -47,14 +47,11 @@ public class ConstMethod extends Oop { private static int HAS_LINENUMBER_TABLE; private static int HAS_CHECKED_EXCEPTIONS; private static int HAS_LOCALVARIABLE_TABLE; + private static int HAS_EXCEPTION_TABLE; private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { Type type = db.lookupType("constMethodOopDesc"); constants = new OopField(type.getOopField("_constants"), 0); - // The exception handler table. 4-tuples of ints [start_pc, end_pc, - // handler_pc, catch_type index] For methods with no exceptions the - // table is pointing to Universe::the_empty_int_array - exceptionTable = new OopField(type.getOopField("_exception_table"), 0); constMethodSize = new CIntField(type.getCIntegerField("_constMethod_size"), 0); flags = new ByteField(type.getJByteField("_flags"), 0); @@ -62,6 +59,7 @@ public class ConstMethod extends Oop { HAS_LINENUMBER_TABLE = db.lookupIntConstant("constMethodOopDesc::_has_linenumber_table").intValue(); HAS_CHECKED_EXCEPTIONS = db.lookupIntConstant("constMethodOopDesc::_has_checked_exceptions").intValue(); HAS_LOCALVARIABLE_TABLE = db.lookupIntConstant("constMethodOopDesc::_has_localvariable_table").intValue(); + HAS_EXCEPTION_TABLE = db.lookupIntConstant("constMethodOopDesc::_has_exception_table").intValue(); // Size of Java bytecodes allocated immediately after constMethodOop. codeSize = new CIntField(type.getCIntegerField("_code_size"), 0); @@ -78,6 +76,9 @@ public class ConstMethod extends Oop { type = db.lookupType("LocalVariableTableElement"); localVariableTableElementSize = type.getSize(); + + type = db.lookupType("ExceptionTableElement"); + exceptionTableElementSize = type.getSize(); } ConstMethod(OopHandle handle, ObjectHeap heap) { @@ -86,7 +87,6 @@ public class ConstMethod extends Oop { // Fields private static OopField constants; - private static OopField exceptionTable; private static CIntField constMethodSize; private static ByteField flags; private static CIntField codeSize; @@ -100,6 +100,7 @@ public class ConstMethod extends Oop { private static long checkedExceptionElementSize; private static long localVariableTableElementSize; + private static long exceptionTableElementSize; public Method getMethod() { InstanceKlass ik = (InstanceKlass)getConstants().getPoolHolder(); @@ -112,10 +113,6 @@ public class ConstMethod extends Oop { return (ConstantPool) constants.getValue(this); } - public TypeArray getExceptionTable() { - return (TypeArray) exceptionTable.getValue(this); - } - public long getConstMethodSize() { return constMethodSize.getValue(this); } @@ -235,7 +232,6 @@ public class ConstMethod extends Oop { super.iterateFields(visitor, doVMFields); if (doVMFields) { visitor.doOop(constants, true); - visitor.doOop(exceptionTable, true); visitor.doCInt(constMethodSize, true); visitor.doByte(flags, true); visitor.doCInt(codeSize, true); @@ -326,6 +322,23 @@ public class ConstMethod extends Oop { return ret; } + public boolean hasExceptionTable() { + return (getFlags() & HAS_EXCEPTION_TABLE) != 0; + } + + public ExceptionTableElement[] getExceptionTable() { + if (Assert.ASSERTS_ENABLED) { + Assert.that(hasExceptionTable(), "should only be called if table is present"); + } + ExceptionTableElement[] ret = new ExceptionTableElement[getExceptionTableLength()]; + long offset = offsetOfExceptionTable(); + for (int i = 0; i < ret.length; i++) { + ret[i] = new ExceptionTableElement(getHandle(), offset); + offset += exceptionTableElementSize; + } + return ret; + } + public boolean hasCheckedExceptions() { return (getFlags() & HAS_CHECKED_EXCEPTIONS) != 0; } @@ -415,7 +428,10 @@ public class ConstMethod extends Oop { if (Assert.ASSERTS_ENABLED) { Assert.that(hasLocalVariableTable(), "should only be called if table is present"); } - if (hasCheckedExceptions()) { + + if (hasExceptionTable()) { + return offsetOfExceptionTable() - 2; + } else if (hasCheckedExceptions()) { return offsetOfCheckedExceptions() - 2; } else { return offsetOfLastU2Element(); @@ -432,4 +448,33 @@ public class ConstMethod extends Oop { return offset; } + private int getExceptionTableLength() { + if (hasExceptionTable()) { + return (int) getHandle().getCIntegerAt(offsetOfExceptionTableLength(), 2, true); + } else { + return 0; + } + } + + private long offsetOfExceptionTableLength() { + if (Assert.ASSERTS_ENABLED) { + Assert.that(hasExceptionTable(), "should only be called if table is present"); + } + if (hasCheckedExceptions()) { + return offsetOfCheckedExceptions() - 2; + } else { + return offsetOfLastU2Element(); + } + } + + private long offsetOfExceptionTable() { + long offset = offsetOfExceptionTableLength(); + long length = getExceptionTableLength(); + if (Assert.ASSERTS_ENABLED) { + Assert.that(length > 0, "should only be called if table is present"); + } + offset -= length * exceptionTableElementSize; + return offset; + } + } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ExceptionTableElement.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ExceptionTableElement.java new file mode 100644 index 00000000000..93153708696 --- /dev/null +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ExceptionTableElement.java @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +package sun.jvm.hotspot.oops; + +import java.io.*; +import java.util.*; +import sun.jvm.hotspot.debugger.*; +import sun.jvm.hotspot.interpreter.*; +import sun.jvm.hotspot.runtime.*; +import sun.jvm.hotspot.types.*; +import sun.jvm.hotspot.utilities.*; + +public class ExceptionTableElement { + static { + VM.registerVMInitializedObserver(new Observer() { + public void update(Observable o, Object data) { + initialize(VM.getVM().getTypeDataBase()); + } + }); + } + + private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { + Type type = db.lookupType("ExceptionTableElement"); + offsetOfStartPC = type.getCIntegerField("start_pc").getOffset(); + offsetOfEndPC = type.getCIntegerField("end_pc").getOffset(); + offsetOfHandlerPC = type.getCIntegerField("handler_pc").getOffset(); + offsetOfCatchTypeIndex = type.getCIntegerField("catch_type_index").getOffset(); + } + + private static long offsetOfStartPC; + private static long offsetOfEndPC; + private static long offsetOfHandlerPC; + private static long offsetOfCatchTypeIndex; + + private OopHandle handle; + private long offset; + + public ExceptionTableElement(OopHandle handle, long offset) { + this.handle = handle; + this.offset = offset; + } + + public int getStartPC() { + return (int) handle.getCIntegerAt(offset + offsetOfStartPC, 2, true); + } + + public int getEndPC() { + return (int) handle.getCIntegerAt(offset + offsetOfEndPC, 2, true); + } + + public int getHandlerPC() { + return (int) handle.getCIntegerAt(offset + offsetOfHandlerPC, 2, true); + } + + public int getCatchTypeIndex() { + return (int) handle.getCIntegerAt(offset + offsetOfCatchTypeIndex, 2, true); + } +} + diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/GenerateOopMap.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/GenerateOopMap.java index f25493d6831..581eee80d85 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/GenerateOopMap.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/GenerateOopMap.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -651,10 +651,11 @@ public class GenerateOopMap { boolean fellThrough = false; // False to get first BB marked. // First mark all exception handlers as start of a basic-block - TypeArray excps = method().getExceptionTable(); - for(int i = 0; i < excps.getLength(); i += 4) { - int handler_pc_idx = i+2; - markBB(excps.getIntAt(handler_pc_idx), null); + if (method().hasExceptionTable()) { + ExceptionTableElement[] excps = method().getExceptionTable(); + for(int i = 0; i < excps.length; i++) { + markBB(excps[i].getHandlerPC(), null); + } } // Then iterate through the code @@ -891,14 +892,15 @@ public class GenerateOopMap { // Mark entry basic block as alive and all exception handlers _basic_blocks[0].markAsAlive(); - TypeArray excps = method().getExceptionTable(); - for(int i = 0; i < excps.getLength(); i += 4) { - int handler_pc_idx = i+2; - BasicBlock bb = getBasicBlockAt(excps.getIntAt(handler_pc_idx)); - // If block is not already alive (due to multiple exception handlers to same bb), then - // make it alive - if (bb.isDead()) - bb.markAsAlive(); + if (method().hasExceptionTable()) { + ExceptionTableElement[] excps = method().getExceptionTable(); + for(int i = 0; i < excps.length; i ++) { + BasicBlock bb = getBasicBlockAt(excps[i].getHandlerPC()); + // If block is not already alive (due to multiple exception handlers to same bb), then + // make it alive + if (bb.isDead()) + bb.markAsAlive(); + } } BytecodeStream bcs = new BytecodeStream(_method); @@ -1468,12 +1470,12 @@ public class GenerateOopMap { if (_has_exceptions) { int bci = itr.bci(); - TypeArray exct = method().getExceptionTable(); - for(int i = 0; i< exct.getLength(); i+=4) { - int start_pc = exct.getIntAt(i); - int end_pc = exct.getIntAt(i+1); - int handler_pc = exct.getIntAt(i+2); - int catch_type = exct.getIntAt(i+3); + ExceptionTableElement[] exct = method().getExceptionTable(); + for(int i = 0; i< exct.length; i++) { + int start_pc = exct[i].getStartPC(); + int end_pc = exct[i].getEndPC(); + int handler_pc = exct[i].getHandlerPC(); + int catch_type = exct[i].getCatchTypeIndex(); if (start_pc <= bci && bci < end_pc) { BasicBlock excBB = getBasicBlockAt(handler_pc); @@ -2151,7 +2153,7 @@ public class GenerateOopMap { _conflict = false; _max_locals = (int) method().getMaxLocals(); _max_stack = (int) method().getMaxStack(); - _has_exceptions = (method().getExceptionTable().getLength() > 0); + _has_exceptions = (method().hasExceptionTable()); _nof_refval_conflicts = 0; _init_vars = new ArrayList(5); // There are seldom more than 5 init_vars _report_result = false; diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Method.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Method.java index b691f1537c3..d8b3fade1af 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Method.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Method.java @@ -127,7 +127,6 @@ public class Method extends Oop { return getConstMethod().getConstants(); } public MethodData getMethodData() { return (MethodData) methodData.getValue(this); } - public TypeArray getExceptionTable() { return getConstMethod().getExceptionTable(); } /** WARNING: this is in words, not useful in this system; use getObjectSize() instead */ public long getMethodSize() { return methodSize.getValue(this); } public long getMaxStack() { return maxStack.getValue(this); } @@ -328,6 +327,14 @@ public class Method extends Oop { return null; } + public boolean hasExceptionTable() { + return getConstMethod().hasExceptionTable(); + } + + public ExceptionTableElement[] getExceptionTable() { + return getConstMethod().getExceptionTable(); + } + public boolean hasCheckedExceptions() { return getConstMethod().hasCheckedExceptions(); } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/jcore/ClassWriter.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/jcore/ClassWriter.java index f4e3d7c937e..a71592d930b 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/jcore/ClassWriter.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/jcore/ClassWriter.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -504,11 +504,14 @@ public class ClassWriter implements /* imports */ ClassConstants 2 /* exp. table len. */ + 2 /* code attr. count */; - TypeArray exceptionTable = m.getExceptionTable(); - final int exceptionTableLen = (int) exceptionTable.getLength(); - if (exceptionTableLen != 0) { + boolean hasExceptionTable = m.hasExceptionTable(); + ExceptionTableElement[] exceptionTable = null; + int exceptionTableLen = 0; + if (hasExceptionTable) { + exceptionTable = m.getExceptionTable(); + exceptionTableLen = exceptionTable.length; if (DEBUG) debugMessage("\tmethod has exception table"); - codeSize += (exceptionTableLen / 4) /* exception table is 4-tuple array */ + codeSize += exceptionTableLen /* exception table is 4-tuple array */ * (2 /* start_pc */ + 2 /* end_pc */ + 2 /* handler_pc */ + @@ -586,15 +589,15 @@ public class ClassWriter implements /* imports */ ClassConstants dos.write(code); // write exception table size - dos.writeShort((short) (exceptionTableLen / 4)); - if (DEBUG) debugMessage("\texception table length = " + (exceptionTableLen / 4)); + dos.writeShort((short) exceptionTableLen); + if (DEBUG) debugMessage("\texception table length = " + exceptionTableLen); if (exceptionTableLen != 0) { - for (int e = 0; e < exceptionTableLen; e += 4) { - dos.writeShort((short) exceptionTable.getIntAt(e)); - dos.writeShort((short) exceptionTable.getIntAt(e + 1)); - dos.writeShort((short) exceptionTable.getIntAt(e + 2)); - dos.writeShort((short) exceptionTable.getIntAt(e + 3)); + for (int e = 0; e < exceptionTableLen; e++) { + dos.writeShort((short) exceptionTable[e].getStartPC()); + dos.writeShort((short) exceptionTable[e].getEndPC()); + dos.writeShort((short) exceptionTable[e].getHandlerPC()); + dos.writeShort((short) exceptionTable[e].getCatchTypeIndex()); } } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/ui/classbrowser/HTMLGenerator.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/ui/classbrowser/HTMLGenerator.java index b8d5c8bab7b..2ab2bf6e2a3 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/ui/classbrowser/HTMLGenerator.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/ui/classbrowser/HTMLGenerator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -783,37 +783,39 @@ public class HTMLGenerator implements /* imports */ ClassConstants { }); // display exception table for this method - TypeArray exceptionTable = method.getExceptionTable(); - // exception table is 4 tuple array of shorts - int numEntries = (int)exceptionTable.getLength() / 4; - if (numEntries != 0) { - buf.h4("Exception Table"); - buf.beginTable(1); - buf.beginTag("tr"); - buf.headerCell("start bci"); - buf.headerCell("end bci"); - buf.headerCell("handler bci"); - buf.headerCell("catch type"); - buf.endTag("tr"); - - for (int e = 0; e < numEntries; e += 4) { + boolean hasException = method.hasExceptionTable(); + if (hasException) { + ExceptionTableElement[] exceptionTable = method.getExceptionTable(); + int numEntries = exceptionTable.length; + if (numEntries != 0) { + buf.h4("Exception Table"); + buf.beginTable(1); buf.beginTag("tr"); - buf.cell(Integer.toString(exceptionTable.getIntAt(e))); - buf.cell(Integer.toString(exceptionTable.getIntAt(e + 1))); - buf.cell(Integer.toString(exceptionTable.getIntAt(e + 2))); - short cpIndex = (short) exceptionTable.getIntAt(e + 3); - ConstantPool.CPSlot obj = cpIndex == 0? null : cpool.getSlotAt(cpIndex); - if (obj == null) { - buf.cell("Any"); - } else if (obj.isMetaData()) { - buf.cell(obj.getSymbol().asString().replace('/', '.')); - } else { - buf.cell(genKlassLink((InstanceKlass)obj.getOop())); - } + buf.headerCell("start bci"); + buf.headerCell("end bci"); + buf.headerCell("handler bci"); + buf.headerCell("catch type"); buf.endTag("tr"); - } - buf.endTable(); + for (int e = 0; e < numEntries; e ++) { + buf.beginTag("tr"); + buf.cell(Integer.toString(exceptionTable[e].getStartPC())); + buf.cell(Integer.toString(exceptionTable[e].getEndPC())); + buf.cell(Integer.toString(exceptionTable[e].getHandlerPC())); + short cpIndex = (short) exceptionTable[e].getCatchTypeIndex(); + ConstantPool.CPSlot obj = cpIndex == 0? null : cpool.getSlotAt(cpIndex); + if (obj == null) { + buf.cell("Any"); + } else if (obj.isMetaData()) { + buf.cell(obj.getSymbol().asString().replace('/', '.')); + } else { + buf.cell(genKlassLink((InstanceKlass)obj.getOop())); + } + buf.endTag("tr"); + } + + buf.endTable(); + } } // display constant pool hyperlink diff --git a/hotspot/src/share/vm/ci/ciMethod.cpp b/hotspot/src/share/vm/ci/ciMethod.cpp index 6049d7b9330..180f22f2144 100644 --- a/hotspot/src/share/vm/ci/ciMethod.cpp +++ b/hotspot/src/share/vm/ci/ciMethod.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -79,7 +79,7 @@ ciMethod::ciMethod(methodHandle h_m) : ciObject(h_m) { _max_locals = h_m()->max_locals(); _code_size = h_m()->code_size(); _intrinsic_id = h_m()->intrinsic_id(); - _handler_count = h_m()->exception_table()->length() / 4; + _handler_count = h_m()->exception_table_length(); _uses_monitors = h_m()->access_flags().has_monitor_bytecodes(); _balanced_monitors = !_uses_monitors || h_m()->access_flags().is_monitor_matching(); _is_c1_compilable = !h_m()->is_not_c1_compilable(); @@ -198,7 +198,7 @@ void ciMethod::load_code() { } // And load the exception table. - typeArrayOop exc_table = me->exception_table(); + ExceptionTable exc_table(me); // Allocate one extra spot in our list of exceptions. This // last entry will be used to represent the possibility that @@ -209,13 +209,12 @@ void ciMethod::load_code() { * (_handler_count + 1)); if (_handler_count > 0) { for (int i=0; i<_handler_count; i++) { - int base = i*4; _exception_handlers[i] = new (arena) ciExceptionHandler( holder(), - /* start */ exc_table->int_at(base), - /* limit */ exc_table->int_at(base+1), - /* goto pc */ exc_table->int_at(base+2), - /* cp index */ exc_table->int_at(base+3)); + /* start */ exc_table.start_pc(i), + /* limit */ exc_table.end_pc(i), + /* goto pc */ exc_table.handler_pc(i), + /* cp index */ exc_table.catch_type_index(i)); } } diff --git a/hotspot/src/share/vm/classfile/classFileParser.cpp b/hotspot/src/share/vm/classfile/classFileParser.cpp index b2330e61e37..46129ed381e 100644 --- a/hotspot/src/share/vm/classfile/classFileParser.cpp +++ b/hotspot/src/share/vm/classfile/classFileParser.cpp @@ -1284,42 +1284,38 @@ static void copy_u2_with_conversion(u2* dest, u2* src, int length) { } -typeArrayHandle ClassFileParser::parse_exception_table(u4 code_length, - u4 exception_table_length, - constantPoolHandle cp, - TRAPS) { +u2* ClassFileParser::parse_exception_table(u4 code_length, + u4 exception_table_length, + constantPoolHandle cp, + TRAPS) { ClassFileStream* cfs = stream(); - typeArrayHandle nullHandle; - // 4-tuples of ints [start_pc, end_pc, handler_pc, catch_type index] - typeArrayOop eh = oopFactory::new_permanent_intArray(exception_table_length*4, CHECK_(nullHandle)); - typeArrayHandle exception_handlers = typeArrayHandle(THREAD, eh); - - int index = 0; - cfs->guarantee_more(8 * exception_table_length, CHECK_(nullHandle)); // start_pc, end_pc, handler_pc, catch_type_index - for (unsigned int i = 0; i < exception_table_length; i++) { - u2 start_pc = cfs->get_u2_fast(); - u2 end_pc = cfs->get_u2_fast(); - u2 handler_pc = cfs->get_u2_fast(); - u2 catch_type_index = cfs->get_u2_fast(); - // Will check legal target after parsing code array in verifier. - if (_need_verify) { + u2* exception_table_start = cfs->get_u2_buffer(); + assert(exception_table_start != NULL, "null exception table"); + cfs->guarantee_more(8 * exception_table_length, CHECK_NULL); // start_pc, end_pc, handler_pc, catch_type_index + // Will check legal target after parsing code array in verifier. + if (_need_verify) { + for (unsigned int i = 0; i < exception_table_length; i++) { + u2 start_pc = cfs->get_u2_fast(); + u2 end_pc = cfs->get_u2_fast(); + u2 handler_pc = cfs->get_u2_fast(); + u2 catch_type_index = cfs->get_u2_fast(); guarantee_property((start_pc < end_pc) && (end_pc <= code_length), - "Illegal exception table range in class file %s", CHECK_(nullHandle)); + "Illegal exception table range in class file %s", + CHECK_NULL); guarantee_property(handler_pc < code_length, - "Illegal exception table handler in class file %s", CHECK_(nullHandle)); + "Illegal exception table handler in class file %s", + CHECK_NULL); if (catch_type_index != 0) { guarantee_property(valid_cp_range(catch_type_index, cp->length()) && is_klass_reference(cp, catch_type_index), - "Catch type in exception table has bad constant type in class file %s", CHECK_(nullHandle)); + "Catch type in exception table has bad constant type in class file %s", CHECK_NULL); } } - exception_handlers->int_at_put(index++, start_pc); - exception_handlers->int_at_put(index++, end_pc); - exception_handlers->int_at_put(index++, handler_pc); - exception_handlers->int_at_put(index++, catch_type_index); + } else { + cfs->skip_u2_fast(exception_table_length * 4); } - return exception_handlers; + return exception_table_start; } void ClassFileParser::parse_linenumber_table( @@ -1712,6 +1708,7 @@ methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interf u4 code_length = 0; u1* code_start = 0; u2 exception_table_length = 0; + u2* exception_table_start = NULL; typeArrayHandle exception_handlers(THREAD, Universe::the_empty_int_array()); u2 checked_exceptions_length = 0; u2* checked_exceptions_start = NULL; @@ -1798,7 +1795,7 @@ methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interf cfs->guarantee_more(2, CHECK_(nullHandle)); // exception_table_length exception_table_length = cfs->get_u2_fast(); if (exception_table_length > 0) { - exception_handlers = + exception_table_start = parse_exception_table(code_length, exception_table_length, cp, CHECK_(nullHandle)); } @@ -2002,9 +1999,13 @@ methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interf } // All sizing information for a methodOop is finally available, now create it - methodOop m_oop = oopFactory::new_method(code_length, access_flags, linenumber_table_length, - total_lvt_length, checked_exceptions_length, - oopDesc::IsSafeConc, CHECK_(nullHandle)); + methodOop m_oop = oopFactory::new_method(code_length, access_flags, + linenumber_table_length, + total_lvt_length, + exception_table_length, + checked_exceptions_length, + oopDesc::IsSafeConc, + CHECK_(nullHandle)); methodHandle m (THREAD, m_oop); ClassLoadingService::add_class_method_size(m_oop->size()*HeapWordSize); @@ -2035,16 +2036,15 @@ methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interf // Fill in code attribute information m->set_max_stack(max_stack); m->set_max_locals(max_locals); - m->constMethod()->set_stackmap_data(stackmap_data()); /** - * The exception_table field is the flag used to indicate + * The stackmap_data field is the flag used to indicate * that the methodOop and it's associated constMethodOop are partially * initialized and thus are exempt from pre/post GC verification. Once * the field is set, the oops are considered fully initialized so make * sure that the oops can pass verification when this field is set. */ - m->set_exception_table(exception_handlers()); + m->constMethod()->set_stackmap_data(stackmap_data()); // Copy byte codes m->set_code(code_start); @@ -2055,6 +2055,14 @@ methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interf linenumber_table->buffer(), linenumber_table_length); } + // Copy exception table + if (exception_table_length > 0) { + int size = + exception_table_length * sizeof(ExceptionTableElement) / sizeof(u2); + copy_u2_with_conversion((u2*) m->exception_table_start(), + exception_table_start, size); + } + // Copy checked exceptions if (checked_exceptions_length > 0) { int size = checked_exceptions_length * sizeof(CheckedExceptionElement) / sizeof(u2); diff --git a/hotspot/src/share/vm/classfile/classFileParser.hpp b/hotspot/src/share/vm/classfile/classFileParser.hpp index de781b2fb1f..008902eac47 100644 --- a/hotspot/src/share/vm/classfile/classFileParser.hpp +++ b/hotspot/src/share/vm/classfile/classFileParser.hpp @@ -113,8 +113,8 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC { objArrayHandle methods_parameter_annotations, objArrayHandle methods_default_annotations, TRAPS); - typeArrayHandle parse_exception_table(u4 code_length, u4 exception_table_length, - constantPoolHandle cp, TRAPS); + u2* parse_exception_table(u4 code_length, u4 exception_table_length, + constantPoolHandle cp, TRAPS); void parse_linenumber_table( u4 code_attribute_length, u4 code_length, CompressedLineNumberWriteStream** write_stream, TRAPS); diff --git a/hotspot/src/share/vm/classfile/systemDictionary.cpp b/hotspot/src/share/vm/classfile/systemDictionary.cpp index 78c854f3058..3b3a494ceb6 100644 --- a/hotspot/src/share/vm/classfile/systemDictionary.cpp +++ b/hotspot/src/share/vm/classfile/systemDictionary.cpp @@ -2771,7 +2771,6 @@ class ClassStatistics: AllStatic { nmethods++; method_size += m->size(); // class loader uses same objArray for empty vectors, so don't count these - if (m->exception_table()->length() != 0) method_size += m->exception_table()->size(); if (m->has_stackmap_table()) { method_size += m->stackmap_data()->size(); } diff --git a/hotspot/src/share/vm/classfile/verifier.cpp b/hotspot/src/share/vm/classfile/verifier.cpp index 7b5932a5401..2490049e9f2 100644 --- a/hotspot/src/share/vm/classfile/verifier.cpp +++ b/hotspot/src/share/vm/classfile/verifier.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -1368,47 +1368,48 @@ char* ClassVerifier::generate_code_data(methodHandle m, u4 code_length, TRAPS) { } void ClassVerifier::verify_exception_handler_table(u4 code_length, char* code_data, int& min, int& max, TRAPS) { - typeArrayHandle exhandlers (THREAD, _method->exception_table()); + ExceptionTable exhandlers(_method()); + int exlength = exhandlers.length(); constantPoolHandle cp (THREAD, _method->constants()); - if (exhandlers() != NULL) { - for(int i = 0; i < exhandlers->length();) { - u2 start_pc = exhandlers->int_at(i++); - u2 end_pc = exhandlers->int_at(i++); - u2 handler_pc = exhandlers->int_at(i++); - if (start_pc >= code_length || code_data[start_pc] == 0) { - class_format_error("Illegal exception table start_pc %d", start_pc); - return; - } - if (end_pc != code_length) { // special case: end_pc == code_length - if (end_pc > code_length || code_data[end_pc] == 0) { - class_format_error("Illegal exception table end_pc %d", end_pc); - return; - } - } - if (handler_pc >= code_length || code_data[handler_pc] == 0) { - class_format_error("Illegal exception table handler_pc %d", handler_pc); - return; - } - int catch_type_index = exhandlers->int_at(i++); - if (catch_type_index != 0) { - VerificationType catch_type = cp_index_to_type( - catch_type_index, cp, CHECK_VERIFY(this)); - VerificationType throwable = - VerificationType::reference_type(vmSymbols::java_lang_Throwable()); - bool is_subclass = throwable.is_assignable_from( - catch_type, this, CHECK_VERIFY(this)); - if (!is_subclass) { - // 4286534: should throw VerifyError according to recent spec change - verify_error( - "Catch type is not a subclass of Throwable in handler %d", - handler_pc); - return; - } - } - if (start_pc < min) min = start_pc; - if (end_pc > max) max = end_pc; + for(int i = 0; i < exlength; i++) { + //reacquire the table in case a GC happened + ExceptionTable exhandlers(_method()); + u2 start_pc = exhandlers.start_pc(i); + u2 end_pc = exhandlers.end_pc(i); + u2 handler_pc = exhandlers.handler_pc(i); + if (start_pc >= code_length || code_data[start_pc] == 0) { + class_format_error("Illegal exception table start_pc %d", start_pc); + return; } + if (end_pc != code_length) { // special case: end_pc == code_length + if (end_pc > code_length || code_data[end_pc] == 0) { + class_format_error("Illegal exception table end_pc %d", end_pc); + return; + } + } + if (handler_pc >= code_length || code_data[handler_pc] == 0) { + class_format_error("Illegal exception table handler_pc %d", handler_pc); + return; + } + int catch_type_index = exhandlers.catch_type_index(i); + if (catch_type_index != 0) { + VerificationType catch_type = cp_index_to_type( + catch_type_index, cp, CHECK_VERIFY(this)); + VerificationType throwable = + VerificationType::reference_type(vmSymbols::java_lang_Throwable()); + bool is_subclass = throwable.is_assignable_from( + catch_type, this, CHECK_VERIFY(this)); + if (!is_subclass) { + // 4286534: should throw VerifyError according to recent spec change + verify_error( + "Catch type is not a subclass of Throwable in handler %d", + handler_pc); + return; + } + } + if (start_pc < min) min = start_pc; + if (end_pc > max) max = end_pc; } } @@ -1474,35 +1475,36 @@ u2 ClassVerifier::verify_stackmap_table(u2 stackmap_index, u2 bci, void ClassVerifier::verify_exception_handler_targets(u2 bci, bool this_uninit, StackMapFrame* current_frame, StackMapTable* stackmap_table, TRAPS) { constantPoolHandle cp (THREAD, _method->constants()); - typeArrayHandle exhandlers (THREAD, _method->exception_table()); - if (exhandlers() != NULL) { - for(int i = 0; i < exhandlers->length();) { - u2 start_pc = exhandlers->int_at(i++); - u2 end_pc = exhandlers->int_at(i++); - u2 handler_pc = exhandlers->int_at(i++); - int catch_type_index = exhandlers->int_at(i++); - if(bci >= start_pc && bci < end_pc) { - u1 flags = current_frame->flags(); - if (this_uninit) { flags |= FLAG_THIS_UNINIT; } - StackMapFrame* new_frame = current_frame->frame_in_exception_handler(flags); - if (catch_type_index != 0) { - // We know that this index refers to a subclass of Throwable - VerificationType catch_type = cp_index_to_type( - catch_type_index, cp, CHECK_VERIFY(this)); - new_frame->push_stack(catch_type, CHECK_VERIFY(this)); - } else { - VerificationType throwable = - VerificationType::reference_type(vmSymbols::java_lang_Throwable()); - new_frame->push_stack(throwable, CHECK_VERIFY(this)); - } - bool match = stackmap_table->match_stackmap( - new_frame, handler_pc, true, false, CHECK_VERIFY(this)); - if (!match) { - verify_error(bci, - "Stack map does not match the one at exception handler %d", - handler_pc); - return; - } + ExceptionTable exhandlers(_method()); + int exlength = exhandlers.length(); + for(int i = 0; i < exlength; i++) { + //reacquire the table in case a GC happened + ExceptionTable exhandlers(_method()); + u2 start_pc = exhandlers.start_pc(i); + u2 end_pc = exhandlers.end_pc(i); + u2 handler_pc = exhandlers.handler_pc(i); + int catch_type_index = exhandlers.catch_type_index(i); + if(bci >= start_pc && bci < end_pc) { + u1 flags = current_frame->flags(); + if (this_uninit) { flags |= FLAG_THIS_UNINIT; } + StackMapFrame* new_frame = current_frame->frame_in_exception_handler(flags); + if (catch_type_index != 0) { + // We know that this index refers to a subclass of Throwable + VerificationType catch_type = cp_index_to_type( + catch_type_index, cp, CHECK_VERIFY(this)); + new_frame->push_stack(catch_type, CHECK_VERIFY(this)); + } else { + VerificationType throwable = + VerificationType::reference_type(vmSymbols::java_lang_Throwable()); + new_frame->push_stack(throwable, CHECK_VERIFY(this)); + } + bool match = stackmap_table->match_stackmap( + new_frame, handler_pc, true, false, CHECK_VERIFY(this)); + if (!match) { + verify_error(bci, + "Stack map does not match the one at exception handler %d", + handler_pc); + return; } } } diff --git a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp index 6f5511f9fcc..0e790457e43 100644 --- a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp +++ b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -375,7 +375,6 @@ IRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThrea Handle h_exception(thread, exception); methodHandle h_method (thread, method(thread)); constantPoolHandle h_constants(thread, h_method->constants()); - typeArrayHandle h_extable (thread, h_method->exception_table()); bool should_repeat; int handler_bci; int current_bci = bci(thread); diff --git a/hotspot/src/share/vm/memory/dump.cpp b/hotspot/src/share/vm/memory/dump.cpp index e91d33135e4..3e357365ceb 100644 --- a/hotspot/src/share/vm/memory/dump.cpp +++ b/hotspot/src/share/vm/memory/dump.cpp @@ -231,8 +231,6 @@ public: if (obj->is_constMethod()) { mark_object(obj); mark_object(constMethodOop(obj)->stackmap_data()); - // Exception tables are needed by ci code during compilation. - mark_object(constMethodOop(obj)->exception_table()); } // Mark objects referenced by klass objects which are read-only. @@ -513,7 +511,6 @@ public: for(i = 0; i < methods->length(); i++) { methodOop m = methodOop(methods->obj_at(i)); mark_and_move_for_policy(OP_favor_startup, m->constMethod(), _move_ro); - mark_and_move_for_policy(OP_favor_runtime, m->constMethod()->exception_table(), _move_ro); mark_and_move_for_policy(OP_favor_runtime, m->constMethod()->stackmap_data(), _move_ro); } diff --git a/hotspot/src/share/vm/memory/oopFactory.cpp b/hotspot/src/share/vm/memory/oopFactory.cpp index 0dd620650e1..def88ccf14d 100644 --- a/hotspot/src/share/vm/memory/oopFactory.cpp +++ b/hotspot/src/share/vm/memory/oopFactory.cpp @@ -140,14 +140,15 @@ klassOop oopFactory::new_instanceKlass(Symbol* name, int vtable_len, int itable_ constMethodOop oopFactory::new_constMethod(int byte_code_size, int compressed_line_number_size, int localvariable_table_length, + int exception_table_length, int checked_exceptions_length, bool is_conc_safe, TRAPS) { klassOop cmkObj = Universe::constMethodKlassObj(); constMethodKlass* cmk = constMethodKlass::cast(cmkObj); return cmk->allocate(byte_code_size, compressed_line_number_size, - localvariable_table_length, checked_exceptions_length, - is_conc_safe, + localvariable_table_length, exception_table_length, + checked_exceptions_length, is_conc_safe, CHECK_NULL); } @@ -155,6 +156,7 @@ constMethodOop oopFactory::new_constMethod(int byte_code_size, methodOop oopFactory::new_method(int byte_code_size, AccessFlags access_flags, int compressed_line_number_size, int localvariable_table_length, + int exception_table_length, int checked_exceptions_length, bool is_conc_safe, TRAPS) { @@ -164,6 +166,7 @@ methodOop oopFactory::new_method(int byte_code_size, AccessFlags access_flags, constMethodOop cm = new_constMethod(byte_code_size, compressed_line_number_size, localvariable_table_length, + exception_table_length, checked_exceptions_length, is_conc_safe, CHECK_NULL); constMethodHandle rw(THREAD, cm); diff --git a/hotspot/src/share/vm/memory/oopFactory.hpp b/hotspot/src/share/vm/memory/oopFactory.hpp index 38de1a4f2c2..5fd843ee83d 100644 --- a/hotspot/src/share/vm/memory/oopFactory.hpp +++ b/hotspot/src/share/vm/memory/oopFactory.hpp @@ -86,6 +86,7 @@ private: static constMethodOop new_constMethod(int byte_code_size, int compressed_line_number_size, int localvariable_table_length, + int exception_table_length, int checked_exceptions_length, bool is_conc_safe, TRAPS); @@ -97,6 +98,7 @@ public: AccessFlags access_flags, int compressed_line_number_size, int localvariable_table_length, + int exception_table_length, int checked_exceptions_length, bool is_conc_safe, TRAPS); diff --git a/hotspot/src/share/vm/oops/constMethodKlass.cpp b/hotspot/src/share/vm/oops/constMethodKlass.cpp index b66df9505fd..e74811f54b0 100644 --- a/hotspot/src/share/vm/oops/constMethodKlass.cpp +++ b/hotspot/src/share/vm/oops/constMethodKlass.cpp @@ -65,6 +65,7 @@ bool constMethodKlass::oop_is_conc_safe(oop obj) const { constMethodOop constMethodKlass::allocate(int byte_code_size, int compressed_line_number_size, int localvariable_table_length, + int exception_table_length, int checked_exceptions_length, bool is_conc_safe, TRAPS) { @@ -72,6 +73,7 @@ constMethodOop constMethodKlass::allocate(int byte_code_size, int size = constMethodOopDesc::object_size(byte_code_size, compressed_line_number_size, localvariable_table_length, + exception_table_length, checked_exceptions_length); KlassHandle h_k(THREAD, as_klassOop()); constMethodOop cm = (constMethodOop) @@ -82,12 +84,12 @@ constMethodOop constMethodKlass::allocate(int byte_code_size, cm->init_fingerprint(); cm->set_constants(NULL); cm->set_stackmap_data(NULL); - cm->set_exception_table(NULL); cm->set_code_size(byte_code_size); cm->set_constMethod_size(size); cm->set_inlined_tables_length(checked_exceptions_length, compressed_line_number_size, - localvariable_table_length); + localvariable_table_length, + exception_table_length); assert(cm->size() == size, "wrong size for object"); cm->set_is_conc_safe(is_conc_safe); cm->set_partially_loaded(); @@ -100,7 +102,6 @@ void constMethodKlass::oop_follow_contents(oop obj) { constMethodOop cm = constMethodOop(obj); MarkSweep::mark_and_push(cm->adr_constants()); MarkSweep::mark_and_push(cm->adr_stackmap_data()); - MarkSweep::mark_and_push(cm->adr_exception_table()); // Performance tweak: We skip iterating over the klass pointer since we // know that Universe::constMethodKlassObj never moves. } @@ -112,7 +113,6 @@ void constMethodKlass::oop_follow_contents(ParCompactionManager* cm, constMethodOop cm_oop = constMethodOop(obj); PSParallelCompact::mark_and_push(cm, cm_oop->adr_constants()); PSParallelCompact::mark_and_push(cm, cm_oop->adr_stackmap_data()); - PSParallelCompact::mark_and_push(cm, cm_oop->adr_exception_table()); // Performance tweak: We skip iterating over the klass pointer since we // know that Universe::constMethodKlassObj never moves. } @@ -123,7 +123,6 @@ int constMethodKlass::oop_oop_iterate(oop obj, OopClosure* blk) { constMethodOop cm = constMethodOop(obj); blk->do_oop(cm->adr_constants()); blk->do_oop(cm->adr_stackmap_data()); - blk->do_oop(cm->adr_exception_table()); // Get size before changing pointers. // Don't call size() or oop_size() since that is a virtual call. int size = cm->object_size(); @@ -139,8 +138,6 @@ int constMethodKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) if (mr.contains(adr)) blk->do_oop(adr); adr = cm->adr_stackmap_data(); if (mr.contains(adr)) blk->do_oop(adr); - adr = cm->adr_exception_table(); - if (mr.contains(adr)) blk->do_oop(adr); // Get size before changing pointers. // Don't call size() or oop_size() since that is a virtual call. int size = cm->object_size(); @@ -155,7 +152,6 @@ int constMethodKlass::oop_adjust_pointers(oop obj) { constMethodOop cm = constMethodOop(obj); MarkSweep::adjust_pointer(cm->adr_constants()); MarkSweep::adjust_pointer(cm->adr_stackmap_data()); - MarkSweep::adjust_pointer(cm->adr_exception_table()); // Get size before changing pointers. // Don't call size() or oop_size() since that is a virtual call. int size = cm->object_size(); @@ -190,7 +186,6 @@ void constMethodKlass::oop_print_on(oop obj, outputStream* st) { constMethodOop m = constMethodOop(obj); st->print(" - constants: " INTPTR_FORMAT " ", (address)m->constants()); m->constants()->print_value_on(st); st->cr(); - st->print(" - exceptions: " INTPTR_FORMAT "\n", (address)m->exception_table()); if (m->has_stackmap_table()) { st->print(" - stackmap data: "); m->stackmap_data()->print_value_on(st); @@ -228,8 +223,6 @@ void constMethodKlass::oop_verify_on(oop obj, outputStream* st) { typeArrayOop stackmap_data = m->stackmap_data(); guarantee(stackmap_data == NULL || stackmap_data->is_perm(), "should be in permspace"); - guarantee(m->exception_table()->is_perm(), "should be in permspace"); - guarantee(m->exception_table()->is_typeArray(), "should be type array"); address m_end = (address)((oop*) m + m->size()); address compressed_table_start = m->code_end(); @@ -244,11 +237,15 @@ void constMethodKlass::oop_verify_on(oop obj, outputStream* st) { compressed_table_end += stream.position(); } guarantee(compressed_table_end <= m_end, "invalid method layout"); - // Verify checked exceptions and local variable tables + // Verify checked exceptions, exception table and local variable tables if (m->has_checked_exceptions()) { u2* addr = m->checked_exceptions_length_addr(); guarantee(*addr > 0 && (address) addr >= compressed_table_end && (address) addr < m_end, "invalid method layout"); } + if (m->has_exception_handler()) { + u2* addr = m->exception_table_length_addr(); + guarantee(*addr > 0 && (address) addr >= compressed_table_end && (address) addr < m_end, "invalid method layout"); + } if (m->has_localvariable_table()) { u2* addr = m->localvariable_table_length_addr(); guarantee(*addr > 0 && (address) addr >= compressed_table_end && (address) addr < m_end, "invalid method layout"); @@ -257,12 +254,12 @@ void constMethodKlass::oop_verify_on(oop obj, outputStream* st) { u2* uncompressed_table_start; if (m->has_localvariable_table()) { uncompressed_table_start = (u2*) m->localvariable_table_start(); - } else { - if (m->has_checked_exceptions()) { + } else if (m->has_exception_handler()) { + uncompressed_table_start = (u2*) m->exception_table_start(); + } else if (m->has_checked_exceptions()) { uncompressed_table_start = (u2*) m->checked_exceptions_start(); - } else { + } else { uncompressed_table_start = (u2*) m_end; - } } int gap = (intptr_t) uncompressed_table_start - (intptr_t) compressed_table_end; int max_gap = align_object_size(1)*BytesPerWord; @@ -273,8 +270,8 @@ void constMethodKlass::oop_verify_on(oop obj, outputStream* st) { bool constMethodKlass::oop_partially_loaded(oop obj) const { assert(obj->is_constMethod(), "object must be klass"); constMethodOop m = constMethodOop(obj); - // check whether exception_table points to self (flag for partially loaded) - return m->exception_table() == (typeArrayOop)obj; + // check whether stackmap_data points to self (flag for partially loaded) + return m->stackmap_data() == (typeArrayOop)obj; } @@ -282,6 +279,6 @@ bool constMethodKlass::oop_partially_loaded(oop obj) const { void constMethodKlass::oop_set_partially_loaded(oop obj) { assert(obj->is_constMethod(), "object must be klass"); constMethodOop m = constMethodOop(obj); - // Temporarily set exception_table to point to self - m->set_exception_table((typeArrayOop)obj); + // Temporarily set stackmap_data to point to self + m->set_stackmap_data((typeArrayOop)obj); } diff --git a/hotspot/src/share/vm/oops/constMethodKlass.hpp b/hotspot/src/share/vm/oops/constMethodKlass.hpp index 1c3e3c83b83..23ba1122782 100644 --- a/hotspot/src/share/vm/oops/constMethodKlass.hpp +++ b/hotspot/src/share/vm/oops/constMethodKlass.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -46,6 +46,7 @@ public: DEFINE_ALLOCATE_PERMANENT(constMethodKlass); constMethodOop allocate(int byte_code_size, int compressed_line_number_size, int localvariable_table_length, + int exception_table_length, int checked_exceptions_length, bool is_conc_safe, TRAPS); diff --git a/hotspot/src/share/vm/oops/constMethodOop.cpp b/hotspot/src/share/vm/oops/constMethodOop.cpp index cc8dfd5011b..cb9256da662 100644 --- a/hotspot/src/share/vm/oops/constMethodOop.cpp +++ b/hotspot/src/share/vm/oops/constMethodOop.cpp @@ -35,6 +35,7 @@ const u2 constMethodOopDesc::UNSET_IDNUM = 0xFFFF; int constMethodOopDesc::object_size(int code_size, int compressed_line_number_size, int local_variable_table_length, + int exception_table_length, int checked_exceptions_length) { int extra_bytes = code_size; if (compressed_line_number_size > 0) { @@ -49,6 +50,10 @@ int constMethodOopDesc::object_size(int code_size, extra_bytes += local_variable_table_length * sizeof(LocalVariableTableElement); } + if (exception_table_length > 0) { + extra_bytes += sizeof(u2); + extra_bytes += exception_table_length * sizeof(ExceptionTableElement); + } int extra_words = align_size_up(extra_bytes, BytesPerWord) / BytesPerWord; return align_object_size(header_size() + extra_words); } @@ -73,23 +78,40 @@ u2* constMethodOopDesc::checked_exceptions_length_addr() const { return last_u2_element(); } -u2* constMethodOopDesc::localvariable_table_length_addr() const { - assert(has_localvariable_table(), "called only if table is present"); +u2* constMethodOopDesc::exception_table_length_addr() const { + assert(has_exception_handler(), "called only if table is present"); if (has_checked_exceptions()) { // If checked_exception present, locate immediately before them. return (u2*) checked_exceptions_start() - 1; } else { - // Else, the linenumber table is at the end of the constMethod. + // Else, the exception table is at the end of the constMethod. return last_u2_element(); } } +u2* constMethodOopDesc::localvariable_table_length_addr() const { + assert(has_localvariable_table(), "called only if table is present"); + if (has_exception_handler()) { + // If exception_table present, locate immediately before them. + return (u2*) exception_table_start() - 1; + } else { + if (has_checked_exceptions()) { + // If checked_exception present, locate immediately before them. + return (u2*) checked_exceptions_start() - 1; + } else { + // Else, the linenumber table is at the end of the constMethod. + return last_u2_element(); + } + } +} + // Update the flags to indicate the presence of these optional fields. void constMethodOopDesc::set_inlined_tables_length( int checked_exceptions_len, int compressed_line_number_size, - int localvariable_table_len) { + int localvariable_table_len, + int exception_table_len) { // Must be done in the order below, otherwise length_addr accessors // will not work. Only set bit in header if length is positive. assert(_flags == 0, "Error"); @@ -100,6 +122,10 @@ void constMethodOopDesc::set_inlined_tables_length( _flags |= _has_checked_exceptions; *(checked_exceptions_length_addr()) = checked_exceptions_len; } + if (exception_table_len > 0) { + _flags |= _has_exception_table; + *(exception_table_length_addr()) = exception_table_len; + } if (localvariable_table_len > 0) { _flags |= _has_localvariable_table; *(localvariable_table_length_addr()) = localvariable_table_len; @@ -133,3 +159,15 @@ LocalVariableTableElement* constMethodOopDesc::localvariable_table_start() const addr -= length * sizeof(LocalVariableTableElement) / sizeof(u2); return (LocalVariableTableElement*) addr; } + +int constMethodOopDesc::exception_table_length() const { + return has_exception_handler() ? *(exception_table_length_addr()) : 0; +} + +ExceptionTableElement* constMethodOopDesc::exception_table_start() const { + u2* addr = exception_table_length_addr(); + u2 length = *addr; + assert(length > 0, "should only be called if table is present"); + addr -= length * sizeof(ExceptionTableElement) / sizeof(u2); + return (ExceptionTableElement*)addr; +} diff --git a/hotspot/src/share/vm/oops/constMethodOop.hpp b/hotspot/src/share/vm/oops/constMethodOop.hpp index 10344ec6db7..549192be7a9 100644 --- a/hotspot/src/share/vm/oops/constMethodOop.hpp +++ b/hotspot/src/share/vm/oops/constMethodOop.hpp @@ -43,7 +43,6 @@ // | fingerprint 2 | // | constants (oop) | // | stackmap_data (oop) | -// | exception_table (oop) | // | constMethod_size | // | interp_kind | flags | code_size | // | name index | signature index | @@ -64,7 +63,13 @@ // | (length is u2, elements are 6-tuples of u2) | // | (see class LocalVariableTableElement) | // | (access flags bit tells whether table is present) | -// | (indexed from end of contMethodOop) | +// | (indexed from end of constMethodOop) | +// |------------------------------------------------------| +// | exception table + length (length last) | +// | (length is u2, elements are 4-tuples of u2) | +// | (see class ExceptionTableElement) | +// | (access flags bit tells whether table is present) | +// | (indexed from end of constMethodOop) | // |------------------------------------------------------| // | checked exceptions elements + length (length last) | // | (length is u2, elements are u2) | @@ -93,6 +98,15 @@ class LocalVariableTableElement VALUE_OBJ_CLASS_SPEC { }; +// Utitily class describing elements in exception table +class ExceptionTableElement VALUE_OBJ_CLASS_SPEC { + public: + u2 start_pc; + u2 end_pc; + u2 handler_pc; + u2 catch_type_index; +}; + class constMethodOopDesc : public oopDesc { friend class constMethodKlass; friend class VMStructs; @@ -100,7 +114,8 @@ private: enum { _has_linenumber_table = 1, _has_checked_exceptions = 2, - _has_localvariable_table = 4 + _has_localvariable_table = 4, + _has_exception_table = 8 }; // Bit vector of signature @@ -114,7 +129,7 @@ private: public: oop* oop_block_beg() const { return adr_constants(); } - oop* oop_block_end() const { return adr_exception_table() + 1; } + oop* oop_block_end() const { return adr_stackmap_data() + 1; } private: // @@ -126,11 +141,6 @@ private: // Raw stackmap data for the method typeArrayOop _stackmap_data; - // The exception handler table. 4-tuples of ints [start_pc, end_pc, - // handler_pc, catch_type index] For methods with no exceptions the - // table is pointing to Universe::the_empty_int_array - typeArrayOop _exception_table; - // // End of the oop block. // @@ -152,7 +162,8 @@ public: // Inlined tables void set_inlined_tables_length(int checked_exceptions_len, int compressed_line_number_size, - int localvariable_table_len); + int localvariable_table_len, + int exception_table_len); bool has_linenumber_table() const { return (_flags & _has_linenumber_table) != 0; } @@ -163,6 +174,9 @@ public: bool has_localvariable_table() const { return (_flags & _has_localvariable_table) != 0; } + bool has_exception_handler() const + { return (_flags & _has_exception_table) != 0; } + void set_interpreter_kind(int kind) { _interpreter_kind = kind; } int interpreter_kind(void) const { return _interpreter_kind; } @@ -181,11 +195,6 @@ public: } bool has_stackmap_table() const { return _stackmap_data != NULL; } - // exception handler table - typeArrayOop exception_table() const { return _exception_table; } - void set_exception_table(typeArrayOop e) { oop_store_without_check((oop*) &_exception_table, (oop) e); } - bool has_exception_handler() const { return exception_table() != NULL && exception_table()->length() > 0; } - void init_fingerprint() { const uint64_t initval = CONST64(0x8000000000000000); _fingerprint = initval; @@ -235,6 +244,7 @@ public: // Object size needed static int object_size(int code_size, int compressed_line_number_size, int local_variable_table_length, + int exception_table_length, int checked_exceptions_length); int object_size() const { return _constMethod_size; } @@ -256,6 +266,7 @@ public: u_char* compressed_linenumber_table() const; // not preserved by gc u2* checked_exceptions_length_addr() const; u2* localvariable_table_length_addr() const; + u2* exception_table_length_addr() const; // checked exceptions int checked_exceptions_length() const; @@ -265,6 +276,10 @@ public: int localvariable_table_length() const; LocalVariableTableElement* localvariable_table_start() const; + // exception table + int exception_table_length() const; + ExceptionTableElement* exception_table_start() const; + // byte codes void set_code(address code) { if (code_size() > 0) { @@ -282,13 +297,10 @@ public: // interpreter support static ByteSize constants_offset() { return byte_offset_of(constMethodOopDesc, _constants); } - static ByteSize exception_table_offset() - { return byte_offset_of(constMethodOopDesc, _exception_table); } // Garbage collection support oop* adr_constants() const { return (oop*)&_constants; } oop* adr_stackmap_data() const { return (oop*)&_stackmap_data; } - oop* adr_exception_table() const { return (oop*)&_exception_table; } bool is_conc_safe() { return _is_conc_safe; } void set_is_conc_safe(bool v) { _is_conc_safe = v; } diff --git a/hotspot/src/share/vm/oops/generateOopMap.cpp b/hotspot/src/share/vm/oops/generateOopMap.cpp index 58ef931527f..3a818aad4db 100644 --- a/hotspot/src/share/vm/oops/generateOopMap.cpp +++ b/hotspot/src/share/vm/oops/generateOopMap.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -400,10 +400,9 @@ void GenerateOopMap::mark_bbheaders_and_count_gc_points() { bool fellThrough = false; // False to get first BB marked. // First mark all exception handlers as start of a basic-block - typeArrayOop excps = method()->exception_table(); - for(int i = 0; i < excps->length(); i += 4) { - int handler_pc_idx = i+2; - bb_mark_fct(this, excps->int_at(handler_pc_idx), NULL); + ExceptionTable excps(method()); + for(int i = 0; i < excps.length(); i ++) { + bb_mark_fct(this, excps.handler_pc(i), NULL); } // Then iterate through the code @@ -450,10 +449,9 @@ void GenerateOopMap::mark_reachable_code() { // Mark entry basic block as alive and all exception handlers _basic_blocks[0].mark_as_alive(); - typeArrayOop excps = method()->exception_table(); - for(int i = 0; i < excps->length(); i += 4) { - int handler_pc_idx = i+2; - BasicBlock *bb = get_basic_block_at(excps->int_at(handler_pc_idx)); + ExceptionTable excps(method()); + for(int i = 0; i < excps.length(); i++) { + BasicBlock *bb = get_basic_block_at(excps.handler_pc(i)); // If block is not already alive (due to multiple exception handlers to same bb), then // make it alive if (bb->is_dead()) bb->mark_as_alive(); @@ -1181,12 +1179,12 @@ void GenerateOopMap::do_exception_edge(BytecodeStream* itr) { if (_has_exceptions) { int bci = itr->bci(); - typeArrayOop exct = method()->exception_table(); - for(int i = 0; i< exct->length(); i+=4) { - int start_pc = exct->int_at(i); - int end_pc = exct->int_at(i+1); - int handler_pc = exct->int_at(i+2); - int catch_type = exct->int_at(i+3); + ExceptionTable exct(method()); + for(int i = 0; i< exct.length(); i++) { + int start_pc = exct.start_pc(i); + int end_pc = exct.end_pc(i); + int handler_pc = exct.handler_pc(i); + int catch_type = exct.catch_type_index(i); if (start_pc <= bci && bci < end_pc) { BasicBlock *excBB = get_basic_block_at(handler_pc); @@ -2055,7 +2053,7 @@ void GenerateOopMap::compute_map(TRAPS) { _conflict = false; _max_locals = method()->max_locals(); _max_stack = method()->max_stack(); - _has_exceptions = (method()->exception_table()->length() > 0); + _has_exceptions = (method()->has_exception_handler()); _nof_refval_conflicts = 0; _init_vars = new GrowableArray(5); // There are seldom more than 5 init_vars _report_result = false; @@ -2070,9 +2068,10 @@ void GenerateOopMap::compute_map(TRAPS) { if (Verbose) { _method->print_codes(); tty->print_cr("Exception table:"); - typeArrayOop excps = method()->exception_table(); - for(int i = 0; i < excps->length(); i += 4) { - tty->print_cr("[%d - %d] -> %d", excps->int_at(i + 0), excps->int_at(i + 1), excps->int_at(i + 2)); + ExceptionTable excps(method()); + for(int i = 0; i < excps.length(); i ++) { + tty->print_cr("[%d - %d] -> %d", + excps.start_pc(i), excps.end_pc(i), excps.handler_pc(i)); } } } diff --git a/hotspot/src/share/vm/oops/methodOop.cpp b/hotspot/src/share/vm/oops/methodOop.cpp index 7a0e74e0fe3..66c545a6c9b 100644 --- a/hotspot/src/share/vm/oops/methodOop.cpp +++ b/hotspot/src/share/vm/oops/methodOop.cpp @@ -111,25 +111,21 @@ char* methodOopDesc::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, int methodOopDesc::fast_exception_handler_bci_for(KlassHandle ex_klass, int throw_bci, TRAPS) { // exception table holds quadruple entries of the form (beg_bci, end_bci, handler_bci, klass_index) - const int beg_bci_offset = 0; - const int end_bci_offset = 1; - const int handler_bci_offset = 2; - const int klass_index_offset = 3; - const int entry_size = 4; // access exception table - typeArrayHandle table (THREAD, constMethod()->exception_table()); - int length = table->length(); - assert(length % entry_size == 0, "exception table format has changed"); + ExceptionTable table(this); + int length = table.length(); // iterate through all entries sequentially constantPoolHandle pool(THREAD, constants()); - for (int i = 0; i < length; i += entry_size) { - int beg_bci = table->int_at(i + beg_bci_offset); - int end_bci = table->int_at(i + end_bci_offset); + for (int i = 0; i < length; i ++) { + //reacquire the table in case a GC happened + ExceptionTable table(this); + int beg_bci = table.start_pc(i); + int end_bci = table.end_pc(i); assert(beg_bci <= end_bci, "inconsistent exception table"); if (beg_bci <= throw_bci && throw_bci < end_bci) { // exception handler bci range covers throw_bci => investigate further - int handler_bci = table->int_at(i + handler_bci_offset); - int klass_index = table->int_at(i + klass_index_offset); + int handler_bci = table.handler_pc(i); + int klass_index = table.catch_type_index(i); if (klass_index == 0) { return handler_bci; } else if (ex_klass.is_null()) { @@ -980,7 +976,7 @@ methodHandle methodOopDesc::make_invoke_method(KlassHandle holder, { int flags_bits = (JVM_MH_INVOKE_BITS | JVM_ACC_PUBLIC | JVM_ACC_FINAL); methodOop m_oop = oopFactory::new_method(0, accessFlags_from(flags_bits), - 0, 0, 0, IsSafeConc, CHECK_(empty)); + 0, 0, 0, 0, IsSafeConc, CHECK_(empty)); m = methodHandle(THREAD, m_oop); } m->set_constants(cp()); @@ -994,7 +990,6 @@ methodHandle methodOopDesc::make_invoke_method(KlassHandle holder, m->set_result_index(rtf.type()); #endif m->compute_size_of_parameters(THREAD); - m->set_exception_table(Universe::the_empty_int_array()); m->init_intrinsic_id(); assert(m->intrinsic_id() == vmIntrinsics::_invokeExact || m->intrinsic_id() == vmIntrinsics::_invokeGeneric, "must be an invoker"); @@ -1038,6 +1033,7 @@ methodHandle methodOopDesc:: clone_with_new_data(methodHandle m, u_char* new_cod AccessFlags flags = m->access_flags(); int checked_exceptions_len = m->checked_exceptions_length(); int localvariable_len = m->localvariable_table_length(); + int exception_table_len = m->exception_table_length(); // Allocate newm_oop with the is_conc_safe parameter set // to IsUnsafeConc to indicate that newm_oop is not yet // safe for concurrent processing by a GC. @@ -1045,6 +1041,7 @@ methodHandle methodOopDesc:: clone_with_new_data(methodHandle m, u_char* new_cod flags, new_compressed_linenumber_size, localvariable_len, + exception_table_len, checked_exceptions_len, IsUnsafeConc, CHECK_(methodHandle())); diff --git a/hotspot/src/share/vm/oops/methodOop.hpp b/hotspot/src/share/vm/oops/methodOop.hpp index de10b7c96f0..4e66bdcc4e0 100644 --- a/hotspot/src/share/vm/oops/methodOop.hpp +++ b/hotspot/src/share/vm/oops/methodOop.hpp @@ -282,12 +282,12 @@ class methodOopDesc : public oopDesc { } // exception handler table - typeArrayOop exception_table() const - { return constMethod()->exception_table(); } - void set_exception_table(typeArrayOop e) - { constMethod()->set_exception_table(e); } bool has_exception_handler() const { return constMethod()->has_exception_handler(); } + int exception_table_length() const + { return constMethod()->exception_table_length(); } + ExceptionTableElement* exception_table_start() const + { return constMethod()->exception_table_start(); } // Finds the first entry point bci of an exception handler for an // exception of klass ex_klass thrown at throw_bci. A value of NULL @@ -835,4 +835,66 @@ class BreakpointInfo : public CHeapObj { void clear(methodOop method); }; +// Utility class for access exception handlers +class ExceptionTable : public StackObj { + private: + ExceptionTableElement* _table; + u2 _length; + + public: + ExceptionTable(methodOop m) { + if (m->has_exception_handler()) { + _table = m->exception_table_start(); + _length = m->exception_table_length(); + } else { + _table = NULL; + _length = 0; + } + } + + int length() const { + return _length; + } + + u2 start_pc(int idx) const { + assert(idx < _length, "out of bounds"); + return _table[idx].start_pc; + } + + void set_start_pc(int idx, u2 value) { + assert(idx < _length, "out of bounds"); + _table[idx].start_pc = value; + } + + u2 end_pc(int idx) const { + assert(idx < _length, "out of bounds"); + return _table[idx].end_pc; + } + + void set_end_pc(int idx, u2 value) { + assert(idx < _length, "out of bounds"); + _table[idx].end_pc = value; + } + + u2 handler_pc(int idx) const { + assert(idx < _length, "out of bounds"); + return _table[idx].handler_pc; + } + + void set_handler_pc(int idx, u2 value) { + assert(idx < _length, "out of bounds"); + _table[idx].handler_pc = value; + } + + u2 catch_type_index(int idx) const { + assert(idx < _length, "out of bounds"); + return _table[idx].catch_type_index; + } + + void set_catch_type_index(int idx, u2 value) { + assert(idx < _length, "out of bounds"); + _table[idx].catch_type_index = value; + } +}; + #endif // SHARE_VM_OOPS_METHODOOP_HPP diff --git a/hotspot/src/share/vm/prims/jvm.cpp b/hotspot/src/share/vm/prims/jvm.cpp index 3f097819e3d..cb32e6e0ff4 100644 --- a/hotspot/src/share/vm/prims/jvm.cpp +++ b/hotspot/src/share/vm/prims/jvm.cpp @@ -35,6 +35,7 @@ #include "oops/fieldStreams.hpp" #include "oops/instanceKlass.hpp" #include "oops/objArrayKlass.hpp" +#include "oops/methodOop.hpp" #include "prims/jvm.h" #include "prims/jvm_misc.hpp" #include "prims/jvmtiExport.hpp" @@ -2179,11 +2180,11 @@ JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - typeArrayOop extable = methodOop(method)->exception_table(); - entry->start_pc = extable->int_at(entry_index * 4); - entry->end_pc = extable->int_at(entry_index * 4 + 1); - entry->handler_pc = extable->int_at(entry_index * 4 + 2); - entry->catchType = extable->int_at(entry_index * 4 + 3); + ExceptionTable extable((methodOop(method))); + entry->start_pc = extable.start_pc(entry_index); + entry->end_pc = extable.end_pc(entry_index); + entry->handler_pc = extable.handler_pc(entry_index); + entry->catchType = extable.catch_type_index(entry_index); JVM_END @@ -2192,7 +2193,7 @@ JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cl klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->exception_table()->length() / 4; + return methodOop(method)->exception_table_length(); JVM_END diff --git a/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.cpp b/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.cpp index d7dfea5a99e..27cd4a54f12 100644 --- a/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.cpp +++ b/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.cpp @@ -191,15 +191,14 @@ void JvmtiClassFileReconstituter::write_code_attribute(methodHandle method) { } } - typeArrayHandle exception_table(thread(), const_method->exception_table()); - int exception_table_length = exception_table->length(); - int exception_table_entries = exception_table_length / 4; + ExceptionTable exception_table(method()); + int exception_table_length = exception_table.length(); int code_size = const_method->code_size(); int size = 2+2+4 + // max_stack, max_locals, code_length code_size + // code 2 + // exception_table_length - (2+2+2+2) * exception_table_entries + // exception_table + (2+2+2+2) * exception_table_length + // exception_table 2 + // attributes_count attr_size; // attributes @@ -209,12 +208,12 @@ void JvmtiClassFileReconstituter::write_code_attribute(methodHandle method) { write_u2(method->max_locals()); write_u4(code_size); copy_bytecodes(method, (unsigned char*)writeable_address(code_size)); - write_u2(exception_table_entries); - for (int index = 0; index < exception_table_length; ) { - write_u2(exception_table->int_at(index++)); - write_u2(exception_table->int_at(index++)); - write_u2(exception_table->int_at(index++)); - write_u2(exception_table->int_at(index++)); + write_u2(exception_table_length); + for (int index = 0; index < exception_table_length; index++) { + write_u2(exception_table.start_pc(index)); + write_u2(exception_table.end_pc(index)); + write_u2(exception_table.handler_pc(index)); + write_u2(exception_table.catch_type_index(index)); } write_u2(attr_count); if (line_num_cnt != 0) { diff --git a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp index 2caecf680bb..53b91062e20 100644 --- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp +++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -2478,23 +2478,17 @@ void VM_RedefineClasses::set_new_constant_pool( // to use new constant pool indices as needed. The exception table // holds quadruple entries of the form: // (beg_bci, end_bci, handler_bci, klass_index) - const int beg_bci_offset = 0; - const int end_bci_offset = 1; - const int handler_bci_offset = 2; - const int klass_index_offset = 3; - const int entry_size = 4; - typeArrayHandle ex_table (THREAD, method->exception_table()); - int ext_length = ex_table->length(); - assert(ext_length % entry_size == 0, "exception table format has changed"); + ExceptionTable ex_table(method()); + int ext_length = ex_table.length(); - for (int j = 0; j < ext_length; j += entry_size) { - int cur_index = ex_table->int_at(j + klass_index_offset); + for (int j = 0; j < ext_length; j ++) { + int cur_index = ex_table.catch_type_index(j); int new_index = find_new_index(cur_index); if (new_index != 0) { RC_TRACE_WITH_THREAD(0x00080000, THREAD, ("ext-klass_index change: %d to %d", cur_index, new_index)); - ex_table->int_at_put(j + klass_index_offset, new_index); + ex_table.set_catch_type_index(j, new_index); } } // end for each exception table entry diff --git a/hotspot/src/share/vm/prims/methodHandleWalk.cpp b/hotspot/src/share/vm/prims/methodHandleWalk.cpp index d4d9a7130a5..68e83bdc7d6 100644 --- a/hotspot/src/share/vm/prims/methodHandleWalk.cpp +++ b/hotspot/src/share/vm/prims/methodHandleWalk.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -1796,7 +1796,7 @@ methodHandle MethodHandleCompiler::get_method_oop(TRAPS) { { methodOop m_oop = oopFactory::new_method(bytecode_length(), accessFlags_from(flags_bits), - 0, 0, 0, oopDesc::IsSafeConc, CHECK_(empty)); + 0, 0, 0, 0, oopDesc::IsSafeConc, CHECK_(empty)); m = methodHandle(THREAD, m_oop); } @@ -1812,9 +1812,6 @@ methodHandle MethodHandleCompiler::get_method_oop(TRAPS) { m->set_max_locals(max_locals()); m->set_size_of_parameters(_num_params); - typeArrayHandle exception_handlers(THREAD, Universe::the_empty_int_array()); - m->set_exception_table(exception_handlers()); - // Rewrite the method and set up the constant pool cache. objArrayOop m_array = oopFactory::new_system_objArray(1, CHECK_(empty)); objArrayHandle methods(THREAD, m_array); diff --git a/hotspot/src/share/vm/runtime/relocator.cpp b/hotspot/src/share/vm/runtime/relocator.cpp index a3970907761..e385b22fee7 100644 --- a/hotspot/src/share/vm/runtime/relocator.cpp +++ b/hotspot/src/share/vm/runtime/relocator.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -392,16 +392,16 @@ void Relocator::change_jumps(int break_bci, int delta) { // The width of instruction at "pc" is changing by "delta". Adjust the // exception table, if any, of "rc->mb". void Relocator::adjust_exception_table(int bci, int delta) { - typeArrayOop table = method()->exception_table(); - for (int index = 0; index < table->length(); index +=4) { - if (table->int_at(index) > bci) { - table->int_at_put(index+0, table->int_at(index+0) + delta); - table->int_at_put(index+1, table->int_at(index+1) + delta); - } else if (bci < table->int_at(index+1)) { - table->int_at_put(index+1, table->int_at(index+1) + delta); + ExceptionTable table(_method()); + for (int index = 0; index < table.length(); index ++) { + if (table.start_pc(index) > bci) { + table.set_start_pc(index, table.start_pc(index) + delta); + table.set_end_pc(index, table.end_pc(index) + delta); + } else if (bci < table.end_pc(index)) { + table.set_end_pc(index, table.end_pc(index) + delta); } - if (table->int_at(index+2) > bci) - table->int_at_put(index+2, table->int_at(index+2) + delta); + if (table.handler_pc(index) > bci) + table.set_handler_pc(index, table.handler_pc(index) + delta); } } diff --git a/hotspot/src/share/vm/runtime/vmStructs.cpp b/hotspot/src/share/vm/runtime/vmStructs.cpp index 7045fa8b3ce..bcfc2ecb115 100644 --- a/hotspot/src/share/vm/runtime/vmStructs.cpp +++ b/hotspot/src/share/vm/runtime/vmStructs.cpp @@ -379,7 +379,6 @@ static inline uint64_t cast_uint64_t(size_t x) volatile_nonstatic_field(constMethodOopDesc, _fingerprint, uint64_t) \ nonstatic_field(constMethodOopDesc, _constants, constantPoolOop) \ nonstatic_field(constMethodOopDesc, _stackmap_data, typeArrayOop) \ - nonstatic_field(constMethodOopDesc, _exception_table, typeArrayOop) \ nonstatic_field(constMethodOopDesc, _constMethod_size, int) \ nonstatic_field(constMethodOopDesc, _interpreter_kind, jbyte) \ nonstatic_field(constMethodOopDesc, _flags, jbyte) \ @@ -416,6 +415,10 @@ static inline uint64_t cast_uint64_t(size_t x) nonstatic_field(LocalVariableTableElement, descriptor_cp_index, u2) \ nonstatic_field(LocalVariableTableElement, signature_cp_index, u2) \ nonstatic_field(LocalVariableTableElement, slot, u2) \ + nonstatic_field(ExceptionTableElement, start_pc, u2) \ + nonstatic_field(ExceptionTableElement, end_pc, u2) \ + nonstatic_field(ExceptionTableElement, handler_pc, u2) \ + nonstatic_field(ExceptionTableElement, catch_type_index, u2) \ nonstatic_field(BreakpointInfo, _orig_bytecode, Bytecodes::Code) \ nonstatic_field(BreakpointInfo, _bci, int) \ nonstatic_field(BreakpointInfo, _name_index, u2) \ @@ -1451,6 +1454,7 @@ static inline uint64_t cast_uint64_t(size_t x) \ declare_toplevel_type(CheckedExceptionElement) \ declare_toplevel_type(LocalVariableTableElement) \ + declare_toplevel_type(ExceptionTableElement) \ \ /******************************************/ \ /* Generation and space hierarchies */ \ @@ -2334,6 +2338,7 @@ static inline uint64_t cast_uint64_t(size_t x) declare_constant(constMethodOopDesc::_has_linenumber_table) \ declare_constant(constMethodOopDesc::_has_checked_exceptions) \ declare_constant(constMethodOopDesc::_has_localvariable_table) \ + declare_constant(constMethodOopDesc::_has_exception_table) \ \ /*************************************/ \ /* instanceKlass enum */ \ From 8e42425c921a2ddd27073519c73b943d1c9f73e6 Mon Sep 17 00:00:00 2001 From: Staffan Larsen Date: Wed, 27 Jun 2012 15:23:36 +0200 Subject: [PATCH 030/160] 7178667: ALT_EXPORT_PATH does not export server jvm on macosx Missing .PHONY targets in makefile Reviewed-by: dholmes, dsamersoff --- hotspot/make/bsd/makefiles/universal.gmk | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/hotspot/make/bsd/makefiles/universal.gmk b/hotspot/make/bsd/makefiles/universal.gmk index 169b70d8772..0cc92758af9 100644 --- a/hotspot/make/bsd/makefiles/universal.gmk +++ b/hotspot/make/bsd/makefiles/universal.gmk @@ -110,4 +110,5 @@ copy_debug_jdk:: .PHONY: universal_product universal_fastdebug universal_debug \ all_product_universal all_fastdebug_universal all_debug_universal \ - universalize export_universal copy_universal + universalize export_universal copy_universal \ + $(UNIVERSAL_LIPO_LIST) $(UNIVERSAL_COPY_LIST) From 55c71e93179a77a198b72b7935ab55777b78aecd Mon Sep 17 00:00:00 2001 From: Sean Coffey Date: Wed, 27 Jun 2012 21:09:29 +0100 Subject: [PATCH 031/160] 7162902: Umbrella port of a number of corba bug fixes from JDK 6 to jdk7u/8 Reviewed-by: lancea --- .../se/impl/encoding/CachedCodeBase.java | 42 +- .../se/impl/interceptors/PIHandlerImpl.java | 27 +- .../impl/interceptors/PINoOpHandlerImpl.java | 5 +- .../MonitoringManagerFactoryImpl.java | 10 +- .../monitoring/MonitoringManagerImpl.java | 19 +- .../com/sun/corba/se/impl/orb/ORBImpl.java | 433 +++++++++++++----- .../orbutil/threadpool/ThreadPoolImpl.java | 397 +++++++++------- .../threadpool/ThreadPoolManagerImpl.java | 116 ++++- .../orbutil/threadpool/WorkQueueImpl.java | 17 +- .../protocol/CorbaMessageMediatorImpl.java | 6 +- .../corba/se/impl/transport/SelectorImpl.java | 6 +- .../sun/corba/se/spi/logging/data/ORBUtil.mc | 27 +- .../se/spi/monitoring/MonitoringManager.java | 5 +- .../monitoring/MonitoringManagerFactory.java | 4 +- .../classes/com/sun/corba/se/spi/orb/ORB.java | 26 +- .../se/spi/orbutil/threadpool/ThreadPool.java | 10 +- .../orbutil/threadpool/ThreadPoolManager.java | 6 +- .../sun/corba/se/spi/protocol/PIHandler.java | 6 +- .../protocol/RequestDispatcherRegistry.java | 40 +- 19 files changed, 837 insertions(+), 365 deletions(-) diff --git a/corba/src/share/classes/com/sun/corba/se/impl/encoding/CachedCodeBase.java b/corba/src/share/classes/com/sun/corba/se/impl/encoding/CachedCodeBase.java index 4b08a1ce249..3e698764e8d 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/encoding/CachedCodeBase.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/encoding/CachedCodeBase.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2004, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -22,7 +22,6 @@ * or visit www.oracle.com if you need additional information or have any * questions. */ - package com.sun.corba.se.impl.encoding; import java.util.Hashtable; @@ -32,7 +31,8 @@ import com.sun.org.omg.SendingContext.CodeBaseHelper; import com.sun.org.omg.SendingContext._CodeBaseImplBase; import com.sun.org.omg.SendingContext._CodeBaseStub; import com.sun.corba.se.spi.transport.CorbaConnection; - +import com.sun.corba.se.spi.ior.IOR; +import com.sun.corba.se.spi.orb.ORB; /** * Provides the reading side with a per connection cache of * info obtained via calls to the remote CodeBase. @@ -51,14 +51,24 @@ import com.sun.corba.se.spi.transport.CorbaConnection; * * Needs cache management. */ -// REVISIT: revert to package protected after framework merge. public class CachedCodeBase extends _CodeBaseImplBase { private Hashtable implementations, fvds, bases; - private CodeBase delegate; + private volatile CodeBase delegate; private CorbaConnection conn; - private static Hashtable iorToCodeBaseObjMap = new Hashtable(); + private static Object iorMapLock = new Object(); + private static Hashtable iorMap = new Hashtable<>(); + + public static synchronized void cleanCache( ORB orb ) { + synchronized (iorMapLock) { + for (IOR ior : iorMap.keySet()) { + if (ior.getORB() == orb) { + iorMap.remove(ior); + } + } + } + } public CachedCodeBase(CorbaConnection connection) { conn = connection; @@ -68,7 +78,7 @@ public class CachedCodeBase extends _CodeBaseImplBase return null; } - public String implementation (String repId) { + public synchronized String implementation (String repId) { String urlResult = null; if (implementations == null) @@ -86,7 +96,7 @@ public class CachedCodeBase extends _CodeBaseImplBase return urlResult; } - public String[] implementations (String[] repIds) { + public synchronized String[] implementations (String[] repIds) { String[] urlResults = new String[repIds.length]; for (int i = 0; i < urlResults.length; i++) @@ -95,7 +105,7 @@ public class CachedCodeBase extends _CodeBaseImplBase return urlResults; } - public FullValueDescription meta (String repId) { + public synchronized FullValueDescription meta (String repId) { FullValueDescription result = null; if (fvds == null) @@ -113,7 +123,7 @@ public class CachedCodeBase extends _CodeBaseImplBase return result; } - public FullValueDescription[] metas (String[] repIds) { + public synchronized FullValueDescription[] metas (String[] repIds) { FullValueDescription[] results = new FullValueDescription[repIds.length]; @@ -123,7 +133,7 @@ public class CachedCodeBase extends _CodeBaseImplBase return results; } - public String[] bases (String repId) { + public synchronized String[] bases (String repId) { String[] results = null; @@ -145,7 +155,7 @@ public class CachedCodeBase extends _CodeBaseImplBase // Ensures that we've used the connection's IOR to create // a valid CodeBase delegate. If this returns false, then // it is not valid to access the delegate. - private boolean connectedCodeBase() { + private synchronized boolean connectedCodeBase() { if (delegate != null) return true; @@ -165,7 +175,7 @@ public class CachedCodeBase extends _CodeBaseImplBase return false; } - synchronized(this) { + synchronized(iorMapLock) { // Recheck the condition to make sure another // thread didn't already do this while we waited @@ -173,7 +183,8 @@ public class CachedCodeBase extends _CodeBaseImplBase return true; // Do we have a reference initialized by another connection? - delegate = (CodeBase)CachedCodeBase.iorToCodeBaseObjMap.get(conn.getCodeBaseIOR()); + delegate = CachedCodeBase.iorMap.get(conn.getCodeBaseIOR()); + if (delegate != null) return true; @@ -181,8 +192,7 @@ public class CachedCodeBase extends _CodeBaseImplBase delegate = CodeBaseHelper.narrow(getObjectFromIOR()); // Save it for the benefit of other connections - CachedCodeBase.iorToCodeBaseObjMap.put(conn.getCodeBaseIOR(), - delegate); + CachedCodeBase.iorMap.put(conn.getCodeBaseIOR(), delegate); } // It's now safe to use the delegate diff --git a/corba/src/share/classes/com/sun/corba/se/impl/interceptors/PIHandlerImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/interceptors/PIHandlerImpl.java index e8c6d1560fc..e7d7ae27e76 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/interceptors/PIHandlerImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/interceptors/PIHandlerImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -58,7 +58,7 @@ import org.omg.PortableInterceptor.SYSTEM_EXCEPTION; import org.omg.PortableInterceptor.TRANSPORT_RETRY; import org.omg.PortableInterceptor.USER_EXCEPTION; import org.omg.PortableInterceptor.PolicyFactory; -import org.omg.PortableInterceptor.ObjectReferenceTemplate ; +import org.omg.PortableInterceptor.ObjectReferenceTemplate; import com.sun.corba.se.pept.encoding.OutputObject; @@ -112,10 +112,10 @@ public class PIHandlerImpl implements PIHandler } } - private ORB orb ; - InterceptorsSystemException wrapper ; - ORBUtilSystemException orbutilWrapper ; - OMGSystemException omgWrapper ; + private ORB orb; + InterceptorsSystemException wrapper; + ORBUtilSystemException orbutilWrapper; + OMGSystemException omgWrapper; // A unique id used in ServerRequestInfo. // This does not correspond to the GIOP request id. @@ -178,6 +178,21 @@ public class PIHandlerImpl implements PIHandler } }; + public void close() { + orb = null; + wrapper = null; + orbutilWrapper = null; + omgWrapper = null; + codecFactory = null; + arguments = null; + interceptorList = null; + interceptorInvoker = null; + current = null; + policyFactoryTable = null; + threadLocalClientRequestInfoStack = null; + threadLocalServerRequestInfoStack = null; + } + // Class to contain all ThreadLocal data for ClientRequestInfo // maintenance. // diff --git a/corba/src/share/classes/com/sun/corba/se/impl/interceptors/PINoOpHandlerImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/interceptors/PINoOpHandlerImpl.java index e6d9e53609f..93c047b76cd 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/interceptors/PINoOpHandlerImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/interceptors/PINoOpHandlerImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -69,6 +69,9 @@ public class PINoOpHandlerImpl implements PIHandler public PINoOpHandlerImpl( ) { } + public void close() { + } + public void initialize() { } diff --git a/corba/src/share/classes/com/sun/corba/se/impl/monitoring/MonitoringManagerFactoryImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/monitoring/MonitoringManagerFactoryImpl.java index eb365213270..a88d2f2f697 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/monitoring/MonitoringManagerFactoryImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/monitoring/MonitoringManagerFactoryImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -34,14 +34,18 @@ public class MonitoringManagerFactoryImpl implements MonitoringManagerFactory { private HashMap monitoringManagerTable = new HashMap(); public synchronized MonitoringManager createMonitoringManager( - String nameOfTheRoot, String description ) + String nameOfTheRoot, String description) { MonitoringManagerImpl m = null; m = (MonitoringManagerImpl)monitoringManagerTable.get(nameOfTheRoot); if (m == null) { - m = new MonitoringManagerImpl( nameOfTheRoot, description ); + m = new MonitoringManagerImpl(nameOfTheRoot, description); monitoringManagerTable.put(nameOfTheRoot, m); } return m; } + + public synchronized void remove(String nameOfTheRoot) { + monitoringManagerTable.remove(nameOfTheRoot); + } } diff --git a/corba/src/share/classes/com/sun/corba/se/impl/monitoring/MonitoringManagerImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/monitoring/MonitoringManagerImpl.java index 4e97a73815c..b7e676eafed 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/monitoring/MonitoringManagerImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/monitoring/MonitoringManagerImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,6 +26,7 @@ package com.sun.corba.se.impl.monitoring; import com.sun.corba.se.spi.monitoring.MonitoringManager; +import com.sun.corba.se.spi.monitoring.MonitoringManagerFactory; import com.sun.corba.se.spi.monitoring.MonitoredObject; import com.sun.corba.se.spi.monitoring.MonitoredObjectFactory; import com.sun.corba.se.spi.monitoring.MonitoringFactories; @@ -33,18 +34,24 @@ import com.sun.corba.se.spi.monitoring.MonitoringFactories; public class MonitoringManagerImpl implements MonitoringManager { private final MonitoredObject rootMonitoredObject; - MonitoringManagerImpl( String nameOfTheRoot, String description ) { + MonitoringManagerImpl(String nameOfTheRoot, String description) { MonitoredObjectFactory f = MonitoringFactories.getMonitoredObjectFactory(); rootMonitoredObject = - f.createMonitoredObject( nameOfTheRoot, description ); + f.createMonitoredObject(nameOfTheRoot, description); } - public void clearState( ) { - rootMonitoredObject.clearState( ); + public void clearState() { + rootMonitoredObject.clearState(); } - public MonitoredObject getRootMonitoredObject( ) { + public MonitoredObject getRootMonitoredObject() { return rootMonitoredObject; } + + public void close() { + MonitoringManagerFactory f = + MonitoringFactories.getMonitoringManagerFactory(); + f.remove(rootMonitoredObject.getName()); + } } diff --git a/corba/src/share/classes/com/sun/corba/se/impl/orb/ORBImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/orb/ORBImpl.java index 65d8246f7ad..9c03173238b 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/orb/ORBImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/orb/ORBImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,35 +23,37 @@ * questions. */ -package com.sun.corba.se.impl.orb ; +package com.sun.corba.se.impl.orb; import java.applet.Applet; -import java.io.IOException ; +import java.io.IOException; import java.lang.reflect.Constructor; -import java.lang.reflect.Field ; -import java.lang.reflect.Modifier ; -import java.lang.reflect.InvocationTargetException ; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.lang.reflect.InvocationTargetException; -import java.util.ArrayList ; -import java.util.Iterator ; -import java.util.Properties ; -import java.util.Vector ; -import java.util.Hashtable ; -import java.util.Map ; -import java.util.HashMap ; -import java.util.LinkedList ; -import java.util.Collection ; -import java.util.Collections ; -import java.util.StringTokenizer ; -import java.util.Enumeration ; -import java.util.WeakHashMap ; +import java.util.Set; +import java.util.HashSet; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.Properties; +import java.util.Vector; +import java.util.Hashtable; +import java.util.Map; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.Collection; +import java.util.Collections; +import java.util.StringTokenizer; +import java.util.Enumeration; +import java.util.WeakHashMap; -import java.net.InetAddress ; +import java.net.InetAddress; import java.security.PrivilegedAction; -import java.security.AccessController ; +import java.security.AccessController; import javax.rmi.CORBA.Util; import javax.rmi.CORBA.ValueHandler; @@ -82,18 +84,18 @@ import org.omg.CORBA.ORBPackage.InvalidName; import com.sun.org.omg.SendingContext.CodeBase; import com.sun.corba.se.pept.broker.Broker; -import com.sun.corba.se.pept.protocol.ClientInvocationInfo ; +import com.sun.corba.se.pept.protocol.ClientInvocationInfo; import com.sun.corba.se.pept.transport.ContactInfo; import com.sun.corba.se.pept.transport.ConnectionCache; import com.sun.corba.se.pept.transport.TransportManager; import com.sun.corba.se.spi.ior.IOR; -import com.sun.corba.se.spi.ior.IdentifiableFactoryFinder ; +import com.sun.corba.se.spi.ior.IdentifiableFactoryFinder; import com.sun.corba.se.spi.ior.TaggedComponentFactoryFinder; -import com.sun.corba.se.spi.ior.IORFactories ; -import com.sun.corba.se.spi.ior.ObjectKey ; -import com.sun.corba.se.spi.ior.ObjectKeyFactory ; -import com.sun.corba.se.spi.ior.iiop.IIOPFactories ; +import com.sun.corba.se.spi.ior.IORFactories; +import com.sun.corba.se.spi.ior.ObjectKey; +import com.sun.corba.se.spi.ior.ObjectKeyFactory; +import com.sun.corba.se.spi.ior.iiop.IIOPFactories; import com.sun.corba.se.spi.ior.iiop.GIOPVersion; import com.sun.corba.se.spi.oa.OAInvocationInfo; import com.sun.corba.se.spi.oa.ObjectAdapterFactory; @@ -122,10 +124,10 @@ import com.sun.corba.se.spi.orb.StringPair; import com.sun.corba.se.spi.transport.CorbaContactInfoListFactory; import com.sun.corba.se.spi.transport.CorbaTransportManager; import com.sun.corba.se.spi.legacy.connection.LegacyServerSocketManager; -import com.sun.corba.se.spi.copyobject.CopierManager ; -import com.sun.corba.se.spi.presentation.rmi.PresentationDefaults ; -import com.sun.corba.se.spi.presentation.rmi.PresentationManager ; -import com.sun.corba.se.spi.presentation.rmi.StubAdapter ; +import com.sun.corba.se.spi.copyobject.CopierManager; +import com.sun.corba.se.spi.presentation.rmi.PresentationDefaults; +import com.sun.corba.se.spi.presentation.rmi.PresentationManager; +import com.sun.corba.se.spi.presentation.rmi.StubAdapter; import com.sun.corba.se.spi.servicecontext.ServiceContextRegistry; import com.sun.corba.se.impl.corba.TypeCodeFactory; @@ -140,6 +142,7 @@ import com.sun.corba.se.impl.corba.AnyImpl; import com.sun.corba.se.impl.corba.RequestImpl; import com.sun.corba.se.impl.dynamicany.DynAnyFactoryImpl; import com.sun.corba.se.impl.encoding.EncapsOutputStream; +import com.sun.corba.se.impl.encoding.CachedCodeBase; import com.sun.corba.se.impl.interceptors.PIHandlerImpl; import com.sun.corba.se.impl.interceptors.PINoOpHandlerImpl; import com.sun.corba.se.impl.ior.TaggedComponentFactoryFinderImpl; @@ -185,6 +188,7 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB private java.lang.Object runObj = new java.lang.Object(); private java.lang.Object shutdownObj = new java.lang.Object(); + private java.lang.Object waitForCompletionObj = new java.lang.Object(); private static final byte STATUS_OPERATING = 1; private static final byte STATUS_SHUTTING_DOWN = 2; private static final byte STATUS_SHUTDOWN = 3; @@ -193,6 +197,7 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB // XXX Should we move invocation tracking to the first level server dispatcher? private java.lang.Object invocationObj = new java.lang.Object(); + private int numInvocations = 0; // thread local variable to store a boolean to detect deadlock in // ORB.shutdown(true). @@ -220,8 +225,6 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB private int transientServerId ; - private ThreadGroup threadGroup ; - private ServiceContextRegistry serviceContextRegistry ; // Needed here to implement connect/disconnect @@ -265,6 +268,7 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB private final Object urlOperationLock = new java.lang.Object() ; private CorbaServerRequestDispatcher insNamingDelegate ; + // resolverLock must be used for all access to either resolver or // localResolver, since it is possible for the resolver to indirectly // refer to the localResolver. Also used to protect access to @@ -279,6 +283,8 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB private ObjectKeyFactory objectKeyFactory ; + private boolean orbOwnsThreadPoolManager = false ; + private ThreadPoolManager threadpoolMgr; private void dprint( String msg ) @@ -322,11 +328,17 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public ORBVersion getORBVersion() { + synchronized (this) { + checkShutdownState(); + } return (ORBVersion)(orbVersionThreadLocal.get()) ; } public void setORBVersion(ORBVersion verObj) { + synchronized (this) { + checkShutdownState(); + } orbVersionThreadLocal.set(verObj); } @@ -347,46 +359,6 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB // end of this method. pihandler = new PINoOpHandlerImpl( ); - // See bugs 4916766 and 4936203 - // We intend to create new threads in a reliable thread group. - // This avoids problems if the application/applet - // creates a thread group, makes JavaIDL calls which create a new - // connection and ReaderThread, and then destroys the thread - // group. If our ReaderThreads were to be part of such destroyed thread - // group then it might get killed and cause other invoking threads - // sharing the same connection to get a non-restartable - // CommunicationFailure. We'd like to avoid that. - // - // Our solution is to create all of our threads in the highest thread - // group that we have access to, given our own security clearance. - // - try { - // try to get a thread group that's as high in the threadgroup - // parent-child hierarchy, as we can get to. - // this will prevent an ORB thread created during applet-init from - // being killed when an applet dies. - threadGroup = (ThreadGroup) AccessController.doPrivileged( - new PrivilegedAction() { - public Object run() { - ThreadGroup tg = Thread.currentThread().getThreadGroup() ; - ThreadGroup ptg = tg ; - try { - while (ptg != null) { - tg = ptg; - ptg = tg.getParent(); - } - } catch (SecurityException se) { - // Discontinue going higher on a security exception. - } - return new ThreadGroup(tg, "ORB ThreadGroup"); - } - } - ); - } catch (SecurityException e) { - // something wrong, we go back to the original code - threadGroup = Thread.currentThread().getThreadGroup(); - } - // This is the unique id of this server (JVM). Multiple incarnations // of this server will get different ids. // Compute transientServerId = milliseconds since Jan 1, 1970 @@ -547,6 +519,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void set_parameters( Properties props ) { + synchronized (this) { + checkShutdownState(); + } preInit( null, props ) ; DataCollector dataCollector = DataCollectorFactory.create( props, getLocalHostName() ) ; @@ -788,6 +763,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB */ public void notifyORB() { + synchronized (this) { + checkShutdownState(); + } synchronized (this.svResponseReceived) { this.svResponseReceived.set(); this.svResponseReceived.notify(); @@ -854,6 +832,8 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB // Note that we connect this if we have not already done so. public synchronized IOR getFVDCodeBaseIOR() { + checkShutdownState(); + if (codeBaseIOR != null) // i.e. We are already connected to it return codeBaseIOR; @@ -1118,6 +1098,8 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public synchronized void setTypeCodeForClass(Class c, TypeCodeImpl tci) { + checkShutdownState(); + if (typeCodeForClassMap == null) typeCodeForClassMap = Collections.synchronizedMap( new WeakHashMap(64)); @@ -1128,6 +1110,8 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public synchronized TypeCodeImpl getTypeCodeForClass(Class c) { + checkShutdownState(); + if (typeCodeForClassMap == null) return null; return (TypeCodeImpl)typeCodeForClassMap.get(c); @@ -1210,6 +1194,10 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB { CorbaServerRequestDispatcher insnd ; + synchronized (this) { + checkShutdownState(); + } + if ((id == null) || (id.length() == 0)) throw new InvalidName() ; @@ -1253,66 +1241,88 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB } } - public void shutdown(boolean wait_for_completion) - { - // to wait for completion, we would deadlock, so throw a standard - // OMG exception. - if (wait_for_completion && ((Boolean)isProcessingInvocation.get()).booleanValue()) { - throw omgWrapper.shutdownWaitForCompletionDeadlock() ; - } - - boolean doShutdown = false ; + public void shutdown(boolean wait_for_completion) { + boolean wait = false; synchronized (this) { - checkShutdownState() ; + checkShutdownState(); + + // This is to avoid deadlock: don't allow a thread that is + // processing a request to call shutdown( true ), because + // the shutdown would block waiting for the request to complete, + // while the request would block waiting for shutdown to complete. + if (wait_for_completion && + isProcessingInvocation.get() == Boolean.TRUE) { + throw omgWrapper.shutdownWaitForCompletionDeadlock(); + } if (status == STATUS_SHUTTING_DOWN) { - if (!wait_for_completion) - // If we are already shutting down and don't want - // to wait, nothing to do: return. - return ; - } else { - // The ORB status was STATUS_OPERATING, so start the shutdown. - status = STATUS_SHUTTING_DOWN ; - doShutdown = true ; + if (wait_for_completion) { + wait = true; + } else { + return; + } } + + status = STATUS_SHUTTING_DOWN; } - // At this point, status is SHUTTING_DOWN. - // All shutdown calls with wait_for_completion == true must synchronize - // here. Only the first call will be made with doShutdown == true. + // Avoid more than one thread performing shutdown at a time. synchronized (shutdownObj) { - if (doShutdown) { - // shutdownServants will set all POAManagers into the - // INACTIVE state, causing request to be rejected. - // If wait_for_completion is true, this will not return until - // all invocations have completed. + // At this point, the ORB status is certainly STATUS_SHUTTING_DOWN. + // If wait is true, another thread already called shutdown( true ), + // and so we wait for completion + if (wait) { + while (true) { + synchronized (this) { + if (status == STATUS_SHUTDOWN) + break; + } + + try { + shutdownObj.wait(); + } catch (InterruptedException exc) { + // NOP: just loop and wait until state is changed + } + } + } else { + // perform the actual shutdown shutdownServants(wait_for_completion); + if (wait_for_completion) { + synchronized ( waitForCompletionObj ) { + while (numInvocations > 0) { + try { + waitForCompletionObj.wait(); + } catch (InterruptedException ex) {} + } + } + } + synchronized (runObj) { runObj.notifyAll(); } - synchronized (this) { - status = STATUS_SHUTDOWN; - } + status = STATUS_SHUTDOWN; + + shutdownObj.notifyAll(); } } } - /** This method shuts down the ORB and causes orb.run() to return. - * It will cause all POAManagers to be deactivated, which in turn - * will cause all POAs to be deactivated. - */ + // Cause all ObjectAdapaterFactories to clean up all of their internal state, which + // may include activated objects that have associated state and callbacks that must + // complete in order to shutdown. This will cause new request to be rejected. protected void shutdownServants(boolean wait_for_completion) { - Iterator iter = requestDispatcherRegistry.getObjectAdapterFactories().iterator() ; - while (iter.hasNext()) { - ObjectAdapterFactory oaf = (ObjectAdapterFactory)iter.next() ; - oaf.shutdown( wait_for_completion ) ; + Set oaset; + synchronized (this) { + oaset = new HashSet<>(requestDispatcherRegistry.getObjectAdapterFactories()); } + + for (ObjectAdapterFactory oaf : oaset) + oaf.shutdown(wait_for_completion); } - // REVISIT: was protected - made public for framework // Note that the caller must hold the ORBImpl lock. public void checkShutdownState() { @@ -1327,21 +1337,40 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public boolean isDuringDispatch() { + synchronized (this) { + checkShutdownState(); + } Boolean value = (Boolean)(isProcessingInvocation.get()) ; return value.booleanValue() ; } public void startingDispatch() { + synchronized (this) { + checkShutdownState(); + } synchronized (invocationObj) { isProcessingInvocation.set(Boolean.TRUE); + numInvocations++; } } public void finishedDispatch() { + synchronized (this) { + checkShutdownState(); + } synchronized (invocationObj) { - isProcessingInvocation.set(Boolean.FALSE); + numInvocations--; + isProcessingInvocation.set(false); + if (numInvocations == 0) { + synchronized (waitForCompletionObj) { + waitForCompletionObj.notifyAll(); + } + } else if (numInvocations < 0) { + throw wrapper.numInvocationsAlreadyZero( + CompletionStatus.COMPLETED_YES); + } } } @@ -1350,12 +1379,12 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB * not been shut down, it will start the shutdown process and block until * the ORB has shut down before it destroys the ORB." */ - public synchronized void destroy() + public void destroy() { - boolean shutdownFirst = false ; + boolean shutdownFirst = false; synchronized (this) { - shutdownFirst = (status == STATUS_OPERATING) ; + shutdownFirst = (status == STATUS_OPERATING); } if (shutdownFirst) { @@ -1365,11 +1394,76 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB synchronized (this) { if (status < STATUS_DESTROYED) { getCorbaTransportManager().close(); - getPIHandler().destroyInterceptors() ; + getPIHandler().destroyInterceptors(); status = STATUS_DESTROYED; } } + synchronized (threadPoolManagerAccessLock) { + if (orbOwnsThreadPoolManager) { + try { + threadpoolMgr.close(); + threadpoolMgr = null; + } catch (IOException exc) { + wrapper.ioExceptionOnClose(exc); + } + } + } + try { + monitoringManager.close(); + monitoringManager = null; + } catch (IOException exc) { + wrapper.ioExceptionOnClose(exc); + } + + CachedCodeBase.cleanCache(this); + try { + pihandler.close(); + } catch (IOException exc) { + wrapper.ioExceptionOnClose(exc); + } + + super.destroy(); + + badServerIdHandlerAccessLock = null; + clientDelegateFactoryAccessorLock = null; + corbaContactInfoListFactoryAccessLock = null; + + objectKeyFactoryAccessLock = null; + legacyServerSocketManagerAccessLock = null; + threadPoolManagerAccessLock = null; + transportManager = null; + legacyServerSocketManager = null; + OAInvocationInfoStack = null; + clientInvocationInfoStack = null; + codeBaseIOR = null; + dynamicRequests = null; + svResponseReceived = null; + runObj = null; + shutdownObj = null; + waitForCompletionObj = null; + invocationObj = null; + isProcessingInvocation = null; + typeCodeForClassMap = null; + valueFactoryCache = null; + orbVersionThreadLocal = null; + requestDispatcherRegistry = null; + copierManager = null; + toaFactory = null; + poaFactory = null; + pihandler = null; + configData = null; + badServerIdHandler = null; + clientDelegateFactory = null; + corbaContactInfoListFactory = null; + resolver = null; + localResolver = null; + insNamingDelegate = null; + urlOperation = null; + taggedComponentFactoryFinder = null; + taggedProfileFactoryFinder = null; + taggedProfileTemplateFactoryFinder = null; + objectKeyFactory = null; } /** @@ -1434,18 +1528,27 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public OAInvocationInfo peekInvocationInfo() { + synchronized (this) { + checkShutdownState(); + } StackImpl stack = (StackImpl)(OAInvocationInfoStack.get()) ; return (OAInvocationInfo)(stack.peek()) ; } public void pushInvocationInfo( OAInvocationInfo info ) { + synchronized (this) { + checkShutdownState(); + } StackImpl stack = (StackImpl)(OAInvocationInfoStack.get()) ; stack.push( info ) ; } public OAInvocationInfo popInvocationInfo() { + synchronized (this) { + checkShutdownState(); + } StackImpl stack = (StackImpl)(OAInvocationInfoStack.get()) ; return (OAInvocationInfo)(stack.pop()) ; } @@ -1459,6 +1562,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void initBadServerIdHandler() { + synchronized (this) { + checkShutdownState(); + } synchronized (badServerIdHandlerAccessLock) { Class cls = configData.getBadServerIdHandler() ; if (cls != null) { @@ -1477,6 +1583,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void setBadServerIdHandler( BadServerIdHandler handler ) { + synchronized (this) { + checkShutdownState(); + } synchronized (badServerIdHandlerAccessLock) { badServerIdHandler = handler; } @@ -1484,6 +1593,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void handleBadServerId( ObjectKey okey ) { + synchronized (this) { + checkShutdownState(); + } synchronized (badServerIdHandlerAccessLock) { if (badServerIdHandler == null) throw wrapper.badServerId() ; @@ -1532,6 +1644,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public int getTransientServerId() { + synchronized (this) { + checkShutdownState(); + } if( configData.getORBServerIdPropertySpecified( ) ) { // ORBServerId is specified then use that value return configData.getPersistentServerId( ); @@ -1541,11 +1656,17 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public RequestDispatcherRegistry getRequestDispatcherRegistry() { + synchronized (this) { + checkShutdownState(); + } return requestDispatcherRegistry; } public ServiceContextRegistry getServiceContextRegistry() { + synchronized (this) { + checkShutdownState(); + } return serviceContextRegistry ; } @@ -1563,12 +1684,18 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB // XXX What about multi-homed host? public boolean isLocalHost( String hostName ) { + synchronized (this) { + checkShutdownState(); + } return hostName.equals( configData.getORBServerHost() ) || hostName.equals( getLocalHostName() ) ; } public boolean isLocalServerId( int subcontractId, int serverId ) { + synchronized (this) { + checkShutdownState(); + } if ((subcontractId < ORBConstants.FIRST_POA_SCID) || (subcontractId > ORBConstants.MAX_POA_SCID)) return serverId == getTransientServerId( ) ; @@ -1659,6 +1786,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public ClientInvocationInfo createOrIncrementInvocationInfo() { + synchronized (this) { + checkShutdownState(); + } StackImpl invocationInfoStack = (StackImpl) clientInvocationInfoStack.get(); ClientInvocationInfo clientInvocationInfo = null; @@ -1682,10 +1812,13 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void releaseOrDecrementInvocationInfo() { - StackImpl invocationInfoStack = - (StackImpl)clientInvocationInfoStack.get(); + synchronized (this) { + checkShutdownState(); + } int entryCount = -1; ClientInvocationInfo clientInvocationInfo = null; + StackImpl invocationInfoStack = + (StackImpl)clientInvocationInfoStack.get(); if (!invocationInfoStack.empty()) { clientInvocationInfo = (ClientInvocationInfo)invocationInfoStack.peek(); @@ -1705,6 +1838,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public ClientInvocationInfo getInvocationInfo() { + synchronized (this) { + checkShutdownState(); + } StackImpl invocationInfoStack = (StackImpl) clientInvocationInfoStack.get(); return (ClientInvocationInfo) invocationInfoStack.peek(); @@ -1719,6 +1855,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void setClientDelegateFactory( ClientDelegateFactory factory ) { + synchronized (this) { + checkShutdownState(); + } synchronized (clientDelegateFactoryAccessorLock) { clientDelegateFactory = factory ; } @@ -1726,6 +1865,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public ClientDelegateFactory getClientDelegateFactory() { + synchronized (this) { + checkShutdownState(); + } synchronized (clientDelegateFactoryAccessorLock) { return clientDelegateFactory ; } @@ -1735,6 +1877,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void setCorbaContactInfoListFactory( CorbaContactInfoListFactory factory ) { + synchronized (this) { + checkShutdownState(); + } synchronized (corbaContactInfoListFactoryAccessLock) { corbaContactInfoListFactory = factory ; } @@ -1742,6 +1887,7 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public synchronized CorbaContactInfoListFactory getCorbaContactInfoListFactory() { + checkShutdownState(); return corbaContactInfoListFactory ; } @@ -1750,6 +1896,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB */ public void setResolver( Resolver resolver ) { + synchronized (this) { + checkShutdownState(); + } synchronized (resolverLock) { this.resolver = resolver ; } @@ -1760,6 +1909,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB */ public Resolver getResolver() { + synchronized (this) { + checkShutdownState(); + } synchronized (resolverLock) { return resolver ; } @@ -1770,6 +1922,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB */ public void setLocalResolver( LocalResolver resolver ) { + synchronized (this) { + checkShutdownState(); + } synchronized (resolverLock) { this.localResolver = resolver ; } @@ -1780,6 +1935,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB */ public LocalResolver getLocalResolver() { + synchronized (this) { + checkShutdownState(); + } synchronized (resolverLock) { return localResolver ; } @@ -1790,6 +1948,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB */ public void setURLOperation( Operation stringToObject ) { + synchronized (this) { + checkShutdownState(); + } synchronized (urlOperationLock) { urlOperation = stringToObject ; } @@ -1800,6 +1961,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB */ public Operation getURLOperation() { + synchronized (this) { + checkShutdownState(); + } synchronized (urlOperationLock) { return urlOperation ; } @@ -1807,6 +1971,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void setINSDelegate( CorbaServerRequestDispatcher sdel ) { + synchronized (this) { + checkShutdownState(); + } synchronized (resolverLock) { insNamingDelegate = sdel ; } @@ -1814,16 +1981,25 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public TaggedComponentFactoryFinder getTaggedComponentFactoryFinder() { + synchronized (this) { + checkShutdownState(); + } return taggedComponentFactoryFinder ; } public IdentifiableFactoryFinder getTaggedProfileFactoryFinder() { + synchronized (this) { + checkShutdownState(); + } return taggedProfileFactoryFinder ; } public IdentifiableFactoryFinder getTaggedProfileTemplateFactoryFinder() { + synchronized (this) { + checkShutdownState(); + } return taggedProfileTemplateFactoryFinder ; } @@ -1831,6 +2007,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public ObjectKeyFactory getObjectKeyFactory() { + synchronized (this) { + checkShutdownState(); + } synchronized (objectKeyFactoryAccessLock) { return objectKeyFactory ; } @@ -1838,6 +2017,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void setObjectKeyFactory( ObjectKeyFactory factory ) { + synchronized (this) { + checkShutdownState(); + } synchronized (objectKeyFactoryAccessLock) { objectKeyFactory = factory ; } @@ -1864,6 +2046,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public LegacyServerSocketManager getLegacyServerSocketManager() { + synchronized (this) { + checkShutdownState(); + } synchronized (legacyServerSocketManagerAccessLock) { if (legacyServerSocketManager == null) { legacyServerSocketManager = new LegacyServerSocketManagerImpl(this); @@ -1876,6 +2061,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public void setThreadPoolManager(ThreadPoolManager mgr) { + synchronized (this) { + checkShutdownState(); + } synchronized (threadPoolManagerAccessLock) { threadpoolMgr = mgr; } @@ -1883,9 +2071,13 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public ThreadPoolManager getThreadPoolManager() { + synchronized (this) { + checkShutdownState(); + } synchronized (threadPoolManagerAccessLock) { if (threadpoolMgr == null) { - threadpoolMgr = new ThreadPoolManagerImpl( threadGroup ); + threadpoolMgr = new ThreadPoolManagerImpl(); + orbOwnsThreadPoolManager = true; } return threadpoolMgr; } @@ -1893,6 +2085,9 @@ public class ORBImpl extends com.sun.corba.se.spi.orb.ORB public CopierManager getCopierManager() { + synchronized (this) { + checkShutdownState(); + } return copierManager ; } } // Class ORBImpl diff --git a/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/ThreadPoolImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/ThreadPoolImpl.java index f8341f84b0c..f98880bf68d 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/ThreadPoolImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/ThreadPoolImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,6 +25,18 @@ package com.sun.corba.se.impl.orbutil.threadpool; +import java.io.IOException; +import java.io.Closeable; + +import java.security.AccessController; +import java.security.PrivilegedAction; + +import java.util.List; +import java.util.ArrayList; + +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicLong; + import com.sun.corba.se.spi.orbutil.threadpool.NoSuchWorkQueueException; import com.sun.corba.se.spi.orbutil.threadpool.ThreadPool; import com.sun.corba.se.spi.orbutil.threadpool.Work; @@ -36,12 +48,27 @@ import com.sun.corba.se.impl.orbutil.threadpool.WorkQueueImpl; import com.sun.corba.se.spi.monitoring.MonitoringConstants; import com.sun.corba.se.spi.monitoring.MonitoredObject; import com.sun.corba.se.spi.monitoring.MonitoringFactories; +import com.sun.corba.se.spi.orb.ORB; import com.sun.corba.se.spi.monitoring.LongMonitoredAttributeBase; +import com.sun.corba.se.impl.logging.ORBUtilSystemException; +import com.sun.corba.se.impl.orbutil.ORBConstants; +import com.sun.corba.se.spi.logging.CORBALogDomains; + public class ThreadPoolImpl implements ThreadPool { - private static int threadCounter = 0; // serial counter useful for debugging + // serial counter useful for debugging + private static AtomicInteger threadCounter = new AtomicInteger(0); + private static final ORBUtilSystemException wrapper = + ORBUtilSystemException.get(CORBALogDomains.RPC_TRANSPORT); + + // Any time currentThreadCount and/or availableWorkerThreads is updated + // or accessed this ThreadPool's WorkQueue must be locked. And, it is + // expected that this ThreadPool's WorkQueue is the only object that + // updates and accesses these values directly and indirectly though a + // call to a method in this ThreadPool. If any call to update or access + // those values must synchronized on this ThreadPool's WorkQueue. private WorkQueue workQueue; // Stores the number of available worker threads @@ -65,14 +92,11 @@ public class ThreadPoolImpl implements ThreadPool // Running count of the work items processed // Set the value to 1 so that divide by zero is avoided in // averageWorkCompletionTime() - private long processedCount = 1; + private AtomicLong processedCount = new AtomicLong(1); // Running aggregate of the time taken in millis to execute work items // processed by the threads in the threadpool - private long totalTimeTaken = 0; - - // Lock for protecting state when required - private Object lock = new Object(); + private AtomicLong totalTimeTaken = new AtomicLong(0); // Name of the ThreadPool private String name; @@ -81,7 +105,10 @@ public class ThreadPoolImpl implements ThreadPool private MonitoredObject threadpoolMonitoredObject; // ThreadGroup in which threads should be created - private ThreadGroup threadGroup ; + private ThreadGroup threadGroup; + + Object workersLock = new Object(); + List workers = new ArrayList<>(); /** * This constructor is used to create an unbounded threadpool @@ -90,7 +117,7 @@ public class ThreadPoolImpl implements ThreadPool inactivityTimeout = ORBConstants.DEFAULT_INACTIVITY_TIMEOUT; maxWorkerThreads = Integer.MAX_VALUE; workQueue = new WorkQueueImpl(this); - threadGroup = tg ; + threadGroup = tg; name = threadpoolName; initializeMonitoring(); } @@ -121,6 +148,30 @@ public class ThreadPoolImpl implements ThreadPool initializeMonitoring(); } + // Note that this method should not return until AFTER all threads have died. + public void close() throws IOException { + + // Copy to avoid concurrent modification problems. + List copy = null; + synchronized (workersLock) { + copy = new ArrayList<>(workers); + } + + for (WorkerThread wt : copy) { + wt.close(); + while (wt.getState() != Thread.State.TERMINATED) { + try { + wt.join(); + } catch (InterruptedException exc) { + wrapper.interruptedJoinCallWhileClosingThreadPool(exc, wt, this); + } + } + } + + threadGroup = null; + } + + // Setup monitoring for this threadpool private void initializeMonitoring() { // Get root monitored object @@ -217,8 +268,8 @@ public class ThreadPoolImpl implements ThreadPool * or notify waiting threads on the queue for available work */ void notifyForAvailableWork(WorkQueue aWorkQueue) { - synchronized (lock) { - if (availableWorkerThreads == 0) { + synchronized (aWorkQueue) { + if (availableWorkerThreads < aWorkQueue.workItemsInQueue()) { createWorkerThread(); } else { aWorkQueue.notify(); @@ -227,120 +278,145 @@ public class ThreadPoolImpl implements ThreadPool } - /** - * To be called from the workqueue to create worker threads when none - * available. - */ - void createWorkerThread() { - WorkerThread thread; - - synchronized (lock) { - if (boundedThreadPool) { - if (currentThreadCount < maxWorkerThreads) { - thread = new WorkerThread(threadGroup, getName()); - currentThreadCount++; - } else { - // REVIST - Need to create a thread to monitor the - // the state for deadlock i.e. all threads waiting for - // something which can be got from the item in the - // workqueue, but there is no thread available to - // process that work item - DEADLOCK !! - return; - } - } else { - thread = new WorkerThread(threadGroup, getName()); - currentThreadCount++; - } + private Thread createWorkerThreadHelper( String name ) { + // Thread creation needs to be in a doPrivileged block + // if there is a non-null security manager for two reasons: + // 1. The creation of a thread in a specific ThreadGroup + // is a privileged operation. Lack of a doPrivileged + // block here causes an AccessControlException + // (see bug 6268145). + // 2. We want to make sure that the permissions associated + // with this thread do NOT include the permissions of + // the current thread that is calling this method. + // This leads to problems in the app server where + // some threads in the ThreadPool randomly get + // bad permissions, leading to unpredictable + // permission errors (see bug 6021011). + // + // A Java thread contains a stack of call frames, + // one for each method called that has not yet returned. + // Each method comes from a particular class. The class + // was loaded by a ClassLoader which has an associated + // CodeSource, and this determines the Permissions + // for all methods in that class. The current + // Permissions for the thread are the intersection of + // all Permissions for the methods on the stack. + // This is part of the Security Context of the thread. + // + // When a thread creates a new thread, the new thread + // inherits the security context of the old thread. + // This is bad in a ThreadPool, because different + // creators of threads may have different security contexts. + // This leads to occasional unpredictable errors when + // a thread is re-used in a different security context. + // + // Avoiding this problem is simple: just do the thread + // creation in a doPrivileged block. This sets the + // inherited security context to that of the code source + // for the ORB code itself, which contains all permissions + // in either Java SE or Java EE. + WorkerThread thread = new WorkerThread(threadGroup, name); + synchronized (workersLock) { + workers.add(thread); } // The thread must be set to a daemon thread so the // VM can exit if the only threads left are PooledThreads // or other daemons. We don't want to rely on the // calling thread always being a daemon. + // Note that no exception is possible here since we + // are inside the doPrivileged block. + thread.setDaemon(true); - // Catch exceptions since setDaemon can cause a - // security exception to be thrown under netscape - // in the Applet mode - try { - thread.setDaemon(true); - } catch (Exception e) { - // REVISIT - need to do some logging here - } + wrapper.workerThreadCreated(thread, thread.getContextClassLoader()); thread.start(); + return null; } + /** - * This method will return the minimum number of threads maintained - * by the threadpool. - */ + * To be called from the workqueue to create worker threads when none + * available. + */ + void createWorkerThread() { + final String name = getName(); + synchronized (workQueue) { + try { + if (System.getSecurityManager() == null) { + createWorkerThreadHelper(name); + } else { + // If we get here, we need to create a thread. + AccessController.doPrivileged( + new PrivilegedAction() { + public Object run() { + return createWorkerThreadHelper(name); + } + } + ); + } + } catch (Throwable t) { + // Decrementing the count of current worker threads. + // But, it will be increased in the finally block. + decrementCurrentNumberOfThreads(); + wrapper.workerThreadCreationFailure(t); + } finally { + incrementCurrentNumberOfThreads(); + } + } + } + public int minimumNumberOfThreads() { return minWorkerThreads; } - /** - * This method will return the maximum number of threads in the - * threadpool at any point in time, for the life of the threadpool - */ public int maximumNumberOfThreads() { return maxWorkerThreads; } - /** - * This method will return the time in milliseconds when idle - * threads in the threadpool are removed. - */ public long idleTimeoutForThreads() { return inactivityTimeout; } - /** - * This method will return the total number of threads currently in the - * threadpool. This method returns a value which is not synchronized. - */ public int currentNumberOfThreads() { - synchronized (lock) { + synchronized (workQueue) { return currentThreadCount; } } - /** - * This method will return the number of available threads in the - * threadpool which are waiting for work. This method returns a - * value which is not synchronized. - */ + void decrementCurrentNumberOfThreads() { + synchronized (workQueue) { + currentThreadCount--; + } + } + + void incrementCurrentNumberOfThreads() { + synchronized (workQueue) { + currentThreadCount++; + } + } + public int numberOfAvailableThreads() { - synchronized (lock) { + synchronized (workQueue) { return availableWorkerThreads; } } - /** - * This method will return the number of busy threads in the threadpool - * This method returns a value which is not synchronized. - */ public int numberOfBusyThreads() { - synchronized (lock) { + synchronized (workQueue) { return (currentThreadCount - availableWorkerThreads); } } - /** - * This method returns the average elapsed time taken to complete a Work - * item in milliseconds. - */ public long averageWorkCompletionTime() { - synchronized (lock) { - return (totalTimeTaken / processedCount); + synchronized (workQueue) { + return (totalTimeTaken.get() / processedCount.get()); } } - /** - * This method returns the number of Work items processed by the threadpool - */ public long currentProcessedCount() { - synchronized (lock) { - return processedCount; + synchronized (workQueue) { + return processedCount.get(); } } @@ -357,15 +433,37 @@ public class ThreadPoolImpl implements ThreadPool private static synchronized int getUniqueThreadId() { - return ThreadPoolImpl.threadCounter++; + return ThreadPoolImpl.threadCounter.incrementAndGet(); + } + + /** + * This method will decrement the number of available threads + * in the threadpool which are waiting for work. Called from + * WorkQueueImpl.requestWork() + */ + void decrementNumberOfAvailableThreads() { + synchronized (workQueue) { + availableWorkerThreads--; + } + } + + /** + * This method will increment the number of available threads + * in the threadpool which are waiting for work. Called from + * WorkQueueImpl.requestWork() + */ + void incrementNumberOfAvailableThreads() { + synchronized (workQueue) { + availableWorkerThreads++; + } } - private class WorkerThread extends Thread + private class WorkerThread extends Thread implements Closeable { private Work currentWork; private int threadId = 0; // unique id for the thread - // thread pool this WorkerThread belongs too + private volatile boolean closeCalled = false; private String threadPoolName; // name seen by Thread.getName() private StringBuffer workerThreadName = new StringBuffer(); @@ -377,100 +475,61 @@ public class ThreadPoolImpl implements ThreadPool setName(composeWorkerThreadName(threadPoolName, "Idle")); } + public synchronized void close() { + closeCalled = true; + interrupt(); + } + + private void resetClassLoader() { + + } + + private void performWork() { + long start = System.currentTimeMillis(); + try { + currentWork.doWork(); + } catch (Throwable t) { + wrapper.workerThreadDoWorkThrowable(this, t); + } + long elapsedTime = System.currentTimeMillis() - start; + totalTimeTaken.addAndGet(elapsedTime); + processedCount.incrementAndGet(); + } + public void run() { - while (true) { - try { - - synchronized (lock) { - availableWorkerThreads++; - } - - // Get some work to do - currentWork = ((WorkQueueImpl)workQueue).requestWork(inactivityTimeout); - - synchronized (lock) { - availableWorkerThreads--; - // It is possible in notifyForAvailableWork that the - // check for availableWorkerThreads = 0 may return - // false, because the availableWorkerThreads has not been - // decremented to zero before the producer thread added - // work to the queue. This may create a deadlock, if the - // executing thread needs information which is in the work - // item queued in the workqueue, but has no thread to work - // on it since none was created because availableWorkerThreads = 0 - // returned false. - // The following code will ensure that a thread is always available - // in those situations - if ((availableWorkerThreads == 0) && - (workQueue.workItemsInQueue() > 0)) { - createWorkerThread(); - } - } - - // Set the thread name for debugging. - setName(composeWorkerThreadName(threadPoolName, - Integer.toString(this.threadId))); - - long start = System.currentTimeMillis(); - + try { + while (!closeCalled) { try { - // Do the work - currentWork.doWork(); + currentWork = ((WorkQueueImpl)workQueue).requestWork( + inactivityTimeout); + if (currentWork == null) + continue; + } catch (InterruptedException exc) { + wrapper.workQueueThreadInterrupted( exc, getName(), + Boolean.valueOf(closeCalled)); + + continue ; } catch (Throwable t) { - // Ignore all errors. - ; + wrapper.workerThreadThrowableFromRequestWork(this, t, + workQueue.getName()); + + continue; } - long end = System.currentTimeMillis(); - - - synchronized (lock) { - totalTimeTaken += (end - start); - processedCount++; - } + performWork(); // set currentWork to null so that the work item can be - // garbage collected + // garbage collected without waiting for the next work item. currentWork = null; - setName(composeWorkerThreadName(threadPoolName, "Idle")); - - } catch (TimeoutException e) { - // This thread timed out waiting for something to do. - - synchronized (lock) { - availableWorkerThreads--; - - // This should for both bounded and unbounded case - if (currentThreadCount > minWorkerThreads) { - currentThreadCount--; - // This thread can exit. - return; - } else { - // Go back to waiting on workQueue - continue; - } - } - } catch (InterruptedException ie) { - // InterruptedExceptions are - // caught here. Thus, threads can be forced out of - // requestWork and so they have to reacquire the lock. - // Other options include ignoring or - // letting this thread die. - // Ignoring for now. REVISIT - synchronized (lock) { - availableWorkerThreads--; - } - - } catch (Throwable e) { - - // Ignore any exceptions that currentWork.process - // accidently lets through, but let Errors pass. - // Add debugging output? REVISIT - synchronized (lock) { - availableWorkerThreads--; - } - + resetClassLoader(); + } + } catch (Throwable e) { + // This should not be possible + wrapper.workerThreadCaughtUnexpectedThrowable(this,e); + } finally { + synchronized (workersLock) { + workers.remove(this); } } } diff --git a/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/ThreadPoolManagerImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/ThreadPoolManagerImpl.java index 43573fda6ee..40214e816d6 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/ThreadPoolManagerImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/ThreadPoolManagerImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,6 +25,15 @@ package com.sun.corba.se.impl.orbutil.threadpool; +import java.io.IOException; + +import java.security.PrivilegedAction; +import java.security.AccessController; + +import java.util.concurrent.atomic.AtomicInteger; + +import com.sun.corba.se.spi.orb.ORB; + import com.sun.corba.se.spi.orbutil.threadpool.NoSuchThreadPoolException; import com.sun.corba.se.spi.orbutil.threadpool.ThreadPool; import com.sun.corba.se.spi.orbutil.threadpool.ThreadPoolManager; @@ -33,21 +42,102 @@ import com.sun.corba.se.spi.orbutil.threadpool.ThreadPoolChooser; import com.sun.corba.se.impl.orbutil.threadpool.ThreadPoolImpl; import com.sun.corba.se.impl.orbutil.ORBConstants; +import com.sun.corba.se.impl.logging.ORBUtilSystemException; +import com.sun.corba.se.impl.orbutil.ORBConstants; +import com.sun.corba.se.spi.logging.CORBALogDomains; + + public class ThreadPoolManagerImpl implements ThreadPoolManager { - private ThreadPool threadPool ; + private ThreadPool threadPool; + private ThreadGroup threadGroup; - public ThreadPoolManagerImpl( ThreadGroup tg ) - { - // Use unbounded threadpool in J2SE ORB - // ThreadPoolManager from s1as appserver code base can be set in the - // ORB. ThreadPools in the appserver are bounded. In that situation - // the ThreadPool in this ThreadPoolManager will have its threads - // die after the idle timeout. - // XXX Should there be cleanup when ORB.shutdown is called if the - // ORB owns the ThreadPool? - threadPool = new ThreadPoolImpl( tg, - ORBConstants.THREADPOOL_DEFAULT_NAME ) ; + private static final ORBUtilSystemException wrapper = + ORBUtilSystemException.get(CORBALogDomains.RPC_TRANSPORT); + + public ThreadPoolManagerImpl() { + threadGroup = getThreadGroup(); + threadPool = new ThreadPoolImpl(threadGroup, + ORBConstants.THREADPOOL_DEFAULT_NAME); + } + + private static AtomicInteger tgCount = new AtomicInteger(); + + + private ThreadGroup getThreadGroup() { + ThreadGroup tg; + + // See bugs 4916766 and 4936203 + // We intend to create new threads in a reliable thread group. + // This avoids problems if the application/applet + // creates a thread group, makes JavaIDL calls which create a new + // connection and ReaderThread, and then destroys the thread + // group. If our ReaderThreads were to be part of such destroyed thread + // group then it might get killed and cause other invoking threads + // sharing the same connection to get a non-restartable + // CommunicationFailure. We'd like to avoid that. + // + // Our solution is to create all of our threads in the highest thread + // group that we have access to, given our own security clearance. + // + try { + // try to get a thread group that's as high in the threadgroup + // parent-child hierarchy, as we can get to. + // this will prevent an ORB thread created during applet-init from + // being killed when an applet dies. + tg = AccessController.doPrivileged( + new PrivilegedAction() { + public ThreadGroup run() { + ThreadGroup tg = Thread.currentThread().getThreadGroup(); + ThreadGroup ptg = tg; + try { + while (ptg != null) { + tg = ptg; + ptg = tg.getParent(); + } + } catch (SecurityException se) { + // Discontinue going higher on a security exception. + } + return new ThreadGroup(tg, "ORB ThreadGroup " + tgCount.getAndIncrement()); + } + } + ); + } catch (SecurityException e) { + // something wrong, we go back to the original code + tg = Thread.currentThread().getThreadGroup(); + } + + return tg; + } + + public void close() { + try { + threadPool.close(); + } catch (IOException exc) { + wrapper.threadPoolCloseError(); + } + + try { + boolean isDestroyed = threadGroup.isDestroyed(); + int numThreads = threadGroup.activeCount(); + int numGroups = threadGroup.activeGroupCount(); + + if (isDestroyed) { + wrapper.threadGroupIsDestroyed(threadGroup); + } else { + if (numThreads > 0) + wrapper.threadGroupHasActiveThreadsInClose(threadGroup, numThreads); + + if (numGroups > 0) + wrapper.threadGroupHasSubGroupsInClose(threadGroup, numGroups); + + threadGroup.destroy(); + } + } catch (IllegalThreadStateException exc) { + wrapper.threadGroupDestroyFailed(exc, threadGroup); + } + + threadGroup = null; } /** diff --git a/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/WorkQueueImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/WorkQueueImpl.java index 022f2e0c93b..6e2320eeade 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/WorkQueueImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/orbutil/threadpool/WorkQueueImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -111,24 +111,23 @@ public class WorkQueueImpl implements WorkQueue return workqueueMonitoredObject; } - public void addWork(Work work) { - synchronized (this) { + public synchronized void addWork(Work work) { workItemsAdded++; work.setEnqueueTime(System.currentTimeMillis()); theWorkQueue.addLast(work); ((ThreadPoolImpl)workerThreadPool).notifyForAvailableWork(this); - } } - Work requestWork(long waitTime) - throws TimeoutException, InterruptedException + synchronized Work requestWork(long waitTime) throws TimeoutException, InterruptedException { Work workItem; - synchronized (this) { + ((ThreadPoolImpl)workerThreadPool).incrementNumberOfAvailableThreads(); + if (theWorkQueue.size() != 0) { workItem = (Work)theWorkQueue.removeFirst(); totalTimeInQueue += System.currentTimeMillis() - workItem.getEnqueueTime(); workItemsDequeued++; + ((ThreadPoolImpl)workerThreadPool).decrementNumberOfAvailableThreads(); return workItem; } @@ -145,6 +144,7 @@ public class WorkQueueImpl implements WorkQueue workItem = (Work)theWorkQueue.removeFirst(); totalTimeInQueue += System.currentTimeMillis() - workItem.getEnqueueTime(); workItemsDequeued++; + ((ThreadPoolImpl)workerThreadPool).decrementNumberOfAvailableThreads(); return workItem; } @@ -152,12 +152,13 @@ public class WorkQueueImpl implements WorkQueue } while (remainingWaitTime > 0); + ((ThreadPoolImpl)workerThreadPool).decrementNumberOfAvailableThreads(); throw new TimeoutException(); } catch (InterruptedException ie) { + ((ThreadPoolImpl)workerThreadPool).decrementNumberOfAvailableThreads(); throw ie; } - } } public void setThreadPool(ThreadPool workerThreadPool) { diff --git a/corba/src/share/classes/com/sun/corba/se/impl/protocol/CorbaMessageMediatorImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/protocol/CorbaMessageMediatorImpl.java index 038acdb132b..a5ee15ba763 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/protocol/CorbaMessageMediatorImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/protocol/CorbaMessageMediatorImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2004, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -1666,7 +1666,9 @@ public class CorbaMessageMediatorImpl ((CDRInputObject)messageMediator.getInputObject()).unmarshalHeader(); ORB orb = (ORB)messageMediator.getBroker(); - orb.checkShutdownState(); + synchronized (orb) { + orb.checkShutdownState(); + } ObjectKey okey = messageMediator.getObjectKey(); if (orb.subcontractDebugFlag) { diff --git a/corba/src/share/classes/com/sun/corba/se/impl/transport/SelectorImpl.java b/corba/src/share/classes/com/sun/corba/se/impl/transport/SelectorImpl.java index 1c60088a7a3..7bd98805ab7 100644 --- a/corba/src/share/classes/com/sun/corba/se/impl/transport/SelectorImpl.java +++ b/corba/src/share/classes/com/sun/corba/se/impl/transport/SelectorImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -69,8 +69,8 @@ public class SelectorImpl private HashMap listenerThreads; private Map readerThreads; private boolean selectorStarted; - private boolean closed; - private ORBUtilSystemException wrapper ; + private volatile boolean closed; + private ORBUtilSystemException wrapper; public SelectorImpl(ORB orb) diff --git a/corba/src/share/classes/com/sun/corba/se/spi/logging/data/ORBUtil.mc b/corba/src/share/classes/com/sun/corba/se/spi/logging/data/ORBUtil.mc index e82f724642d..da1ab4de948 100644 --- a/corba/src/share/classes/com/sun/corba/se/spi/logging/data/ORBUtil.mc +++ b/corba/src/share/classes/com/sun/corba/se/spi/logging/data/ORBUtil.mc @@ -1,6 +1,6 @@ ; -; Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. +; Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. ; DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ; ; This code is free software; you can redistribute it and/or modify it @@ -62,6 +62,7 @@ (IS_LOCAL_REQUIRES_STUB 43 WARNING "Call to StubAdapter.isLocal did not pass a stub") (REQUEST_REQUIRES_STUB 44 WARNING "Call to StubAdapter.request did not pass a stub") (BAD_ACTIVATE_TIE_CALL 45 WARNING "Call to StubAdapter.activateTie did not pass a valid Tie") + (IO_EXCEPTION_ON_CLOSE 46 FINE "Useless exception on call to Closeable.close()") ) (BAD_PARAM (NULL_PARAM 1 WARNING "Null parameter") @@ -291,7 +292,31 @@ (JAVA_STREAM_INIT_FAILED 95 WARNING "Java stream initialization failed") (DUPLICATE_ORB_VERSION_SERVICE_CONTEXT 96 WARNING "An ORBVersionServiceContext was already in the service context list") (DUPLICATE_SENDING_CONTEXT_SERVICE_CONTEXT 97 WARNING "A SendingContextServiceContext was already in the service context list") + (WORK_QUEUE_THREAD_INTERRUPTED 98 FINE "Worker Thread from thread pool {0} was interrupted: closeCalled is {1}.") + (WORKER_THREAD_CREATED + 104 FINE "Worker thread {0} has been created with ClassLoader {1}") + (WORKER_THREAD_THROWABLE_FROM_REQUEST_WORK + 109 FINE "Worker thread {0} caught throwable {1} when requesting work from work queue {2}.") + (WORKER_THREAD_NOT_NEEDED + 110 FINE "Worker thread {0} will exit; current thread count, {1}, greater than minunum worker threads needed, {2}.") + (WORKER_THREAD_DO_WORK_THROWABLE + 111 FINE "Worker thread {0} caught throwable {1} while executing work.") + (WORKER_THREAD_CAUGHT_UNEXPECTED_THROWABLE + 112 WARNING "Worker thread {0} caught unexpected throwable {1}.") + (WORKER_THREAD_CREATION_FAILURE + 113 SEVERE "Worker thread creation failure; cause {0}.") + (WORKER_THREAD_SET_NAME_FAILURE + 114 WARNING "Unable to set worker thread {0} name to {1}; cause {2}.") + (WORK_QUEUE_REQUEST_WORK_NO_WORK_FOUND + 116 WARNING "Ignoring unexpected {0} when retrieving of work from work queue, {1}.") + (THREAD_POOL_CLOSE_ERROR 126 WARNING "Error in closing ThreadPool") + (THREAD_GROUP_IS_DESTROYED 127 WARNING "ThreadGroup {0} is already destroyed: can't destroy it") + (THREAD_GROUP_HAS_ACTIVE_THREADS_IN_CLOSE 128 WARNING "ThreadGroup {0} has {1} active threads: destroy may cause exception") + (THREAD_GROUP_HAS_SUB_GROUPS_IN_CLOSE 129 WARNING "ThreadGroup {0} has {1} sub-thread groups: destroy may cause exception") + (THREAD_GROUP_DESTROY_FAILED 130 WARNING "ThreadGroup {0} could not be destroyed") + (INTERRUPTED_JOIN_CALL_WHILE_CLOSING_THREAD_POOL 131 WARNING "Join was interrupted on thread {0} while closing ThreadPool {1}") ) + (MARSHAL (CHUNK_OVERFLOW 1 WARNING "Data read past end of chunk without closing the chunk") (UNEXPECTED_EOF 2 WARNING "Grow buffer strategy called underflow handler") diff --git a/corba/src/share/classes/com/sun/corba/se/spi/monitoring/MonitoringManager.java b/corba/src/share/classes/com/sun/corba/se/spi/monitoring/MonitoringManager.java index 2f5ce1e5343..1a7e6b61f80 100644 --- a/corba/src/share/classes/com/sun/corba/se/spi/monitoring/MonitoringManager.java +++ b/corba/src/share/classes/com/sun/corba/se/spi/monitoring/MonitoringManager.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,6 +24,7 @@ */ package com.sun.corba.se.spi.monitoring; +import java.io.Closeable; import com.sun.corba.se.spi.orb.ORB; import com.sun.corba.se.spi.monitoring.MonitoredObject; import java.util.*; @@ -39,7 +40,7 @@ import java.util.*; * @author Hemanth Puttaswamy *

*/ -public interface MonitoringManager { +public interface MonitoringManager extends Closeable { /////////////////////////////////////// // operations diff --git a/corba/src/share/classes/com/sun/corba/se/spi/monitoring/MonitoringManagerFactory.java b/corba/src/share/classes/com/sun/corba/se/spi/monitoring/MonitoringManagerFactory.java index a23dfc3d0d6..88b6238ff53 100644 --- a/corba/src/share/classes/com/sun/corba/se/spi/monitoring/MonitoringManagerFactory.java +++ b/corba/src/share/classes/com/sun/corba/se/spi/monitoring/MonitoringManagerFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -40,4 +40,6 @@ public interface MonitoringManagerFactory { */ MonitoringManager createMonitoringManager( String nameOfTheRoot, String description ); + + void remove(String nameOfTheRoot); } diff --git a/corba/src/share/classes/com/sun/corba/se/spi/orb/ORB.java b/corba/src/share/classes/com/sun/corba/se/spi/orb/ORB.java index 0fad97f78ba..22b89e73f22 100644 --- a/corba/src/share/classes/com/sun/corba/se/spi/orb/ORB.java +++ b/corba/src/share/classes/com/sun/corba/se/spi/orb/ORB.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2004, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -171,7 +171,7 @@ public abstract class ORB extends com.sun.corba.se.org.omg.CORBA.ORB private static Map staticWrapperMap = new ConcurrentHashMap(); - private MonitoringManager monitoringManager; + protected MonitoringManager monitoringManager; // There is only one instance of the PresentationManager // that is shared between all ORBs. This is necessary @@ -226,6 +226,14 @@ public abstract class ORB extends com.sun.corba.se.org.omg.CORBA.ORB globalPM.setStubFactoryFactory( true, dynamicStubFactoryFactory ) ; } + public void destroy() { + wrapper = null; + omgWrapper = null; + typeCodeMap = null; + primitiveTypeCodeConstants = null; + byteBufferPool = null; + } + /** Get the single instance of the PresentationManager */ public static PresentationManager getPresentationManager() @@ -302,6 +310,9 @@ public abstract class ORB extends com.sun.corba.se.org.omg.CORBA.ORB // Typecode support: needed in both ORBImpl and ORBSingleton public TypeCodeImpl get_primitive_tc(int kind) { + synchronized (this) { + checkShutdownState(); + } try { return primitiveTypeCodeConstants[kind] ; } catch (Throwable t) { @@ -311,15 +322,20 @@ public abstract class ORB extends com.sun.corba.se.org.omg.CORBA.ORB public synchronized void setTypeCode(String id, TypeCodeImpl code) { + checkShutdownState(); typeCodeMap.put(id, code); } public synchronized TypeCodeImpl getTypeCode(String id) { + checkShutdownState(); return (TypeCodeImpl)typeCodeMap.get(id); } public MonitoringManager getMonitoringManager( ) { + synchronized (this) { + checkShutdownState(); + } return monitoringManager; } @@ -434,6 +450,9 @@ public abstract class ORB extends com.sun.corba.se.org.omg.CORBA.ORB */ public Logger getLogger( String domain ) { + synchronized (this) { + checkShutdownState(); + } ORBData odata = getORBData() ; // Determine the correct ORBId. There are 3 cases: @@ -510,6 +529,9 @@ public abstract class ORB extends com.sun.corba.se.org.omg.CORBA.ORB // This method must also be inherited by both ORB and ORBSingleton. public ByteBufferPool getByteBufferPool() { + synchronized (this) { + checkShutdownState(); + } if (byteBufferPool == null) byteBufferPool = new ByteBufferPoolImpl(this); diff --git a/corba/src/share/classes/com/sun/corba/se/spi/orbutil/threadpool/ThreadPool.java b/corba/src/share/classes/com/sun/corba/se/spi/orbutil/threadpool/ThreadPool.java index a4cc2b6a559..dd61ff22032 100644 --- a/corba/src/share/classes/com/sun/corba/se/spi/orbutil/threadpool/ThreadPool.java +++ b/corba/src/share/classes/com/sun/corba/se/spi/orbutil/threadpool/ThreadPool.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,9 +25,15 @@ package com.sun.corba.se.spi.orbutil.threadpool; +import java.io.Closeable; -public interface ThreadPool +/** This interface defines a thread pool execution service. The ORB uses this + * interface, which preceeds the JDK 5 ExecutorService. Note that the close + * method must be called in order to reclaim thread resources. + */ +public interface ThreadPool extends Closeable { + /** * This method will return any instance of the WorkQueue. If the ThreadPool * instance only services one WorkQueue then that WorkQueue instance will diff --git a/corba/src/share/classes/com/sun/corba/se/spi/orbutil/threadpool/ThreadPoolManager.java b/corba/src/share/classes/com/sun/corba/se/spi/orbutil/threadpool/ThreadPoolManager.java index 9225a90a598..14875f6d20a 100644 --- a/corba/src/share/classes/com/sun/corba/se/spi/orbutil/threadpool/ThreadPoolManager.java +++ b/corba/src/share/classes/com/sun/corba/se/spi/orbutil/threadpool/ThreadPoolManager.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,7 +25,9 @@ package com.sun.corba.se.spi.orbutil.threadpool; -public interface ThreadPoolManager +import java.io.Closeable; + +public interface ThreadPoolManager extends Closeable { /** * This method will return an instance of the threadpool given a threadpoolId, diff --git a/corba/src/share/classes/com/sun/corba/se/spi/protocol/PIHandler.java b/corba/src/share/classes/com/sun/corba/se/spi/protocol/PIHandler.java index b59062a43be..ac25b79510a 100644 --- a/corba/src/share/classes/com/sun/corba/se/spi/protocol/PIHandler.java +++ b/corba/src/share/classes/com/sun/corba/se/spi/protocol/PIHandler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,6 +25,8 @@ package com.sun.corba.se.spi.protocol; +import java.io.Closeable; + import org.omg.PortableInterceptor.ObjectReferenceTemplate ; import org.omg.PortableInterceptor.Interceptor ; import org.omg.PortableInterceptor.Current ; @@ -51,7 +53,7 @@ import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage ; /** This interface defines the PI interface that is used to interface the rest of the * ORB to the PI implementation. */ -public interface PIHandler { +public interface PIHandler extends Closeable { /** Complete the initialization of the PIHandler. This will execute the methods * on the ORBInitializers, if any are defined. This must be done here so that * the ORB can obtain the PIHandler BEFORE the ORBInitializers run, since they diff --git a/corba/src/share/classes/com/sun/corba/se/spi/protocol/RequestDispatcherRegistry.java b/corba/src/share/classes/com/sun/corba/se/spi/protocol/RequestDispatcherRegistry.java index e4fc9ae4265..f5aae43731d 100644 --- a/corba/src/share/classes/com/sun/corba/se/spi/protocol/RequestDispatcherRegistry.java +++ b/corba/src/share/classes/com/sun/corba/se/spi/protocol/RequestDispatcherRegistry.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -37,33 +37,59 @@ import com.sun.corba.se.spi.oa.ObjectAdapterFactory ; * This is a registry of all subcontract ID dependent objects. This includes: * LocalClientRequestDispatcherFactory, ClientRequestDispatcher, ServerRequestDispatcher, and * ObjectAdapterFactory. - * XXX Should the registerXXX methods take an scid or not? I think we - * want to do this so that the same instance can be shared across multiple - * scids (and this is already true for ObjectAdapterFactory and LocalClientRequestDispatcherFactory), - * but this will require some changes for ClientRequestDispatcher and ServerRequestDispatcher. */ public interface RequestDispatcherRegistry { - // XXX needs javadocs! + /** Register a ClientRequestDispatcher for a particular subcontract ID. + * The subcontract ID appears in the ObjectKey of an object reference, and is used + * to control how a remote method invocation is processed by the ORB for a + * particular kind of object reference. + */ void registerClientRequestDispatcher( ClientRequestDispatcher csc, int scid) ; + /** Get the ClientRequestDispatcher for subcontract ID scid. + */ ClientRequestDispatcher getClientRequestDispatcher( int scid ) ; + /** Register a LocalClientRequestDispatcher for a particular subcontract ID. + * The subcontract ID appears in the ObjectKey of an object reference, and is used + * to control how a particular kind of colocated request is processed. + */ void registerLocalClientRequestDispatcherFactory( LocalClientRequestDispatcherFactory csc, int scid) ; + /** Get the LocalClientRequestDispatcher for subcontract ID scid. + */ LocalClientRequestDispatcherFactory getLocalClientRequestDispatcherFactory( int scid ) ; + /** Register a CorbaServerRequestDispatcher for a particular subcontract ID. + * The subcontract ID appears in the ObjectKey of an object reference, and is used + * to control how a particular kind of request is processed when received by the ORB. + */ void registerServerRequestDispatcher( CorbaServerRequestDispatcher ssc, int scid) ; + /** Get the CorbaServerRequestDispatcher for subcontract ID scid. + */ CorbaServerRequestDispatcher getServerRequestDispatcher(int scid) ; + /** Register a CorbaServerRequestDispatcher for handling an explicit object key name. + * This is used for non-standard invocations such as INS and the bootstrap name service. + */ void registerServerRequestDispatcher( CorbaServerRequestDispatcher ssc, String name ) ; + /** Get the CorbaServerRequestDispatcher for a particular object key. + */ CorbaServerRequestDispatcher getServerRequestDispatcher( String name ) ; + /** Register an ObjectAdapterFactory for a particular subcontract ID. + * This controls how Object references are created and managed. + */ void registerObjectAdapterFactory( ObjectAdapterFactory oaf, int scid) ; + /** Get the ObjectAdapterFactory for a particular subcontract ID scid. + */ ObjectAdapterFactory getObjectAdapterFactory( int scid ) ; - Set getObjectAdapterFactories() ; + /** Return the set of all ObjectAdapterFactory instances that are registered. + */ + Set getObjectAdapterFactories(); } From 39dfe6d047139a4bcd46199e195b010bea4b546b Mon Sep 17 00:00:00 2001 From: Staffan Larsen Date: Thu, 28 Jun 2012 11:37:28 +0200 Subject: [PATCH 032/160] 7178703: Fix handling of quoted arguments and better error messages in dcmd Reviewed-by: coleenp, mgronlun, rbackman --- hotspot/src/share/vm/prims/whitebox.cpp | 3 ++ .../share/vm/services/diagnosticCommand.hpp | 12 +++---- .../share/vm/services/diagnosticFramework.cpp | 35 +++++++++++++++---- .../share/vm/services/diagnosticFramework.hpp | 12 ++++++- hotspot/test/serviceability/ParserTest.java | 28 +++++++++++++++ 5 files changed, 77 insertions(+), 13 deletions(-) diff --git a/hotspot/src/share/vm/prims/whitebox.cpp b/hotspot/src/share/vm/prims/whitebox.cpp index eadc7df523f..e93b9104b44 100644 --- a/hotspot/src/share/vm/prims/whitebox.cpp +++ b/hotspot/src/share/vm/prims/whitebox.cpp @@ -113,6 +113,9 @@ const char* WhiteBox::lookup_jstring(const char* field_name, oop object) { int offset = offset_for_field(field_name, object, vmSymbols::string_signature()); oop string = object->obj_field(offset); + if (string == NULL) { + return NULL; + } const char* ret = java_lang_String::as_utf8_string(string); return ret; } diff --git a/hotspot/src/share/vm/services/diagnosticCommand.hpp b/hotspot/src/share/vm/services/diagnosticCommand.hpp index d5c5cd172aa..cf4134f4123 100644 --- a/hotspot/src/share/vm/services/diagnosticCommand.hpp +++ b/hotspot/src/share/vm/services/diagnosticCommand.hpp @@ -48,7 +48,7 @@ public: "With no argument this will show a list of available commands. " "'help all' will show help for all commands."; } - static const char* impact() { return "Low: "; } + static const char* impact() { return "Low"; } static int num_arguments(); virtual void execute(TRAPS); }; @@ -60,7 +60,7 @@ public: static const char* description() { return "Print JVM version information."; } - static const char* impact() { return "Low: "; } + static const char* impact() { return "Low"; } static int num_arguments() { return 0; } virtual void execute(TRAPS); }; @@ -72,7 +72,7 @@ public: static const char* description() { return "Print the command line used to start this VM instance."; } - static const char* impact() { return "Low: "; } + static const char* impact() { return "Low"; } static int num_arguments() { return 0; } virtual void execute(TRAPS) { Arguments::print_on(_output); @@ -88,7 +88,7 @@ public: return "Print system properties."; } static const char* impact() { - return "Low: "; + return "Low"; } static int num_arguments() { return 0; } virtual void execute(TRAPS); @@ -105,7 +105,7 @@ public: return "Print VM flag options and their current values."; } static const char* impact() { - return "Low: "; + return "Low"; } static int num_arguments(); virtual void execute(TRAPS); @@ -121,7 +121,7 @@ public: return "Print VM uptime."; } static const char* impact() { - return "Low: "; + return "Low"; } static int num_arguments(); virtual void execute(TRAPS); diff --git a/hotspot/src/share/vm/services/diagnosticFramework.cpp b/hotspot/src/share/vm/services/diagnosticFramework.cpp index 73e9bdc540c..2ae7866f6c6 100644 --- a/hotspot/src/share/vm/services/diagnosticFramework.cpp +++ b/hotspot/src/share/vm/services/diagnosticFramework.cpp @@ -75,11 +75,13 @@ bool DCmdArgIter::next(TRAPS) { } // extracting first item, argument or option name _key_addr = &_buffer[_cursor]; + bool arg_had_quotes = false; while (_cursor <= _len - 1 && _buffer[_cursor] != '=' && _buffer[_cursor] != _delim) { // argument can be surrounded by single or double quotes if (_buffer[_cursor] == '\"' || _buffer[_cursor] == '\'') { _key_addr++; char quote = _buffer[_cursor]; + arg_had_quotes = true; while (_cursor < _len - 1) { _cursor++; if (_buffer[_cursor] == quote && _buffer[_cursor - 1] != '\\') { @@ -95,16 +97,22 @@ bool DCmdArgIter::next(TRAPS) { _cursor++; } _key_len = &_buffer[_cursor] - _key_addr; + if (arg_had_quotes) { + // if the argument was quoted, we need to step past the last quote here + _cursor++; + } // check if the argument has the = format if (_cursor <= _len -1 && _buffer[_cursor] == '=') { _cursor++; _value_addr = &_buffer[_cursor]; + bool value_had_quotes = false; // extract the value while (_cursor <= _len - 1 && _buffer[_cursor] != _delim) { // value can be surrounded by simple or double quotes if (_buffer[_cursor] == '\"' || _buffer[_cursor] == '\'') { _value_addr++; char quote = _buffer[_cursor]; + value_had_quotes = true; while (_cursor < _len - 1) { _cursor++; if (_buffer[_cursor] == quote && _buffer[_cursor - 1] != '\\') { @@ -120,6 +128,10 @@ bool DCmdArgIter::next(TRAPS) { _cursor++; } _value_len = &_buffer[_cursor] - _value_addr; + if (value_had_quotes) { + // if the value was quoted, we need to step past the last quote here + _cursor++; + } } else { _value_addr = NULL; _value_len = 0; @@ -185,8 +197,17 @@ void DCmdParser::parse(CmdLine* line, char delim, TRAPS) { arg->read_value(iter.key_addr(), iter.key_length(), CHECK); next_argument = next_argument->next(); } else { - THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), - "Unknown argument in diagnostic command"); + const size_t buflen = 120; + const size_t argbuflen = 30; + char buf[buflen]; + char argbuf[argbuflen]; + size_t len = MIN2(iter.key_length(), argbuflen - 1); + + strncpy(argbuf, iter.key_addr(), len); + argbuf[len] = '\0'; + jio_snprintf(buf, buflen - 1, "Unknown argument '%s' in diagnostic command.", argbuf); + + THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), buf); } } cont = iter.next(CHECK); @@ -207,19 +228,21 @@ GenDCmdArgument* DCmdParser::lookup_dcmd_option(const char* name, size_t len) { } void DCmdParser::check(TRAPS) { + const size_t buflen = 256; + char buf[buflen]; GenDCmdArgument* arg = _arguments_list; while (arg != NULL) { if (arg->is_mandatory() && !arg->has_value()) { - THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), - "Missing argument for diagnostic command"); + jio_snprintf(buf, buflen - 1, "The argument '%s' is mandatory.", arg->name()); + THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), buf); } arg = arg->next(); } arg = _options; while (arg != NULL) { if (arg->is_mandatory() && !arg->has_value()) { - THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), - "Missing option for diagnostic command"); + jio_snprintf(buf, buflen - 1, "The option '%s' is mandatory.", arg->name()); + THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), buf); } arg = arg->next(); } diff --git a/hotspot/src/share/vm/services/diagnosticFramework.hpp b/hotspot/src/share/vm/services/diagnosticFramework.hpp index f6863e4775e..08b24e07f33 100644 --- a/hotspot/src/share/vm/services/diagnosticFramework.hpp +++ b/hotspot/src/share/vm/services/diagnosticFramework.hpp @@ -238,6 +238,16 @@ public: static const char* name() { return "No Name";} static const char* description() { return "No Help";} static const char* disabled_message() { return "Diagnostic command currently disabled"; } + // The impact() method returns a description of the intrusiveness of the diagnostic + // command on the Java Virtual Machine behavior. The rational for this method is that some + // diagnostic commands can seriously disrupt the behavior of the Java Virtual Machine + // (for instance a Thread Dump for an application with several tens of thousands of threads, + // or a Head Dump with a 40GB+ heap size) and other diagnostic commands have no serious + // impact on the JVM (for instance, getting the command line arguments or the JVM version). + // The recommended format for the description is : [longer description], + // where the impact level is selected among this list: {Low, Medium, High}. The optional + // longer description can provide more specific details like the fact that Thread Dump + // impact depends on the heap size. static const char* impact() { return "Low: No impact"; } static int num_arguments() { return 0; } outputStream* output() { return _output; } @@ -250,7 +260,7 @@ public: bool has_arg = iter.next(CHECK); if (has_arg) { THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), - "Unknown argument in diagnostic command"); + "The argument list of this diagnostic command should be empty."); } } virtual void execute(TRAPS) { } diff --git a/hotspot/test/serviceability/ParserTest.java b/hotspot/test/serviceability/ParserTest.java index b031b4de017..b70d235260d 100644 --- a/hotspot/test/serviceability/ParserTest.java +++ b/hotspot/test/serviceability/ParserTest.java @@ -20,6 +20,7 @@ public class ParserTest { testNanoTime(); testJLong(); testBool(); + testQuotes(); testMemorySize(); } @@ -95,6 +96,33 @@ public class ParserTest { parse(name, "false", "", args); } + public void testQuotes() throws Exception { + String name = "name"; + DiagnosticCommand arg1 = new DiagnosticCommand(name, + "desc", DiagnosticArgumentType.STRING, + false, null); + DiagnosticCommand arg2 = new DiagnosticCommand("arg", + "desc", DiagnosticArgumentType.STRING, + false, null); + DiagnosticCommand[] args = {arg1, arg2}; + + // try with a quoted value + parse(name, "Recording 1", name + "=\"Recording 1\"", args); + // try with a quoted argument + parse(name, "myrec", "\"" + name + "\"" + "=myrec", args); + // try with both a quoted value and a quoted argument + parse(name, "Recording 1", "\"" + name + "\"" + "=\"Recording 1\"", args); + + // now the same thing but with other arguments after + + // try with a quoted value + parse(name, "Recording 1", name + "=\"Recording 1\",arg=value", args); + // try with a quoted argument + parse(name, "myrec", "\"" + name + "\"" + "=myrec,arg=value", args); + // try with both a quoted value and a quoted argument + parse(name, "Recording 1", "\"" + name + "\"" + "=\"Recording 1\",arg=value", args); + } + public void testMemorySize() throws Exception { String name = "name"; String defaultValue = "1024"; From 86e45f8339f82447c55bf30f174dac186a93789c Mon Sep 17 00:00:00 2001 From: Pavel Porvatov Date: Thu, 28 Jun 2012 14:05:06 +0400 Subject: [PATCH 033/160] 7169111: Unreadable menu bar with Ambiance theme in GTK L&F Reviewed-by: kizune --- .../classes/com/sun/java/swing/plaf/gtk/GTKLookAndFeel.java | 3 ++- .../com/sun/java/swing/plaf/gtk/GTKStyleFactory.java | 6 ++++++ .../share/classes/javax/swing/plaf/synth/SynthMenuUI.java | 3 ++- 3 files changed, 10 insertions(+), 2 deletions(-) diff --git a/jdk/src/share/classes/com/sun/java/swing/plaf/gtk/GTKLookAndFeel.java b/jdk/src/share/classes/com/sun/java/swing/plaf/gtk/GTKLookAndFeel.java index fcfb1783605..6fb52a4cd4a 100644 --- a/jdk/src/share/classes/com/sun/java/swing/plaf/gtk/GTKLookAndFeel.java +++ b/jdk/src/share/classes/com/sun/java/swing/plaf/gtk/GTKLookAndFeel.java @@ -796,9 +796,10 @@ public class GTKLookAndFeel extends SynthLookAndFeel { "Menu.margin", zeroInsets, "Menu.cancelMode", "hideMenuTree", "Menu.alignAcceleratorText", Boolean.FALSE, + "Menu.useMenuBarForTopLevelMenus", Boolean.TRUE, - "MenuBar.windowBindings", new Object[] { + "MenuBar.windowBindings", new Object[] { "F10", "takeFocus" }, "MenuBar.font", new FontLazyValue(Region.MENU_BAR), diff --git a/jdk/src/share/classes/com/sun/java/swing/plaf/gtk/GTKStyleFactory.java b/jdk/src/share/classes/com/sun/java/swing/plaf/gtk/GTKStyleFactory.java index 5c28db4e23d..cfc2fc3ccb3 100644 --- a/jdk/src/share/classes/com/sun/java/swing/plaf/gtk/GTKStyleFactory.java +++ b/jdk/src/share/classes/com/sun/java/swing/plaf/gtk/GTKStyleFactory.java @@ -92,7 +92,13 @@ class GTKStyleFactory extends SynthStyleFactory { boolean defaultCapable = btn.isDefaultCapable(); key = new ComplexKey(wt, toolButton, defaultCapable); } + } else if (id == Region.MENU) { + if (c instanceof JMenu && ((JMenu) c).isTopLevelMenu() && + UIManager.getBoolean("Menu.useMenuBarForTopLevelMenus")) { + wt = WidgetType.MENU_BAR; + } } + if (key == null) { // Otherwise, just use the WidgetType as the key. key = wt; diff --git a/jdk/src/share/classes/javax/swing/plaf/synth/SynthMenuUI.java b/jdk/src/share/classes/javax/swing/plaf/synth/SynthMenuUI.java index 6f309861ba5..a55aa715fe3 100644 --- a/jdk/src/share/classes/javax/swing/plaf/synth/SynthMenuUI.java +++ b/jdk/src/share/classes/javax/swing/plaf/synth/SynthMenuUI.java @@ -299,7 +299,8 @@ public class SynthMenuUI extends BasicMenuUI */ @Override public void propertyChange(PropertyChangeEvent e) { - if (SynthLookAndFeel.shouldUpdateStyle(e)) { + if (SynthLookAndFeel.shouldUpdateStyle(e) || + (e.getPropertyName().equals("ancestor") && UIManager.getBoolean("Menu.useMenuBarForTopLevelMenus"))) { updateStyle((JMenu)e.getSource()); } } From 4f081bf0d0915a166394dbdf80f87eccf89e453d Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 28 Jun 2012 09:32:26 -0700 Subject: [PATCH 034/160] Added tag jdk8-b45 for changeset 07ad352154a8 --- .hgtags-top-repo | 1 + 1 file changed, 1 insertion(+) diff --git a/.hgtags-top-repo b/.hgtags-top-repo index 44ad17af265..dc560c35729 100644 --- a/.hgtags-top-repo +++ b/.hgtags-top-repo @@ -166,3 +166,4 @@ a2b2d435f1d275fa8010774c653197c64e326d3a jdk8-b40 1ce5dc16416611c58b7480ca67a2eee5153498a6 jdk8-b42 661c9aae602bbd9766d12590800c90f1edd1d8dd jdk8-b43 e4f81a817447c3a4f6868f083c81c2fb1b15d44c jdk8-b44 +633f2378c904c92bb922a6e19e9f62fe8eac14af jdk8-b45 From c6fbe129bfead4cb2f74cdb91c1f2dce32cfec69 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 28 Jun 2012 09:32:28 -0700 Subject: [PATCH 035/160] Added tag jdk8-b45 for changeset 27f3d36a24d5 --- corba/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/corba/.hgtags b/corba/.hgtags index fa937dfa1e9..d145e022f27 100644 --- a/corba/.hgtags +++ b/corba/.hgtags @@ -166,3 +166,4 @@ b8cbfb31139f820e5e094ba71449e58159fbe22e jdk8-b38 79cc42c9c71bbd6630ede681642e98f5e4a841fa jdk8-b42 cd879aff5d3cc1f58829aab3116880aa19525b78 jdk8-b43 439d9bf8e4ff204cc89c9974c1515a508b2cc6ff jdk8-b44 +747dad9e9d37d244a5c765a1afe9194f7ddae118 jdk8-b45 From 405208abe797a139ad169fbd8d796caae6f83945 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 28 Jun 2012 09:32:35 -0700 Subject: [PATCH 036/160] Added tag jdk8-b45 for changeset 8ff1c75f204a --- hotspot/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/hotspot/.hgtags b/hotspot/.hgtags index 4a7f07f305b..b1ba8c68fa9 100644 --- a/hotspot/.hgtags +++ b/hotspot/.hgtags @@ -256,3 +256,4 @@ bd568544be7fcd12a9327e6c448592198d57b043 hs24-b13 e77b8e0ed1f84e3e268239e276c7ab64fa573baa jdk8-b43 5ba29a1db46ecb80a321ca873adb56a3fe6ad320 hs24-b14 831e5c76a20af18f3c08c5a95ed31be0e128a010 jdk8-b44 +9d5f20961bc5846fa8d098d534effafbbdae0a58 jdk8-b45 From 6af718bb7ff3c7845af315e2fd76c07c9287f825 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 28 Jun 2012 09:32:52 -0700 Subject: [PATCH 037/160] Added tag jdk8-b45 for changeset a21c904ee700 --- jaxp/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/jaxp/.hgtags b/jaxp/.hgtags index 72b505f142b..93f3d6587f1 100644 --- a/jaxp/.hgtags +++ b/jaxp/.hgtags @@ -166,3 +166,4 @@ f95fdbe525c88ef0d57dc1390be6582a8af5e07c jdk8-b39 39ee03c1602155ff02e5feb6cd44869452f24cf7 jdk8-b42 eff4ece9c8bc43b3ce2b3758574c4c20147f0689 jdk8-b43 0b3f3a4ce13930430b32b616a717dfc7fe385b28 jdk8-b44 +57476f66e13c55eea2f2fe2b858369a4c64b9936 jdk8-b45 From f69560f821e6ed35974f87310dc41416e9ce5d5b Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 28 Jun 2012 09:32:55 -0700 Subject: [PATCH 038/160] Added tag jdk8-b45 for changeset 466ddaf02777 --- jaxws/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/jaxws/.hgtags b/jaxws/.hgtags index 43d26862ac0..0e5917c7e71 100644 --- a/jaxws/.hgtags +++ b/jaxws/.hgtags @@ -166,3 +166,4 @@ f2072b164b0519227833a2994f78e3988ee67827 jdk8-b41 1f20f37818a91b66eaeba268d0b785718598ee0e jdk8-b42 f00c12994562c2f68d348a7c3e829374a89294e2 jdk8-b43 f6a417540ef124c9b4123d07da5e26f2ab909949 jdk8-b44 +e80ac58b5ba904f24e125c742c30d0d740f05f86 jdk8-b45 From 0a806c8aa76486457817298756dc71ea67a098ea Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 28 Jun 2012 09:33:05 -0700 Subject: [PATCH 039/160] Added tag jdk8-b45 for changeset 82534e9c5cc7 --- jdk/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/jdk/.hgtags b/jdk/.hgtags index 3635c35c55e..ebc63ad4733 100644 --- a/jdk/.hgtags +++ b/jdk/.hgtags @@ -166,3 +166,4 @@ b88fc3359dc7edabfa8a228855d8cebf8843c055 jdk8-b40 cf5c1f6fbc5ba14163fe0ef8eb8601b33f951372 jdk8-b42 b3246687c3695dff6f461bb407f9db88f7d072e7 jdk8-b43 db471a7af03168e4441c245b1d9976f720a7cb77 jdk8-b44 +b92353a01aa049bc508fc56f0347d5934b7c4390 jdk8-b45 From efdeeb14af1cfce82bc9c9069af935feee521e76 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 28 Jun 2012 09:33:16 -0700 Subject: [PATCH 040/160] Added tag jdk8-b45 for changeset b34aca67a4db --- langtools/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/langtools/.hgtags b/langtools/.hgtags index cee894b8d9b..383d61393a4 100644 --- a/langtools/.hgtags +++ b/langtools/.hgtags @@ -166,3 +166,4 @@ a9f547c218d957306dfc0cdd710be041bb62a555 jdk8-b39 02c5a3575539e737a1855b31287654e843edd6da jdk8-b42 f8c64d835b2806293b8e924b44f0e32b20657ed3 jdk8-b43 59cbead12ff46dbb397120bd26635bcd7d41ff21 jdk8-b44 +e111e4587ccada8eb93f72e834e378c76256f4b7 jdk8-b45 From a39b17624a65f5cff09a88a5bcddbf97e36cc9c3 Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Thu, 28 Jun 2012 17:03:16 -0400 Subject: [PATCH 041/160] 6995781: Native Memory Tracking (Phase 1) 7151532: DCmd for hotspot native memory tracking Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd Reviewed-by: acorn, coleenp, fparain --- .../jvm/hotspot/utilities/BasicHashtable.java | 4 +- .../utilities/BasicHashtableEntry.java | 2 +- .../sun/jvm/hotspot/utilities/Hashtable.java | 2 +- .../hotspot/utilities/HashtableBucket.java | 2 +- .../jvm/hotspot/utilities/HashtableEntry.java | 2 +- hotspot/make/bsd/makefiles/jvmg.make | 4 +- hotspot/make/linux/makefiles/jvmg.make | 6 +- hotspot/make/solaris/makefiles/jvmg.make | 3 +- hotspot/make/windows/makefiles/debug.make | 3 +- hotspot/src/os/bsd/vm/os_bsd.cpp | 30 +- hotspot/src/os/bsd/vm/os_bsd.hpp | 4 +- hotspot/src/os/bsd/vm/os_bsd.inline.hpp | 2 +- hotspot/src/os/bsd/vm/perfMemory_bsd.cpp | 66 +- hotspot/src/os/linux/vm/os_linux.cpp | 40 +- hotspot/src/os/linux/vm/os_linux.hpp | 4 +- hotspot/src/os/linux/vm/os_linux.inline.hpp | 2 +- hotspot/src/os/linux/vm/perfMemory_linux.cpp | 66 +- hotspot/src/os/posix/vm/os_posix.cpp | 18 + hotspot/src/os/solaris/dtrace/hs_private.d | 1 - hotspot/src/os/solaris/vm/os_solaris.cpp | 60 +- hotspot/src/os/solaris/vm/os_solaris.hpp | 4 +- .../src/os/solaris/vm/os_solaris.inline.hpp | 2 +- .../src/os/solaris/vm/perfMemory_solaris.cpp | 66 +- hotspot/src/os/windows/vm/os_windows.cpp | 117 ++-- hotspot/src/os/windows/vm/os_windows.hpp | 8 +- .../src/os/windows/vm/perfMemory_windows.cpp | 106 +-- hotspot/src/share/vm/asm/codeBuffer.cpp | 8 +- hotspot/src/share/vm/c1/c1_CFGPrinter.cpp | 4 +- hotspot/src/share/vm/c1/c1_Compiler.cpp | 2 +- hotspot/src/share/vm/c1/c1_LinearScan.cpp | 12 +- hotspot/src/share/vm/ci/ciObjectFactory.cpp | 2 +- .../share/vm/classfile/classFileParser.cpp | 2 +- .../src/share/vm/classfile/classLoader.cpp | 40 +- .../src/share/vm/classfile/classLoader.hpp | 8 +- hotspot/src/share/vm/classfile/dictionary.cpp | 20 +- hotspot/src/share/vm/classfile/dictionary.hpp | 38 +- .../src/share/vm/classfile/javaAssertions.cpp | 2 +- .../src/share/vm/classfile/javaAssertions.hpp | 2 +- .../share/vm/classfile/loaderConstraints.cpp | 16 +- .../share/vm/classfile/loaderConstraints.hpp | 14 +- .../src/share/vm/classfile/placeholders.cpp | 6 +- .../src/share/vm/classfile/placeholders.hpp | 16 +- .../share/vm/classfile/resolutionErrors.cpp | 6 +- .../share/vm/classfile/resolutionErrors.hpp | 15 +- .../src/share/vm/classfile/symbolTable.cpp | 56 +- .../src/share/vm/classfile/symbolTable.hpp | 39 +- .../share/vm/classfile/systemDictionary.cpp | 4 +- .../share/vm/classfile/systemDictionary.hpp | 5 +- hotspot/src/share/vm/code/codeBlob.cpp | 4 +- hotspot/src/share/vm/code/codeCache.cpp | 4 +- hotspot/src/share/vm/code/codeCache.hpp | 3 + hotspot/src/share/vm/code/nmethod.hpp | 2 +- hotspot/src/share/vm/code/stubs.hpp | 4 +- .../share/vm/compiler/abstractCompiler.hpp | 2 +- .../src/share/vm/compiler/compileBroker.cpp | 6 +- .../src/share/vm/compiler/compileBroker.hpp | 6 +- hotspot/src/share/vm/compiler/compileLog.cpp | 8 +- .../src/share/vm/compiler/compilerOracle.cpp | 2 +- hotspot/src/share/vm/compiler/oopMap.cpp | 4 +- .../compactibleFreeListSpace.hpp | 2 +- .../concurrentMarkSweepGeneration.cpp | 28 +- .../concurrentMarkSweepGeneration.hpp | 10 +- .../g1/collectionSetChooser.hpp | 2 +- .../g1/concurrentG1Refine.cpp | 22 +- .../g1/concurrentG1Refine.hpp | 2 +- .../gc_implementation/g1/concurrentMark.cpp | 17 +- .../gc_implementation/g1/concurrentMark.hpp | 6 +- .../gc_implementation/g1/dirtyCardQueue.hpp | 2 +- .../g1/g1BlockOffsetTable.cpp | 4 + .../g1/g1BlockOffsetTable.hpp | 2 +- .../gc_implementation/g1/g1CollectedHeap.cpp | 20 +- .../gc_implementation/g1/g1CollectedHeap.hpp | 8 +- .../g1/g1CollectorPolicy.hpp | 6 +- .../vm/gc_implementation/g1/g1MMUTracker.hpp | 2 +- .../g1/g1MonitoringSupport.hpp | 2 +- .../vm/gc_implementation/g1/g1RemSet.cpp | 8 +- .../vm/gc_implementation/g1/g1RemSet.hpp | 2 +- .../gc_implementation/g1/heapRegionRemSet.cpp | 20 +- .../gc_implementation/g1/heapRegionRemSet.hpp | 4 +- .../vm/gc_implementation/g1/heapRegionSeq.cpp | 2 +- .../vm/gc_implementation/g1/heapRegionSeq.hpp | 2 +- .../vm/gc_implementation/g1/ptrQueue.cpp | 4 +- .../vm/gc_implementation/g1/satbQueue.cpp | 2 +- .../vm/gc_implementation/g1/sparsePRT.cpp | 8 +- .../vm/gc_implementation/g1/sparsePRT.hpp | 4 +- .../vm/gc_implementation/g1/survRateGroup.cpp | 14 +- .../vm/gc_implementation/g1/survRateGroup.hpp | 2 +- .../parNew/parCardTableModRefBS.cpp | 4 +- .../parNew/parGCAllocBuffer.hpp | 2 +- .../parNew/parNewGeneration.cpp | 21 +- .../parNew/parNewGeneration.hpp | 10 +- .../parNew/parOopClosures.hpp | 2 +- .../parallelScavenge/adjoiningGenerations.hpp | 2 +- .../parallelScavenge/gcTaskManager.cpp | 22 +- .../parallelScavenge/gcTaskManager.hpp | 6 +- .../parallelScavenge/gcTaskThread.cpp | 4 +- .../parallelScavenge/gcTaskThread.hpp | 2 +- .../parallelScavenge/objectStartArray.cpp | 6 + .../parallelScavenge/objectStartArray.hpp | 2 +- .../parallelScavenge/parMarkBitMap.cpp | 4 + .../parallelScavenge/parMarkBitMap.hpp | 2 +- .../parallelScavenge/parallelScavengeHeap.cpp | 3 + .../parallelScavenge/psCompactionManager.cpp | 6 +- .../parallelScavenge/psCompactionManager.hpp | 18 +- .../parallelScavenge/psGenerationCounters.cpp | 2 +- .../parallelScavenge/psMarkSweepDecorator.hpp | 2 +- .../parallelScavenge/psOldGen.hpp | 2 +- .../parallelScavenge/psParallelCompact.cpp | 8 +- .../parallelScavenge/psPromotionLAB.hpp | 2 +- .../parallelScavenge/psPromotionManager.cpp | 2 +- .../parallelScavenge/psPromotionManager.hpp | 4 +- .../parallelScavenge/psScavenge.cpp | 4 +- .../parallelScavenge/psScavenge.hpp | 4 +- .../parallelScavenge/psVirtualspace.hpp | 2 +- .../parallelScavenge/psYoungGen.hpp | 2 +- .../shared/adaptiveSizePolicy.hpp | 2 +- .../shared/cSpaceCounters.cpp | 2 +- .../shared/cSpaceCounters.hpp | 4 +- .../shared/collectorCounters.cpp | 2 +- .../shared/collectorCounters.hpp | 4 +- .../shared/gSpaceCounters.cpp | 2 +- .../shared/gSpaceCounters.hpp | 4 +- .../shared/gcPolicyCounters.hpp | 2 +- .../vm/gc_implementation/shared/gcStats.hpp | 2 +- .../vm/gc_implementation/shared/gcUtil.hpp | 6 +- .../shared/generationCounters.cpp | 2 +- .../shared/generationCounters.hpp | 4 +- .../shared/hSpaceCounters.cpp | 2 +- .../shared/hSpaceCounters.hpp | 4 +- .../shared/immutableSpace.hpp | 2 +- .../vm/gc_implementation/shared/markSweep.cpp | 14 +- .../vm/gc_implementation/shared/markSweep.hpp | 12 +- .../shared/mutableNUMASpace.cpp | 6 +- .../shared/mutableNUMASpace.hpp | 2 +- .../shared/spaceCounters.cpp | 2 +- .../shared/spaceCounters.hpp | 4 +- .../shared/spaceDecorator.hpp | 2 +- .../share/vm/gc_interface/collectedHeap.hpp | 2 +- .../vm/interpreter/interpreterRuntime.cpp | 4 +- .../src/share/vm/interpreter/oopMapCache.cpp | 12 +- .../src/share/vm/interpreter/oopMapCache.hpp | 2 +- hotspot/src/share/vm/libadt/set.cpp | 6 +- hotspot/src/share/vm/libadt/vectset.cpp | 2 +- hotspot/src/share/vm/memory/allocation.cpp | 111 +++- hotspot/src/share/vm/memory/allocation.hpp | 135 +++- .../src/share/vm/memory/allocation.inline.hpp | 55 +- hotspot/src/share/vm/memory/barrierSet.hpp | 2 +- .../src/share/vm/memory/blockOffsetTable.cpp | 4 + .../src/share/vm/memory/blockOffsetTable.hpp | 2 +- .../src/share/vm/memory/cardTableModRefBS.cpp | 13 +- .../src/share/vm/memory/collectorPolicy.hpp | 2 +- .../src/share/vm/memory/defNewGeneration.hpp | 6 +- hotspot/src/share/vm/memory/filemap.hpp | 2 +- .../share/vm/memory/freeBlockDictionary.hpp | 2 +- hotspot/src/share/vm/memory/genMarkSweep.cpp | 24 +- .../src/share/vm/memory/genOopClosures.hpp | 8 +- hotspot/src/share/vm/memory/genRemSet.hpp | 2 +- hotspot/src/share/vm/memory/generation.hpp | 2 +- .../src/share/vm/memory/generationSpec.hpp | 4 +- hotspot/src/share/vm/memory/heap.cpp | 5 +- hotspot/src/share/vm/memory/heap.hpp | 2 +- .../src/share/vm/memory/heapInspection.cpp | 6 +- .../src/share/vm/memory/heapInspection.hpp | 4 +- hotspot/src/share/vm/memory/memRegion.hpp | 4 +- hotspot/src/share/vm/memory/permGen.hpp | 2 +- .../src/share/vm/memory/referencePolicy.hpp | 2 +- .../share/vm/memory/referenceProcessor.cpp | 3 +- .../share/vm/memory/referenceProcessor.hpp | 2 +- hotspot/src/share/vm/memory/resourceArea.hpp | 23 +- hotspot/src/share/vm/memory/restore.cpp | 8 +- hotspot/src/share/vm/memory/space.hpp | 2 +- .../src/share/vm/memory/tenuredGeneration.cpp | 2 +- .../vm/memory/threadLocalAllocBuffer.hpp | 4 +- hotspot/src/share/vm/memory/universe.cpp | 4 +- hotspot/src/share/vm/memory/universe.hpp | 4 +- hotspot/src/share/vm/oops/constantPoolOop.hpp | 8 +- hotspot/src/share/vm/oops/instanceKlass.cpp | 16 +- hotspot/src/share/vm/oops/instanceKlass.hpp | 6 +- hotspot/src/share/vm/oops/methodOop.hpp | 2 +- hotspot/src/share/vm/oops/symbol.cpp | 2 +- .../src/share/vm/opto/idealGraphPrinter.cpp | 8 +- hotspot/src/share/vm/opto/macro.cpp | 2 +- hotspot/src/share/vm/opto/runtime.hpp | 2 +- hotspot/src/share/vm/opto/type.cpp | 2 +- hotspot/src/share/vm/prims/jni.cpp | 9 +- hotspot/src/share/vm/prims/jniCheck.cpp | 6 +- .../vm/prims/jvmtiClassFileReconstituter.hpp | 4 +- .../share/vm/prims/jvmtiCodeBlobEvents.cpp | 4 +- hotspot/src/share/vm/prims/jvmtiEnv.cpp | 4 +- hotspot/src/share/vm/prims/jvmtiEnvBase.cpp | 4 +- hotspot/src/share/vm/prims/jvmtiEnvBase.hpp | 6 +- .../share/vm/prims/jvmtiEnvThreadState.cpp | 2 +- .../share/vm/prims/jvmtiEnvThreadState.hpp | 4 +- hotspot/src/share/vm/prims/jvmtiExport.cpp | 8 +- hotspot/src/share/vm/prims/jvmtiExport.hpp | 2 +- .../src/share/vm/prims/jvmtiExtensions.cpp | 4 +- .../share/vm/prims/jvmtiGetLoadedClasses.cpp | 2 +- hotspot/src/share/vm/prims/jvmtiImpl.cpp | 8 +- hotspot/src/share/vm/prims/jvmtiImpl.hpp | 8 +- .../src/share/vm/prims/jvmtiRawMonitor.cpp | 4 +- .../share/vm/prims/jvmtiRedefineClasses.cpp | 2 +- hotspot/src/share/vm/prims/jvmtiTagMap.cpp | 30 +- hotspot/src/share/vm/prims/jvmtiTagMap.hpp | 2 +- .../src/share/vm/prims/jvmtiThreadState.hpp | 2 +- hotspot/src/share/vm/prims/jvmtiUtil.cpp | 2 +- hotspot/src/share/vm/prims/unsafe.cpp | 16 +- hotspot/src/share/vm/runtime/arguments.cpp | 67 +- hotspot/src/share/vm/runtime/arguments.hpp | 16 +- .../src/share/vm/runtime/biasedLocking.cpp | 4 +- .../share/vm/runtime/compilationPolicy.hpp | 2 +- .../src/share/vm/runtime/deoptimization.cpp | 12 +- .../src/share/vm/runtime/deoptimization.hpp | 2 +- hotspot/src/share/vm/runtime/dtraceJSDT.hpp | 6 +- hotspot/src/share/vm/runtime/fprofiler.cpp | 14 +- hotspot/src/share/vm/runtime/fprofiler.hpp | 2 +- hotspot/src/share/vm/runtime/globals.cpp | 16 +- hotspot/src/share/vm/runtime/globals.hpp | 4 +- hotspot/src/share/vm/runtime/handles.cpp | 4 +- hotspot/src/share/vm/runtime/handles.hpp | 3 +- .../src/share/vm/runtime/handles.inline.hpp | 2 +- hotspot/src/share/vm/runtime/java.cpp | 2 +- hotspot/src/share/vm/runtime/jniHandles.hpp | 2 +- hotspot/src/share/vm/runtime/monitorChunk.cpp | 2 +- hotspot/src/share/vm/runtime/monitorChunk.hpp | 2 +- hotspot/src/share/vm/runtime/mutex.hpp | 2 +- hotspot/src/share/vm/runtime/os.cpp | 135 +++- hotspot/src/share/vm/runtime/os.hpp | 37 +- hotspot/src/share/vm/runtime/osThread.hpp | 2 +- hotspot/src/share/vm/runtime/park.cpp | 2 +- hotspot/src/share/vm/runtime/perfData.cpp | 12 +- hotspot/src/share/vm/runtime/perfData.hpp | 6 +- hotspot/src/share/vm/runtime/perfMemory.cpp | 8 +- .../src/share/vm/runtime/reflectionUtils.cpp | 2 +- hotspot/src/share/vm/runtime/safepoint.cpp | 7 +- hotspot/src/share/vm/runtime/safepoint.hpp | 2 +- .../src/share/vm/runtime/sharedRuntime.cpp | 28 +- .../src/share/vm/runtime/sharedRuntime.hpp | 4 +- .../share/vm/runtime/stubCodeGenerator.hpp | 2 +- hotspot/src/share/vm/runtime/sweeper.cpp | 2 +- hotspot/src/share/vm/runtime/task.hpp | 2 +- hotspot/src/share/vm/runtime/thread.cpp | 86 ++- hotspot/src/share/vm/runtime/thread.hpp | 30 +- .../src/share/vm/runtime/unhandledOops.cpp | 2 +- hotspot/src/share/vm/runtime/vframeArray.cpp | 2 +- hotspot/src/share/vm/runtime/vframeArray.hpp | 2 +- hotspot/src/share/vm/runtime/vframe_hp.cpp | 4 +- hotspot/src/share/vm/runtime/vframe_hp.hpp | 4 +- hotspot/src/share/vm/runtime/virtualspace.cpp | 10 + hotspot/src/share/vm/runtime/vmStructs.cpp | 59 +- hotspot/src/share/vm/runtime/vmThread.hpp | 2 +- .../src/share/vm/runtime/vm_operations.hpp | 2 +- .../src/share/vm/services/attachListener.cpp | 2 +- .../src/share/vm/services/attachListener.hpp | 2 +- .../share/vm/services/diagnosticArgument.cpp | 4 +- .../share/vm/services/diagnosticArgument.hpp | 8 +- .../share/vm/services/diagnosticFramework.hpp | 4 +- hotspot/src/share/vm/services/gcNotifier.cpp | 2 +- hotspot/src/share/vm/services/gcNotifier.hpp | 2 +- hotspot/src/share/vm/services/heapDumper.cpp | 12 +- .../share/vm/services/lowMemoryDetector.hpp | 4 +- hotspot/src/share/vm/services/management.cpp | 2 + hotspot/src/share/vm/services/memBaseline.cpp | 387 +++++++++++ hotspot/src/share/vm/services/memBaseline.hpp | 447 +++++++++++++ hotspot/src/share/vm/services/memPtr.cpp | 74 +++ hotspot/src/share/vm/services/memPtr.hpp | 509 +++++++++++++++ hotspot/src/share/vm/services/memPtrArray.hpp | 310 +++++++++ hotspot/src/share/vm/services/memRecorder.cpp | 162 +++++ hotspot/src/share/vm/services/memRecorder.hpp | 267 ++++++++ hotspot/src/share/vm/services/memReporter.cpp | 560 ++++++++++++++++ hotspot/src/share/vm/services/memReporter.hpp | 268 ++++++++ hotspot/src/share/vm/services/memSnapshot.cpp | 463 +++++++++++++ hotspot/src/share/vm/services/memSnapshot.hpp | 286 ++++++++ .../src/share/vm/services/memTrackWorker.cpp | 199 ++++++ .../src/share/vm/services/memTrackWorker.hpp | 74 +++ hotspot/src/share/vm/services/memTracker.cpp | 617 ++++++++++++++++++ hotspot/src/share/vm/services/memTracker.hpp | 384 +++++++++++ .../src/share/vm/services/memoryManager.cpp | 12 +- .../src/share/vm/services/memoryManager.hpp | 2 +- hotspot/src/share/vm/services/memoryPool.hpp | 2 +- .../src/share/vm/services/memoryService.cpp | 4 +- hotspot/src/share/vm/services/nmtDCmd.cpp | 172 +++++ hotspot/src/share/vm/services/nmtDCmd.hpp | 60 ++ .../src/share/vm/services/threadService.cpp | 10 +- .../src/share/vm/services/threadService.hpp | 12 +- hotspot/src/share/vm/utilities/array.cpp | 10 +- hotspot/src/share/vm/utilities/array.hpp | 4 +- hotspot/src/share/vm/utilities/bitMap.cpp | 8 +- hotspot/src/share/vm/utilities/decoder.hpp | 2 +- hotspot/src/share/vm/utilities/elfFile.cpp | 2 +- hotspot/src/share/vm/utilities/elfFile.hpp | 2 +- .../src/share/vm/utilities/elfStringTable.cpp | 2 +- .../src/share/vm/utilities/elfStringTable.hpp | 2 +- .../src/share/vm/utilities/elfSymbolTable.cpp | 2 +- .../src/share/vm/utilities/elfSymbolTable.hpp | 2 +- hotspot/src/share/vm/utilities/events.hpp | 2 +- hotspot/src/share/vm/utilities/exceptions.hpp | 2 +- .../src/share/vm/utilities/growableArray.cpp | 2 +- .../src/share/vm/utilities/growableArray.hpp | 18 +- hotspot/src/share/vm/utilities/hashtable.cpp | 115 ++-- hotspot/src/share/vm/utilities/hashtable.hpp | 80 +-- .../share/vm/utilities/hashtable.inline.hpp | 25 +- hotspot/src/share/vm/utilities/histogram.cpp | 2 +- hotspot/src/share/vm/utilities/histogram.hpp | 4 +- hotspot/src/share/vm/utilities/intHisto.cpp | 2 +- hotspot/src/share/vm/utilities/intHisto.hpp | 2 +- hotspot/src/share/vm/utilities/numberSeq.cpp | 4 +- hotspot/src/share/vm/utilities/numberSeq.hpp | 4 +- hotspot/src/share/vm/utilities/ostream.cpp | 30 +- hotspot/src/share/vm/utilities/stack.hpp | 33 +- .../src/share/vm/utilities/stack.inline.hpp | 158 ++--- hotspot/src/share/vm/utilities/taskqueue.hpp | 150 +++-- hotspot/src/share/vm/utilities/vmError.cpp | 4 + hotspot/src/share/vm/utilities/workgroup.cpp | 7 +- hotspot/src/share/vm/utilities/workgroup.hpp | 4 +- hotspot/src/share/vm/utilities/xmlstream.cpp | 8 +- 315 files changed, 7245 insertions(+), 1477 deletions(-) create mode 100644 hotspot/src/share/vm/services/memBaseline.cpp create mode 100644 hotspot/src/share/vm/services/memBaseline.hpp create mode 100644 hotspot/src/share/vm/services/memPtr.cpp create mode 100644 hotspot/src/share/vm/services/memPtr.hpp create mode 100644 hotspot/src/share/vm/services/memPtrArray.hpp create mode 100644 hotspot/src/share/vm/services/memRecorder.cpp create mode 100644 hotspot/src/share/vm/services/memRecorder.hpp create mode 100644 hotspot/src/share/vm/services/memReporter.cpp create mode 100644 hotspot/src/share/vm/services/memReporter.hpp create mode 100644 hotspot/src/share/vm/services/memSnapshot.cpp create mode 100644 hotspot/src/share/vm/services/memSnapshot.hpp create mode 100644 hotspot/src/share/vm/services/memTrackWorker.cpp create mode 100644 hotspot/src/share/vm/services/memTrackWorker.hpp create mode 100644 hotspot/src/share/vm/services/memTracker.cpp create mode 100644 hotspot/src/share/vm/services/memTracker.hpp create mode 100644 hotspot/src/share/vm/services/nmtDCmd.cpp create mode 100644 hotspot/src/share/vm/services/nmtDCmd.hpp diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/BasicHashtable.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/BasicHashtable.java index bb296a509d2..0f4da3a9218 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/BasicHashtable.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/BasicHashtable.java @@ -41,10 +41,10 @@ public class BasicHashtable extends VMObject { } private static synchronized void initialize(TypeDataBase db) { - Type type = db.lookupType("BasicHashtable"); + Type type = db.lookupType("BasicHashtable"); tableSizeField = type.getCIntegerField("_table_size"); bucketsField = type.getAddressField("_buckets"); - bucketSize = db.lookupType("HashtableBucket").getSize(); + bucketSize = db.lookupType("HashtableBucket").getSize(); } // Fields diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/BasicHashtableEntry.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/BasicHashtableEntry.java index 192c1dd9fa0..0296dcbd651 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/BasicHashtableEntry.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/BasicHashtableEntry.java @@ -41,7 +41,7 @@ public class BasicHashtableEntry extends VMObject { } private static synchronized void initialize(TypeDataBase db) { - Type type = db.lookupType("BasicHashtableEntry"); + Type type = db.lookupType("BasicHashtableEntry"); hashField = type.getCIntegerField("_hash"); nextField = type.getAddressField("_next"); } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/Hashtable.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/Hashtable.java index 3c2e0f965c2..70709f02b84 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/Hashtable.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/Hashtable.java @@ -40,7 +40,7 @@ public class Hashtable extends BasicHashtable { private static synchronized void initialize(TypeDataBase db) { // just to confirm that type exists - Type type = db.lookupType("Hashtable"); + Type type = db.lookupType("IntptrHashtable"); } // derived class may return Class diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HashtableBucket.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HashtableBucket.java index 2e86b9a8318..44f78e49dd8 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HashtableBucket.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HashtableBucket.java @@ -39,7 +39,7 @@ public class HashtableBucket extends VMObject { } private static synchronized void initialize(TypeDataBase db) { - Type type = db.lookupType("HashtableBucket"); + Type type = db.lookupType("HashtableBucket"); entryField = type.getAddressField("_entry"); } diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HashtableEntry.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HashtableEntry.java index 73932a43033..38c5968720d 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HashtableEntry.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HashtableEntry.java @@ -41,7 +41,7 @@ public class HashtableEntry extends BasicHashtableEntry { } private static synchronized void initialize(TypeDataBase db) { - Type type = db.lookupType("HashtableEntry"); + Type type = db.lookupType("IntptrHashtableEntry"); literalField = type.getAddressField("_literal"); } diff --git a/hotspot/make/bsd/makefiles/jvmg.make b/hotspot/make/bsd/makefiles/jvmg.make index 8c56368d4dc..b5be2967edc 100644 --- a/hotspot/make/bsd/makefiles/jvmg.make +++ b/hotspot/make/bsd/makefiles/jvmg.make @@ -27,7 +27,9 @@ # Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make DEBUG_CFLAGS/DEFAULT= $(DEBUG_CFLAGS) DEBUG_CFLAGS/BYFILE = $(DEBUG_CFLAGS/$@)$(DEBUG_CFLAGS/DEFAULT$(DEBUG_CFLAGS/$@)) -CFLAGS += $(DEBUG_CFLAGS/BYFILE) + +# _NMT_NOINLINE_ informs NMT that no inlining by Compiler +CFLAGS += $(DEBUG_CFLAGS/BYFILE) -D_NMT_NOINLINE_ # Set the environment variable HOTSPARC_GENERIC to "true" # to inhibit the effect of the previous line on CFLAGS. diff --git a/hotspot/make/linux/makefiles/jvmg.make b/hotspot/make/linux/makefiles/jvmg.make index db10608c142..3c0ae3a628e 100644 --- a/hotspot/make/linux/makefiles/jvmg.make +++ b/hotspot/make/linux/makefiles/jvmg.make @@ -1,5 +1,5 @@ # -# Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -27,7 +27,9 @@ # Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make DEBUG_CFLAGS/DEFAULT= $(DEBUG_CFLAGS) DEBUG_CFLAGS/BYFILE = $(DEBUG_CFLAGS/$@)$(DEBUG_CFLAGS/DEFAULT$(DEBUG_CFLAGS/$@)) -CFLAGS += $(DEBUG_CFLAGS/BYFILE) + +# _NMT_NOINLINE_ informs NMT that no inlining by Compiler +CFLAGS += $(DEBUG_CFLAGS/BYFILE) -D_NMT_NOINLINE_ # Set the environment variable HOTSPARC_GENERIC to "true" # to inhibit the effect of the previous line on CFLAGS. diff --git a/hotspot/make/solaris/makefiles/jvmg.make b/hotspot/make/solaris/makefiles/jvmg.make index 8e1db865e33..821c0a13850 100644 --- a/hotspot/make/solaris/makefiles/jvmg.make +++ b/hotspot/make/solaris/makefiles/jvmg.make @@ -37,7 +37,8 @@ ifeq ($(COMPILER_REV_NUMERIC),508) endif endif -CFLAGS += $(DEBUG_CFLAGS/BYFILE) +# _NMT_NOINLINE_ informs NMT that no inlining by Compiler +CFLAGS += $(DEBUG_CFLAGS/BYFILE) -D_NMT_NOINLINE_ # Set the environment variable HOTSPARC_GENERIC to "true" # to inhibit the effect of the previous line on CFLAGS. diff --git a/hotspot/make/windows/makefiles/debug.make b/hotspot/make/windows/makefiles/debug.make index 9f434729d76..36a12dc9de2 100644 --- a/hotspot/make/windows/makefiles/debug.make +++ b/hotspot/make/windows/makefiles/debug.make @@ -38,7 +38,8 @@ default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA wb !include ../local.make !include compile.make -CXX_FLAGS=$(CXX_FLAGS) $(DEBUG_OPT_OPTION) +# _NMT_NOINLINE_ informs NMT that no inlining by Compiler +CXX_FLAGS=$(CXX_FLAGS) $(DEBUG_OPT_OPTION) /D "_NMT_NOINLINE_" !include $(WorkSpace)/make/windows/makefiles/vm.make !include local.make diff --git a/hotspot/src/os/bsd/vm/os_bsd.cpp b/hotspot/src/os/bsd/vm/os_bsd.cpp index f9b21acb464..0305b3df0de 100644 --- a/hotspot/src/os/bsd/vm/os_bsd.cpp +++ b/hotspot/src/os/bsd/vm/os_bsd.cpp @@ -440,7 +440,7 @@ void os::init_system_properties_values() { // code needs to be changed accordingly. // The next few definitions allow the code to be verbatim: -#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n)) +#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n), mtInternal) #define getenv(n) ::getenv(n) /* @@ -1913,11 +1913,11 @@ void os::dll_build_name(char* buffer, size_t buflen, // release the storage for (int i = 0 ; i < n ; i++) { if (pelements[i] != NULL) { - FREE_C_HEAP_ARRAY(char, pelements[i]); + FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal); } } if (pelements != NULL) { - FREE_C_HEAP_ARRAY(char*, pelements); + FREE_C_HEAP_ARRAY(char*, pelements, mtInternal); } } else { snprintf(buffer, buflen, "%s/" JNI_LIB_PREFIX "%s" JNI_LIB_SUFFIX, pname, fname); @@ -2766,7 +2766,7 @@ void bsd_wrap_code(char* base, size_t size) { // All it does is to check if there are enough free pages // left at the time of mmap(). This could be a potential // problem. -bool os::commit_memory(char* addr, size_t size, bool exec) { +bool os::pd_commit_memory(char* addr, size_t size, bool exec) { int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE; #ifdef __OpenBSD__ // XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD @@ -2790,7 +2790,7 @@ bool os::commit_memory(char* addr, size_t size, bool exec) { #endif #endif -bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, +bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint, bool exec) { #ifndef _ALLBSD_SOURCE if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) { @@ -2806,7 +2806,7 @@ bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, return commit_memory(addr, size, exec); } -void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { +void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { #ifndef _ALLBSD_SOURCE if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) { // We don't check the return value: madvise(MADV_HUGEPAGE) may not @@ -2816,7 +2816,7 @@ void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { #endif } -void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { +void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { ::madvise(addr, bytes, MADV_DONTNEED); } @@ -2958,7 +2958,7 @@ os::Bsd::numa_interleave_memory_func_t os::Bsd::_numa_interleave_memory; unsigned long* os::Bsd::_numa_all_nodes; #endif -bool os::uncommit_memory(char* addr, size_t size) { +bool os::pd_uncommit_memory(char* addr, size_t size) { #ifdef __OpenBSD__ // XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD return ::mprotect(addr, size, PROT_NONE) == 0; @@ -2969,7 +2969,7 @@ bool os::uncommit_memory(char* addr, size_t size) { #endif } -bool os::create_stack_guard_pages(char* addr, size_t size) { +bool os::pd_create_stack_guard_pages(char* addr, size_t size) { return os::commit_memory(addr, size); } @@ -3023,12 +3023,12 @@ static int anon_munmap(char * addr, size_t size) { return ::munmap(addr, size) == 0; } -char* os::reserve_memory(size_t bytes, char* requested_addr, +char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) { return anon_mmap(requested_addr, bytes, (requested_addr != NULL)); } -bool os::release_memory(char* addr, size_t size) { +bool os::pd_release_memory(char* addr, size_t size) { return anon_munmap(addr, size); } @@ -3331,7 +3331,7 @@ bool os::can_execute_large_page_memory() { // Reserve memory at an arbitrary address, only if that area is // available (and not reserved for something else). -char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { +char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) { const int max_tries = 10; char* base[max_tries]; size_t size[max_tries]; @@ -4987,7 +4987,7 @@ int os::socket_available(int fd, jint *pbytes) { } // Map a block of memory. -char* os::map_memory(int fd, const char* file_name, size_t file_offset, +char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset, char *addr, size_t bytes, bool read_only, bool allow_exec) { int prot; @@ -5019,7 +5019,7 @@ char* os::map_memory(int fd, const char* file_name, size_t file_offset, // Remap a block of memory. -char* os::remap_memory(int fd, const char* file_name, size_t file_offset, +char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset, char *addr, size_t bytes, bool read_only, bool allow_exec) { // same as map_memory() on this OS @@ -5029,7 +5029,7 @@ char* os::remap_memory(int fd, const char* file_name, size_t file_offset, // Unmap a block of memory. -bool os::unmap_memory(char* addr, size_t bytes) { +bool os::pd_unmap_memory(char* addr, size_t bytes) { return munmap(addr, bytes) == 0; } diff --git a/hotspot/src/os/bsd/vm/os_bsd.hpp b/hotspot/src/os/bsd/vm/os_bsd.hpp index 271d1e291e9..bb8fe3f211e 100644 --- a/hotspot/src/os/bsd/vm/os_bsd.hpp +++ b/hotspot/src/os/bsd/vm/os_bsd.hpp @@ -312,7 +312,7 @@ public: }; -class PlatformEvent : public CHeapObj { +class PlatformEvent : public CHeapObj { private: double CachePad [4] ; // increase odds that _mutex is sole occupant of cache line volatile int _Event ; @@ -347,7 +347,7 @@ class PlatformEvent : public CHeapObj { void SetAssociation (Thread * a) { _Assoc = a ; } } ; -class PlatformParker : public CHeapObj { +class PlatformParker : public CHeapObj { protected: pthread_mutex_t _mutex [1] ; pthread_cond_t _cond [1] ; diff --git a/hotspot/src/os/bsd/vm/os_bsd.inline.hpp b/hotspot/src/os/bsd/vm/os_bsd.inline.hpp index c582a45315a..9980d4631a2 100644 --- a/hotspot/src/os/bsd/vm/os_bsd.inline.hpp +++ b/hotspot/src/os/bsd/vm/os_bsd.inline.hpp @@ -95,7 +95,7 @@ inline bool os::allocate_stack_guard_pages() { // On Bsd, reservations are made on a page by page basis, nothing to do. -inline void os::split_reserved_memory(char *base, size_t size, +inline void os::pd_split_reserved_memory(char *base, size_t size, size_t split, bool realloc) { } diff --git a/hotspot/src/os/bsd/vm/perfMemory_bsd.cpp b/hotspot/src/os/bsd/vm/perfMemory_bsd.cpp index c93289e5909..e9db634135f 100644 --- a/hotspot/src/os/bsd/vm/perfMemory_bsd.cpp +++ b/hotspot/src/os/bsd/vm/perfMemory_bsd.cpp @@ -126,7 +126,7 @@ static void save_memory_to_file(char* addr, size_t size) { } } } - FREE_C_HEAP_ARRAY(char, destfile); + FREE_C_HEAP_ARRAY(char, destfile, mtInternal); } @@ -153,7 +153,7 @@ static char* get_user_tmp_dir(const char* user) { const char* tmpdir = os::get_temp_directory(); const char* perfdir = PERFDATA_NAME; size_t nbytes = strlen(tmpdir) + strlen(perfdir) + strlen(user) + 3; - char* dirname = NEW_C_HEAP_ARRAY(char, nbytes); + char* dirname = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); // construct the path name to user specific tmp directory snprintf(dirname, nbytes, "%s/%s_%s", tmpdir, perfdir, user); @@ -246,7 +246,7 @@ static char* get_user_name(uid_t uid) { if (bufsize == -1) bufsize = 1024; - char* pwbuf = NEW_C_HEAP_ARRAY(char, bufsize); + char* pwbuf = NEW_C_HEAP_ARRAY(char, bufsize, mtInternal); // POSIX interface to getpwuid_r is used on LINUX struct passwd* p; @@ -278,14 +278,14 @@ static char* get_user_name(uid_t uid) { "pw_name zero length"); } } - FREE_C_HEAP_ARRAY(char, pwbuf); + FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal); return NULL; } - char* user_name = NEW_C_HEAP_ARRAY(char, strlen(p->pw_name) + 1); + char* user_name = NEW_C_HEAP_ARRAY(char, strlen(p->pw_name) + 1, mtInternal); strcpy(user_name, p->pw_name); - FREE_C_HEAP_ARRAY(char, pwbuf); + FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal); return user_name; } @@ -328,7 +328,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { // to determine the user name for the process id. // struct dirent* dentry; - char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname)); + char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname), mtInternal); errno = 0; while ((dentry = os::readdir(tmpdirp, (struct dirent *)tdbuf)) != NULL) { @@ -338,7 +338,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { } char* usrdir_name = NEW_C_HEAP_ARRAY(char, - strlen(tmpdirname) + strlen(dentry->d_name) + 2); + strlen(tmpdirname) + strlen(dentry->d_name) + 2, mtInternal); strcpy(usrdir_name, tmpdirname); strcat(usrdir_name, "/"); strcat(usrdir_name, dentry->d_name); @@ -346,7 +346,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { DIR* subdirp = os::opendir(usrdir_name); if (subdirp == NULL) { - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); continue; } @@ -357,13 +357,13 @@ static char* get_user_name_slow(int vmid, TRAPS) { // symlink can be exploited. // if (!is_directory_secure(usrdir_name)) { - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); os::closedir(subdirp); continue; } struct dirent* udentry; - char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name)); + char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name), mtInternal); errno = 0; while ((udentry = os::readdir(subdirp, (struct dirent *)udbuf)) != NULL) { @@ -372,7 +372,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { int result; char* filename = NEW_C_HEAP_ARRAY(char, - strlen(usrdir_name) + strlen(udentry->d_name) + 2); + strlen(usrdir_name) + strlen(udentry->d_name) + 2, mtInternal); strcpy(filename, usrdir_name); strcat(filename, "/"); @@ -381,13 +381,13 @@ static char* get_user_name_slow(int vmid, TRAPS) { // don't follow symbolic links for the file RESTARTABLE(::lstat(filename, &statbuf), result); if (result == OS_ERR) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); continue; } // skip over files that are not regular files. if (!S_ISREG(statbuf.st_mode)) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); continue; } @@ -397,23 +397,23 @@ static char* get_user_name_slow(int vmid, TRAPS) { if (statbuf.st_ctime > oldest_ctime) { char* user = strchr(dentry->d_name, '_') + 1; - if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user); - oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1); + if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user, mtInternal); + oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1, mtInternal); strcpy(oldest_user, user); oldest_ctime = statbuf.st_ctime; } } - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); } } os::closedir(subdirp); - FREE_C_HEAP_ARRAY(char, udbuf); - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, udbuf, mtInternal); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); } os::closedir(tmpdirp); - FREE_C_HEAP_ARRAY(char, tdbuf); + FREE_C_HEAP_ARRAY(char, tdbuf, mtInternal); return(oldest_user); } @@ -434,7 +434,7 @@ static char* get_sharedmem_filename(const char* dirname, int vmid) { // add 2 for the file separator and a null terminator. size_t nbytes = strlen(dirname) + UINT_CHARS + 2; - char* name = NEW_C_HEAP_ARRAY(char, nbytes); + char* name = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); snprintf(name, nbytes, "%s/%d", dirname, vmid); return name; @@ -472,7 +472,7 @@ static void remove_file(const char* path) { static void remove_file(const char* dirname, const char* filename) { size_t nbytes = strlen(dirname) + strlen(filename) + 2; - char* path = NEW_C_HEAP_ARRAY(char, nbytes); + char* path = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); strcpy(path, dirname); strcat(path, "/"); @@ -480,7 +480,7 @@ static void remove_file(const char* dirname, const char* filename) { remove_file(path); - FREE_C_HEAP_ARRAY(char, path); + FREE_C_HEAP_ARRAY(char, path, mtInternal); } @@ -517,7 +517,7 @@ static void cleanup_sharedmem_resources(const char* dirname) { // opendir/readdir. // struct dirent* entry; - char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname)); + char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname), mtInternal); errno = 0; while ((entry = os::readdir(dirp, (struct dirent *)dbuf)) != NULL) { @@ -556,7 +556,7 @@ static void cleanup_sharedmem_resources(const char* dirname) { errno = 0; } os::closedir(dirp); - FREE_C_HEAP_ARRAY(char, dbuf); + FREE_C_HEAP_ARRAY(char, dbuf, mtInternal); } // make the user specific temporary directory. Returns true if @@ -723,11 +723,11 @@ static char* mmap_create_shared(size_t size) { fd = create_sharedmem_resources(dirname, filename, size); - FREE_C_HEAP_ARRAY(char, user_name); - FREE_C_HEAP_ARRAY(char, dirname); + FREE_C_HEAP_ARRAY(char, user_name, mtInternal); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); if (fd == -1) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); return NULL; } @@ -743,7 +743,7 @@ static char* mmap_create_shared(size_t size) { warning("mmap failed - %s\n", strerror(errno)); } remove_file(filename); - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); return NULL; } @@ -869,7 +869,7 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor // store file, we don't follow them when attaching either. // if (!is_directory_secure(dirname)) { - FREE_C_HEAP_ARRAY(char, dirname); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Process not found"); } @@ -884,9 +884,9 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor strcpy(rfilename, filename); // free the c heap resources that are no longer needed - if (luser != user) FREE_C_HEAP_ARRAY(char, luser); - FREE_C_HEAP_ARRAY(char, dirname); - FREE_C_HEAP_ARRAY(char, filename); + if (luser != user) FREE_C_HEAP_ARRAY(char, luser, mtInternal); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); // open the shared memory file for the give vmid fd = open_sharedmem_file(rfilename, file_flags, CHECK); diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp index 53457ec8db9..ce7c71b9d43 100644 --- a/hotspot/src/os/linux/vm/os_linux.cpp +++ b/hotspot/src/os/linux/vm/os_linux.cpp @@ -371,7 +371,7 @@ void os::init_system_properties_values() { // code needs to be changed accordingly. // The next few definitions allow the code to be verbatim: -#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n)) +#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n), mtInternal) #define getenv(n) ::getenv(n) /* @@ -639,7 +639,7 @@ void os::Linux::libpthread_init() { size_t n = confstr(_CS_GNU_LIBC_VERSION, NULL, 0); if (n > 0) { - char *str = (char *)malloc(n); + char *str = (char *)malloc(n, mtInternal); confstr(_CS_GNU_LIBC_VERSION, str, n); os::Linux::set_glibc_version(str); } else { @@ -652,7 +652,7 @@ void os::Linux::libpthread_init() { n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0); if (n > 0) { - char *str = (char *)malloc(n); + char *str = (char *)malloc(n, mtInternal); confstr(_CS_GNU_LIBPTHREAD_VERSION, str, n); // Vanilla RH-9 (glibc 2.3.2) has a bug that confstr() always tells // us "NPTL-0.29" even we are running with LinuxThreads. Check if this @@ -1685,11 +1685,11 @@ void os::dll_build_name(char* buffer, size_t buflen, // release the storage for (int i = 0 ; i < n ; i++) { if (pelements[i] != NULL) { - FREE_C_HEAP_ARRAY(char, pelements[i]); + FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal); } } if (pelements != NULL) { - FREE_C_HEAP_ARRAY(char*, pelements); + FREE_C_HEAP_ARRAY(char*, pelements, mtInternal); } } else { snprintf(buffer, buflen, "%s/lib%s.so", pname, fname); @@ -2469,7 +2469,7 @@ void linux_wrap_code(char* base, size_t size) { // All it does is to check if there are enough free pages // left at the time of mmap(). This could be a potential // problem. -bool os::commit_memory(char* addr, size_t size, bool exec) { +bool os::pd_commit_memory(char* addr, size_t size, bool exec) { int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE; uintptr_t res = (uintptr_t) ::mmap(addr, size, prot, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0); @@ -2492,7 +2492,7 @@ bool os::commit_memory(char* addr, size_t size, bool exec) { #define MADV_HUGEPAGE 14 #endif -bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, +bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint, bool exec) { if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) { int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE; @@ -2516,7 +2516,7 @@ bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, return false; } -void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { +void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) { // We don't check the return value: madvise(MADV_HUGEPAGE) may not // be supported or the memory may already be backed by huge pages. @@ -2524,7 +2524,7 @@ void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } } -void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { +void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { // This method works by doing an mmap over an existing mmaping and effectively discarding // the existing pages. However it won't work for SHM-based large pages that cannot be // uncommitted at all. We don't do anything in this case to avoid creating a segment with @@ -2646,7 +2646,7 @@ bool os::Linux::libnuma_init() { if (numa_available() != -1) { set_numa_all_nodes((unsigned long*)libnuma_dlsym(handle, "numa_all_nodes")); // Create a cpu -> node mapping - _cpu_to_node = new (ResourceObj::C_HEAP) GrowableArray(0, true); + _cpu_to_node = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(0, true); rebuild_cpu_to_node_map(); return true; } @@ -2676,7 +2676,7 @@ void os::Linux::rebuild_cpu_to_node_map() { cpu_to_node()->at_grow(cpu_num - 1); size_t node_num = numa_get_groups_num(); - unsigned long *cpu_map = NEW_C_HEAP_ARRAY(unsigned long, cpu_map_size); + unsigned long *cpu_map = NEW_C_HEAP_ARRAY(unsigned long, cpu_map_size, mtInternal); for (size_t i = 0; i < node_num; i++) { if (numa_node_to_cpus(i, cpu_map, cpu_map_size * sizeof(unsigned long)) != -1) { for (size_t j = 0; j < cpu_map_valid_size; j++) { @@ -2690,7 +2690,7 @@ void os::Linux::rebuild_cpu_to_node_map() { } } } - FREE_C_HEAP_ARRAY(unsigned long, cpu_map); + FREE_C_HEAP_ARRAY(unsigned long, cpu_map, mtInternal); } int os::Linux::get_node_by_cpu(int cpu_id) { @@ -2709,7 +2709,7 @@ os::Linux::numa_tonode_memory_func_t os::Linux::_numa_tonode_memory; os::Linux::numa_interleave_memory_func_t os::Linux::_numa_interleave_memory; unsigned long* os::Linux::_numa_all_nodes; -bool os::uncommit_memory(char* addr, size_t size) { +bool os::pd_uncommit_memory(char* addr, size_t size) { uintptr_t res = (uintptr_t) ::mmap(addr, size, PROT_NONE, MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0); return res != (uintptr_t) MAP_FAILED; @@ -2774,7 +2774,7 @@ bool get_stack_bounds(uintptr_t *bottom, uintptr_t *top) { // munmap() the guard pages we don't leave a hole in the stack // mapping. This only affects the main/initial thread, but guard // against future OS changes -bool os::create_stack_guard_pages(char* addr, size_t size) { +bool os::pd_create_stack_guard_pages(char* addr, size_t size) { uintptr_t stack_extent, stack_base; bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true); if (chk_bounds && get_stack_bounds(&stack_extent, &stack_base)) { @@ -2847,12 +2847,12 @@ static int anon_munmap(char * addr, size_t size) { return ::munmap(addr, size) == 0; } -char* os::reserve_memory(size_t bytes, char* requested_addr, +char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) { return anon_mmap(requested_addr, bytes, (requested_addr != NULL)); } -bool os::release_memory(char* addr, size_t size) { +bool os::pd_release_memory(char* addr, size_t size) { return anon_munmap(addr, size); } @@ -3149,7 +3149,7 @@ bool os::can_execute_large_page_memory() { // Reserve memory at an arbitrary address, only if that area is // available (and not reserved for something else). -char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { +char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) { const int max_tries = 10; char* base[max_tries]; size_t size[max_tries]; @@ -4671,7 +4671,7 @@ int os::socket_available(int fd, jint *pbytes) { } // Map a block of memory. -char* os::map_memory(int fd, const char* file_name, size_t file_offset, +char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset, char *addr, size_t bytes, bool read_only, bool allow_exec) { int prot; @@ -4701,7 +4701,7 @@ char* os::map_memory(int fd, const char* file_name, size_t file_offset, // Remap a block of memory. -char* os::remap_memory(int fd, const char* file_name, size_t file_offset, +char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset, char *addr, size_t bytes, bool read_only, bool allow_exec) { // same as map_memory() on this OS @@ -4711,7 +4711,7 @@ char* os::remap_memory(int fd, const char* file_name, size_t file_offset, // Unmap a block of memory. -bool os::unmap_memory(char* addr, size_t bytes) { +bool os::pd_unmap_memory(char* addr, size_t bytes) { return munmap(addr, bytes) == 0; } diff --git a/hotspot/src/os/linux/vm/os_linux.hpp b/hotspot/src/os/linux/vm/os_linux.hpp index 7c19517e21e..0f0fa214a04 100644 --- a/hotspot/src/os/linux/vm/os_linux.hpp +++ b/hotspot/src/os/linux/vm/os_linux.hpp @@ -287,7 +287,7 @@ public: }; -class PlatformEvent : public CHeapObj { +class PlatformEvent : public CHeapObj { private: double CachePad [4] ; // increase odds that _mutex is sole occupant of cache line volatile int _Event ; @@ -322,7 +322,7 @@ class PlatformEvent : public CHeapObj { void SetAssociation (Thread * a) { _Assoc = a ; } } ; -class PlatformParker : public CHeapObj { +class PlatformParker : public CHeapObj { protected: pthread_mutex_t _mutex [1] ; pthread_cond_t _cond [1] ; diff --git a/hotspot/src/os/linux/vm/os_linux.inline.hpp b/hotspot/src/os/linux/vm/os_linux.inline.hpp index 566c0ad3168..c663c9b6961 100644 --- a/hotspot/src/os/linux/vm/os_linux.inline.hpp +++ b/hotspot/src/os/linux/vm/os_linux.inline.hpp @@ -99,7 +99,7 @@ inline bool os::allocate_stack_guard_pages() { // On Linux, reservations are made on a page by page basis, nothing to do. -inline void os::split_reserved_memory(char *base, size_t size, +inline void os::pd_split_reserved_memory(char *base, size_t size, size_t split, bool realloc) { } diff --git a/hotspot/src/os/linux/vm/perfMemory_linux.cpp b/hotspot/src/os/linux/vm/perfMemory_linux.cpp index 1cd430cfbc7..8839aac6c10 100644 --- a/hotspot/src/os/linux/vm/perfMemory_linux.cpp +++ b/hotspot/src/os/linux/vm/perfMemory_linux.cpp @@ -126,7 +126,7 @@ static void save_memory_to_file(char* addr, size_t size) { } } } - FREE_C_HEAP_ARRAY(char, destfile); + FREE_C_HEAP_ARRAY(char, destfile, mtInternal); } @@ -153,7 +153,7 @@ static char* get_user_tmp_dir(const char* user) { const char* tmpdir = os::get_temp_directory(); const char* perfdir = PERFDATA_NAME; size_t nbytes = strlen(tmpdir) + strlen(perfdir) + strlen(user) + 3; - char* dirname = NEW_C_HEAP_ARRAY(char, nbytes); + char* dirname = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); // construct the path name to user specific tmp directory snprintf(dirname, nbytes, "%s/%s_%s", tmpdir, perfdir, user); @@ -246,7 +246,7 @@ static char* get_user_name(uid_t uid) { if (bufsize == -1) bufsize = 1024; - char* pwbuf = NEW_C_HEAP_ARRAY(char, bufsize); + char* pwbuf = NEW_C_HEAP_ARRAY(char, bufsize, mtInternal); // POSIX interface to getpwuid_r is used on LINUX struct passwd* p; @@ -278,14 +278,14 @@ static char* get_user_name(uid_t uid) { "pw_name zero length"); } } - FREE_C_HEAP_ARRAY(char, pwbuf); + FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal); return NULL; } - char* user_name = NEW_C_HEAP_ARRAY(char, strlen(p->pw_name) + 1); + char* user_name = NEW_C_HEAP_ARRAY(char, strlen(p->pw_name) + 1, mtInternal); strcpy(user_name, p->pw_name); - FREE_C_HEAP_ARRAY(char, pwbuf); + FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal); return user_name; } @@ -328,7 +328,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { // to determine the user name for the process id. // struct dirent* dentry; - char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname)); + char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname), mtInternal); errno = 0; while ((dentry = os::readdir(tmpdirp, (struct dirent *)tdbuf)) != NULL) { @@ -338,7 +338,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { } char* usrdir_name = NEW_C_HEAP_ARRAY(char, - strlen(tmpdirname) + strlen(dentry->d_name) + 2); + strlen(tmpdirname) + strlen(dentry->d_name) + 2, mtInternal); strcpy(usrdir_name, tmpdirname); strcat(usrdir_name, "/"); strcat(usrdir_name, dentry->d_name); @@ -346,7 +346,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { DIR* subdirp = os::opendir(usrdir_name); if (subdirp == NULL) { - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); continue; } @@ -357,13 +357,13 @@ static char* get_user_name_slow(int vmid, TRAPS) { // symlink can be exploited. // if (!is_directory_secure(usrdir_name)) { - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); os::closedir(subdirp); continue; } struct dirent* udentry; - char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name)); + char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name), mtInternal); errno = 0; while ((udentry = os::readdir(subdirp, (struct dirent *)udbuf)) != NULL) { @@ -372,7 +372,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { int result; char* filename = NEW_C_HEAP_ARRAY(char, - strlen(usrdir_name) + strlen(udentry->d_name) + 2); + strlen(usrdir_name) + strlen(udentry->d_name) + 2, mtInternal); strcpy(filename, usrdir_name); strcat(filename, "/"); @@ -381,13 +381,13 @@ static char* get_user_name_slow(int vmid, TRAPS) { // don't follow symbolic links for the file RESTARTABLE(::lstat(filename, &statbuf), result); if (result == OS_ERR) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); continue; } // skip over files that are not regular files. if (!S_ISREG(statbuf.st_mode)) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); continue; } @@ -397,23 +397,23 @@ static char* get_user_name_slow(int vmid, TRAPS) { if (statbuf.st_ctime > oldest_ctime) { char* user = strchr(dentry->d_name, '_') + 1; - if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user); - oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1); + if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user, mtInternal); + oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1, mtInternal); strcpy(oldest_user, user); oldest_ctime = statbuf.st_ctime; } } - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); } } os::closedir(subdirp); - FREE_C_HEAP_ARRAY(char, udbuf); - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, udbuf, mtInternal); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); } os::closedir(tmpdirp); - FREE_C_HEAP_ARRAY(char, tdbuf); + FREE_C_HEAP_ARRAY(char, tdbuf, mtInternal); return(oldest_user); } @@ -434,7 +434,7 @@ static char* get_sharedmem_filename(const char* dirname, int vmid) { // add 2 for the file separator and a null terminator. size_t nbytes = strlen(dirname) + UINT_CHARS + 2; - char* name = NEW_C_HEAP_ARRAY(char, nbytes); + char* name = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); snprintf(name, nbytes, "%s/%d", dirname, vmid); return name; @@ -472,7 +472,7 @@ static void remove_file(const char* path) { static void remove_file(const char* dirname, const char* filename) { size_t nbytes = strlen(dirname) + strlen(filename) + 2; - char* path = NEW_C_HEAP_ARRAY(char, nbytes); + char* path = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); strcpy(path, dirname); strcat(path, "/"); @@ -480,7 +480,7 @@ static void remove_file(const char* dirname, const char* filename) { remove_file(path); - FREE_C_HEAP_ARRAY(char, path); + FREE_C_HEAP_ARRAY(char, path, mtInternal); } @@ -517,7 +517,7 @@ static void cleanup_sharedmem_resources(const char* dirname) { // opendir/readdir. // struct dirent* entry; - char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname)); + char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname), mtInternal); errno = 0; while ((entry = os::readdir(dirp, (struct dirent *)dbuf)) != NULL) { @@ -556,7 +556,7 @@ static void cleanup_sharedmem_resources(const char* dirname) { errno = 0; } os::closedir(dirp); - FREE_C_HEAP_ARRAY(char, dbuf); + FREE_C_HEAP_ARRAY(char, dbuf, mtInternal); } // make the user specific temporary directory. Returns true if @@ -723,11 +723,11 @@ static char* mmap_create_shared(size_t size) { fd = create_sharedmem_resources(dirname, filename, size); - FREE_C_HEAP_ARRAY(char, user_name); - FREE_C_HEAP_ARRAY(char, dirname); + FREE_C_HEAP_ARRAY(char, user_name, mtInternal); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); if (fd == -1) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); return NULL; } @@ -743,7 +743,7 @@ static char* mmap_create_shared(size_t size) { warning("mmap failed - %s\n", strerror(errno)); } remove_file(filename); - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); return NULL; } @@ -869,7 +869,7 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor // store file, we don't follow them when attaching either. // if (!is_directory_secure(dirname)) { - FREE_C_HEAP_ARRAY(char, dirname); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Process not found"); } @@ -884,9 +884,9 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor strcpy(rfilename, filename); // free the c heap resources that are no longer needed - if (luser != user) FREE_C_HEAP_ARRAY(char, luser); - FREE_C_HEAP_ARRAY(char, dirname); - FREE_C_HEAP_ARRAY(char, filename); + if (luser != user) FREE_C_HEAP_ARRAY(char, luser, mtInternal); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); // open the shared memory file for the give vmid fd = open_sharedmem_file(rfilename, file_flags, CHECK); diff --git a/hotspot/src/os/posix/vm/os_posix.cpp b/hotspot/src/os/posix/vm/os_posix.cpp index 9f05a74a4a0..3e49b8b9ddd 100644 --- a/hotspot/src/os/posix/vm/os_posix.cpp +++ b/hotspot/src/os/posix/vm/os_posix.cpp @@ -23,6 +23,7 @@ */ #include "prims/jvm.h" +#include "runtime/frame.inline.hpp" #include "runtime/os.hpp" #include "utilities/vmError.hpp" @@ -61,6 +62,23 @@ void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char* VMError::report_coredump_status(buffer, success); } +address os::get_caller_pc(int n) { +#ifdef _NMT_NOINLINE_ + n ++; +#endif + frame fr = os::current_frame(); + while (n > 0 && fr.pc() && + !os::is_first_C_frame(&fr) && fr.sender_pc()) { + fr = os::get_sender_for_C_frame(&fr); + n --; + } + if (n == 0) { + return fr.pc(); + } else { + return NULL; + } +} + int os::get_last_error() { return errno; } diff --git a/hotspot/src/os/solaris/dtrace/hs_private.d b/hotspot/src/os/solaris/dtrace/hs_private.d index 23463a409b3..df395e5c045 100644 --- a/hotspot/src/os/solaris/dtrace/hs_private.d +++ b/hotspot/src/os/solaris/dtrace/hs_private.d @@ -23,7 +23,6 @@ */ provider hs_private { - probe hashtable__new_entry(void*, uintptr_t, void*); probe safepoint__begin(); probe safepoint__end(); probe cms__initmark__begin(); diff --git a/hotspot/src/os/solaris/vm/os_solaris.cpp b/hotspot/src/os/solaris/vm/os_solaris.cpp index c3389a47764..1d241d650e8 100644 --- a/hotspot/src/os/solaris/vm/os_solaris.cpp +++ b/hotspot/src/os/solaris/vm/os_solaris.cpp @@ -546,7 +546,7 @@ static bool find_processors_in_pset(psetid_t pset, // Find the number of processors in the processor set. if (pset_info(pset, NULL, id_length, NULL) == 0) { // Make up an array to hold their ids. - *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length); + *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal); // Fill in the array with their processor ids. if (pset_info(pset, NULL, id_length, *id_array) == 0) { result = true; @@ -577,7 +577,7 @@ static bool find_processors_online(processorid_t** id_array, // Find the number of processors online. *id_length = sysconf(_SC_NPROCESSORS_ONLN); // Make up an array to hold their ids. - *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length); + *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal); // Processors need not be numbered consecutively. long found = 0; processorid_t next = 0; @@ -629,7 +629,7 @@ static bool assign_distribution(processorid_t* id_array, // The next id, to limit loops. const processorid_t limit_id = max_id + 1; // Make up markers for available processors. - bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id); + bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id, mtInternal); for (uint c = 0; c < limit_id; c += 1) { available_id[c] = false; } @@ -666,7 +666,7 @@ static bool assign_distribution(processorid_t* id_array, } } if (available_id != NULL) { - FREE_C_HEAP_ARRAY(bool, available_id); + FREE_C_HEAP_ARRAY(bool, available_id, mtInternal); } return true; } @@ -698,7 +698,7 @@ bool os::distribute_processes(uint length, uint* distribution) { } } if (id_array != NULL) { - FREE_C_HEAP_ARRAY(processorid_t, id_array); + FREE_C_HEAP_ARRAY(processorid_t, id_array, mtInternal); } return result; } @@ -771,8 +771,8 @@ void os::init_system_properties_values() { // code needs to be changed accordingly. // The next few definitions allow the code to be verbatim: -#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n)) -#define free(p) FREE_C_HEAP_ARRAY(char, p) +#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n), mtInternal) +#define free(p) FREE_C_HEAP_ARRAY(char, p, mtInternal) #define getenv(n) ::getenv(n) #define EXTENSIONS_DIR "/lib/ext" @@ -1927,11 +1927,11 @@ void os::dll_build_name(char* buffer, size_t buflen, // release the storage for (int i = 0 ; i < n ; i++) { if (pelements[i] != NULL) { - FREE_C_HEAP_ARRAY(char, pelements[i]); + FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal); } } if (pelements != NULL) { - FREE_C_HEAP_ARRAY(char*, pelements); + FREE_C_HEAP_ARRAY(char*, pelements, mtInternal); } } else { snprintf(buffer, buflen, "%s/lib%s.so", pname, fname); @@ -2662,17 +2662,17 @@ void os::Solaris::init_signal_mem() { // pending_signals has one int per signal // The additional signal is for SIGEXIT - exit signal to signal_thread - pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1)); + pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1), mtInternal); memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1))); if (UseSignalChaining) { chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction) - * (Maxsignum + 1)); + * (Maxsignum + 1), mtInternal); memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1))); - preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1)); + preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1), mtInternal); memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1))); } - ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 )); + ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ), mtInternal); memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1)); } @@ -2760,7 +2760,7 @@ int os::vm_allocation_granularity() { return page_size; } -bool os::commit_memory(char* addr, size_t bytes, bool exec) { +bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) { int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE; size_t size = bytes; char *res = Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot); @@ -2773,7 +2773,7 @@ bool os::commit_memory(char* addr, size_t bytes, bool exec) { return false; } -bool os::commit_memory(char* addr, size_t bytes, size_t alignment_hint, +bool os::pd_commit_memory(char* addr, size_t bytes, size_t alignment_hint, bool exec) { if (commit_memory(addr, bytes, exec)) { if (UseMPSS && alignment_hint > (size_t)vm_page_size()) { @@ -2803,14 +2803,14 @@ bool os::commit_memory(char* addr, size_t bytes, size_t alignment_hint, } // Uncommit the pages in a specified region. -void os::free_memory(char* addr, size_t bytes, size_t alignment_hint) { +void os::pd_free_memory(char* addr, size_t bytes, size_t alignment_hint) { if (madvise(addr, bytes, MADV_FREE) < 0) { debug_only(warning("MADV_FREE failed.")); return; } } -bool os::create_stack_guard_pages(char* addr, size_t size) { +bool os::pd_create_stack_guard_pages(char* addr, size_t size) { return os::commit_memory(addr, size); } @@ -2819,7 +2819,7 @@ bool os::remove_stack_guard_pages(char* addr, size_t size) { } // Change the page size in a given range. -void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { +void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned."); assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned."); if (UseLargePages && UseMPSS) { @@ -3006,7 +3006,7 @@ char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info return end; } -bool os::uncommit_memory(char* addr, size_t bytes) { +bool os::pd_uncommit_memory(char* addr, size_t bytes) { size_t size = bytes; // Map uncommitted pages PROT_NONE so we fail early if we touch an // uncommitted page. Otherwise, the read/write might succeed if we @@ -3045,7 +3045,7 @@ char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes, size_t alignmen return mmap_chunk(addr, bytes, flags, PROT_NONE); } -char* os::reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) { +char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) { char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL)); guarantee(requested_addr == NULL || requested_addr == addr, @@ -3056,7 +3056,7 @@ char* os::reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hi // Reserve memory at an arbitrary address, only if that area is // available (and not reserved for something else). -char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { +char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) { const int max_tries = 10; char* base[max_tries]; size_t size[max_tries]; @@ -3178,7 +3178,7 @@ char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { return (i < max_tries) ? requested_addr : NULL; } -bool os::release_memory(char* addr, size_t bytes) { +bool os::pd_release_memory(char* addr, size_t bytes) { size_t size = bytes; return munmap(addr, size) == 0; } @@ -4792,7 +4792,7 @@ bool isT2_libthread() { lwpSize = 16*1024; for (;;) { ::lseek64 (lwpFile, 0, SEEK_SET); - lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize); + lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize, mtInternal); if (::read(lwpFile, lwpArray, lwpSize) < 0) { if (ThreadPriorityVerbose) warning("Error reading /proc/self/lstatus\n"); break; @@ -4810,10 +4810,10 @@ bool isT2_libthread() { break; } lwpSize = lwpArray->pr_nent * lwpArray->pr_entsize; - FREE_C_HEAP_ARRAY(char, lwpArray); // retry. + FREE_C_HEAP_ARRAY(char, lwpArray, mtInternal); // retry. } - FREE_C_HEAP_ARRAY(char, lwpArray); + FREE_C_HEAP_ARRAY(char, lwpArray, mtInternal); ::close (lwpFile); if (ThreadPriorityVerbose) { if (isT2) tty->print_cr("We are running with a T2 libthread\n"); @@ -5137,9 +5137,9 @@ jint os::init_2(void) { UseNUMA = false; } else { size_t lgrp_limit = os::numa_get_groups_num(); - int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit); + int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit, mtInternal); size_t lgrp_num = os::numa_get_leaf_groups(lgrp_ids, lgrp_limit); - FREE_C_HEAP_ARRAY(int, lgrp_ids); + FREE_C_HEAP_ARRAY(int, lgrp_ids, mtInternal); if (lgrp_num < 2) { // There's only one locality group, disable NUMA. UseNUMA = false; @@ -5485,7 +5485,7 @@ int os::available(int fd, jlong *bytes) { } // Map a block of memory. -char* os::map_memory(int fd, const char* file_name, size_t file_offset, +char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset, char *addr, size_t bytes, bool read_only, bool allow_exec) { int prot; @@ -5517,7 +5517,7 @@ char* os::map_memory(int fd, const char* file_name, size_t file_offset, // Remap a block of memory. -char* os::remap_memory(int fd, const char* file_name, size_t file_offset, +char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset, char *addr, size_t bytes, bool read_only, bool allow_exec) { // same as map_memory() on this OS @@ -5527,7 +5527,7 @@ char* os::remap_memory(int fd, const char* file_name, size_t file_offset, // Unmap a block of memory. -bool os::unmap_memory(char* addr, size_t bytes) { +bool os::pd_unmap_memory(char* addr, size_t bytes) { return munmap(addr, bytes) == 0; } diff --git a/hotspot/src/os/solaris/vm/os_solaris.hpp b/hotspot/src/os/solaris/vm/os_solaris.hpp index 340aa4b7775..174f2529dbe 100644 --- a/hotspot/src/os/solaris/vm/os_solaris.hpp +++ b/hotspot/src/os/solaris/vm/os_solaris.hpp @@ -346,7 +346,7 @@ class Solaris { }; -class PlatformEvent : public CHeapObj { +class PlatformEvent : public CHeapObj { private: double CachePad [4] ; // increase odds that _mutex is sole occupant of cache line volatile int _Event ; @@ -383,7 +383,7 @@ class PlatformEvent : public CHeapObj { void unpark () ; } ; -class PlatformParker : public CHeapObj { +class PlatformParker : public CHeapObj { protected: mutex_t _mutex [1] ; cond_t _cond [1] ; diff --git a/hotspot/src/os/solaris/vm/os_solaris.inline.hpp b/hotspot/src/os/solaris/vm/os_solaris.inline.hpp index 7b63badc434..2468100fc43 100644 --- a/hotspot/src/os/solaris/vm/os_solaris.inline.hpp +++ b/hotspot/src/os/solaris/vm/os_solaris.inline.hpp @@ -71,7 +71,7 @@ inline bool os::allocate_stack_guard_pages() { // On Solaris, reservations are made on a page by page basis, nothing to do. -inline void os::split_reserved_memory(char *base, size_t size, +inline void os::pd_split_reserved_memory(char *base, size_t size, size_t split, bool realloc) { } diff --git a/hotspot/src/os/solaris/vm/perfMemory_solaris.cpp b/hotspot/src/os/solaris/vm/perfMemory_solaris.cpp index 1d1ff260cd8..c841ff8a1b6 100644 --- a/hotspot/src/os/solaris/vm/perfMemory_solaris.cpp +++ b/hotspot/src/os/solaris/vm/perfMemory_solaris.cpp @@ -128,7 +128,7 @@ static void save_memory_to_file(char* addr, size_t size) { } } } - FREE_C_HEAP_ARRAY(char, destfile); + FREE_C_HEAP_ARRAY(char, destfile, mtInternal); } @@ -155,7 +155,7 @@ static char* get_user_tmp_dir(const char* user) { const char* tmpdir = os::get_temp_directory(); const char* perfdir = PERFDATA_NAME; size_t nbytes = strlen(tmpdir) + strlen(perfdir) + strlen(user) + 3; - char* dirname = NEW_C_HEAP_ARRAY(char, nbytes); + char* dirname = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); // construct the path name to user specific tmp directory snprintf(dirname, nbytes, "%s/%s_%s", tmpdir, perfdir, user); @@ -248,7 +248,7 @@ static char* get_user_name(uid_t uid) { if (bufsize == -1) bufsize = 1024; - char* pwbuf = NEW_C_HEAP_ARRAY(char, bufsize); + char* pwbuf = NEW_C_HEAP_ARRAY(char, bufsize, mtInternal); #ifdef _GNU_SOURCE struct passwd* p = NULL; @@ -269,14 +269,14 @@ static char* get_user_name(uid_t uid) { "pw_name zero length"); } } - FREE_C_HEAP_ARRAY(char, pwbuf); + FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal); return NULL; } - char* user_name = NEW_C_HEAP_ARRAY(char, strlen(p->pw_name) + 1); + char* user_name = NEW_C_HEAP_ARRAY(char, strlen(p->pw_name) + 1, mtInternal); strcpy(user_name, p->pw_name); - FREE_C_HEAP_ARRAY(char, pwbuf); + FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal); return user_name; } @@ -319,7 +319,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { // to determine the user name for the process id. // struct dirent* dentry; - char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname)); + char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname), mtInternal); errno = 0; while ((dentry = os::readdir(tmpdirp, (struct dirent *)tdbuf)) != NULL) { @@ -329,7 +329,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { } char* usrdir_name = NEW_C_HEAP_ARRAY(char, - strlen(tmpdirname) + strlen(dentry->d_name) + 2); + strlen(tmpdirname) + strlen(dentry->d_name) + 2, mtInternal); strcpy(usrdir_name, tmpdirname); strcat(usrdir_name, "/"); strcat(usrdir_name, dentry->d_name); @@ -337,7 +337,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { DIR* subdirp = os::opendir(usrdir_name); if (subdirp == NULL) { - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); continue; } @@ -348,13 +348,13 @@ static char* get_user_name_slow(int vmid, TRAPS) { // symlink can be exploited. // if (!is_directory_secure(usrdir_name)) { - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); os::closedir(subdirp); continue; } struct dirent* udentry; - char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name)); + char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name), mtInternal); errno = 0; while ((udentry = os::readdir(subdirp, (struct dirent *)udbuf)) != NULL) { @@ -363,7 +363,7 @@ static char* get_user_name_slow(int vmid, TRAPS) { int result; char* filename = NEW_C_HEAP_ARRAY(char, - strlen(usrdir_name) + strlen(udentry->d_name) + 2); + strlen(usrdir_name) + strlen(udentry->d_name) + 2, mtInternal); strcpy(filename, usrdir_name); strcat(filename, "/"); @@ -372,13 +372,13 @@ static char* get_user_name_slow(int vmid, TRAPS) { // don't follow symbolic links for the file RESTARTABLE(::lstat(filename, &statbuf), result); if (result == OS_ERR) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); continue; } // skip over files that are not regular files. if (!S_ISREG(statbuf.st_mode)) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); continue; } @@ -388,23 +388,23 @@ static char* get_user_name_slow(int vmid, TRAPS) { if (statbuf.st_ctime > oldest_ctime) { char* user = strchr(dentry->d_name, '_') + 1; - if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user); - oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1); + if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user, mtInternal); + oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1, mtInternal); strcpy(oldest_user, user); oldest_ctime = statbuf.st_ctime; } } - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); } } os::closedir(subdirp); - FREE_C_HEAP_ARRAY(char, udbuf); - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, udbuf, mtInternal); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); } os::closedir(tmpdirp); - FREE_C_HEAP_ARRAY(char, tdbuf); + FREE_C_HEAP_ARRAY(char, tdbuf, mtInternal); return(oldest_user); } @@ -471,7 +471,7 @@ static char* get_sharedmem_filename(const char* dirname, int vmid) { // add 2 for the file separator and a NULL terminator. size_t nbytes = strlen(dirname) + UINT_CHARS + 2; - char* name = NEW_C_HEAP_ARRAY(char, nbytes); + char* name = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); snprintf(name, nbytes, "%s/%d", dirname, vmid); return name; @@ -509,7 +509,7 @@ static void remove_file(const char* path) { static void remove_file(const char* dirname, const char* filename) { size_t nbytes = strlen(dirname) + strlen(filename) + 2; - char* path = NEW_C_HEAP_ARRAY(char, nbytes); + char* path = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); strcpy(path, dirname); strcat(path, "/"); @@ -517,7 +517,7 @@ static void remove_file(const char* dirname, const char* filename) { remove_file(path); - FREE_C_HEAP_ARRAY(char, path); + FREE_C_HEAP_ARRAY(char, path, mtInternal); } @@ -554,7 +554,7 @@ static void cleanup_sharedmem_resources(const char* dirname) { // opendir/readdir. // struct dirent* entry; - char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname)); + char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname), mtInternal); errno = 0; while ((entry = os::readdir(dirp, (struct dirent *)dbuf)) != NULL) { @@ -593,7 +593,7 @@ static void cleanup_sharedmem_resources(const char* dirname) { errno = 0; } os::closedir(dirp); - FREE_C_HEAP_ARRAY(char, dbuf); + FREE_C_HEAP_ARRAY(char, dbuf, mtInternal); } // make the user specific temporary directory. Returns true if @@ -738,11 +738,11 @@ static char* mmap_create_shared(size_t size) { fd = create_sharedmem_resources(dirname, filename, size); - FREE_C_HEAP_ARRAY(char, user_name); - FREE_C_HEAP_ARRAY(char, dirname); + FREE_C_HEAP_ARRAY(char, user_name, mtInternal); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); if (fd == -1) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); return NULL; } @@ -758,7 +758,7 @@ static char* mmap_create_shared(size_t size) { warning("mmap failed - %s\n", strerror(errno)); } remove_file(filename); - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); return NULL; } @@ -884,7 +884,7 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor // store file, we don't follow them when attaching either. // if (!is_directory_secure(dirname)) { - FREE_C_HEAP_ARRAY(char, dirname); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Process not found"); } @@ -899,9 +899,9 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor strcpy(rfilename, filename); // free the c heap resources that are no longer needed - if (luser != user) FREE_C_HEAP_ARRAY(char, luser); - FREE_C_HEAP_ARRAY(char, dirname); - FREE_C_HEAP_ARRAY(char, filename); + if (luser != user) FREE_C_HEAP_ARRAY(char, luser, mtInternal); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); // open the shared memory file for the give vmid fd = open_sharedmem_file(rfilename, file_flags, CHECK); diff --git a/hotspot/src/os/windows/vm/os_windows.cpp b/hotspot/src/os/windows/vm/os_windows.cpp index 440b8026233..5534a1ea0a1 100644 --- a/hotspot/src/os/windows/vm/os_windows.cpp +++ b/hotspot/src/os/windows/vm/os_windows.cpp @@ -96,7 +96,6 @@ #include #include // For _beginthreadex(), _endthreadex() #include // For os::dll_address_to_function_name - /* for enumerating dll libraries */ #include @@ -214,13 +213,13 @@ void os::init_system_properties_values() { } } - home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1); + home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1, mtInternal); if (home_path == NULL) return; strcpy(home_path, home_dir); Arguments::set_java_home(home_path); - dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1); + dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1, mtInternal); if (dll_path == NULL) return; strcpy(dll_path, home_dir); @@ -251,7 +250,7 @@ void os::init_system_properties_values() { char *path_str = ::getenv("PATH"); library_path = NEW_C_HEAP_ARRAY(char, MAX_PATH * 5 + sizeof(PACKAGE_DIR) + - sizeof(BIN_DIR) + (path_str ? strlen(path_str) : 0) + 10); + sizeof(BIN_DIR) + (path_str ? strlen(path_str) : 0) + 10, mtInternal); library_path[0] = '\0'; @@ -280,7 +279,7 @@ void os::init_system_properties_values() { strcat(library_path, ";."); Arguments::set_library_path(library_path); - FREE_C_HEAP_ARRAY(char, library_path); + FREE_C_HEAP_ARRAY(char, library_path, mtInternal); } /* Default extensions directory */ @@ -300,7 +299,7 @@ void os::init_system_properties_values() { { #define ENDORSED_DIR "\\lib\\endorsed" size_t len = strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR); - char * buf = NEW_C_HEAP_ARRAY(char, len); + char * buf = NEW_C_HEAP_ARRAY(char, len, mtInternal); sprintf(buf, "%s%s", Arguments::get_java_home(), ENDORSED_DIR); Arguments::set_endorsed_dirs(buf); #undef ENDORSED_DIR @@ -324,6 +323,23 @@ extern "C" void breakpoint() { os::breakpoint(); } +/* + * RtlCaptureStackBackTrace Windows API may not exist prior to Windows XP. + * So far, this method is only used by Native Memory Tracking, which is + * only supported on Windows XP or later. + */ +address os::get_caller_pc(int n) { +#ifdef _NMT_NOINLINE_ + n ++; +#endif + address pc; + if (os::Kernel32Dll::RtlCaptureStackBackTrace(n + 1, 1, (PVOID*)&pc, NULL) == 1) { + return pc; + } + return NULL; +} + + // os::current_stack_base() // // Returns the base of the stack, which is the stack's @@ -1014,7 +1030,7 @@ DIR * os::opendir(const char *dirname) { assert(dirname != NULL, "just checking"); // hotspot change - DIR *dirp = (DIR *)malloc(sizeof(DIR)); + DIR *dirp = (DIR *)malloc(sizeof(DIR), mtInternal); DWORD fattr; // hotspot change char alt_dirname[4] = { 0, 0, 0, 0 }; @@ -1036,9 +1052,9 @@ os::opendir(const char *dirname) dirname = alt_dirname; } - dirp->path = (char *)malloc(strlen(dirname) + 5); + dirp->path = (char *)malloc(strlen(dirname) + 5, mtInternal); if (dirp->path == 0) { - free(dirp); + free(dirp, mtInternal); errno = ENOMEM; return 0; } @@ -1046,13 +1062,13 @@ os::opendir(const char *dirname) fattr = GetFileAttributes(dirp->path); if (fattr == 0xffffffff) { - free(dirp->path); - free(dirp); + free(dirp->path, mtInternal); + free(dirp, mtInternal); errno = ENOENT; return 0; } else if ((fattr & FILE_ATTRIBUTE_DIRECTORY) == 0) { - free(dirp->path); - free(dirp); + free(dirp->path, mtInternal); + free(dirp, mtInternal); errno = ENOTDIR; return 0; } @@ -1070,8 +1086,8 @@ os::opendir(const char *dirname) dirp->handle = FindFirstFile(dirp->path, &dirp->find_data); if (dirp->handle == INVALID_HANDLE_VALUE) { if (GetLastError() != ERROR_FILE_NOT_FOUND) { - free(dirp->path); - free(dirp); + free(dirp->path, mtInternal); + free(dirp, mtInternal); errno = EACCES; return 0; } @@ -1114,8 +1130,8 @@ os::closedir(DIR *dirp) } dirp->handle = INVALID_HANDLE_VALUE; } - free(dirp->path); - free(dirp); + free(dirp->path, mtInternal); + free(dirp, mtInternal); return 0; } @@ -1176,11 +1192,11 @@ void os::dll_build_name(char *buffer, size_t buflen, // release the storage for (int i = 0 ; i < n ; i++) { if (pelements[i] != NULL) { - FREE_C_HEAP_ARRAY(char, pelements[i]); + FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal); } } if (pelements != NULL) { - FREE_C_HEAP_ARRAY(char*, pelements); + FREE_C_HEAP_ARRAY(char*, pelements, mtInternal); } } else { jio_snprintf(buffer, buflen, "%s\\%s.dll", pname, fname); @@ -2637,7 +2653,7 @@ private: void free_node_list() { if (_numa_used_node_list != NULL) { - FREE_C_HEAP_ARRAY(int, _numa_used_node_list); + FREE_C_HEAP_ARRAY(int, _numa_used_node_list, mtInternal); } } @@ -2659,7 +2675,7 @@ public: ULONG highest_node_number; if (!os::Kernel32Dll::GetNumaHighestNodeNumber(&highest_node_number)) return false; free_node_list(); - _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1); + _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1, mtInternal); for (unsigned int i = 0; i <= highest_node_number; i++) { ULONGLONG proc_mask_numa_node; if (!os::Kernel32Dll::GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false; @@ -2918,7 +2934,7 @@ void os::large_page_init() { // On win32, one cannot release just a part of reserved memory, it's an // all or nothing deal. When we split a reservation, we must break the // reservation into two reservations. -void os::split_reserved_memory(char *base, size_t size, size_t split, +void os::pd_split_reserved_memory(char *base, size_t size, size_t split, bool realloc) { if (size > 0) { release_memory(base, size); @@ -2931,7 +2947,7 @@ void os::split_reserved_memory(char *base, size_t size, size_t split, } } -char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { +char* os::pd_reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { assert((size_t)addr % os::vm_allocation_granularity() == 0, "reserve alignment"); assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size"); @@ -2964,7 +2980,7 @@ char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { // Reserve memory at an arbitrary address, only if that area is // available (and not reserved for something else). -char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { +char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) { // Windows os::reserve_memory() fails of the requested address range is // not avilable. return reserve_memory(bytes, requested_addr); @@ -3027,7 +3043,7 @@ bool os::release_memory_special(char* base, size_t bytes) { void os::print_statistics() { } -bool os::commit_memory(char* addr, size_t bytes, bool exec) { +bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) { if (bytes == 0) { // Don't bother the OS with noops. return true; @@ -3075,26 +3091,26 @@ bool os::commit_memory(char* addr, size_t bytes, bool exec) { return true; } -bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, +bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint, bool exec) { return commit_memory(addr, size, exec); } -bool os::uncommit_memory(char* addr, size_t bytes) { +bool os::pd_uncommit_memory(char* addr, size_t bytes) { if (bytes == 0) { // Don't bother the OS with noops. return true; } assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries"); assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks"); - return VirtualFree(addr, bytes, MEM_DECOMMIT) != 0; + return (VirtualFree(addr, bytes, MEM_DECOMMIT) != 0); } -bool os::release_memory(char* addr, size_t bytes) { +bool os::pd_release_memory(char* addr, size_t bytes) { return VirtualFree(addr, 0, MEM_RELEASE) != 0; } -bool os::create_stack_guard_pages(char* addr, size_t size) { +bool os::pd_create_stack_guard_pages(char* addr, size_t size) { return os::commit_memory(addr, size); } @@ -3141,8 +3157,8 @@ bool os::unguard_memory(char* addr, size_t bytes) { return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0; } -void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } -void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { } +void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } +void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { } void os::numa_make_global(char *addr, size_t bytes) { } void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { } bool os::numa_topology_changed() { return false; } @@ -4276,14 +4292,14 @@ static int stdinAvailable(int fd, long *pbytes) { numEvents = MAX_INPUT_EVENTS; } - lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD)); + lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal); if (lpBuffer == NULL) { return FALSE; } error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead); if (error == 0) { - os::free(lpBuffer); + os::free(lpBuffer, mtInternal); return FALSE; } @@ -4304,7 +4320,7 @@ static int stdinAvailable(int fd, long *pbytes) { } if(lpBuffer != NULL) { - os::free(lpBuffer); + os::free(lpBuffer, mtInternal); } *pbytes = (long) actualLength; @@ -4312,7 +4328,7 @@ static int stdinAvailable(int fd, long *pbytes) { } // Map a block of memory. -char* os::map_memory(int fd, const char* file_name, size_t file_offset, +char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset, char *addr, size_t bytes, bool read_only, bool allow_exec) { HANDLE hFile; @@ -4432,7 +4448,7 @@ char* os::map_memory(int fd, const char* file_name, size_t file_offset, // Remap a block of memory. -char* os::remap_memory(int fd, const char* file_name, size_t file_offset, +char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset, char *addr, size_t bytes, bool read_only, bool allow_exec) { // This OS does not allow existing memory maps to be remapped so we @@ -4445,15 +4461,15 @@ char* os::remap_memory(int fd, const char* file_name, size_t file_offset, // call above and the map_memory() call below where a thread in native // code may be able to access an address that is no longer mapped. - return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only, - allow_exec); + return os::map_memory(fd, file_name, file_offset, addr, bytes, + read_only, allow_exec); } // Unmap a block of memory. // Returns true=success, otherwise false. -bool os::unmap_memory(char* addr, size_t bytes) { +bool os::pd_unmap_memory(char* addr, size_t bytes) { BOOL result = UnmapViewOfFile(addr); if (result == 0) { if (PrintMiscellaneous && Verbose) { @@ -4931,11 +4947,15 @@ typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void); typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD); typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn) (PULONG); typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn) (UCHAR, PULONGLONG); +typedef USHORT (WINAPI* RtlCaptureStackBackTrace_Fn)(ULONG, ULONG, PVOID*, PULONG); GetLargePageMinimum_Fn os::Kernel32Dll::_GetLargePageMinimum = NULL; VirtualAllocExNuma_Fn os::Kernel32Dll::_VirtualAllocExNuma = NULL; GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL; GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL; +RtlCaptureStackBackTrace_Fn os::Kernel32Dll::_RtlCaptureStackBackTrace = NULL; + + BOOL os::Kernel32Dll::initialized = FALSE; SIZE_T os::Kernel32Dll::GetLargePageMinimum() { assert(initialized && _GetLargePageMinimum != NULL, @@ -4978,6 +4998,19 @@ BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, PULONGLONG proc_mask) return _GetNumaNodeProcessorMask(node, proc_mask); } +USHORT os::Kernel32Dll::RtlCaptureStackBackTrace(ULONG FrameToSkip, + ULONG FrameToCapture, PVOID* BackTrace, PULONG BackTraceHash) { + if (!initialized) { + initialize(); + } + + if (_RtlCaptureStackBackTrace != NULL) { + return _RtlCaptureStackBackTrace(FrameToSkip, FrameToCapture, + BackTrace, BackTraceHash); + } else { + return 0; + } +} void os::Kernel32Dll::initializeCommon() { if (!initialized) { @@ -4987,6 +5020,7 @@ void os::Kernel32Dll::initializeCommon() { _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma"); _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber"); _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask"); + _RtlCaptureStackBackTrace = (RtlCaptureStackBackTrace_Fn)::GetProcAddress(handle, "RtlCaptureStackBackTrace"); initialized = TRUE; } } @@ -5101,7 +5135,6 @@ Module32First_Fn os::Kernel32Dll::_Module32First = NULL; Module32Next_Fn os::Kernel32Dll::_Module32Next = NULL; GetNativeSystemInfo_Fn os::Kernel32Dll::_GetNativeSystemInfo = NULL; - void os::Kernel32Dll::initialize() { if (!initialized) { HMODULE handle = ::GetModuleHandle("Kernel32.dll"); @@ -5179,8 +5212,6 @@ void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) { _GetNativeSystemInfo(lpSystemInfo); } - - // PSAPI API diff --git a/hotspot/src/os/windows/vm/os_windows.hpp b/hotspot/src/os/windows/vm/os_windows.hpp index e0692e5f2f7..33ea7064ba6 100644 --- a/hotspot/src/os/windows/vm/os_windows.hpp +++ b/hotspot/src/os/windows/vm/os_windows.hpp @@ -98,7 +98,7 @@ class win32 { static LONG WINAPI serialize_fault_filter(struct _EXCEPTION_POINTERS* e); }; -class PlatformEvent : public CHeapObj { +class PlatformEvent : public CHeapObj { private: double CachePad [4] ; // increase odds that _Event is sole occupant of cache line volatile int _Event ; @@ -124,7 +124,7 @@ class PlatformEvent : public CHeapObj { -class PlatformParker : public CHeapObj { +class PlatformParker : public CHeapObj { protected: HANDLE _ParkEvent ; @@ -182,6 +182,9 @@ public: static BOOL GetNumaHighestNodeNumber(PULONG); static BOOL GetNumaNodeProcessorMask(UCHAR, PULONGLONG); + // Stack walking + static USHORT RtlCaptureStackBackTrace(ULONG, ULONG, PVOID*, PULONG); + private: // GetLargePageMinimum available on Windows Vista/Windows Server 2003 // and later @@ -191,6 +194,7 @@ private: static LPVOID (WINAPI *_VirtualAllocExNuma) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD); static BOOL (WINAPI *_GetNumaHighestNodeNumber) (PULONG); static BOOL (WINAPI *_GetNumaNodeProcessorMask) (UCHAR, PULONGLONG); + static USHORT (WINAPI *_RtlCaptureStackBackTrace)(ULONG, ULONG, PVOID*, PULONG); static BOOL initialized; static void initialize(); diff --git a/hotspot/src/os/windows/vm/perfMemory_windows.cpp b/hotspot/src/os/windows/vm/perfMemory_windows.cpp index 4f3280d5906..2358171b78a 100644 --- a/hotspot/src/os/windows/vm/perfMemory_windows.cpp +++ b/hotspot/src/os/windows/vm/perfMemory_windows.cpp @@ -120,7 +120,7 @@ static void save_memory_to_file(char* addr, size_t size) { } } - FREE_C_HEAP_ARRAY(char, destfile); + FREE_C_HEAP_ARRAY(char, destfile, mtInternal); } // Shared Memory Implementation Details @@ -157,7 +157,7 @@ static char* get_user_tmp_dir(const char* user) { const char* tmpdir = os::get_temp_directory(); const char* perfdir = PERFDATA_NAME; size_t nbytes = strlen(tmpdir) + strlen(perfdir) + strlen(user) + 3; - char* dirname = NEW_C_HEAP_ARRAY(char, nbytes); + char* dirname = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); // construct the path name to user specific tmp directory _snprintf(dirname, nbytes, "%s\\%s_%s", tmpdir, perfdir, user); @@ -281,7 +281,7 @@ static char* get_user_name() { } } - char* user_name = NEW_C_HEAP_ARRAY(char, strlen(user)+1); + char* user_name = NEW_C_HEAP_ARRAY(char, strlen(user)+1, mtInternal); strcpy(user_name, user); return user_name; @@ -315,7 +315,7 @@ static char* get_user_name_slow(int vmid) { // to determine the user name for the process id. // struct dirent* dentry; - char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname)); + char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname), mtInternal); errno = 0; while ((dentry = os::readdir(tmpdirp, (struct dirent *)tdbuf)) != NULL) { @@ -325,7 +325,7 @@ static char* get_user_name_slow(int vmid) { } char* usrdir_name = NEW_C_HEAP_ARRAY(char, - strlen(tmpdirname) + strlen(dentry->d_name) + 2); + strlen(tmpdirname) + strlen(dentry->d_name) + 2, mtInternal); strcpy(usrdir_name, tmpdirname); strcat(usrdir_name, "\\"); strcat(usrdir_name, dentry->d_name); @@ -333,7 +333,7 @@ static char* get_user_name_slow(int vmid) { DIR* subdirp = os::opendir(usrdir_name); if (subdirp == NULL) { - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); continue; } @@ -344,13 +344,13 @@ static char* get_user_name_slow(int vmid) { // symlink can be exploited. // if (!is_directory_secure(usrdir_name)) { - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); os::closedir(subdirp); continue; } struct dirent* udentry; - char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name)); + char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name), mtInternal); errno = 0; while ((udentry = os::readdir(subdirp, (struct dirent *)udbuf)) != NULL) { @@ -358,20 +358,20 @@ static char* get_user_name_slow(int vmid) { struct stat statbuf; char* filename = NEW_C_HEAP_ARRAY(char, - strlen(usrdir_name) + strlen(udentry->d_name) + 2); + strlen(usrdir_name) + strlen(udentry->d_name) + 2, mtInternal); strcpy(filename, usrdir_name); strcat(filename, "\\"); strcat(filename, udentry->d_name); if (::stat(filename, &statbuf) == OS_ERR) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); continue; } // skip over files that are not regular files. if ((statbuf.st_mode & S_IFMT) != S_IFREG) { - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); continue; } @@ -393,22 +393,22 @@ static char* get_user_name_slow(int vmid) { if (statbuf.st_ctime > latest_ctime) { char* user = strchr(dentry->d_name, '_') + 1; - if (latest_user != NULL) FREE_C_HEAP_ARRAY(char, latest_user); - latest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1); + if (latest_user != NULL) FREE_C_HEAP_ARRAY(char, latest_user, mtInternal); + latest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1, mtInternal); strcpy(latest_user, user); latest_ctime = statbuf.st_ctime; } - FREE_C_HEAP_ARRAY(char, filename); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); } } os::closedir(subdirp); - FREE_C_HEAP_ARRAY(char, udbuf); - FREE_C_HEAP_ARRAY(char, usrdir_name); + FREE_C_HEAP_ARRAY(char, udbuf, mtInternal); + FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal); } os::closedir(tmpdirp); - FREE_C_HEAP_ARRAY(char, tdbuf); + FREE_C_HEAP_ARRAY(char, tdbuf, mtInternal); return(latest_user); } @@ -453,7 +453,7 @@ static char *get_sharedmem_objectname(const char* user, int vmid) { // about a name containing a '-' characters. // nbytes += UINT_CHARS; - char* name = NEW_C_HEAP_ARRAY(char, nbytes); + char* name = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); _snprintf(name, nbytes, "%s_%s_%u", PERFDATA_NAME, user, vmid); return name; @@ -469,7 +469,7 @@ static char* get_sharedmem_filename(const char* dirname, int vmid) { // add 2 for the file separator and a null terminator. size_t nbytes = strlen(dirname) + UINT_CHARS + 2; - char* name = NEW_C_HEAP_ARRAY(char, nbytes); + char* name = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); _snprintf(name, nbytes, "%s\\%d", dirname, vmid); return name; @@ -485,7 +485,7 @@ static char* get_sharedmem_filename(const char* dirname, int vmid) { static void remove_file(const char* dirname, const char* filename) { size_t nbytes = strlen(dirname) + strlen(filename) + 2; - char* path = NEW_C_HEAP_ARRAY(char, nbytes); + char* path = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); strcpy(path, dirname); strcat(path, "\\"); @@ -500,7 +500,7 @@ static void remove_file(const char* dirname, const char* filename) { } } - FREE_C_HEAP_ARRAY(char, path); + FREE_C_HEAP_ARRAY(char, path, mtInternal); } // returns true if the process represented by pid is alive, otherwise @@ -638,7 +638,7 @@ static void cleanup_sharedmem_resources(const char* dirname) { // opendir/readdir. // struct dirent* entry; - char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname)); + char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname), mtInternal); errno = 0; while ((entry = os::readdir(dirp, (struct dirent *)dbuf)) != NULL) { @@ -681,7 +681,7 @@ static void cleanup_sharedmem_resources(const char* dirname) { errno = 0; } os::closedir(dirp); - FREE_C_HEAP_ARRAY(char, dbuf); + FREE_C_HEAP_ARRAY(char, dbuf, mtInternal); } // create a file mapping object with the requested name, and size @@ -747,11 +747,11 @@ static void free_security_desc(PSECURITY_DESCRIPTOR pSD) { // be an ACL we enlisted. free the resources. // if (success && exists && pACL != NULL && !isdefault) { - FREE_C_HEAP_ARRAY(char, pACL); + FREE_C_HEAP_ARRAY(char, pACL, mtInternal); } // free the security descriptor - FREE_C_HEAP_ARRAY(char, pSD); + FREE_C_HEAP_ARRAY(char, pSD, mtInternal); } } @@ -766,7 +766,7 @@ static void free_security_attr(LPSECURITY_ATTRIBUTES lpSA) { lpSA->lpSecurityDescriptor = NULL; // free the security attributes structure - FREE_C_HEAP_ARRAY(char, lpSA); + FREE_C_HEAP_ARRAY(char, lpSA, mtInternal); } } @@ -805,7 +805,7 @@ static PSID get_user_sid(HANDLE hProcess) { } } - token_buf = (PTOKEN_USER) NEW_C_HEAP_ARRAY(char, rsize); + token_buf = (PTOKEN_USER) NEW_C_HEAP_ARRAY(char, rsize, mtInternal); // get the user token information if (!GetTokenInformation(hAccessToken, TokenUser, token_buf, rsize, &rsize)) { @@ -813,28 +813,28 @@ static PSID get_user_sid(HANDLE hProcess) { warning("GetTokenInformation failure: lasterror = %d," " rsize = %d\n", GetLastError(), rsize); } - FREE_C_HEAP_ARRAY(char, token_buf); + FREE_C_HEAP_ARRAY(char, token_buf, mtInternal); CloseHandle(hAccessToken); return NULL; } DWORD nbytes = GetLengthSid(token_buf->User.Sid); - PSID pSID = NEW_C_HEAP_ARRAY(char, nbytes); + PSID pSID = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal); if (!CopySid(nbytes, pSID, token_buf->User.Sid)) { if (PrintMiscellaneous && Verbose) { warning("GetTokenInformation failure: lasterror = %d," " rsize = %d\n", GetLastError(), rsize); } - FREE_C_HEAP_ARRAY(char, token_buf); - FREE_C_HEAP_ARRAY(char, pSID); + FREE_C_HEAP_ARRAY(char, token_buf, mtInternal); + FREE_C_HEAP_ARRAY(char, pSID, mtInternal); CloseHandle(hAccessToken); return NULL; } // close the access token. CloseHandle(hAccessToken); - FREE_C_HEAP_ARRAY(char, token_buf); + FREE_C_HEAP_ARRAY(char, token_buf, mtInternal); return pSID; } @@ -912,13 +912,13 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, } // create the new ACL - newACL = (PACL) NEW_C_HEAP_ARRAY(char, newACLsize); + newACL = (PACL) NEW_C_HEAP_ARRAY(char, newACLsize, mtInternal); if (!InitializeAcl(newACL, newACLsize, ACL_REVISION)) { if (PrintMiscellaneous && Verbose) { warning("InitializeAcl failure: lasterror = %d \n", GetLastError()); } - FREE_C_HEAP_ARRAY(char, newACL); + FREE_C_HEAP_ARRAY(char, newACL, mtInternal); return false; } @@ -931,7 +931,7 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, if (PrintMiscellaneous && Verbose) { warning("InitializeAcl failure: lasterror = %d \n", GetLastError()); } - FREE_C_HEAP_ARRAY(char, newACL); + FREE_C_HEAP_ARRAY(char, newACL, mtInternal); return false; } if (((ACCESS_ALLOWED_ACE *)ace)->Header.AceFlags && INHERITED_ACE) { @@ -958,7 +958,7 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, if (PrintMiscellaneous && Verbose) { warning("AddAce failure: lasterror = %d \n", GetLastError()); } - FREE_C_HEAP_ARRAY(char, newACL); + FREE_C_HEAP_ARRAY(char, newACL, mtInternal); return false; } } @@ -974,7 +974,7 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, warning("AddAccessAllowedAce failure: lasterror = %d \n", GetLastError()); } - FREE_C_HEAP_ARRAY(char, newACL); + FREE_C_HEAP_ARRAY(char, newACL, mtInternal); return false; } } @@ -989,7 +989,7 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, if (PrintMiscellaneous && Verbose) { warning("InitializeAcl failure: lasterror = %d \n", GetLastError()); } - FREE_C_HEAP_ARRAY(char, newACL); + FREE_C_HEAP_ARRAY(char, newACL, mtInternal); return false; } if (!AddAce(newACL, ACL_REVISION, MAXDWORD, ace, @@ -997,7 +997,7 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, if (PrintMiscellaneous && Verbose) { warning("AddAce failure: lasterror = %d \n", GetLastError()); } - FREE_C_HEAP_ARRAY(char, newACL); + FREE_C_HEAP_ARRAY(char, newACL, mtInternal); return false; } ace_index++; @@ -1010,7 +1010,7 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, warning("SetSecurityDescriptorDacl failure:" " lasterror = %d \n", GetLastError()); } - FREE_C_HEAP_ARRAY(char, newACL); + FREE_C_HEAP_ARRAY(char, newACL, mtInternal); return false; } @@ -1030,7 +1030,7 @@ static bool add_allow_aces(PSECURITY_DESCRIPTOR pSD, warning("SetSecurityDescriptorControl failure:" " lasterror = %d \n", GetLastError()); } - FREE_C_HEAP_ARRAY(char, newACL); + FREE_C_HEAP_ARRAY(char, newACL, mtInternal); return false; } } @@ -1054,7 +1054,7 @@ static LPSECURITY_ATTRIBUTES make_security_attr(ace_data_t aces[], int count) { // allocate space for a security descriptor PSECURITY_DESCRIPTOR pSD = (PSECURITY_DESCRIPTOR) - NEW_C_HEAP_ARRAY(char, SECURITY_DESCRIPTOR_MIN_LENGTH); + NEW_C_HEAP_ARRAY(char, SECURITY_DESCRIPTOR_MIN_LENGTH, mtInternal); // initialize the security descriptor if (!InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION)) { @@ -1076,7 +1076,7 @@ static LPSECURITY_ATTRIBUTES make_security_attr(ace_data_t aces[], int count) { // return it to the caller. // LPSECURITY_ATTRIBUTES lpSA = (LPSECURITY_ATTRIBUTES) - NEW_C_HEAP_ARRAY(char, sizeof(SECURITY_ATTRIBUTES)); + NEW_C_HEAP_ARRAY(char, sizeof(SECURITY_ATTRIBUTES), mtInternal); lpSA->nLength = sizeof(SECURITY_ATTRIBUTES); lpSA->lpSecurityDescriptor = pSD; lpSA->bInheritHandle = FALSE; @@ -1147,7 +1147,7 @@ static LPSECURITY_ATTRIBUTES make_user_everybody_admin_security_attr( // create a security attributes structure with access control // entries as initialized above. LPSECURITY_ATTRIBUTES lpSA = make_security_attr(aces, 3); - FREE_C_HEAP_ARRAY(char, aces[0].pSid); + FREE_C_HEAP_ARRAY(char, aces[0].pSid, mtInternal); FreeSid(everybodySid); FreeSid(administratorsSid); return(lpSA); @@ -1462,15 +1462,15 @@ static char* mapping_create_shared(size_t size) { assert(((size != 0) && (size % os::vm_page_size() == 0)), "unexpected PerfMemry region size"); - FREE_C_HEAP_ARRAY(char, user); + FREE_C_HEAP_ARRAY(char, user, mtInternal); // create the shared memory resources sharedmem_fileMapHandle = create_sharedmem_resources(dirname, filename, objectname, size); - FREE_C_HEAP_ARRAY(char, filename); - FREE_C_HEAP_ARRAY(char, objectname); - FREE_C_HEAP_ARRAY(char, dirname); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); + FREE_C_HEAP_ARRAY(char, objectname, mtInternal); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); if (sharedmem_fileMapHandle == NULL) { return NULL; @@ -1621,7 +1621,7 @@ static void open_file_mapping(const char* user, int vmid, // store file, we also don't following them when attaching // if (!is_directory_secure(dirname)) { - FREE_C_HEAP_ARRAY(char, dirname); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Process not found"); } @@ -1640,10 +1640,10 @@ static void open_file_mapping(const char* user, int vmid, strcpy(robjectname, objectname); // free the c heap resources that are no longer needed - if (luser != user) FREE_C_HEAP_ARRAY(char, luser); - FREE_C_HEAP_ARRAY(char, dirname); - FREE_C_HEAP_ARRAY(char, filename); - FREE_C_HEAP_ARRAY(char, objectname); + if (luser != user) FREE_C_HEAP_ARRAY(char, luser, mtInternal); + FREE_C_HEAP_ARRAY(char, dirname, mtInternal); + FREE_C_HEAP_ARRAY(char, filename, mtInternal); + FREE_C_HEAP_ARRAY(char, objectname, mtInternal); if (*sizep == 0) { size = sharedmem_filesize(rfilename, CHECK); diff --git a/hotspot/src/share/vm/asm/codeBuffer.cpp b/hotspot/src/share/vm/asm/codeBuffer.cpp index f52b942df2c..8235786b40a 100644 --- a/hotspot/src/share/vm/asm/codeBuffer.cpp +++ b/hotspot/src/share/vm/asm/codeBuffer.cpp @@ -261,7 +261,7 @@ address CodeBuffer::decode_begin() { GrowableArray* CodeBuffer::create_patch_overflow() { if (_overflow_arena == NULL) { - _overflow_arena = new Arena(); + _overflow_arena = new (mtCode) Arena(); } return new (_overflow_arena) GrowableArray(_overflow_arena, 8, 0, 0); } @@ -910,7 +910,7 @@ void CodeBuffer::block_comment(intptr_t offset, const char * comment) { _comments.add_comment(offset, comment); } -class CodeComment: public CHeapObj { +class CodeComment: public CHeapObj { private: friend class CodeComments; intptr_t _offset; @@ -919,13 +919,13 @@ class CodeComment: public CHeapObj { ~CodeComment() { assert(_next == NULL, "wrong interface for freeing list"); - os::free((void*)_comment); + os::free((void*)_comment, mtCode); } public: CodeComment(intptr_t offset, const char * comment) { _offset = offset; - _comment = os::strdup(comment); + _comment = os::strdup(comment, mtCode); _next = NULL; } diff --git a/hotspot/src/share/vm/c1/c1_CFGPrinter.cpp b/hotspot/src/share/vm/c1/c1_CFGPrinter.cpp index 4964ebd683e..66a7e225ebd 100644 --- a/hotspot/src/share/vm/c1/c1_CFGPrinter.cpp +++ b/hotspot/src/share/vm/c1/c1_CFGPrinter.cpp @@ -33,7 +33,7 @@ #ifndef PRODUCT -class CFGPrinterOutput : public CHeapObj { +class CFGPrinterOutput : public CHeapObj { private: outputStream* _output; @@ -106,7 +106,7 @@ void CFGPrinter::print_intervals(IntervalList* intervals, const char* name) { CFGPrinterOutput::CFGPrinterOutput() - : _output(new(ResourceObj::C_HEAP) fileStream("output.cfg")) + : _output(new(ResourceObj::C_HEAP, mtCompiler) fileStream("output.cfg")) { } diff --git a/hotspot/src/share/vm/c1/c1_Compiler.cpp b/hotspot/src/share/vm/c1/c1_Compiler.cpp index 41b5eb572e6..7e55ce30fd6 100644 --- a/hotspot/src/share/vm/c1/c1_Compiler.cpp +++ b/hotspot/src/share/vm/c1/c1_Compiler.cpp @@ -55,7 +55,7 @@ Compiler::~Compiler() { void Compiler::initialize_all() { BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob(); - Arena* arena = new Arena(); + Arena* arena = new (mtCompiler) Arena(); Runtime1::initialize(buffer_blob); FrameMap::initialize(); // initialize data structures diff --git a/hotspot/src/share/vm/c1/c1_LinearScan.cpp b/hotspot/src/share/vm/c1/c1_LinearScan.cpp index 56f94636586..bd4061ec787 100644 --- a/hotspot/src/share/vm/c1/c1_LinearScan.cpp +++ b/hotspot/src/share/vm/c1/c1_LinearScan.cpp @@ -2467,12 +2467,12 @@ void LinearScan::compute_oop_map(IntervalWalker* iw, const LIR_OpVisitState &vis // Allocate them with new so they are never destroyed (otherwise, a // forced exit could destroy these objects while they are still in // use). -ConstantOopWriteValue* LinearScan::_oop_null_scope_value = new (ResourceObj::C_HEAP) ConstantOopWriteValue(NULL); -ConstantIntValue* LinearScan::_int_m1_scope_value = new (ResourceObj::C_HEAP) ConstantIntValue(-1); -ConstantIntValue* LinearScan::_int_0_scope_value = new (ResourceObj::C_HEAP) ConstantIntValue(0); -ConstantIntValue* LinearScan::_int_1_scope_value = new (ResourceObj::C_HEAP) ConstantIntValue(1); -ConstantIntValue* LinearScan::_int_2_scope_value = new (ResourceObj::C_HEAP) ConstantIntValue(2); -LocationValue* _illegal_value = new (ResourceObj::C_HEAP) LocationValue(Location()); +ConstantOopWriteValue* LinearScan::_oop_null_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantOopWriteValue(NULL); +ConstantIntValue* LinearScan::_int_m1_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(-1); +ConstantIntValue* LinearScan::_int_0_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(0); +ConstantIntValue* LinearScan::_int_1_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(1); +ConstantIntValue* LinearScan::_int_2_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(2); +LocationValue* _illegal_value = new (ResourceObj::C_HEAP, mtCompiler) LocationValue(Location()); void LinearScan::init_compute_debug_info() { // cache for frequently used scope values diff --git a/hotspot/src/share/vm/ci/ciObjectFactory.cpp b/hotspot/src/share/vm/ci/ciObjectFactory.cpp index 9aa6b261118..a68fb1259ce 100644 --- a/hotspot/src/share/vm/ci/ciObjectFactory.cpp +++ b/hotspot/src/share/vm/ci/ciObjectFactory.cpp @@ -111,7 +111,7 @@ void ciObjectFactory::initialize() { // This Arena is long lived and exists in the resource mark of the // compiler thread that initializes the initial ciObjectFactory which // creates the shared ciObjects that all later ciObjectFactories use. - Arena* arena = new Arena(); + Arena* arena = new (mtCompiler) Arena(); ciEnv initial(arena); ciEnv* env = ciEnv::current(); env->_factory->init_shared_objects(); diff --git a/hotspot/src/share/vm/classfile/classFileParser.cpp b/hotspot/src/share/vm/classfile/classFileParser.cpp index b2330e61e37..1be1c7bf19c 100644 --- a/hotspot/src/share/vm/classfile/classFileParser.cpp +++ b/hotspot/src/share/vm/classfile/classFileParser.cpp @@ -1368,7 +1368,7 @@ class Classfile_LVT_Element VALUE_OBJ_CLASS_SPEC { }; -class LVT_Hash: public CHeapObj { +class LVT_Hash: public CHeapObj { public: LocalVariableTableElement *_elem; // element LVT_Hash* _next; // Next entry in hash table diff --git a/hotspot/src/share/vm/classfile/classLoader.cpp b/hotspot/src/share/vm/classfile/classLoader.cpp index df42dc75d42..a2e61a4ad3b 100644 --- a/hotspot/src/share/vm/classfile/classLoader.cpp +++ b/hotspot/src/share/vm/classfile/classLoader.cpp @@ -153,7 +153,7 @@ MetaIndex::MetaIndex(char** meta_package_names, int num_meta_package_names) { _meta_package_names = NULL; _num_meta_package_names = 0; } else { - _meta_package_names = NEW_C_HEAP_ARRAY(char*, num_meta_package_names); + _meta_package_names = NEW_C_HEAP_ARRAY(char*, num_meta_package_names, mtClass); _num_meta_package_names = num_meta_package_names; memcpy(_meta_package_names, meta_package_names, num_meta_package_names * sizeof(char*)); } @@ -161,7 +161,7 @@ MetaIndex::MetaIndex(char** meta_package_names, int num_meta_package_names) { MetaIndex::~MetaIndex() { - FREE_C_HEAP_ARRAY(char*, _meta_package_names); + FREE_C_HEAP_ARRAY(char*, _meta_package_names, mtClass); } @@ -192,7 +192,7 @@ bool ClassPathEntry::is_lazy() { } ClassPathDirEntry::ClassPathDirEntry(char* dir) : ClassPathEntry() { - _dir = NEW_C_HEAP_ARRAY(char, strlen(dir)+1); + _dir = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass); strcpy(_dir, dir); } @@ -229,7 +229,7 @@ ClassFileStream* ClassPathDirEntry::open_stream(const char* name) { ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() { _zip = zip; - _zip_name = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1); + _zip_name = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass); strcpy(_zip_name, zip_name); } @@ -237,7 +237,7 @@ ClassPathZipEntry::~ClassPathZipEntry() { if (ZipClose != NULL) { (*ZipClose)(_zip); } - FREE_C_HEAP_ARRAY(char, _zip_name); + FREE_C_HEAP_ARRAY(char, _zip_name, mtClass); } ClassFileStream* ClassPathZipEntry::open_stream(const char* name) { @@ -454,11 +454,11 @@ void ClassLoader::setup_bootstrap_search_path() { while (sys_class_path[end] && sys_class_path[end] != os::path_separator()[0]) { end++; } - char* path = NEW_C_HEAP_ARRAY(char, end-start+1); + char* path = NEW_C_HEAP_ARRAY(char, end-start+1, mtClass); strncpy(path, &sys_class_path[start], end-start); path[end-start] = '\0'; update_class_path_entry_list(path, false); - FREE_C_HEAP_ARRAY(char, path); + FREE_C_HEAP_ARRAY(char, path, mtClass); while (sys_class_path[end] == os::path_separator()[0]) { end++; } @@ -652,13 +652,13 @@ void ClassLoader::load_zip_library() { // in the classpath must be the same files, in the same order, even // though the exact name is not the same. -class PackageInfo: public BasicHashtableEntry { +class PackageInfo: public BasicHashtableEntry { public: const char* _pkgname; // Package name int _classpath_index; // Index of directory or JAR file loaded from PackageInfo* next() { - return (PackageInfo*)BasicHashtableEntry::next(); + return (PackageInfo*)BasicHashtableEntry::next(); } const char* pkgname() { return _pkgname; } @@ -674,7 +674,7 @@ public: }; -class PackageHashtable : public BasicHashtable { +class PackageHashtable : public BasicHashtable { private: inline unsigned int compute_hash(const char *s, int n) { unsigned int val = 0; @@ -685,7 +685,7 @@ private: } PackageInfo* bucket(int index) { - return (PackageInfo*)BasicHashtable::bucket(index); + return (PackageInfo*)BasicHashtable::bucket(index); } PackageInfo* get_entry(int index, unsigned int hash, @@ -702,10 +702,10 @@ private: public: PackageHashtable(int table_size) - : BasicHashtable(table_size, sizeof(PackageInfo)) {} + : BasicHashtable(table_size, sizeof(PackageInfo)) {} - PackageHashtable(int table_size, HashtableBucket* t, int number_of_entries) - : BasicHashtable(table_size, sizeof(PackageInfo), t, number_of_entries) {} + PackageHashtable(int table_size, HashtableBucket* t, int number_of_entries) + : BasicHashtable(table_size, sizeof(PackageInfo), t, number_of_entries) {} PackageInfo* get_entry(const char* pkgname, int n) { unsigned int hash = compute_hash(pkgname, n); @@ -715,14 +715,14 @@ public: PackageInfo* new_entry(char* pkgname, int n) { unsigned int hash = compute_hash(pkgname, n); PackageInfo* pp; - pp = (PackageInfo*)BasicHashtable::new_entry(hash); + pp = (PackageInfo*)BasicHashtable::new_entry(hash); pp->set_pkgname(pkgname); return pp; } void add_entry(PackageInfo* pp) { int index = hash_to_index(pp->hash()); - BasicHashtable::add_entry(index, pp); + BasicHashtable::add_entry(index, pp); } void copy_pkgnames(const char** packages) { @@ -742,7 +742,7 @@ public: void PackageHashtable::copy_table(char** top, char* end, PackageHashtable* table) { // Copy (relocate) the table to the shared space. - BasicHashtable::copy_table(top, end); + BasicHashtable::copy_table(top, end); // Calculate the space needed for the package name strings. int i; @@ -815,7 +815,7 @@ bool ClassLoader::add_package(const char *pkgname, int classpath_index, TRAPS) { // Package prefix found int n = cp - pkgname + 1; - char* new_pkgname = NEW_C_HEAP_ARRAY(char, n + 1); + char* new_pkgname = NEW_C_HEAP_ARRAY(char, n + 1, mtClass); if (new_pkgname == NULL) { return false; } @@ -929,10 +929,10 @@ instanceKlassHandle ClassLoader::load_classfile(Symbol* h_name, TRAPS) { } -void ClassLoader::create_package_info_table(HashtableBucket *t, int length, +void ClassLoader::create_package_info_table(HashtableBucket *t, int length, int number_of_entries) { assert(_package_hash_table == NULL, "One package info table allowed."); - assert(length == package_hash_table_size * sizeof(HashtableBucket), + assert(length == package_hash_table_size * sizeof(HashtableBucket), "bad shared package info size."); _package_hash_table = new PackageHashtable(package_hash_table_size, t, number_of_entries); diff --git a/hotspot/src/share/vm/classfile/classLoader.hpp b/hotspot/src/share/vm/classfile/classLoader.hpp index 6f816837ae7..ee58550b61e 100644 --- a/hotspot/src/share/vm/classfile/classLoader.hpp +++ b/hotspot/src/share/vm/classfile/classLoader.hpp @@ -33,7 +33,7 @@ // Meta-index (optional, to be able to skip opening boot classpath jar files) -class MetaIndex: public CHeapObj { +class MetaIndex: public CHeapObj { private: char** _meta_package_names; int _num_meta_package_names; @@ -46,7 +46,7 @@ class MetaIndex: public CHeapObj { // Class path entry (directory or zip file) -class ClassPathEntry: public CHeapObj { +class ClassPathEntry: public CHeapObj { private: ClassPathEntry* _next; public: @@ -141,7 +141,7 @@ class LazyClassPathEntry: public ClassPathEntry { class PackageHashtable; class PackageInfo; -class HashtableBucket; +template class HashtableBucket; class ClassLoader: AllStatic { public: @@ -299,7 +299,7 @@ class ClassLoader: AllStatic { // Initialization static void initialize(); static void create_package_info_table(); - static void create_package_info_table(HashtableBucket *t, int length, + static void create_package_info_table(HashtableBucket *t, int length, int number_of_entries); static int compute_Object_vtable(); diff --git a/hotspot/src/share/vm/classfile/dictionary.cpp b/hotspot/src/share/vm/classfile/dictionary.cpp index 4458f46d7a9..78e76cc1f67 100644 --- a/hotspot/src/share/vm/classfile/dictionary.cpp +++ b/hotspot/src/share/vm/classfile/dictionary.cpp @@ -36,16 +36,16 @@ int Dictionary::_current_class_index = 0; Dictionary::Dictionary(int table_size) - : TwoOopHashtable(table_size, sizeof(DictionaryEntry)) { + : TwoOopHashtable(table_size, sizeof(DictionaryEntry)) { _current_class_index = 0; _current_class_entry = NULL; }; -Dictionary::Dictionary(int table_size, HashtableBucket* t, +Dictionary::Dictionary(int table_size, HashtableBucket* t, int number_of_entries) - : TwoOopHashtable(table_size, sizeof(DictionaryEntry), t, number_of_entries) { + : TwoOopHashtable(table_size, sizeof(DictionaryEntry), t, number_of_entries) { _current_class_index = 0; _current_class_entry = NULL; }; @@ -54,7 +54,7 @@ Dictionary::Dictionary(int table_size, HashtableBucket* t, DictionaryEntry* Dictionary::new_entry(unsigned int hash, klassOop klass, oop loader) { DictionaryEntry* entry; - entry = (DictionaryEntry*)Hashtable::new_entry(hash, klass); + entry = (DictionaryEntry*)Hashtable::new_entry(hash, klass); entry->set_loader(loader); entry->set_pd_set(NULL); return entry; @@ -62,7 +62,7 @@ DictionaryEntry* Dictionary::new_entry(unsigned int hash, klassOop klass, DictionaryEntry* Dictionary::new_entry() { - DictionaryEntry* entry = (DictionaryEntry*)Hashtable::new_entry(0L, NULL); + DictionaryEntry* entry = (DictionaryEntry*)Hashtable::new_entry(0L, NULL); entry->set_loader(NULL); entry->set_pd_set(NULL); return entry; @@ -76,7 +76,7 @@ void Dictionary::free_entry(DictionaryEntry* entry) { entry->set_pd_set(to_delete->next()); delete to_delete; } - Hashtable::free_entry(entry); + Hashtable::free_entry(entry); } @@ -554,12 +554,12 @@ void Dictionary::reorder_dictionary() { } SymbolPropertyTable::SymbolPropertyTable(int table_size) - : Hashtable(table_size, sizeof(SymbolPropertyEntry)) + : Hashtable(table_size, sizeof(SymbolPropertyEntry)) { } -SymbolPropertyTable::SymbolPropertyTable(int table_size, HashtableBucket* t, +SymbolPropertyTable::SymbolPropertyTable(int table_size, HashtableBucket* t, int number_of_entries) - : Hashtable(table_size, sizeof(SymbolPropertyEntry), t, number_of_entries) + : Hashtable(table_size, sizeof(SymbolPropertyEntry), t, number_of_entries) { } @@ -584,7 +584,7 @@ SymbolPropertyEntry* SymbolPropertyTable::add_entry(int index, unsigned int hash assert(find_entry(index, hash, sym, sym_mode) == NULL, "no double entry"); SymbolPropertyEntry* p = new_entry(hash, sym, sym_mode); - Hashtable::add_entry(index, p); + Hashtable::add_entry(index, p); return p; } diff --git a/hotspot/src/share/vm/classfile/dictionary.hpp b/hotspot/src/share/vm/classfile/dictionary.hpp index 98e01695001..bd33760b721 100644 --- a/hotspot/src/share/vm/classfile/dictionary.hpp +++ b/hotspot/src/share/vm/classfile/dictionary.hpp @@ -36,7 +36,7 @@ class DictionaryEntry; // The data structure for the system dictionary (and the shared system // dictionary). -class Dictionary : public TwoOopHashtable { +class Dictionary : public TwoOopHashtable { friend class VMStructs; private: // current iteration index. @@ -48,22 +48,22 @@ private: Symbol* name, Handle loader); DictionaryEntry* bucket(int i) { - return (DictionaryEntry*)Hashtable::bucket(i); + return (DictionaryEntry*)Hashtable::bucket(i); } // The following method is not MT-safe and must be done under lock. DictionaryEntry** bucket_addr(int i) { - return (DictionaryEntry**)Hashtable::bucket_addr(i); + return (DictionaryEntry**)Hashtable::bucket_addr(i); } void add_entry(int index, DictionaryEntry* new_entry) { - Hashtable::add_entry(index, (HashtableEntry*)new_entry); + Hashtable::add_entry(index, (HashtableEntry*)new_entry); } public: Dictionary(int table_size); - Dictionary(int table_size, HashtableBucket* t, int number_of_entries); + Dictionary(int table_size, HashtableBucket* t, int number_of_entries); DictionaryEntry* new_entry(unsigned int hash, klassOop klass, oop loader); @@ -129,7 +129,7 @@ public: // The following classes can be in dictionary.cpp, but we need these // to be in header file so that SA's vmStructs can access. -class ProtectionDomainEntry :public CHeapObj { +class ProtectionDomainEntry :public CHeapObj { friend class VMStructs; public: ProtectionDomainEntry* _next; @@ -147,7 +147,7 @@ class ProtectionDomainEntry :public CHeapObj { // An entry in the system dictionary, this describes a class as // { klassOop, loader, protection_domain }. -class DictionaryEntry : public HashtableEntry { +class DictionaryEntry : public HashtableEntry { friend class VMStructs; private: // Contains the set of approved protection domains that can access @@ -166,11 +166,11 @@ class DictionaryEntry : public HashtableEntry { klassOop* klass_addr() { return (klassOop*)literal_addr(); } DictionaryEntry* next() const { - return (DictionaryEntry*)HashtableEntry::next(); + return (DictionaryEntry*)HashtableEntry::next(); } DictionaryEntry** next_addr() { - return (DictionaryEntry**)HashtableEntry::next_addr(); + return (DictionaryEntry**)HashtableEntry::next_addr(); } oop loader() const { return _loader; } @@ -228,7 +228,7 @@ class DictionaryEntry : public HashtableEntry { // Entry in a SymbolPropertyTable, mapping a single Symbol* // to a managed and an unmanaged pointer. -class SymbolPropertyEntry : public HashtableEntry { +class SymbolPropertyEntry : public HashtableEntry { friend class VMStructs; private: intptr_t _symbol_mode; // secondary key @@ -248,11 +248,11 @@ class SymbolPropertyEntry : public HashtableEntry { void set_property_data(address p) { _property_data = p; } SymbolPropertyEntry* next() const { - return (SymbolPropertyEntry*)HashtableEntry::next(); + return (SymbolPropertyEntry*)HashtableEntry::next(); } SymbolPropertyEntry** next_addr() { - return (SymbolPropertyEntry**)HashtableEntry::next_addr(); + return (SymbolPropertyEntry**)HashtableEntry::next_addr(); } oop* property_oop_addr() { return &_property_oop; } @@ -278,16 +278,16 @@ class SymbolPropertyEntry : public HashtableEntry { // A system-internal mapping of symbols to pointers, both managed // and unmanaged. Used to record the auto-generation of each method // MethodHandle.invoke(S)T, for all signatures (S)T. -class SymbolPropertyTable : public Hashtable { +class SymbolPropertyTable : public Hashtable { friend class VMStructs; private: SymbolPropertyEntry* bucket(int i) { - return (SymbolPropertyEntry*) Hashtable::bucket(i); + return (SymbolPropertyEntry*) Hashtable::bucket(i); } // The following method is not MT-safe and must be done under lock. SymbolPropertyEntry** bucket_addr(int i) { - return (SymbolPropertyEntry**) Hashtable::bucket_addr(i); + return (SymbolPropertyEntry**) Hashtable::bucket_addr(i); } void add_entry(int index, SymbolPropertyEntry* new_entry) { @@ -298,7 +298,7 @@ private: } SymbolPropertyEntry* new_entry(unsigned int hash, Symbol* symbol, intptr_t symbol_mode) { - SymbolPropertyEntry* entry = (SymbolPropertyEntry*) Hashtable::new_entry(hash, symbol); + SymbolPropertyEntry* entry = (SymbolPropertyEntry*) Hashtable::new_entry(hash, symbol); // Hashtable with Symbol* literal must increment and decrement refcount. symbol->increment_refcount(); entry->set_symbol_mode(symbol_mode); @@ -309,17 +309,17 @@ private: public: SymbolPropertyTable(int table_size); - SymbolPropertyTable(int table_size, HashtableBucket* t, int number_of_entries); + SymbolPropertyTable(int table_size, HashtableBucket* t, int number_of_entries); void free_entry(SymbolPropertyEntry* entry) { // decrement Symbol refcount here because hashtable doesn't. entry->literal()->decrement_refcount(); - Hashtable::free_entry(entry); + Hashtable::free_entry(entry); } unsigned int compute_hash(Symbol* sym, intptr_t symbol_mode) { // Use the regular identity_hash. - return Hashtable::compute_hash(sym) ^ symbol_mode; + return Hashtable::compute_hash(sym) ^ symbol_mode; } int index_for(Symbol* name, intptr_t symbol_mode) { diff --git a/hotspot/src/share/vm/classfile/javaAssertions.cpp b/hotspot/src/share/vm/classfile/javaAssertions.cpp index 7884881dedc..3e6a8ce6041 100644 --- a/hotspot/src/share/vm/classfile/javaAssertions.cpp +++ b/hotspot/src/share/vm/classfile/javaAssertions.cpp @@ -58,7 +58,7 @@ void JavaAssertions::addOption(const char* name, bool enable) { // it is never freed, so will be leaked (along with other option strings - // e.g., bootclasspath) if a process creates/destroys multiple VMs. int len = (int)strlen(name); - char *name_copy = NEW_C_HEAP_ARRAY(char, len + 1); + char *name_copy = NEW_C_HEAP_ARRAY(char, len + 1, mtClass); strcpy(name_copy, name); // Figure out which list the new item should go on. Names that end in "..." diff --git a/hotspot/src/share/vm/classfile/javaAssertions.hpp b/hotspot/src/share/vm/classfile/javaAssertions.hpp index b0fb21a2d07..d06d9010f00 100644 --- a/hotspot/src/share/vm/classfile/javaAssertions.hpp +++ b/hotspot/src/share/vm/classfile/javaAssertions.hpp @@ -68,7 +68,7 @@ private: static OptionList* _packages; // Options for package trees. }; -class JavaAssertions::OptionList: public CHeapObj { +class JavaAssertions::OptionList: public CHeapObj { public: inline OptionList(const char* name, bool enable, OptionList* next); diff --git a/hotspot/src/share/vm/classfile/loaderConstraints.cpp b/hotspot/src/share/vm/classfile/loaderConstraints.cpp index 5e25e4cbd02..8650cd98db6 100644 --- a/hotspot/src/share/vm/classfile/loaderConstraints.cpp +++ b/hotspot/src/share/vm/classfile/loaderConstraints.cpp @@ -31,7 +31,7 @@ #include "utilities/hashtable.inline.hpp" LoaderConstraintTable::LoaderConstraintTable(int nof_buckets) - : Hashtable(nof_buckets, sizeof(LoaderConstraintEntry)) {}; + : Hashtable(nof_buckets, sizeof(LoaderConstraintEntry)) {}; LoaderConstraintEntry* LoaderConstraintTable::new_entry( @@ -39,7 +39,7 @@ LoaderConstraintEntry* LoaderConstraintTable::new_entry( klassOop klass, int num_loaders, int max_loaders) { LoaderConstraintEntry* entry; - entry = (LoaderConstraintEntry*)Hashtable::new_entry(hash, klass); + entry = (LoaderConstraintEntry*)Hashtable::new_entry(hash, klass); entry->set_name(name); entry->set_num_loaders(num_loaders); entry->set_max_loaders(max_loaders); @@ -49,7 +49,7 @@ LoaderConstraintEntry* LoaderConstraintTable::new_entry( void LoaderConstraintTable::free_entry(LoaderConstraintEntry *entry) { // decrement name refcount before freeing entry->name()->decrement_refcount(); - Hashtable::free_entry(entry); + Hashtable::free_entry(entry); } @@ -164,7 +164,7 @@ void LoaderConstraintTable::purge_loader_constraints(BoolObjectClosure* is_alive // Purge entry *p = probe->next(); - FREE_C_HEAP_ARRAY(oop, probe->loaders()); + FREE_C_HEAP_ARRAY(oop, probe->loaders(), mtClass); free_entry(probe); } else { #ifdef ASSERT @@ -224,7 +224,7 @@ bool LoaderConstraintTable::add_entry(Symbol* class_name, int index = hash_to_index(hash); LoaderConstraintEntry* p; p = new_entry(hash, class_name, klass, 2, 2); - p->set_loaders(NEW_C_HEAP_ARRAY(oop, 2)); + p->set_loaders(NEW_C_HEAP_ARRAY(oop, 2, mtClass)); p->set_loader(0, class_loader1()); p->set_loader(1, class_loader2()); p->set_klass(klass); @@ -340,10 +340,10 @@ void LoaderConstraintTable::ensure_loader_constraint_capacity( int nfree) { if (p->max_loaders() - p->num_loaders() < nfree) { int n = nfree + p->num_loaders(); - oop* new_loaders = NEW_C_HEAP_ARRAY(oop, n); + oop* new_loaders = NEW_C_HEAP_ARRAY(oop, n, mtClass); memcpy(new_loaders, p->loaders(), sizeof(oop) * p->num_loaders()); p->set_max_loaders(n); - FREE_C_HEAP_ARRAY(oop, p->loaders()); + FREE_C_HEAP_ARRAY(oop, p->loaders(), mtClass); p->set_loaders(new_loaders); } } @@ -425,7 +425,7 @@ void LoaderConstraintTable::merge_loader_constraints( } *pp2 = p2->next(); - FREE_C_HEAP_ARRAY(oop, p2->loaders()); + FREE_C_HEAP_ARRAY(oop, p2->loaders(), mtClass); free_entry(p2); return; } diff --git a/hotspot/src/share/vm/classfile/loaderConstraints.hpp b/hotspot/src/share/vm/classfile/loaderConstraints.hpp index 60612f5dba3..d01b2c4d63f 100644 --- a/hotspot/src/share/vm/classfile/loaderConstraints.hpp +++ b/hotspot/src/share/vm/classfile/loaderConstraints.hpp @@ -31,7 +31,7 @@ class LoaderConstraintEntry; -class LoaderConstraintTable : public Hashtable { +class LoaderConstraintTable : public Hashtable { friend class VMStructs; private: @@ -53,11 +53,11 @@ public: void free_entry(LoaderConstraintEntry *entry); LoaderConstraintEntry* bucket(int i) { - return (LoaderConstraintEntry*)Hashtable::bucket(i); + return (LoaderConstraintEntry*)Hashtable::bucket(i); } LoaderConstraintEntry** bucket_addr(int i) { - return (LoaderConstraintEntry**)Hashtable::bucket_addr(i); + return (LoaderConstraintEntry**)Hashtable::bucket_addr(i); } // GC support @@ -94,7 +94,7 @@ public: #endif }; -class LoaderConstraintEntry : public HashtableEntry { +class LoaderConstraintEntry : public HashtableEntry { friend class VMStructs; private: Symbol* _name; // class name @@ -109,14 +109,14 @@ public: void set_klass(klassOop k) { set_literal(k); } LoaderConstraintEntry* next() { - return (LoaderConstraintEntry*)HashtableEntry::next(); + return (LoaderConstraintEntry*)HashtableEntry::next(); } LoaderConstraintEntry** next_addr() { - return (LoaderConstraintEntry**)HashtableEntry::next_addr(); + return (LoaderConstraintEntry**)HashtableEntry::next_addr(); } void set_next(LoaderConstraintEntry* next) { - HashtableEntry::set_next(next); + HashtableEntry::set_next(next); } Symbol* name() { return _name; } diff --git a/hotspot/src/share/vm/classfile/placeholders.cpp b/hotspot/src/share/vm/classfile/placeholders.cpp index ef877b1033e..d3f425b241a 100644 --- a/hotspot/src/share/vm/classfile/placeholders.cpp +++ b/hotspot/src/share/vm/classfile/placeholders.cpp @@ -34,7 +34,7 @@ PlaceholderEntry* PlaceholderTable::new_entry(int hash, Symbol* name, oop loader, bool havesupername, Symbol* supername) { - PlaceholderEntry* entry = (PlaceholderEntry*)Hashtable::new_entry(hash, name); + PlaceholderEntry* entry = (PlaceholderEntry*)Hashtable::new_entry(hash, name); // Hashtable with Symbol* literal must increment and decrement refcount. name->increment_refcount(); entry->set_loader(loader); @@ -52,7 +52,7 @@ void PlaceholderTable::free_entry(PlaceholderEntry* entry) { // decrement Symbol refcount here because Hashtable doesn't. entry->literal()->decrement_refcount(); if (entry->supername() != NULL) entry->supername()->decrement_refcount(); - Hashtable::free_entry(entry); + Hashtable::free_entry(entry); } @@ -166,7 +166,7 @@ void PlaceholderTable::find_and_remove(int index, unsigned int hash, } PlaceholderTable::PlaceholderTable(int table_size) - : TwoOopHashtable(table_size, sizeof(PlaceholderEntry)) { + : TwoOopHashtable(table_size, sizeof(PlaceholderEntry)) { } diff --git a/hotspot/src/share/vm/classfile/placeholders.hpp b/hotspot/src/share/vm/classfile/placeholders.hpp index 667c59b8c70..4dea3a6804c 100644 --- a/hotspot/src/share/vm/classfile/placeholders.hpp +++ b/hotspot/src/share/vm/classfile/placeholders.hpp @@ -34,7 +34,7 @@ class PlaceholderEntry; // being loaded, as well as arrays of primitives. // -class PlaceholderTable : public TwoOopHashtable { +class PlaceholderTable : public TwoOopHashtable { friend class VMStructs; public: @@ -44,15 +44,15 @@ public: void free_entry(PlaceholderEntry* entry); PlaceholderEntry* bucket(int i) { - return (PlaceholderEntry*)Hashtable::bucket(i); + return (PlaceholderEntry*)Hashtable::bucket(i); } PlaceholderEntry** bucket_addr(int i) { - return (PlaceholderEntry**)Hashtable::bucket_addr(i); + return (PlaceholderEntry**)Hashtable::bucket_addr(i); } void add_entry(int index, PlaceholderEntry* new_entry) { - Hashtable::add_entry(index, (HashtableEntry*)new_entry); + Hashtable::add_entry(index, (HashtableEntry*)new_entry); } void add_entry(int index, unsigned int hash, Symbol* name, @@ -116,7 +116,7 @@ public: // For DEFINE_CLASS, the head of the queue owns the // define token and the rest of the threads wait to return the // result the first thread gets. -class SeenThread: public CHeapObj { +class SeenThread: public CHeapObj { private: Thread *_thread; SeenThread* _stnext; @@ -152,7 +152,7 @@ public: // on store ordering here. // The system dictionary is the only user of this class. -class PlaceholderEntry : public HashtableEntry { +class PlaceholderEntry : public HashtableEntry { friend class VMStructs; @@ -206,11 +206,11 @@ class PlaceholderEntry : public HashtableEntry { void set_defineThreadQ(SeenThread* SeenThread) { _defineThreadQ = SeenThread; } PlaceholderEntry* next() const { - return (PlaceholderEntry*)HashtableEntry::next(); + return (PlaceholderEntry*)HashtableEntry::next(); } PlaceholderEntry** next_addr() { - return (PlaceholderEntry**)HashtableEntry::next_addr(); + return (PlaceholderEntry**)HashtableEntry::next_addr(); } // Test for equality diff --git a/hotspot/src/share/vm/classfile/resolutionErrors.cpp b/hotspot/src/share/vm/classfile/resolutionErrors.cpp index ed31224e010..e94ffa288ab 100644 --- a/hotspot/src/share/vm/classfile/resolutionErrors.cpp +++ b/hotspot/src/share/vm/classfile/resolutionErrors.cpp @@ -67,7 +67,7 @@ void ResolutionErrorEntry::set_error(Symbol* e) { ResolutionErrorEntry* ResolutionErrorTable::new_entry(int hash, constantPoolOop pool, int cp_index, Symbol* error) { - ResolutionErrorEntry* entry = (ResolutionErrorEntry*)Hashtable::new_entry(hash, pool); + ResolutionErrorEntry* entry = (ResolutionErrorEntry*)Hashtable::new_entry(hash, pool); entry->set_cp_index(cp_index); NOT_PRODUCT(entry->set_error(NULL);) entry->set_error(error); @@ -79,13 +79,13 @@ void ResolutionErrorTable::free_entry(ResolutionErrorEntry *entry) { // decrement error refcount assert(entry->error() != NULL, "error should be set"); entry->error()->decrement_refcount(); - Hashtable::free_entry(entry); + Hashtable::free_entry(entry); } // create resolution error table ResolutionErrorTable::ResolutionErrorTable(int table_size) - : Hashtable(table_size, sizeof(ResolutionErrorEntry)) { + : Hashtable(table_size, sizeof(ResolutionErrorEntry)) { } // GC support diff --git a/hotspot/src/share/vm/classfile/resolutionErrors.hpp b/hotspot/src/share/vm/classfile/resolutionErrors.hpp index 03fcf4957bb..a18a55a2340 100644 --- a/hotspot/src/share/vm/classfile/resolutionErrors.hpp +++ b/hotspot/src/share/vm/classfile/resolutionErrors.hpp @@ -33,7 +33,7 @@ class ResolutionErrorEntry; // ResolutionError objects are used to record errors encountered during // constant pool resolution (JVMS 5.4.3). -class ResolutionErrorTable : public Hashtable { +class ResolutionErrorTable : public Hashtable { public: ResolutionErrorTable(int table_size); @@ -42,15 +42,16 @@ public: void free_entry(ResolutionErrorEntry *entry); ResolutionErrorEntry* bucket(int i) { - return (ResolutionErrorEntry*)Hashtable::bucket(i); + return (ResolutionErrorEntry*)Hashtable::bucket(i); } ResolutionErrorEntry** bucket_addr(int i) { - return (ResolutionErrorEntry**)Hashtable::bucket_addr(i); + return (ResolutionErrorEntry**)Hashtable::bucket_addr(i); } void add_entry(int index, ResolutionErrorEntry* new_entry) { - Hashtable::add_entry(index, (HashtableEntry*)new_entry); + Hashtable::add_entry(index, + (HashtableEntry*)new_entry); } void add_entry(int index, unsigned int hash, @@ -74,7 +75,7 @@ public: }; -class ResolutionErrorEntry : public HashtableEntry { +class ResolutionErrorEntry : public HashtableEntry { private: int _cp_index; Symbol* _error; @@ -90,11 +91,11 @@ class ResolutionErrorEntry : public HashtableEntry { void set_error(Symbol* e); ResolutionErrorEntry* next() const { - return (ResolutionErrorEntry*)HashtableEntry::next(); + return (ResolutionErrorEntry*)HashtableEntry::next(); } ResolutionErrorEntry** next_addr() { - return (ResolutionErrorEntry**)HashtableEntry::next_addr(); + return (ResolutionErrorEntry**)HashtableEntry::next_addr(); } // GC support diff --git a/hotspot/src/share/vm/classfile/symbolTable.cpp b/hotspot/src/share/vm/classfile/symbolTable.cpp index 3b6ec7ceb34..85cc5002d10 100644 --- a/hotspot/src/share/vm/classfile/symbolTable.cpp +++ b/hotspot/src/share/vm/classfile/symbolTable.cpp @@ -64,9 +64,9 @@ Symbol* SymbolTable::allocate_symbol(const u1* name, int len, bool c_heap, TRAPS void SymbolTable::initialize_symbols(int arena_alloc_size) { // Initialize the arena for global symbols, size passed in depends on CDS. if (arena_alloc_size == 0) { - _arena = new Arena(); + _arena = new (mtSymbol) Arena(); } else { - _arena = new Arena(arena_alloc_size); + _arena = new (mtSymbol) Arena(arena_alloc_size); } } @@ -74,7 +74,7 @@ void SymbolTable::initialize_symbols(int arena_alloc_size) { void SymbolTable::symbols_do(SymbolClosure *cl) { const int n = the_table()->table_size(); for (int i = 0; i < n; i++) { - for (HashtableEntry* p = the_table()->bucket(i); + for (HashtableEntry* p = the_table()->bucket(i); p != NULL; p = p->next()) { cl->do_symbol(p->literal_addr()); @@ -92,8 +92,8 @@ void SymbolTable::unlink() { int total = 0; size_t memory_total = 0; for (int i = 0; i < the_table()->table_size(); ++i) { - HashtableEntry** p = the_table()->bucket_addr(i); - HashtableEntry* entry = the_table()->bucket(i); + HashtableEntry** p = the_table()->bucket_addr(i); + HashtableEntry* entry = the_table()->bucket(i); while (entry != NULL) { // Shared entries are normally at the end of the bucket and if we run into // a shared entry, then there is nothing more to remove. However, if we @@ -117,7 +117,7 @@ void SymbolTable::unlink() { p = entry->next_addr(); } // get next entry - entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); + entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); } } symbols_removed += removed; @@ -164,7 +164,7 @@ void SymbolTable::rehash_table() { Symbol* SymbolTable::lookup(int index, const char* name, int len, unsigned int hash) { int count = 0; - for (HashtableEntry* e = bucket(index); e != NULL; e = e->next()) { + for (HashtableEntry* e = bucket(index); e != NULL; e = e->next()) { count++; // count all entries in this bucket, not just ones with same hash if (e->hash() == hash) { Symbol* sym = e->literal(); @@ -176,7 +176,7 @@ Symbol* SymbolTable::lookup(int index, const char* name, } } // If the bucket size is too deep check if this hash code is insufficient. - if (count >= BasicHashtable::rehash_count && !needs_rehashing()) { + if (count >= BasicHashtable::rehash_count && !needs_rehashing()) { _needs_rehashing = check_rehash_table(count); } return NULL; @@ -268,7 +268,7 @@ Symbol** SymbolTable::lookup_symbol_addr(Symbol* sym){ unsigned int hash = hash_symbol((char*)sym->bytes(), sym->utf8_length()); int index = the_table()->hash_to_index(hash); - for (HashtableEntry* e = the_table()->bucket(index); e != NULL; e = e->next()) { + for (HashtableEntry* e = the_table()->bucket(index); e != NULL; e = e->next()) { if (e->hash() == hash) { Symbol* literal_sym = e->literal(); if (sym == literal_sym) { @@ -387,7 +387,7 @@ Symbol* SymbolTable::basic_add(int index_arg, u1 *name, int len, Symbol* sym = allocate_symbol(name, len, c_heap, CHECK_NULL); assert(sym->equals((char*)name, len), "symbol must be properly initialized"); - HashtableEntry* entry = new_entry(hashValue, sym); + HashtableEntry* entry = new_entry(hashValue, sym); add_entry(index, entry); return sym; } @@ -435,7 +435,7 @@ bool SymbolTable::basic_add(Handle class_loader, constantPoolHandle cp, bool c_heap = class_loader() != NULL; Symbol* sym = allocate_symbol((const u1*)names[i], lengths[i], c_heap, CHECK_(false)); assert(sym->equals(names[i], lengths[i]), "symbol must be properly initialized"); // why wouldn't it be??? - HashtableEntry* entry = new_entry(hashValue, sym); + HashtableEntry* entry = new_entry(hashValue, sym); add_entry(index, entry); cp->symbol_at_put(cp_indices[i], sym); } @@ -446,7 +446,7 @@ bool SymbolTable::basic_add(Handle class_loader, constantPoolHandle cp, void SymbolTable::verify() { for (int i = 0; i < the_table()->table_size(); ++i) { - HashtableEntry* p = the_table()->bucket(i); + HashtableEntry* p = the_table()->bucket(i); for ( ; p != NULL; p = p->next()) { Symbol* s = (Symbol*)(p->literal()); guarantee(s != NULL, "symbol is NULL"); @@ -462,7 +462,7 @@ void SymbolTable::dump(outputStream* st) { NumberSeq summary; for (int i = 0; i < the_table()->table_size(); ++i) { int count = 0; - for (HashtableEntry* e = the_table()->bucket(i); + for (HashtableEntry* e = the_table()->bucket(i); e != NULL; e = e->next()) { count++; } @@ -499,7 +499,7 @@ void SymbolTable::print_histogram() { int memory_total = 0; int count = 0; for (i = 0; i < the_table()->table_size(); i++) { - HashtableEntry* p = the_table()->bucket(i); + HashtableEntry* p = the_table()->bucket(i); for ( ; p != NULL; p = p->next()) { memory_total += p->literal()->object_size(); count++; @@ -560,15 +560,15 @@ void SymbolTable::print_histogram() { void SymbolTable::print() { for (int i = 0; i < the_table()->table_size(); ++i) { - HashtableEntry** p = the_table()->bucket_addr(i); - HashtableEntry* entry = the_table()->bucket(i); + HashtableEntry** p = the_table()->bucket_addr(i); + HashtableEntry* entry = the_table()->bucket(i); if (entry != NULL) { while (entry != NULL) { tty->print(PTR_FORMAT " ", entry->literal()); entry->literal()->print(); tty->print(" %d", entry->literal()->refcount()); p = entry->next_addr(); - entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); + entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); } tty->cr(); } @@ -631,7 +631,7 @@ unsigned int StringTable::hash_string(const jchar* s, int len) { oop StringTable::lookup(int index, jchar* name, int len, unsigned int hash) { int count = 0; - for (HashtableEntry* l = bucket(index); l != NULL; l = l->next()) { + for (HashtableEntry* l = bucket(index); l != NULL; l = l->next()) { count++; if (l->hash() == hash) { if (java_lang_String::equals(l->literal(), name, len)) { @@ -640,7 +640,7 @@ oop StringTable::lookup(int index, jchar* name, } } // If the bucket size is too deep check if this hash code is insufficient. - if (count >= BasicHashtable::rehash_count && !needs_rehashing()) { + if (count >= BasicHashtable::rehash_count && !needs_rehashing()) { _needs_rehashing = check_rehash_table(count); } return NULL; @@ -676,7 +676,7 @@ oop StringTable::basic_add(int index_arg, Handle string, jchar* name, return test; } - HashtableEntry* entry = new_entry(hashValue, string()); + HashtableEntry* entry = new_entry(hashValue, string()); add_entry(index, entry); return string(); } @@ -761,8 +761,8 @@ void StringTable::unlink(BoolObjectClosure* is_alive) { // entries at a safepoint. assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); for (int i = 0; i < the_table()->table_size(); ++i) { - HashtableEntry** p = the_table()->bucket_addr(i); - HashtableEntry* entry = the_table()->bucket(i); + HashtableEntry** p = the_table()->bucket_addr(i); + HashtableEntry* entry = the_table()->bucket(i); while (entry != NULL) { // Shared entries are normally at the end of the bucket and if we run into // a shared entry, then there is nothing more to remove. However, if we @@ -778,15 +778,15 @@ void StringTable::unlink(BoolObjectClosure* is_alive) { *p = entry->next(); the_table()->free_entry(entry); } - entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); + entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); } } } void StringTable::oops_do(OopClosure* f) { for (int i = 0; i < the_table()->table_size(); ++i) { - HashtableEntry** p = the_table()->bucket_addr(i); - HashtableEntry* entry = the_table()->bucket(i); + HashtableEntry** p = the_table()->bucket_addr(i); + HashtableEntry* entry = the_table()->bucket(i); while (entry != NULL) { f->do_oop((oop*)entry->literal_addr()); @@ -798,14 +798,14 @@ void StringTable::oops_do(OopClosure* f) { } else { p = entry->next_addr(); } - entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); + entry = (HashtableEntry*)HashtableEntry::make_ptr(*p); } } } void StringTable::verify() { for (int i = 0; i < the_table()->table_size(); ++i) { - HashtableEntry* p = the_table()->bucket(i); + HashtableEntry* p = the_table()->bucket(i); for ( ; p != NULL; p = p->next()) { oop s = p->literal(); guarantee(s != NULL, "interned string is NULL"); @@ -821,7 +821,7 @@ void StringTable::verify() { void StringTable::dump(outputStream* st) { NumberSeq summary; for (int i = 0; i < the_table()->table_size(); ++i) { - HashtableEntry* p = the_table()->bucket(i); + HashtableEntry* p = the_table()->bucket(i); int count = 0; for ( ; p != NULL; p = p->next()) { count++; diff --git a/hotspot/src/share/vm/classfile/symbolTable.hpp b/hotspot/src/share/vm/classfile/symbolTable.hpp index 6e5782cd7ea..f63de80280e 100644 --- a/hotspot/src/share/vm/classfile/symbolTable.hpp +++ b/hotspot/src/share/vm/classfile/symbolTable.hpp @@ -71,7 +71,7 @@ class TempNewSymbol : public StackObj { operator Symbol*() { return _temp; } }; -class SymbolTable : public Hashtable { +class SymbolTable : public Hashtable { friend class VMStructs; friend class ClassFileParser; @@ -113,10 +113,10 @@ private: Symbol* lookup(int index, const char* name, int len, unsigned int hash); SymbolTable() - : Hashtable(symbol_table_size, sizeof (HashtableEntry)) {} + : Hashtable(symbol_table_size, sizeof (HashtableEntry)) {} - SymbolTable(HashtableBucket* t, int number_of_entries) - : Hashtable(symbol_table_size, sizeof (HashtableEntry), t, + SymbolTable(HashtableBucket* t, int number_of_entries) + : Hashtable(symbol_table_size, sizeof (HashtableEntry), t, number_of_entries) {} // Arena for permanent symbols (null class loader) that are never unloaded @@ -145,10 +145,10 @@ public: initialize_symbols(symbol_alloc_arena_size); } - static void create_table(HashtableBucket* t, int length, + static void create_table(HashtableBucket* t, int length, int number_of_entries) { assert(_the_table == NULL, "One symbol table allowed."); - assert(length == symbol_table_size * sizeof(HashtableBucket), + assert(length == symbol_table_size * sizeof(HashtableBucket), "bad shared symbol size."); _the_table = new SymbolTable(t, number_of_entries); // if CDS give symbol table a default arena size since most symbols @@ -224,13 +224,13 @@ public: // Sharing static void copy_buckets(char** top, char*end) { - the_table()->Hashtable::copy_buckets(top, end); + the_table()->Hashtable::copy_buckets(top, end); } static void copy_table(char** top, char*end) { - the_table()->Hashtable::copy_table(top, end); + the_table()->Hashtable::copy_table(top, end); } static void reverse(void* boundary = NULL) { - the_table()->Hashtable::reverse(boundary); + the_table()->Hashtable::reverse(boundary); } // Rehash the symbol table if it gets out of balance @@ -238,8 +238,7 @@ public: static bool needs_rehashing() { return _needs_rehashing; } }; - -class StringTable : public Hashtable { +class StringTable : public Hashtable { friend class VMStructs; private: @@ -256,11 +255,11 @@ private: oop lookup(int index, jchar* chars, int length, unsigned int hashValue); - StringTable() : Hashtable((int)StringTableSize, - sizeof (HashtableEntry)) {} + StringTable() : Hashtable((int)StringTableSize, + sizeof (HashtableEntry)) {} - StringTable(HashtableBucket* t, int number_of_entries) - : Hashtable((int)StringTableSize, sizeof (HashtableEntry), t, + StringTable(HashtableBucket* t, int number_of_entries) + : Hashtable((int)StringTableSize, sizeof (HashtableEntry), t, number_of_entries) {} static bool use_alternate_hashcode() { return _seed != 0; } @@ -276,10 +275,10 @@ public: _the_table = new StringTable(); } - static void create_table(HashtableBucket* t, int length, + static void create_table(HashtableBucket* t, int length, int number_of_entries) { assert(_the_table == NULL, "One string table allowed."); - assert((size_t)length == StringTableSize * sizeof(HashtableBucket), + assert((size_t)length == StringTableSize * sizeof(HashtableBucket), "bad shared string size."); _the_table = new StringTable(t, number_of_entries); } @@ -313,13 +312,13 @@ public: // Sharing static void copy_buckets(char** top, char*end) { - the_table()->Hashtable::copy_buckets(top, end); + the_table()->Hashtable::copy_buckets(top, end); } static void copy_table(char** top, char*end) { - the_table()->Hashtable::copy_table(top, end); + the_table()->Hashtable::copy_table(top, end); } static void reverse() { - the_table()->Hashtable::reverse(); + the_table()->Hashtable::reverse(); } // Rehash the symbol table if it gets out of balance diff --git a/hotspot/src/share/vm/classfile/systemDictionary.cpp b/hotspot/src/share/vm/classfile/systemDictionary.cpp index 78c854f3058..74901574d54 100644 --- a/hotspot/src/share/vm/classfile/systemDictionary.cpp +++ b/hotspot/src/share/vm/classfile/systemDictionary.cpp @@ -1168,9 +1168,9 @@ klassOop SystemDictionary::resolve_from_stream(Symbol* class_name, } -void SystemDictionary::set_shared_dictionary(HashtableBucket* t, int length, +void SystemDictionary::set_shared_dictionary(HashtableBucket* t, int length, int number_of_entries) { - assert(length == _nof_buckets * sizeof(HashtableBucket), + assert(length == _nof_buckets * sizeof(HashtableBucket), "bad shared dictionary size."); _shared_dictionary = new Dictionary(_nof_buckets, t, number_of_entries); } diff --git a/hotspot/src/share/vm/classfile/systemDictionary.hpp b/hotspot/src/share/vm/classfile/systemDictionary.hpp index 72be344383b..7b59f075021 100644 --- a/hotspot/src/share/vm/classfile/systemDictionary.hpp +++ b/hotspot/src/share/vm/classfile/systemDictionary.hpp @@ -32,6 +32,7 @@ #include "runtime/java.hpp" #include "runtime/reflectionUtils.hpp" #include "utilities/hashtable.hpp" +#include "utilities/hashtable.inline.hpp" // The system dictionary stores all loaded classes and maps: // @@ -72,7 +73,7 @@ class Dictionary; class PlaceholderTable; class LoaderConstraintTable; -class HashtableBucket; +template class HashtableBucket; class ResolutionErrorTable; class SymbolPropertyTable; @@ -363,7 +364,7 @@ public: static void copy_buckets(char** top, char* end); static void copy_table(char** top, char* end); static void reverse(); - static void set_shared_dictionary(HashtableBucket* t, int length, + static void set_shared_dictionary(HashtableBucket* t, int length, int number_of_entries); // Printing static void print() PRODUCT_RETURN; diff --git a/hotspot/src/share/vm/code/codeBlob.cpp b/hotspot/src/share/vm/code/codeBlob.cpp index 244c32043f3..aa20f1d1bb9 100644 --- a/hotspot/src/share/vm/code/codeBlob.cpp +++ b/hotspot/src/share/vm/code/codeBlob.cpp @@ -144,7 +144,7 @@ void CodeBlob::set_oop_maps(OopMapSet* p) { // chunk of memory, its your job to free it. if (p != NULL) { // We need to allocate a chunk big enough to hold the OopMapSet and all of its OopMaps - _oop_maps = (OopMapSet* )NEW_C_HEAP_ARRAY(unsigned char, p->heap_size()); + _oop_maps = (OopMapSet* )NEW_C_HEAP_ARRAY(unsigned char, p->heap_size(), mtCode); p->copy_to((address)_oop_maps); } else { _oop_maps = NULL; @@ -180,7 +180,7 @@ void CodeBlob::trace_new_stub(CodeBlob* stub, const char* name1, const char* nam void CodeBlob::flush() { if (_oop_maps) { - FREE_C_HEAP_ARRAY(unsigned char, _oop_maps); + FREE_C_HEAP_ARRAY(unsigned char, _oop_maps, mtCode); _oop_maps = NULL; } _comments.free(); diff --git a/hotspot/src/share/vm/code/codeCache.cpp b/hotspot/src/share/vm/code/codeCache.cpp index 8e82aaad056..ffef685f96d 100644 --- a/hotspot/src/share/vm/code/codeCache.cpp +++ b/hotspot/src/share/vm/code/codeCache.cpp @@ -856,7 +856,7 @@ void CodeCache::print_internals() { int bucketSize = 512; int bucketLimit = maxCodeSize / bucketSize + 1; - int *buckets = NEW_C_HEAP_ARRAY(int, bucketLimit); + int *buckets = NEW_C_HEAP_ARRAY(int, bucketLimit, mtCode); memset(buckets,0,sizeof(int) * bucketLimit); for (cb = first(); cb != NULL; cb = next(cb)) { @@ -893,7 +893,7 @@ void CodeCache::print_internals() { } } - FREE_C_HEAP_ARRAY(int, buckets); + FREE_C_HEAP_ARRAY(int, buckets, mtCode); } void CodeCache::print() { diff --git a/hotspot/src/share/vm/code/codeCache.hpp b/hotspot/src/share/vm/code/codeCache.hpp index bdd128e9813..6c97cc79bd1 100644 --- a/hotspot/src/share/vm/code/codeCache.hpp +++ b/hotspot/src/share/vm/code/codeCache.hpp @@ -88,6 +88,9 @@ class CodeCache : AllStatic { // Lookup that does not fail if you lookup a zombie method (if you call this, be sure to know // what you are doing) static CodeBlob* find_blob_unsafe(void* start) { + // NMT can walk the stack before code cache is created + if (_heap == NULL) return NULL; + CodeBlob* result = (CodeBlob*)_heap->find_start(start); // this assert is too strong because the heap code will return the // heapblock containing start. That block can often be larger than diff --git a/hotspot/src/share/vm/code/nmethod.hpp b/hotspot/src/share/vm/code/nmethod.hpp index 33f44a919b5..75e8940aa8e 100644 --- a/hotspot/src/share/vm/code/nmethod.hpp +++ b/hotspot/src/share/vm/code/nmethod.hpp @@ -31,7 +31,7 @@ // This class is used internally by nmethods, to cache // exception/pc/handler information. -class ExceptionCache : public CHeapObj { +class ExceptionCache : public CHeapObj { friend class VMStructs; private: enum { cache_size = 16 }; diff --git a/hotspot/src/share/vm/code/stubs.hpp b/hotspot/src/share/vm/code/stubs.hpp index 328ad8bf76e..afc8f04d46c 100644 --- a/hotspot/src/share/vm/code/stubs.hpp +++ b/hotspot/src/share/vm/code/stubs.hpp @@ -101,7 +101,7 @@ class Stub VALUE_OBJ_CLASS_SPEC { // of the concrete stub (see also macro below). There's exactly // one stub interface instance required per stub queue. -class StubInterface: public CHeapObj { +class StubInterface: public CHeapObj { public: // Initialization/finalization virtual void initialize(Stub* self, int size) = 0; // called after creation (called twice if allocated via (request, commit)) @@ -152,7 +152,7 @@ class StubInterface: public CHeapObj { // A StubQueue maintains a queue of stubs. // Note: All sizes (spaces) are given in bytes. -class StubQueue: public CHeapObj { +class StubQueue: public CHeapObj { friend class VMStructs; private: StubInterface* _stub_interface; // the interface prototype diff --git a/hotspot/src/share/vm/compiler/abstractCompiler.hpp b/hotspot/src/share/vm/compiler/abstractCompiler.hpp index 380dfe7bda0..55303a01fad 100644 --- a/hotspot/src/share/vm/compiler/abstractCompiler.hpp +++ b/hotspot/src/share/vm/compiler/abstractCompiler.hpp @@ -29,7 +29,7 @@ typedef void (*initializer)(void); -class AbstractCompiler : public CHeapObj { +class AbstractCompiler : public CHeapObj { private: bool _is_initialized; // Mark whether compiler object is initialized diff --git a/hotspot/src/share/vm/compiler/compileBroker.cpp b/hotspot/src/share/vm/compiler/compileBroker.cpp index 8729e056221..2c2e64b3862 100644 --- a/hotspot/src/share/vm/compiler/compileBroker.cpp +++ b/hotspot/src/share/vm/compiler/compileBroker.cpp @@ -951,7 +951,7 @@ void CompileBroker::init_compiler_threads(int c1_compiler_count, int c2_compiler int compiler_count = c1_compiler_count + c2_compiler_count; _method_threads = - new (ResourceObj::C_HEAP) GrowableArray(compiler_count, true); + new (ResourceObj::C_HEAP, mtCompiler) GrowableArray(compiler_count, true); char name_buffer[256]; for (int i = 0; i < c2_compiler_count; i++) { @@ -1627,7 +1627,7 @@ void CompileBroker::init_compiler_thread_log() { } fp = fopen(fileBuf, "at"); if (fp != NULL) { - file = NEW_C_HEAP_ARRAY(char, strlen(fileBuf)+1); + file = NEW_C_HEAP_ARRAY(char, strlen(fileBuf)+1, mtCompiler); strcpy(file, fileBuf); break; } @@ -1637,7 +1637,7 @@ void CompileBroker::init_compiler_thread_log() { } else { if (LogCompilation && Verbose) tty->print_cr("Opening compilation log %s", file); - CompileLog* log = new(ResourceObj::C_HEAP) CompileLog(file, fp, thread_id); + CompileLog* log = new(ResourceObj::C_HEAP, mtCompiler) CompileLog(file, fp, thread_id); thread->init_log(log); if (xtty != NULL) { diff --git a/hotspot/src/share/vm/compiler/compileBroker.hpp b/hotspot/src/share/vm/compiler/compileBroker.hpp index 1ee2c5419f9..8d28f8c8224 100644 --- a/hotspot/src/share/vm/compiler/compileBroker.hpp +++ b/hotspot/src/share/vm/compiler/compileBroker.hpp @@ -36,7 +36,7 @@ class nmethodLocker; // // An entry in the compile queue. It represents a pending or current // compilation. -class CompileTask : public CHeapObj { +class CompileTask : public CHeapObj { friend class VMStructs; private: @@ -131,7 +131,7 @@ public: // // Per Compiler Performance Counters. // -class CompilerCounters : public CHeapObj { +class CompilerCounters : public CHeapObj { public: enum { @@ -175,7 +175,7 @@ class CompilerCounters : public CHeapObj { // CompileQueue // // A list of CompileTasks. -class CompileQueue : public CHeapObj { +class CompileQueue : public CHeapObj { private: const char* _name; Monitor* _lock; diff --git a/hotspot/src/share/vm/compiler/compileLog.cpp b/hotspot/src/share/vm/compiler/compileLog.cpp index a306117f965..2e0fe86bc47 100644 --- a/hotspot/src/share/vm/compiler/compileLog.cpp +++ b/hotspot/src/share/vm/compiler/compileLog.cpp @@ -37,14 +37,14 @@ CompileLog* CompileLog::_first = NULL; CompileLog::CompileLog(const char* file, FILE* fp, intx thread_id) : _context(_context_buffer, sizeof(_context_buffer)) { - initialize(new(ResourceObj::C_HEAP) fileStream(fp)); + initialize(new(ResourceObj::C_HEAP, mtCompiler) fileStream(fp)); _file = file; _file_end = 0; _thread_id = thread_id; _identities_limit = 0; _identities_capacity = 400; - _identities = NEW_C_HEAP_ARRAY(char, _identities_capacity); + _identities = NEW_C_HEAP_ARRAY(char, _identities_capacity, mtCompiler); // link into the global list { MutexLocker locker(CompileTaskAlloc_lock); @@ -56,7 +56,7 @@ CompileLog::CompileLog(const char* file, FILE* fp, intx thread_id) CompileLog::~CompileLog() { delete _out; _out = NULL; - FREE_C_HEAP_ARRAY(char, _identities); + FREE_C_HEAP_ARRAY(char, _identities, mtCompiler); } @@ -109,7 +109,7 @@ int CompileLog::identify(ciObject* obj) { if (id >= _identities_capacity) { int new_cap = _identities_capacity * 2; if (new_cap <= id) new_cap = id + 100; - _identities = REALLOC_C_HEAP_ARRAY(char, _identities, new_cap); + _identities = REALLOC_C_HEAP_ARRAY(char, _identities, new_cap, mtCompiler); _identities_capacity = new_cap; } while (id >= _identities_limit) { diff --git a/hotspot/src/share/vm/compiler/compilerOracle.cpp b/hotspot/src/share/vm/compiler/compilerOracle.cpp index 6ac45b41345..286a9ec16a8 100644 --- a/hotspot/src/share/vm/compiler/compilerOracle.cpp +++ b/hotspot/src/share/vm/compiler/compilerOracle.cpp @@ -34,7 +34,7 @@ #include "runtime/handles.inline.hpp" #include "runtime/jniHandles.hpp" -class MethodMatcher : public CHeapObj { +class MethodMatcher : public CHeapObj { public: enum Mode { Exact, diff --git a/hotspot/src/share/vm/compiler/oopMap.cpp b/hotspot/src/share/vm/compiler/oopMap.cpp index 9c1195cecff..2cd212d277f 100644 --- a/hotspot/src/share/vm/compiler/oopMap.cpp +++ b/hotspot/src/share/vm/compiler/oopMap.cpp @@ -599,7 +599,7 @@ void OopMapSet::print_on(outputStream* st) const { #ifdef COMPILER2 -class DerivedPointerEntry : public CHeapObj { +class DerivedPointerEntry : public CHeapObj { private: oop* _location; // Location of derived pointer (also pointing to the base) intptr_t _offset; // Offset from base pointer @@ -621,7 +621,7 @@ void DerivedPointerTable::clear() { assert (!_active, "should not be active"); assert(_list == NULL || _list->length() == 0, "table not empty"); if (_list == NULL) { - _list = new (ResourceObj::C_HEAP) GrowableArray(10, true); // Allocated on C heap + _list = new (ResourceObj::C_HEAP, mtCompiler) GrowableArray(10, true); // Allocated on C heap } _active = true; } diff --git a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp index 663b747fd77..3b7bb9aefb4 100644 --- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp +++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp @@ -617,7 +617,7 @@ class CompactibleFreeListSpace: public CompactibleSpace { // A parallel-GC-thread-local allocation buffer for allocation into a // CompactibleFreeListSpace. -class CFLS_LAB : public CHeapObj { +class CFLS_LAB : public CHeapObj { // The space that this buffer allocates into. CompactibleFreeListSpace* _cfls; diff --git a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp index 938e94efcff..e8e33ff8f8a 100644 --- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp +++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @@ -174,7 +174,7 @@ NOT_PRODUCT(CompactibleFreeListSpace* debug_cms_space;) // This struct contains per-thread things necessary to support parallel // young-gen collection. -class CMSParGCThreadState: public CHeapObj { +class CMSParGCThreadState: public CHeapObj { public: CFLS_LAB lab; PromotionInfo promo; @@ -229,7 +229,7 @@ ConcurrentMarkSweepGeneration::ConcurrentMarkSweepGeneration( if (CollectedHeap::use_parallel_gc_threads()) { typedef CMSParGCThreadState* CMSParGCThreadStatePtr; _par_gc_thread_states = - NEW_C_HEAP_ARRAY(CMSParGCThreadStatePtr, ParallelGCThreads); + NEW_C_HEAP_ARRAY(CMSParGCThreadStatePtr, ParallelGCThreads, mtGC); if (_par_gc_thread_states == NULL) { vm_exit_during_initialization("Could not allocate par gc structs"); } @@ -687,7 +687,7 @@ CMSCollector::CMSCollector(ConcurrentMarkSweepGeneration* cmsGen, warning("task_queues allocation failure."); return; } - _hash_seed = NEW_C_HEAP_ARRAY(int, num_queues); + _hash_seed = NEW_C_HEAP_ARRAY(int, num_queues, mtGC); if (_hash_seed == NULL) { warning("_hash_seed array allocation failure"); return; @@ -737,7 +737,7 @@ CMSCollector::CMSCollector(ConcurrentMarkSweepGeneration* cmsGen, assert(_young_gen != NULL, "no _young_gen"); _eden_chunk_index = 0; _eden_chunk_capacity = (_young_gen->max_capacity()+CMSSamplingGrain)/CMSSamplingGrain; - _eden_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, _eden_chunk_capacity); + _eden_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, _eden_chunk_capacity, mtGC); if (_eden_chunk_array == NULL) { _eden_chunk_capacity = 0; warning("GC/CMS: _eden_chunk_array allocation failure"); @@ -750,35 +750,35 @@ CMSCollector::CMSCollector(ConcurrentMarkSweepGeneration* cmsGen, const size_t max_plab_samples = ((DefNewGeneration*)_young_gen)->max_survivor_size()/MinTLABSize; - _survivor_plab_array = NEW_C_HEAP_ARRAY(ChunkArray, ParallelGCThreads); - _survivor_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, 2*max_plab_samples); - _cursor = NEW_C_HEAP_ARRAY(size_t, ParallelGCThreads); + _survivor_plab_array = NEW_C_HEAP_ARRAY(ChunkArray, ParallelGCThreads, mtGC); + _survivor_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, 2*max_plab_samples, mtGC); + _cursor = NEW_C_HEAP_ARRAY(size_t, ParallelGCThreads, mtGC); if (_survivor_plab_array == NULL || _survivor_chunk_array == NULL || _cursor == NULL) { warning("Failed to allocate survivor plab/chunk array"); if (_survivor_plab_array != NULL) { - FREE_C_HEAP_ARRAY(ChunkArray, _survivor_plab_array); + FREE_C_HEAP_ARRAY(ChunkArray, _survivor_plab_array, mtGC); _survivor_plab_array = NULL; } if (_survivor_chunk_array != NULL) { - FREE_C_HEAP_ARRAY(HeapWord*, _survivor_chunk_array); + FREE_C_HEAP_ARRAY(HeapWord*, _survivor_chunk_array, mtGC); _survivor_chunk_array = NULL; } if (_cursor != NULL) { - FREE_C_HEAP_ARRAY(size_t, _cursor); + FREE_C_HEAP_ARRAY(size_t, _cursor, mtGC); _cursor = NULL; } } else { _survivor_chunk_capacity = 2*max_plab_samples; for (uint i = 0; i < ParallelGCThreads; i++) { - HeapWord** vec = NEW_C_HEAP_ARRAY(HeapWord*, max_plab_samples); + HeapWord** vec = NEW_C_HEAP_ARRAY(HeapWord*, max_plab_samples, mtGC); if (vec == NULL) { warning("Failed to allocate survivor plab array"); for (int j = i; j > 0; j--) { - FREE_C_HEAP_ARRAY(HeapWord*, _survivor_plab_array[j-1].array()); + FREE_C_HEAP_ARRAY(HeapWord*, _survivor_plab_array[j-1].array(), mtGC); } - FREE_C_HEAP_ARRAY(ChunkArray, _survivor_plab_array); - FREE_C_HEAP_ARRAY(HeapWord*, _survivor_chunk_array); + FREE_C_HEAP_ARRAY(ChunkArray, _survivor_plab_array, mtGC); + FREE_C_HEAP_ARRAY(HeapWord*, _survivor_chunk_array, mtGC); _survivor_plab_array = NULL; _survivor_chunk_array = NULL; _survivor_chunk_capacity = 0; diff --git a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp index ecc60cc3ead..3db4f11f785 100644 --- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp +++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp @@ -161,7 +161,7 @@ class CMSBitMap VALUE_OBJ_CLASS_SPEC { // Represents a marking stack used by the CMS collector. // Ideally this should be GrowableArray<> just like MSC's marking stack(s). -class CMSMarkStack: public CHeapObj { +class CMSMarkStack: public CHeapObj { // friend class CMSCollector; // to get at expasion stats further below // @@ -265,7 +265,7 @@ class ModUnionClosurePar: public ModUnionClosure { // Survivor Chunk Array in support of parallelization of // Survivor Space rescan. -class ChunkArray: public CHeapObj { +class ChunkArray: public CHeapObj { size_t _index; size_t _capacity; size_t _overflows; @@ -506,7 +506,7 @@ private: }; -class CMSCollector: public CHeapObj { +class CMSCollector: public CHeapObj { friend class VMStructs; friend class ConcurrentMarkSweepThread; friend class ConcurrentMarkSweepGeneration; @@ -553,8 +553,8 @@ class CMSCollector: public CHeapObj { // The following array-pair keeps track of mark words // displaced for accomodating overflow list above. // This code will likely be revisited under RFE#4922830. - Stack _preserved_oop_stack; - Stack _preserved_mark_stack; + Stack _preserved_oop_stack; + Stack _preserved_mark_stack; int* _hash_seed; diff --git a/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp b/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp index e52476586c5..44ee2ad3476 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp @@ -28,7 +28,7 @@ #include "gc_implementation/g1/heapRegion.hpp" #include "utilities/growableArray.hpp" -class CollectionSetChooser: public CHeapObj { +class CollectionSetChooser: public CHeapObj { GrowableArray _regions; diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp index a7b24607064..cb802770ff7 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp @@ -79,7 +79,7 @@ ConcurrentG1Refine::ConcurrentG1Refine() : _n_threads = _n_worker_threads + 1; reset_threshold_step(); - _threads = NEW_C_HEAP_ARRAY(ConcurrentG1RefineThread*, _n_threads); + _threads = NEW_C_HEAP_ARRAY(ConcurrentG1RefineThread*, _n_threads, mtGC); int worker_id_offset = (int)DirtyCardQueueSet::num_par_ids(); ConcurrentG1RefineThread *next = NULL; for (int i = _n_threads - 1; i >= 0; i--) { @@ -157,7 +157,7 @@ void ConcurrentG1Refine::init() { _def_use_cache = true; _use_cache = true; _hot_cache_size = (1 << G1ConcRSLogCacheSize); - _hot_cache = NEW_C_HEAP_ARRAY(jbyte*, _hot_cache_size); + _hot_cache = NEW_C_HEAP_ARRAY(jbyte*, _hot_cache_size, mtGC); _n_hot = 0; _hot_cache_idx = 0; @@ -191,18 +191,18 @@ ConcurrentG1Refine::~ConcurrentG1Refine() { // Please see the comment in allocate_card_count_cache // for why we call os::malloc() and os::free() directly. assert(_card_counts != NULL, "Logic"); - os::free(_card_counts); + os::free(_card_counts, mtGC); assert(_card_epochs != NULL, "Logic"); - os::free(_card_epochs); + os::free(_card_epochs, mtGC); assert(_hot_cache != NULL, "Logic"); - FREE_C_HEAP_ARRAY(jbyte*, _hot_cache); + FREE_C_HEAP_ARRAY(jbyte*, _hot_cache, mtGC); } if (_threads != NULL) { for (int i = 0; i < _n_threads; i++) { delete _threads[i]; } - FREE_C_HEAP_ARRAY(ConcurrentG1RefineThread*, _threads); + FREE_C_HEAP_ARRAY(ConcurrentG1RefineThread*, _threads, mtGC); } } @@ -436,17 +436,17 @@ bool ConcurrentG1Refine::allocate_card_count_cache(size_t n, size_t counts_size = n * sizeof(CardCountCacheEntry); size_t epochs_size = n * sizeof(CardEpochCacheEntry); - *counts = (CardCountCacheEntry*) os::malloc(counts_size); + *counts = (CardCountCacheEntry*) os::malloc(counts_size, mtGC); if (*counts == NULL) { // allocation was unsuccessful return false; } - *epochs = (CardEpochCacheEntry*) os::malloc(epochs_size); + *epochs = (CardEpochCacheEntry*) os::malloc(epochs_size, mtGC); if (*epochs == NULL) { // allocation was unsuccessful - free counts array assert(*counts != NULL, "must be"); - os::free(*counts); + os::free(*counts, mtGC); *counts = NULL; return false; } @@ -479,8 +479,8 @@ bool ConcurrentG1Refine::expand_card_count_cache(int cache_size_idx) { // Allocation was successful. // We can just free the old arrays; we're // not interested in preserving the contents - if (_card_counts != NULL) os::free(_card_counts); - if (_card_epochs != NULL) os::free(_card_epochs); + if (_card_counts != NULL) os::free(_card_counts, mtGC); + if (_card_epochs != NULL) os::free(_card_epochs, mtGC); // Cache the size of the arrays and the index that got us there. _n_card_counts = cache_size; diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.hpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.hpp index 2379e189f9f..46a7d309cdc 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.hpp @@ -34,7 +34,7 @@ class ConcurrentG1RefineThread; class G1RemSet; -class ConcurrentG1Refine: public CHeapObj { +class ConcurrentG1Refine: public CHeapObj { ConcurrentG1RefineThread** _threads; int _n_threads; int _n_worker_threads; diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp index fd228964f7d..85ea7ce3a65 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp @@ -42,6 +42,7 @@ #include "oops/oop.inline.hpp" #include "runtime/handles.inline.hpp" #include "runtime/java.hpp" +#include "services/memTracker.hpp" // Concurrent marking bit map wrapper @@ -53,6 +54,8 @@ CMBitMapRO::CMBitMapRO(ReservedSpace rs, int shifter) : ReservedSpace brs(ReservedSpace::allocation_align_size_up( (_bmWordSize >> (_shifter + LogBitsPerByte)) + 1)); + MemTracker::record_virtual_memory_type((address)brs.base(), mtGC); + guarantee(brs.is_reserved(), "couldn't allocate concurrent marking bit map"); // For now we'll just commit all of the bit map up fromt. // Later on we'll try to be more parsimonious with swap. @@ -161,7 +164,7 @@ CMMarkStack::CMMarkStack(ConcurrentMark* cm) : {} void CMMarkStack::allocate(size_t size) { - _base = NEW_C_HEAP_ARRAY(oop, size); + _base = NEW_C_HEAP_ARRAY(oop, size, mtGC); if (_base == NULL) { vm_exit_during_initialization("Failed to allocate CM region mark stack"); } @@ -173,7 +176,7 @@ void CMMarkStack::allocate(size_t size) { CMMarkStack::~CMMarkStack() { if (_base != NULL) { - FREE_C_HEAP_ARRAY(oop, _base); + FREE_C_HEAP_ARRAY(oop, _base, mtGC); } } @@ -480,11 +483,11 @@ ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) : _root_regions.init(_g1h, this); - _tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_task_num); - _accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_task_num); + _tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_task_num, mtGC); + _accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_task_num, mtGC); - _count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap, _max_task_num); - _count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_task_num); + _count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap, _max_task_num, mtGC); + _count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_task_num, mtGC); BitMap::idx_t card_bm_size = _card_bm.size(); @@ -496,7 +499,7 @@ ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) : _task_queues->register_queue(i, task_queue); _count_card_bitmaps[i] = BitMap(card_bm_size, false); - _count_marked_bytes[i] = NEW_C_HEAP_ARRAY(size_t, (size_t) max_regions); + _count_marked_bytes[i] = NEW_C_HEAP_ARRAY(size_t, (size_t) max_regions, mtGC); _tasks[i] = new CMTask(i, this, _count_marked_bytes[i], diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp index ac1eff7aa40..c448e34fa2d 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp @@ -30,8 +30,8 @@ class G1CollectedHeap; class CMTask; -typedef GenericTaskQueue CMTaskQueue; -typedef GenericTaskQueueSet CMTaskQueueSet; +typedef GenericTaskQueue CMTaskQueue; +typedef GenericTaskQueueSet CMTaskQueueSet; // Closure used by CM during concurrent reference discovery // and reference processing (during remarking) to determine @@ -343,7 +343,7 @@ public: class ConcurrentMarkThread; -class ConcurrentMark : public CHeapObj { +class ConcurrentMark: public CHeapObj { friend class ConcurrentMarkThread; friend class CMTask; friend class CMBitMapClosure; diff --git a/hotspot/src/share/vm/gc_implementation/g1/dirtyCardQueue.hpp b/hotspot/src/share/vm/gc_implementation/g1/dirtyCardQueue.hpp index 88d47dbe16b..7a0b71356f7 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/dirtyCardQueue.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/dirtyCardQueue.hpp @@ -32,7 +32,7 @@ class FreeIdSet; // A closure class for processing card table entries. Note that we don't // require these closure objects to be stack-allocated. -class CardTableEntryClosure: public CHeapObj { +class CardTableEntryClosure: public CHeapObj { public: // Process the card whose card table entry is "card_ptr". If returns // "false", terminate the iteration early. diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp index d16685a7ebc..79f28250141 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp @@ -27,6 +27,7 @@ #include "memory/space.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" +#include "services/memTracker.hpp" ////////////////////////////////////////////////////////////////////// // G1BlockOffsetSharedArray @@ -44,6 +45,9 @@ G1BlockOffsetSharedArray::G1BlockOffsetSharedArray(MemRegion reserved, if (!_vs.initialize(rs, 0)) { vm_exit_during_initialization("Could not reserve enough space for heap offset array"); } + + MemTracker::record_virtual_memory_type((address)rs.base(), mtGC); + _offset_array = (u_char*)_vs.low_boundary(); resize(init_word_size); if (TraceBlockOffsetTable) { diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.hpp index b6a42c73eba..5621fd27ec8 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.hpp @@ -117,7 +117,7 @@ public: // Here is the shared array type. -class G1BlockOffsetSharedArray: public CHeapObj { +class G1BlockOffsetSharedArray: public CHeapObj { friend class G1BlockOffsetArray; friend class G1BlockOffsetArrayContigSpace; friend class VMStructs; diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp index fdd82c5c9c6..6952628e0b6 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @@ -1916,14 +1916,14 @@ G1CollectedHeap::G1CollectedHeap(G1CollectorPolicy* policy_) : assert(n_rem_sets > 0, "Invariant."); HeapRegionRemSetIterator** iter_arr = - NEW_C_HEAP_ARRAY(HeapRegionRemSetIterator*, n_queues); + NEW_C_HEAP_ARRAY(HeapRegionRemSetIterator*, n_queues, mtGC); for (int i = 0; i < n_queues; i++) { iter_arr[i] = new HeapRegionRemSetIterator(); } _rem_set_iterator = iter_arr; - _worker_cset_start_region = NEW_C_HEAP_ARRAY(HeapRegion*, n_queues); - _worker_cset_start_region_time_stamp = NEW_C_HEAP_ARRAY(unsigned int, n_queues); + _worker_cset_start_region = NEW_C_HEAP_ARRAY(HeapRegion*, n_queues, mtGC); + _worker_cset_start_region_time_stamp = NEW_C_HEAP_ARRAY(unsigned int, n_queues, mtGC); for (int i = 0; i < n_queues; i++) { RefToScanQueue* q = new RefToScanQueue(); @@ -2082,7 +2082,7 @@ jint G1CollectedHeap::initialize() { _in_cset_fast_test_length = max_regions(); _in_cset_fast_test_base = - NEW_C_HEAP_ARRAY(bool, (size_t) _in_cset_fast_test_length); + NEW_C_HEAP_ARRAY(bool, (size_t) _in_cset_fast_test_length, mtGC); // We're biasing _in_cset_fast_test to avoid subtracting the // beginning of the heap every time we want to index; basically @@ -3505,7 +3505,7 @@ void G1CollectedHeap::setup_surviving_young_words() { assert(_surviving_young_words == NULL, "pre-condition"); uint array_length = g1_policy()->young_cset_region_length(); - _surviving_young_words = NEW_C_HEAP_ARRAY(size_t, (size_t) array_length); + _surviving_young_words = NEW_C_HEAP_ARRAY(size_t, (size_t) array_length, mtGC); if (_surviving_young_words == NULL) { vm_exit_out_of_memory(sizeof(size_t) * array_length, "Not enough space for young surv words summary."); @@ -3530,7 +3530,7 @@ G1CollectedHeap::update_surviving_young_words(size_t* surv_young_words) { void G1CollectedHeap::cleanup_surviving_young_words() { guarantee( _surviving_young_words != NULL, "pre-condition" ); - FREE_C_HEAP_ARRAY(size_t, _surviving_young_words); + FREE_C_HEAP_ARRAY(size_t, _surviving_young_words, mtGC); _surviving_young_words = NULL; } @@ -4073,7 +4073,7 @@ void G1CollectedHeap::abandon_gc_alloc_regions() { void G1CollectedHeap::init_for_evac_failure(OopsInHeapRegionClosure* cl) { _drain_in_progress = false; set_evac_failure_closure(cl); - _evac_failure_scan_stack = new (ResourceObj::C_HEAP) GrowableArray(40, true); + _evac_failure_scan_stack = new (ResourceObj::C_HEAP, mtGC) GrowableArray(40, true); } void G1CollectedHeap::finalize_for_evac_failure() { @@ -4207,9 +4207,9 @@ void G1CollectedHeap::preserve_mark_if_necessary(oop obj, markOop m) { if (_objs_with_preserved_marks == NULL) { assert(_preserved_marks_of_objs == NULL, "Both or none."); _objs_with_preserved_marks = - new (ResourceObj::C_HEAP) GrowableArray(40, true); + new (ResourceObj::C_HEAP, mtGC) GrowableArray(40, true); _preserved_marks_of_objs = - new (ResourceObj::C_HEAP) GrowableArray(40, true); + new (ResourceObj::C_HEAP, mtGC) GrowableArray(40, true); } _objs_with_preserved_marks->push(obj); _preserved_marks_of_objs->push(m); @@ -4269,7 +4269,7 @@ G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num) uint array_length = PADDING_ELEM_NUM + real_length + PADDING_ELEM_NUM; - _surviving_young_words_base = NEW_C_HEAP_ARRAY(size_t, array_length); + _surviving_young_words_base = NEW_C_HEAP_ARRAY(size_t, array_length, mtGC); if (_surviving_young_words_base == NULL) vm_exit_out_of_memory(array_length * sizeof(size_t), "Not enough space for young surv histo."); diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp index d3f5382d03a..611cdd0b5ca 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @@ -62,8 +62,8 @@ class ConcurrentMarkThread; class ConcurrentG1Refine; class GenerationCounters; -typedef OverflowTaskQueue RefToScanQueue; -typedef GenericTaskQueueSet RefToScanQueueSet; +typedef OverflowTaskQueue RefToScanQueue; +typedef GenericTaskQueueSet RefToScanQueueSet; typedef int RegionIdx_t; // needs to hold [ 0..max_regions() ) typedef int CardIdx_t; // needs to hold [ 0..CardsPerRegion ) @@ -74,7 +74,7 @@ enum GCAllocPurpose { GCAllocPurposeCount }; -class YoungList : public CHeapObj { +class YoungList : public CHeapObj { private: G1CollectedHeap* _g1h; @@ -1772,7 +1772,7 @@ public: G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num); ~G1ParScanThreadState() { - FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base); + FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base, mtGC); } RefToScanQueue* refs() { return _refs; } diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp index b3b839752b9..1d2cc9f189c 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp @@ -40,7 +40,7 @@ class CollectionSetChooser; // TraceGen0Time collects data on _both_ young and mixed evacuation pauses // (the latter may contain non-young regions - i.e. regions that are // technically in Gen1) while TraceGen1Time collects data about full GCs. -class TraceGen0TimeData : public CHeapObj { +class TraceGen0TimeData : public CHeapObj { private: unsigned _young_pause_num; unsigned _mixed_pause_num; @@ -86,7 +86,7 @@ public: void print() const; }; -class TraceGen1TimeData : public CHeapObj { +class TraceGen1TimeData : public CHeapObj { private: NumberSeq _all_full_gc_times; @@ -131,7 +131,7 @@ class TraceGen1TimeData : public CHeapObj { // // NewSize and MaxNewSize override NewRatio. So, NewRatio is ignored if it is // combined with either NewSize or MaxNewSize. (A warning message is printed.) -class G1YoungGenSizer : public CHeapObj { +class G1YoungGenSizer : public CHeapObj { private: enum SizerKind { SizerDefaults, diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1MMUTracker.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1MMUTracker.hpp index a13c62eb782..a8146c92386 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1MMUTracker.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1MMUTracker.hpp @@ -34,7 +34,7 @@ /***** ALL TIMES ARE IN SECS!!!!!!! *****/ // this is the "interface" -class G1MMUTracker: public CHeapObj { +class G1MMUTracker: public CHeapObj { protected: double _time_slice; double _max_gc_time; // this is per time slice diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp index 61e278a7ff7..4e1761e260b 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp @@ -112,7 +112,7 @@ class G1CollectedHeap; // do which is important as we want to keep the eden region allocation // path as low-overhead as possible. -class G1MonitoringSupport : public CHeapObj { +class G1MonitoringSupport : public CHeapObj { friend class VMStructs; G1CollectedHeap* _g1h; diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp index 1f366c8c676..b2bcbae937f 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp @@ -75,7 +75,7 @@ G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs) { _seq_task = new SubTasksDone(NumSeqTasks); guarantee(n_workers() > 0, "There should be some workers"); - _cset_rs_update_cl = NEW_C_HEAP_ARRAY(OopsInHeapRegionClosure*, n_workers()); + _cset_rs_update_cl = NEW_C_HEAP_ARRAY(OopsInHeapRegionClosure*, n_workers(), mtGC); for (uint i = 0; i < n_workers(); i++) { _cset_rs_update_cl[i] = NULL; } @@ -86,7 +86,7 @@ G1RemSet::~G1RemSet() { for (uint i = 0; i < n_workers(); i++) { assert(_cset_rs_update_cl[i] == NULL, "it should be"); } - FREE_C_HEAP_ARRAY(OopsInHeapRegionClosure*, _cset_rs_update_cl); + FREE_C_HEAP_ARRAY(OopsInHeapRegionClosure*, _cset_rs_update_cl, mtGC); } void CountNonCleanMemRegionClosure::do_MemRegion(MemRegion mr) { @@ -416,7 +416,7 @@ void G1RemSet::prepare_for_oops_into_collection_set_do() { // _seq_task->set_n_termination((int)n_workers()); } guarantee( _cards_scanned == NULL, "invariant" ); - _cards_scanned = NEW_C_HEAP_ARRAY(size_t, n_workers()); + _cards_scanned = NEW_C_HEAP_ARRAY(size_t, n_workers(), mtGC); for (uint i = 0; i < n_workers(); ++i) { _cards_scanned[i] = 0; } @@ -487,7 +487,7 @@ void G1RemSet::cleanup_after_oops_into_collection_set_do() { for (uint i = 0; i < n_workers(); ++i) { _total_cards_scanned += _cards_scanned[i]; } - FREE_C_HEAP_ARRAY(size_t, _cards_scanned); + FREE_C_HEAP_ARRAY(size_t, _cards_scanned, mtGC); _cards_scanned = NULL; // Cleanup after copy _g1->set_refine_cte_cl_concurrency(true); diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp index 9c869055afd..edf28a0536b 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp @@ -36,7 +36,7 @@ class ConcurrentG1Refine; // external heap references into it. Uses a mod ref bs to track updates, // so that they can be used to update the individual region remsets. -class G1RemSet: public CHeapObj { +class G1RemSet: public CHeapObj { protected: G1CollectedHeap* _g1; unsigned _conc_refine_cards; diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp index fc275a6edae..16dc0e4a2db 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp @@ -39,7 +39,7 @@ // OtherRegionsTable -class PerRegionTable: public CHeapObj { +class PerRegionTable: public CHeapObj { friend class OtherRegionsTable; friend class HeapRegionRemSetIterator; @@ -282,7 +282,7 @@ class PosParPRT: public PerRegionTable { // We must recount the "occupied." recount_occupied(); #endif - FREE_C_HEAP_ARRAY(PerRegionTable*, _par_tables); + FREE_C_HEAP_ARRAY(PerRegionTable*, _par_tables, mtGC); _par_tables = NULL; #if COUNT_PAR_EXPANDS Atomic::inc(&n_par_contracts); @@ -385,7 +385,7 @@ public: if (res != NULL) return; // Otherwise, we reserved the right to do the expansion. - PerRegionTable** ptables = NEW_C_HEAP_ARRAY(PerRegionTable*, n); + PerRegionTable** ptables = NEW_C_HEAP_ARRAY(PerRegionTable*, n, mtGC); for (int i = 0; i < n; i++) { PerRegionTable* ptable = PerRegionTable::alloc(hr()); ptables[i] = ptable; @@ -546,9 +546,9 @@ void OtherRegionsTable::init_from_card_cache(size_t max_regions) { _from_card_cache_max_regions = max_regions; int n_par_rs = HeapRegionRemSet::num_par_rem_sets(); - _from_card_cache = NEW_C_HEAP_ARRAY(int*, n_par_rs); + _from_card_cache = NEW_C_HEAP_ARRAY(int*, n_par_rs, mtGC); for (int i = 0; i < n_par_rs; i++) { - _from_card_cache[i] = NEW_C_HEAP_ARRAY(int, max_regions); + _from_card_cache[i] = NEW_C_HEAP_ARRAY(int, max_regions, mtGC); for (size_t j = 0; j < max_regions; j++) { _from_card_cache[i][j] = -1; // An invalid value. } @@ -1333,9 +1333,9 @@ void HeapRegionRemSet::record(HeapRegion* hr, OopOrNarrowOopStar f) { && _recorded_cards == NULL && _recorded_regions == NULL, "Inv"); - _recorded_oops = NEW_C_HEAP_ARRAY(OopOrNarrowOopStar, MaxRecorded); - _recorded_cards = NEW_C_HEAP_ARRAY(HeapWord*, MaxRecorded); - _recorded_regions = NEW_C_HEAP_ARRAY(HeapRegion*, MaxRecorded); + _recorded_oops = NEW_C_HEAP_ARRAY(OopOrNarrowOopStar, MaxRecorded, mtGC); + _recorded_cards = NEW_C_HEAP_ARRAY(HeapWord*, MaxRecorded, mtGC); + _recorded_regions = NEW_C_HEAP_ARRAY(HeapRegion*, MaxRecorded, mtGC); } if (_n_recorded == MaxRecorded) { gclog_or_tty->print_cr("Filled up 'recorded' (%d).", MaxRecorded); @@ -1356,8 +1356,8 @@ void HeapRegionRemSet::record_event(Event evnt) { assert(_n_recorded_events == 0 && _recorded_event_index == NULL, "Inv"); - _recorded_events = NEW_C_HEAP_ARRAY(Event, MaxRecordedEvents); - _recorded_event_index = NEW_C_HEAP_ARRAY(int, MaxRecordedEvents); + _recorded_events = NEW_C_HEAP_ARRAY(Event, MaxRecordedEvents, mtGC); + _recorded_event_index = NEW_C_HEAP_ARRAY(int, MaxRecordedEvents, mtGC); } if (_n_recorded_events == MaxRecordedEvents) { gclog_or_tty->print_cr("Filled up 'recorded_events' (%d).", MaxRecordedEvents); diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp index 504afa2ef04..f0d4d165952 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp @@ -173,7 +173,7 @@ public: static void print_from_card_cache(); }; -class HeapRegionRemSet : public CHeapObj { +class HeapRegionRemSet : public CHeapObj { friend class VMStructs; friend class HeapRegionRemSetIterator; @@ -360,7 +360,7 @@ public: #endif }; -class HeapRegionRemSetIterator : public CHeapObj { +class HeapRegionRemSetIterator : public CHeapObj { // The region over which we're iterating. const HeapRegionRemSet* _hrrs; diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp index dfac7d47d29..fcee7cb354b 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.cpp @@ -86,7 +86,7 @@ void HeapRegionSeq::initialize(HeapWord* bottom, HeapWord* end, _allocated_length = 0; _max_length = max_length; - _regions = NEW_C_HEAP_ARRAY(HeapRegion*, max_length); + _regions = NEW_C_HEAP_ARRAY(HeapRegion*, max_length, mtGC); memset(_regions, 0, (size_t) max_length * sizeof(HeapRegion*)); _regions_biased = _regions - ((uintx) bottom >> _region_shift); diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp index 94f4c0f7699..b1da14f6bc5 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSeq.hpp @@ -53,7 +53,7 @@ class FreeRegionList; // // and maintain that: _length <= _allocated_length <= _max_length -class HeapRegionSeq: public CHeapObj { +class HeapRegionSeq: public CHeapObj { friend class VMStructs; // The array that holds the HeapRegions. diff --git a/hotspot/src/share/vm/gc_implementation/g1/ptrQueue.cpp b/hotspot/src/share/vm/gc_implementation/g1/ptrQueue.cpp index 7bf8fec644f..1a756aa3122 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/ptrQueue.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/ptrQueue.cpp @@ -126,7 +126,7 @@ void** PtrQueueSet::allocate_buffer() { return res; } else { // Allocate space for the BufferNode in front of the buffer. - char *b = NEW_C_HEAP_ARRAY(char, _sz + BufferNode::aligned_size()); + char *b = NEW_C_HEAP_ARRAY(char, _sz + BufferNode::aligned_size(), mtGC); return BufferNode::make_buffer_from_block(b); } } @@ -149,7 +149,7 @@ void PtrQueueSet::reduce_free_list() { assert(_buf_free_list != NULL, "_buf_free_list_sz must be wrong."); void* b = BufferNode::make_block_from_node(_buf_free_list); _buf_free_list = _buf_free_list->next(); - FREE_C_HEAP_ARRAY(char, b); + FREE_C_HEAP_ARRAY(char, b, mtGC); _buf_free_list_sz --; n--; } diff --git a/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp b/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp index 69b01bc69f5..c87f12dad3e 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp @@ -208,7 +208,7 @@ void SATBMarkQueueSet::initialize(Monitor* cbl_mon, Mutex* fl_lock, PtrQueueSet::initialize(cbl_mon, fl_lock, process_completed_threshold, -1); _shared_satb_queue.set_lock(lock); if (ParallelGCThreads > 0) { - _par_closures = NEW_C_HEAP_ARRAY(ObjectClosure*, ParallelGCThreads); + _par_closures = NEW_C_HEAP_ARRAY(ObjectClosure*, ParallelGCThreads, mtGC); } } diff --git a/hotspot/src/share/vm/gc_implementation/g1/sparsePRT.cpp b/hotspot/src/share/vm/gc_implementation/g1/sparsePRT.cpp index 64b1be2460f..0daa63512a3 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/sparsePRT.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/sparsePRT.cpp @@ -148,8 +148,8 @@ void SparsePRTEntry::copy_cards(SparsePRTEntry* e) const { RSHashTable::RSHashTable(size_t capacity) : _capacity(capacity), _capacity_mask(capacity-1), _occupied_entries(0), _occupied_cards(0), - _entries((SparsePRTEntry*)NEW_C_HEAP_ARRAY(char, SparsePRTEntry::size() * capacity)), - _buckets(NEW_C_HEAP_ARRAY(int, capacity)), + _entries((SparsePRTEntry*)NEW_C_HEAP_ARRAY(char, SparsePRTEntry::size() * capacity, mtGC)), + _buckets(NEW_C_HEAP_ARRAY(int, capacity, mtGC)), _free_list(NullEntry), _free_region(0) { clear(); @@ -157,11 +157,11 @@ RSHashTable::RSHashTable(size_t capacity) : RSHashTable::~RSHashTable() { if (_entries != NULL) { - FREE_C_HEAP_ARRAY(SparsePRTEntry, _entries); + FREE_C_HEAP_ARRAY(SparsePRTEntry, _entries, mtGC); _entries = NULL; } if (_buckets != NULL) { - FREE_C_HEAP_ARRAY(int, _buckets); + FREE_C_HEAP_ARRAY(int, _buckets, mtGC); _buckets = NULL; } } diff --git a/hotspot/src/share/vm/gc_implementation/g1/sparsePRT.hpp b/hotspot/src/share/vm/gc_implementation/g1/sparsePRT.hpp index 6780086795f..6a860295745 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/sparsePRT.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/sparsePRT.hpp @@ -42,7 +42,7 @@ // insertions only enqueue old versions for deletions, but do not delete // old versions synchronously. -class SparsePRTEntry: public CHeapObj { +class SparsePRTEntry: public CHeapObj { public: enum SomePublicConstants { NullEntry = -1, @@ -101,7 +101,7 @@ public: }; -class RSHashTable : public CHeapObj { +class RSHashTable : public CHeapObj { friend class RSHashTableIter; diff --git a/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.cpp b/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.cpp index ec44c8e70a8..1232cf390e8 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.cpp @@ -43,7 +43,7 @@ SurvRateGroup::SurvRateGroup(G1CollectorPolicy* g1p, reset(); if (summary_surv_rates_len > 0) { size_t length = summary_surv_rates_len; - _summary_surv_rates = NEW_C_HEAP_ARRAY(NumberSeq*, length); + _summary_surv_rates = NEW_C_HEAP_ARRAY(NumberSeq*, length, mtGC); for (size_t i = 0; i < length; ++i) { _summary_surv_rates[i] = new NumberSeq(); } @@ -90,9 +90,9 @@ SurvRateGroup::stop_adding_regions() { double* old_accum_surv_rate_pred = _accum_surv_rate_pred; TruncatedSeq** old_surv_rate_pred = _surv_rate_pred; - _surv_rate = NEW_C_HEAP_ARRAY(double, _region_num); - _accum_surv_rate_pred = NEW_C_HEAP_ARRAY(double, _region_num); - _surv_rate_pred = NEW_C_HEAP_ARRAY(TruncatedSeq*, _region_num); + _surv_rate = NEW_C_HEAP_ARRAY(double, _region_num, mtGC); + _accum_surv_rate_pred = NEW_C_HEAP_ARRAY(double, _region_num, mtGC); + _surv_rate_pred = NEW_C_HEAP_ARRAY(TruncatedSeq*, _region_num, mtGC); for (size_t i = 0; i < _stats_arrays_length; ++i) { _surv_rate_pred[i] = old_surv_rate_pred[i]; @@ -104,13 +104,13 @@ SurvRateGroup::stop_adding_regions() { _stats_arrays_length = _region_num; if (old_surv_rate != NULL) { - FREE_C_HEAP_ARRAY(double, old_surv_rate); + FREE_C_HEAP_ARRAY(double, old_surv_rate, mtGC); } if (old_accum_surv_rate_pred != NULL) { - FREE_C_HEAP_ARRAY(double, old_accum_surv_rate_pred); + FREE_C_HEAP_ARRAY(double, old_accum_surv_rate_pred, mtGC); } if (old_surv_rate_pred != NULL) { - FREE_C_HEAP_ARRAY(TruncatedSeq*, old_surv_rate_pred); + FREE_C_HEAP_ARRAY(TruncatedSeq*, old_surv_rate_pred, mtGC); } } diff --git a/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.hpp b/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.hpp index c9617f2ed2e..abac3e00a72 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.hpp @@ -29,7 +29,7 @@ class G1CollectorPolicy; -class SurvRateGroup : public CHeapObj { +class SurvRateGroup : public CHeapObj { private: G1CollectorPolicy* _g1p; const char* _name; diff --git a/hotspot/src/share/vm/gc_implementation/parNew/parCardTableModRefBS.cpp b/hotspot/src/share/vm/gc_implementation/parNew/parCardTableModRefBS.cpp index 25be723aa98..b4b62fc77f9 100644 --- a/hotspot/src/share/vm/gc_implementation/parNew/parCardTableModRefBS.cpp +++ b/hotspot/src/share/vm/gc_implementation/parNew/parCardTableModRefBS.cpp @@ -457,12 +457,12 @@ get_LNC_array_for_space(Space* sp, if (_lowest_non_clean[i] != NULL) { assert(n_chunks != _lowest_non_clean_chunk_size[i], "logical consequence"); - FREE_C_HEAP_ARRAY(CardPtr, _lowest_non_clean[i]); + FREE_C_HEAP_ARRAY(CardPtr, _lowest_non_clean[i], mtGC); _lowest_non_clean[i] = NULL; } // Now allocate a new one if necessary. if (_lowest_non_clean[i] == NULL) { - _lowest_non_clean[i] = NEW_C_HEAP_ARRAY(CardPtr, n_chunks); + _lowest_non_clean[i] = NEW_C_HEAP_ARRAY(CardPtr, n_chunks, mtGC); _lowest_non_clean_chunk_size[i] = n_chunks; _lowest_non_clean_base_chunk_index[i] = addr_to_chunk_index(covered.start()); for (int j = 0; j < (int)n_chunks; j++) diff --git a/hotspot/src/share/vm/gc_implementation/parNew/parGCAllocBuffer.hpp b/hotspot/src/share/vm/gc_implementation/parNew/parGCAllocBuffer.hpp index 6d1504a8653..ea2fbf6170e 100644 --- a/hotspot/src/share/vm/gc_implementation/parNew/parGCAllocBuffer.hpp +++ b/hotspot/src/share/vm/gc_implementation/parNew/parGCAllocBuffer.hpp @@ -35,7 +35,7 @@ class PLABStats; // A per-thread allocation buffer used during GC. -class ParGCAllocBuffer: public CHeapObj { +class ParGCAllocBuffer: public CHeapObj { protected: char head[32]; size_t _word_sz; // in HeapWord units diff --git a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp index 96ae468f0bf..12472f6ad93 100644 --- a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp +++ b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp @@ -59,7 +59,7 @@ ParScanThreadState::ParScanThreadState(Space* to_space_, Generation* old_gen_, int thread_num_, ObjToScanQueueSet* work_queue_set_, - Stack* overflow_stacks_, + Stack* overflow_stacks_, size_t desired_plab_sz_, ParallelTaskTerminator& term_) : _to_space(to_space_), _old_gen(old_gen_), _young_gen(gen_), _thread_num(thread_num_), @@ -184,7 +184,7 @@ bool ParScanThreadState::take_from_overflow_stack() { assert(ParGCUseLocalOverflow, "Else should not call"); assert(young_gen()->overflow_list() == NULL, "Error"); ObjToScanQueue* queue = work_queue(); - Stack* const of_stack = overflow_stack(); + Stack* const of_stack = overflow_stack(); const size_t num_overflow_elems = of_stack->size(); const size_t space_available = queue->max_elems() - queue->size(); const size_t num_take_elems = MIN3(space_available / 4, @@ -297,7 +297,7 @@ public: ParNewGeneration& gen, Generation& old_gen, ObjToScanQueueSet& queue_set, - Stack* overflow_stacks_, + Stack* overflow_stacks_, size_t desired_plab_sz, ParallelTaskTerminator& term); @@ -331,7 +331,7 @@ private: ParScanThreadStateSet::ParScanThreadStateSet( int num_threads, Space& to_space, ParNewGeneration& gen, Generation& old_gen, ObjToScanQueueSet& queue_set, - Stack* overflow_stacks, + Stack* overflow_stacks, size_t desired_plab_sz, ParallelTaskTerminator& term) : ResourceArray(sizeof(ParScanThreadState), num_threads), _gen(gen), _next_gen(old_gen), _term(term) @@ -649,9 +649,14 @@ ParNewGeneration(ReservedSpace rs, size_t initial_byte_size, int level) _overflow_stacks = NULL; if (ParGCUseLocalOverflow) { - _overflow_stacks = NEW_C_HEAP_ARRAY(Stack, ParallelGCThreads); + + // typedef to workaround NEW_C_HEAP_ARRAY macro, which can not deal + // with ',' + typedef Stack GCOopStack; + + _overflow_stacks = NEW_C_HEAP_ARRAY(GCOopStack, ParallelGCThreads, mtGC); for (size_t i = 0; i < ParallelGCThreads; ++i) { - new (_overflow_stacks + i) Stack(); + new (_overflow_stacks + i) Stack(); } } @@ -1401,7 +1406,7 @@ void ParNewGeneration::push_on_overflow_list(oop from_space_obj, ParScanThreadSt assert(_num_par_pushes > 0, "Tautology"); #endif if (from_space_obj->forwardee() == from_space_obj) { - oopDesc* listhead = NEW_C_HEAP_ARRAY(oopDesc, 1); + oopDesc* listhead = NEW_C_HEAP_ARRAY(oopDesc, 1, mtGC); listhead->forward_to(from_space_obj); from_space_obj = listhead; } @@ -1553,7 +1558,7 @@ bool ParNewGeneration::take_from_overflow_list_work(ParScanThreadState* par_scan // This can become a scaling bottleneck when there is work queue overflow coincident // with promotion failure. oopDesc* f = cur; - FREE_C_HEAP_ARRAY(oopDesc, f); + FREE_C_HEAP_ARRAY(oopDesc, f, mtGC); } else if (par_scan_state->should_be_partially_scanned(obj_to_push, cur)) { assert(arrayOop(cur)->length() == 0, "entire array remaining to be scanned"); obj_to_push = cur; diff --git a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.hpp b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.hpp index 75eac033b06..5b124a953fd 100644 --- a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.hpp +++ b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.hpp @@ -41,7 +41,7 @@ class ParEvacuateFollowersClosure; // in genOopClosures.inline.hpp. typedef Padded ObjToScanQueue; -typedef GenericTaskQueueSet ObjToScanQueueSet; +typedef GenericTaskQueueSet ObjToScanQueueSet; class ParKeepAliveClosure: public DefNewGeneration::KeepAliveClosure { private: @@ -59,7 +59,7 @@ class ParScanThreadState { friend class ParScanThreadStateSet; private: ObjToScanQueue *_work_queue; - Stack* const _overflow_stack; + Stack* const _overflow_stack; ParGCAllocBuffer _to_space_alloc_buffer; @@ -127,7 +127,7 @@ class ParScanThreadState { ParScanThreadState(Space* to_space_, ParNewGeneration* gen_, Generation* old_gen_, int thread_num_, ObjToScanQueueSet* work_queue_set_, - Stack* overflow_stacks_, + Stack* overflow_stacks_, size_t desired_plab_sz_, ParallelTaskTerminator& term_); @@ -151,7 +151,7 @@ class ParScanThreadState { void trim_queues(int max_size); // Private overflow stack usage - Stack* overflow_stack() { return _overflow_stack; } + Stack* overflow_stack() { return _overflow_stack; } bool take_from_overflow_stack(); void push_on_overflow_stack(oop p); @@ -312,7 +312,7 @@ class ParNewGeneration: public DefNewGeneration { ObjToScanQueueSet* _task_queues; // Per-worker-thread local overflow stacks - Stack* _overflow_stacks; + Stack* _overflow_stacks; // Desired size of survivor space plab's PLABStats _plab_stats; diff --git a/hotspot/src/share/vm/gc_implementation/parNew/parOopClosures.hpp b/hotspot/src/share/vm/gc_implementation/parNew/parOopClosures.hpp index 747868fc5f5..4a727e9357a 100644 --- a/hotspot/src/share/vm/gc_implementation/parNew/parOopClosures.hpp +++ b/hotspot/src/share/vm/gc_implementation/parNew/parOopClosures.hpp @@ -32,7 +32,7 @@ class ParScanThreadState; class ParNewGeneration; typedef Padded ObjToScanQueue; -typedef GenericTaskQueueSet ObjToScanQueueSet; +typedef GenericTaskQueueSet ObjToScanQueueSet; class ParallelTaskTerminator; class ParScanClosure: public OopsInGenClosure { diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/adjoiningGenerations.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/adjoiningGenerations.hpp index 77fe9e022e5..3018805fe69 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/adjoiningGenerations.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/adjoiningGenerations.hpp @@ -40,7 +40,7 @@ // must be shrunk. Adjusting the boundary between the generations // is called for in this class. -class AdjoiningGenerations : public CHeapObj { +class AdjoiningGenerations : public CHeapObj { friend class VMStructs; private: // The young generation and old generation, respectively diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.cpp index 04424aa5208..b32007eded5 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.cpp @@ -116,7 +116,7 @@ GCTaskQueue* GCTaskQueue::create() { } GCTaskQueue* GCTaskQueue::create_on_c_heap() { - GCTaskQueue* result = new(ResourceObj::C_HEAP) GCTaskQueue(true); + GCTaskQueue* result = new(ResourceObj::C_HEAP, mtGC) GCTaskQueue(true); if (TraceGCTaskQueue) { tty->print_cr("GCTaskQueue::create_on_c_heap()" " returns " INTPTR_FORMAT, @@ -403,19 +403,19 @@ void GCTaskManager::initialize() { _queue = SynchronizedGCTaskQueue::create(unsynchronized_queue, lock()); _noop_task = NoopGCTask::create_on_c_heap(); _idle_inactive_task = WaitForBarrierGCTask::create_on_c_heap(); - _resource_flag = NEW_C_HEAP_ARRAY(bool, workers()); + _resource_flag = NEW_C_HEAP_ARRAY(bool, workers(), mtGC); { // Set up worker threads. // Distribute the workers among the available processors, // unless we were told not to, or if the os doesn't want to. - uint* processor_assignment = NEW_C_HEAP_ARRAY(uint, workers()); + uint* processor_assignment = NEW_C_HEAP_ARRAY(uint, workers(), mtGC); if (!BindGCTaskThreadsToCPUs || !os::distribute_processes(workers(), processor_assignment)) { for (uint a = 0; a < workers(); a += 1) { processor_assignment[a] = sentinel_worker(); } } - _thread = NEW_C_HEAP_ARRAY(GCTaskThread*, workers()); + _thread = NEW_C_HEAP_ARRAY(GCTaskThread*, workers(), mtGC); for (uint t = 0; t < workers(); t += 1) { set_thread(t, GCTaskThread::create(this, t, processor_assignment[t])); } @@ -426,7 +426,7 @@ void GCTaskManager::initialize() { } tty->cr(); } - FREE_C_HEAP_ARRAY(uint, processor_assignment); + FREE_C_HEAP_ARRAY(uint, processor_assignment, mtGC); } reset_busy_workers(); set_unblocked(); @@ -455,11 +455,11 @@ GCTaskManager::~GCTaskManager() { GCTaskThread::destroy(thread(i)); set_thread(i, NULL); } - FREE_C_HEAP_ARRAY(GCTaskThread*, _thread); + FREE_C_HEAP_ARRAY(GCTaskThread*, _thread, mtGC); _thread = NULL; } if (_resource_flag != NULL) { - FREE_C_HEAP_ARRAY(bool, _resource_flag); + FREE_C_HEAP_ARRAY(bool, _resource_flag, mtGC); _resource_flag = NULL; } if (queue() != NULL) { @@ -817,7 +817,7 @@ NoopGCTask* NoopGCTask::create() { } NoopGCTask* NoopGCTask::create_on_c_heap() { - NoopGCTask* result = new(ResourceObj::C_HEAP) NoopGCTask(true); + NoopGCTask* result = new(ResourceObj::C_HEAP, mtGC) NoopGCTask(true); return result; } @@ -848,7 +848,7 @@ IdleGCTask* IdleGCTask::create() { } IdleGCTask* IdleGCTask::create_on_c_heap() { - IdleGCTask* result = new(ResourceObj::C_HEAP) IdleGCTask(true); + IdleGCTask* result = new(ResourceObj::C_HEAP, mtGC) IdleGCTask(true); assert(UseDynamicNumberOfGCThreads, "Should only be used with dynamic GC thread"); return result; @@ -984,7 +984,7 @@ WaitForBarrierGCTask* WaitForBarrierGCTask::create() { WaitForBarrierGCTask* WaitForBarrierGCTask::create_on_c_heap() { WaitForBarrierGCTask* result = - new (ResourceObj::C_HEAP) WaitForBarrierGCTask(true); + new (ResourceObj::C_HEAP, mtGC) WaitForBarrierGCTask(true); return result; } @@ -1114,7 +1114,7 @@ Monitor* MonitorSupply::reserve() { // Lazy initialization. if (freelist() == NULL) { _freelist = - new(ResourceObj::C_HEAP) GrowableArray(ParallelGCThreads, + new(ResourceObj::C_HEAP, mtGC) GrowableArray(ParallelGCThreads, true); } if (! freelist()->is_empty()) { diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.hpp index 65a8458d3b9..b64f7d9557e 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.hpp @@ -216,7 +216,7 @@ protected: // A GCTaskQueue that can be synchronized. // This "has-a" GCTaskQueue and a mutex to do the exclusion. -class SynchronizedGCTaskQueue : public CHeapObj { +class SynchronizedGCTaskQueue : public CHeapObj { private: // Instance state. GCTaskQueue* _unsynchronized_queue; // Has-a unsynchronized queue. @@ -278,7 +278,7 @@ protected: // This is an abstract base class for getting notifications // when a GCTaskManager is done. -class NotifyDoneClosure : public CHeapObj { +class NotifyDoneClosure : public CHeapObj { public: // The notification callback method. virtual void notify(GCTaskManager* manager) = 0; @@ -355,7 +355,7 @@ protected: // held in the GCTaskThread** _thread array in GCTaskManager. -class GCTaskManager : public CHeapObj { +class GCTaskManager : public CHeapObj { friend class ParCompactionManager; friend class PSParallelCompact; friend class PSScavenge; diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.cpp index 976d879d5f6..9bbdf49ed75 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.cpp @@ -46,7 +46,7 @@ GCTaskThread::GCTaskThread(GCTaskManager* manager, vm_exit_out_of_memory(0, "Cannot create GC thread. Out of system resources."); if (PrintGCTaskTimeStamps) { - _time_stamps = NEW_C_HEAP_ARRAY(GCTaskTimeStamp, GCTaskTimeStampEntries ); + _time_stamps = NEW_C_HEAP_ARRAY(GCTaskTimeStamp, GCTaskTimeStampEntries, mtGC); guarantee(_time_stamps != NULL, "Sanity"); } @@ -56,7 +56,7 @@ GCTaskThread::GCTaskThread(GCTaskManager* manager, GCTaskThread::~GCTaskThread() { if (_time_stamps != NULL) { - FREE_C_HEAP_ARRAY(GCTaskTimeStamp, _time_stamps); + FREE_C_HEAP_ARRAY(GCTaskTimeStamp, _time_stamps, mtGC); } } diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.hpp index c8406545e9b..1a77fe060c4 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.hpp @@ -90,7 +90,7 @@ protected: void set_is_working(bool v) { _is_working = v; } }; -class GCTaskTimeStamp : public CHeapObj +class GCTaskTimeStamp : public CHeapObj { private: jlong _entry_time; diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.cpp index 1b80839213d..8a852cc95e9 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.cpp @@ -28,6 +28,7 @@ #include "memory/cardTableModRefBS.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" +#include "services/memTracker.hpp" void ObjectStartArray::initialize(MemRegion reserved_region) { // We're based on the assumption that we use the same @@ -50,6 +51,7 @@ void ObjectStartArray::initialize(MemRegion reserved_region) { if (!backing_store.is_reserved()) { vm_exit_during_initialization("Could not reserve space for ObjectStartArray"); } + MemTracker::record_virtual_memory_type((address)backing_store.base(), mtGC); // We do not commit any memory initially if (!_virtual_space.initialize(backing_store, 0)) { @@ -57,10 +59,14 @@ void ObjectStartArray::initialize(MemRegion reserved_region) { } _raw_base = (jbyte*)_virtual_space.low_boundary(); + if (_raw_base == NULL) { vm_exit_during_initialization("Could not get raw_base address"); } + MemTracker::record_virtual_memory_type((address)_raw_base, mtGC); + + _offset_base = _raw_base - (size_t(reserved_region.start()) >> block_shift); _covered_region.set_start(reserved_region.start()); diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp index cea680b58b1..cbd671a06c4 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/objectStartArray.hpp @@ -35,7 +35,7 @@ // covered region. // -class ObjectStartArray : public CHeapObj { +class ObjectStartArray : public CHeapObj { friend class VerifyObjectStartArrayClosure; private: diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp index 4496a6987de..44ddcba440f 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp @@ -29,6 +29,7 @@ #include "oops/oop.inline.hpp" #include "runtime/os.hpp" #include "utilities/bitMap.inline.hpp" +#include "services/memTracker.hpp" #ifdef TARGET_OS_FAMILY_linux # include "os_linux.inline.hpp" #endif @@ -61,6 +62,9 @@ ParMarkBitMap::initialize(MemRegion covered_region) ReservedSpace rs(bytes, rs_align, rs_align > 0); os::trace_page_sizes("par bitmap", raw_bytes, raw_bytes, page_sz, rs.base(), rs.size()); + + MemTracker::record_virtual_memory_type((address)rs.base(), mtGC); + _virtual_space = new PSVirtualSpace(rs, page_sz); if (_virtual_space != NULL && _virtual_space->expand_by(bytes)) { _region_start = covered_region.start(); diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp index e6a07310dbf..9523b7923f6 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp @@ -32,7 +32,7 @@ class oopDesc; class ParMarkBitMapClosure; -class ParMarkBitMap: public CHeapObj +class ParMarkBitMap: public CHeapObj { public: typedef BitMap::idx_t idx_t; diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp index 9a8848d5399..a1031a76a61 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp @@ -40,6 +40,7 @@ #include "runtime/handles.inline.hpp" #include "runtime/java.hpp" #include "runtime/vmThread.hpp" +#include "services/memTracker.hpp" #include "utilities/vmError.hpp" PSYoungGen* ParallelScavengeHeap::_young_gen = NULL; @@ -161,6 +162,8 @@ jint ParallelScavengeHeap::initialize() { } } + MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap); + os::trace_page_sizes("ps perm", pg_min_size, pg_max_size, pg_page_sz, heap_rs.base(), pg_max_size); os::trace_page_sizes("ps main", og_min_size + yg_min_size, diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp index ab4ad84796b..fc66dcf52a9 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp @@ -81,14 +81,14 @@ void ParCompactionManager::initialize(ParMarkBitMap* mbm) { uint parallel_gc_threads = PSParallelCompact::gc_task_manager()->workers(); assert(_manager_array == NULL, "Attempt to initialize twice"); - _manager_array = NEW_C_HEAP_ARRAY(ParCompactionManager*, parallel_gc_threads+1 ); + _manager_array = NEW_C_HEAP_ARRAY(ParCompactionManager*, parallel_gc_threads+1, mtGC); guarantee(_manager_array != NULL, "Could not allocate manager_array"); _region_list = NEW_C_HEAP_ARRAY(RegionTaskQueue*, - parallel_gc_threads+1); + parallel_gc_threads+1, mtGC); guarantee(_region_list != NULL, "Could not initialize promotion manager"); - _recycled_stack_index = NEW_C_HEAP_ARRAY(uint, parallel_gc_threads); + _recycled_stack_index = NEW_C_HEAP_ARRAY(uint, parallel_gc_threads, mtGC); // parallel_gc-threads + 1 to be consistent with the number of // compaction managers. diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp index a864ac8edf1..73849bebaaf 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp @@ -41,7 +41,7 @@ class ObjectStartArray; class ParallelCompactData; class ParMarkBitMap; -class ParCompactionManager : public CHeapObj { +class ParCompactionManager : public CHeapObj { friend class ParallelTaskTerminator; friend class ParMarkBitMap; friend class PSParallelCompact; @@ -66,8 +66,8 @@ class ParCompactionManager : public CHeapObj { private: // 32-bit: 4K * 8 = 32KiB; 64-bit: 8K * 16 = 128KiB #define QUEUE_SIZE (1 << NOT_LP64(12) LP64_ONLY(13)) - typedef OverflowTaskQueue ObjArrayTaskQueue; - typedef GenericTaskQueueSet ObjArrayTaskQueueSet; + typedef OverflowTaskQueue ObjArrayTaskQueue; + typedef GenericTaskQueueSet ObjArrayTaskQueueSet; #undef QUEUE_SIZE static ParCompactionManager** _manager_array; @@ -78,7 +78,7 @@ class ParCompactionManager : public CHeapObj { static PSOldGen* _old_gen; private: - OverflowTaskQueue _marking_stack; + OverflowTaskQueue _marking_stack; ObjArrayTaskQueue _objarray_stack; // Is there a way to reuse the _marking_stack for the @@ -110,8 +110,8 @@ private: // popped. If -1, there has not been any entry popped. static int _recycled_bottom; - Stack _revisit_klass_stack; - Stack _revisit_mdo_stack; + Stack _revisit_klass_stack; + Stack _revisit_mdo_stack; static ParMarkBitMap* _mark_bitmap; @@ -126,7 +126,7 @@ private: protected: // Array of tasks. Needed by the ParallelTaskTerminator. static RegionTaskQueueSet* region_array() { return _region_array; } - OverflowTaskQueue* marking_stack() { return &_marking_stack; } + OverflowTaskQueue* marking_stack() { return &_marking_stack; } // Pushes onto the marking stack. If the marking stack is full, // pushes onto the overflow stack. @@ -175,8 +175,8 @@ private: bool should_update(); bool should_copy(); - Stack* revisit_klass_stack() { return &_revisit_klass_stack; } - Stack* revisit_mdo_stack() { return &_revisit_mdo_stack; } + Stack* revisit_klass_stack() { return &_revisit_klass_stack; } + Stack* revisit_mdo_stack() { return &_revisit_mdo_stack; } // Save for later processing. Must not fail. inline void push(oop obj) { _marking_stack.push(obj); } diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psGenerationCounters.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psGenerationCounters.cpp index 67378de145e..ccb4298f883 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psGenerationCounters.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psGenerationCounters.cpp @@ -40,7 +40,7 @@ PSGenerationCounters::PSGenerationCounters(const char* name, const char* cns = PerfDataManager::name_space("generation", ordinal); - _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1); + _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1, mtGC); strcpy(_name_space, cns); const char* cname = PerfDataManager::counter_name(_name_space, "name"); diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp index 9d721d61bc4..ae92f3690fe 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp @@ -34,7 +34,7 @@ class ObjectStartArray; -class PSMarkSweepDecorator: public CHeapObj { +class PSMarkSweepDecorator: public CHeapObj { private: static PSMarkSweepDecorator* _destination_decorator; diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp index ce45376f01e..c07b381bc62 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp @@ -34,7 +34,7 @@ class PSMarkSweepDecorator; -class PSOldGen : public CHeapObj { +class PSOldGen : public CHeapObj { friend class VMStructs; friend class PSPromotionManager; // Uses the cas_allocate methods friend class ParallelScavengeHeap; diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp index 8e7c74e4495..2633197b067 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp @@ -53,6 +53,7 @@ #include "runtime/vmThread.hpp" #include "services/management.hpp" #include "services/memoryService.hpp" +#include "services/memTracker.hpp" #include "utilities/events.hpp" #include "utilities/stack.inline.hpp" @@ -405,6 +406,9 @@ ParallelCompactData::create_vspace(size_t count, size_t element_size) ReservedSpace rs(bytes, rs_align, rs_align > 0); os::trace_page_sizes("par compact", raw_bytes, raw_bytes, page_sz, rs.base(), rs.size()); + + MemTracker::record_virtual_memory_type((address)rs.base(), mtGC); + PSVirtualSpace* vspace = new PSVirtualSpace(rs, page_sz); if (vspace != 0) { if (vspace->expand_by(bytes)) { @@ -2732,7 +2736,7 @@ PSParallelCompact::follow_weak_klass_links() { for (uint i = 0; i < ParallelGCThreads + 1; i++) { ParCompactionManager* cm = ParCompactionManager::manager_array(i); KeepAliveClosure keep_alive_closure(cm); - Stack* const rks = cm->revisit_klass_stack(); + Stack* const rks = cm->revisit_klass_stack(); if (PrintRevisitStats) { gclog_or_tty->print_cr("Revisit klass stack[%u] length = " SIZE_FORMAT, i, rks->size()); @@ -2765,7 +2769,7 @@ void PSParallelCompact::follow_mdo_weak_refs() { } for (uint i = 0; i < ParallelGCThreads + 1; i++) { ParCompactionManager* cm = ParCompactionManager::manager_array(i); - Stack* rms = cm->revisit_mdo_stack(); + Stack* rms = cm->revisit_mdo_stack(); if (PrintRevisitStats) { gclog_or_tty->print_cr("Revisit MDO stack[%u] size = " SIZE_FORMAT, i, rms->size()); diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.hpp index fd6a7bf561b..e11ce406eec 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.hpp @@ -36,7 +36,7 @@ class ObjectStartArray; -class PSPromotionLAB : public CHeapObj { +class PSPromotionLAB : public CHeapObj { protected: static size_t filler_header_size; diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp index f7249690539..b3f91d51f99 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp @@ -45,7 +45,7 @@ void PSPromotionManager::initialize() { _young_space = heap->young_gen()->to_space(); assert(_manager_array == NULL, "Attempt to initialize twice"); - _manager_array = NEW_C_HEAP_ARRAY(PSPromotionManager*, ParallelGCThreads+1 ); + _manager_array = NEW_C_HEAP_ARRAY(PSPromotionManager*, ParallelGCThreads+1, mtGC); guarantee(_manager_array != NULL, "Could not initialize promotion manager"); _stack_array_depth = new OopStarTaskQueueSet(ParallelGCThreads); diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp index 360640eba07..0e429edc660 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp @@ -49,7 +49,7 @@ class MutableSpace; class PSOldGen; class ParCompactionManager; -class PSPromotionManager : public CHeapObj { +class PSPromotionManager : public CHeapObj { friend class PSScavenge; friend class PSRefProcTaskExecutor; private: @@ -77,7 +77,7 @@ class PSPromotionManager : public CHeapObj { bool _old_gen_is_full; OopStarTaskQueue _claimed_stack_depth; - OverflowTaskQueue _claimed_stack_breadth; + OverflowTaskQueue _claimed_stack_breadth; bool _totally_drain; uint _target_stack_size; diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp index 65ece052d16..38d74422deb 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp @@ -62,8 +62,8 @@ bool PSScavenge::_survivor_overflow = false; int PSScavenge::_tenuring_threshold = 0; HeapWord* PSScavenge::_young_generation_boundary = NULL; elapsedTimer PSScavenge::_accumulated_time; -Stack PSScavenge::_preserved_mark_stack; -Stack PSScavenge::_preserved_oop_stack; +Stack PSScavenge::_preserved_mark_stack; +Stack PSScavenge::_preserved_oop_stack; CollectorCounters* PSScavenge::_counters = NULL; bool PSScavenge::_promotion_failed = false; diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp index 2ff201e4e8b..25416d01141 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp @@ -71,8 +71,8 @@ class PSScavenge: AllStatic { static HeapWord* _young_generation_boundary; // The lowest address possible for the young_gen. // This is used to decide if an oop should be scavenged, // cards should be marked, etc. - static Stack _preserved_mark_stack; // List of marks to be restored after failed promotion - static Stack _preserved_oop_stack; // List of oops that need their mark restored. + static Stack _preserved_mark_stack; // List of marks to be restored after failed promotion + static Stack _preserved_oop_stack; // List of oops that need their mark restored. static CollectorCounters* _counters; // collector performance counters static bool _promotion_failed; diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.hpp index da452cab0dc..b90ed979b4e 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.hpp @@ -32,7 +32,7 @@ // VirtualSpace is data structure for committing a previously reserved address // range in smaller chunks. -class PSVirtualSpace : public CHeapObj { +class PSVirtualSpace : public CHeapObj { friend class VMStructs; protected: // The space is committed/uncommited in chunks of size _alignment. The diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.hpp index b5a2a14bbbf..7f1c297cc58 100644 --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.hpp +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.hpp @@ -33,7 +33,7 @@ class PSMarkSweepDecorator; -class PSYoungGen : public CHeapObj { +class PSYoungGen : public CHeapObj { friend class VMStructs; friend class ParallelScavengeHeap; friend class AdjoiningGenerations; diff --git a/hotspot/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp b/hotspot/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp index dd1895e9e06..4becadce84b 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp @@ -38,7 +38,7 @@ class elapsedTimer; class CollectorPolicy; -class AdaptiveSizePolicy : public CHeapObj { +class AdaptiveSizePolicy : public CHeapObj { friend class GCAdaptivePolicyCounters; friend class PSGCAdaptivePolicyCounters; friend class CMSGCAdaptivePolicyCounters; diff --git a/hotspot/src/share/vm/gc_implementation/shared/cSpaceCounters.cpp b/hotspot/src/share/vm/gc_implementation/shared/cSpaceCounters.cpp index e6820723007..2319ca1a7a2 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/cSpaceCounters.cpp +++ b/hotspot/src/share/vm/gc_implementation/shared/cSpaceCounters.cpp @@ -37,7 +37,7 @@ CSpaceCounters::CSpaceCounters(const char* name, int ordinal, size_t max_size, const char* cns = PerfDataManager::name_space(gc->name_space(), "space", ordinal); - _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1); + _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1, mtGC); strcpy(_name_space, cns); const char* cname = PerfDataManager::counter_name(_name_space, "name"); diff --git a/hotspot/src/share/vm/gc_implementation/shared/cSpaceCounters.hpp b/hotspot/src/share/vm/gc_implementation/shared/cSpaceCounters.hpp index d4a860eb842..c113a3338fd 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/cSpaceCounters.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/cSpaceCounters.hpp @@ -32,7 +32,7 @@ // A CSpaceCounters is a holder class for performance counters // that track a space; -class CSpaceCounters: public CHeapObj { +class CSpaceCounters: public CHeapObj { friend class VMStructs; private: @@ -52,7 +52,7 @@ class CSpaceCounters: public CHeapObj { ContiguousSpace* s, GenerationCounters* gc); ~CSpaceCounters() { - if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space); + if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space, mtInternal); } inline void update_capacity() { diff --git a/hotspot/src/share/vm/gc_implementation/shared/collectorCounters.cpp b/hotspot/src/share/vm/gc_implementation/shared/collectorCounters.cpp index 91dad5e66e1..d5aff5c5d09 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/collectorCounters.cpp +++ b/hotspot/src/share/vm/gc_implementation/shared/collectorCounters.cpp @@ -34,7 +34,7 @@ CollectorCounters::CollectorCounters(const char* name, int ordinal) { const char* cns = PerfDataManager::name_space("collector", ordinal); - _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1); + _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1, mtGC); strcpy(_name_space, cns); char* cname = PerfDataManager::counter_name(_name_space, "name"); diff --git a/hotspot/src/share/vm/gc_implementation/shared/collectorCounters.hpp b/hotspot/src/share/vm/gc_implementation/shared/collectorCounters.hpp index b793f7b24db..52eb44396ad 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/collectorCounters.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/collectorCounters.hpp @@ -30,7 +30,7 @@ // CollectorCounters is a holder class for performance counters // that track a collector -class CollectorCounters: public CHeapObj { +class CollectorCounters: public CHeapObj { friend class VMStructs; private: @@ -50,7 +50,7 @@ class CollectorCounters: public CHeapObj { CollectorCounters(const char* name, int ordinal); ~CollectorCounters() { - if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space); + if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space, mtGC); } inline PerfCounter* invocation_counter() const { return _invocations; } diff --git a/hotspot/src/share/vm/gc_implementation/shared/gSpaceCounters.cpp b/hotspot/src/share/vm/gc_implementation/shared/gSpaceCounters.cpp index 3d95950e834..00a96703d57 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/gSpaceCounters.cpp +++ b/hotspot/src/share/vm/gc_implementation/shared/gSpaceCounters.cpp @@ -41,7 +41,7 @@ GSpaceCounters::GSpaceCounters(const char* name, int ordinal, size_t max_size, const char* cns = PerfDataManager::name_space(gc->name_space(), "space", ordinal); - _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1); + _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1, mtGC); strcpy(_name_space, cns); const char* cname = PerfDataManager::counter_name(_name_space, "name"); diff --git a/hotspot/src/share/vm/gc_implementation/shared/gSpaceCounters.hpp b/hotspot/src/share/vm/gc_implementation/shared/gSpaceCounters.hpp index 85764c4f743..8b901e2e9e0 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/gSpaceCounters.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/gSpaceCounters.hpp @@ -34,7 +34,7 @@ // A GSpaceCounter is a holder class for performance counters // that track a space; -class GSpaceCounters: public CHeapObj { +class GSpaceCounters: public CHeapObj { friend class VMStructs; private: @@ -54,7 +54,7 @@ class GSpaceCounters: public CHeapObj { GenerationCounters* gc, bool sampled=true); ~GSpaceCounters() { - if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space); + if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space, mtGC); } inline void update_capacity() { diff --git a/hotspot/src/share/vm/gc_implementation/shared/gcPolicyCounters.hpp b/hotspot/src/share/vm/gc_implementation/shared/gcPolicyCounters.hpp index 6d4494c0f4d..10a7bac5144 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/gcPolicyCounters.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/gcPolicyCounters.hpp @@ -30,7 +30,7 @@ // GCPolicyCounters is a holder class for performance counters // that track a generation -class GCPolicyCounters: public CHeapObj { +class GCPolicyCounters: public CHeapObj { friend class VMStructs; private: diff --git a/hotspot/src/share/vm/gc_implementation/shared/gcStats.hpp b/hotspot/src/share/vm/gc_implementation/shared/gcStats.hpp index 070300e9b1a..af16ca63ecf 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/gcStats.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/gcStats.hpp @@ -27,7 +27,7 @@ #include "gc_implementation/shared/gcUtil.hpp" -class GCStats : public CHeapObj { +class GCStats : public CHeapObj { protected: // Avg amount promoted; used for avoiding promotion undo // This class does not update deviations if the sample is zero. diff --git a/hotspot/src/share/vm/gc_implementation/shared/gcUtil.hpp b/hotspot/src/share/vm/gc_implementation/shared/gcUtil.hpp index 86daba64c3f..ba97f7cfd3a 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/gcUtil.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/gcUtil.hpp @@ -43,7 +43,7 @@ // // This serves as our best estimate of a future unknown. // -class AdaptiveWeightedAverage : public CHeapObj { +class AdaptiveWeightedAverage : public CHeapObj { private: float _average; // The last computed average unsigned _sample_count; // How often we've sampled this average @@ -146,7 +146,7 @@ class AdaptivePaddedAverage : public AdaptiveWeightedAverage { // Placement support void* operator new(size_t ignored, void* p) { return p; } // Allocator - void* operator new(size_t size) { return CHeapObj::operator new(size); } + void* operator new(size_t size) { return CHeapObj::operator new(size); } // Accessor float padded_average() const { return _padded_avg; } @@ -192,7 +192,7 @@ public: // equation. // y = intercept + slope * x -class LinearLeastSquareFit : public CHeapObj { +class LinearLeastSquareFit : public CHeapObj { double _sum_x; // sum of all independent data points x double _sum_x_squared; // sum of all independent data points x**2 double _sum_y; // sum of all dependent data points y diff --git a/hotspot/src/share/vm/gc_implementation/shared/generationCounters.cpp b/hotspot/src/share/vm/gc_implementation/shared/generationCounters.cpp index 68ab6ffc17e..8cbfac19bee 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/generationCounters.cpp +++ b/hotspot/src/share/vm/gc_implementation/shared/generationCounters.cpp @@ -35,7 +35,7 @@ void GenerationCounters::initialize(const char* name, int ordinal, int spaces, const char* cns = PerfDataManager::name_space("generation", ordinal); - _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1); + _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1, mtGC); strcpy(_name_space, cns); const char* cname = PerfDataManager::counter_name(_name_space, "name"); diff --git a/hotspot/src/share/vm/gc_implementation/shared/generationCounters.hpp b/hotspot/src/share/vm/gc_implementation/shared/generationCounters.hpp index f399b955819..78c00769101 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/generationCounters.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/generationCounters.hpp @@ -31,7 +31,7 @@ // A GenerationCounter is a holder class for performance counters // that track a generation -class GenerationCounters: public CHeapObj { +class GenerationCounters: public CHeapObj { friend class VMStructs; private: @@ -69,7 +69,7 @@ private: VirtualSpace* v); ~GenerationCounters() { - if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space); + if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space, mtGC); } virtual void update_all(); diff --git a/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.cpp b/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.cpp index 17a69fa832e..cc4cccb3bdc 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.cpp +++ b/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.cpp @@ -40,7 +40,7 @@ HSpaceCounters::HSpaceCounters(const char* name, const char* cns = PerfDataManager::name_space(gc->name_space(), "space", ordinal); - _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1); + _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1, mtGC); strcpy(_name_space, cns); const char* cname = PerfDataManager::counter_name(_name_space, "name"); diff --git a/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.hpp b/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.hpp index a55d443a91f..d33a103fb32 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.hpp @@ -37,7 +37,7 @@ class HeapSpaceUsedHelper; class G1SpaceMonitoringSupport; -class HSpaceCounters: public CHeapObj { +class HSpaceCounters: public CHeapObj { friend class VMStructs; private: @@ -55,7 +55,7 @@ class HSpaceCounters: public CHeapObj { size_t initial_capacity, GenerationCounters* gc); ~HSpaceCounters() { - if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space); + if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space, mtGC); } inline void update_capacity(size_t v) { diff --git a/hotspot/src/share/vm/gc_implementation/shared/immutableSpace.hpp b/hotspot/src/share/vm/gc_implementation/shared/immutableSpace.hpp index 7d6be0d9f85..6152e64e4c9 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/immutableSpace.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/immutableSpace.hpp @@ -33,7 +33,7 @@ // Invariant: bottom() and end() are on page_size boundaries and // bottom() <= end() -class ImmutableSpace: public CHeapObj { +class ImmutableSpace: public CHeapObj { friend class VMStructs; protected: HeapWord* _bottom; diff --git a/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp b/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp index 584c24c821a..77678293653 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp +++ b/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp @@ -30,13 +30,13 @@ #include "oops/objArrayKlass.inline.hpp" #include "oops/oop.inline.hpp" -Stack MarkSweep::_marking_stack; -Stack MarkSweep::_revisit_mdo_stack; -Stack MarkSweep::_revisit_klass_stack; -Stack MarkSweep::_objarray_stack; +Stack MarkSweep::_marking_stack; +Stack MarkSweep::_revisit_mdo_stack; +Stack MarkSweep::_revisit_klass_stack; +Stack MarkSweep::_objarray_stack; -Stack MarkSweep::_preserved_oop_stack; -Stack MarkSweep::_preserved_mark_stack; +Stack MarkSweep::_preserved_oop_stack; +Stack MarkSweep::_preserved_mark_stack; size_t MarkSweep::_preserved_count = 0; size_t MarkSweep::_preserved_count_max = 0; PreservedMark* MarkSweep::_preserved_marks = NULL; @@ -166,7 +166,7 @@ void MarkSweep::adjust_marks() { } // deal with the overflow stack - StackIterator iter(_preserved_oop_stack); + StackIterator iter(_preserved_oop_stack); while (!iter.is_empty()) { oop* p = iter.next_addr(); adjust_pointer(p); diff --git a/hotspot/src/share/vm/gc_implementation/shared/markSweep.hpp b/hotspot/src/share/vm/gc_implementation/shared/markSweep.hpp index 19bee0ed34e..4decbddc7fd 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/markSweep.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/markSweep.hpp @@ -122,16 +122,16 @@ class MarkSweep : AllStatic { // protected: // Traversal stacks used during phase1 - static Stack _marking_stack; - static Stack _objarray_stack; + static Stack _marking_stack; + static Stack _objarray_stack; // Stack for live klasses to revisit at end of marking phase - static Stack _revisit_klass_stack; + static Stack _revisit_klass_stack; // Set (stack) of MDO's to revisit at end of marking phase - static Stack _revisit_mdo_stack; + static Stack _revisit_mdo_stack; // Space for storing/restoring mark word - static Stack _preserved_mark_stack; - static Stack _preserved_oop_stack; + static Stack _preserved_mark_stack; + static Stack _preserved_oop_stack; static size_t _preserved_count; static size_t _preserved_count_max; static PreservedMark* _preserved_marks; diff --git a/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp b/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp index f0f6a49d958..d930b00674b 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp +++ b/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp @@ -43,7 +43,7 @@ MutableNUMASpace::MutableNUMASpace(size_t alignment) : MutableSpace(alignment) { - _lgrp_spaces = new (ResourceObj::C_HEAP) GrowableArray(0, true); + _lgrp_spaces = new (ResourceObj::C_HEAP, mtGC) GrowableArray(0, true); _page_size = os::vm_page_size(); _adaptation_cycles = 0; _samples_count = 0; @@ -231,7 +231,7 @@ bool MutableNUMASpace::update_layout(bool force) { if (force || changed) { // Compute lgrp intersection. Add/remove spaces. int lgrp_limit = (int)os::numa_get_groups_num(); - int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit); + int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit, mtGC); int lgrp_num = (int)os::numa_get_leaf_groups(lgrp_ids, lgrp_limit); assert(lgrp_num > 0, "There should be at least one locality group"); // Add new spaces for the new nodes @@ -265,7 +265,7 @@ bool MutableNUMASpace::update_layout(bool force) { } } - FREE_C_HEAP_ARRAY(int, lgrp_ids); + FREE_C_HEAP_ARRAY(int, lgrp_ids, mtGC); if (changed) { for (JavaThread *thread = Threads::first(); thread; thread = thread->next()) { diff --git a/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.hpp b/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.hpp index db7207cc24b..8b8f8d65e21 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.hpp @@ -63,7 +63,7 @@ class MutableNUMASpace : public MutableSpace { friend class VMStructs; - class LGRPSpace : public CHeapObj { + class LGRPSpace : public CHeapObj { int _lgrp_id; MutableSpace* _space; MemRegion _invalid_region; diff --git a/hotspot/src/share/vm/gc_implementation/shared/spaceCounters.cpp b/hotspot/src/share/vm/gc_implementation/shared/spaceCounters.cpp index a5815c921cd..44fc6e16b70 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/spaceCounters.cpp +++ b/hotspot/src/share/vm/gc_implementation/shared/spaceCounters.cpp @@ -39,7 +39,7 @@ SpaceCounters::SpaceCounters(const char* name, int ordinal, size_t max_size, const char* cns = PerfDataManager::name_space(gc->name_space(), "space", ordinal); - _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1); + _name_space = NEW_C_HEAP_ARRAY(char, strlen(cns)+1, mtGC); strcpy(_name_space, cns); const char* cname = PerfDataManager::counter_name(_name_space, "name"); diff --git a/hotspot/src/share/vm/gc_implementation/shared/spaceCounters.hpp b/hotspot/src/share/vm/gc_implementation/shared/spaceCounters.hpp index f75a9f26c1e..1369ee0c313 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/spaceCounters.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/spaceCounters.hpp @@ -35,7 +35,7 @@ // A SpaceCounter is a holder class for performance counters // that track a space; -class SpaceCounters: public CHeapObj { +class SpaceCounters: public CHeapObj { friend class VMStructs; private: @@ -55,7 +55,7 @@ class SpaceCounters: public CHeapObj { MutableSpace* m, GenerationCounters* gc); ~SpaceCounters() { - if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space); + if (_name_space != NULL) FREE_C_HEAP_ARRAY(char, _name_space, mtGC); } inline void update_capacity() { diff --git a/hotspot/src/share/vm/gc_implementation/shared/spaceDecorator.hpp b/hotspot/src/share/vm/gc_implementation/shared/spaceDecorator.hpp index c41a5eb591b..513735ddf08 100644 --- a/hotspot/src/share/vm/gc_implementation/shared/spaceDecorator.hpp +++ b/hotspot/src/share/vm/gc_implementation/shared/spaceDecorator.hpp @@ -70,7 +70,7 @@ class SpaceDecorator: public AllStatic { // These subclasses abstract the differences in the types of spaces used // by each heap. -class SpaceMangler: public CHeapObj { +class SpaceMangler: public CHeapObj { friend class VMStructs; // High water mark for allocations. Typically, the space above diff --git a/hotspot/src/share/vm/gc_interface/collectedHeap.hpp b/hotspot/src/share/vm/gc_interface/collectedHeap.hpp index 105e1ea8f24..be42500031d 100644 --- a/hotspot/src/share/vm/gc_interface/collectedHeap.hpp +++ b/hotspot/src/share/vm/gc_interface/collectedHeap.hpp @@ -74,7 +74,7 @@ class GCHeapLog : public EventLogBase { // G1CollectedHeap // ParallelScavengeHeap // -class CollectedHeap : public CHeapObj { +class CollectedHeap : public CHeapObj { friend class VMStructs; friend class IsGCActiveMark; // Block structured external access to _is_gc_active friend class constantPoolCacheKlass; // allocate() method inserts is_conc_safe diff --git a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp index 6f5511f9fcc..956dbf86917 100644 --- a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp +++ b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp @@ -1118,8 +1118,8 @@ void SignatureHandlerLibrary::initialize() { SignatureHandlerLibrary::buffer_size); _buffer = bb->code_begin(); - _fingerprints = new(ResourceObj::C_HEAP)GrowableArray(32, true); - _handlers = new(ResourceObj::C_HEAP)GrowableArray
(32, true); + _fingerprints = new(ResourceObj::C_HEAP, mtCode)GrowableArray(32, true); + _handlers = new(ResourceObj::C_HEAP, mtCode)GrowableArray
(32, true); } address SignatureHandlerLibrary::set_handler(CodeBuffer* buffer) { diff --git a/hotspot/src/share/vm/interpreter/oopMapCache.cpp b/hotspot/src/share/vm/interpreter/oopMapCache.cpp index f5ff6f6c917..01d5753547b 100644 --- a/hotspot/src/share/vm/interpreter/oopMapCache.cpp +++ b/hotspot/src/share/vm/interpreter/oopMapCache.cpp @@ -348,7 +348,7 @@ void OopMapCacheEntry::allocate_bit_mask() { if (mask_size() > small_mask_limit) { assert(_bit_mask[0] == 0, "bit mask should be new or just flushed"); _bit_mask[0] = (intptr_t) - NEW_C_HEAP_ARRAY(uintptr_t, mask_word_size()); + NEW_C_HEAP_ARRAY(uintptr_t, mask_word_size(), mtClass); } } @@ -356,7 +356,7 @@ void OopMapCacheEntry::deallocate_bit_mask() { if (mask_size() > small_mask_limit && _bit_mask[0] != 0) { assert(!Thread::current()->resource_area()->contains((void*)_bit_mask[0]), "This bit mask should not be in the resource area"); - FREE_C_HEAP_ARRAY(uintptr_t, _bit_mask[0]); + FREE_C_HEAP_ARRAY(uintptr_t, _bit_mask[0], mtClass); debug_only(_bit_mask[0] = 0;) } } @@ -506,7 +506,7 @@ inline unsigned int OopMapCache::hash_value_for(methodHandle method, int bci) { OopMapCache::OopMapCache() : _mut(Mutex::leaf, "An OopMapCache lock", true) { - _array = NEW_C_HEAP_ARRAY(OopMapCacheEntry, _size); + _array = NEW_C_HEAP_ARRAY(OopMapCacheEntry, _size, mtClass); // Cannot call flush for initialization, since flush // will check if memory should be deallocated for(int i = 0; i < _size; i++) _array[i].initialize(); @@ -520,7 +520,7 @@ OopMapCache::~OopMapCache() { flush(); // Deallocate array NOT_PRODUCT(_total_memory_usage -= sizeof(OopMapCache) + (sizeof(OopMapCacheEntry) * _size);) - FREE_C_HEAP_ARRAY(OopMapCacheEntry, _array); + FREE_C_HEAP_ARRAY(OopMapCacheEntry, _array, mtClass); } OopMapCacheEntry* OopMapCache::entry_at(int i) const { @@ -639,9 +639,9 @@ void OopMapCache::lookup(methodHandle method, void OopMapCache::compute_one_oop_map(methodHandle method, int bci, InterpreterOopMap* entry) { // Due to the invariants above it's tricky to allocate a temporary OopMapCacheEntry on the stack - OopMapCacheEntry* tmp = NEW_C_HEAP_ARRAY(OopMapCacheEntry, 1); + OopMapCacheEntry* tmp = NEW_C_HEAP_ARRAY(OopMapCacheEntry, 1, mtClass); tmp->initialize(); tmp->fill(method, bci); entry->resource_copy(tmp); - FREE_C_HEAP_ARRAY(OopMapCacheEntry, tmp); + FREE_C_HEAP_ARRAY(OopMapCacheEntry, tmp, mtInternal); } diff --git a/hotspot/src/share/vm/interpreter/oopMapCache.hpp b/hotspot/src/share/vm/interpreter/oopMapCache.hpp index 068e4d3b982..fea9ec09ca9 100644 --- a/hotspot/src/share/vm/interpreter/oopMapCache.hpp +++ b/hotspot/src/share/vm/interpreter/oopMapCache.hpp @@ -156,7 +156,7 @@ class InterpreterOopMap: ResourceObj { #endif }; -class OopMapCache : public CHeapObj { +class OopMapCache : public CHeapObj { private: enum { _size = 32, // Use fixed size for now _probe_depth = 3 // probe depth in case of collisions diff --git a/hotspot/src/share/vm/libadt/set.cpp b/hotspot/src/share/vm/libadt/set.cpp index 1849b13b294..c475a21f700 100644 --- a/hotspot/src/share/vm/libadt/set.cpp +++ b/hotspot/src/share/vm/libadt/set.cpp @@ -71,7 +71,7 @@ char *Set::setstr() const set.Sort(); // Sort elements for in-order retrieval uint len = 128; // Total string space - char *buf = NEW_C_HEAP_ARRAY(char,len);// Some initial string space + char *buf = NEW_C_HEAP_ARRAY(char,len, mtCompiler);// Some initial string space register char *s = buf; // Current working string pointer *s++ = '{'; @@ -86,7 +86,7 @@ char *Set::setstr() const if( buf+len-s < 25 ) { // Generous trailing space for upcoming numbers int offset = (int)(s-buf);// Not enuf space; compute offset into buffer len <<= 1; // Double string size - buf = REALLOC_C_HEAP_ARRAY(char,buf,len); // Reallocate doubled size + buf = REALLOC_C_HEAP_ARRAY(char,buf,len, mtCompiler); // Reallocate doubled size s = buf+offset; // Get working pointer into new bigger buffer } if( lo != (uint)-2 ) { // Startup? No! Then print previous range. @@ -101,7 +101,7 @@ char *Set::setstr() const if( buf+len-s < 25 ) { // Generous trailing space for upcoming numbers int offset = (int)(s-buf);// Not enuf space; compute offset into buffer len <<= 1; // Double string size - buf = (char*)ReallocateHeap(buf,len); // Reallocate doubled size + buf = (char*)ReallocateHeap(buf,len, mtCompiler); // Reallocate doubled size s = buf+offset; // Get working pointer into new bigger buffer } if( lo != hi ) sprintf(s,"%d-%d}",lo,hi); diff --git a/hotspot/src/share/vm/libadt/vectset.cpp b/hotspot/src/share/vm/libadt/vectset.cpp index 0042ca762fd..de7bcd81e80 100644 --- a/hotspot/src/share/vm/libadt/vectset.cpp +++ b/hotspot/src/share/vm/libadt/vectset.cpp @@ -362,7 +362,7 @@ public: }; SetI_ *VectorSet::iterate(uint &elem) const { - return new(ResourceObj::C_HEAP) VSetI_(this, elem); + return new(ResourceObj::C_HEAP, mtInternal) VSetI_(this, elem); } //============================================================================= diff --git a/hotspot/src/share/vm/memory/allocation.cpp b/hotspot/src/share/vm/memory/allocation.cpp index 0479e73378f..dfd061214f7 100644 --- a/hotspot/src/share/vm/memory/allocation.cpp +++ b/hotspot/src/share/vm/memory/allocation.cpp @@ -26,10 +26,13 @@ #include "memory/allocation.hpp" #include "memory/allocation.inline.hpp" #include "memory/resourceArea.hpp" +#include "runtime/atomic.hpp" #include "runtime/os.hpp" #include "runtime/task.hpp" #include "runtime/threadCritical.hpp" +#include "services/memTracker.hpp" #include "utilities/ostream.hpp" + #ifdef TARGET_OS_FAMILY_linux # include "os_linux.inline.hpp" #endif @@ -43,32 +46,16 @@ # include "os_bsd.inline.hpp" #endif -void* CHeapObj::operator new(size_t size){ - return (void *) AllocateHeap(size, "CHeapObj-new"); -} - -void* CHeapObj::operator new (size_t size, const std::nothrow_t& nothrow_constant) { - char* p = (char*) os::malloc(size); -#ifdef ASSERT - if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p); -#endif - return p; -} - -void CHeapObj::operator delete(void* p){ - FreeHeap(p); -} - void* StackObj::operator new(size_t size) { ShouldNotCallThis(); return 0; }; void StackObj::operator delete(void* p) { ShouldNotCallThis(); }; void* _ValueObj::operator new(size_t size) { ShouldNotCallThis(); return 0; }; void _ValueObj::operator delete(void* p) { ShouldNotCallThis(); }; -void* ResourceObj::operator new(size_t size, allocation_type type) { +void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) { address res; switch (type) { case C_HEAP: - res = (address)AllocateHeap(size, "C_Heap: ResourceOBJ"); + res = (address)AllocateHeap(size, flags, CALLER_PC); DEBUG_ONLY(set_allocation_type(res, C_HEAP);) break; case RESOURCE_AREA: @@ -184,7 +171,7 @@ bool warn_new_operator = false; // see vm_main // MT-safe pool of chunks to reduce malloc/free thrashing // NB: not using Mutex because pools are used before Threads are initialized -class ChunkPool { +class ChunkPool: public CHeapObj { Chunk* _first; // first cached Chunk; its first word points to next chunk size_t _num_chunks; // number of unused chunks in pool size_t _num_used; // number of chunks currently checked out @@ -210,14 +197,16 @@ class ChunkPool { ChunkPool(size_t size) : _size(size) { _first = NULL; _num_chunks = _num_used = 0; } // Allocate a new chunk from the pool (might expand the pool) - void* allocate(size_t bytes) { + _NOINLINE_ void* allocate(size_t bytes) { assert(bytes == _size, "bad size"); void* p = NULL; + // No VM lock can be taken inside ThreadCritical lock, so os::malloc + // should be done outside ThreadCritical lock due to NMT { ThreadCritical tc; _num_used++; p = get_first(); - if (p == NULL) p = os::malloc(bytes); } + if (p == NULL) p = os::malloc(bytes, mtChunk, CURRENT_PC); if (p == NULL) vm_exit_out_of_memory(bytes, "ChunkPool::allocate"); @@ -238,28 +227,34 @@ class ChunkPool { // Prune the pool void free_all_but(size_t n) { + Chunk* cur = NULL; + Chunk* next; + { // if we have more than n chunks, free all of them ThreadCritical tc; if (_num_chunks > n) { // free chunks at end of queue, for better locality - Chunk* cur = _first; + cur = _first; for (size_t i = 0; i < (n - 1) && cur != NULL; i++) cur = cur->next(); if (cur != NULL) { - Chunk* next = cur->next(); + next = cur->next(); cur->set_next(NULL); cur = next; - // Free all remaining chunks - while(cur != NULL) { - next = cur->next(); - os::free(cur); - _num_chunks--; - cur = next; + _num_chunks = n; } } } - } + + // Free all remaining chunks, outside of ThreadCritical + // to avoid deadlock with NMT + while(cur != NULL) { + next = cur->next(); + os::free(cur, mtChunk); + cur = next; + } + } // Accessors to preallocated pool's static ChunkPool* large_pool() { assert(_large_pool != NULL, "must be initialized"); return _large_pool; } @@ -323,7 +318,7 @@ void* Chunk::operator new(size_t requested_size, size_t length) { case Chunk::medium_size: return ChunkPool::medium_pool()->allocate(bytes); case Chunk::init_size: return ChunkPool::small_pool()->allocate(bytes); default: { - void *p = os::malloc(bytes); + void *p = os::malloc(bytes, mtChunk, CALLER_PC); if (p == NULL) vm_exit_out_of_memory(bytes, "Chunk::new"); return p; @@ -337,7 +332,7 @@ void Chunk::operator delete(void* p) { case Chunk::size: ChunkPool::large_pool()->free(c); break; case Chunk::medium_size: ChunkPool::medium_pool()->free(c); break; case Chunk::init_size: ChunkPool::small_pool()->free(c); break; - default: os::free(c); + default: os::free(c, mtChunk); } } @@ -374,6 +369,7 @@ void Chunk::start_chunk_pool_cleaner_task() { } //------------------------------Arena------------------------------------------ +NOT_PRODUCT(volatile jint Arena::_instance_count = 0;) Arena::Arena(size_t init_size) { size_t round_size = (sizeof (char *)) - 1; @@ -382,6 +378,7 @@ Arena::Arena(size_t init_size) { _hwm = _chunk->bottom(); // Save the cached hwm, max _max = _chunk->top(); set_size_in_bytes(init_size); + NOT_PRODUCT(Atomic::inc(&_instance_count);) } Arena::Arena() { @@ -389,12 +386,15 @@ Arena::Arena() { _hwm = _chunk->bottom(); // Save the cached hwm, max _max = _chunk->top(); set_size_in_bytes(Chunk::init_size); + NOT_PRODUCT(Atomic::inc(&_instance_count);) } Arena::Arena(Arena *a) : _chunk(a->_chunk), _hwm(a->_hwm), _max(a->_max), _first(a->_first) { set_size_in_bytes(a->size_in_bytes()); + NOT_PRODUCT(Atomic::inc(&_instance_count);) } + Arena *Arena::move_contents(Arena *copy) { copy->destruct_contents(); copy->_chunk = _chunk; @@ -409,6 +409,42 @@ Arena *Arena::move_contents(Arena *copy) { Arena::~Arena() { destruct_contents(); + NOT_PRODUCT(Atomic::dec(&_instance_count);) +} + +void* Arena::operator new(size_t size) { + assert(false, "Use dynamic memory type binding"); + return NULL; +} + +void* Arena::operator new (size_t size, const std::nothrow_t& nothrow_constant) { + assert(false, "Use dynamic memory type binding"); + return NULL; +} + + // dynamic memory type binding +void* Arena::operator new(size_t size, MEMFLAGS flags) { +#ifdef ASSERT + void* p = (void*)AllocateHeap(size, flags|otArena, CALLER_PC); + if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p); + return p; +#else + return (void *) AllocateHeap(size, flags|otArena, CALLER_PC); +#endif +} + +void* Arena::operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags) { +#ifdef ASSERT + void* p = os::malloc(size, flags|otArena, CALLER_PC); + if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p); + return p; +#else + return os::malloc(size, flags|otArena, CALLER_PC); +#endif +} + +void Arena::operator delete(void* p) { + FreeHeap(p); } // Destroy this arenas contents and reset to empty @@ -421,6 +457,14 @@ void Arena::destruct_contents() { reset(); } +// This is high traffic method, but many calls actually don't +// change the size +void Arena::set_size_in_bytes(size_t size) { + if (_size_in_bytes != size) { + _size_in_bytes = size; + MemTracker::record_arena_size((address)this, size); + } +} // Total of all Chunks in arena size_t Arena::used() const { @@ -448,7 +492,6 @@ void* Arena::grow( size_t x ) { if (_chunk == NULL) { signal_out_of_memory(len * Chunk::aligned_overhead_size(), "Arena::grow"); } - if (k) k->set_next(_chunk); // Append new chunk to end of linked list else _first = _chunk; _hwm = _chunk->bottom(); // Save the cached hwm, max @@ -538,7 +581,7 @@ void* Arena::malloc(size_t size) { assert(UseMallocOnly, "shouldn't call"); // use malloc, but save pointer in res. area for later freeing char** save = (char**)internal_malloc_4(sizeof(char*)); - return (*save = (char*)os::malloc(size)); + return (*save = (char*)os::malloc(size, mtChunk)); } // for debugging with UseMallocOnly diff --git a/hotspot/src/share/vm/memory/allocation.hpp b/hotspot/src/share/vm/memory/allocation.hpp index 4c2f1e8c836..4f0338af983 100644 --- a/hotspot/src/share/vm/memory/allocation.hpp +++ b/hotspot/src/share/vm/memory/allocation.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -40,6 +40,18 @@ #define ARENA_ALIGN_MASK (~((size_t)ARENA_ALIGN_M1)) #define ARENA_ALIGN(x) ((((size_t)(x)) + ARENA_ALIGN_M1) & ARENA_ALIGN_MASK) + +// noinline attribute +#ifdef _WINDOWS + #define _NOINLINE_ __declspec(noinline) +#else + #if __GNUC__ < 3 // gcc 2.x does not support noinline attribute + #define _NOINLINE_ + #else + #define _NOINLINE_ __attribute__ ((noinline)) + #endif +#endif + // All classes in the virtual machine must be subclassed // by one of the following allocation classes: // @@ -98,12 +110,72 @@ class AllocatedObj { }; #endif -class CHeapObj ALLOCATION_SUPER_CLASS_SPEC { + +/* + * MemoryType bitmap layout: + * | 16 15 14 13 12 11 10 09 | 08 07 06 05 | 04 03 02 01 | + * | memory type | object | reserved | + * | | type | | + */ +enum MemoryType { + // Memory type by sub systems. It occupies lower byte. + mtNone = 0x0000, // undefined + mtClass = 0x0100, // memory class for Java classes + mtThread = 0x0200, // memory for thread objects + mtThreadStack = 0x0300, + mtCode = 0x0400, // memory for generated code + mtGC = 0x0500, // memory for GC + mtCompiler = 0x0600, // memory for compiler + mtInternal = 0x0700, // memory used by VM, but does not belong to + // any of above categories, and not used for + // native memory tracking + mtOther = 0x0800, // memory not used by VM + mtSymbol = 0x0900, // symbol + mtNMT = 0x0A00, // memory used by native memory tracking + mtChunk = 0x0B00, // chunk that holds content of arenas + mtJavaHeap = 0x0C00, // Java heap + mtDontTrack = 0x0D00, // memory we donot or cannot track + mt_number_of_types = 0x000C, // number of memory types + mt_masks = 0x7F00, + + // object type mask + otArena = 0x0010, // an arena object + otNMTRecorder = 0x0020, // memory recorder object + ot_masks = 0x00F0 +}; + +#define IS_MEMORY_TYPE(flags, type) ((flags & mt_masks) == type) +#define HAS_VALID_MEMORY_TYPE(flags)((flags & mt_masks) != mtNone) +#define FLAGS_TO_MEMORY_TYPE(flags) (flags & mt_masks) + +#define IS_ARENA_OBJ(flags) ((flags & ot_masks) == otArena) +#define IS_NMT_RECORDER(flags) ((flags & ot_masks) == otNMTRecorder) +#define NMT_CAN_TRACK(flags) (!IS_NMT_RECORDER(flags) && !(IS_MEMORY_TYPE(flags, mtDontTrack))) + +typedef unsigned short MEMFLAGS; + +extern bool NMT_track_callsite; + +// debug build does not inline +#if defined(_DEBUG_) + #define CURRENT_PC (NMT_track_callsite ? os::get_caller_pc(1) : 0) + #define CALLER_PC (NMT_track_callsite ? os::get_caller_pc(2) : 0) + #define CALLER_CALLER_PC (NMT_track_callsite ? os::get_caller_pc(3) : 0) +#else + #define CURRENT_PC (NMT_track_callsite? os::get_caller_pc(0) : 0) + #define CALLER_PC (NMT_track_callsite ? os::get_caller_pc(1) : 0) + #define CALLER_CALLER_PC (NMT_track_callsite ? os::get_caller_pc(2) : 0) +#endif + + + +template class CHeapObj ALLOCATION_SUPER_CLASS_SPEC { public: - void* operator new(size_t size); - void* operator new (size_t size, const std::nothrow_t& nothrow_constant); + _NOINLINE_ void* operator new(size_t size, address caller_pc = 0); + _NOINLINE_ void* operator new (size_t size, const std::nothrow_t& nothrow_constant, + address caller_pc = 0); + void operator delete(void* p); - void* new_array(size_t size); }; // Base class for objects allocated on the stack only. @@ -150,7 +222,7 @@ class AllStatic { //------------------------------Chunk------------------------------------------ // Linked list of raw memory chunks -class Chunk: public CHeapObj { +class Chunk: CHeapObj { friend class VMStructs; protected: @@ -197,7 +269,7 @@ class Chunk: public CHeapObj { //------------------------------Arena------------------------------------------ // Fast allocation of memory -class Arena: public CHeapObj { +class Arena : public CHeapObj { protected: friend class ResourceMark; friend class HandleMark; @@ -208,7 +280,8 @@ protected: Chunk *_chunk; // current chunk char *_hwm, *_max; // High water mark and max in current chunk void* grow(size_t x); // Get a new Chunk of at least size x - NOT_PRODUCT(size_t _size_in_bytes;) // Size of arena (used for memory usage tracing) + size_t _size_in_bytes; // Size of arena (used for native memory tracking) + NOT_PRODUCT(static julong _bytes_allocated;) // total #bytes allocated since start friend class AllocStats; debug_only(void* malloc(size_t size);) @@ -231,6 +304,15 @@ protected: void destruct_contents(); char* hwm() const { return _hwm; } + // new operators + void* operator new (size_t size); + void* operator new (size_t size, const std::nothrow_t& nothrow_constant); + + // dynamic memory type tagging + void* operator new(size_t size, MEMFLAGS flags); + void* operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags); + void operator delete(void* p); + // Fast allocate in the arena. Common case is: pointer test + increment. void* Amalloc(size_t x) { assert(is_power_of_2(ARENA_AMALLOC_ALIGNMENT) , "should be a power of 2"); @@ -306,16 +388,20 @@ protected: size_t used() const; // Total # of bytes used - size_t size_in_bytes() const NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0; - void set_size_in_bytes(size_t size) NOT_PRODUCT({ _size_in_bytes = size; }) PRODUCT_RETURN; + size_t size_in_bytes() const { return _size_in_bytes; }; + void set_size_in_bytes(size_t size); + static void free_malloced_objects(Chunk* chunk, char* hwm, char* max, char* hwm2) PRODUCT_RETURN; static void free_all(char** start, char** end) PRODUCT_RETURN; + // how many arena instances + NOT_PRODUCT(static volatile jint _instance_count;) private: // Reset this Arena to empty, access will trigger grow if necessary void reset(void) { _first = _chunk = NULL; _hwm = _max = NULL; + set_size_in_bytes(0); } }; @@ -373,7 +459,7 @@ class ResourceObj ALLOCATION_SUPER_CLASS_SPEC { #endif // ASSERT public: - void* operator new(size_t size, allocation_type type); + void* operator new(size_t size, allocation_type type, MEMFLAGS flags); void* operator new(size_t size, Arena *arena) { address res = (address)arena->Amalloc(size); DEBUG_ONLY(set_allocation_type(res, ARENA);) @@ -409,17 +495,28 @@ class ResourceObj ALLOCATION_SUPER_CLASS_SPEC { #define NEW_RESOURCE_OBJ(type)\ NEW_RESOURCE_ARRAY(type, 1) -#define NEW_C_HEAP_ARRAY(type, size)\ - (type*) (AllocateHeap((size) * sizeof(type), XSTR(type) " in " __FILE__)) +#define NEW_C_HEAP_ARRAY(type, size, memflags)\ + (type*) (AllocateHeap((size) * sizeof(type), memflags)) -#define REALLOC_C_HEAP_ARRAY(type, old, size)\ - (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), XSTR(type) " in " __FILE__)) +#define REALLOC_C_HEAP_ARRAY(type, old, size, memflags)\ + (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags)) -#define FREE_C_HEAP_ARRAY(type,old) \ - FreeHeap((char*)(old)) +#define FREE_C_HEAP_ARRAY(type,old,memflags) \ + FreeHeap((char*)(old), memflags) + +#define NEW_C_HEAP_OBJ(type, memflags)\ + NEW_C_HEAP_ARRAY(type, 1, memflags) + + +#define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\ + (type*) (AllocateHeap((size) * sizeof(type), memflags, pc)) + +#define REALLOC_C_HEAP_ARRAY2(type, old, size, memflags, pc)\ + (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags, pc)) + +#define NEW_C_HEAP_OBJ2(type, memflags, pc)\ + NEW_C_HEAP_ARRAY2(type, 1, memflags, pc) -#define NEW_C_HEAP_OBJ(type)\ - NEW_C_HEAP_ARRAY(type, 1) extern bool warn_new_operator; diff --git a/hotspot/src/share/vm/memory/allocation.inline.hpp b/hotspot/src/share/vm/memory/allocation.inline.hpp index 795016df838..21e8a3bc94e 100644 --- a/hotspot/src/share/vm/memory/allocation.inline.hpp +++ b/hotspot/src/share/vm/memory/allocation.inline.hpp @@ -48,33 +48,60 @@ inline void inc_stat_counter(volatile julong* dest, julong add_value) { #endif // allocate using malloc; will fail if no memory available -inline char* AllocateHeap(size_t size, const char* name = NULL) { - char* p = (char*) os::malloc(size); +inline char* AllocateHeap(size_t size, MEMFLAGS flags, address pc = 0) { + if (pc == 0) { + pc = CURRENT_PC; + } + char* p = (char*) os::malloc(size, flags, pc); #ifdef ASSERT - if (PrintMallocFree) trace_heap_malloc(size, name, p); - #else - Unused_Variable(name); + if (PrintMallocFree) trace_heap_malloc(size, "AllocateHeap", p); #endif - if (p == NULL) vm_exit_out_of_memory(size, name); + if (p == NULL) vm_exit_out_of_memory(size, "AllocateHeap"); return p; } -inline char* ReallocateHeap(char *old, size_t size, const char* name = NULL) { - char* p = (char*) os::realloc(old,size); +inline char* ReallocateHeap(char *old, size_t size, MEMFLAGS flags) { + char* p = (char*) os::realloc(old, size, flags, CURRENT_PC); #ifdef ASSERT - if (PrintMallocFree) trace_heap_malloc(size, name, p); - #else - Unused_Variable(name); + if (PrintMallocFree) trace_heap_malloc(size, "ReallocateHeap", p); #endif - if (p == NULL) vm_exit_out_of_memory(size, name); + if (p == NULL) vm_exit_out_of_memory(size, "ReallocateHeap"); return p; } -inline void FreeHeap(void* p) { +inline void FreeHeap(void* p, MEMFLAGS memflags = mtInternal) { #ifdef ASSERT if (PrintMallocFree) trace_heap_free(p); #endif - os::free(p); + os::free(p, memflags); } + +template void* CHeapObj::operator new(size_t size, + address caller_pc){ +#ifdef ASSERT + void* p = (void*)AllocateHeap(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC)); + if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p); + return p; +#else + return (void *) AllocateHeap(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC)); +#endif + } + +template void* CHeapObj::operator new (size_t size, + const std::nothrow_t& nothrow_constant, address caller_pc) { +#ifdef ASSERT + void* p = os::malloc(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC)); + if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p); + return p; +#else + return os::malloc(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC)); +#endif +} + +template void CHeapObj::operator delete(void* p){ + FreeHeap(p, F); +} + + #endif // SHARE_VM_MEMORY_ALLOCATION_INLINE_HPP diff --git a/hotspot/src/share/vm/memory/barrierSet.hpp b/hotspot/src/share/vm/memory/barrierSet.hpp index d9cf3c29394..bd92616f802 100644 --- a/hotspot/src/share/vm/memory/barrierSet.hpp +++ b/hotspot/src/share/vm/memory/barrierSet.hpp @@ -31,7 +31,7 @@ // This class provides the interface between a barrier implementation and // the rest of the system. -class BarrierSet: public CHeapObj { +class BarrierSet: public CHeapObj { friend class VMStructs; public: enum Name { diff --git a/hotspot/src/share/vm/memory/blockOffsetTable.cpp b/hotspot/src/share/vm/memory/blockOffsetTable.cpp index d40965ea813..0d607db803b 100644 --- a/hotspot/src/share/vm/memory/blockOffsetTable.cpp +++ b/hotspot/src/share/vm/memory/blockOffsetTable.cpp @@ -30,6 +30,7 @@ #include "memory/universe.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" +#include "services/memTracker.hpp" ////////////////////////////////////////////////////////////////////// // BlockOffsetSharedArray @@ -44,6 +45,9 @@ BlockOffsetSharedArray::BlockOffsetSharedArray(MemRegion reserved, if (!rs.is_reserved()) { vm_exit_during_initialization("Could not reserve enough space for heap offset array"); } + + MemTracker::record_virtual_memory_type((address)rs.base(), mtGC); + if (!_vs.initialize(rs, 0)) { vm_exit_during_initialization("Could not reserve enough space for heap offset array"); } diff --git a/hotspot/src/share/vm/memory/blockOffsetTable.hpp b/hotspot/src/share/vm/memory/blockOffsetTable.hpp index 16f329bddcf..b31865c93aa 100644 --- a/hotspot/src/share/vm/memory/blockOffsetTable.hpp +++ b/hotspot/src/share/vm/memory/blockOffsetTable.hpp @@ -100,7 +100,7 @@ public: ////////////////////////////////////////////////////////////////////////// // BlockOffsetSharedArray ////////////////////////////////////////////////////////////////////////// -class BlockOffsetSharedArray: public CHeapObj { +class BlockOffsetSharedArray: public CHeapObj { friend class BlockOffsetArray; friend class BlockOffsetArrayNonContigSpace; friend class BlockOffsetArrayContigSpace; diff --git a/hotspot/src/share/vm/memory/cardTableModRefBS.cpp b/hotspot/src/share/vm/memory/cardTableModRefBS.cpp index acf6413c411..496b2cbbf7d 100644 --- a/hotspot/src/share/vm/memory/cardTableModRefBS.cpp +++ b/hotspot/src/share/vm/memory/cardTableModRefBS.cpp @@ -33,6 +33,7 @@ #include "runtime/java.hpp" #include "runtime/mutexLocker.hpp" #include "runtime/virtualspace.hpp" +#include "services/memTracker.hpp" #ifdef COMPILER1 #include "c1/c1_LIR.hpp" #include "c1/c1_LIRGenerator.hpp" @@ -90,6 +91,9 @@ CardTableModRefBS::CardTableModRefBS(MemRegion whole_heap, const size_t rs_align = _page_size == (size_t) os::vm_page_size() ? 0 : MAX2(_page_size, (size_t) os::vm_allocation_granularity()); ReservedSpace heap_rs(_byte_map_size, rs_align, false); + + MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtGC); + os::trace_page_sizes("card table", _guard_index + 1, _guard_index + 1, _page_size, heap_rs.base(), heap_rs.size()); if (!heap_rs.is_reserved()) { @@ -113,16 +117,17 @@ CardTableModRefBS::CardTableModRefBS(MemRegion whole_heap, // Do better than this for Merlin vm_exit_out_of_memory(_page_size, "card table last card"); } + *guard_card = last_card; _lowest_non_clean = - NEW_C_HEAP_ARRAY(CardArr, max_covered_regions); + NEW_C_HEAP_ARRAY(CardArr, max_covered_regions, mtGC); _lowest_non_clean_chunk_size = - NEW_C_HEAP_ARRAY(size_t, max_covered_regions); + NEW_C_HEAP_ARRAY(size_t, max_covered_regions, mtGC); _lowest_non_clean_base_chunk_index = - NEW_C_HEAP_ARRAY(uintptr_t, max_covered_regions); + NEW_C_HEAP_ARRAY(uintptr_t, max_covered_regions, mtGC); _last_LNC_resizing_collection = - NEW_C_HEAP_ARRAY(int, max_covered_regions); + NEW_C_HEAP_ARRAY(int, max_covered_regions, mtGC); if (_lowest_non_clean == NULL || _lowest_non_clean_chunk_size == NULL || _lowest_non_clean_base_chunk_index == NULL diff --git a/hotspot/src/share/vm/memory/collectorPolicy.hpp b/hotspot/src/share/vm/memory/collectorPolicy.hpp index 7030eb7b58f..9b6b2d47c29 100644 --- a/hotspot/src/share/vm/memory/collectorPolicy.hpp +++ b/hotspot/src/share/vm/memory/collectorPolicy.hpp @@ -56,7 +56,7 @@ class GCPolicyCounters; class PermanentGenerationSpec; class MarkSweepPolicy; -class CollectorPolicy : public CHeapObj { +class CollectorPolicy : public CHeapObj { protected: PermanentGenerationSpec *_permanent_generation; GCPolicyCounters* _gc_policy_counters; diff --git a/hotspot/src/share/vm/memory/defNewGeneration.hpp b/hotspot/src/share/vm/memory/defNewGeneration.hpp index 1d5a4859041..4f959d674af 100644 --- a/hotspot/src/share/vm/memory/defNewGeneration.hpp +++ b/hotspot/src/share/vm/memory/defNewGeneration.hpp @@ -89,8 +89,8 @@ protected: // Together, these keep pairs. // They should always contain the same number of elements. - Stack _objs_with_preserved_marks; - Stack _preserved_marks_of_objs; + Stack _objs_with_preserved_marks; + Stack _preserved_marks_of_objs; // Promotion failure handling OopClosure *_promo_failure_scan_stack_closure; @@ -98,7 +98,7 @@ protected: _promo_failure_scan_stack_closure = scan_stack_closure; } - Stack _promo_failure_scan_stack; + Stack _promo_failure_scan_stack; void drain_promo_failure_scan_stack(void); bool _promo_failure_drain_in_progress; diff --git a/hotspot/src/share/vm/memory/filemap.hpp b/hotspot/src/share/vm/memory/filemap.hpp index 8d239b8413e..5c03ae38874 100644 --- a/hotspot/src/share/vm/memory/filemap.hpp +++ b/hotspot/src/share/vm/memory/filemap.hpp @@ -44,7 +44,7 @@ static const int JVM_ARCH_MAX = 12; -class FileMapInfo : public CHeapObj { +class FileMapInfo : public CHeapObj { private: enum { _invalid_version = -1, diff --git a/hotspot/src/share/vm/memory/freeBlockDictionary.hpp b/hotspot/src/share/vm/memory/freeBlockDictionary.hpp index 9e3e20a7794..66ce2be57f3 100644 --- a/hotspot/src/share/vm/memory/freeBlockDictionary.hpp +++ b/hotspot/src/share/vm/memory/freeBlockDictionary.hpp @@ -34,7 +34,7 @@ // A FreeBlockDictionary is an abstract superclass that will allow // a number of alternative implementations in the future. template -class FreeBlockDictionary: public CHeapObj { +class FreeBlockDictionary: public CHeapObj { public: enum Dither { atLeast, diff --git a/hotspot/src/share/vm/memory/genMarkSweep.cpp b/hotspot/src/share/vm/memory/genMarkSweep.cpp index 4d13fbb22dd..e7097db9dcf 100644 --- a/hotspot/src/share/vm/memory/genMarkSweep.cpp +++ b/hotspot/src/share/vm/memory/genMarkSweep.cpp @@ -203,21 +203,21 @@ void GenMarkSweep::allocate_stacks() { #ifdef VALIDATE_MARK_SWEEP if (ValidateMarkSweep) { - _root_refs_stack = new (ResourceObj::C_HEAP) GrowableArray(100, true); - _other_refs_stack = new (ResourceObj::C_HEAP) GrowableArray(100, true); - _adjusted_pointers = new (ResourceObj::C_HEAP) GrowableArray(100, true); - _live_oops = new (ResourceObj::C_HEAP) GrowableArray(100, true); - _live_oops_moved_to = new (ResourceObj::C_HEAP) GrowableArray(100, true); - _live_oops_size = new (ResourceObj::C_HEAP) GrowableArray(100, true); + _root_refs_stack = new (ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _other_refs_stack = new (ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _adjusted_pointers = new (ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _live_oops = new (ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _live_oops_moved_to = new (ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _live_oops_size = new (ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); } if (RecordMarkSweepCompaction) { if (_cur_gc_live_oops == NULL) { - _cur_gc_live_oops = new(ResourceObj::C_HEAP) GrowableArray(100, true); - _cur_gc_live_oops_moved_to = new(ResourceObj::C_HEAP) GrowableArray(100, true); - _cur_gc_live_oops_size = new(ResourceObj::C_HEAP) GrowableArray(100, true); - _last_gc_live_oops = new(ResourceObj::C_HEAP) GrowableArray(100, true); - _last_gc_live_oops_moved_to = new(ResourceObj::C_HEAP) GrowableArray(100, true); - _last_gc_live_oops_size = new(ResourceObj::C_HEAP) GrowableArray(100, true); + _cur_gc_live_oops = new(ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _cur_gc_live_oops_moved_to = new(ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _cur_gc_live_oops_size = new(ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _last_gc_live_oops = new(ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _last_gc_live_oops_moved_to = new(ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); + _last_gc_live_oops_size = new(ResourceObj::C_HEAP, mtGC) GrowableArray(100, true); } else { _cur_gc_live_oops->clear(); _cur_gc_live_oops_moved_to->clear(); diff --git a/hotspot/src/share/vm/memory/genOopClosures.hpp b/hotspot/src/share/vm/memory/genOopClosures.hpp index 2c9b5ad0d0b..ded9c6262a2 100644 --- a/hotspot/src/share/vm/memory/genOopClosures.hpp +++ b/hotspot/src/share/vm/memory/genOopClosures.hpp @@ -34,10 +34,10 @@ class CardTableRS; class CardTableModRefBS; class DefNewGeneration; -template class GenericTaskQueue; -typedef GenericTaskQueue OopTaskQueue; -template class GenericTaskQueueSet; -typedef GenericTaskQueueSet OopTaskQueueSet; +template class GenericTaskQueue; +typedef GenericTaskQueue OopTaskQueue; +template class GenericTaskQueueSet; +typedef GenericTaskQueueSet OopTaskQueueSet; // Closure for iterating roots from a particular generation // Note: all classes deriving from this MUST call this do_barrier diff --git a/hotspot/src/share/vm/memory/genRemSet.hpp b/hotspot/src/share/vm/memory/genRemSet.hpp index bf0535f83db..9306d452543 100644 --- a/hotspot/src/share/vm/memory/genRemSet.hpp +++ b/hotspot/src/share/vm/memory/genRemSet.hpp @@ -35,7 +35,7 @@ class BarrierSet; class OopsInGenClosure; class CardTableRS; -class GenRemSet: public CHeapObj { +class GenRemSet: public CHeapObj { friend class Generation; BarrierSet* _bs; diff --git a/hotspot/src/share/vm/memory/generation.hpp b/hotspot/src/share/vm/memory/generation.hpp index 5c62e8bf2de..96becb638b6 100644 --- a/hotspot/src/share/vm/memory/generation.hpp +++ b/hotspot/src/share/vm/memory/generation.hpp @@ -86,7 +86,7 @@ struct ScratchBlock { }; -class Generation: public CHeapObj { +class Generation: public CHeapObj { friend class VMStructs; private: jlong _time_of_last_gc; // time when last gc on this generation happened (ms) diff --git a/hotspot/src/share/vm/memory/generationSpec.hpp b/hotspot/src/share/vm/memory/generationSpec.hpp index 5aff302b9c9..e602ef7976c 100644 --- a/hotspot/src/share/vm/memory/generationSpec.hpp +++ b/hotspot/src/share/vm/memory/generationSpec.hpp @@ -32,7 +32,7 @@ // some generation-specific behavior. This is done here rather than as a // virtual function of Generation because these methods are needed in // initialization of the Generations. -class GenerationSpec : public CHeapObj { +class GenerationSpec : public CHeapObj { friend class VMStructs; private: Generation::Name _name; @@ -71,7 +71,7 @@ typedef GenerationSpec* GenerationSpecPtr; // The specification of a permanent generation. This class is very // similar to GenerationSpec in use. Due to PermGen's not being a // true Generation, we cannot combine the spec classes either. -class PermanentGenerationSpec : public CHeapObj { +class PermanentGenerationSpec : public CHeapObj { friend class VMStructs; private: PermGen::Name _name; diff --git a/hotspot/src/share/vm/memory/heap.cpp b/hotspot/src/share/vm/memory/heap.cpp index dcf1e41e0e4..95c99082cad 100644 --- a/hotspot/src/share/vm/memory/heap.cpp +++ b/hotspot/src/share/vm/memory/heap.cpp @@ -26,7 +26,7 @@ #include "memory/heap.hpp" #include "oops/oop.inline.hpp" #include "runtime/os.hpp" - +#include "services/memTracker.hpp" size_t CodeHeap::header_size() { return sizeof(HeapBlock); @@ -130,6 +130,9 @@ bool CodeHeap::reserve(size_t reserved_size, size_t committed_size, if (!_segmap.initialize(align_to_page_size(_number_of_reserved_segments), align_to_page_size(_number_of_committed_segments))) { return false; } + + MemTracker::record_virtual_memory_type((address)_segmap.low_boundary(), mtCode); + assert(_segmap.committed_size() >= (size_t) _number_of_committed_segments, "could not commit enough space for segment map"); assert(_segmap.reserved_size() >= (size_t) _number_of_reserved_segments , "could not reserve enough space for segment map"); assert(_segmap.reserved_size() >= _segmap.committed_size() , "just checking"); diff --git a/hotspot/src/share/vm/memory/heap.hpp b/hotspot/src/share/vm/memory/heap.hpp index 4f592a20ce2..74f68ae054a 100644 --- a/hotspot/src/share/vm/memory/heap.hpp +++ b/hotspot/src/share/vm/memory/heap.hpp @@ -77,7 +77,7 @@ class FreeBlock: public HeapBlock { void set_link(FreeBlock* link) { _link = link; } }; -class CodeHeap : public CHeapObj { +class CodeHeap : public CHeapObj { friend class VMStructs; private: VirtualSpace _memory; // the memory holding the blocks diff --git a/hotspot/src/share/vm/memory/heapInspection.cpp b/hotspot/src/share/vm/memory/heapInspection.cpp index 1042ff43b94..998a1ecc56c 100644 --- a/hotspot/src/share/vm/memory/heapInspection.cpp +++ b/hotspot/src/share/vm/memory/heapInspection.cpp @@ -116,7 +116,7 @@ void KlassInfoBucket::empty() { KlassInfoTable::KlassInfoTable(int size, HeapWord* ref) { _size = 0; _ref = ref; - _buckets = NEW_C_HEAP_ARRAY(KlassInfoBucket, size); + _buckets = NEW_C_HEAP_ARRAY(KlassInfoBucket, size, mtInternal); if (_buckets != NULL) { _size = size; for (int index = 0; index < _size; index++) { @@ -130,7 +130,7 @@ KlassInfoTable::~KlassInfoTable() { for (int index = 0; index < _size; index++) { _buckets[index].empty(); } - FREE_C_HEAP_ARRAY(KlassInfoBucket, _buckets); + FREE_C_HEAP_ARRAY(KlassInfoBucket, _buckets, mtInternal); _size = 0; } } @@ -179,7 +179,7 @@ int KlassInfoHisto::sort_helper(KlassInfoEntry** e1, KlassInfoEntry** e2) { KlassInfoHisto::KlassInfoHisto(const char* title, int estimatedCount) : _title(title) { - _elements = new (ResourceObj::C_HEAP) GrowableArray(estimatedCount,true); + _elements = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(estimatedCount,true); } KlassInfoHisto::~KlassInfoHisto() { diff --git a/hotspot/src/share/vm/memory/heapInspection.hpp b/hotspot/src/share/vm/memory/heapInspection.hpp index 6d2f544b461..779ff072557 100644 --- a/hotspot/src/share/vm/memory/heapInspection.hpp +++ b/hotspot/src/share/vm/memory/heapInspection.hpp @@ -44,7 +44,7 @@ // to KlassInfoEntry's and is used to sort // the entries. -class KlassInfoEntry: public CHeapObj { +class KlassInfoEntry: public CHeapObj { private: KlassInfoEntry* _next; klassOop _klass; @@ -72,7 +72,7 @@ class KlassInfoClosure: public StackObj { virtual void do_cinfo(KlassInfoEntry* cie) = 0; }; -class KlassInfoBucket: public CHeapObj { +class KlassInfoBucket: public CHeapObj { private: KlassInfoEntry* _list; KlassInfoEntry* list() { return _list; } diff --git a/hotspot/src/share/vm/memory/memRegion.hpp b/hotspot/src/share/vm/memory/memRegion.hpp index 4ed33d7312b..e8de140c654 100644 --- a/hotspot/src/share/vm/memory/memRegion.hpp +++ b/hotspot/src/share/vm/memory/memRegion.hpp @@ -99,8 +99,8 @@ public: class MemRegionClosureRO: public MemRegionClosure { public: - void* operator new(size_t size, ResourceObj::allocation_type type) { - return ResourceObj::operator new(size, type); + void* operator new(size_t size, ResourceObj::allocation_type type, MEMFLAGS flags) { + return ResourceObj::operator new(size, type, flags); } void* operator new(size_t size, Arena *arena) { return ResourceObj::operator new(size, arena); diff --git a/hotspot/src/share/vm/memory/permGen.hpp b/hotspot/src/share/vm/memory/permGen.hpp index 7400ed65f46..a6e2c8a6f0a 100644 --- a/hotspot/src/share/vm/memory/permGen.hpp +++ b/hotspot/src/share/vm/memory/permGen.hpp @@ -42,7 +42,7 @@ class CSpaceCounters; // PermGen models the part of the heap used to allocate class meta-data. -class PermGen : public CHeapObj { +class PermGen : public CHeapObj { friend class VMStructs; protected: size_t _capacity_expansion_limit; // maximum expansion allowed without a diff --git a/hotspot/src/share/vm/memory/referencePolicy.hpp b/hotspot/src/share/vm/memory/referencePolicy.hpp index 6616f253c19..99015d01aff 100644 --- a/hotspot/src/share/vm/memory/referencePolicy.hpp +++ b/hotspot/src/share/vm/memory/referencePolicy.hpp @@ -29,7 +29,7 @@ // should be cleared. -class ReferencePolicy : public CHeapObj { +class ReferencePolicy : public CHeapObj { public: virtual bool should_clear_reference(oop p, jlong timestamp_clock) { ShouldNotReachHere(); diff --git a/hotspot/src/share/vm/memory/referenceProcessor.cpp b/hotspot/src/share/vm/memory/referenceProcessor.cpp index 2699ecd0f5d..f103dc97944 100644 --- a/hotspot/src/share/vm/memory/referenceProcessor.cpp +++ b/hotspot/src/share/vm/memory/referenceProcessor.cpp @@ -108,7 +108,8 @@ ReferenceProcessor::ReferenceProcessor(MemRegion span, _num_q = MAX2(1U, mt_processing_degree); _max_num_q = MAX2(_num_q, mt_discovery_degree); _discovered_refs = NEW_C_HEAP_ARRAY(DiscoveredList, - _max_num_q * number_of_subclasses_of_ref()); + _max_num_q * number_of_subclasses_of_ref(), mtGC); + if (_discovered_refs == NULL) { vm_exit_during_initialization("Could not allocated RefProc Array"); } diff --git a/hotspot/src/share/vm/memory/referenceProcessor.hpp b/hotspot/src/share/vm/memory/referenceProcessor.hpp index bfa3bdffa9e..9df15bd4d3d 100644 --- a/hotspot/src/share/vm/memory/referenceProcessor.hpp +++ b/hotspot/src/share/vm/memory/referenceProcessor.hpp @@ -203,7 +203,7 @@ public: } }; -class ReferenceProcessor : public CHeapObj { +class ReferenceProcessor : public CHeapObj { protected: // Compatibility with pre-4965777 JDK's static bool _pending_list_uses_discovered_field; diff --git a/hotspot/src/share/vm/memory/resourceArea.hpp b/hotspot/src/share/vm/memory/resourceArea.hpp index 3d312489769..567f41d400a 100644 --- a/hotspot/src/share/vm/memory/resourceArea.hpp +++ b/hotspot/src/share/vm/memory/resourceArea.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,7 +75,7 @@ public: if (UseMallocOnly) { // use malloc, but save pointer in res. area for later freeing char** save = (char**)internal_malloc_4(sizeof(char*)); - return (*save = (char*)os::malloc(size)); + return (*save = (char*)os::malloc(size, mtThread)); } #endif return (char*)Amalloc(size); @@ -93,18 +93,17 @@ protected: ResourceArea *_area; // Resource area to stack allocate Chunk *_chunk; // saved arena chunk char *_hwm, *_max; - NOT_PRODUCT(size_t _size_in_bytes;) + size_t _size_in_bytes; void initialize(Thread *thread) { _area = thread->resource_area(); _chunk = _area->_chunk; _hwm = _area->_hwm; _max= _area->_max; - NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();) + _size_in_bytes = _area->size_in_bytes(); debug_only(_area->_nesting++;) assert( _area->_nesting > 0, "must stack allocate RMs" ); } - public: #ifndef ASSERT @@ -120,7 +119,7 @@ protected: ResourceMark( ResourceArea *r ) : _area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) { - NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();) + _size_in_bytes = r->_size_in_bytes; debug_only(_area->_nesting++;) assert( _area->_nesting > 0, "must stack allocate RMs" ); } @@ -148,7 +147,7 @@ protected: private: void free_malloced_objects() PRODUCT_RETURN; - size_t size_in_bytes() NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0; + size_t size_in_bytes() { return _size_in_bytes; } }; //------------------------------DeoptResourceMark----------------------------------- @@ -180,19 +179,19 @@ protected: // and they would be stack allocated. This leaves open the possibilty of accidental // misuse so we simple duplicate the ResourceMark functionality here. -class DeoptResourceMark: public CHeapObj { +class DeoptResourceMark: public CHeapObj { protected: ResourceArea *_area; // Resource area to stack allocate Chunk *_chunk; // saved arena chunk char *_hwm, *_max; - NOT_PRODUCT(size_t _size_in_bytes;) + size_t _size_in_bytes; void initialize(Thread *thread) { _area = thread->resource_area(); _chunk = _area->_chunk; _hwm = _area->_hwm; _max= _area->_max; - NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();) + _size_in_bytes = _area->size_in_bytes(); debug_only(_area->_nesting++;) assert( _area->_nesting > 0, "must stack allocate RMs" ); } @@ -212,7 +211,7 @@ protected: DeoptResourceMark( ResourceArea *r ) : _area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) { - NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();) + _size_in_bytes = _area->size_in_bytes(); debug_only(_area->_nesting++;) assert( _area->_nesting > 0, "must stack allocate RMs" ); } @@ -240,7 +239,7 @@ protected: private: void free_malloced_objects() PRODUCT_RETURN; - size_t size_in_bytes() NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0; + size_t size_in_bytes() { return _size_in_bytes; }; }; #endif // SHARE_VM_MEMORY_RESOURCEAREA_HPP diff --git a/hotspot/src/share/vm/memory/restore.cpp b/hotspot/src/share/vm/memory/restore.cpp index 263867e6fff..e2f8b6a6dce 100644 --- a/hotspot/src/share/vm/memory/restore.cpp +++ b/hotspot/src/share/vm/memory/restore.cpp @@ -132,7 +132,7 @@ void CompactingPermGenGen::initialize_oops() { buffer += sizeof(intptr_t); int number_of_entries = *(intptr_t*)buffer; buffer += sizeof(intptr_t); - SymbolTable::create_table((HashtableBucket*)buffer, symbolTableLen, + SymbolTable::create_table((HashtableBucket*)buffer, symbolTableLen, number_of_entries); buffer += symbolTableLen; @@ -144,7 +144,7 @@ void CompactingPermGenGen::initialize_oops() { buffer += sizeof(intptr_t); number_of_entries = *(intptr_t*)buffer; buffer += sizeof(intptr_t); - StringTable::create_table((HashtableBucket*)buffer, stringTableLen, + StringTable::create_table((HashtableBucket*)buffer, stringTableLen, number_of_entries); buffer += stringTableLen; @@ -157,7 +157,7 @@ void CompactingPermGenGen::initialize_oops() { buffer += sizeof(intptr_t); number_of_entries = *(intptr_t*)buffer; buffer += sizeof(intptr_t); - SystemDictionary::set_shared_dictionary((HashtableBucket*)buffer, + SystemDictionary::set_shared_dictionary((HashtableBucket*)buffer, sharedDictionaryLen, number_of_entries); buffer += sharedDictionaryLen; @@ -171,7 +171,7 @@ void CompactingPermGenGen::initialize_oops() { buffer += sizeof(intptr_t); number_of_entries = *(intptr_t*)buffer; buffer += sizeof(intptr_t); - ClassLoader::create_package_info_table((HashtableBucket*)buffer, pkgInfoLen, + ClassLoader::create_package_info_table((HashtableBucket*)buffer, pkgInfoLen, number_of_entries); buffer += pkgInfoLen; ClassLoader::verify(); diff --git a/hotspot/src/share/vm/memory/space.hpp b/hotspot/src/share/vm/memory/space.hpp index f81c293a4bf..ef2f2c6e559 100644 --- a/hotspot/src/share/vm/memory/space.hpp +++ b/hotspot/src/share/vm/memory/space.hpp @@ -105,7 +105,7 @@ class SpaceMemRegionOopsIterClosure: public OopClosure { // bottom() <= top() <= end() // top() is inclusive and end() is exclusive. -class Space: public CHeapObj { +class Space: public CHeapObj { friend class VMStructs; protected: HeapWord* _bottom; diff --git a/hotspot/src/share/vm/memory/tenuredGeneration.cpp b/hotspot/src/share/vm/memory/tenuredGeneration.cpp index b88f315ed16..50b2615baea 100644 --- a/hotspot/src/share/vm/memory/tenuredGeneration.cpp +++ b/hotspot/src/share/vm/memory/tenuredGeneration.cpp @@ -65,7 +65,7 @@ TenuredGeneration::TenuredGeneration(ReservedSpace rs, if (UseParNewGC && ParallelGCThreads > 0) { typedef ParGCAllocBufferWithBOT* ParGCAllocBufferWithBOTPtr; _alloc_buffers = NEW_C_HEAP_ARRAY(ParGCAllocBufferWithBOTPtr, - ParallelGCThreads); + ParallelGCThreads, mtGC); if (_alloc_buffers == NULL) vm_exit_during_initialization("Could not allocate alloc_buffers"); for (uint i = 0; i < ParallelGCThreads; i++) { diff --git a/hotspot/src/share/vm/memory/threadLocalAllocBuffer.hpp b/hotspot/src/share/vm/memory/threadLocalAllocBuffer.hpp index 1b8bb0a3ca7..c85a59de14e 100644 --- a/hotspot/src/share/vm/memory/threadLocalAllocBuffer.hpp +++ b/hotspot/src/share/vm/memory/threadLocalAllocBuffer.hpp @@ -36,7 +36,7 @@ class GlobalTLABStats; // It is thread-private at any time, but maybe multiplexed over // time across multiple threads. The park()/unpark() pair is // used to make it avaiable for such multiplexing. -class ThreadLocalAllocBuffer: public CHeapObj { +class ThreadLocalAllocBuffer: public CHeapObj { friend class VMStructs; private: HeapWord* _start; // address of TLAB @@ -172,7 +172,7 @@ public: void verify(); }; -class GlobalTLABStats: public CHeapObj { +class GlobalTLABStats: public CHeapObj { private: // Accumulate perfdata in private variables because diff --git a/hotspot/src/share/vm/memory/universe.cpp b/hotspot/src/share/vm/memory/universe.cpp index 9282828a7e9..4ed723afa57 100644 --- a/hotspot/src/share/vm/memory/universe.cpp +++ b/hotspot/src/share/vm/memory/universe.cpp @@ -764,7 +764,7 @@ jint universe_init() { FileMapInfo* mapinfo = NULL; if (UseSharedSpaces) { - mapinfo = NEW_C_HEAP_OBJ(FileMapInfo); + mapinfo = NEW_C_HEAP_OBJ(FileMapInfo, mtInternal); memset(mapinfo, 0, sizeof(FileMapInfo)); // Open the shared archive file, read and validate the header. If @@ -1546,7 +1546,7 @@ void ActiveMethodOopsCache::add_previous_version(const methodOop method) { // This is the first previous version so make some space. // Start with 2 elements under the assumption that the class // won't be redefined much. - _prev_methods = new (ResourceObj::C_HEAP) GrowableArray(2, true); + _prev_methods = new (ResourceObj::C_HEAP, mtClass) GrowableArray(2, true); } // RC_TRACE macro has an embedded ResourceMark diff --git a/hotspot/src/share/vm/memory/universe.hpp b/hotspot/src/share/vm/memory/universe.hpp index 073a5c2ca75..6f268b3f10b 100644 --- a/hotspot/src/share/vm/memory/universe.hpp +++ b/hotspot/src/share/vm/memory/universe.hpp @@ -43,7 +43,7 @@ class DeferredObjAllocEvent; // Common parts of a methodOop cache. This cache safely interacts with // the RedefineClasses API. // -class CommonMethodOopCache : public CHeapObj { +class CommonMethodOopCache : public CHeapObj { // We save the klassOop and the idnum of methodOop in order to get // the current cached methodOop. private: @@ -455,7 +455,7 @@ class Universe: AllStatic { static int base_vtable_size() { return _base_vtable_size; } }; -class DeferredObjAllocEvent : public CHeapObj { +class DeferredObjAllocEvent : public CHeapObj { private: oop _oop; size_t _bytesize; diff --git a/hotspot/src/share/vm/oops/constantPoolOop.hpp b/hotspot/src/share/vm/oops/constantPoolOop.hpp index c2f985d7750..a2c046859df 100644 --- a/hotspot/src/share/vm/oops/constantPoolOop.hpp +++ b/hotspot/src/share/vm/oops/constantPoolOop.hpp @@ -764,7 +764,7 @@ class constantPoolOopDesc : public oopDesc { unsigned char *bytes); }; -class SymbolHashMapEntry : public CHeapObj { +class SymbolHashMapEntry : public CHeapObj { private: unsigned int _hash; // 32-bit hash for item SymbolHashMapEntry* _next; // Next element in the linked list for this bucket @@ -790,7 +790,7 @@ class SymbolHashMapEntry : public CHeapObj { }; // End SymbolHashMapEntry class -class SymbolHashMapBucket : public CHeapObj { +class SymbolHashMapBucket : public CHeapObj { private: SymbolHashMapEntry* _entry; @@ -803,7 +803,7 @@ public: }; // End SymbolHashMapBucket class -class SymbolHashMap: public CHeapObj { +class SymbolHashMap: public CHeapObj { private: // Default number of entries in the table @@ -816,7 +816,7 @@ class SymbolHashMap: public CHeapObj { void initialize_table(int table_size) { _table_size = table_size; - _buckets = NEW_C_HEAP_ARRAY(SymbolHashMapBucket, table_size); + _buckets = NEW_C_HEAP_ARRAY(SymbolHashMapBucket, table_size, mtSymbol); for (int index = 0; index < table_size; index++) { _buckets[index].clear(); } diff --git a/hotspot/src/share/vm/oops/instanceKlass.cpp b/hotspot/src/share/vm/oops/instanceKlass.cpp index 794a7e2809f..b742889b66b 100644 --- a/hotspot/src/share/vm/oops/instanceKlass.cpp +++ b/hotspot/src/share/vm/oops/instanceKlass.cpp @@ -989,7 +989,7 @@ void instanceKlass::do_nonstatic_fields(FieldClosure* cl) { fieldDescriptor fd; int length = java_fields_count(); // In DebugInfo nonstatic fields are sorted by offset. - int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1)); + int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1), mtClass); int j = 0; for (int i = 0; i < length; i += 1) { fd.initialize(as_klassOop(), i); @@ -1009,7 +1009,7 @@ void instanceKlass::do_nonstatic_fields(FieldClosure* cl) { cl->do_field(&fd); } } - FREE_C_HEAP_ARRAY(int, fields_sorted); + FREE_C_HEAP_ARRAY(int, fields_sorted, mtClass); } @@ -1236,7 +1236,7 @@ jmethodID instanceKlass::get_jmethod_id(instanceKlassHandle ik_h, methodHandle m if (length <= idnum) { // allocate a new cache that might be used size_t size = MAX2(idnum+1, (size_t)ik_h->idnum_allocated_count()); - new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1); + new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1, mtClass); memset(new_jmeths, 0, (size+1)*sizeof(jmethodID)); // cache size is stored in element[0], other elements offset by one new_jmeths[0] = (jmethodID)size; @@ -1397,7 +1397,7 @@ void instanceKlass::set_cached_itable_index(size_t idnum, int index) { // cache size is stored in element[0], other elements offset by one if (indices == NULL || (length = (size_t)indices[0]) <= idnum) { size_t size = MAX2(idnum+1, (size_t)idnum_allocated_count()); - int* new_indices = NEW_C_HEAP_ARRAY(int, size+1); + int* new_indices = NEW_C_HEAP_ARRAY(int, size+1, mtClass); new_indices[0] = (int)size; // copy any existing entries size_t i; @@ -1933,7 +1933,7 @@ void instanceKlass::release_C_heap_structures() { // deallocate the cached class file if (_cached_class_file_bytes != NULL) { - os::free(_cached_class_file_bytes); + os::free(_cached_class_file_bytes, mtClass); _cached_class_file_bytes = NULL; _cached_class_file_len = 0; } @@ -2530,7 +2530,7 @@ void instanceKlass::add_previous_version(instanceKlassHandle ikh, // This is the first previous version so make some space. // Start with 2 elements under the assumption that the class // won't be redefined much. - _previous_versions = new (ResourceObj::C_HEAP) + _previous_versions = new (ResourceObj::C_HEAP, mtClass) GrowableArray(2, true); } @@ -2556,7 +2556,7 @@ void instanceKlass::add_previous_version(instanceKlassHandle ikh, ("add: all methods are obsolete; flushing any EMCP weak refs")); } else { int local_count = 0; - GrowableArray* method_refs = new (ResourceObj::C_HEAP) + GrowableArray* method_refs = new (ResourceObj::C_HEAP, mtClass) GrowableArray(emcp_method_count, true); for (int i = 0; i < old_methods->length(); i++) { if (emcp_methods->at(i)) { @@ -2948,7 +2948,7 @@ PreviousVersionInfo* PreviousVersionWalker::next_previous_version() { while (_current_index < length) { PreviousVersionNode * pv_node = _previous_versions->at(_current_index++); - PreviousVersionInfo * pv_info = new (ResourceObj::C_HEAP) + PreviousVersionInfo * pv_info = new (ResourceObj::C_HEAP, mtClass) PreviousVersionInfo(pv_node); constantPoolHandle cp_h = pv_info->prev_constant_pool_handle(); diff --git a/hotspot/src/share/vm/oops/instanceKlass.hpp b/hotspot/src/share/vm/oops/instanceKlass.hpp index 229750bce64..93e804c281e 100644 --- a/hotspot/src/share/vm/oops/instanceKlass.hpp +++ b/hotspot/src/share/vm/oops/instanceKlass.hpp @@ -1008,7 +1008,7 @@ inline u2 instanceKlass::next_method_idnum() { /* JNIid class for jfieldIDs only */ -class JNIid: public CHeapObj { +class JNIid: public CHeapObj { friend class VMStructs; private: klassOop _holder; @@ -1059,7 +1059,7 @@ class BreakpointInfo; // reference must be used because a weak reference would be seen as // collectible. A GrowableArray of PreviousVersionNodes is attached // to the instanceKlass as needed. See PreviousVersionWalker below. -class PreviousVersionNode : public CHeapObj { +class PreviousVersionNode : public CHeapObj { private: // A shared ConstantPool is never collected so we'll always have // a reference to it so we can update items in the cache. We'll @@ -1154,7 +1154,7 @@ class PreviousVersionWalker : public StackObj { // noticed since an nmethod should be removed as many times are it's // added. // -class nmethodBucket: public CHeapObj { +class nmethodBucket: public CHeapObj { friend class VMStructs; private: nmethod* _nmethod; diff --git a/hotspot/src/share/vm/oops/methodOop.hpp b/hotspot/src/share/vm/oops/methodOop.hpp index de10b7c96f0..822a47c9356 100644 --- a/hotspot/src/share/vm/oops/methodOop.hpp +++ b/hotspot/src/share/vm/oops/methodOop.hpp @@ -801,7 +801,7 @@ class CompressedLineNumberReadStream: public CompressedReadStream { // breakpoints are written only at safepoints, and are read // concurrently only outside of safepoints. -class BreakpointInfo : public CHeapObj { +class BreakpointInfo : public CHeapObj { friend class VMStructs; private: Bytecodes::Code _orig_bytecode; diff --git a/hotspot/src/share/vm/oops/symbol.cpp b/hotspot/src/share/vm/oops/symbol.cpp index 8db92d1e2fd..cc52c7adb2d 100644 --- a/hotspot/src/share/vm/oops/symbol.cpp +++ b/hotspot/src/share/vm/oops/symbol.cpp @@ -38,7 +38,7 @@ Symbol::Symbol(const u1* name, int length, int refcount) : _refcount(refcount), void* Symbol::operator new(size_t sz, int len, TRAPS) { int alloc_size = object_size(len)*HeapWordSize; - address res = (address) AllocateHeap(alloc_size, "symbol"); + address res = (address) AllocateHeap(alloc_size, mtSymbol); DEBUG_ONLY(set_allocation_type(res, ResourceObj::C_HEAP);) return res; } diff --git a/hotspot/src/share/vm/opto/idealGraphPrinter.cpp b/hotspot/src/share/vm/opto/idealGraphPrinter.cpp index f9f40a37d7a..3344ce29c8e 100644 --- a/hotspot/src/share/vm/opto/idealGraphPrinter.cpp +++ b/hotspot/src/share/vm/opto/idealGraphPrinter.cpp @@ -130,15 +130,15 @@ IdealGraphPrinter::IdealGraphPrinter() { } else { st.print("%s%d", PrintIdealGraphFile, _file_count); } - fileStream *stream = new (ResourceObj::C_HEAP) fileStream(st.as_string()); + fileStream *stream = new (ResourceObj::C_HEAP, mtCompiler) fileStream(st.as_string()); _output = stream; } else { - fileStream *stream = new (ResourceObj::C_HEAP) fileStream(PrintIdealGraphFile); + fileStream *stream = new (ResourceObj::C_HEAP, mtCompiler) fileStream(PrintIdealGraphFile); _output = stream; } _file_count++; } else { - _stream = new (ResourceObj::C_HEAP) networkStream(); + _stream = new (ResourceObj::C_HEAP, mtCompiler) networkStream(); // Try to connect to visualizer if (_stream->connect(PrintIdealGraphAddress, PrintIdealGraphPort)) { @@ -160,7 +160,7 @@ IdealGraphPrinter::IdealGraphPrinter() { } } - _xml = new (ResourceObj::C_HEAP) xmlStream(_output); + _xml = new (ResourceObj::C_HEAP, mtCompiler) xmlStream(_output); head(TOP_ELEMENT); } diff --git a/hotspot/src/share/vm/opto/macro.cpp b/hotspot/src/share/vm/opto/macro.cpp index b4d54f7e9af..fee17c48a95 100644 --- a/hotspot/src/share/vm/opto/macro.cpp +++ b/hotspot/src/share/vm/opto/macro.cpp @@ -409,7 +409,7 @@ Node *PhaseMacroExpand::value_from_mem_phi(Node *mem, BasicType ft, const Type * Node *alloc_mem = alloc->in(TypeFunc::Memory); uint length = mem->req(); - GrowableArray values(length, length, NULL); + GrowableArray values(length, length, NULL, false); // create a new Phi for the value PhiNode *phi = new (C, length) PhiNode(mem->in(0), phi_type, NULL, instance_id, alias_idx, offset); diff --git a/hotspot/src/share/vm/opto/runtime.hpp b/hotspot/src/share/vm/opto/runtime.hpp index 11b5434a54d..6037d19f2bc 100644 --- a/hotspot/src/share/vm/opto/runtime.hpp +++ b/hotspot/src/share/vm/opto/runtime.hpp @@ -55,7 +55,7 @@ class CallInfo; // code in various ways. Currently they are used by the lock coarsening code // -class NamedCounter : public CHeapObj { +class NamedCounter : public CHeapObj { public: enum CounterTag { NoTag, diff --git a/hotspot/src/share/vm/opto/type.cpp b/hotspot/src/share/vm/opto/type.cpp index af118139e2b..b22473bada9 100644 --- a/hotspot/src/share/vm/opto/type.cpp +++ b/hotspot/src/share/vm/opto/type.cpp @@ -208,7 +208,7 @@ void Type::Initialize_shared(Compile* current) { // locking. Arena* save = current->type_arena(); - Arena* shared_type_arena = new Arena(); + Arena* shared_type_arena = new (mtCompiler)Arena(); current->set_type_arena(shared_type_arena); _shared_type_dict = diff --git a/hotspot/src/share/vm/prims/jni.cpp b/hotspot/src/share/vm/prims/jni.cpp index 166bbd6079d..cf032489568 100644 --- a/hotspot/src/share/vm/prims/jni.cpp +++ b/hotspot/src/share/vm/prims/jni.cpp @@ -33,6 +33,7 @@ #ifndef SERIALGC #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp" #endif // SERIALGC +#include "memory/allocation.hpp" #include "memory/allocation.inline.hpp" #include "memory/gcLocker.inline.hpp" #include "memory/oopFactory.hpp" @@ -3270,7 +3271,7 @@ JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( int s_len = java_lang_String::length(s); typeArrayOop s_value = java_lang_String::value(s); int s_offset = java_lang_String::offset(s); - jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len + 1); // add one for zero termination + jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len + 1, mtInternal); // add one for zero termination if (s_len > 0) { memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len); } @@ -3363,7 +3364,7 @@ JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboole #endif /* USDT2 */ oop java_string = JNIHandles::resolve_non_null(string); size_t length = java_lang_String::utf8_length(java_string); - char* result = AllocateHeap(length + 1, "GetStringUTFChars"); + char* result = AllocateHeap(length + 1, mtInternal); java_lang_String::as_utf8_string(java_string, result, (int) length + 1); if (isCopy != NULL) *isCopy = JNI_TRUE; #ifndef USDT2 @@ -3619,7 +3620,7 @@ JNI_QUICK_ENTRY(ElementType*, \ * Avoid asserts in typeArrayOop. */ \ result = (ElementType*)get_bad_address(); \ } else { \ - result = NEW_C_HEAP_ARRAY(ElementType, len); \ + result = NEW_C_HEAP_ARRAY(ElementType, len, mtInternal); \ /* copy the array to the c chunk */ \ memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \ } \ @@ -3656,7 +3657,7 @@ JNI_QUICK_ENTRY(ElementType*, \ * Avoid asserts in typeArrayOop. */ \ result = (ElementType*)get_bad_address(); \ } else { \ - result = NEW_C_HEAP_ARRAY(ElementType, len); \ + result = NEW_C_HEAP_ARRAY(ElementType, len, mtInternal); \ /* copy the array to the c chunk */ \ memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \ } \ diff --git a/hotspot/src/share/vm/prims/jniCheck.cpp b/hotspot/src/share/vm/prims/jniCheck.cpp index 3bf4ecd1a7f..7e30b58828f 100644 --- a/hotspot/src/share/vm/prims/jniCheck.cpp +++ b/hotspot/src/share/vm/prims/jniCheck.cpp @@ -1308,7 +1308,7 @@ JNI_ENTRY_CHECKED(const jchar *, assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringChars didn't return a copy as expected"); size_t len = UNCHECKED()->GetStringLength(env,str) + 1; // + 1 for NULL termination - jint* tagLocation = (jint*) AllocateHeap(len * sizeof(jchar) + sizeof(jint), "checked_jni_GetStringChars"); + jint* tagLocation = (jint*) AllocateHeap(len * sizeof(jchar) + sizeof(jint), mtInternal); *tagLocation = STRING_TAG; jchar* newResult = (jchar*) (tagLocation + 1); memcpy(newResult, result, len * sizeof(jchar)); @@ -1378,13 +1378,13 @@ JNI_ENTRY_CHECKED(const char *, assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringUTFChars didn't return a copy as expected"); size_t len = strlen(result) + 1; // + 1 for NULL termination - jint* tagLocation = (jint*) AllocateHeap(len + sizeof(jint), "checked_jni_GetStringUTFChars"); + jint* tagLocation = (jint*) AllocateHeap(len + sizeof(jint), mtInternal); *tagLocation = STRING_UTF_TAG; char* newResult = (char*) (tagLocation + 1); strcpy(newResult, result); // Avoiding call to UNCHECKED()->ReleaseStringUTFChars() since that will fire unexpected dtrace probes // Note that the dtrace arguments for the allocated memory will not match up with this solution. - FreeHeap((char*)result); + FreeHeap((char*)result, mtInternal); functionExit(env); return newResult; diff --git a/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.hpp b/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.hpp index 565c6fe8401..64caf38631f 100644 --- a/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.hpp +++ b/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.hpp @@ -68,11 +68,11 @@ class JvmtiConstantPoolReconstituter : public StackObj { ~JvmtiConstantPoolReconstituter() { if (_symmap != NULL) { - os::free(_symmap); + os::free(_symmap, mtClass); _symmap = NULL; } if (_classmap != NULL) { - os::free(_classmap); + os::free(_classmap, mtClass); _classmap = NULL; } } diff --git a/hotspot/src/share/vm/prims/jvmtiCodeBlobEvents.cpp b/hotspot/src/share/vm/prims/jvmtiCodeBlobEvents.cpp index 7f20ec3ae86..3a9a4ea1c55 100644 --- a/hotspot/src/share/vm/prims/jvmtiCodeBlobEvents.cpp +++ b/hotspot/src/share/vm/prims/jvmtiCodeBlobEvents.cpp @@ -157,7 +157,7 @@ void CodeBlobCollector::collect() { assert(_global_code_blobs == NULL, "checking"); // create the global list - _global_code_blobs = new (ResourceObj::C_HEAP) GrowableArray(50,true); + _global_code_blobs = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(50,true); // iterate over the stub code descriptors and put them in the list first. int index = 0; @@ -247,7 +247,7 @@ void JvmtiCodeBlobEvents::build_jvmti_addr_location_map(nmethod *nm, int pcds_in_method; pcds_in_method = (nm->scopes_pcs_end() - nm->scopes_pcs_begin()); - map = NEW_C_HEAP_ARRAY(jvmtiAddrLocationMap, pcds_in_method); + map = NEW_C_HEAP_ARRAY(jvmtiAddrLocationMap, pcds_in_method, mtInternal); address scopes_data = nm->scopes_data_begin(); for( pcd = nm->scopes_pcs_begin(); pcd < nm->scopes_pcs_end(); ++pcd ) { diff --git a/hotspot/src/share/vm/prims/jvmtiEnv.cpp b/hotspot/src/share/vm/prims/jvmtiEnv.cpp index 46519bb5796..637b6a3ce36 100644 --- a/hotspot/src/share/vm/prims/jvmtiEnv.cpp +++ b/hotspot/src/share/vm/prims/jvmtiEnv.cpp @@ -1012,7 +1012,7 @@ JvmtiEnv::GetOwnedMonitorInfo(JavaThread* java_thread, jint* owned_monitor_count // growable array of jvmti monitors info on the C-heap GrowableArray *owned_monitors_list = - new (ResourceObj::C_HEAP) GrowableArray(1, true); + new (ResourceObj::C_HEAP, mtInternal) GrowableArray(1, true); uint32_t debug_bits = 0; if (is_thread_fully_suspended(java_thread, true, &debug_bits)) { @@ -1057,7 +1057,7 @@ JvmtiEnv::GetOwnedMonitorStackDepthInfo(JavaThread* java_thread, jint* monitor_i // growable array of jvmti monitors info on the C-heap GrowableArray *owned_monitors_list = - new (ResourceObj::C_HEAP) GrowableArray(1, true); + new (ResourceObj::C_HEAP, mtInternal) GrowableArray(1, true); uint32_t debug_bits = 0; if (is_thread_fully_suspended(java_thread, true, &debug_bits)) { diff --git a/hotspot/src/share/vm/prims/jvmtiEnvBase.cpp b/hotspot/src/share/vm/prims/jvmtiEnvBase.cpp index fd426422b13..2a6fd143b90 100644 --- a/hotspot/src/share/vm/prims/jvmtiEnvBase.cpp +++ b/hotspot/src/share/vm/prims/jvmtiEnvBase.cpp @@ -381,7 +381,7 @@ JvmtiEnvBase::set_native_method_prefixes(jint prefix_count, char** prefixes) { _native_method_prefixes = NULL; } else { // there are prefixes, allocate an array to hold them, and fill it - char** new_prefixes = (char**)os::malloc((prefix_count) * sizeof(char*)); + char** new_prefixes = (char**)os::malloc((prefix_count) * sizeof(char*), mtInternal); if (new_prefixes == NULL) { return JVMTI_ERROR_OUT_OF_MEMORY; } @@ -1150,7 +1150,7 @@ JvmtiEnvBase::get_object_monitor_usage(JavaThread* calling_thread, jobject objec ResourceTracker::ResourceTracker(JvmtiEnv* env) { _env = env; - _allocations = new (ResourceObj::C_HEAP) GrowableArray(20, true); + _allocations = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(20, true); _failed = false; } ResourceTracker::~ResourceTracker() { diff --git a/hotspot/src/share/vm/prims/jvmtiEnvBase.hpp b/hotspot/src/share/vm/prims/jvmtiEnvBase.hpp index ba0374648e5..29604db13b7 100644 --- a/hotspot/src/share/vm/prims/jvmtiEnvBase.hpp +++ b/hotspot/src/share/vm/prims/jvmtiEnvBase.hpp @@ -52,7 +52,7 @@ class JvmtiTagMap; // done via JNI GetEnv() call. Multiple attachments are // allowed in jvmti. -class JvmtiEnvBase : public CHeapObj { +class JvmtiEnvBase : public CHeapObj { private: @@ -175,7 +175,7 @@ class JvmtiEnvBase : public CHeapObj { if (size == 0) { *mem_ptr = NULL; } else { - *mem_ptr = (unsigned char *)os::malloc((size_t)size); + *mem_ptr = (unsigned char *)os::malloc((size_t)size, mtInternal); if (*mem_ptr == NULL) { return JVMTI_ERROR_OUT_OF_MEMORY; } @@ -185,7 +185,7 @@ class JvmtiEnvBase : public CHeapObj { jvmtiError deallocate(unsigned char* mem) { if (mem != NULL) { - os::free(mem); + os::free(mem, mtInternal); } return JVMTI_ERROR_NONE; } diff --git a/hotspot/src/share/vm/prims/jvmtiEnvThreadState.cpp b/hotspot/src/share/vm/prims/jvmtiEnvThreadState.cpp index 9df767eb681..8e5214002c2 100644 --- a/hotspot/src/share/vm/prims/jvmtiEnvThreadState.cpp +++ b/hotspot/src/share/vm/prims/jvmtiEnvThreadState.cpp @@ -95,7 +95,7 @@ JvmtiFramePops::clear_to(JvmtiFramePop& fp) { // JvmtiFramePops::JvmtiFramePops() { - _pops = new (ResourceObj::C_HEAP) GrowableArray (2, true); + _pops = new (ResourceObj::C_HEAP, mtInternal) GrowableArray (2, true); } JvmtiFramePops::~JvmtiFramePops() { diff --git a/hotspot/src/share/vm/prims/jvmtiEnvThreadState.hpp b/hotspot/src/share/vm/prims/jvmtiEnvThreadState.hpp index e2273df0835..f9e686c0874 100644 --- a/hotspot/src/share/vm/prims/jvmtiEnvThreadState.hpp +++ b/hotspot/src/share/vm/prims/jvmtiEnvThreadState.hpp @@ -76,7 +76,7 @@ class JvmtiFramePop VALUE_OBJ_CLASS_SPEC { // It records what frames on a threads stack should post frame_pop events when they're exited. // -class JvmtiFramePops : public CHeapObj { +class JvmtiFramePops : public CHeapObj { private: GrowableArray* _pops; @@ -107,7 +107,7 @@ class JvmtiFramePops : public CHeapObj { // 3: Location of last executed instruction, used to filter out duplicate // events due to instruction rewriting. -class JvmtiEnvThreadState : public CHeapObj { +class JvmtiEnvThreadState : public CHeapObj { private: friend class JvmtiEnv; JavaThread *_thread; diff --git a/hotspot/src/share/vm/prims/jvmtiExport.cpp b/hotspot/src/share/vm/prims/jvmtiExport.cpp index 5325073b620..70c5c71c9c9 100644 --- a/hotspot/src/share/vm/prims/jvmtiExport.cpp +++ b/hotspot/src/share/vm/prims/jvmtiExport.cpp @@ -617,7 +617,7 @@ class JvmtiClassFileLoadHookPoster : public StackObj { if (caching_needed && *_cached_data_ptr == NULL) { // data has been changed by the new retransformable agent // and it hasn't already been cached, cache it - *_cached_data_ptr = (unsigned char *)os::malloc(_curr_len); + *_cached_data_ptr = (unsigned char *)os::malloc(_curr_len, mtInternal); memcpy(*_cached_data_ptr, _curr_data, _curr_len); *_cached_length_ptr = _curr_len; } @@ -720,7 +720,7 @@ class JvmtiCompiledMethodLoadEventMark : public JvmtiMethodEventMark { JvmtiCodeBlobEvents::build_jvmti_addr_location_map(nm, &_map, &_map_length); } ~JvmtiCompiledMethodLoadEventMark() { - FREE_C_HEAP_ARRAY(jvmtiAddrLocationMap, _map); + FREE_C_HEAP_ARRAY(jvmtiAddrLocationMap, _map, mtInternal); } jint code_size() { return _code_size; } @@ -2323,7 +2323,7 @@ JvmtiDynamicCodeEventCollector::~JvmtiDynamicCodeEventCollector() { // register a stub void JvmtiDynamicCodeEventCollector::register_stub(const char* name, address start, address end) { if (_code_blobs == NULL) { - _code_blobs = new (ResourceObj::C_HEAP) GrowableArray(1,true); + _code_blobs = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(1,true); } _code_blobs->append(new JvmtiCodeBlobDesc(name, start, end)); } @@ -2357,7 +2357,7 @@ JvmtiVMObjectAllocEventCollector::~JvmtiVMObjectAllocEventCollector() { void JvmtiVMObjectAllocEventCollector::record_allocation(oop obj) { assert(is_enabled(), "VM object alloc event collector is not enabled"); if (_allocated == NULL) { - _allocated = new (ResourceObj::C_HEAP) GrowableArray(1, true); + _allocated = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(1, true); } _allocated->push(obj); } diff --git a/hotspot/src/share/vm/prims/jvmtiExport.hpp b/hotspot/src/share/vm/prims/jvmtiExport.hpp index 31ee1ec93e8..4f6e6c6ae49 100644 --- a/hotspot/src/share/vm/prims/jvmtiExport.hpp +++ b/hotspot/src/share/vm/prims/jvmtiExport.hpp @@ -350,7 +350,7 @@ class JvmtiExport : public AllStatic { // Support class used by JvmtiDynamicCodeEventCollector and others. It // describes a single code blob by name and address range. -class JvmtiCodeBlobDesc : public CHeapObj { +class JvmtiCodeBlobDesc : public CHeapObj { private: char _name[64]; address _code_begin; diff --git a/hotspot/src/share/vm/prims/jvmtiExtensions.cpp b/hotspot/src/share/vm/prims/jvmtiExtensions.cpp index 00f99720101..9f6a1b101ec 100644 --- a/hotspot/src/share/vm/prims/jvmtiExtensions.cpp +++ b/hotspot/src/share/vm/prims/jvmtiExtensions.cpp @@ -49,8 +49,8 @@ static jvmtiError JNICALL IsClassUnloadingEnabled(const jvmtiEnv* env, jboolean* // event. The function and the event are registered here. // void JvmtiExtensions::register_extensions() { - _ext_functions = new (ResourceObj::C_HEAP) GrowableArray(1,true); - _ext_events = new (ResourceObj::C_HEAP) GrowableArray(1,true); + _ext_functions = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(1,true); + _ext_events = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(1,true); // register our extension function static jvmtiParamInfo func_params[] = { diff --git a/hotspot/src/share/vm/prims/jvmtiGetLoadedClasses.cpp b/hotspot/src/share/vm/prims/jvmtiGetLoadedClasses.cpp index dd07a295ad1..050aa60177e 100644 --- a/hotspot/src/share/vm/prims/jvmtiGetLoadedClasses.cpp +++ b/hotspot/src/share/vm/prims/jvmtiGetLoadedClasses.cpp @@ -152,7 +152,7 @@ class JvmtiGetLoadedClassesClosure : public StackObj { // Public methods that get called within the scope of the closure void allocate() { - _list = NEW_C_HEAP_ARRAY(Handle, _count); + _list = NEW_C_HEAP_ARRAY(Handle, _count, mtInternal); assert(_list != NULL, "Out of memory"); if (_list == NULL) { _count = 0; diff --git a/hotspot/src/share/vm/prims/jvmtiImpl.cpp b/hotspot/src/share/vm/prims/jvmtiImpl.cpp index e0d809d4541..2244d81d9d7 100644 --- a/hotspot/src/share/vm/prims/jvmtiImpl.cpp +++ b/hotspot/src/share/vm/prims/jvmtiImpl.cpp @@ -98,8 +98,8 @@ JvmtiAgentThread::call_start_function() { void GrowableCache::recache() { int len = _elements->length(); - FREE_C_HEAP_ARRAY(address, _cache); - _cache = NEW_C_HEAP_ARRAY(address,len+1); + FREE_C_HEAP_ARRAY(address, _cache, mtInternal); + _cache = NEW_C_HEAP_ARRAY(address,len+1, mtInternal); for (int i=0; iat(i)->getCacheValue(); @@ -142,13 +142,13 @@ GrowableCache::GrowableCache() { GrowableCache::~GrowableCache() { clear(); delete _elements; - FREE_C_HEAP_ARRAY(address, _cache); + FREE_C_HEAP_ARRAY(address, _cache, mtInternal); } void GrowableCache::initialize(void *this_obj, void listener_fun(void *, address*) ) { _this_obj = this_obj; _listener_fun = listener_fun; - _elements = new (ResourceObj::C_HEAP) GrowableArray(5,true); + _elements = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(5,true); recache(); } diff --git a/hotspot/src/share/vm/prims/jvmtiImpl.hpp b/hotspot/src/share/vm/prims/jvmtiImpl.hpp index 704d287a8f3..f80d63144d4 100644 --- a/hotspot/src/share/vm/prims/jvmtiImpl.hpp +++ b/hotspot/src/share/vm/prims/jvmtiImpl.hpp @@ -64,7 +64,7 @@ class JvmtiBreakpoints; // to update its pointer to the address cache. // -class GrowableElement : public CHeapObj { +class GrowableElement : public CHeapObj { public: virtual address getCacheValue() =0; virtual bool equals(GrowableElement* e) =0; @@ -130,7 +130,7 @@ public: // Note : typesafe wrapper for GrowableCache of JvmtiBreakpoint // -class JvmtiBreakpointCache : public CHeapObj { +class JvmtiBreakpointCache : public CHeapObj { private: GrowableCache _cache; @@ -258,7 +258,7 @@ public: // CHeap allocated to emphasize its similarity to JvmtiFramePops. // -class JvmtiBreakpoints : public CHeapObj { +class JvmtiBreakpoints : public CHeapObj { private: JvmtiBreakpointCache _bps; @@ -496,7 +496,7 @@ class JvmtiDeferredEvent VALUE_OBJ_CLASS_SPEC { class JvmtiDeferredEventQueue : AllStatic { friend class JvmtiDeferredEvent; private: - class QueueNode : public CHeapObj { + class QueueNode : public CHeapObj { private: JvmtiDeferredEvent _event; QueueNode* _next; diff --git a/hotspot/src/share/vm/prims/jvmtiRawMonitor.cpp b/hotspot/src/share/vm/prims/jvmtiRawMonitor.cpp index 89cac00bb5c..9031bbb290a 100644 --- a/hotspot/src/share/vm/prims/jvmtiRawMonitor.cpp +++ b/hotspot/src/share/vm/prims/jvmtiRawMonitor.cpp @@ -27,7 +27,7 @@ #include "runtime/interfaceSupport.hpp" #include "runtime/thread.hpp" -GrowableArray *JvmtiPendingMonitors::_monitors = new (ResourceObj::C_HEAP) GrowableArray(1,true); +GrowableArray *JvmtiPendingMonitors::_monitors = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(1,true); void JvmtiPendingMonitors::transition_raw_monitors() { assert((Threads::number_of_threads()==1), @@ -53,7 +53,7 @@ is running. Raw monitor transition will not work"); JvmtiRawMonitor::JvmtiRawMonitor(const char *name) { #ifdef ASSERT - _name = strcpy(NEW_C_HEAP_ARRAY(char, strlen(name) + 1), name); + _name = strcpy(NEW_C_HEAP_ARRAY(char, strlen(name) + 1, mtInternal), name); #else _name = NULL; #endif diff --git a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp index 2caecf680bb..0eb188a6371 100644 --- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp +++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp @@ -831,7 +831,7 @@ bool VM_RedefineClasses::is_unresolved_string_mismatch(constantPoolHandle cp1, jvmtiError VM_RedefineClasses::load_new_class_versions(TRAPS) { // For consistency allocate memory using os::malloc wrapper. _scratch_classes = (instanceKlassHandle *) - os::malloc(sizeof(instanceKlassHandle) * _class_count); + os::malloc(sizeof(instanceKlassHandle) * _class_count, mtInternal); if (_scratch_classes == NULL) { return JVMTI_ERROR_OUT_OF_MEMORY; } diff --git a/hotspot/src/share/vm/prims/jvmtiTagMap.cpp b/hotspot/src/share/vm/prims/jvmtiTagMap.cpp index 3b58f0f087e..ba77093a7f8 100644 --- a/hotspot/src/share/vm/prims/jvmtiTagMap.cpp +++ b/hotspot/src/share/vm/prims/jvmtiTagMap.cpp @@ -55,7 +55,7 @@ // and the tag value. In addition an entry includes a next pointer which // is used to chain entries together. -class JvmtiTagHashmapEntry : public CHeapObj { +class JvmtiTagHashmapEntry : public CHeapObj { private: friend class JvmtiTagMap; @@ -106,7 +106,7 @@ class JvmtiTagHashmapEntry : public CHeapObj { // entries. It also provides a function to iterate over all entries // in the hashmap. -class JvmtiTagHashmap : public CHeapObj { +class JvmtiTagHashmap : public CHeapObj { private: friend class JvmtiTagMap; @@ -150,7 +150,7 @@ class JvmtiTagHashmap : public CHeapObj { _resize_threshold = (int)(_load_factor * _size); _resizing_enabled = true; size_t s = initial_size * sizeof(JvmtiTagHashmapEntry*); - _table = (JvmtiTagHashmapEntry**)os::malloc(s); + _table = (JvmtiTagHashmapEntry**)os::malloc(s, mtInternal); if (_table == NULL) { vm_exit_out_of_memory(s, "unable to allocate initial hashtable for jvmti object tags"); } @@ -188,7 +188,7 @@ class JvmtiTagHashmap : public CHeapObj { // allocate new table size_t s = new_size * sizeof(JvmtiTagHashmapEntry*); - JvmtiTagHashmapEntry** new_table = (JvmtiTagHashmapEntry**)os::malloc(s); + JvmtiTagHashmapEntry** new_table = (JvmtiTagHashmapEntry**)os::malloc(s, mtInternal); if (new_table == NULL) { warning("unable to allocate larger hashtable for jvmti object tags"); set_resizing_enabled(false); @@ -776,7 +776,7 @@ jlong JvmtiTagMap::get_tag(jobject object) { // For each field it holds the field index (as defined by the JVMTI specification), // the field type, and the offset. -class ClassFieldDescriptor: public CHeapObj { +class ClassFieldDescriptor: public CHeapObj { private: int _field_index; int _field_offset; @@ -790,7 +790,7 @@ class ClassFieldDescriptor: public CHeapObj { int field_offset() const { return _field_offset; } }; -class ClassFieldMap: public CHeapObj { +class ClassFieldMap: public CHeapObj { private: enum { initial_field_count = 5 @@ -821,7 +821,8 @@ class ClassFieldMap: public CHeapObj { }; ClassFieldMap::ClassFieldMap() { - _fields = new (ResourceObj::C_HEAP) GrowableArray(initial_field_count, true); + _fields = new (ResourceObj::C_HEAP, mtInternal) + GrowableArray(initial_field_count, true); } ClassFieldMap::~ClassFieldMap() { @@ -892,7 +893,7 @@ ClassFieldMap* ClassFieldMap::create_map_of_instance_fields(oop obj) { // heap iteration and avoid creating a field map for each object in the heap // (only need to create the map when the first instance of a class is encountered). // -class JvmtiCachedClassFieldMap : public CHeapObj { +class JvmtiCachedClassFieldMap : public CHeapObj { private: enum { initial_class_count = 200 @@ -957,7 +958,8 @@ bool ClassFieldMapCacheMark::_is_active; // record that the given instanceKlass is caching a field map void JvmtiCachedClassFieldMap::add_to_class_list(instanceKlass* ik) { if (_class_list == NULL) { - _class_list = new (ResourceObj::C_HEAP) GrowableArray(initial_class_count, true); + _class_list = new (ResourceObj::C_HEAP, mtInternal) + GrowableArray(initial_class_count, true); } _class_list->push(ik); } @@ -1526,8 +1528,8 @@ class TagObjectCollector : public JvmtiTagHashmapEntryClosure { _env = env; _tags = (jlong*)tags; _tag_count = tag_count; - _object_results = new (ResourceObj::C_HEAP) GrowableArray(1,true); - _tag_results = new (ResourceObj::C_HEAP) GrowableArray(1,true); + _object_results = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(1,true); + _tag_results = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(1,true); } ~TagObjectCollector() { @@ -1672,8 +1674,8 @@ void ObjectMarker::init() { Universe::heap()->ensure_parsability(false); // no need to retire TLABs // create stacks for interesting headers - _saved_mark_stack = new (ResourceObj::C_HEAP) GrowableArray(4000, true); - _saved_oop_stack = new (ResourceObj::C_HEAP) GrowableArray(4000, true); + _saved_mark_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(4000, true); + _saved_oop_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(4000, true); if (UseBiasedLocking) { BiasedLocking::preserve_marks(); @@ -2712,7 +2714,7 @@ class VM_HeapWalkOperation: public VM_Operation { bool _reporting_string_values; GrowableArray* create_visit_stack() { - return new (ResourceObj::C_HEAP) GrowableArray(initial_visit_stack_size, true); + return new (ResourceObj::C_HEAP, mtInternal) GrowableArray(initial_visit_stack_size, true); } // accessors diff --git a/hotspot/src/share/vm/prims/jvmtiTagMap.hpp b/hotspot/src/share/vm/prims/jvmtiTagMap.hpp index 2a460edc1e0..ede639efe7e 100644 --- a/hotspot/src/share/vm/prims/jvmtiTagMap.hpp +++ b/hotspot/src/share/vm/prims/jvmtiTagMap.hpp @@ -41,7 +41,7 @@ class JvmtiTagHashmap; class JvmtiTagHashmapEntry; class JvmtiTagHashmapEntryClosure; -class JvmtiTagMap : public CHeapObj { +class JvmtiTagMap : public CHeapObj { private: enum{ diff --git a/hotspot/src/share/vm/prims/jvmtiThreadState.hpp b/hotspot/src/share/vm/prims/jvmtiThreadState.hpp index 87d2f0b03a4..6cc4e275d85 100644 --- a/hotspot/src/share/vm/prims/jvmtiThreadState.hpp +++ b/hotspot/src/share/vm/prims/jvmtiThreadState.hpp @@ -72,7 +72,7 @@ class JvmtiEnvThreadStateIterator : public StackObj { // // The Jvmti state for each thread (across all JvmtiEnv): // 1. Local table of enabled events. -class JvmtiThreadState : public CHeapObj { +class JvmtiThreadState : public CHeapObj { private: friend class JvmtiEnv; JavaThread *_thread; diff --git a/hotspot/src/share/vm/prims/jvmtiUtil.cpp b/hotspot/src/share/vm/prims/jvmtiUtil.cpp index 6671d48e995..425ca1d9803 100644 --- a/hotspot/src/share/vm/prims/jvmtiUtil.cpp +++ b/hotspot/src/share/vm/prims/jvmtiUtil.cpp @@ -40,7 +40,7 @@ ResourceArea* JvmtiUtil::single_threaded_resource_area() { if (_single_threaded_resource_area == NULL) { // lazily create the single threaded resource area // pick a size which is not a standard since the pools don't exist yet - _single_threaded_resource_area = new ResourceArea(Chunk::non_pool_size); + _single_threaded_resource_area = new (mtInternal) ResourceArea(Chunk::non_pool_size); } return _single_threaded_resource_area; } diff --git a/hotspot/src/share/vm/prims/unsafe.cpp b/hotspot/src/share/vm/prims/unsafe.cpp index 19f77a5f160..e3202eaaf39 100644 --- a/hotspot/src/share/vm/prims/unsafe.cpp +++ b/hotspot/src/share/vm/prims/unsafe.cpp @@ -596,7 +596,7 @@ UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory(JNIEnv *env, jobject unsafe, jlong siz return 0; } sz = round_to(sz, HeapWordSize); - void* x = os::malloc(sz); + void* x = os::malloc(sz, mtInternal); if (x == NULL) { THROW_0(vmSymbols::java_lang_OutOfMemoryError()); } @@ -616,7 +616,7 @@ UNSAFE_ENTRY(jlong, Unsafe_ReallocateMemory(JNIEnv *env, jobject unsafe, jlong a return 0; } sz = round_to(sz, HeapWordSize); - void* x = (p == NULL) ? os::malloc(sz) : os::realloc(p, sz); + void* x = (p == NULL) ? os::malloc(sz, mtInternal) : os::realloc(p, sz, mtInternal); if (x == NULL) { THROW_0(vmSymbols::java_lang_OutOfMemoryError()); } @@ -877,7 +877,7 @@ static jclass Unsafe_DefineClass(JNIEnv *env, jstring name, jbyteArray data, int return 0; } - body = NEW_C_HEAP_ARRAY(jbyte, length); + body = NEW_C_HEAP_ARRAY(jbyte, length, mtInternal); if (body == 0) { throw_new(env, "OutOfMemoryError"); @@ -893,7 +893,7 @@ static jclass Unsafe_DefineClass(JNIEnv *env, jstring name, jbyteArray data, int uint len = env->GetStringUTFLength(name); int unicode_len = env->GetStringLength(name); if (len >= sizeof(buf)) { - utfName = NEW_C_HEAP_ARRAY(char, len + 1); + utfName = NEW_C_HEAP_ARRAY(char, len + 1, mtInternal); if (utfName == NULL) { throw_new(env, "OutOfMemoryError"); goto free_body; @@ -913,10 +913,10 @@ static jclass Unsafe_DefineClass(JNIEnv *env, jstring name, jbyteArray data, int result = JVM_DefineClass(env, utfName, loader, body, length, pd); if (utfName && utfName != buf) - FREE_C_HEAP_ARRAY(char, utfName); + FREE_C_HEAP_ARRAY(char, utfName, mtInternal); free_body: - FREE_C_HEAP_ARRAY(jbyte, body); + FREE_C_HEAP_ARRAY(jbyte, body, mtInternal); return result; } } @@ -1011,7 +1011,7 @@ Unsafe_DefineAnonymousClass_impl(JNIEnv *env, jint length = typeArrayOop(JNIHandles::resolve_non_null(data))->length(); jint word_length = (length + sizeof(HeapWord)-1) / sizeof(HeapWord); - HeapWord* body = NEW_C_HEAP_ARRAY(HeapWord, word_length); + HeapWord* body = NEW_C_HEAP_ARRAY(HeapWord, word_length, mtInternal); if (body == NULL) { THROW_0(vmSymbols::java_lang_OutOfMemoryError()); } @@ -1095,7 +1095,7 @@ UNSAFE_ENTRY(jclass, Unsafe_DefineAnonymousClass(JNIEnv *env, jobject unsafe, jc // try/finally clause: if (temp_alloc != NULL) { - FREE_C_HEAP_ARRAY(HeapWord, temp_alloc); + FREE_C_HEAP_ARRAY(HeapWord, temp_alloc, mtInternal); } return (jclass) res_jh; diff --git a/hotspot/src/share/vm/runtime/arguments.cpp b/hotspot/src/share/vm/runtime/arguments.cpp index d319fddfe51..b93ef053bed 100644 --- a/hotspot/src/share/vm/runtime/arguments.cpp +++ b/hotspot/src/share/vm/runtime/arguments.cpp @@ -35,6 +35,7 @@ #include "runtime/globals_extension.hpp" #include "runtime/java.hpp" #include "services/management.hpp" +#include "services/memTracker.hpp" #include "utilities/defaultStream.hpp" #include "utilities/taskqueue.hpp" #ifdef TARGET_OS_FAMILY_linux @@ -368,7 +369,7 @@ inline void SysClassPath::add_suffix(const char* suffix) { inline void SysClassPath::reset_item_at(int index) { assert(index < _scp_nitems && index != _scp_base, "just checking"); if (_items[index] != NULL) { - FREE_C_HEAP_ARRAY(char, _items[index]); + FREE_C_HEAP_ARRAY(char, _items[index], mtInternal); _items[index] = NULL; } } @@ -400,11 +401,11 @@ void SysClassPath::expand_endorsed() { expanded_path = add_jars_to_path(expanded_path, path); path = end; } else { - char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1); + char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1, mtInternal); memcpy(dirpath, path, tmp_end - path); dirpath[tmp_end - path] = '\0'; expanded_path = add_jars_to_path(expanded_path, dirpath); - FREE_C_HEAP_ARRAY(char, dirpath); + FREE_C_HEAP_ARRAY(char, dirpath, mtInternal); path = tmp_end + 1; } } @@ -435,7 +436,7 @@ char* SysClassPath::combined_path() { assert(total_len > 0, "empty sysclasspath not allowed"); // Copy the _items to a single string. - char* cp = NEW_C_HEAP_ARRAY(char, total_len); + char* cp = NEW_C_HEAP_ARRAY(char, total_len, mtInternal); char* cp_tmp = cp; for (i = 0; i < _scp_nitems; ++i) { if (_items[i] != NULL) { @@ -456,7 +457,7 @@ SysClassPath::add_to_path(const char* path, const char* str, bool prepend) { assert(str != NULL, "just checking"); if (path == NULL) { size_t len = strlen(str) + 1; - cp = NEW_C_HEAP_ARRAY(char, len); + cp = NEW_C_HEAP_ARRAY(char, len, mtInternal); memcpy(cp, str, len); // copy the trailing null } else { const char separator = *os::path_separator(); @@ -465,15 +466,15 @@ SysClassPath::add_to_path(const char* path, const char* str, bool prepend) { size_t len = old_len + str_len + 2; if (prepend) { - cp = NEW_C_HEAP_ARRAY(char, len); + cp = NEW_C_HEAP_ARRAY(char, len, mtInternal); char* cp_tmp = cp; memcpy(cp_tmp, str, str_len); cp_tmp += str_len; *cp_tmp = separator; memcpy(++cp_tmp, path, old_len + 1); // copy the trailing null - FREE_C_HEAP_ARRAY(char, path); + FREE_C_HEAP_ARRAY(char, path, mtInternal); } else { - cp = REALLOC_C_HEAP_ARRAY(char, path, len); + cp = REALLOC_C_HEAP_ARRAY(char, path, len, mtInternal); char* cp_tmp = cp + old_len; *cp_tmp = separator; memcpy(++cp_tmp, str, str_len + 1); // copy the trailing null @@ -495,7 +496,7 @@ char* SysClassPath::add_jars_to_path(char* path, const char* directory) { /* Scan the directory for jars/zips, appending them to path. */ struct dirent *entry; - char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory)); + char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory), mtInternal); while ((entry = os::readdir(dir, (dirent *) dbuf)) != NULL) { const char* name = entry->d_name; const char* ext = name + strlen(name) - 4; @@ -503,13 +504,13 @@ char* SysClassPath::add_jars_to_path(char* path, const char* directory) { (os::file_name_strcmp(ext, ".jar") == 0 || os::file_name_strcmp(ext, ".zip") == 0); if (isJarOrZip) { - char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name)); + char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name), mtInternal); sprintf(jarpath, "%s%s%s", directory, dir_sep, name); path = add_to_path(path, jarpath, false); - FREE_C_HEAP_ARRAY(char, jarpath); + FREE_C_HEAP_ARRAY(char, jarpath, mtInternal); } } - FREE_C_HEAP_ARRAY(char, dbuf); + FREE_C_HEAP_ARRAY(char, dbuf, mtInternal); os::closedir(dir); return path; } @@ -631,7 +632,7 @@ static bool set_numeric_flag(char* name, char* value, FlagValueOrigin origin) { static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) { if (!CommandLineFlags::ccstrAtPut(name, &value, origin)) return false; // Contract: CommandLineFlags always returns a pointer that needs freeing. - FREE_C_HEAP_ARRAY(char, value); + FREE_C_HEAP_ARRAY(char, value, mtInternal); return true; } @@ -647,7 +648,7 @@ static bool append_to_string_flag(char* name, const char* new_value, FlagValueOr } else if (new_len == 0) { value = old_value; } else { - char* buf = NEW_C_HEAP_ARRAY(char, old_len + 1 + new_len + 1); + char* buf = NEW_C_HEAP_ARRAY(char, old_len + 1 + new_len + 1, mtInternal); // each new setting adds another LINE to the switch: sprintf(buf, "%s\n%s", old_value, new_value); value = buf; @@ -655,10 +656,10 @@ static bool append_to_string_flag(char* name, const char* new_value, FlagValueOr } (void) CommandLineFlags::ccstrAtPut(name, &value, origin); // CommandLineFlags always returns a pointer that needs freeing. - FREE_C_HEAP_ARRAY(char, value); + FREE_C_HEAP_ARRAY(char, value, mtInternal); if (free_this_too != NULL) { // CommandLineFlags made its own copy, so I must delete my own temp. buffer. - FREE_C_HEAP_ARRAY(char, free_this_too); + FREE_C_HEAP_ARRAY(char, free_this_too, mtInternal); } return true; } @@ -735,9 +736,9 @@ void Arguments::add_string(char*** bldarray, int* count, const char* arg) { // expand the array and add arg to the last element (*count)++; if (*bldarray == NULL) { - *bldarray = NEW_C_HEAP_ARRAY(char*, *count); + *bldarray = NEW_C_HEAP_ARRAY(char*, *count, mtInternal); } else { - *bldarray = REALLOC_C_HEAP_ARRAY(char*, *bldarray, *count); + *bldarray = REALLOC_C_HEAP_ARRAY(char*, *bldarray, *count, mtInternal); } (*bldarray)[index] = strdup(arg); } @@ -917,13 +918,13 @@ bool Arguments::add_property(const char* prop) { char* value = (char *)ns; size_t key_len = (eq == NULL) ? strlen(prop) : (eq - prop); - key = AllocateHeap(key_len + 1, "add_property"); + key = AllocateHeap(key_len + 1, mtInternal); strncpy(key, prop, key_len); key[key_len] = '\0'; if (eq != NULL) { size_t value_len = strlen(prop) - key_len - 1; - value = AllocateHeap(value_len + 1, "add_property"); + value = AllocateHeap(value_len + 1, mtInternal); strncpy(value, &prop[key_len + 1], value_len + 1); } @@ -2058,12 +2059,12 @@ jint Arguments::parse_vm_init_args(const JavaVMInitArgs* args) { const char* altclasses_jar = "alt-rt.jar"; size_t altclasses_path_len = strlen(get_meta_index_dir()) + 1 + strlen(altclasses_jar); - char* altclasses_path = NEW_C_HEAP_ARRAY(char, altclasses_path_len); + char* altclasses_path = NEW_C_HEAP_ARRAY(char, altclasses_path_len, mtInternal); strcpy(altclasses_path, get_meta_index_dir()); strcat(altclasses_path, altclasses_jar); scp.add_suffix_to_prefix(altclasses_path); scp_assembly_required = true; - FREE_C_HEAP_ARRAY(char, altclasses_path); + FREE_C_HEAP_ARRAY(char, altclasses_path, mtInternal); } if (WhiteBoxAPI) { @@ -2071,12 +2072,12 @@ jint Arguments::parse_vm_init_args(const JavaVMInitArgs* args) { const char* wb_jar = "wb.jar"; size_t wb_path_len = strlen(get_meta_index_dir()) + 1 + strlen(wb_jar); - char* wb_path = NEW_C_HEAP_ARRAY(char, wb_path_len); + char* wb_path = NEW_C_HEAP_ARRAY(char, wb_path_len, mtInternal); strcpy(wb_path, get_meta_index_dir()); strcat(wb_path, wb_jar); scp.add_suffix(wb_path); scp_assembly_required = true; - FREE_C_HEAP_ARRAY(char, wb_path); + FREE_C_HEAP_ARRAY(char, wb_path, mtInternal); } // Parse _JAVA_OPTIONS environment variable (if present) (mimics classic VM) @@ -2161,13 +2162,13 @@ jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, if (tail != NULL) { const char* pos = strchr(tail, ':'); size_t len = (pos == NULL) ? strlen(tail) : pos - tail; - char* name = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len + 1), tail, len); + char* name = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len); name[len] = '\0'; char *options = NULL; if(pos != NULL) { size_t len2 = strlen(pos+1) + 1; // options start after ':'. Final zero must be copied. - options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2), pos+1, len2); + options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2, mtInternal), pos+1, len2); } #ifdef JVMTI_KERNEL if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) { @@ -2182,12 +2183,12 @@ jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, if(tail != NULL) { const char* pos = strchr(tail, '='); size_t len = (pos == NULL) ? strlen(tail) : pos - tail; - char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1), tail, len); + char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len); name[len] = '\0'; char *options = NULL; if(pos != NULL) { - options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1), pos + 1); + options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1, mtInternal), pos + 1); } #ifdef JVMTI_KERNEL if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) { @@ -2200,7 +2201,7 @@ jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, // -javaagent } else if (match_option(option, "-javaagent:", &tail)) { if(tail != NULL) { - char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1), tail); + char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1, mtInternal), tail); add_init_agent("instrument", options, false); } // -Xnoclassgc @@ -2958,7 +2959,7 @@ jint Arguments::parse(const JavaVMInitArgs* args) { char *end = strrchr(jvm_path, *os::file_separator()); if (end != NULL) *end = '\0'; char *shared_archive_path = NEW_C_HEAP_ARRAY(char, strlen(jvm_path) + - strlen(os::file_separator()) + 20); + strlen(os::file_separator()) + 20, mtInternal); if (shared_archive_path == NULL) return JNI_ENOMEM; strcpy(shared_archive_path, jvm_path); strcat(shared_archive_path, os::file_separator()); @@ -2996,6 +2997,10 @@ jint Arguments::parse(const JavaVMInitArgs* args) { CommandLineFlags::printFlags(tty, false); vm_exit(0); } + if (match_option(option, "-XX:NativeMemoryTracking", &tail)) { + MemTracker::init_tracking_options(tail); + } + #ifndef PRODUCT if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) { @@ -3331,7 +3336,7 @@ char *Arguments::get_kernel_properties() { } } // Add one for null terminator. - char *props = AllocateHeap(length + 1, "get_kernel_properties"); + char *props = AllocateHeap(length + 1, mtInternal); if (length != 0) { int pos = 0; for (prop = _system_properties; prop != NULL; prop = prop->next()) { diff --git a/hotspot/src/share/vm/runtime/arguments.hpp b/hotspot/src/share/vm/runtime/arguments.hpp index 076b4861db1..e78e45c912c 100644 --- a/hotspot/src/share/vm/runtime/arguments.hpp +++ b/hotspot/src/share/vm/runtime/arguments.hpp @@ -44,7 +44,7 @@ class SysClassPath; // Element describing System and User (-Dkey=value flags) defined property. -class SystemProperty: public CHeapObj { +class SystemProperty: public CHeapObj { private: char* _key; char* _value; @@ -63,7 +63,7 @@ class SystemProperty: public CHeapObj { if (_value != NULL) { FreeHeap(_value); } - _value = AllocateHeap(strlen(value)+1); + _value = AllocateHeap(strlen(value)+1, mtInternal); if (_value != NULL) { strcpy(_value, value); } @@ -80,7 +80,7 @@ class SystemProperty: public CHeapObj { if (_value != NULL) { len += strlen(_value); } - sp = AllocateHeap(len+2); + sp = AllocateHeap(len+2, mtInternal); if (sp != NULL) { if (_value != NULL) { strcpy(sp, _value); @@ -100,13 +100,13 @@ class SystemProperty: public CHeapObj { if (key == NULL) { _key = NULL; } else { - _key = AllocateHeap(strlen(key)+1); + _key = AllocateHeap(strlen(key)+1, mtInternal); strcpy(_key, key); } if (value == NULL) { _value = NULL; } else { - _value = AllocateHeap(strlen(value)+1); + _value = AllocateHeap(strlen(value)+1, mtInternal); strcpy(_value, value); } _next = NULL; @@ -116,7 +116,7 @@ class SystemProperty: public CHeapObj { // For use by -agentlib, -agentpath and -Xrun -class AgentLibrary : public CHeapObj { +class AgentLibrary : public CHeapObj { friend class AgentLibraryList; private: char* _name; @@ -136,12 +136,12 @@ class AgentLibrary : public CHeapObj { // Constructor AgentLibrary(const char* name, const char* options, bool is_absolute_path, void* os_lib) { - _name = AllocateHeap(strlen(name)+1); + _name = AllocateHeap(strlen(name)+1, mtInternal); strcpy(_name, name); if (options == NULL) { _options = NULL; } else { - _options = AllocateHeap(strlen(options)+1); + _options = AllocateHeap(strlen(options)+1, mtInternal); strcpy(_options, options); } _is_absolute_path = is_absolute_path; diff --git a/hotspot/src/share/vm/runtime/biasedLocking.cpp b/hotspot/src/share/vm/runtime/biasedLocking.cpp index ba49d80de08..de739ecafb1 100644 --- a/hotspot/src/share/vm/runtime/biasedLocking.cpp +++ b/hotspot/src/share/vm/runtime/biasedLocking.cpp @@ -687,8 +687,8 @@ void BiasedLocking::preserve_marks() { // monitors in a prepass and, if they are biased, preserve their // mark words here. This should be a relatively small set of objects // especially compared to the number of objects in the heap. - _preserved_mark_stack = new (ResourceObj::C_HEAP) GrowableArray(10, true); - _preserved_oop_stack = new (ResourceObj::C_HEAP) GrowableArray(10, true); + _preserved_mark_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(10, true); + _preserved_oop_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(10, true); ResourceMark rm; Thread* cur = Thread::current(); diff --git a/hotspot/src/share/vm/runtime/compilationPolicy.hpp b/hotspot/src/share/vm/runtime/compilationPolicy.hpp index 1d8427cf2fd..a0912beaf5a 100644 --- a/hotspot/src/share/vm/runtime/compilationPolicy.hpp +++ b/hotspot/src/share/vm/runtime/compilationPolicy.hpp @@ -37,7 +37,7 @@ class CompileTask; class CompileQueue; -class CompilationPolicy : public CHeapObj { +class CompilationPolicy : public CHeapObj { static CompilationPolicy* _policy; // Accumulated time static elapsedTimer _accumulated_time; diff --git a/hotspot/src/share/vm/runtime/deoptimization.cpp b/hotspot/src/share/vm/runtime/deoptimization.cpp index 0e2a9839bc5..bbb5bc3cc81 100644 --- a/hotspot/src/share/vm/runtime/deoptimization.cpp +++ b/hotspot/src/share/vm/runtime/deoptimization.cpp @@ -101,7 +101,7 @@ Deoptimization::UnrollBlock::UnrollBlock(int size_of_deoptimized_frame, _number_of_frames = number_of_frames; _frame_sizes = frame_sizes; _frame_pcs = frame_pcs; - _register_block = NEW_C_HEAP_ARRAY(intptr_t, RegisterMap::reg_count * 2); + _register_block = NEW_C_HEAP_ARRAY(intptr_t, RegisterMap::reg_count * 2, mtCompiler); _return_type = return_type; _initial_info = 0; // PD (x86 only) @@ -114,9 +114,9 @@ Deoptimization::UnrollBlock::UnrollBlock(int size_of_deoptimized_frame, Deoptimization::UnrollBlock::~UnrollBlock() { - FREE_C_HEAP_ARRAY(intptr_t, _frame_sizes); - FREE_C_HEAP_ARRAY(intptr_t, _frame_pcs); - FREE_C_HEAP_ARRAY(intptr_t, _register_block); + FREE_C_HEAP_ARRAY(intptr_t, _frame_sizes, mtCompiler); + FREE_C_HEAP_ARRAY(intptr_t, _frame_pcs, mtCompiler); + FREE_C_HEAP_ARRAY(intptr_t, _register_block, mtCompiler); } @@ -358,9 +358,9 @@ Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread // Compute the vframes' sizes. Note that frame_sizes[] entries are ordered from outermost to innermost // virtual activation, which is the reverse of the elements in the vframes array. - intptr_t* frame_sizes = NEW_C_HEAP_ARRAY(intptr_t, number_of_frames); + intptr_t* frame_sizes = NEW_C_HEAP_ARRAY(intptr_t, number_of_frames, mtCompiler); // +1 because we always have an interpreter return address for the final slot. - address* frame_pcs = NEW_C_HEAP_ARRAY(address, number_of_frames + 1); + address* frame_pcs = NEW_C_HEAP_ARRAY(address, number_of_frames + 1, mtCompiler); int popframe_extra_args = 0; // Create an interpreter return address for the stub to use as its return // address so the skeletal frames are perfectly walkable diff --git a/hotspot/src/share/vm/runtime/deoptimization.hpp b/hotspot/src/share/vm/runtime/deoptimization.hpp index 18225467921..23870b4e8a6 100644 --- a/hotspot/src/share/vm/runtime/deoptimization.hpp +++ b/hotspot/src/share/vm/runtime/deoptimization.hpp @@ -129,7 +129,7 @@ class Deoptimization : AllStatic { // UnrollBlock is returned by fetch_unroll_info() to the deoptimization handler (blob). // This is only a CheapObj to ease debugging after a deopt failure - class UnrollBlock : public CHeapObj { + class UnrollBlock : public CHeapObj { private: int _size_of_deoptimized_frame; // Size, in bytes, of current deoptimized frame int _caller_adjustment; // Adjustment, in bytes, to caller's SP by initial interpreted frame diff --git a/hotspot/src/share/vm/runtime/dtraceJSDT.hpp b/hotspot/src/share/vm/runtime/dtraceJSDT.hpp index bff43108439..670eabfef44 100644 --- a/hotspot/src/share/vm/runtime/dtraceJSDT.hpp +++ b/hotspot/src/share/vm/runtime/dtraceJSDT.hpp @@ -63,7 +63,7 @@ class DTraceJSDT : AllStatic { static jboolean is_supported(); }; -class RegisteredProbes : public CHeapObj { +class RegisteredProbes : public CHeapObj { private: nmethod** _nmethods; // all the probe methods size_t _count; // number of probe methods @@ -72,7 +72,7 @@ class RegisteredProbes : public CHeapObj { public: RegisteredProbes(size_t count) { _count = count; - _nmethods = NEW_C_HEAP_ARRAY(nmethod*, count); + _nmethods = NEW_C_HEAP_ARRAY(nmethod*, count, mtInternal); } ~RegisteredProbes() { @@ -81,7 +81,7 @@ class RegisteredProbes : public CHeapObj { _nmethods[i]->make_not_entrant(); _nmethods[i]->method()->clear_code(); } - FREE_C_HEAP_ARRAY(nmethod*, _nmethods); + FREE_C_HEAP_ARRAY(nmethod*, _nmethods, mtInternal); _nmethods = NULL; _count = 0; } diff --git a/hotspot/src/share/vm/runtime/fprofiler.cpp b/hotspot/src/share/vm/runtime/fprofiler.cpp index 3c100aa4c98..9901fb9fa80 100644 --- a/hotspot/src/share/vm/runtime/fprofiler.cpp +++ b/hotspot/src/share/vm/runtime/fprofiler.cpp @@ -70,12 +70,12 @@ IntervalData* FlatProfiler::interval_data = NULL; ThreadProfiler::ThreadProfiler() { // Space for the ProfilerNodes const int area_size = 1 * ProfilerNodeSize * 1024; - area_bottom = AllocateHeap(area_size, "fprofiler"); + area_bottom = AllocateHeap(area_size, mtInternal); area_top = area_bottom; area_limit = area_bottom + area_size; // ProfilerNode pointer table - table = NEW_C_HEAP_ARRAY(ProfilerNode*, table_size); + table = NEW_C_HEAP_ARRAY(ProfilerNode*, table_size, mtInternal); initialize(); engaged = false; } @@ -157,7 +157,7 @@ address PCRecorder::base = NULL; void PCRecorder::init() { MutexLockerEx lm(CodeCache_lock, Mutex::_no_safepoint_check_flag); int s = size(); - counters = NEW_C_HEAP_ARRAY(int, s); + counters = NEW_C_HEAP_ARRAY(int, s, mtInternal); for (int index = 0; index < s; index++) { counters[index] = 0; } @@ -850,7 +850,7 @@ void FlatProfiler::record_thread_ticks() { if (Threads_lock->try_lock()) { { // Threads_lock scope maxthreads = Threads::number_of_threads(); - threadsList = NEW_C_HEAP_ARRAY(JavaThread *, maxthreads); + threadsList = NEW_C_HEAP_ARRAY(JavaThread *, maxthreads, mtInternal); suspendedthreadcount = 0; for (JavaThread* tp = Threads::first(); tp != NULL; tp = tp->next()) { if (tp->is_Compiler_thread()) { @@ -1195,8 +1195,8 @@ void ThreadProfiler::reset() { void FlatProfiler::allocate_table() { { // Bytecode table - bytecode_ticks = NEW_C_HEAP_ARRAY(int, Bytecodes::number_of_codes); - bytecode_ticks_stub = NEW_C_HEAP_ARRAY(int, Bytecodes::number_of_codes); + bytecode_ticks = NEW_C_HEAP_ARRAY(int, Bytecodes::number_of_codes, mtInternal); + bytecode_ticks_stub = NEW_C_HEAP_ARRAY(int, Bytecodes::number_of_codes, mtInternal); for(int index = 0; index < Bytecodes::number_of_codes; index++) { bytecode_ticks[index] = 0; bytecode_ticks_stub[index] = 0; @@ -1205,7 +1205,7 @@ void FlatProfiler::allocate_table() { if (ProfilerRecordPC) PCRecorder::init(); - interval_data = NEW_C_HEAP_ARRAY(IntervalData, interval_print_size); + interval_data = NEW_C_HEAP_ARRAY(IntervalData, interval_print_size, mtInternal); FlatProfiler::interval_reset(); } diff --git a/hotspot/src/share/vm/runtime/fprofiler.hpp b/hotspot/src/share/vm/runtime/fprofiler.hpp index 2f8d6158c29..25c2f2a10dc 100644 --- a/hotspot/src/share/vm/runtime/fprofiler.hpp +++ b/hotspot/src/share/vm/runtime/fprofiler.hpp @@ -121,7 +121,7 @@ public: }; #endif // FPROF_KERNEL -class ThreadProfiler: public CHeapObj { +class ThreadProfiler: public CHeapObj { public: ThreadProfiler() KERNEL_RETURN; ~ThreadProfiler() KERNEL_RETURN; diff --git a/hotspot/src/share/vm/runtime/globals.cpp b/hotspot/src/share/vm/runtime/globals.cpp index 474090a2a4b..3dad7a0f05d 100644 --- a/hotspot/src/share/vm/runtime/globals.cpp +++ b/hotspot/src/share/vm/runtime/globals.cpp @@ -465,13 +465,13 @@ bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, FlagValu ccstr old_value = result->get_ccstr(); char* new_value = NULL; if (*value != NULL) { - new_value = NEW_C_HEAP_ARRAY(char, strlen(*value)+1); + new_value = NEW_C_HEAP_ARRAY(char, strlen(*value)+1, mtInternal); strcpy(new_value, *value); } result->set_ccstr(new_value); if (result->origin == DEFAULT && old_value != NULL) { // Prior value is NOT heap allocated, but was a literal constant. - char* old_value_to_free = NEW_C_HEAP_ARRAY(char, strlen(old_value)+1); + char* old_value_to_free = NEW_C_HEAP_ARRAY(char, strlen(old_value)+1, mtInternal); strcpy(old_value_to_free, old_value); old_value = old_value_to_free; } @@ -485,12 +485,12 @@ void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, F Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type"); ccstr old_value = faddr->get_ccstr(); - char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1); + char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1, mtInternal); strcpy(new_value, value); faddr->set_ccstr(new_value); if (faddr->origin != DEFAULT && old_value != NULL) { // Prior value is heap allocated so free it. - FREE_C_HEAP_ARRAY(char, old_value); + FREE_C_HEAP_ARRAY(char, old_value, mtInternal); } faddr->origin = origin; } @@ -511,7 +511,7 @@ void CommandLineFlags::printSetFlags(outputStream* out) { while (flagTable[length].name != NULL) length++; // Sort - Flag** array = NEW_C_HEAP_ARRAY(Flag*, length); + Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal); for (int index = 0; index < length; index++) { array[index] = &flagTable[index]; } @@ -525,7 +525,7 @@ void CommandLineFlags::printSetFlags(outputStream* out) { } } out->cr(); - FREE_C_HEAP_ARRAY(Flag*, array); + FREE_C_HEAP_ARRAY(Flag*, array, mtInternal); } #ifndef PRODUCT @@ -547,7 +547,7 @@ void CommandLineFlags::printFlags(outputStream* out, bool withComments) { while (flagTable[length].name != NULL) length++; // Sort - Flag** array = NEW_C_HEAP_ARRAY(Flag*, length); + Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal); for (int index = 0; index < length; index++) { array[index] = &flagTable[index]; } @@ -560,5 +560,5 @@ void CommandLineFlags::printFlags(outputStream* out, bool withComments) { array[i]->print_on(out, withComments); } } - FREE_C_HEAP_ARRAY(Flag*, array); + FREE_C_HEAP_ARRAY(Flag*, array, mtInternal); } diff --git a/hotspot/src/share/vm/runtime/globals.hpp b/hotspot/src/share/vm/runtime/globals.hpp index a961a151c35..504c4061cc5 100644 --- a/hotspot/src/share/vm/runtime/globals.hpp +++ b/hotspot/src/share/vm/runtime/globals.hpp @@ -190,7 +190,6 @@ define_pd_global(uint64_t,MaxRAM, 1ULL*G); #endif // no compilers - // string type aliases used only in this file typedef const char* ccstr; typedef const char* ccstrlist; // represents string arguments which accumulate @@ -896,6 +895,9 @@ class CommandLineFlags { develop(bool, UseFakeTimers, false, \ "Tells whether the VM should use system time or a fake timer") \ \ + product(ccstr, NativeMemoryTracking, "off", \ + "Native memory tracking options") \ + \ diagnostic(bool, LogCompilation, false, \ "Log compilation activity in detail to hotspot.log or LogFile") \ \ diff --git a/hotspot/src/share/vm/runtime/handles.cpp b/hotspot/src/share/vm/runtime/handles.cpp index 3c24f81ce0d..1ddbacc444b 100644 --- a/hotspot/src/share/vm/runtime/handles.cpp +++ b/hotspot/src/share/vm/runtime/handles.cpp @@ -111,7 +111,7 @@ void HandleMark::initialize(Thread* thread) { _chunk = _area->_chunk; _hwm = _area->_hwm; _max = _area->_max; - NOT_PRODUCT(_size_in_bytes = _area->_size_in_bytes;) + _size_in_bytes = _area->_size_in_bytes; debug_only(_area->_handle_mark_nesting++); assert(_area->_handle_mark_nesting > 0, "must stack allocate HandleMarks"); debug_only(Atomic::inc(&_nof_handlemarks);) @@ -159,7 +159,7 @@ HandleMark::~HandleMark() { area->_chunk = _chunk; area->_hwm = _hwm; area->_max = _max; - NOT_PRODUCT(area->set_size_in_bytes(_size_in_bytes);) + area->set_size_in_bytes(_size_in_bytes); #ifdef ASSERT // clear out first chunk (to detect allocation bugs) if (ZapVMHandleArea) { diff --git a/hotspot/src/share/vm/runtime/handles.hpp b/hotspot/src/share/vm/runtime/handles.hpp index d9d71e67010..e2b2d49713e 100644 --- a/hotspot/src/share/vm/runtime/handles.hpp +++ b/hotspot/src/share/vm/runtime/handles.hpp @@ -238,7 +238,6 @@ DEF_KLASS_HANDLE(constantPoolCacheKlass, oop_is_constantPool ) //------------------------------------------------------------------------------------------------------------------------ // Thread local handle area - class HandleArea: public Arena { friend class HandleMark; friend class NoHandleMark; @@ -312,7 +311,7 @@ class HandleMark { HandleArea *_area; // saved handle area Chunk *_chunk; // saved arena chunk char *_hwm, *_max; // saved arena info - NOT_PRODUCT(size_t _size_in_bytes;) // size of handle area + size_t _size_in_bytes; // size of handle area // Link to previous active HandleMark in thread HandleMark* _previous_handle_mark; diff --git a/hotspot/src/share/vm/runtime/handles.inline.hpp b/hotspot/src/share/vm/runtime/handles.inline.hpp index 3bd42fb2e17..806d66fca9b 100644 --- a/hotspot/src/share/vm/runtime/handles.inline.hpp +++ b/hotspot/src/share/vm/runtime/handles.inline.hpp @@ -85,7 +85,7 @@ inline void HandleMark::pop_and_restore() { area->_chunk = _chunk; area->_hwm = _hwm; area->_max = _max; - NOT_PRODUCT(area->set_size_in_bytes(_size_in_bytes);) + area->set_size_in_bytes(_size_in_bytes); debug_only(area->_handle_mark_nesting--); } diff --git a/hotspot/src/share/vm/runtime/java.cpp b/hotspot/src/share/vm/runtime/java.cpp index f256e515e9c..70c9e2895bc 100644 --- a/hotspot/src/share/vm/runtime/java.cpp +++ b/hotspot/src/share/vm/runtime/java.cpp @@ -384,7 +384,7 @@ extern "C" { typedef void (*__exit_proc)(void); } -class ExitProc : public CHeapObj { +class ExitProc : public CHeapObj { private: __exit_proc _proc; // void (*_proc)(void); diff --git a/hotspot/src/share/vm/runtime/jniHandles.hpp b/hotspot/src/share/vm/runtime/jniHandles.hpp index a3b2f9c4c29..71bb1dd8949 100644 --- a/hotspot/src/share/vm/runtime/jniHandles.hpp +++ b/hotspot/src/share/vm/runtime/jniHandles.hpp @@ -109,7 +109,7 @@ class JNIHandles : AllStatic { // JNI handle blocks holding local/global JNI handles -class JNIHandleBlock : public CHeapObj { +class JNIHandleBlock : public CHeapObj { friend class VMStructs; friend class CppInterpreter; diff --git a/hotspot/src/share/vm/runtime/monitorChunk.cpp b/hotspot/src/share/vm/runtime/monitorChunk.cpp index 1a4be7920e8..f8793fdeaee 100644 --- a/hotspot/src/share/vm/runtime/monitorChunk.cpp +++ b/hotspot/src/share/vm/runtime/monitorChunk.cpp @@ -29,7 +29,7 @@ MonitorChunk::MonitorChunk(int number_on_monitors) { _number_of_monitors = number_on_monitors; - _monitors = NEW_C_HEAP_ARRAY(BasicObjectLock, number_on_monitors); + _monitors = NEW_C_HEAP_ARRAY(BasicObjectLock, number_on_monitors, mtInternal); _next = NULL; } diff --git a/hotspot/src/share/vm/runtime/monitorChunk.hpp b/hotspot/src/share/vm/runtime/monitorChunk.hpp index 66d62438c57..eca92a6b4a7 100644 --- a/hotspot/src/share/vm/runtime/monitorChunk.hpp +++ b/hotspot/src/share/vm/runtime/monitorChunk.hpp @@ -30,7 +30,7 @@ // Data structure for holding monitors for one activation during // deoptimization. -class MonitorChunk: public CHeapObj { +class MonitorChunk: public CHeapObj { private: int _number_of_monitors; BasicObjectLock* _monitors; diff --git a/hotspot/src/share/vm/runtime/mutex.hpp b/hotspot/src/share/vm/runtime/mutex.hpp index 66a3295c857..7d2cd82724f 100644 --- a/hotspot/src/share/vm/runtime/mutex.hpp +++ b/hotspot/src/share/vm/runtime/mutex.hpp @@ -84,7 +84,7 @@ class ParkEvent ; // The default length of monitor name is chosen to be 64 to avoid false sharing. static const int MONITOR_NAME_LEN = 64; -class Monitor : public CHeapObj { +class Monitor : public CHeapObj { public: // A special lock: Is a lock where you are guaranteed not to block while you are diff --git a/hotspot/src/share/vm/runtime/os.cpp b/hotspot/src/share/vm/runtime/os.cpp index 33495d66d43..d9395b3ad0c 100644 --- a/hotspot/src/share/vm/runtime/os.cpp +++ b/hotspot/src/share/vm/runtime/os.cpp @@ -45,6 +45,7 @@ #include "runtime/os.hpp" #include "runtime/stubRoutines.hpp" #include "services/attachListener.hpp" +#include "services/memTracker.hpp" #include "services/threadService.hpp" #include "utilities/defaultStream.hpp" #include "utilities/events.hpp" @@ -433,9 +434,9 @@ void* os::native_java_library() { // --------------------- heap allocation utilities --------------------- -char *os::strdup(const char *str) { +char *os::strdup(const char *str, MEMFLAGS flags) { size_t size = strlen(str); - char *dup_str = (char *)malloc(size + 1); + char *dup_str = (char *)malloc(size + 1, flags); if (dup_str == NULL) return NULL; strcpy(dup_str, str); return dup_str; @@ -559,7 +560,7 @@ void verify_block(void* memblock) { } #endif -void* os::malloc(size_t size) { +void* os::malloc(size_t size, MEMFLAGS memflags, address caller) { NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); @@ -571,6 +572,7 @@ void* os::malloc(size_t size) { NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); u_char* ptr = (u_char*)::malloc(size + space_before + space_after); + #ifdef ASSERT if (ptr == NULL) return NULL; if (MallocCushion) { @@ -589,18 +591,29 @@ void* os::malloc(size_t size) { } debug_only(if (paranoid) verify_block(memblock)); if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock); + + // we do not track MallocCushion memory + if (MemTracker::is_on()) { + MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller); + } + return memblock; } -void* os::realloc(void *memblock, size_t size) { +void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) { #ifndef ASSERT NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); - return ::realloc(memblock, size); + void* ptr = ::realloc(memblock, size); + if (ptr != NULL && MemTracker::is_on()) { + MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags, + caller == 0 ? CALLER_PC : caller); + } + return ptr; #else if (memblock == NULL) { - return malloc(size); + return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller)); } if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { tty->print_cr("os::realloc caught " PTR_FORMAT, memblock); @@ -610,7 +623,7 @@ void* os::realloc(void *memblock, size_t size) { NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); if (size == 0) return NULL; // always move the block - void* ptr = malloc(size); + void* ptr = malloc(size, memflags, caller == 0 ? CALLER_PC : caller); if (PrintMalloc) tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr); // Copy to new memory if malloc didn't fail if ( ptr != NULL ) { @@ -627,7 +640,7 @@ void* os::realloc(void *memblock, size_t size) { } -void os::free(void *memblock) { +void os::free(void *memblock, MEMFLAGS memflags) { NOT_PRODUCT(inc_stat_counter(&num_frees, 1)); #ifdef ASSERT if (memblock == NULL) return; @@ -660,6 +673,8 @@ void os::free(void *memblock) { fprintf(stderr, "os::free " PTR_FORMAT "\n", (uintptr_t)memblock); } #endif + MemTracker::record_free((address)memblock, memflags); + ::free((char*)memblock - space_before); } @@ -1048,7 +1063,7 @@ char* os::format_boot_path(const char* format_string, ++formatted_path_len; } - char* formatted_path = NEW_C_HEAP_ARRAY(char, formatted_path_len + 1); + char* formatted_path = NEW_C_HEAP_ARRAY(char, formatted_path_len + 1, mtInternal); if (formatted_path == NULL) { return NULL; } @@ -1127,7 +1142,7 @@ char** os::split_path(const char* path, int* n) { return NULL; } const char psepchar = *os::path_separator(); - char* inpath = (char*)NEW_C_HEAP_ARRAY(char, strlen(path) + 1); + char* inpath = (char*)NEW_C_HEAP_ARRAY(char, strlen(path) + 1, mtInternal); if (inpath == NULL) { return NULL; } @@ -1140,7 +1155,7 @@ char** os::split_path(const char* path, int* n) { p++; p = strchr(p, psepchar); } - char** opath = (char**) NEW_C_HEAP_ARRAY(char*, count); + char** opath = (char**) NEW_C_HEAP_ARRAY(char*, count, mtInternal); if (opath == NULL) { return NULL; } @@ -1153,7 +1168,7 @@ char** os::split_path(const char* path, int* n) { return NULL; } // allocate the string and add terminator storage - char* s = (char*)NEW_C_HEAP_ARRAY(char, len + 1); + char* s = (char*)NEW_C_HEAP_ARRAY(char, len + 1, mtInternal); if (s == NULL) { return NULL; } @@ -1162,7 +1177,7 @@ char** os::split_path(const char* path, int* n) { opath[i] = s; p += len + 1; } - FREE_C_HEAP_ARRAY(char, inpath); + FREE_C_HEAP_ARRAY(char, inpath, mtInternal); *n = count; return opath; } @@ -1366,3 +1381,97 @@ int os::get_line_chars(int fd, char* buf, const size_t bsize){ return (int) i; } + +bool os::create_stack_guard_pages(char* addr, size_t bytes) { + return os::pd_create_stack_guard_pages(addr, bytes); +} + + +char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { + char* result = pd_reserve_memory(bytes, addr, alignment_hint); + if (result != NULL && MemTracker::is_on()) { + MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); + } + + return result; +} +char* os::attempt_reserve_memory_at(size_t bytes, char* addr) { + char* result = pd_attempt_reserve_memory_at(bytes, addr); + if (result != NULL && MemTracker::is_on()) { + MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); + } + return result; +} + +void os::split_reserved_memory(char *base, size_t size, + size_t split, bool realloc) { + pd_split_reserved_memory(base, size, split, realloc); +} + +bool os::commit_memory(char* addr, size_t bytes, bool executable) { + bool res = pd_commit_memory(addr, bytes, executable); + if (res && MemTracker::is_on()) { + MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC); + } + return res; +} + +bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, + bool executable) { + bool res = os::pd_commit_memory(addr, size, alignment_hint, executable); + if (res && MemTracker::is_on()) { + MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC); + } + return res; +} + +bool os::uncommit_memory(char* addr, size_t bytes) { + bool res = pd_uncommit_memory(addr, bytes); + if (res) { + MemTracker::record_virtual_memory_uncommit((address)addr, bytes); + } + return res; +} + +bool os::release_memory(char* addr, size_t bytes) { + bool res = pd_release_memory(addr, bytes); + if (res) { + MemTracker::record_virtual_memory_release((address)addr, bytes); + } + return res; +} + + +char* os::map_memory(int fd, const char* file_name, size_t file_offset, + char *addr, size_t bytes, bool read_only, + bool allow_exec) { + char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec); + if (result != NULL && MemTracker::is_on()) { + MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); + } + return result; +} + +char* os::remap_memory(int fd, const char* file_name, size_t file_offset, + char *addr, size_t bytes, bool read_only, + bool allow_exec) { + return pd_remap_memory(fd, file_name, file_offset, addr, bytes, + read_only, allow_exec); +} + +bool os::unmap_memory(char *addr, size_t bytes) { + bool result = pd_unmap_memory(addr, bytes); + if (result) { + MemTracker::record_virtual_memory_release((address)addr, bytes); + } + return result; +} + +void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { + pd_free_memory(addr, bytes, alignment_hint); +} + +void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { + pd_realign_memory(addr, bytes, alignment_hint); +} + diff --git a/hotspot/src/share/vm/runtime/os.hpp b/hotspot/src/share/vm/runtime/os.hpp index 68f8a3ab62a..3be7248a911 100644 --- a/hotspot/src/share/vm/runtime/os.hpp +++ b/hotspot/src/share/vm/runtime/os.hpp @@ -99,6 +99,28 @@ class os: AllStatic { _page_sizes[1] = 0; // sentinel } + static char* pd_reserve_memory(size_t bytes, char* addr = 0, + size_t alignment_hint = 0); + static char* pd_attempt_reserve_memory_at(size_t bytes, char* addr); + static void pd_split_reserved_memory(char *base, size_t size, + size_t split, bool realloc); + static bool pd_commit_memory(char* addr, size_t bytes, bool executable = false); + static bool pd_commit_memory(char* addr, size_t size, size_t alignment_hint, + bool executable = false); + static bool pd_uncommit_memory(char* addr, size_t bytes); + static bool pd_release_memory(char* addr, size_t bytes); + + static char* pd_map_memory(int fd, const char* file_name, size_t file_offset, + char *addr, size_t bytes, bool read_only = false, + bool allow_exec = false); + static char* pd_remap_memory(int fd, const char* file_name, size_t file_offset, + char *addr, size_t bytes, bool read_only, + bool allow_exec); + static bool pd_unmap_memory(char *addr, size_t bytes); + static void pd_free_memory(char *addr, size_t bytes, size_t alignment_hint); + static void pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint); + + public: static void init(void); // Called before command line parsing static jint init_2(void); // Called after command line parsing @@ -236,8 +258,7 @@ class os: AllStatic { static char* attempt_reserve_memory_at(size_t bytes, char* addr); static void split_reserved_memory(char *base, size_t size, size_t split, bool realloc); - static bool commit_memory(char* addr, size_t bytes, - bool executable = false); + static bool commit_memory(char* addr, size_t bytes, bool executable = false); static bool commit_memory(char* addr, size_t size, size_t alignment_hint, bool executable = false); static bool uncommit_memory(char* addr, size_t bytes); @@ -250,6 +271,7 @@ class os: AllStatic { static bool guard_memory(char* addr, size_t bytes); static bool unguard_memory(char* addr, size_t bytes); static bool create_stack_guard_pages(char* addr, size_t bytes); + static bool pd_create_stack_guard_pages(char* addr, size_t bytes); static bool remove_stack_guard_pages(char* addr, size_t bytes); static char* map_memory(int fd, const char* file_name, size_t file_offset, @@ -573,12 +595,15 @@ class os: AllStatic { static void* thread_local_storage_at(int index); static void free_thread_local_storage(int index); + // Stack walk + static address get_caller_pc(int n = 0); + // General allocation (must be MT-safe) - static void* malloc (size_t size); - static void* realloc (void *memblock, size_t size); - static void free (void *memblock); + static void* malloc (size_t size, MEMFLAGS flags, address caller_pc = 0); + static void* realloc (void *memblock, size_t size, MEMFLAGS flags, address caller_pc = 0); + static void free (void *memblock, MEMFLAGS flags = mtNone); static bool check_heap(bool force = false); // verify C heap integrity - static char* strdup(const char *); // Like strdup + static char* strdup(const char *, MEMFLAGS flags = mtInternal); // Like strdup #ifndef PRODUCT static julong num_mallocs; // # of calls to malloc/realloc diff --git a/hotspot/src/share/vm/runtime/osThread.hpp b/hotspot/src/share/vm/runtime/osThread.hpp index c0f2b1932c9..1dfcb376163 100644 --- a/hotspot/src/share/vm/runtime/osThread.hpp +++ b/hotspot/src/share/vm/runtime/osThread.hpp @@ -58,7 +58,7 @@ enum ThreadState { // the main thread into its own Thread at will. -class OSThread: public CHeapObj { +class OSThread: public CHeapObj { friend class VMStructs; private: OSThreadStartFunc _start_proc; // Thread start routine diff --git a/hotspot/src/share/vm/runtime/park.cpp b/hotspot/src/share/vm/runtime/park.cpp index 1be5733321a..8d91d0b6887 100644 --- a/hotspot/src/share/vm/runtime/park.cpp +++ b/hotspot/src/share/vm/runtime/park.cpp @@ -141,7 +141,7 @@ void ParkEvent::Release (ParkEvent * ev) { // although Niagara's hash function should help. void * ParkEvent::operator new (size_t sz) { - return (void *) ((intptr_t (CHeapObj::operator new (sz + 256)) + 256) & -256) ; + return (void *) ((intptr_t (AllocateHeap(sz + 256, mtInternal, CALLER_PC)) + 256) & -256) ; } void ParkEvent::operator delete (void * a) { diff --git a/hotspot/src/share/vm/runtime/perfData.cpp b/hotspot/src/share/vm/runtime/perfData.cpp index 04631ec260b..3d4bf2da8a4 100644 --- a/hotspot/src/share/vm/runtime/perfData.cpp +++ b/hotspot/src/share/vm/runtime/perfData.cpp @@ -81,7 +81,7 @@ PerfData::PerfData(CounterNS ns, const char* name, Units u, Variability v) const char* prefix = PerfDataManager::ns_to_string(ns); - _name = NEW_C_HEAP_ARRAY(char, strlen(name) + strlen(prefix) + 2); + _name = NEW_C_HEAP_ARRAY(char, strlen(name) + strlen(prefix) + 2, mtInternal); assert(_name != NULL && strlen(name) != 0, "invalid name"); if (ns == NULL_NS) { @@ -111,10 +111,10 @@ PerfData::PerfData(CounterNS ns, const char* name, Units u, Variability v) PerfData::~PerfData() { if (_name != NULL) { - FREE_C_HEAP_ARRAY(char, _name); + FREE_C_HEAP_ARRAY(char, _name, mtInternal); } if (is_on_c_heap()) { - FREE_C_HEAP_ARRAY(PerfDataEntry, _pdep); + FREE_C_HEAP_ARRAY(PerfDataEntry, _pdep, mtInternal); } } @@ -137,7 +137,7 @@ void PerfData::create_entry(BasicType dtype, size_t dsize, size_t vlen) { if (psmp == NULL) { // out of PerfMemory memory resources. allocate on the C heap // to avoid vm termination. - psmp = NEW_C_HEAP_ARRAY(char, size); + psmp = NEW_C_HEAP_ARRAY(char, size, mtInternal); _on_c_heap = true; } @@ -559,12 +559,12 @@ PerfLongCounter* PerfDataManager::create_long_counter(CounterNS ns, PerfDataList::PerfDataList(int length) { - _set = new(ResourceObj::C_HEAP) PerfDataArray(length, true); + _set = new(ResourceObj::C_HEAP, mtInternal) PerfDataArray(length, true); } PerfDataList::PerfDataList(PerfDataList* p) { - _set = new(ResourceObj::C_HEAP) PerfDataArray(p->length(), true); + _set = new(ResourceObj::C_HEAP, mtInternal) PerfDataArray(p->length(), true); _set->appendAll(p->get_impl()); } diff --git a/hotspot/src/share/vm/runtime/perfData.hpp b/hotspot/src/share/vm/runtime/perfData.hpp index 2f84ee62008..2552fe8badb 100644 --- a/hotspot/src/share/vm/runtime/perfData.hpp +++ b/hotspot/src/share/vm/runtime/perfData.hpp @@ -240,7 +240,7 @@ enum CounterNS { * be removed from the product in the future. * */ -class PerfData : public CHeapObj { +class PerfData : public CHeapObj { friend class StatSampler; // for access to protected void sample() friend class PerfDataManager; // for access to protected destructor @@ -342,7 +342,7 @@ class PerfData : public CHeapObj { * invoke the take_sample() method and write the value returned to its * appropriate location in the PerfData memory region. */ -class PerfLongSampleHelper : public CHeapObj { +class PerfLongSampleHelper : public CHeapObj { public: virtual jlong take_sample() = 0; }; @@ -591,7 +591,7 @@ class PerfStringVariable : public PerfString { * some other implementation, as long as that implementation provides * a mechanism to iterate over the container by index. */ -class PerfDataList : public CHeapObj { +class PerfDataList : public CHeapObj { private: diff --git a/hotspot/src/share/vm/runtime/perfMemory.cpp b/hotspot/src/share/vm/runtime/perfMemory.cpp index 0855b38c97f..26ef55e5f58 100644 --- a/hotspot/src/share/vm/runtime/perfMemory.cpp +++ b/hotspot/src/share/vm/runtime/perfMemory.cpp @@ -112,7 +112,7 @@ void PerfMemory::initialize() { warning("Could not create PerfData Memory region, reverting to malloc"); } - _prologue = NEW_C_HEAP_OBJ(PerfDataPrologue); + _prologue = NEW_C_HEAP_OBJ(PerfDataPrologue, mtInternal); } else { @@ -244,10 +244,10 @@ char* PerfMemory::get_perfdata_file_path() { if (PerfDataSaveFile != NULL) { // dest_file_name stores the validated file name if file_name // contains %p which will be replaced by pid. - dest_file = NEW_C_HEAP_ARRAY(char, JVM_MAXPATHLEN); + dest_file = NEW_C_HEAP_ARRAY(char, JVM_MAXPATHLEN, mtInternal); if(!Arguments::copy_expand_pid(PerfDataSaveFile, strlen(PerfDataSaveFile), dest_file, JVM_MAXPATHLEN)) { - FREE_C_HEAP_ARRAY(char, dest_file); + FREE_C_HEAP_ARRAY(char, dest_file, mtInternal); if (PrintMiscellaneous && Verbose) { warning("Invalid performance data file path name specified, "\ "fall back to a default name"); @@ -257,7 +257,7 @@ char* PerfMemory::get_perfdata_file_path() { } } // create the name of the file for retaining the instrumentation memory. - dest_file = NEW_C_HEAP_ARRAY(char, PERFDATA_FILENAME_LEN); + dest_file = NEW_C_HEAP_ARRAY(char, PERFDATA_FILENAME_LEN, mtInternal); jio_snprintf(dest_file, PERFDATA_FILENAME_LEN, "%s_%d", PERFDATA_NAME, os::current_process_id()); diff --git a/hotspot/src/share/vm/runtime/reflectionUtils.cpp b/hotspot/src/share/vm/runtime/reflectionUtils.cpp index 6c6e8c361b6..e8a986ab346 100644 --- a/hotspot/src/share/vm/runtime/reflectionUtils.cpp +++ b/hotspot/src/share/vm/runtime/reflectionUtils.cpp @@ -59,7 +59,7 @@ bool KlassStream::eos() { GrowableArray *FilteredFieldsMap::_filtered_fields = - new (ResourceObj::C_HEAP) GrowableArray(3,true); + new (ResourceObj::C_HEAP, mtInternal) GrowableArray(3,true); void FilteredFieldsMap::initialize() { diff --git a/hotspot/src/share/vm/runtime/safepoint.cpp b/hotspot/src/share/vm/runtime/safepoint.cpp index c29d257cc3f..31b33e320ec 100644 --- a/hotspot/src/share/vm/runtime/safepoint.cpp +++ b/hotspot/src/share/vm/runtime/safepoint.cpp @@ -48,6 +48,7 @@ #include "runtime/stubRoutines.hpp" #include "runtime/sweeper.hpp" #include "runtime/synchronizer.hpp" +#include "services/memTracker.hpp" #include "services/runtimeService.hpp" #include "utilities/events.hpp" #ifdef TARGET_ARCH_x86 @@ -546,6 +547,10 @@ void SafepointSynchronize::do_cleanup_tasks() { if (UseGCLogFileRotation) { gclog_or_tty->rotate_log(); } + + if (MemTracker::is_on()) { + MemTracker::sync(); + } } @@ -1157,7 +1162,7 @@ void SafepointSynchronize::deferred_initialize_stat() { stats_array_size = PrintSafepointStatisticsCount; } _safepoint_stats = (SafepointStats*)os::malloc(stats_array_size - * sizeof(SafepointStats)); + * sizeof(SafepointStats), mtInternal); guarantee(_safepoint_stats != NULL, "not enough memory for safepoint instrumentation data"); diff --git a/hotspot/src/share/vm/runtime/safepoint.hpp b/hotspot/src/share/vm/runtime/safepoint.hpp index 71255a27d48..005ea4d0360 100644 --- a/hotspot/src/share/vm/runtime/safepoint.hpp +++ b/hotspot/src/share/vm/runtime/safepoint.hpp @@ -190,7 +190,7 @@ public: }; // State class for a thread suspended at a safepoint -class ThreadSafepointState: public CHeapObj { +class ThreadSafepointState: public CHeapObj { public: // These states are maintained by VM thread while threads are being brought // to a safepoint. After SafepointSynchronize::end(), they are reset to diff --git a/hotspot/src/share/vm/runtime/sharedRuntime.cpp b/hotspot/src/share/vm/runtime/sharedRuntime.cpp index 503ad0719fd..7c74f493008 100644 --- a/hotspot/src/share/vm/runtime/sharedRuntime.cpp +++ b/hotspot/src/share/vm/runtime/sharedRuntime.cpp @@ -2117,7 +2117,7 @@ void SharedRuntime::print_call_statistics(int comp_total) { // A simple wrapper class around the calling convention information // that allows sharing of adapters for the same calling convention. -class AdapterFingerPrint : public CHeapObj { +class AdapterFingerPrint : public CHeapObj { private: union { int _compact[3]; @@ -2174,7 +2174,7 @@ class AdapterFingerPrint : public CHeapObj { ptr = _value._compact; } else { _length = len; - _value._fingerprint = NEW_C_HEAP_ARRAY(int, _length); + _value._fingerprint = NEW_C_HEAP_ARRAY(int, _length, mtCode); ptr = _value._fingerprint; } @@ -2193,7 +2193,7 @@ class AdapterFingerPrint : public CHeapObj { ~AdapterFingerPrint() { if (_length > 0) { - FREE_C_HEAP_ARRAY(int, _value._fingerprint); + FREE_C_HEAP_ARRAY(int, _value._fingerprint, mtCode); } } @@ -2251,7 +2251,7 @@ class AdapterFingerPrint : public CHeapObj { // A hashtable mapping from AdapterFingerPrints to AdapterHandlerEntries -class AdapterHandlerTable : public BasicHashtable { +class AdapterHandlerTable : public BasicHashtable { friend class AdapterHandlerTableIterator; private: @@ -2265,16 +2265,16 @@ class AdapterHandlerTable : public BasicHashtable { #endif AdapterHandlerEntry* bucket(int i) { - return (AdapterHandlerEntry*)BasicHashtable::bucket(i); + return (AdapterHandlerEntry*)BasicHashtable::bucket(i); } public: AdapterHandlerTable() - : BasicHashtable(293, sizeof(AdapterHandlerEntry)) { } + : BasicHashtable(293, sizeof(AdapterHandlerEntry)) { } // Create a new entry suitable for insertion in the table AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry, address c2i_unverified_entry) { - AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable::new_entry(fingerprint->compute_hash()); + AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable::new_entry(fingerprint->compute_hash()); entry->init(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry); return entry; } @@ -2287,7 +2287,7 @@ class AdapterHandlerTable : public BasicHashtable { void free_entry(AdapterHandlerEntry* entry) { entry->deallocate(); - BasicHashtable::free_entry(entry); + BasicHashtable::free_entry(entry); } // Find a entry with the same fingerprint if it exists @@ -2572,8 +2572,8 @@ void AdapterHandlerEntry::relocate(address new_base) { void AdapterHandlerEntry::deallocate() { delete _fingerprint; #ifdef ASSERT - if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code); - if (_saved_sig) FREE_C_HEAP_ARRAY(Basictype, _saved_sig); + if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code, mtCode); + if (_saved_sig) FREE_C_HEAP_ARRAY(Basictype, _saved_sig, mtCode); #endif } @@ -2583,11 +2583,11 @@ void AdapterHandlerEntry::deallocate() { // against other versions. If the code is captured after relocation // then relative instructions won't be equivalent. void AdapterHandlerEntry::save_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) { - _saved_code = NEW_C_HEAP_ARRAY(unsigned char, length); + _saved_code = NEW_C_HEAP_ARRAY(unsigned char, length, mtCode); _code_length = length; memcpy(_saved_code, buffer, length); _total_args_passed = total_args_passed; - _saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed); + _saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed, mtCode); memcpy(_saved_sig, sig_bt, _total_args_passed * sizeof(BasicType)); } @@ -2893,7 +2893,7 @@ JRT_LEAF(intptr_t*, SharedRuntime::OSR_migration_begin( JavaThread *thread) ) int max_locals = moop->max_locals(); // Allocate temp buffer, 1 word per local & 2 per active monitor int buf_size_words = max_locals + active_monitor_count*2; - intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words); + intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words, mtCode); // Copy the locals. Order is preserved so that loading of longs works. // Since there's no GC I can copy the oops blindly. @@ -2923,7 +2923,7 @@ JRT_LEAF(intptr_t*, SharedRuntime::OSR_migration_begin( JavaThread *thread) ) JRT_END JRT_LEAF(void, SharedRuntime::OSR_migration_end( intptr_t* buf) ) - FREE_C_HEAP_ARRAY(intptr_t,buf); + FREE_C_HEAP_ARRAY(intptr_t,buf, mtCode); JRT_END bool AdapterHandlerLibrary::contains(CodeBlob* b) { diff --git a/hotspot/src/share/vm/runtime/sharedRuntime.hpp b/hotspot/src/share/vm/runtime/sharedRuntime.hpp index 9650c6e11c7..cb955c46db2 100644 --- a/hotspot/src/share/vm/runtime/sharedRuntime.hpp +++ b/hotspot/src/share/vm/runtime/sharedRuntime.hpp @@ -610,7 +610,7 @@ class SharedRuntime: AllStatic { // used by the adapters. The code generation happens here because it's very // similar to what the adapters have to do. -class AdapterHandlerEntry : public BasicHashtableEntry { +class AdapterHandlerEntry : public BasicHashtableEntry { friend class AdapterHandlerTable; private: @@ -656,7 +656,7 @@ class AdapterHandlerEntry : public BasicHashtableEntry { AdapterFingerPrint* fingerprint() { return _fingerprint; } AdapterHandlerEntry* next() { - return (AdapterHandlerEntry*)BasicHashtableEntry::next(); + return (AdapterHandlerEntry*)BasicHashtableEntry::next(); } #ifdef ASSERT diff --git a/hotspot/src/share/vm/runtime/stubCodeGenerator.hpp b/hotspot/src/share/vm/runtime/stubCodeGenerator.hpp index bc81f5a30ec..3fb5161f8fa 100644 --- a/hotspot/src/share/vm/runtime/stubCodeGenerator.hpp +++ b/hotspot/src/share/vm/runtime/stubCodeGenerator.hpp @@ -36,7 +36,7 @@ // Currently, code descriptors are simply chained in a linked list, // this may have to change if searching becomes too slow. -class StubCodeDesc: public CHeapObj { +class StubCodeDesc: public CHeapObj { protected: static StubCodeDesc* _list; // the list of all descriptors static int _count; // length of list diff --git a/hotspot/src/share/vm/runtime/sweeper.cpp b/hotspot/src/share/vm/runtime/sweeper.cpp index 7f8561b6b3b..2dea6d7ba7c 100644 --- a/hotspot/src/share/vm/runtime/sweeper.cpp +++ b/hotspot/src/share/vm/runtime/sweeper.cpp @@ -228,7 +228,7 @@ void NMethodSweeper::possibly_sweep() { #ifdef ASSERT if (LogSweeper && _records == NULL) { // Create the ring buffer for the logging code - _records = NEW_C_HEAP_ARRAY(SweeperRecord, SweeperLogEntries); + _records = NEW_C_HEAP_ARRAY(SweeperRecord, SweeperLogEntries, mtGC); memset(_records, 0, sizeof(SweeperRecord) * SweeperLogEntries); } #endif diff --git a/hotspot/src/share/vm/runtime/task.hpp b/hotspot/src/share/vm/runtime/task.hpp index 2357e835fb0..206442d765b 100644 --- a/hotspot/src/share/vm/runtime/task.hpp +++ b/hotspot/src/share/vm/runtime/task.hpp @@ -35,7 +35,7 @@ // ... // pf.disenroll(); -class PeriodicTask: public CHeapObj { +class PeriodicTask: public CHeapObj { public: // Useful constants. // The interval constants are used to ensure the declared interval diff --git a/hotspot/src/share/vm/runtime/thread.cpp b/hotspot/src/share/vm/runtime/thread.cpp index 76865f6ff2c..13f617db25f 100644 --- a/hotspot/src/share/vm/runtime/thread.cpp +++ b/hotspot/src/share/vm/runtime/thread.cpp @@ -73,6 +73,7 @@ #include "runtime/vm_operations.hpp" #include "services/attachListener.hpp" #include "services/management.hpp" +#include "services/memTracker.hpp" #include "services/threadService.hpp" #include "trace/traceEventTypes.hpp" #include "utilities/defaultStream.hpp" @@ -159,6 +160,7 @@ HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t, #endif // ndef DTRACE_ENABLED + // Class hierarchy // - Thread // - VMThread @@ -168,13 +170,13 @@ HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t, // - CompilerThread // ======= Thread ======== - // Support for forcing alignment of thread objects for biased locking -void* Thread::operator new(size_t size) { +void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) { if (UseBiasedLocking) { const int alignment = markOopDesc::biased_lock_alignment; size_t aligned_size = size + (alignment - sizeof(intptr_t)); - void* real_malloc_addr = CHeapObj::operator new(aligned_size); + void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC) + : os::malloc(aligned_size, flags, CURRENT_PC); void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment); assert(((uintptr_t) aligned_addr + (uintptr_t) size) <= ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size), @@ -187,16 +189,17 @@ void* Thread::operator new(size_t size) { ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr; return aligned_addr; } else { - return CHeapObj::operator new(size); + return throw_excpt? AllocateHeap(size, flags, CURRENT_PC) + : os::malloc(size, flags, CURRENT_PC); } } void Thread::operator delete(void* p) { if (UseBiasedLocking) { void* real_malloc_addr = ((Thread*) p)->_real_malloc_address; - CHeapObj::operator delete(real_malloc_addr); + FreeHeap(real_malloc_addr, mtThread); } else { - CHeapObj::operator delete(p); + FreeHeap(p, mtThread); } } @@ -214,8 +217,8 @@ Thread::Thread() { // allocated data structures set_osthread(NULL); - set_resource_area(new ResourceArea()); - set_handle_area(new HandleArea(NULL)); + set_resource_area(new (mtThread)ResourceArea()); + set_handle_area(new (mtThread) HandleArea(NULL)); set_active_handles(NULL); set_free_handle_block(NULL); set_last_handle_mark(NULL); @@ -306,12 +309,17 @@ void Thread::initialize_thread_local_storage() { // set up any platform-specific state. os::initialize_thread(); - } void Thread::record_stack_base_and_size() { set_stack_base(os::current_stack_base()); set_stack_size(os::current_stack_size()); + + // record thread's native stack, stack grows downward + address vm_base = _stack_base - _stack_size; + MemTracker::record_virtual_memory_reserve(vm_base, _stack_size, + CURRENT_PC, this); + MemTracker::record_virtual_memory_type(vm_base, mtThreadStack); } @@ -319,6 +327,9 @@ Thread::~Thread() { // Reclaim the objectmonitors from the omFreeList of the moribund thread. ObjectSynchronizer::omFlush (this) ; + MemTracker::record_virtual_memory_release((_stack_base - _stack_size), + _stack_size, this); + // deallocate data structures delete resource_area(); // since the handle marks are using the handle area, we have to deallocated the root @@ -1105,14 +1116,14 @@ NamedThread::NamedThread() : Thread() { NamedThread::~NamedThread() { if (_name != NULL) { - FREE_C_HEAP_ARRAY(char, _name); + FREE_C_HEAP_ARRAY(char, _name, mtThread); _name = NULL; } } void NamedThread::set_name(const char* format, ...) { guarantee(_name == NULL, "Only get to set name once."); - _name = NEW_C_HEAP_ARRAY(char, max_name_len); + _name = NEW_C_HEAP_ARRAY(char, max_name_len, mtThread); guarantee(_name != NULL, "alloc failure"); va_list ap; va_start(ap, format); @@ -1295,6 +1306,7 @@ void JavaThread::initialize() { set_monitor_chunks(NULL); set_next(NULL); set_thread_state(_thread_new); + set_recorder(NULL); _terminated = _not_terminated; _privileged_stack_top = NULL; _array_for_gc = NULL; @@ -1370,6 +1382,7 @@ JavaThread::JavaThread(bool is_attaching_via_jni) : _jni_attach_state = _not_attaching_via_jni; } assert(_deferred_card_mark.is_empty(), "Default MemRegion ctor"); + _safepoint_visible = false; } bool JavaThread::reguard_stack(address cur_sp) { @@ -1432,7 +1445,7 @@ JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) : thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread : os::java_thread; os::create_thread(this, thr_type, stack_sz); - + _safepoint_visible = false; // The _osthread may be NULL here because we ran out of memory (too many threads active). // We need to throw and OutOfMemoryError - however we cannot do this here because the caller // may hold a lock and all locks must be unlocked before throwing the exception (throwing @@ -1450,6 +1463,11 @@ JavaThread::~JavaThread() { tty->print_cr("terminate thread %p", this); } + // Info NMT that this JavaThread is exiting, its memory + // recorder should be collected + assert(!is_safepoint_visible(), "wrong state"); + MemTracker::thread_exiting(this); + // JSR166 -- return the parker to the free list Parker::Release(_parker); _parker = NULL ; @@ -2892,7 +2910,7 @@ void JavaThread::print_stack_on(outputStream* st) { void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) { assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments"); if (in_bytes(size_in_bytes) != 0) { - _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes)); + _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes), mtThread); _popframe_preserved_args_size = in_bytes(size_in_bytes); Copy::conjoint_jbytes(start, _popframe_preserved_args, _popframe_preserved_args_size); } @@ -2914,7 +2932,7 @@ WordSize JavaThread::popframe_preserved_args_size_in_words() { void JavaThread::popframe_free_preserved_args() { assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice"); - FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args); + FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args, mtThread); _popframe_preserved_args = NULL; _popframe_preserved_args_size = 0; } @@ -3163,6 +3181,14 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { jint os_init_2_result = os::init_2(); if (os_init_2_result != JNI_OK) return os_init_2_result; + // intialize TLS + ThreadLocalStorage::init(); + + // Bootstrap native memory tracking, so it can start recording memory + // activities before worker thread is started. This is the first phase + // of bootstrapping, VM is currently running in single-thread mode. + MemTracker::bootstrap_single_thread(); + // Initialize output stream logging ostream_init_log(); @@ -3182,9 +3208,6 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { _number_of_threads = 0; _number_of_non_daemon_threads = 0; - // Initialize TLS - ThreadLocalStorage::init(); - // Initialize global data structures and create system classes in heap vm_init_globals(); @@ -3216,6 +3239,9 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { // Initialize Java-Level synchronization subsystem ObjectMonitor::Initialize() ; + // Second phase of bootstrapping, VM is about entering multi-thread mode + MemTracker::bootstrap_multi_thread(); + // Initialize global modules jint status = init_globals(); if (status != JNI_OK) { @@ -3243,6 +3269,9 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { Universe::verify(); // make sure we're starting with a clean slate } + // Fully start NMT + MemTracker::start(); + // Create the VMThread { TraceTime timer("Start VMThread", TraceStartupTime); VMThread::create(); @@ -3544,11 +3573,11 @@ static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_sym if (library == NULL) { const char *sub_msg = " in absolute path, with error: "; size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1; - char *buf = NEW_C_HEAP_ARRAY(char, len); + char *buf = NEW_C_HEAP_ARRAY(char, len, mtThread); jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); // If we can't find the agent, exit. vm_exit_during_initialization(buf, NULL); - FREE_C_HEAP_ARRAY(char, buf); + FREE_C_HEAP_ARRAY(char, buf, mtThread); } } else { // Try to load the agent from the standard dll directory @@ -3562,7 +3591,7 @@ static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_sym const char *fmt = "%s/bin/java %s -Dkernel.background.download=false" " sun.jkernel.DownloadManager -download client_jvm"; size_t length = strlen(props) + strlen(home) + strlen(fmt) + 1; - char *cmd = NEW_C_HEAP_ARRAY(char, length); + char *cmd = NEW_C_HEAP_ARRAY(char, length, mtThread); jio_snprintf(cmd, length, fmt, home, props); int status = os::fork_and_exec(cmd); FreeHeap(props); @@ -3571,7 +3600,7 @@ static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_sym vm_exit_during_initialization("fork_and_exec failed: %s", strerror(errno)); } - FREE_C_HEAP_ARRAY(char, cmd); + FREE_C_HEAP_ARRAY(char, cmd, mtThread); // when this comes back the instrument.dll should be where it belongs. library = os::dll_load(buffer, ebuf, sizeof ebuf); } @@ -3583,11 +3612,11 @@ static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_sym if (library == NULL) { const char *sub_msg = " on the library path, with error: "; size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1; - char *buf = NEW_C_HEAP_ARRAY(char, len); + char *buf = NEW_C_HEAP_ARRAY(char, len, mtThread); jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); // If we can't find the agent, exit. vm_exit_during_initialization(buf, NULL); - FREE_C_HEAP_ARRAY(char, buf); + FREE_C_HEAP_ARRAY(char, buf, mtThread); } } } @@ -3756,6 +3785,7 @@ void JavaThread::invoke_shutdown_hooks() { // and VM_Exit op at VM level. // // Shutdown sequence: +// + Shutdown native memory tracking if it is on // + Wait until we are the last non-daemon thread to execute // <-- every thing is still working at this moment --> // + Call java.lang.Shutdown.shutdown(), which will invoke Java level @@ -3801,6 +3831,10 @@ bool Threads::destroy_vm() { Mutex::_as_suspend_equivalent_flag); } + // Shutdown NMT before exit. Otherwise, + // it will run into trouble when system destroys static variables. + MemTracker::shutdown(MemTracker::NMT_normal); + // Hang forever on exit if we are reporting an error. if (ShowMessageBoxOnError && is_error_reported()) { os::infinite_sleep(); @@ -3907,6 +3941,8 @@ void Threads::add(JavaThread* p, bool force_daemon) { daemon = false; } + p->set_safepoint_visible(true); + ThreadService::add_thread(p, daemon); // Possible GC point. @@ -3952,6 +3988,10 @@ void Threads::remove(JavaThread* p) { // to do callbacks into the safepoint code. However, the safepoint code is not aware // of this thread since it is removed from the queue. p->set_terminated_value(); + + // Now, this thread is not visible to safepoint + p->set_safepoint_visible(false); + } // unlock Threads_lock // Since Events::log uses a lock, we grab it outside the Threads_lock diff --git a/hotspot/src/share/vm/runtime/thread.hpp b/hotspot/src/share/vm/runtime/thread.hpp index 7846cc07058..a375f264ff8 100644 --- a/hotspot/src/share/vm/runtime/thread.hpp +++ b/hotspot/src/share/vm/runtime/thread.hpp @@ -41,6 +41,7 @@ #include "runtime/stubRoutines.hpp" #include "runtime/threadLocalStorage.hpp" #include "runtime/unhandledOops.hpp" +#include "services/memRecorder.hpp" #include "trace/tracing.hpp" #include "utilities/exceptions.hpp" #include "utilities/top.hpp" @@ -100,12 +101,16 @@ class Thread: public ThreadShadow { //oop _pending_exception; // pending exception for current thread // const char* _exception_file; // file information for exception (debugging only) // int _exception_line; // line information for exception (debugging only) - + protected: // Support for forcing alignment of thread objects for biased locking void* _real_malloc_address; public: - void* operator new(size_t size); + void* operator new(size_t size) { return allocate(size, true); } + void* operator new(size_t size, std::nothrow_t& nothrow_constant) { return allocate(size, false); } void operator delete(void* p); + + protected: + static void* allocate(size_t size, bool throw_excpt, MEMFLAGS flags = mtThread); private: // *************************************************************** @@ -548,7 +553,6 @@ public: virtual void print_on_error(outputStream* st, char* buf, int buflen) const; // Debug-only code - #ifdef ASSERT private: // Deadlock detection support for Mutex locks. List of locks own by thread. @@ -1027,9 +1031,15 @@ class JavaThread: public Thread { bool do_not_unlock_if_synchronized() { return _do_not_unlock_if_synchronized; } void set_do_not_unlock_if_synchronized(bool val) { _do_not_unlock_if_synchronized = val; } + // native memory tracking + inline MemRecorder* get_recorder() const { return (MemRecorder*)_recorder; } + inline void set_recorder(MemRecorder* rc) { _recorder = (volatile MemRecorder*)rc; } + + private: + // per-thread memory recorder + volatile MemRecorder* _recorder; // Suspend/resume support for JavaThread - private: void set_ext_suspended() { set_suspend_flag (_ext_suspended); } void clear_ext_suspended() { clear_suspend_flag(_ext_suspended); } @@ -1453,6 +1463,18 @@ public: return result; } + // NMT (Native memory tracking) support. + // This flag helps NMT to determine if this JavaThread will be blocked + // at safepoint. If not, ThreadCritical is needed for writing memory records. + // JavaThread is only safepoint visible when it is in Threads' thread list, + // it is not visible until it is added to the list and becomes invisible + // once it is removed from the list. + public: + bool is_safepoint_visible() const { return _safepoint_visible; } + void set_safepoint_visible(bool visible) { _safepoint_visible = visible; } + private: + bool _safepoint_visible; + // Static operations public: // Returns the running thread as a JavaThread diff --git a/hotspot/src/share/vm/runtime/unhandledOops.cpp b/hotspot/src/share/vm/runtime/unhandledOops.cpp index 9b7211c8d1d..3216da1f2c0 100644 --- a/hotspot/src/share/vm/runtime/unhandledOops.cpp +++ b/hotspot/src/share/vm/runtime/unhandledOops.cpp @@ -37,7 +37,7 @@ const int free_list_size = 256; UnhandledOops::UnhandledOops(Thread* thread) { _thread = thread; - _oop_list = new (ResourceObj::C_HEAP) + _oop_list = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(free_list_size, true); _level = 0; } diff --git a/hotspot/src/share/vm/runtime/vframeArray.cpp b/hotspot/src/share/vm/runtime/vframeArray.cpp index 52b08099922..742197394d8 100644 --- a/hotspot/src/share/vm/runtime/vframeArray.cpp +++ b/hotspot/src/share/vm/runtime/vframeArray.cpp @@ -443,7 +443,7 @@ vframeArray* vframeArray::allocate(JavaThread* thread, int frame_size, GrowableA // Allocate the vframeArray vframeArray * result = (vframeArray*) AllocateHeap(sizeof(vframeArray) + // fixed part sizeof(vframeArrayElement) * (chunk->length() - 1), // variable part - "vframeArray::allocate"); + mtCompiler); result->_frames = chunk->length(); result->_owner_thread = thread; result->_sender = sender; diff --git a/hotspot/src/share/vm/runtime/vframeArray.hpp b/hotspot/src/share/vm/runtime/vframeArray.hpp index 6f8d436c6ca..2eeeb39e60e 100644 --- a/hotspot/src/share/vm/runtime/vframeArray.hpp +++ b/hotspot/src/share/vm/runtime/vframeArray.hpp @@ -108,7 +108,7 @@ class vframeArrayElement : public _ValueObj { // but it does make debugging easier even if we can't look // at the data in each vframeElement -class vframeArray: public CHeapObj { +class vframeArray: public CHeapObj { friend class VMStructs; private: diff --git a/hotspot/src/share/vm/runtime/vframe_hp.cpp b/hotspot/src/share/vm/runtime/vframe_hp.cpp index 274bfc604ce..4f63575d9d6 100644 --- a/hotspot/src/share/vm/runtime/vframe_hp.cpp +++ b/hotspot/src/share/vm/runtime/vframe_hp.cpp @@ -154,7 +154,7 @@ void compiledVFrame::update_local(BasicType type, int index, jvalue value) { } else { // No deferred updates pending for this thread. // allocate in C heap - deferred = new(ResourceObj::C_HEAP) GrowableArray (1, true); + deferred = new(ResourceObj::C_HEAP, mtCompiler) GrowableArray (1, true); thread()->set_deferred_locals(deferred); } deferred->push(new jvmtiDeferredLocalVariableSet(method(), bci(), fr().id())); @@ -323,7 +323,7 @@ jvmtiDeferredLocalVariableSet::jvmtiDeferredLocalVariableSet(methodOop method, i _bci = bci; _id = id; // Alway will need at least one, must be on C heap - _locals = new(ResourceObj::C_HEAP) GrowableArray (1, true); + _locals = new(ResourceObj::C_HEAP, mtCompiler) GrowableArray (1, true); } jvmtiDeferredLocalVariableSet::~jvmtiDeferredLocalVariableSet() { diff --git a/hotspot/src/share/vm/runtime/vframe_hp.hpp b/hotspot/src/share/vm/runtime/vframe_hp.hpp index 6d0bd376482..4edb53bc888 100644 --- a/hotspot/src/share/vm/runtime/vframe_hp.hpp +++ b/hotspot/src/share/vm/runtime/vframe_hp.hpp @@ -89,7 +89,7 @@ class compiledVFrame: public javaVFrame { // any updated locals. class jvmtiDeferredLocalVariable; -class jvmtiDeferredLocalVariableSet : public CHeapObj { +class jvmtiDeferredLocalVariableSet : public CHeapObj { private: methodOop _method; // must be GC'd @@ -119,7 +119,7 @@ private: }; -class jvmtiDeferredLocalVariable : public CHeapObj { +class jvmtiDeferredLocalVariable : public CHeapObj { public: jvmtiDeferredLocalVariable(int index, BasicType type, jvalue value); diff --git a/hotspot/src/share/vm/runtime/virtualspace.cpp b/hotspot/src/share/vm/runtime/virtualspace.cpp index c7e6bf80f4b..38f434dce40 100644 --- a/hotspot/src/share/vm/runtime/virtualspace.cpp +++ b/hotspot/src/share/vm/runtime/virtualspace.cpp @@ -26,6 +26,7 @@ #include "oops/markOop.hpp" #include "oops/oop.inline.hpp" #include "runtime/virtualspace.hpp" +#include "services/memTracker.hpp" #ifdef TARGET_OS_FAMILY_linux # include "os_linux.inline.hpp" #endif @@ -489,6 +490,10 @@ ReservedHeapSpace::ReservedHeapSpace(size_t size, size_t alignment, (UseCompressedOops && (Universe::narrow_oop_base() != NULL) && Universe::narrow_oop_use_implicit_null_checks()) ? lcm(os::vm_page_size(), alignment) : 0) { + if (base() > 0) { + MemTracker::record_virtual_memory_type((address)base(), mtJavaHeap); + } + // Only reserved space for the java heap should have a noaccess_prefix // if using compressed oops. protect_noaccess_prefix(size); @@ -504,6 +509,10 @@ ReservedHeapSpace::ReservedHeapSpace(const size_t prefix_size, (UseCompressedOops && (Universe::narrow_oop_base() != NULL) && Universe::narrow_oop_use_implicit_null_checks()) ? lcm(os::vm_page_size(), prefix_align) : 0) { + if (base() > 0) { + MemTracker::record_virtual_memory_type((address)base(), mtJavaHeap); + } + protect_noaccess_prefix(prefix_size+suffix_size); } @@ -513,6 +522,7 @@ ReservedCodeSpace::ReservedCodeSpace(size_t r_size, size_t rs_align, bool large) : ReservedSpace(r_size, rs_align, large, /*executable*/ true) { + MemTracker::record_virtual_memory_type((address)base(), mtCode); } // VirtualSpace diff --git a/hotspot/src/share/vm/runtime/vmStructs.cpp b/hotspot/src/share/vm/runtime/vmStructs.cpp index 7045fa8b3ce..57fab336962 100644 --- a/hotspot/src/share/vm/runtime/vmStructs.cpp +++ b/hotspot/src/share/vm/runtime/vmStructs.cpp @@ -235,7 +235,6 @@ #ifndef REG_COUNT #define REG_COUNT 0 #endif - // whole purpose of this function is to work around bug c++/27724 in gcc 4.1.1 // with optimization turned on it doesn't affect produced code static inline uint64_t cast_uint64_t(size_t x) @@ -244,6 +243,16 @@ static inline uint64_t cast_uint64_t(size_t x) } +typedef HashtableEntry IntptrHashtableEntry; +typedef Hashtable IntptrHashtable; +typedef Hashtable SymbolHashtable; +typedef HashtableEntry SymbolHashtableEntry; +typedef Hashtable StringHashtable; +typedef TwoOopHashtable klassOopTwoOopHashtable; +typedef Hashtable klassOopHashtable; +typedef HashtableEntry klassHashtableEntry; +typedef TwoOopHashtable SymbolTwoOopHashtable; + //-------------------------------------------------------------------------------- // VM_STRUCTS // @@ -711,26 +720,26 @@ static inline uint64_t cast_uint64_t(size_t x) /* HashtableBucket */ \ /*******************/ \ \ - nonstatic_field(HashtableBucket, _entry, BasicHashtableEntry*) \ + nonstatic_field(HashtableBucket, _entry, BasicHashtableEntry*) \ \ /******************/ \ /* HashtableEntry */ \ /******************/ \ \ - nonstatic_field(BasicHashtableEntry, _next, BasicHashtableEntry*) \ - nonstatic_field(BasicHashtableEntry, _hash, unsigned int) \ - nonstatic_field(HashtableEntry, _literal, intptr_t) \ + nonstatic_field(BasicHashtableEntry, _next, BasicHashtableEntry*) \ + nonstatic_field(BasicHashtableEntry, _hash, unsigned int) \ + nonstatic_field(IntptrHashtableEntry, _literal, intptr_t) \ \ /*************/ \ /* Hashtable */ \ /*************/ \ \ - nonstatic_field(BasicHashtable, _table_size, int) \ - nonstatic_field(BasicHashtable, _buckets, HashtableBucket*) \ - nonstatic_field(BasicHashtable, _free_list, BasicHashtableEntry*) \ - nonstatic_field(BasicHashtable, _first_free_entry, char*) \ - nonstatic_field(BasicHashtable, _end_block, char*) \ - nonstatic_field(BasicHashtable, _entry_size, int) \ + nonstatic_field(BasicHashtable, _table_size, int) \ + nonstatic_field(BasicHashtable, _buckets, HashtableBucket*) \ + nonstatic_field(BasicHashtable, _free_list, BasicHashtableEntry*) \ + nonstatic_field(BasicHashtable, _first_free_entry, char*) \ + nonstatic_field(BasicHashtable, _end_block, char*) \ + nonstatic_field(BasicHashtable, _entry_size, int) \ \ /*******************/ \ /* DictionaryEntry */ \ @@ -1538,20 +1547,20 @@ static inline uint64_t cast_uint64_t(size_t x) /* SymbolTable, SystemDictionary */ \ /*********************************/ \ \ - declare_toplevel_type(BasicHashtable) \ - declare_type(Hashtable, BasicHashtable) \ - declare_type(SymbolTable, Hashtable) \ - declare_type(StringTable, Hashtable) \ - declare_type(LoaderConstraintTable, Hashtable) \ - declare_type(TwoOopHashtable, Hashtable) \ - declare_type(Dictionary, TwoOopHashtable) \ - declare_type(PlaceholderTable, TwoOopHashtable) \ - declare_toplevel_type(BasicHashtableEntry) \ - declare_type(HashtableEntry, BasicHashtableEntry) \ - declare_type(DictionaryEntry, HashtableEntry) \ - declare_type(PlaceholderEntry, HashtableEntry) \ - declare_type(LoaderConstraintEntry, HashtableEntry) \ - declare_toplevel_type(HashtableBucket) \ + declare_toplevel_type(BasicHashtable) \ + declare_type(IntptrHashtable, BasicHashtable) \ + declare_type(SymbolTable, SymbolHashtable) \ + declare_type(StringTable, StringHashtable) \ + declare_type(LoaderConstraintTable, klassOopHashtable) \ + declare_type(klassOopTwoOopHashtable, klassOopHashtable) \ + declare_type(Dictionary, klassOopTwoOopHashtable) \ + declare_type(PlaceholderTable, SymbolTwoOopHashtable) \ + declare_toplevel_type(BasicHashtableEntry) \ + declare_type(IntptrHashtableEntry, BasicHashtableEntry) \ + declare_type(DictionaryEntry, klassHashtableEntry) \ + declare_type(PlaceholderEntry, SymbolHashtableEntry) \ + declare_type(LoaderConstraintEntry, klassHashtableEntry) \ + declare_toplevel_type(HashtableBucket) \ declare_toplevel_type(SystemDictionary) \ declare_toplevel_type(vmSymbols) \ declare_toplevel_type(ProtectionDomainEntry) \ diff --git a/hotspot/src/share/vm/runtime/vmThread.hpp b/hotspot/src/share/vm/runtime/vmThread.hpp index f78449676b7..acf95842bf1 100644 --- a/hotspot/src/share/vm/runtime/vmThread.hpp +++ b/hotspot/src/share/vm/runtime/vmThread.hpp @@ -46,7 +46,7 @@ // Encapsulates both queue management and // and priority policy // -class VMOperationQueue : public CHeapObj { +class VMOperationQueue : public CHeapObj { private: enum Priorities { SafepointPriority, // Highest priority (operation executed at a safepoint) diff --git a/hotspot/src/share/vm/runtime/vm_operations.hpp b/hotspot/src/share/vm/runtime/vm_operations.hpp index 081c428a62b..ccbad94b728 100644 --- a/hotspot/src/share/vm/runtime/vm_operations.hpp +++ b/hotspot/src/share/vm/runtime/vm_operations.hpp @@ -96,7 +96,7 @@ template(JFRCheckpoint) \ template(Exit) \ -class VM_Operation: public CHeapObj { +class VM_Operation: public CHeapObj { public: enum Mode { _safepoint, // blocking, safepoint, vm_op C-heap allocated diff --git a/hotspot/src/share/vm/services/attachListener.cpp b/hotspot/src/share/vm/services/attachListener.cpp index 3753a64cc95..14b4aa08eca 100644 --- a/hotspot/src/share/vm/services/attachListener.cpp +++ b/hotspot/src/share/vm/services/attachListener.cpp @@ -320,7 +320,7 @@ static jint set_ccstr_flag(const char* name, AttachOperation* op, outputStream* } bool res = CommandLineFlags::ccstrAtPut((char*)name, &value, ATTACH_ON_DEMAND); if (res) { - FREE_C_HEAP_ARRAY(char, value); + FREE_C_HEAP_ARRAY(char, value, mtInternal); } else { out->print_cr("setting flag %s failed", name); } diff --git a/hotspot/src/share/vm/services/attachListener.hpp b/hotspot/src/share/vm/services/attachListener.hpp index ba8fb93227b..e39c3fde3f9 100644 --- a/hotspot/src/share/vm/services/attachListener.hpp +++ b/hotspot/src/share/vm/services/attachListener.hpp @@ -98,7 +98,7 @@ class AttachListener: AllStatic { }; #ifndef SERVICES_KERNEL -class AttachOperation: public CHeapObj { +class AttachOperation: public CHeapObj { public: enum { name_length_max = 16, // maximum length of name diff --git a/hotspot/src/share/vm/services/diagnosticArgument.cpp b/hotspot/src/share/vm/services/diagnosticArgument.cpp index e2ced389105..23267fae520 100644 --- a/hotspot/src/share/vm/services/diagnosticArgument.cpp +++ b/hotspot/src/share/vm/services/diagnosticArgument.cpp @@ -140,7 +140,7 @@ template <> void DCmdArgument::parse_value(const char* str, if (str == NULL) { _value = NULL; } else { - _value = NEW_C_HEAP_ARRAY(char, len+1); + _value = NEW_C_HEAP_ARRAY(char, len+1, mtInternal); strncpy(_value, str, len); _value[len] = 0; } @@ -159,7 +159,7 @@ template <> void DCmdArgument::init_value(TRAPS) { template <> void DCmdArgument::destroy_value() { if (_value != NULL) { - FREE_C_HEAP_ARRAY(char, _value); + FREE_C_HEAP_ARRAY(char, _value, mtInternal); set_value(NULL); } } diff --git a/hotspot/src/share/vm/services/diagnosticArgument.hpp b/hotspot/src/share/vm/services/diagnosticArgument.hpp index 8881e99556c..596353b0752 100644 --- a/hotspot/src/share/vm/services/diagnosticArgument.hpp +++ b/hotspot/src/share/vm/services/diagnosticArgument.hpp @@ -31,17 +31,17 @@ #include "runtime/thread.hpp" #include "utilities/exceptions.hpp" -class StringArrayArgument : public CHeapObj { +class StringArrayArgument : public CHeapObj { private: GrowableArray* _array; public: StringArrayArgument() { - _array = new(ResourceObj::C_HEAP)GrowableArray(32, true); + _array = new(ResourceObj::C_HEAP, mtInternal)GrowableArray(32, true); assert(_array != NULL, "Sanity check"); } void add(const char* str, size_t len) { if (str != NULL) { - char* ptr = NEW_C_HEAP_ARRAY(char, len+1); + char* ptr = NEW_C_HEAP_ARRAY(char, len+1, mtInternal); strncpy(ptr, str, len); ptr[len] = 0; _array->append(ptr); @@ -53,7 +53,7 @@ public: ~StringArrayArgument() { for (int i=0; i<_array->length(); i++) { if(_array->at(i) != NULL) { // Safety check - FREE_C_HEAP_ARRAY(char, _array->at(i)); + FREE_C_HEAP_ARRAY(char, _array->at(i), mtInternal); } } delete _array; diff --git a/hotspot/src/share/vm/services/diagnosticFramework.hpp b/hotspot/src/share/vm/services/diagnosticFramework.hpp index f9ea562344c..f6863e4775e 100644 --- a/hotspot/src/share/vm/services/diagnosticFramework.hpp +++ b/hotspot/src/share/vm/services/diagnosticFramework.hpp @@ -310,7 +310,7 @@ public: // manages the status of the diagnostic command (hidden, enabled). A DCmdFactory // has to be registered to make the diagnostic command available (see // management.cpp) -class DCmdFactory: public CHeapObj { +class DCmdFactory: public CHeapObj { private: static Mutex* _dcmdFactory_lock; // Pointer to the next factory in the singly-linked list of registered @@ -368,7 +368,7 @@ public: DCmdFactory(DCmdClass::num_arguments(), enabled, hidden) { } // Returns a C-heap allocated instance virtual DCmd* create_Cheap_instance(outputStream* output) { - return new (ResourceObj::C_HEAP) DCmdClass(output, true); + return new (ResourceObj::C_HEAP, mtInternal) DCmdClass(output, true); } // Returns a resourceArea allocated instance virtual DCmd* create_resource_instance(outputStream* output) { diff --git a/hotspot/src/share/vm/services/gcNotifier.cpp b/hotspot/src/share/vm/services/gcNotifier.cpp index c43dadead0b..abb2dd6e798 100644 --- a/hotspot/src/share/vm/services/gcNotifier.cpp +++ b/hotspot/src/share/vm/services/gcNotifier.cpp @@ -45,7 +45,7 @@ void GCNotifier::pushNotification(GCMemoryManager *mgr, const char *action, cons // GC may occur between now and the creation of the notification int num_pools = MemoryService::num_memory_pools(); // stat is deallocated inside GCNotificationRequest - GCStatInfo* stat = new(ResourceObj::C_HEAP) GCStatInfo(num_pools); + GCStatInfo* stat = new(ResourceObj::C_HEAP, mtGC) GCStatInfo(num_pools); mgr->get_last_gc_stat(stat); GCNotificationRequest *request = new GCNotificationRequest(os::javaTimeMillis(),mgr,action,cause,stat); addRequest(request); diff --git a/hotspot/src/share/vm/services/gcNotifier.hpp b/hotspot/src/share/vm/services/gcNotifier.hpp index c26765e824e..1ac807ba592 100644 --- a/hotspot/src/share/vm/services/gcNotifier.hpp +++ b/hotspot/src/share/vm/services/gcNotifier.hpp @@ -30,7 +30,7 @@ #include "services/memoryService.hpp" #include "services/memoryManager.hpp" -class GCNotificationRequest : public CHeapObj { +class GCNotificationRequest : public CHeapObj { friend class GCNotifier; GCNotificationRequest *next; jlong timestamp; diff --git a/hotspot/src/share/vm/services/heapDumper.cpp b/hotspot/src/share/vm/services/heapDumper.cpp index 3cc0e5b6813..73f4a9b6120 100644 --- a/hotspot/src/share/vm/services/heapDumper.cpp +++ b/hotspot/src/share/vm/services/heapDumper.cpp @@ -436,7 +436,7 @@ DumpWriter::DumpWriter(const char* path) { // sufficient memory then reduce size until we can allocate something. _size = io_buffer_size; do { - _buffer = (char*)os::malloc(_size); + _buffer = (char*)os::malloc(_size, mtInternal); if (_buffer == NULL) { _size = _size >> 1; } @@ -1405,7 +1405,7 @@ class VM_HeapDumper : public VM_GC_Operation { _gc_before_heap_dump = gc_before_heap_dump; _is_segmented_dump = false; _dump_start = (jlong)-1; - _klass_map = new (ResourceObj::C_HEAP) GrowableArray(INITIAL_CLASS_COUNT, true); + _klass_map = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(INITIAL_CLASS_COUNT, true); _stack_traces = NULL; _num_threads = 0; if (oome) { @@ -1426,7 +1426,7 @@ class VM_HeapDumper : public VM_GC_Operation { for (int i=0; i < _num_threads; i++) { delete _stack_traces[i]; } - FREE_C_HEAP_ARRAY(ThreadStackTrace*, _stack_traces); + FREE_C_HEAP_ARRAY(ThreadStackTrace*, _stack_traces, mtInternal); } delete _klass_map; } @@ -1806,7 +1806,7 @@ void VM_HeapDumper::dump_stack_traces() { writer()->write_u4(0); // thread number writer()->write_u4(0); // frame count - _stack_traces = NEW_C_HEAP_ARRAY(ThreadStackTrace*, Threads::number_of_threads()); + _stack_traces = NEW_C_HEAP_ARRAY(ThreadStackTrace*, Threads::number_of_threads(), mtInternal); int frame_serial_num = 0; for (JavaThread* thread = Threads::first(); thread != NULL ; thread = thread->next()) { oop threadObj = thread->threadObj(); @@ -2005,7 +2005,7 @@ void HeapDumper::dump_heap(bool oome) { dump_file_name, os::current_process_id(), dump_file_ext); } const size_t len = strlen(base_path) + 1; - my_path = (char*)os::malloc(len); + my_path = (char*)os::malloc(len, mtInternal); if (my_path == NULL) { warning("Cannot create heap dump file. Out of system memory."); return; @@ -2014,7 +2014,7 @@ void HeapDumper::dump_heap(bool oome) { } else { // Append a sequence number id for dumps following the first const size_t len = strlen(base_path) + max_digit_chars + 2; // for '.' and \0 - my_path = (char*)os::malloc(len); + my_path = (char*)os::malloc(len, mtInternal); if (my_path == NULL) { warning("Cannot create heap dump file. Out of system memory."); return; diff --git a/hotspot/src/share/vm/services/lowMemoryDetector.hpp b/hotspot/src/share/vm/services/lowMemoryDetector.hpp index ce15bad2e21..311a3a418f6 100644 --- a/hotspot/src/share/vm/services/lowMemoryDetector.hpp +++ b/hotspot/src/share/vm/services/lowMemoryDetector.hpp @@ -63,7 +63,7 @@ class OopClosure; class MemoryPool; -class ThresholdSupport : public CHeapObj { +class ThresholdSupport : public CHeapObj { private: bool _support_high_threshold; bool _support_low_threshold; @@ -112,7 +112,7 @@ class ThresholdSupport : public CHeapObj { } }; -class SensorInfo : public CHeapObj { +class SensorInfo : public CHeapObj { private: instanceOop _sensor_obj; bool _sensor_on; diff --git a/hotspot/src/share/vm/services/management.cpp b/hotspot/src/share/vm/services/management.cpp index 48a5b6a0997..7d917e7217d 100644 --- a/hotspot/src/share/vm/services/management.cpp +++ b/hotspot/src/share/vm/services/management.cpp @@ -47,6 +47,7 @@ #include "services/jmm.h" #include "services/lowMemoryDetector.hpp" #include "services/gcNotifier.hpp" +#include "services/nmtDCmd.hpp" #include "services/management.hpp" #include "services/memoryManager.hpp" #include "services/memoryPool.hpp" @@ -121,6 +122,7 @@ void Management::init() { // Registration of the diagnostic commands DCmdRegistrant::register_dcmds(); DCmdRegistrant::register_dcmds_ext(); + DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(true, false)); } void Management::initialize(TRAPS) { diff --git a/hotspot/src/share/vm/services/memBaseline.cpp b/hotspot/src/share/vm/services/memBaseline.cpp new file mode 100644 index 00000000000..5b829751649 --- /dev/null +++ b/hotspot/src/share/vm/services/memBaseline.cpp @@ -0,0 +1,387 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ +#include "precompiled.hpp" +#include "classfile/systemDictionary.hpp" +#include "memory/allocation.hpp" +#include "services/memBaseline.hpp" +#include "services/memTracker.hpp" + +MemType2Name MemBaseline::MemType2NameMap[NUMBER_OF_MEMORY_TYPE] = { + {mtJavaHeap, "Java Heap"}, + {mtClass, "Class"}, + {mtThreadStack,"Thread Stack"}, + {mtThread, "Thread"}, + {mtCode, "Code"}, + {mtGC, "GC"}, + {mtCompiler, "Compiler"}, + {mtInternal, "Internal"}, + {mtOther, "Other"}, + {mtSymbol, "Symbol"}, + {mtNMT, "Memory Tracking"}, + {mtChunk, "Pooled Free Chunks"}, + {mtNone, "Unknown"} // It can happen when type tagging records are lagging + // behind +}; + +MemBaseline::MemBaseline() { + _baselined = false; + + for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { + _malloc_data[index].set_type(MemType2NameMap[index]._flag); + _vm_data[index].set_type(MemType2NameMap[index]._flag); + _arena_data[index].set_type(MemType2NameMap[index]._flag); + } + + _malloc_cs = NULL; + _vm_cs = NULL; + + _number_of_classes = 0; + _number_of_threads = 0; +} + + +void MemBaseline::clear() { + if (_malloc_cs != NULL) { + delete _malloc_cs; + _malloc_cs = NULL; + } + + if (_vm_cs != NULL) { + delete _vm_cs; + _vm_cs = NULL; + } + + reset(); +} + + +void MemBaseline::reset() { + _baselined = false; + _total_vm_reserved = 0; + _total_vm_committed = 0; + _total_malloced = 0; + _number_of_classes = 0; + + if (_malloc_cs != NULL) _malloc_cs->clear(); + if (_vm_cs != NULL) _vm_cs->clear(); + + for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { + _malloc_data[index].clear(); + _vm_data[index].clear(); + _arena_data[index].clear(); + } +} + +MemBaseline::~MemBaseline() { + if (_malloc_cs != NULL) { + delete _malloc_cs; + } + + if (_vm_cs != NULL) { + delete _vm_cs; + } +} + +// baseline malloc'd memory records, generate overall summary and summaries by +// memory types +bool MemBaseline::baseline_malloc_summary(const MemPointerArray* malloc_records) { + MemPointerArrayIteratorImpl mItr((MemPointerArray*)malloc_records); + MemPointerRecord* mptr = (MemPointerRecord*)mItr.current(); + size_t used_arena_size = 0; + int index; + while (mptr != NULL) { + index = flag2index(FLAGS_TO_MEMORY_TYPE(mptr->flags())); + size_t size = mptr->size(); + _total_malloced += size; + _malloc_data[index].inc(size); + if (MemPointerRecord::is_arena_record(mptr->flags())) { + // see if arena size record present + MemPointerRecord* next_p = (MemPointerRecordEx*)mItr.peek_next(); + if (MemPointerRecord::is_arena_size_record(next_p->flags())) { + assert(next_p->is_size_record_of_arena(mptr), "arena records do not match"); + size = next_p->size(); + _arena_data[index].inc(size); + used_arena_size += size; + mItr.next(); + } + } + mptr = (MemPointerRecordEx*)mItr.next(); + } + + // substract used arena size to get size of arena chunk in free list + index = flag2index(mtChunk); + _malloc_data[index].reduce(used_arena_size); + // we really don't know how many chunks in free list, so just set to + // 0 + _malloc_data[index].overwrite_counter(0); + + return true; +} + +// baseline mmap'd memory records, generate overall summary and summaries by +// memory types +bool MemBaseline::baseline_vm_summary(const MemPointerArray* vm_records) { + MemPointerArrayIteratorImpl vItr((MemPointerArray*)vm_records); + VMMemRegion* vptr = (VMMemRegion*)vItr.current(); + int index; + while (vptr != NULL) { + index = flag2index(FLAGS_TO_MEMORY_TYPE(vptr->flags())); + + // we use the number of thread stack to count threads + if (IS_MEMORY_TYPE(vptr->flags(), mtThreadStack)) { + _number_of_threads ++; + } + _total_vm_reserved += vptr->reserved_size(); + _total_vm_committed += vptr->committed_size(); + _vm_data[index].inc(vptr->reserved_size(), vptr->committed_size()); + vptr = (VMMemRegion*)vItr.next(); + } + return true; +} + +// baseline malloc'd memory by callsites, but only the callsites with memory allocation +// over 1KB are stored. +bool MemBaseline::baseline_malloc_details(const MemPointerArray* malloc_records) { + assert(MemTracker::track_callsite(), "detail tracking is off"); + + MemPointerArrayIteratorImpl mItr((MemPointerArray*)malloc_records); + MemPointerRecordEx* mptr = (MemPointerRecordEx*)mItr.current(); + MallocCallsitePointer mp; + + if (_malloc_cs == NULL) { + _malloc_cs = new (std::nothrow) MemPointerArrayImpl(64); + // out of native memory + if (_malloc_cs == NULL) { + return false; + } + } else { + _malloc_cs->clear(); + } + + // baseline memory that is totaled over 1 KB + while (mptr != NULL) { + if (!MemPointerRecord::is_arena_size_record(mptr->flags())) { + // skip thread stacks + if (!IS_MEMORY_TYPE(mptr->flags(), mtThreadStack)) { + if (mp.addr() != mptr->pc()) { + if ((mp.amount()/K) > 0) { + if (!_malloc_cs->append(&mp)) { + return false; + } + } + mp = MallocCallsitePointer(mptr->pc()); + } + mp.inc(mptr->size()); + } + } + mptr = (MemPointerRecordEx*)mItr.next(); + } + + if (mp.addr() != 0 && (mp.amount()/K) > 0) { + if (!_malloc_cs->append(&mp)) { + return false; + } + } + return true; +} + +// baseline mmap'd memory by callsites +bool MemBaseline::baseline_vm_details(const MemPointerArray* vm_records) { + assert(MemTracker::track_callsite(), "detail tracking is off"); + + VMCallsitePointer vp; + MemPointerArrayIteratorImpl vItr((MemPointerArray*)vm_records); + VMMemRegionEx* vptr = (VMMemRegionEx*)vItr.current(); + + if (_vm_cs == NULL) { + _vm_cs = new (std::nothrow) MemPointerArrayImpl(64); + if (_vm_cs == NULL) { + return false; + } + } else { + _vm_cs->clear(); + } + + while (vptr != NULL) { + if (vp.addr() != vptr->pc()) { + if (!_vm_cs->append(&vp)) { + return false; + } + vp = VMCallsitePointer(vptr->pc()); + } + vp.inc(vptr->size(), vptr->committed_size()); + vptr = (VMMemRegionEx*)vItr.next(); + } + if (vp.addr() != 0) { + if (!_vm_cs->append(&vp)) { + return false; + } + } + return true; +} + +// baseline a snapshot. If summary_only = false, memory usages aggregated by +// callsites are also baselined. +bool MemBaseline::baseline(MemSnapshot& snapshot, bool summary_only) { + MutexLockerEx snapshot_locker(snapshot._lock, true); + reset(); + _baselined = baseline_malloc_summary(snapshot._alloc_ptrs) && + baseline_vm_summary(snapshot._vm_ptrs); + _number_of_classes = SystemDictionary::number_of_classes(); + + if (!summary_only && MemTracker::track_callsite() && _baselined) { + ((MemPointerArray*)snapshot._alloc_ptrs)->sort((FN_SORT)malloc_sort_by_pc); + ((MemPointerArray*)snapshot._vm_ptrs)->sort((FN_SORT)vm_sort_by_pc); + _baselined = baseline_malloc_details(snapshot._alloc_ptrs) && + baseline_vm_details(snapshot._vm_ptrs); + ((MemPointerArray*)snapshot._alloc_ptrs)->sort((FN_SORT)malloc_sort_by_addr); + ((MemPointerArray*)snapshot._vm_ptrs)->sort((FN_SORT)vm_sort_by_addr); + } + return _baselined; +} + + +int MemBaseline::flag2index(MEMFLAGS flag) const { + for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { + if (MemType2NameMap[index]._flag == flag) { + return index; + } + } + assert(false, "no type"); + return -1; +} + +const char* MemBaseline::type2name(MEMFLAGS type) { + for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { + if (MemType2NameMap[index]._flag == type) { + return MemType2NameMap[index]._name; + } + } + assert(false, "no type"); + return NULL; +} + + +MemBaseline& MemBaseline::operator=(const MemBaseline& other) { + _total_malloced = other._total_malloced; + _total_vm_reserved = other._total_vm_reserved; + _total_vm_committed = other._total_vm_committed; + + _baselined = other._baselined; + _number_of_classes = other._number_of_classes; + + for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { + _malloc_data[index] = other._malloc_data[index]; + _vm_data[index] = other._vm_data[index]; + _arena_data[index] = other._arena_data[index]; + } + + if (MemTracker::track_callsite()) { + assert(_malloc_cs != NULL && _vm_cs != NULL, "out of memory"); + assert(other._malloc_cs != NULL && other._vm_cs != NULL, + "not properly baselined"); + _malloc_cs->clear(); + _vm_cs->clear(); + int index; + for (index = 0; index < other._malloc_cs->length(); index ++) { + _malloc_cs->append(other._malloc_cs->at(index)); + } + + for (index = 0; index < other._vm_cs->length(); index ++) { + _vm_cs->append(other._vm_cs->at(index)); + } + } + return *this; +} + +/* compare functions for sorting */ + +// sort snapshot malloc'd records in callsite pc order +int MemBaseline::malloc_sort_by_pc(const void* p1, const void* p2) { + assert(MemTracker::track_callsite(),"Just check"); + const MemPointerRecordEx* mp1 = (const MemPointerRecordEx*)p1; + const MemPointerRecordEx* mp2 = (const MemPointerRecordEx*)p2; + return UNSIGNED_COMPARE(mp1->pc(), mp2->pc()); +} + +// sort baselined malloc'd records in size order +int MemBaseline::bl_malloc_sort_by_size(const void* p1, const void* p2) { + assert(MemTracker::is_on(), "Just check"); + const MallocCallsitePointer* mp1 = (const MallocCallsitePointer*)p1; + const MallocCallsitePointer* mp2 = (const MallocCallsitePointer*)p2; + return UNSIGNED_COMPARE(mp2->amount(), mp1->amount()); +} + +// sort baselined malloc'd records in callsite pc order +int MemBaseline::bl_malloc_sort_by_pc(const void* p1, const void* p2) { + assert(MemTracker::is_on(), "Just check"); + const MallocCallsitePointer* mp1 = (const MallocCallsitePointer*)p1; + const MallocCallsitePointer* mp2 = (const MallocCallsitePointer*)p2; + return UNSIGNED_COMPARE(mp1->addr(), mp2->addr()); +} + +// sort snapshot mmap'd records in callsite pc order +int MemBaseline::vm_sort_by_pc(const void* p1, const void* p2) { + assert(MemTracker::track_callsite(),"Just check"); + const VMMemRegionEx* mp1 = (const VMMemRegionEx*)p1; + const VMMemRegionEx* mp2 = (const VMMemRegionEx*)p2; + return UNSIGNED_COMPARE(mp1->pc(), mp2->pc()); +} + +// sort baselined mmap'd records in size (reserved size) order +int MemBaseline::bl_vm_sort_by_size(const void* p1, const void* p2) { + assert(MemTracker::is_on(), "Just check"); + const VMCallsitePointer* mp1 = (const VMCallsitePointer*)p1; + const VMCallsitePointer* mp2 = (const VMCallsitePointer*)p2; + return UNSIGNED_COMPARE(mp2->reserved_amount(), mp1->reserved_amount()); +} + +// sort baselined mmap'd records in callsite pc order +int MemBaseline::bl_vm_sort_by_pc(const void* p1, const void* p2) { + assert(MemTracker::is_on(), "Just check"); + const VMCallsitePointer* mp1 = (const VMCallsitePointer*)p1; + const VMCallsitePointer* mp2 = (const VMCallsitePointer*)p2; + return UNSIGNED_COMPARE(mp1->addr(), mp2->addr()); +} + + +// sort snapshot malloc'd records in memory block address order +int MemBaseline::malloc_sort_by_addr(const void* p1, const void* p2) { + assert(MemTracker::is_on(), "Just check"); + const MemPointerRecord* mp1 = (const MemPointerRecord*)p1; + const MemPointerRecord* mp2 = (const MemPointerRecord*)p2; + int delta = UNSIGNED_COMPARE(mp1->addr(), mp2->addr()); + assert(delta != 0, "dup pointer"); + return delta; +} + +// sort snapshot mmap'd records in memory block address order +int MemBaseline::vm_sort_by_addr(const void* p1, const void* p2) { + assert(MemTracker::is_on(), "Just check"); + const VMMemRegion* mp1 = (const VMMemRegion*)p1; + const VMMemRegion* mp2 = (const VMMemRegion*)p2; + int delta = UNSIGNED_COMPARE(mp1->addr(), mp2->addr()); + assert(delta != 0, "dup pointer"); + return delta; +} diff --git a/hotspot/src/share/vm/services/memBaseline.hpp b/hotspot/src/share/vm/services/memBaseline.hpp new file mode 100644 index 00000000000..2affa2b96ca --- /dev/null +++ b/hotspot/src/share/vm/services/memBaseline.hpp @@ -0,0 +1,447 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_SERVICES_MEM_BASELINE_HPP +#define SHARE_VM_SERVICES_MEM_BASELINE_HPP + +#include "memory/allocation.hpp" +#include "runtime/mutex.hpp" +#include "services/memPtr.hpp" +#include "services/memSnapshot.hpp" + +// compare unsigned number +#define UNSIGNED_COMPARE(a, b) ((a > b) ? 1 : ((a == b) ? 0 : -1)) + +/* + * MallocCallsitePointer and VMCallsitePointer are used + * to baseline memory blocks with their callsite information. + * They are only available when detail tracking is turned + * on. + */ + +/* baselined malloc record aggregated by callsite */ +class MallocCallsitePointer : public MemPointer { + private: + size_t _count; // number of malloc invocation from this callsite + size_t _amount; // total amount of memory malloc-ed from this callsite + + public: + MallocCallsitePointer() { + _count = 0; + _amount = 0; + } + + MallocCallsitePointer(address pc) : MemPointer(pc) { + _count = 0; + _amount = 0; + } + + MallocCallsitePointer& operator=(const MallocCallsitePointer& p) { + MemPointer::operator=(p); + _count = p.count(); + _amount = p.amount(); + return *this; + } + + inline void inc(size_t size) { + _count ++; + _amount += size; + }; + + inline size_t count() const { + return _count; + } + + inline size_t amount() const { + return _amount; + } +}; + +// baselined virtual memory record aggregated by callsite +class VMCallsitePointer : public MemPointer { + private: + size_t _count; // number of invocation from this callsite + size_t _reserved_amount; // total reserved amount + size_t _committed_amount; // total committed amount + + public: + VMCallsitePointer() { + _count = 0; + _reserved_amount = 0; + _committed_amount = 0; + } + + VMCallsitePointer(address pc) : MemPointer(pc) { + _count = 0; + _reserved_amount = 0; + _committed_amount = 0; + } + + VMCallsitePointer& operator=(const VMCallsitePointer& p) { + MemPointer::operator=(p); + _count = p.count(); + _reserved_amount = p.reserved_amount(); + _committed_amount = p.committed_amount(); + return *this; + } + + inline void inc(size_t reserved, size_t committed) { + _count ++; + _reserved_amount += reserved; + _committed_amount += committed; + } + + inline size_t count() const { + return _count; + } + + inline size_t reserved_amount() const { + return _reserved_amount; + } + + inline size_t committed_amount() const { + return _committed_amount; + } +}; + +// maps a memory type flag to readable name +typedef struct _memType2Name { + MEMFLAGS _flag; + const char* _name; +} MemType2Name; + + +// This class aggregates malloc'd records by memory type +class MallocMem : public _ValueObj { + private: + MEMFLAGS _type; + + size_t _count; + size_t _amount; + + public: + MallocMem() { + _type = mtNone; + _count = 0; + _amount = 0; + } + + MallocMem(MEMFLAGS flags) { + assert(HAS_VALID_MEMORY_TYPE(flags), "no type"); + _type = FLAGS_TO_MEMORY_TYPE(flags); + _count = 0; + _amount = 0; + } + + inline void set_type(MEMFLAGS flag) { + _type = flag; + } + + inline void clear() { + _count = 0; + _amount = 0; + _type = mtNone; + } + + MallocMem& operator=(const MallocMem& m) { + assert(_type == m.type(), "different type"); + _count = m.count(); + _amount = m.amount(); + return *this; + } + + inline void inc(size_t amt) { + _amount += amt; + _count ++; + } + + inline void reduce(size_t amt) { + assert(_amount >= amt, "Just check"); + _amount -= amt; + } + + inline void overwrite_counter(size_t count) { + _count = count; + } + + inline MEMFLAGS type() const { + return _type; + } + + inline bool is_type(MEMFLAGS flags) const { + return FLAGS_TO_MEMORY_TYPE(flags) == _type; + } + + inline size_t count() const { + return _count; + } + + inline size_t amount() const { + return _amount; + } +}; + +// This class records live arena's memory usage +class ArenaMem : public MallocMem { + public: + ArenaMem(MEMFLAGS typeflag): MallocMem(typeflag) { + } + ArenaMem() { } +}; + +// This class aggregates virtual memory by its memory type +class VMMem : public _ValueObj { + private: + MEMFLAGS _type; + + size_t _count; + size_t _reserved_amount; + size_t _committed_amount; + + public: + VMMem() { + _type = mtNone; + _count = 0; + _reserved_amount = 0; + _committed_amount = 0; + } + + VMMem(MEMFLAGS flags) { + assert(HAS_VALID_MEMORY_TYPE(flags), "no type"); + _type = FLAGS_TO_MEMORY_TYPE(flags); + _count = 0; + _reserved_amount = 0; + _committed_amount = 0; + } + + inline void clear() { + _type = mtNone; + _count = 0; + _reserved_amount = 0; + _committed_amount = 0; + } + + inline void set_type(MEMFLAGS flags) { + _type = FLAGS_TO_MEMORY_TYPE(flags); + } + + VMMem& operator=(const VMMem& m) { + assert(_type == m.type(), "different type"); + + _count = m.count(); + _reserved_amount = m.reserved_amount(); + _committed_amount = m.committed_amount(); + return *this; + } + + + inline MEMFLAGS type() const { + return _type; + } + + inline bool is_type(MEMFLAGS flags) const { + return FLAGS_TO_MEMORY_TYPE(flags) == _type; + } + + inline void inc(size_t reserved_amt, size_t committed_amt) { + _reserved_amount += reserved_amt; + _committed_amount += committed_amt; + _count ++; + } + + inline size_t count() const { + return _count; + } + + inline size_t reserved_amount() const { + return _reserved_amount; + } + + inline size_t committed_amount() const { + return _committed_amount; + } +}; + + + +#define NUMBER_OF_MEMORY_TYPE (mt_number_of_types + 1) + +class BaselineReporter; +class BaselineComparisonReporter; + +/* + * This class baselines current memory snapshot. + * A memory baseline summarizes memory usage by memory type, + * aggregates memory usage by callsites when detail tracking + * is on. + */ +class MemBaseline : public _ValueObj { + friend class BaselineReporter; + friend class BaselineComparisonReporter; + + private: + // overall summaries + size_t _total_malloced; + size_t _total_vm_reserved; + size_t _total_vm_committed; + size_t _number_of_classes; + size_t _number_of_threads; + + // if it has properly baselined + bool _baselined; + + // we categorize memory into three categories within the memory type + MallocMem _malloc_data[NUMBER_OF_MEMORY_TYPE]; + VMMem _vm_data[NUMBER_OF_MEMORY_TYPE]; + ArenaMem _arena_data[NUMBER_OF_MEMORY_TYPE]; + + // memory records that aggregate memory usage by callsites. + // only available when detail tracking is on. + MemPointerArray* _malloc_cs; + MemPointerArray* _vm_cs; + + private: + static MemType2Name MemType2NameMap[NUMBER_OF_MEMORY_TYPE]; + + private: + // should not use copy constructor + MemBaseline(MemBaseline& copy) { ShouldNotReachHere(); } + + public: + // create a memory baseline + MemBaseline(); + + virtual ~MemBaseline(); + + inline bool baselined() const { + return _baselined; + } + + MemBaseline& operator=(const MemBaseline& other); + + // reset the baseline for reuse + void clear(); + + // baseline the snapshot + bool baseline(MemSnapshot& snapshot, bool summary_only = true); + + bool baseline(const MemPointerArray* malloc_records, + const MemPointerArray* vm_records, + bool summary_only = true); + + // total malloc'd memory of specified memory type + inline size_t malloc_amount(MEMFLAGS flag) const { + return _malloc_data[flag2index(flag)].amount(); + } + // number of malloc'd memory blocks of specified memory type + inline size_t malloc_count(MEMFLAGS flag) const { + return _malloc_data[flag2index(flag)].count(); + } + // total memory used by arenas of specified memory type + inline size_t arena_amount(MEMFLAGS flag) const { + return _arena_data[flag2index(flag)].amount(); + } + // number of arenas of specified memory type + inline size_t arena_count(MEMFLAGS flag) const { + return _arena_data[flag2index(flag)].count(); + } + // total reserved memory of specified memory type + inline size_t reserved_amount(MEMFLAGS flag) const { + return _vm_data[flag2index(flag)].reserved_amount(); + } + // total committed memory of specified memory type + inline size_t committed_amount(MEMFLAGS flag) const { + return _vm_data[flag2index(flag)].committed_amount(); + } + // total memory (malloc'd + mmap'd + arena) of specified + // memory type + inline size_t total_amount(MEMFLAGS flag) const { + int index = flag2index(flag); + return _malloc_data[index].amount() + + _vm_data[index].reserved_amount() + + _arena_data[index].amount(); + } + + /* overall summaries */ + + // total malloc'd memory in snapshot + inline size_t total_malloc_amount() const { + return _total_malloced; + } + // total mmap'd memory in snapshot + inline size_t total_reserved_amount() const { + return _total_vm_reserved; + } + // total committed memory in snapshot + inline size_t total_committed_amount() const { + return _total_vm_committed; + } + // number of loaded classes + inline size_t number_of_classes() const { + return _number_of_classes; + } + // number of running threads + inline size_t number_of_threads() const { + return _number_of_threads; + } + // lookup human readable name of a memory type + static const char* type2name(MEMFLAGS type); + + private: + // convert memory flag to the index to mapping table + int flag2index(MEMFLAGS flag) const; + + // reset baseline values + void reset(); + + // summarize the records in global snapshot + bool baseline_malloc_summary(const MemPointerArray* malloc_records); + bool baseline_vm_summary(const MemPointerArray* vm_records); + bool baseline_malloc_details(const MemPointerArray* malloc_records); + bool baseline_vm_details(const MemPointerArray* vm_records); + + // print a line of malloc'd memory aggregated by callsite + void print_malloc_callsite(outputStream* st, address pc, size_t size, + size_t count, int diff_amt, int diff_count) const; + // print a line of mmap'd memory aggregated by callsite + void print_vm_callsite(outputStream* st, address pc, size_t rsz, + size_t csz, int diff_rsz, int diff_csz) const; + + // sorting functions for raw records + static int malloc_sort_by_pc(const void* p1, const void* p2); + static int malloc_sort_by_addr(const void* p1, const void* p2); + + static int vm_sort_by_pc(const void* p1, const void* p2); + static int vm_sort_by_addr(const void* p1, const void* p2); + + private: + // sorting functions for baselined records + static int bl_malloc_sort_by_size(const void* p1, const void* p2); + static int bl_vm_sort_by_size(const void* p1, const void* p2); + static int bl_malloc_sort_by_pc(const void* p1, const void* p2); + static int bl_vm_sort_by_pc(const void* p1, const void* p2); +}; + + +#endif // SHARE_VM_SERVICES_MEM_BASELINE_HPP diff --git a/hotspot/src/share/vm/services/memPtr.cpp b/hotspot/src/share/vm/services/memPtr.cpp new file mode 100644 index 00000000000..c11c374fd14 --- /dev/null +++ b/hotspot/src/share/vm/services/memPtr.cpp @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "services/memPtr.hpp" +#include "services/memTracker.hpp" + +volatile jint SequenceGenerator::_seq_number = 1; +DEBUG_ONLY(jint SequenceGenerator::_max_seq_number = 1;) +DEBUG_ONLY(volatile unsigned long SequenceGenerator::_generation = 0;) + +jint SequenceGenerator::next() { + jint seq = Atomic::add(1, &_seq_number); + if (seq < 0) { + MemTracker::shutdown(MemTracker::NMT_sequence_overflow); + } + assert(seq > 0, "counter overflow"); + DEBUG_ONLY(_max_seq_number = (seq > _max_seq_number) ? seq : _max_seq_number;) + return seq; +} + + + +bool VMMemRegion::contains(const VMMemRegion* mr) const { + assert(base() != 0, "no base address"); + assert(size() != 0 || committed_size() != 0, + "no range"); + address base_addr = base(); + address end_addr = base_addr + + (is_reserve_record()? reserved_size(): committed_size()); + if (mr->is_reserve_record()) { + if (mr->base() == base_addr && mr->size() == size()) { + // the same range + return true; + } + return false; + } else if (mr->is_commit_record() || mr->is_uncommit_record()) { + assert(mr->base() != 0 && mr->committed_size() > 0, + "bad record"); + return (mr->base() >= base_addr && + (mr->base() + mr->committed_size()) <= end_addr); + } else if (mr->is_type_tagging_record()) { + assert(mr->base() != 0, "no base"); + return mr->base() == base_addr; + } else if (mr->is_release_record()) { + assert(mr->base() != 0 && mr->size() > 0, + "bad record"); + return (mr->base() == base_addr && mr->size() == size()); + } else { + assert(false, "what happened?"); + return false; + } +} diff --git a/hotspot/src/share/vm/services/memPtr.hpp b/hotspot/src/share/vm/services/memPtr.hpp new file mode 100644 index 00000000000..b8b41c326f1 --- /dev/null +++ b/hotspot/src/share/vm/services/memPtr.hpp @@ -0,0 +1,509 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_SERVICES_MEM_PTR_HPP +#define SHARE_VM_SERVICES_MEM_PTR_HPP + +#include "memory/allocation.hpp" +#include "runtime/atomic.hpp" +#include "runtime/os.hpp" +#include "runtime/safepoint.hpp" + +/* + * global sequence generator that generates sequence numbers to serialize + * memory records. + */ +class SequenceGenerator : AllStatic { + public: + static jint next(); + + // peek last sequence number + static jint peek() { + return _seq_number; + } + + // reset sequence number + static void reset() { + assert(SafepointSynchronize::is_at_safepoint(), "Safepoint required"); + _seq_number = 1; + DEBUG_ONLY(_generation ++;) + }; + + DEBUG_ONLY(static unsigned long current_generation() { return (unsigned long)_generation; }) + DEBUG_ONLY(static jint max_seq_num() { return _max_seq_number; }) + + private: + static volatile jint _seq_number; + DEBUG_ONLY(static jint _max_seq_number; ) + DEBUG_ONLY(static volatile unsigned long _generation; ) +}; + +/* + * followings are the classes that are used to hold memory activity records in different stages. + * MemPointer + * |--------MemPointerRecord + * | + * |----MemPointerRecordEx + * | | + * | |-------SeqMemPointerRecordEx + * | + * |----SeqMemPointerRecord + * | + * |----VMMemRegion + * | + * |-----VMMemRegionEx + * + * + * prefix 'Seq' - sequenced, the record contains a sequence number + * surfix 'Ex' - extension, the record contains a caller's pc + * + * per-thread recorder : SeqMemPointerRecord(Ex) + * snapshot staging : SeqMemPointerRecord(Ex) + * snapshot : MemPointerRecord(Ex) and VMMemRegion(Ex) + * + */ + +/* + * class that wraps an address to a memory block, + * the memory pointer either points to a malloc'd + * memory block, or a mmap'd memory block + */ +class MemPointer : public _ValueObj { + public: + MemPointer(): _addr(0) { } + MemPointer(address addr): _addr(addr) { } + + MemPointer(const MemPointer& copy_from) { + _addr = copy_from.addr(); + } + + inline address addr() const { + return _addr; + } + + inline operator address() const { + return addr(); + } + + inline bool operator == (const MemPointer& other) const { + return addr() == other.addr(); + } + + inline MemPointer& operator = (const MemPointer& other) { + _addr = other.addr(); + return *this; + } + + protected: + inline void set_addr(address addr) { _addr = addr; } + + protected: + // memory address + address _addr; +}; + +/* MemPointerRecord records an activityand associated + * attributes on a memory block. + */ +class MemPointerRecord : public MemPointer { + private: + MEMFLAGS _flags; + size_t _size; + +public: + /* extension of MemoryType enum + * see share/vm/memory/allocation.hpp for details. + * + * The tag values are associated to sorting orders, so be + * careful if changes are needed. + * The allocation records should be sorted ahead of tagging + * records, which in turn ahead of deallocation records + */ + enum MemPointerTags { + tag_alloc = 0x0001, // malloc or reserve record + tag_commit = 0x0002, // commit record + tag_type = 0x0003, // tag virtual memory to a memory type + tag_uncommit = 0x0004, // uncommit record + tag_release = 0x0005, // free or release record + tag_size = 0x0006, // arena size + tag_masks = 0x0007, // all tag bits + vmBit = 0x0008 + }; + + /* helper functions to interpret the tagging flags */ + + inline static bool is_allocation_record(MEMFLAGS flags) { + return (flags & tag_masks) == tag_alloc; + } + + inline static bool is_deallocation_record(MEMFLAGS flags) { + return (flags & tag_masks) == tag_release; + } + + inline static bool is_arena_record(MEMFLAGS flags) { + return (flags & (otArena | tag_size)) == otArena; + } + + inline static bool is_arena_size_record(MEMFLAGS flags) { + return (flags & (otArena | tag_size)) == (otArena | tag_size); + } + + inline static bool is_virtual_memory_record(MEMFLAGS flags) { + return (flags & vmBit) != 0; + } + + inline static bool is_virtual_memory_reserve_record(MEMFLAGS flags) { + return (flags & 0x0F) == (tag_alloc | vmBit); + } + + inline static bool is_virtual_memory_commit_record(MEMFLAGS flags) { + return (flags & 0x0F) == (tag_commit | vmBit); + } + + inline static bool is_virtual_memory_uncommit_record(MEMFLAGS flags) { + return (flags & 0x0F) == (tag_uncommit | vmBit); + } + + inline static bool is_virtual_memory_release_record(MEMFLAGS flags) { + return (flags & 0x0F) == (tag_release | vmBit); + } + + inline static bool is_virtual_memory_type_record(MEMFLAGS flags) { + return (flags & 0x0F) == (tag_type | vmBit); + } + + /* tagging flags */ + inline static MEMFLAGS malloc_tag() { return tag_alloc; } + inline static MEMFLAGS free_tag() { return tag_release; } + inline static MEMFLAGS arena_size_tag() { return tag_size | otArena; } + inline static MEMFLAGS virtual_memory_tag() { return vmBit; } + inline static MEMFLAGS virtual_memory_reserve_tag() { return (tag_alloc | vmBit); } + inline static MEMFLAGS virtual_memory_commit_tag() { return (tag_commit | vmBit); } + inline static MEMFLAGS virtual_memory_uncommit_tag(){ return (tag_uncommit | vmBit); } + inline static MEMFLAGS virtual_memory_release_tag() { return (tag_release | vmBit); } + inline static MEMFLAGS virtual_memory_type_tag() { return (tag_type | vmBit); } + + public: + MemPointerRecord(): _size(0), _flags(mtNone) { } + + MemPointerRecord(address addr, MEMFLAGS memflags, size_t size = 0): + MemPointer(addr), _flags(memflags), _size(size) { } + + MemPointerRecord(const MemPointerRecord& copy_from): + MemPointer(copy_from), _flags(copy_from.flags()), + _size(copy_from.size()) { + } + + /* MemPointerRecord is not sequenced, it always return + * 0 to indicate non-sequenced + */ + virtual jint seq() const { return 0; } + + inline size_t size() const { return _size; } + inline void set_size(size_t size) { _size = size; } + + inline MEMFLAGS flags() const { return _flags; } + inline void set_flags(MEMFLAGS flags) { _flags = flags; } + + MemPointerRecord& operator= (const MemPointerRecord& ptr) { + MemPointer::operator=(ptr); + _flags = ptr.flags(); +#ifdef ASSERT + if (IS_ARENA_OBJ(_flags)) { + assert(!is_vm_pointer(), "wrong flags"); + assert((_flags & ot_masks) == otArena, "wrong flags"); + } +#endif + _size = ptr.size(); + return *this; + } + + // if the pointer represents a malloc-ed memory address + inline bool is_malloced_pointer() const { + return !is_vm_pointer(); + } + + // if the pointer represents a virtual memory address + inline bool is_vm_pointer() const { + return is_virtual_memory_record(_flags); + } + + // if this record records a 'malloc' or virtual memory + // 'reserve' call + inline bool is_allocation_record() const { + return is_allocation_record(_flags); + } + + // if this record records a size information of an arena + inline bool is_arena_size_record() const { + return is_arena_size_record(_flags); + } + + // if this pointer represents an address to an arena object + inline bool is_arena_record() const { + return is_arena_record(_flags); + } + + // if this record represents a size information of specific arena + inline bool is_size_record_of_arena(const MemPointerRecord* arena_rc) { + assert(is_arena_size_record(), "not size record"); + assert(arena_rc->is_arena_record(), "not arena record"); + return (arena_rc->addr() + sizeof(void*)) == addr(); + } + + // if this record records a 'free' or virtual memory 'free' call + inline bool is_deallocation_record() const { + return is_deallocation_record(_flags); + } + + // if this record records a virtual memory 'commit' call + inline bool is_commit_record() const { + return is_virtual_memory_commit_record(_flags); + } + + // if this record records a virtual memory 'uncommit' call + inline bool is_uncommit_record() const { + return is_virtual_memory_uncommit_record(_flags); + } + + // if this record is a tagging record of a virtual memory block + inline bool is_type_tagging_record() const { + return is_virtual_memory_type_record(_flags); + } +}; + +// MemPointerRecordEx also records callsite pc, from where +// the memory block is allocated +class MemPointerRecordEx : public MemPointerRecord { + private: + address _pc; // callsite pc + + public: + MemPointerRecordEx(): _pc(0) { } + + MemPointerRecordEx(address addr, MEMFLAGS memflags, size_t size = 0, address pc = 0): + MemPointerRecord(addr, memflags, size), _pc(pc) {} + + MemPointerRecordEx(const MemPointerRecordEx& copy_from): + MemPointerRecord(copy_from), _pc(copy_from.pc()) {} + + inline address pc() const { return _pc; } + + void init(const MemPointerRecordEx* mpe) { + MemPointerRecord::operator=(*mpe); + _pc = mpe->pc(); + } + + void init(const MemPointerRecord* mp) { + MemPointerRecord::operator=(*mp); + _pc = 0; + } +}; + +// a virtual memory region +class VMMemRegion : public MemPointerRecord { + private: + // committed size + size_t _committed_size; + +public: + VMMemRegion(): _committed_size(0) { } + + void init(const MemPointerRecord* mp) { + assert(mp->is_vm_pointer(), "not virtual memory pointer"); + _addr = mp->addr(); + if (mp->is_commit_record() || mp->is_uncommit_record()) { + _committed_size = mp->size(); + set_size(_committed_size); + } else { + set_size(mp->size()); + _committed_size = 0; + } + set_flags(mp->flags()); + } + + VMMemRegion& operator=(const VMMemRegion& other) { + MemPointerRecord::operator=(other); + _committed_size = other.committed_size(); + return *this; + } + + inline bool is_reserve_record() const { + return is_virtual_memory_reserve_record(flags()); + } + + inline bool is_release_record() const { + return is_virtual_memory_release_record(flags()); + } + + // resize reserved VM range + inline void set_reserved_size(size_t new_size) { + assert(new_size >= committed_size(), "resize"); + set_size(new_size); + } + + inline void commit(size_t size) { + _committed_size += size; + } + + inline void uncommit(size_t size) { + if (_committed_size >= size) { + _committed_size -= size; + } else { + _committed_size = 0; + } + } + + /* + * if this virtual memory range covers whole range of + * the other VMMemRegion + */ + bool contains(const VMMemRegion* mr) const; + + /* base address of this virtual memory range */ + inline address base() const { + return addr(); + } + + /* tag this virtual memory range to the specified memory type */ + inline void tag(MEMFLAGS f) { + set_flags(flags() | (f & mt_masks)); + } + + // release part of memory range + inline void partial_release(address add, size_t sz) { + assert(add >= addr() && add < addr() + size(), "not valid address"); + // for now, it can partially release from the both ends, + // but not in the middle + assert(add == addr() || (add + sz) == (addr() + size()), + "release in the middle"); + if (add == addr()) { + set_addr(add + sz); + set_size(size() - sz); + } else { + set_size(size() - sz); + } + } + + // the committed size of the virtual memory block + inline size_t committed_size() const { + return _committed_size; + } + + // the reserved size of the virtual memory block + inline size_t reserved_size() const { + return size(); + } +}; + +class VMMemRegionEx : public VMMemRegion { + private: + jint _seq; // sequence number + + public: + VMMemRegionEx(): _pc(0) { } + + void init(const MemPointerRecordEx* mpe) { + VMMemRegion::init(mpe); + _pc = mpe->pc(); + } + + void init(const MemPointerRecord* mpe) { + VMMemRegion::init(mpe); + _pc = 0; + } + + VMMemRegionEx& operator=(const VMMemRegionEx& other) { + VMMemRegion::operator=(other); + _pc = other.pc(); + return *this; + } + + inline address pc() const { return _pc; } + private: + address _pc; +}; + +/* + * Sequenced memory record + */ +class SeqMemPointerRecord : public MemPointerRecord { + private: + jint _seq; // sequence number + + public: + SeqMemPointerRecord(): _seq(0){ } + + SeqMemPointerRecord(address addr, MEMFLAGS flags, size_t size) + : MemPointerRecord(addr, flags, size) { + _seq = SequenceGenerator::next(); + } + + SeqMemPointerRecord(const SeqMemPointerRecord& copy_from) + : MemPointerRecord(copy_from) { + _seq = copy_from.seq(); + } + + SeqMemPointerRecord& operator= (const SeqMemPointerRecord& ptr) { + MemPointerRecord::operator=(ptr); + _seq = ptr.seq(); + return *this; + } + + inline jint seq() const { + return _seq; + } +}; + + + +class SeqMemPointerRecordEx : public MemPointerRecordEx { + private: + jint _seq; // sequence number + + public: + SeqMemPointerRecordEx(): _seq(0) { } + + SeqMemPointerRecordEx(address addr, MEMFLAGS flags, size_t size, + address pc): MemPointerRecordEx(addr, flags, size, pc) { + _seq = SequenceGenerator::next(); + } + + SeqMemPointerRecordEx(const SeqMemPointerRecordEx& copy_from) + : MemPointerRecordEx(copy_from) { + _seq = copy_from.seq(); + } + + SeqMemPointerRecordEx& operator= (const SeqMemPointerRecordEx& ptr) { + MemPointerRecordEx::operator=(ptr); + _seq = ptr.seq(); + return *this; + } + + inline jint seq() const { + return _seq; + } +}; + +#endif // SHARE_VM_SERVICES_MEM_PTR_HPP diff --git a/hotspot/src/share/vm/services/memPtrArray.hpp b/hotspot/src/share/vm/services/memPtrArray.hpp new file mode 100644 index 00000000000..1b1b570ac0f --- /dev/null +++ b/hotspot/src/share/vm/services/memPtrArray.hpp @@ -0,0 +1,310 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ +#ifndef SHARE_VM_UTILITIES_MEM_PTR_ARRAY_HPP +#define SHARE_VM_UTILITIES_MEM_PTR_ARRAY_HPP + +#include "memory/allocation.hpp" +#include "services/memPtr.hpp" + +class MemPtr; +class MemRecorder; +class ArenaInfo; +class MemSnapshot; + +extern "C" { + typedef int (*FN_SORT)(const void *, const void *); +} + + +// Memory pointer array interface. This array is used by NMT to hold +// various memory block information. +// The memory pointer arrays are usually walked with their iterators. + +class MemPointerArray : public CHeapObj { + public: + virtual ~MemPointerArray() { } + + // return true if it can not allocate storage for the data + virtual bool out_of_memory() const = 0; + virtual bool is_empty() const = 0; + virtual bool is_full() = 0; + virtual int length() const = 0; + virtual void clear() = 0; + virtual bool append(MemPointer* ptr) = 0; + virtual bool insert_at(MemPointer* ptr, int pos) = 0; + virtual bool remove_at(int pos) = 0; + virtual MemPointer* at(int index) const = 0; + virtual void sort(FN_SORT fn) = 0; + virtual size_t instance_size() const = 0; + virtual bool shrink() = 0; + + debug_only(virtual int capacity() const = 0;) +}; + +// Iterator interface +class MemPointerArrayIterator VALUE_OBJ_CLASS_SPEC { + public: + // return the pointer at current position + virtual MemPointer* current() const = 0; + // return the next pointer and advance current position + virtual MemPointer* next() = 0; + // return next pointer without advancing current position + virtual MemPointer* peek_next() const = 0; + // return previous pointer without changing current position + virtual MemPointer* peek_prev() const = 0; + // remove the pointer at current position + virtual void remove() = 0; + // insert the pointer at current position + virtual bool insert(MemPointer* ptr) = 0; + // insert specified element after current position and + // move current position to newly inserted position + virtual bool insert_after(MemPointer* ptr) = 0; +}; + +// implementation class +class MemPointerArrayIteratorImpl : public MemPointerArrayIterator { +#ifdef ASSERT + protected: +#else + private: +#endif + MemPointerArray* _array; + int _pos; + + public: + MemPointerArrayIteratorImpl(MemPointerArray* arr) { + assert(arr != NULL, "Parameter check"); + _array = arr; + _pos = 0; + } + + virtual MemPointer* current() const { + if (_pos < _array->length()) { + return _array->at(_pos); + } + return NULL; + } + + virtual MemPointer* next() { + if (_pos + 1 < _array->length()) { + return _array->at(++_pos); + } + _pos = _array->length(); + return NULL; + } + + virtual MemPointer* peek_next() const { + if (_pos + 1 < _array->length()) { + return _array->at(_pos + 1); + } + return NULL; + } + + virtual MemPointer* peek_prev() const { + if (_pos > 0) { + return _array->at(_pos - 1); + } + return NULL; + } + + virtual void remove() { + if (_pos < _array->length()) { + _array->remove_at(_pos); + } + } + + virtual bool insert(MemPointer* ptr) { + return _array->insert_at(ptr, _pos); + } + + virtual bool insert_after(MemPointer* ptr) { + if (_array->insert_at(ptr, _pos + 1)) { + _pos ++; + return true; + } + return false; + } +}; + + + +// Memory pointer array implementation. +// This implementation implements expandable array +#define DEFAULT_PTR_ARRAY_SIZE 1024 + +template class MemPointerArrayImpl : public MemPointerArray { + private: + int _max_size; + int _size; + bool _init_elements; + E* _data; + + public: + MemPointerArrayImpl(int initial_size = DEFAULT_PTR_ARRAY_SIZE, bool init_elements = true): + _max_size(initial_size), _size(0), _init_elements(init_elements) { + _data = (E*)raw_allocate(sizeof(E), initial_size); + if (_init_elements) { + for (int index = 0; index < _max_size; index ++) { + ::new ((void*)&_data[index]) E(); + } + } + } + + virtual ~MemPointerArrayImpl() { + if (_data != NULL) { + raw_free(_data); + } + } + + public: + bool out_of_memory() const { + return (_data == NULL); + } + + size_t instance_size() const { + return sizeof(MemPointerArrayImpl) + _max_size * sizeof(E); + } + + bool is_empty() const { + assert(_data != NULL, "Just check"); + return _size == 0; + } + + bool is_full() { + assert(_data != NULL, "Just check"); + if (_size < _max_size) { + return false; + } else { + return !expand_array(); + } + } + + int length() const { + assert(_data != NULL, "Just check"); + return _size; + } + + debug_only(int capacity() const { return _max_size; }) + + void clear() { + assert(_data != NULL, "Just check"); + _size = 0; + } + + bool append(MemPointer* ptr) { + assert(_data != NULL, "Just check"); + if (is_full()) { + return false; + } + _data[_size ++] = *(E*)ptr; + return true; + } + + bool insert_at(MemPointer* ptr, int pos) { + assert(_data != NULL, "Just check"); + if (is_full()) { + return false; + } + for (int index = _size; index > pos; index --) { + _data[index] = _data[index - 1]; + } + _data[pos] = *(E*)ptr; + _size ++; + return true; + } + + bool remove_at(int pos) { + assert(_data != NULL, "Just check"); + if (_size <= pos && pos >= 0) { + return false; + } + -- _size; + + for (int index = pos; index < _size; index ++) { + _data[index] = _data[index + 1]; + } + return true; + } + + MemPointer* at(int index) const { + assert(_data != NULL, "Just check"); + assert(index >= 0 && index < _size, "illegal index"); + return &_data[index]; + } + + bool shrink() { + float used = ((float)_size) / ((float)_max_size); + if (used < 0.40) { + E* old_ptr = _data; + int new_size = ((_max_size) / (2 * DEFAULT_PTR_ARRAY_SIZE) + 1) * DEFAULT_PTR_ARRAY_SIZE; + _data = (E*)raw_reallocate(_data, sizeof(E), new_size); + if (_data == NULL) { + _data = old_ptr; + return false; + } else { + _max_size = new_size; + return true; + } + } + return false; + } + + void sort(FN_SORT fn) { + assert(_data != NULL, "Just check"); + qsort((void*)_data, _size, sizeof(E), fn); + } + + private: + bool expand_array() { + assert(_data != NULL, "Not yet allocated"); + E* old_ptr = _data; + if ((_data = (E*)raw_reallocate((void*)_data, sizeof(E), + _max_size + DEFAULT_PTR_ARRAY_SIZE)) == NULL) { + _data = old_ptr; + return false; + } else { + _max_size += DEFAULT_PTR_ARRAY_SIZE; + if (_init_elements) { + for (int index = _size; index < _max_size; index ++) { + ::new ((void*)&_data[index]) E(); + } + } + return true; + } + } + + void* raw_allocate(size_t elementSize, int items) { + return os::malloc(elementSize * items, mtNMT); + } + + void* raw_reallocate(void* ptr, size_t elementSize, int items) { + return os::realloc(ptr, elementSize * items, mtNMT); + } + + void raw_free(void* ptr) { + os::free(ptr, mtNMT); + } +}; + +#endif // SHARE_VM_UTILITIES_MEM_PTR_ARRAY_HPP diff --git a/hotspot/src/share/vm/services/memRecorder.cpp b/hotspot/src/share/vm/services/memRecorder.cpp new file mode 100644 index 00000000000..52b2eae62a0 --- /dev/null +++ b/hotspot/src/share/vm/services/memRecorder.cpp @@ -0,0 +1,162 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" + +#include "runtime/atomic.hpp" +#include "services/memBaseline.hpp" +#include "services/memRecorder.hpp" +#include "services/memPtr.hpp" +#include "services/memTracker.hpp" + +MemPointer* SequencedRecordIterator::next_record() { + MemPointer* itr_cur = _itr.current(); + if (itr_cur == NULL) return NULL; + MemPointer* itr_next = _itr.next(); + + while (itr_next != NULL && + same_kind((MemPointerRecord*)itr_cur, (MemPointerRecord*)itr_next)) { + itr_cur = itr_next; + itr_next = _itr.next(); + } + + return itr_cur; +} + + +debug_only(volatile jint MemRecorder::_instance_count = 0;) + +MemRecorder::MemRecorder() { + assert(MemTracker::is_on(), "Native memory tracking is off"); + debug_only(Atomic::inc(&_instance_count);) + debug_only(set_generation();) + + if (MemTracker::track_callsite()) { + _pointer_records = new (std::nothrow)FixedSizeMemPointerArray(); + } else { + _pointer_records = new (std::nothrow)FixedSizeMemPointerArray(); + } + _next = NULL; + + + if (_pointer_records != NULL) { + // recode itself + record((address)this, (MemPointerRecord::malloc_tag()|mtNMT|otNMTRecorder), + sizeof(MemRecorder), CALLER_PC); + record((address)_pointer_records, (MemPointerRecord::malloc_tag()|mtNMT|otNMTRecorder), + _pointer_records->instance_size(),CURRENT_PC); + } +} + +MemRecorder::~MemRecorder() { + if (_pointer_records != NULL) { + if (MemTracker::is_on()) { + MemTracker::record_free((address)_pointer_records, mtNMT); + MemTracker::record_free((address)this, mtNMT); + } + delete _pointer_records; + } + if (_next != NULL) { + delete _next; + } + +#ifdef ASSERT + Atomic::dec(&_instance_count); +#endif +} + +// Sorting order: +// 1. memory block address +// 2. mem pointer record tags +// 3. sequence number +int MemRecorder::sort_record_fn(const void* e1, const void* e2) { + const MemPointerRecord* p1 = (const MemPointerRecord*)e1; + const MemPointerRecord* p2 = (const MemPointerRecord*)e2; + int delta = UNSIGNED_COMPARE(p1->addr(), p2->addr()); + if (delta == 0) { + int df = UNSIGNED_COMPARE((p1->flags() & MemPointerRecord::tag_masks), + (p2->flags() & MemPointerRecord::tag_masks)); + if (df == 0) { + assert(p1->seq() != p2->seq(), "dup seq"); + return p1->seq() - p2->seq(); + } else { + return df; + } + } else { + return delta; + } +} + +bool MemRecorder::record(address p, MEMFLAGS flags, size_t size, address pc) { +#ifdef ASSERT + if (MemPointerRecord::is_virtual_memory_record(flags)) { + assert((flags & MemPointerRecord::tag_masks) != 0, "bad virtual memory record"); + } else { + assert((flags & MemPointerRecord::tag_masks) == MemPointerRecord::malloc_tag() || + (flags & MemPointerRecord::tag_masks) == MemPointerRecord::free_tag() || + IS_ARENA_OBJ(flags), + "bad malloc record"); + } + // a recorder should only hold records within the same generation + unsigned long cur_generation = SequenceGenerator::current_generation(); + assert(cur_generation == _generation, + "this thread did not enter sync point"); +#endif + + if (MemTracker::track_callsite()) { + SeqMemPointerRecordEx ap(p, flags, size, pc); + debug_only(check_dup_seq(ap.seq());) + return _pointer_records->append(&ap); + } else { + SeqMemPointerRecord ap(p, flags, size); + debug_only(check_dup_seq(ap.seq());) + return _pointer_records->append(&ap); + } +} + + // iterator for alloc pointers +SequencedRecordIterator MemRecorder::pointer_itr() { + assert(_pointer_records != NULL, "just check"); + _pointer_records->sort((FN_SORT)sort_record_fn); + return SequencedRecordIterator(_pointer_records); +} + + +#ifdef ASSERT +void MemRecorder::set_generation() { + _generation = SequenceGenerator::current_generation(); +} + +void MemRecorder::check_dup_seq(jint seq) const { + MemPointerArrayIteratorImpl itr(_pointer_records); + MemPointerRecord* rc = (MemPointerRecord*)itr.current(); + while (rc != NULL) { + assert(rc->seq() != seq, "dup seq"); + rc = (MemPointerRecord*)itr.next(); + } +} + +#endif diff --git a/hotspot/src/share/vm/services/memRecorder.hpp b/hotspot/src/share/vm/services/memRecorder.hpp new file mode 100644 index 00000000000..c243564db94 --- /dev/null +++ b/hotspot/src/share/vm/services/memRecorder.hpp @@ -0,0 +1,267 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_SERVICES_MEM_RECORDER_HPP +#define SHARE_VM_SERVICES_MEM_RECORDER_HPP + +#include "memory/allocation.hpp" +#include "runtime/os.hpp" +#include "services/memPtrArray.hpp" + +class MemSnapshot; +class MemTracker; +class MemTrackWorker; + +// Fixed size memory pointer array implementation +template class FixedSizeMemPointerArray : + public MemPointerArray { + // This implementation is for memory recorder only + friend class MemRecorder; + + private: + E _data[SIZE]; + int _size; + + protected: + FixedSizeMemPointerArray(bool init_elements = false): + _size(0){ + if (init_elements) { + for (int index = 0; index < SIZE; index ++) { + ::new ((void*)&_data[index]) E(); + } + } + } + + void* operator new(size_t size, const std::nothrow_t& nothrow_constant) { + // the instance is part of memRecorder, needs to be tagged with 'otNMTRecorder' + // to avoid recursion + return os::malloc(size, (mtNMT | otNMTRecorder)); + } + + void* operator new(size_t size) { + assert(false, "use nothrow version"); + return NULL; + } + + void operator delete(void* p) { + os::free(p, (mtNMT | otNMTRecorder)); + } + + // instance size + inline size_t instance_size() const { + return sizeof(FixedSizeMemPointerArray); + } + + debug_only(int capacity() const { return SIZE; }) + + public: + // implementation of public interface + bool out_of_memory() const { return false; } + bool is_empty() const { return _size == 0; } + bool is_full() { return length() >= SIZE; } + int length() const { return _size; } + + void clear() { + _size = 0; + } + + bool append(MemPointer* ptr) { + if (is_full()) return false; + _data[_size ++] = *(E*)ptr; + return true; + } + + virtual bool insert_at(MemPointer* p, int pos) { + assert(false, "append only"); + return false; + } + + virtual bool remove_at(int pos) { + assert(false, "not supported"); + return false; + } + + MemPointer* at(int index) const { + assert(index >= 0 && index < length(), + "parameter check"); + return ((E*)&_data[index]); + } + + void sort(FN_SORT fn) { + qsort((void*)_data, _size, sizeof(E), fn); + } + + bool shrink() { + return false; + } +}; + + +// This iterator requires pre-sorted MemPointerArray, which is sorted by: +// 1. address +// 2. allocation type +// 3. sequence number +// During the array walking, iterator collapses pointers with the same +// address and allocation type, and only returns the one with highest +// sequence number. +// +// This is read-only iterator, update methods are asserted. +class SequencedRecordIterator : public MemPointerArrayIterator { + private: + MemPointerArrayIteratorImpl _itr; + MemPointer* _cur; + + public: + SequencedRecordIterator(const MemPointerArray* arr): + _itr(const_cast(arr)) { + _cur = next_record(); + } + + SequencedRecordIterator(const SequencedRecordIterator& itr): + _itr(itr._itr) { + _cur = next_record(); + } + + // return the pointer at current position + virtual MemPointer* current() const { + return _cur; + }; + + // return the next pointer and advance current position + virtual MemPointer* next() { + _cur = next_record(); + return _cur; + } + + // return the next pointer without advancing current position + virtual MemPointer* peek_next() const { + assert(false, "not implemented"); + return NULL; + + } + // return the previous pointer without changing current position + virtual MemPointer* peek_prev() const { + assert(false, "not implemented"); + return NULL; + } + + // remove the pointer at current position + virtual void remove() { + assert(false, "read-only iterator"); + }; + // insert the pointer at current position + virtual bool insert(MemPointer* ptr) { + assert(false, "read-only iterator"); + return false; + } + + virtual bool insert_after(MemPointer* ptr) { + assert(false, "read-only iterator"); + return false; + } + private: + // collapse the 'same kind' of records, and return this 'kind' of + // record with highest sequence number + MemPointer* next_record(); + + // Test if the two records are the same kind: the same memory block and allocation + // type. + inline bool same_kind(const MemPointerRecord* p1, const MemPointerRecord* p2) const { + return (p1->addr() == p2->addr() && + (p1->flags() &MemPointerRecord::tag_masks) == + (p2->flags() & MemPointerRecord::tag_masks)); + } +}; + + + +#define DEFAULT_RECORDER_PTR_ARRAY_SIZE 512 + +class MemRecorder : public CHeapObj { + friend class MemSnapshot; + friend class MemTracker; + friend class MemTrackWorker; + + protected: + // the array that holds memory records + MemPointerArray* _pointer_records; + + private: + // used for linked list + MemRecorder* _next; + // active recorder can only record a certain generation data + debug_only(unsigned long _generation;) + + protected: + _NOINLINE_ MemRecorder(); + ~MemRecorder(); + + // record a memory operation + bool record(address addr, MEMFLAGS flags, size_t size, address caller_pc = 0); + + // linked list support + inline void set_next(MemRecorder* rec) { + _next = rec; + } + + inline MemRecorder* next() const { + return _next; + } + + // if the recorder is full + inline bool is_full() const { + assert(_pointer_records != NULL, "just check"); + return _pointer_records->is_full(); + } + + // if running out of memory when initializing recorder's internal + // data + inline bool out_of_memory() const { + return (_pointer_records == NULL || + _pointer_records->out_of_memory()); + } + + inline void clear() { + assert(_pointer_records != NULL, "Just check"); + _pointer_records->clear(); + } + + SequencedRecordIterator pointer_itr(); + + public: + // number of MemRecorder instance + debug_only(static volatile jint _instance_count;) + + private: + // sorting function, sort records into following order + // 1. memory address + // 2. allocation type + // 3. sequence number + static int sort_record_fn(const void* e1, const void* e2); + + debug_only(void check_dup_seq(jint seq) const;) + debug_only(void set_generation();) +}; + +#endif // SHARE_VM_SERVICES_MEM_RECORDER_HPP diff --git a/hotspot/src/share/vm/services/memReporter.cpp b/hotspot/src/share/vm/services/memReporter.cpp new file mode 100644 index 00000000000..783d951de14 --- /dev/null +++ b/hotspot/src/share/vm/services/memReporter.cpp @@ -0,0 +1,560 @@ +/* + * Copyright (c) 2012 Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ +#include "precompiled.hpp" +#include "classfile/systemDictionary.hpp" +#include "runtime/os.hpp" +#include "services/memReporter.hpp" +#include "services/memPtrArray.hpp" +#include "services/memTracker.hpp" + +const char* BaselineOutputer::memory_unit(size_t scale) { + switch(scale) { + case K: return "KB"; + case M: return "MB"; + case G: return "GB"; + } + ShouldNotReachHere(); + return NULL; +} + + +void BaselineReporter::report_baseline(const MemBaseline& baseline, bool summary_only) { + assert(MemTracker::is_on(), "Native memory tracking is off"); + _outputer.start(scale()); + _outputer.total_usage( + amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_reserved_amount()), + amount_in_current_scale(baseline.total_malloc_amount() + baseline.total_committed_amount())); + + _outputer.num_of_classes(baseline.number_of_classes()); + _outputer.num_of_threads(baseline.number_of_threads()); + + report_summaries(baseline); + if (!summary_only && MemTracker::track_callsite()) { + report_callsites(baseline); + } + _outputer.done(); +} + +void BaselineReporter::report_summaries(const MemBaseline& baseline) { + _outputer.start_category_summary(); + MEMFLAGS type; + + for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { + type = MemBaseline::MemType2NameMap[index]._flag; + _outputer.category_summary(type, + amount_in_current_scale(baseline.reserved_amount(type)), + amount_in_current_scale(baseline.committed_amount(type)), + amount_in_current_scale(baseline.malloc_amount(type)), + baseline.malloc_count(type), + amount_in_current_scale(baseline.arena_amount(type)), + baseline.arena_count(type)); + } + + _outputer.done_category_summary(); +} + +void BaselineReporter::report_callsites(const MemBaseline& baseline) { + _outputer.start_callsite(); + MemBaseline* pBL = const_cast(&baseline); + + pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_size); + pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_size); + + // walk malloc callsites + MemPointerArrayIteratorImpl malloc_itr(pBL->_malloc_cs); + MallocCallsitePointer* malloc_callsite = + (MallocCallsitePointer*)malloc_itr.current(); + while (malloc_callsite != NULL) { + _outputer.malloc_callsite(malloc_callsite->addr(), + amount_in_current_scale(malloc_callsite->amount()), malloc_callsite->count()); + malloc_callsite = (MallocCallsitePointer*)malloc_itr.next(); + } + + // walk virtual memory callsite + MemPointerArrayIteratorImpl vm_itr(pBL->_vm_cs); + VMCallsitePointer* vm_callsite = (VMCallsitePointer*)vm_itr.current(); + while (vm_callsite != NULL) { + _outputer.virtual_memory_callsite(vm_callsite->addr(), + amount_in_current_scale(vm_callsite->reserved_amount()), + amount_in_current_scale(vm_callsite->committed_amount())); + vm_callsite = (VMCallsitePointer*)vm_itr.next(); + } + pBL->_malloc_cs->sort((FN_SORT)MemBaseline::bl_malloc_sort_by_pc); + pBL->_vm_cs->sort((FN_SORT)MemBaseline::bl_vm_sort_by_pc); + _outputer.done_callsite(); +} + +void BaselineReporter::diff_baselines(const MemBaseline& cur, const MemBaseline& prev, + bool summary_only) { + assert(MemTracker::is_on(), "Native memory tracking is off"); + _outputer.start(scale()); + size_t total_reserved = cur.total_malloc_amount() + cur.total_reserved_amount(); + size_t total_committed = cur.total_malloc_amount() + cur.total_committed_amount(); + + _outputer.diff_total_usage( + amount_in_current_scale(total_reserved), amount_in_current_scale(total_committed), + diff_in_current_scale(total_reserved, (prev.total_malloc_amount() + prev.total_reserved_amount())), + diff_in_current_scale(total_committed, (prev.total_committed_amount() + prev.total_malloc_amount()))); + + _outputer.diff_num_of_classes(cur.number_of_classes(), + diff(cur.number_of_classes(), prev.number_of_classes())); + _outputer.diff_num_of_threads(cur.number_of_threads(), + diff(cur.number_of_threads(), prev.number_of_threads())); + + diff_summaries(cur, prev); + if (!summary_only && MemTracker::track_callsite()) { + diff_callsites(cur, prev); + } + _outputer.done(); +} + +void BaselineReporter::diff_summaries(const MemBaseline& cur, const MemBaseline& prev) { + _outputer.start_category_summary(); + MEMFLAGS type; + + for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) { + type = MemBaseline::MemType2NameMap[index]._flag; + _outputer.diff_category_summary(type, + amount_in_current_scale(cur.reserved_amount(type)), + amount_in_current_scale(cur.committed_amount(type)), + amount_in_current_scale(cur.malloc_amount(type)), + cur.malloc_count(type), + amount_in_current_scale(cur.arena_amount(type)), + cur.arena_count(type), + diff_in_current_scale(cur.reserved_amount(type), prev.reserved_amount(type)), + diff_in_current_scale(cur.committed_amount(type), prev.committed_amount(type)), + diff_in_current_scale(cur.malloc_amount(type), prev.malloc_amount(type)), + diff(cur.malloc_count(type), prev.malloc_count(type)), + diff_in_current_scale(cur.arena_amount(type), prev.arena_amount(type)), + diff(cur.arena_count(type), prev.arena_count(type))); + } + + _outputer.done_category_summary(); +} + +void BaselineReporter::diff_callsites(const MemBaseline& cur, const MemBaseline& prev) { + _outputer.start_callsite(); + MemBaseline* pBL_cur = const_cast(&cur); + MemBaseline* pBL_prev = const_cast(&prev); + + // walk malloc callsites + MemPointerArrayIteratorImpl cur_malloc_itr(pBL_cur->_malloc_cs); + MemPointerArrayIteratorImpl prev_malloc_itr(pBL_prev->_malloc_cs); + + MallocCallsitePointer* cur_malloc_callsite = + (MallocCallsitePointer*)cur_malloc_itr.current(); + MallocCallsitePointer* prev_malloc_callsite = + (MallocCallsitePointer*)prev_malloc_itr.current(); + + while (cur_malloc_callsite != NULL || prev_malloc_callsite != NULL) { + if (prev_malloc_callsite == NULL || + cur_malloc_callsite->addr() < prev_malloc_callsite->addr()) { + _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), + amount_in_current_scale(cur_malloc_callsite->amount()), + cur_malloc_callsite->count(), + diff_in_current_scale(cur_malloc_callsite->amount(), 0), + diff(cur_malloc_callsite->count(), 0)); + cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); + } else if (prev_malloc_callsite == NULL || + cur_malloc_callsite->addr() > prev_malloc_callsite->addr()) { + _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), + amount_in_current_scale(prev_malloc_callsite->amount()), + prev_malloc_callsite->count(), + diff_in_current_scale(0, prev_malloc_callsite->amount()), + diff(0, prev_malloc_callsite->count())); + prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); + } else { // the same callsite + _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(), + amount_in_current_scale(cur_malloc_callsite->amount()), + cur_malloc_callsite->count(), + diff_in_current_scale(cur_malloc_callsite->amount(), prev_malloc_callsite->amount()), + diff(cur_malloc_callsite->count(), prev_malloc_callsite->count())); + cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next(); + prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next(); + } + } + + // walk virtual memory callsite + MemPointerArrayIteratorImpl cur_vm_itr(pBL_cur->_vm_cs); + MemPointerArrayIteratorImpl prev_vm_itr(pBL_prev->_vm_cs); + VMCallsitePointer* cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.current(); + VMCallsitePointer* prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.current(); + while (cur_vm_callsite != NULL || prev_vm_callsite != NULL) { + if (prev_vm_callsite == NULL || cur_vm_callsite->addr() < prev_vm_callsite->addr()) { + _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), + amount_in_current_scale(cur_vm_callsite->reserved_amount()), + amount_in_current_scale(cur_vm_callsite->committed_amount()), + diff_in_current_scale(cur_vm_callsite->reserved_amount(), 0), + diff_in_current_scale(cur_vm_callsite->committed_amount(), 0)); + cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); + } else if (cur_vm_callsite == NULL || cur_vm_callsite->addr() > prev_vm_callsite->addr()) { + _outputer.diff_virtual_memory_callsite(prev_vm_callsite->addr(), + amount_in_current_scale(prev_vm_callsite->reserved_amount()), + amount_in_current_scale(prev_vm_callsite->committed_amount()), + diff_in_current_scale(0, prev_vm_callsite->reserved_amount()), + diff_in_current_scale(0, prev_vm_callsite->committed_amount())); + prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); + } else { // the same callsite + _outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(), + amount_in_current_scale(cur_vm_callsite->reserved_amount()), + amount_in_current_scale(cur_vm_callsite->committed_amount()), + diff_in_current_scale(cur_vm_callsite->reserved_amount(), prev_vm_callsite->reserved_amount()), + diff_in_current_scale(cur_vm_callsite->committed_amount(), prev_vm_callsite->committed_amount())); + cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next(); + prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next(); + } + } + + _outputer.done_callsite(); +} + +size_t BaselineReporter::amount_in_current_scale(size_t amt) const { + return (size_t)(((float)amt/(float)_scale) + 0.5); +} + +int BaselineReporter::diff_in_current_scale(size_t value1, size_t value2) const { + return (int)(((float)value1 - (float)value2)/((float)_scale) + 0.5); +} + +int BaselineReporter::diff(size_t value1, size_t value2) const { + return ((int)value1 - (int)value2); +} + +void BaselineTTYOutputer::start(size_t scale, bool report_diff) { + _scale = scale; + _output->print_cr(" "); + _output->print_cr("Native Memory Tracking:"); + _output->print_cr(" "); +} + +void BaselineTTYOutputer::done() { + +} + +void BaselineTTYOutputer::total_usage(size_t total_reserved, size_t total_committed) { + const char* unit = memory_unit(_scale); + _output->print_cr("Total: reserved=%d%s, committed=%d%s", + total_reserved, unit, total_committed, unit); +} + +void BaselineTTYOutputer::start_category_summary() { + _output->print_cr(" "); +} + +/** + * report a summary of memory type + */ +void BaselineTTYOutputer::category_summary(MEMFLAGS type, + size_t reserved_amt, size_t committed_amt, size_t malloc_amt, + size_t malloc_count, size_t arena_amt, size_t arena_count) { + + // we report mtThreadStack under mtThread category + if (type == mtThreadStack) { + assert(malloc_amt == 0 && malloc_count == 0 && arena_amt == 0, + "Just check"); + _thread_stack_reserved = reserved_amt; + _thread_stack_committed = committed_amt; + } else { + const char* unit = memory_unit(_scale); + size_t total_reserved = (reserved_amt + malloc_amt + arena_amt); + size_t total_committed = (committed_amt + malloc_amt + arena_amt); + if (type == mtThread) { + total_reserved += _thread_stack_reserved; + total_committed += _thread_stack_committed; + } + + if (total_reserved > 0) { + _output->print_cr("-%26s (reserved=%d%s, committed=%d%s)", + MemBaseline::type2name(type), total_reserved, unit, + total_committed, unit); + + if (type == mtClass) { + _output->print_cr("%27s (classes #%d)", " ", _num_of_classes); + } else if (type == mtThread) { + _output->print_cr("%27s (thread #%d)", " ", _num_of_threads); + _output->print_cr("%27s (stack: reserved=%d%s, committed=%d%s)", " ", + _thread_stack_reserved, unit, _thread_stack_committed, unit); + } + + if (malloc_amt > 0) { + if (type != mtChunk) { + _output->print_cr("%27s (malloc=%d%s, #%d)", " ", malloc_amt, unit, + malloc_count); + } else { + _output->print_cr("%27s (malloc=%d%s)", " ", malloc_amt, unit); + } + } + + if (reserved_amt > 0) { + _output->print_cr("%27s (mmap: reserved=%d%s, committed=%d%s)", + " ", reserved_amt, unit, committed_amt, unit); + } + + if (arena_amt > 0) { + _output->print_cr("%27s (arena=%d%s, #%d)", " ", arena_amt, unit, arena_count); + } + + _output->print_cr(" "); + } + } +} + +void BaselineTTYOutputer::done_category_summary() { + _output->print_cr(" "); +} + +void BaselineTTYOutputer::start_callsite() { + _output->print_cr("Details:"); + _output->print_cr(" "); +} + +void BaselineTTYOutputer::done_callsite() { + _output->print_cr(" "); +} + +void BaselineTTYOutputer::malloc_callsite(address pc, size_t malloc_amt, + size_t malloc_count) { + if (malloc_amt > 0) { + const char* unit = memory_unit(_scale); + char buf[64]; + int offset; + if (pc == 0) { + _output->print("[BOOTSTRAP]%18s", " "); + } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { + _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); + _output->print("%28s", " "); + } else { + _output->print("[" PTR_FORMAT "]%18s", pc, " "); + } + + _output->print_cr("(malloc=%d%s #%d)", malloc_amt, unit, malloc_count); + _output->print_cr(" "); + } +} + +void BaselineTTYOutputer::virtual_memory_callsite(address pc, size_t reserved_amt, + size_t committed_amt) { + if (reserved_amt > 0) { + const char* unit = memory_unit(_scale); + char buf[64]; + int offset; + if (pc == 0) { + _output->print("[BOOTSTRAP]%18s", " "); + } else if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { + _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); + _output->print("%28s", " "); + } else { + _output->print("[" PTR_FORMAT "]%18s", " "); + } + + _output->print_cr("(mmap: reserved=%d%s, committed=%d%s)", + reserved_amt, unit, committed_amt, unit); + _output->print_cr(" "); + } +} + +void BaselineTTYOutputer::diff_total_usage(size_t total_reserved, + size_t total_committed, int reserved_diff, int committed_diff) { + const char* unit = memory_unit(_scale); + _output->print_cr("Total: reserved=%d%s %+d%s, committed=%d%s %+d%s", + total_reserved, unit, reserved_diff, unit, total_committed, unit, + committed_diff, unit); +} + +void BaselineTTYOutputer::diff_category_summary(MEMFLAGS type, + size_t cur_reserved_amt, size_t cur_committed_amt, + size_t cur_malloc_amt, size_t cur_malloc_count, + size_t cur_arena_amt, size_t cur_arena_count, + int reserved_diff, int committed_diff, int malloc_diff, + int malloc_count_diff, int arena_diff, int arena_count_diff) { + + if (type == mtThreadStack) { + assert(cur_malloc_amt == 0 && cur_malloc_count == 0 && + cur_arena_amt == 0, "Just check"); + _thread_stack_reserved = cur_reserved_amt; + _thread_stack_committed = cur_committed_amt; + _thread_stack_reserved_diff = reserved_diff; + _thread_stack_committed_diff = committed_diff; + } else { + const char* unit = memory_unit(_scale); + size_t total_reserved = (cur_reserved_amt + cur_malloc_amt + cur_arena_amt); + // nothing to report in this category + if (total_reserved == 0) { + return; + } + int diff_reserved = (reserved_diff + malloc_diff + arena_diff); + + // category summary + _output->print("-%26s (reserved=%d%s", MemBaseline::type2name(type), + total_reserved, unit); + + if (diff_reserved != 0) { + _output->print(" %+d%s", diff_reserved, unit); + } + + size_t total_committed = cur_committed_amt + cur_malloc_amt + cur_arena_amt; + _output->print(", committed=%d%s", total_committed, unit); + + int total_committed_diff = committed_diff + malloc_diff + arena_diff; + if (total_committed_diff != 0) { + _output->print(" %+d%s", total_committed_diff, unit); + } + + _output->print_cr(")"); + + // special cases + if (type == mtClass) { + _output->print("%27s (classes #%d", " ", _num_of_classes); + if (_num_of_classes_diff != 0) { + _output->print(" %+d", _num_of_classes_diff); + } + _output->print_cr(")"); + } else if (type == mtThread) { + // thread count + _output->print("%27s (thread #%d", " ", _num_of_threads); + if (_num_of_threads_diff != 0) { + _output->print_cr(" %+d)", _num_of_threads_diff); + } else { + _output->print_cr(")"); + } + _output->print("%27s (stack: reserved=%d%s", " ", _thread_stack_reserved, unit); + if (_thread_stack_reserved_diff != 0) { + _output->print(" %+d%s", _thread_stack_reserved_diff, unit); + } + + _output->print(", committed=%d%s", _thread_stack_committed, unit); + if (_thread_stack_committed_diff != 0) { + _output->print(" %+d%s",_thread_stack_committed_diff, unit); + } + + _output->print_cr(")"); + } + + // malloc'd memory + if (cur_malloc_amt > 0) { + _output->print("%27s (malloc=%d%s", " ", cur_malloc_amt, unit); + if (malloc_diff != 0) { + _output->print(" %+d%s", malloc_diff, unit); + } + if (type != mtChunk) { + _output->print(", #%d", cur_malloc_count); + if (malloc_count_diff) { + _output->print(" %+d", malloc_count_diff); + } + } + _output->print_cr(")"); + } + + // mmap'd memory + if (cur_reserved_amt > 0) { + _output->print("%27s (mmap: reserved=%d%s", " ", cur_reserved_amt, unit); + if (reserved_diff != 0) { + _output->print(" %+d%s", reserved_diff, unit); + } + + _output->print(", committed=%d%s", cur_committed_amt, unit); + if (committed_diff != 0) { + _output->print(" %+d%s", committed_diff, unit); + } + _output->print_cr(")"); + } + + // arena memory + if (cur_arena_amt > 0) { + _output->print("%27s (arena=%d%s", " ", cur_arena_amt, unit); + if (arena_diff != 0) { + _output->print(" %+d%s", arena_diff, unit); + } + _output->print(", #%d", cur_arena_count); + if (arena_count_diff != 0) { + _output->print(" %+d", arena_count_diff); + } + _output->print_cr(")"); + } + + _output->print_cr(" "); + } +} + +void BaselineTTYOutputer::diff_malloc_callsite(address pc, + size_t cur_malloc_amt, size_t cur_malloc_count, + int malloc_diff, int malloc_count_diff) { + if (malloc_diff != 0) { + const char* unit = memory_unit(_scale); + char buf[64]; + int offset; + if (pc == 0) { + _output->print_cr("[BOOTSTRAP]%18s", " "); + } else { + if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { + _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); + _output->print("%28s", " "); + } else { + _output->print("[" PTR_FORMAT "]%18s", pc, " "); + } + } + + _output->print("(malloc=%d%s", cur_malloc_amt, unit); + if (malloc_diff != 0) { + _output->print(" %+d%s", malloc_diff, unit); + } + _output->print(", #%d", cur_malloc_count); + if (malloc_count_diff != 0) { + _output->print(" %+d", malloc_count_diff); + } + _output->print_cr(")"); + _output->print_cr(" "); + } +} + +void BaselineTTYOutputer::diff_virtual_memory_callsite(address pc, + size_t cur_reserved_amt, size_t cur_committed_amt, + int reserved_diff, int committed_diff) { + if (reserved_diff != 0 || committed_diff != 0) { + const char* unit = memory_unit(_scale); + char buf[64]; + int offset; + if (pc == 0) { + _output->print_cr("[BOOSTRAP]%18s", " "); + } else { + if (os::dll_address_to_function_name(pc, buf, sizeof(buf), &offset)) { + _output->print_cr("[" PTR_FORMAT "] %s+0x%x", pc, buf, offset); + _output->print("%28s", " "); + } else { + _output->print("[" PTR_FORMAT "]%18s", " "); + } + } + + _output->print("(mmap: reserved=%d%s", cur_reserved_amt, unit); + if (reserved_diff != 0) { + _output->print(" %+d%s", reserved_diff, unit); + } + _output->print(", committed=%d%s", cur_committed_amt, unit); + if (committed_diff != 0) { + _output->print(" %+d%s", committed_diff, unit); + } + _output->print_cr(")"); + _output->print_cr(" "); + } +} diff --git a/hotspot/src/share/vm/services/memReporter.hpp b/hotspot/src/share/vm/services/memReporter.hpp new file mode 100644 index 00000000000..4ce64ba2d31 --- /dev/null +++ b/hotspot/src/share/vm/services/memReporter.hpp @@ -0,0 +1,268 @@ +/* + * Copyright (c) 2012 Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_SERVICES_MEM_REPORTER_HPP +#define SHARE_VM_SERVICES_MEM_REPORTER_HPP + +#include "runtime/mutexLocker.hpp" +#include "services/memBaseline.hpp" +#include "services/memTracker.hpp" +#include "utilities/ostream.hpp" + +/* + * MemBaselineReporter reports data to this outputer class, + * ReportOutputer is responsible for format, store and redirect + * the data to the final destination. + */ +class BaselineOutputer : public StackObj { + public: + // start to report memory usage in specified scale. + // if report_diff = true, the reporter reports baseline comparison + // information. + + virtual void start(size_t scale, bool report_diff = false) = 0; + // Done reporting + virtual void done() = 0; + + /* report baseline summary information */ + virtual void total_usage(size_t total_reserved, + size_t total_committed) = 0; + virtual void num_of_classes(size_t classes) = 0; + virtual void num_of_threads(size_t threads) = 0; + + virtual void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) = 0; + + /* report baseline summary comparison */ + virtual void diff_total_usage(size_t total_reserved, + size_t total_committed, + int reserved_diff, + int committed_diff) = 0; + virtual void diff_num_of_classes(size_t classes, int diff) = 0; + virtual void diff_num_of_threads(size_t threads, int diff) = 0; + + virtual void diff_thread_info(size_t stack_reserved, size_t stack_committed, + int stack_reserved_diff, int stack_committed_diff) = 0; + + + /* + * memory summary by memory types. + * for each memory type, following summaries are reported: + * - reserved amount, committed amount + * - malloc'd amount, malloc count + * - arena amount, arena count + */ + + // start reporting memory summary by memory type + virtual void start_category_summary() = 0; + + virtual void category_summary(MEMFLAGS type, size_t reserved_amt, + size_t committed_amt, + size_t malloc_amt, size_t malloc_count, + size_t arena_amt, size_t arena_count) = 0; + + virtual void diff_category_summary(MEMFLAGS type, size_t cur_reserved_amt, + size_t cur_committed_amt, + size_t cur_malloc_amt, size_t cur_malloc_count, + size_t cur_arena_amt, size_t cur_arena_count, + int reserved_diff, int committed_diff, int malloc_diff, + int malloc_count_diff, int arena_diff, + int arena_count_diff) = 0; + + virtual void done_category_summary() = 0; + + /* + * Report callsite information + */ + virtual void start_callsite() = 0; + virtual void malloc_callsite(address pc, size_t malloc_amt, size_t malloc_count) = 0; + virtual void virtual_memory_callsite(address pc, size_t reserved_amt, size_t committed_amt) = 0; + + virtual void diff_malloc_callsite(address pc, size_t cur_malloc_amt, size_t cur_malloc_count, + int malloc_diff, int malloc_count_diff) = 0; + virtual void diff_virtual_memory_callsite(address pc, size_t cur_reserved_amt, size_t cur_committed_amt, + int reserved_diff, int committed_diff) = 0; + + virtual void done_callsite() = 0; + + // return current scale in "KB", "MB" or "GB" + static const char* memory_unit(size_t scale); +}; + +/* + * This class reports processed data from a baseline or + * the changes between the two baseline. + */ +class BaselineReporter : public StackObj { + private: + BaselineOutputer& _outputer; + size_t _scale; + + public: + // construct a reporter that reports memory usage + // in specified scale + BaselineReporter(BaselineOutputer& outputer, size_t scale = K): + _outputer(outputer) { + _scale = scale; + } + virtual void report_baseline(const MemBaseline& baseline, bool summary_only = false); + virtual void diff_baselines(const MemBaseline& cur, const MemBaseline& prev, + bool summary_only = false); + + void set_scale(size_t scale); + size_t scale() const { return _scale; } + + private: + void report_summaries(const MemBaseline& baseline); + void report_callsites(const MemBaseline& baseline); + + void diff_summaries(const MemBaseline& cur, const MemBaseline& prev); + void diff_callsites(const MemBaseline& cur, const MemBaseline& prev); + + // calculate memory size in current memory scale + size_t amount_in_current_scale(size_t amt) const; + // diff two unsigned values in current memory scale + int diff_in_current_scale(size_t value1, size_t value2) const; + // diff two unsigned value + int diff(size_t value1, size_t value2) const; +}; + +/* + * tty output implementation. Native memory tracking + * DCmd uses this outputer. + */ +class BaselineTTYOutputer : public BaselineOutputer { + private: + size_t _scale; + + size_t _num_of_classes; + size_t _num_of_threads; + size_t _thread_stack_reserved; + size_t _thread_stack_committed; + + int _num_of_classes_diff; + int _num_of_threads_diff; + int _thread_stack_reserved_diff; + int _thread_stack_committed_diff; + + outputStream* _output; + + public: + BaselineTTYOutputer(outputStream* st) { + _scale = K; + _num_of_classes = 0; + _num_of_threads = 0; + _thread_stack_reserved = 0; + _thread_stack_committed = 0; + _num_of_classes_diff = 0; + _num_of_threads_diff = 0; + _thread_stack_reserved_diff = 0; + _thread_stack_committed_diff = 0; + _output = st; + } + + // begin reporting memory usage in specified scale + void start(size_t scale, bool report_diff = false); + // done reporting + void done(); + + // total memory usage + void total_usage(size_t total_reserved, + size_t total_committed); + // report total loaded classes + void num_of_classes(size_t classes) { + _num_of_classes = classes; + } + + void num_of_threads(size_t threads) { + _num_of_threads = threads; + } + + void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) { + _thread_stack_reserved = stack_reserved_amt; + _thread_stack_committed = stack_committed_amt; + } + + void diff_total_usage(size_t total_reserved, + size_t total_committed, + int reserved_diff, + int committed_diff); + + void diff_num_of_classes(size_t classes, int diff) { + _num_of_classes = classes; + _num_of_classes_diff = diff; + } + + void diff_num_of_threads(size_t threads, int diff) { + _num_of_threads = threads; + _num_of_threads_diff = diff; + } + + void diff_thread_info(size_t stack_reserved_amt, size_t stack_committed_amt, + int stack_reserved_diff, int stack_committed_diff) { + _thread_stack_reserved = stack_reserved_amt; + _thread_stack_committed = stack_committed_amt; + _thread_stack_reserved_diff = stack_reserved_diff; + _thread_stack_committed_diff = stack_committed_diff; + } + + /* + * Report memory summary categoriuzed by memory types. + * For each memory type, following summaries are reported: + * - reserved amount, committed amount + * - malloc-ed amount, malloc count + * - arena amount, arena count + */ + // start reporting memory summary by memory type + void start_category_summary(); + void category_summary(MEMFLAGS type, size_t reserved_amt, size_t committed_amt, + size_t malloc_amt, size_t malloc_count, + size_t arena_amt, size_t arena_count); + + void diff_category_summary(MEMFLAGS type, size_t cur_reserved_amt, + size_t cur_committed_amt, + size_t cur_malloc_amt, size_t cur_malloc_count, + size_t cur_arena_amt, size_t cur_arena_count, + int reserved_diff, int committed_diff, int malloc_diff, + int malloc_count_diff, int arena_diff, + int arena_count_diff); + + void done_category_summary(); + + /* + * Report callsite information + */ + void start_callsite(); + void malloc_callsite(address pc, size_t malloc_amt, size_t malloc_count); + void virtual_memory_callsite(address pc, size_t reserved_amt, size_t committed_amt); + + void diff_malloc_callsite(address pc, size_t cur_malloc_amt, size_t cur_malloc_count, + int malloc_diff, int malloc_count_diff); + void diff_virtual_memory_callsite(address pc, size_t cur_reserved_amt, size_t cur_committed_amt, + int reserved_diff, int committed_diff); + + void done_callsite(); +}; + + +#endif // SHARE_VM_SERVICES_MEM_REPORTER_HPP diff --git a/hotspot/src/share/vm/services/memSnapshot.cpp b/hotspot/src/share/vm/services/memSnapshot.cpp new file mode 100644 index 00000000000..4c2a6c2664b --- /dev/null +++ b/hotspot/src/share/vm/services/memSnapshot.cpp @@ -0,0 +1,463 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "runtime/mutexLocker.hpp" +#include "utilities/decoder.hpp" +#include "services/memBaseline.hpp" +#include "services/memPtr.hpp" +#include "services/memPtrArray.hpp" +#include "services/memSnapshot.hpp" +#include "services/memTracker.hpp" + + +// stagging data groups the data of a VM memory range, so we can consolidate +// them into one record during the walk +bool StagingWalker::consolidate_vm_records(VMMemRegionEx* vm_rec) { + MemPointerRecord* cur = (MemPointerRecord*)_itr.current(); + assert(cur != NULL && cur->is_vm_pointer(), "not a virtual memory pointer"); + + jint cur_seq; + jint next_seq; + + bool trackCallsite = MemTracker::track_callsite(); + + if (trackCallsite) { + vm_rec->init((MemPointerRecordEx*)cur); + cur_seq = ((SeqMemPointerRecordEx*)cur)->seq(); + } else { + vm_rec->init((MemPointerRecord*)cur); + cur_seq = ((SeqMemPointerRecord*)cur)->seq(); + } + + // only can consolidate when we have allocation record, + // which contains virtual memory range + if (!cur->is_allocation_record()) { + _itr.next(); + return true; + } + + // allocation range + address base = cur->addr(); + address end = base + cur->size(); + + MemPointerRecord* next = (MemPointerRecord*)_itr.peek_next(); + // if the memory range is alive + bool live_vm_rec = true; + while (next != NULL && next->is_vm_pointer()) { + if (next->is_allocation_record()) { + assert(next->addr() >= base, "sorting order or overlapping"); + break; + } + + if (trackCallsite) { + next_seq = ((SeqMemPointerRecordEx*)next)->seq(); + } else { + next_seq = ((SeqMemPointerRecord*)next)->seq(); + } + + if (next_seq < cur_seq) { + _itr.next(); + next = (MemPointerRecord*)_itr.peek_next(); + continue; + } + + if (next->is_deallocation_record()) { + if (next->addr() == base && next->size() == cur->size()) { + // the virtual memory range has been released + _itr.next(); + live_vm_rec = false; + break; + } else if (next->addr() < end) { // partial release + vm_rec->partial_release(next->addr(), next->size()); + _itr.next(); + } else { + break; + } + } else if (next->is_commit_record()) { + if (next->addr() >= base && next->addr() + next->size() <= end) { + vm_rec->commit(next->size()); + _itr.next(); + } else { + assert(next->addr() >= base, "sorting order or overlapping"); + break; + } + } else if (next->is_uncommit_record()) { + if (next->addr() >= base && next->addr() + next->size() <= end) { + vm_rec->uncommit(next->size()); + _itr.next(); + } else { + assert(next->addr() >= end, "sorting order or overlapping"); + break; + } + } else if (next->is_type_tagging_record()) { + if (next->addr() >= base && next->addr() < end ) { + vm_rec->tag(next->flags()); + _itr.next(); + } else { + break; + } + } else { + assert(false, "unknown record type"); + } + next = (MemPointerRecord*)_itr.peek_next(); + } + _itr.next(); + return live_vm_rec; +} + +MemPointer* StagingWalker::next() { + MemPointerRecord* cur_p = (MemPointerRecord*)_itr.current(); + if (cur_p == NULL) { + _end_of_array = true; + return NULL; + } + + MemPointerRecord* next_p; + if (cur_p->is_vm_pointer()) { + _is_vm_record = true; + if (!consolidate_vm_records(&_vm_record)) { + return next(); + } + } else { // malloc-ed pointer + _is_vm_record = false; + next_p = (MemPointerRecord*)_itr.peek_next(); + if (next_p != NULL && next_p->addr() == cur_p->addr()) { + assert(cur_p->is_allocation_record(), "sorting order"); + assert(!next_p->is_allocation_record(), "sorting order"); + _itr.next(); + if (cur_p->seq() < next_p->seq()) { + cur_p = next_p; + } + } + if (MemTracker::track_callsite()) { + _malloc_record.init((MemPointerRecordEx*)cur_p); + } else { + _malloc_record.init((MemPointerRecord*)cur_p); + } + + _itr.next(); + } + return current(); +} + +MemSnapshot::MemSnapshot() { + if (MemTracker::track_callsite()) { + _alloc_ptrs = new (std::nothrow) MemPointerArrayImpl(); + _vm_ptrs = new (std::nothrow)MemPointerArrayImpl(64, true); + _staging_area = new (std::nothrow)MemPointerArrayImpl(); + } else { + _alloc_ptrs = new (std::nothrow) MemPointerArrayImpl(); + _vm_ptrs = new (std::nothrow)MemPointerArrayImpl(64, true); + _staging_area = new (std::nothrow)MemPointerArrayImpl(); + } + + _lock = new (std::nothrow) Mutex(Monitor::native, "memSnapshotLock"); + NOT_PRODUCT(_untracked_count = 0;) +} + +MemSnapshot::~MemSnapshot() { + assert(MemTracker::shutdown_in_progress(), "native memory tracking still on"); + { + MutexLockerEx locker(_lock); + if (_staging_area != NULL) { + delete _staging_area; + _staging_area = NULL; + } + + if (_alloc_ptrs != NULL) { + delete _alloc_ptrs; + _alloc_ptrs = NULL; + } + + if (_vm_ptrs != NULL) { + delete _vm_ptrs; + _vm_ptrs = NULL; + } + } + + if (_lock != NULL) { + delete _lock; + _lock = NULL; + } +} + +void MemSnapshot::copy_pointer(MemPointerRecord* dest, const MemPointerRecord* src) { + assert(dest != NULL && src != NULL, "Just check"); + assert(dest->addr() == src->addr(), "Just check"); + + MEMFLAGS flags = dest->flags(); + + if (MemTracker::track_callsite()) { + *(MemPointerRecordEx*)dest = *(MemPointerRecordEx*)src; + } else { + *dest = *src; + } +} + + +// merge a per-thread memory recorder to the staging area +bool MemSnapshot::merge(MemRecorder* rec) { + assert(rec != NULL && !rec->out_of_memory(), "Just check"); + + // out of memory + if (_staging_area == NULL || _staging_area->out_of_memory()) { + return false; + } + + SequencedRecordIterator itr(rec->pointer_itr()); + + MutexLockerEx lock(_lock, true); + MemPointerIterator staging_itr(_staging_area); + MemPointerRecord *p1, *p2; + p1 = (MemPointerRecord*) itr.current(); + while (p1 != NULL) { + p2 = (MemPointerRecord*)staging_itr.locate(p1->addr()); + // we have not seen this memory block, so just add to staging area + if (p2 == NULL) { + if (!staging_itr.insert(p1)) { + return false; + } + } else if (p1->addr() == p2->addr()) { + MemPointerRecord* staging_next = (MemPointerRecord*)staging_itr.peek_next(); + // a memory block can have many tagging records, find right one to replace or + // right position to insert + while (staging_next != NULL && staging_next->addr() == p1->addr()) { + if ((staging_next->flags() & MemPointerRecord::tag_masks) <= + (p1->flags() & MemPointerRecord::tag_masks)) { + p2 = (MemPointerRecord*)staging_itr.next(); + staging_next = (MemPointerRecord*)staging_itr.peek_next(); + } else { + break; + } + } + int df = (p1->flags() & MemPointerRecord::tag_masks) - + (p2->flags() & MemPointerRecord::tag_masks); + if (df == 0) { + assert(p1->seq() > 0, "not sequenced"); + assert(p2->seq() > 0, "not sequenced"); + if (p1->seq() > p2->seq()) { + copy_pointer(p2, p1); + } + } else if (df < 0) { + if (!staging_itr.insert(p1)) { + return false; + } + } else { + if (!staging_itr.insert_after(p1)) { + return false; + } + } + } else if (p1->addr() < p2->addr()) { + if (!staging_itr.insert(p1)) { + return false; + } + } else { + if (!staging_itr.insert_after(p1)) { + return false; + } + } + p1 = (MemPointerRecord*)itr.next(); + } + NOT_PRODUCT(void check_staging_data();) + return true; +} + + + +// promote data to next generation +void MemSnapshot::promote() { + assert(_alloc_ptrs != NULL && _staging_area != NULL && _vm_ptrs != NULL, + "Just check"); + MutexLockerEx lock(_lock, true); + StagingWalker walker(_staging_area); + MemPointerIterator malloc_itr(_alloc_ptrs); + VMMemPointerIterator vm_itr(_vm_ptrs); + MemPointer* cur = walker.current(); + while (cur != NULL) { + if (walker.is_vm_record()) { + VMMemRegion* cur_vm = (VMMemRegion*)cur; + VMMemRegion* p = (VMMemRegion*)vm_itr.locate(cur_vm->addr()); + cur_vm = (VMMemRegion*)cur; + if (p != NULL && (p->contains(cur_vm) || p->base() == cur_vm->base())) { + assert(p->is_reserve_record() || + p->is_commit_record(), "wrong vm record type"); + // resize existing reserved range + if (cur_vm->is_reserve_record() && p->base() == cur_vm->base()) { + assert(cur_vm->size() >= p->committed_size(), "incorrect resizing"); + p->set_reserved_size(cur_vm->size()); + } else if (cur_vm->is_commit_record()) { + p->commit(cur_vm->committed_size()); + } else if (cur_vm->is_uncommit_record()) { + p->uncommit(cur_vm->committed_size()); + if (!p->is_reserve_record() && p->committed_size() == 0) { + vm_itr.remove(); + } + } else if (cur_vm->is_type_tagging_record()) { + p->tag(cur_vm->flags()); + } else if (cur_vm->is_release_record()) { + if (cur_vm->base() == p->base() && cur_vm->size() == p->size()) { + // release the whole range + vm_itr.remove(); + } else { + // partial release + p->partial_release(cur_vm->base(), cur_vm->size()); + } + } else { + // we do see multiple reserver on the same vm range + assert((cur_vm->is_commit_record() || cur_vm->is_reserve_record()) && + cur_vm->base() == p->base() && cur_vm->size() == p->size(), "bad record"); + p->tag(cur_vm->flags()); + } + } else { + if(cur_vm->is_reserve_record()) { + if (p == NULL || p->base() > cur_vm->base()) { + vm_itr.insert(cur_vm); + } else { + vm_itr.insert_after(cur_vm); + } + } else { +#ifdef ASSERT + // In theory, we should assert without conditions. However, in case of native + // thread stack, NMT explicitly releases the thread stack in Thread's destructor, + // due to platform dependent behaviors. On some platforms, we see uncommit/release + // native thread stack, but some, we don't. + if (!cur_vm->is_uncommit_record() && !cur_vm->is_deallocation_record()) { + ShouldNotReachHere(); + } +#endif + } + } + } else { + MemPointerRecord* cur_p = (MemPointerRecord*)cur; + MemPointerRecord* p = (MemPointerRecord*)malloc_itr.locate(cur->addr()); + if (p != NULL && cur_p->addr() == p->addr()) { + assert(p->is_allocation_record() || p->is_arena_size_record(), "untracked"); + if (cur_p->is_allocation_record() || cur_p->is_arena_size_record()) { + copy_pointer(p, cur_p); + } else { // deallocation record + assert(cur_p->is_deallocation_record(), "wrong record type"); + + // we are removing an arena record, we also need to remove its 'size' + // record behind it + if (p->is_arena_record()) { + MemPointerRecord* next_p = (MemPointerRecord*)malloc_itr.peek_next(); + if (next_p->is_arena_size_record()) { + assert(next_p->is_size_record_of_arena(p), "arena records dont match"); + malloc_itr.remove(); + } + } + malloc_itr.remove(); + } + } else { + if (cur_p->is_arena_size_record()) { + MemPointerRecord* prev_p = (MemPointerRecord*)malloc_itr.peek_prev(); + if (prev_p != NULL && + (!prev_p->is_arena_record() || !cur_p->is_size_record_of_arena(prev_p))) { + // arena already deallocated + cur_p = NULL; + } + } + if (cur_p != NULL) { + if (cur_p->is_allocation_record() || cur_p->is_arena_size_record()) { + if (p != NULL && cur_p->addr() > p->addr()) { + malloc_itr.insert_after(cur); + } else { + malloc_itr.insert(cur); + } + } +#ifndef PRODUCT + else if (!has_allocation_record(cur_p->addr())){ + // NMT can not track some startup memory, which allocated before NMT + // is enabled + _untracked_count ++; + } +#endif + } + } + } + + cur = walker.next(); + } + NOT_PRODUCT(check_malloc_pointers();) + _staging_area->shrink(); + _staging_area->clear(); +} + + +#ifdef ASSERT +void MemSnapshot::print_snapshot_stats(outputStream* st) { + st->print_cr("Snapshot:"); + st->print_cr("\tMalloced: %d/%d [%5.2f%%] %dKB", _alloc_ptrs->length(), _alloc_ptrs->capacity(), + (100.0 * (float)_alloc_ptrs->length()) / (float)_alloc_ptrs->capacity(), _alloc_ptrs->instance_size()/K); + + st->print_cr("\tVM: %d/%d [%5.2f%%] %dKB", _vm_ptrs->length(), _vm_ptrs->capacity(), + (100.0 * (float)_vm_ptrs->length()) / (float)_vm_ptrs->capacity(), _vm_ptrs->instance_size()/K); + + st->print_cr("\tStaging: %d/%d [%5.2f%%] %dKB", _staging_area->length(), _staging_area->capacity(), + (100.0 * (float)_staging_area->length()) / (float)_staging_area->capacity(), _staging_area->instance_size()/K); + + st->print_cr("\tUntracked allocation: %d", _untracked_count); +} + +void MemSnapshot::check_malloc_pointers() { + MemPointerArrayIteratorImpl mItr(_alloc_ptrs); + MemPointerRecord* p = (MemPointerRecord*)mItr.current(); + MemPointerRecord* prev = NULL; + while (p != NULL) { + if (prev != NULL) { + assert(p->addr() >= prev->addr(), "sorting order"); + } + prev = p; + p = (MemPointerRecord*)mItr.next(); + } +} + +void MemSnapshot::check_staging_data() { + MemPointerArrayIteratorImpl itr(_staging_area); + MemPointerRecord* cur = (MemPointerRecord*)itr.current(); + MemPointerRecord* next = (MemPointerRecord*)itr.next(); + while (next != NULL) { + assert((next->addr() > cur->addr()) || + ((next->flags() & MemPointerRecord::tag_masks) > + (cur->flags() & MemPointerRecord::tag_masks)), + "sorting order"); + cur = next; + next = (MemPointerRecord*)itr.next(); + } +} + +bool MemSnapshot::has_allocation_record(address addr) { + MemPointerArrayIteratorImpl itr(_staging_area); + MemPointerRecord* cur = (MemPointerRecord*)itr.current(); + while (cur != NULL) { + if (cur->addr() == addr && cur->is_allocation_record()) { + return true; + } + cur = (MemPointerRecord*)itr.next(); + } + return false; +} + +#endif diff --git a/hotspot/src/share/vm/services/memSnapshot.hpp b/hotspot/src/share/vm/services/memSnapshot.hpp new file mode 100644 index 00000000000..8b2376e5f79 --- /dev/null +++ b/hotspot/src/share/vm/services/memSnapshot.hpp @@ -0,0 +1,286 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_SERVICES_MEM_SNAPSHOT_HPP +#define SHARE_VM_SERVICES_MEM_SNAPSHOT_HPP + +#include "memory/allocation.hpp" +#include "runtime/mutex.hpp" +#include "runtime/mutexLocker.hpp" +#include "services/memBaseline.hpp" +#include "services/memPtrArray.hpp" + + +// Snapshot pointer array iterator + +// The pointer array contains malloc-ed pointers +class MemPointerIterator : public MemPointerArrayIteratorImpl { + public: + MemPointerIterator(MemPointerArray* arr): + MemPointerArrayIteratorImpl(arr) { + assert(arr != NULL, "null array"); + } + +#ifdef ASSERT + virtual bool is_dup_pointer(const MemPointer* ptr1, + const MemPointer* ptr2) const { + MemPointerRecord* p1 = (MemPointerRecord*)ptr1; + MemPointerRecord* p2 = (MemPointerRecord*)ptr2; + + if (p1->addr() != p2->addr()) return false; + if ((p1->flags() & MemPointerRecord::tag_masks) != + (p2->flags() & MemPointerRecord::tag_masks)) { + return false; + } + // we do see multiple commit/uncommit on the same memory, it is ok + return (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_alloc || + (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_release; + } + + virtual bool insert(MemPointer* ptr) { + if (_pos > 0) { + MemPointer* p1 = (MemPointer*)ptr; + MemPointer* p2 = (MemPointer*)_array->at(_pos - 1); + assert(!is_dup_pointer(p1, p2), + "dup pointer"); + } + if (_pos < _array->length() -1) { + MemPointer* p1 = (MemPointer*)ptr; + MemPointer* p2 = (MemPointer*)_array->at(_pos + 1); + assert(!is_dup_pointer(p1, p2), + "dup pointer"); + } + return _array->insert_at(ptr, _pos); + } + + virtual bool insert_after(MemPointer* ptr) { + if (_pos > 0) { + MemPointer* p1 = (MemPointer*)ptr; + MemPointer* p2 = (MemPointer*)_array->at(_pos - 1); + assert(!is_dup_pointer(p1, p2), + "dup pointer"); + } + if (_pos < _array->length() - 1) { + MemPointer* p1 = (MemPointer*)ptr; + MemPointer* p2 = (MemPointer*)_array->at(_pos + 1); + + assert(!is_dup_pointer(p1, p2), + "dup pointer"); + } + if (_array->insert_at(ptr, _pos + 1)) { + _pos ++; + return true; + } + return false; + } +#endif + + virtual MemPointer* locate(address addr) { + MemPointer* cur = current(); + while (cur != NULL && cur->addr() < addr) { + cur = next(); + } + return cur; + } +}; + +class VMMemPointerIterator : public MemPointerIterator { + public: + VMMemPointerIterator(MemPointerArray* arr): + MemPointerIterator(arr) { + } + + // locate an exiting record that contains specified address, or + // the record, where the record with specified address, should + // be inserted + virtual MemPointer* locate(address addr) { + VMMemRegion* cur = (VMMemRegion*)current(); + VMMemRegion* next_p; + + while (cur != NULL) { + if (cur->base() > addr) { + return cur; + } else { + // find nearest existing range that has base address <= addr + next_p = (VMMemRegion*)peek_next(); + if (next_p != NULL && next_p->base() <= addr) { + cur = (VMMemRegion*)next(); + continue; + } + } + + if (cur->is_reserve_record() && + cur->base() <= addr && + (cur->base() + cur->size() > addr)) { + return cur; + } else if (cur->is_commit_record() && + cur->base() <= addr && + (cur->base() + cur->committed_size() > addr)) { + return cur; + } + cur = (VMMemRegion*)next(); + } + return NULL; + } + +#ifdef ASSERT + virtual bool is_dup_pointer(const MemPointer* ptr1, + const MemPointer* ptr2) const { + VMMemRegion* p1 = (VMMemRegion*)ptr1; + VMMemRegion* p2 = (VMMemRegion*)ptr2; + + if (p1->addr() != p2->addr()) return false; + if ((p1->flags() & MemPointerRecord::tag_masks) != + (p2->flags() & MemPointerRecord::tag_masks)) { + return false; + } + // we do see multiple commit/uncommit on the same memory, it is ok + return (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_alloc || + (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_release; + } +#endif +}; + +class StagingWalker : public MemPointerArrayIterator { + private: + MemPointerArrayIteratorImpl _itr; + bool _is_vm_record; + bool _end_of_array; + VMMemRegionEx _vm_record; + MemPointerRecordEx _malloc_record; + + public: + StagingWalker(MemPointerArray* arr): _itr(arr) { + _end_of_array = false; + next(); + } + + // return the pointer at current position + MemPointer* current() const { + if (_end_of_array) { + return NULL; + } + if (is_vm_record()) { + return (MemPointer*)&_vm_record; + } else { + return (MemPointer*)&_malloc_record; + } + } + + // return the next pointer and advance current position + MemPointer* next(); + + // type of 'current' record + bool is_vm_record() const { + return _is_vm_record; + } + + // return the next poinger without advancing current position + MemPointer* peek_next() const { + assert(false, "not supported"); + return NULL; + } + + MemPointer* peek_prev() const { + assert(false, "not supported"); + return NULL; + } + // remove the pointer at current position + void remove() { + assert(false, "not supported"); + } + + // insert the pointer at current position + bool insert(MemPointer* ptr) { + assert(false, "not supported"); + return false; + } + + bool insert_after(MemPointer* ptr) { + assert(false, "not supported"); + return false; + } + + private: + // consolidate all records referring to this vm region + bool consolidate_vm_records(VMMemRegionEx* vm_rec); +}; + +class MemBaseline; + +class MemSnapshot : public CHeapObj { + private: + // the following two arrays contain records of all known lived memory blocks + // live malloc-ed memory pointers + MemPointerArray* _alloc_ptrs; + // live virtual memory pointers + MemPointerArray* _vm_ptrs; + + // stagging a generation's data, before + // it can be prompted to snapshot + MemPointerArray* _staging_area; + + // the lock to protect this snapshot + Monitor* _lock; + + NOT_PRODUCT(size_t _untracked_count;) + friend class MemBaseline; + + public: + MemSnapshot(); + virtual ~MemSnapshot(); + + // if we are running out of native memory + bool out_of_memory() const { + return (_alloc_ptrs == NULL || _staging_area == NULL || + _vm_ptrs == NULL || _lock == NULL || + _alloc_ptrs->out_of_memory() || + _staging_area->out_of_memory() || + _vm_ptrs->out_of_memory()); + } + + // merge a per-thread memory recorder into staging area + bool merge(MemRecorder* rec); + // promote staged data to snapshot + void promote(); + + + void wait(long timeout) { + assert(_lock != NULL, "Just check"); + MonitorLockerEx locker(_lock); + locker.wait(true, timeout); + } + + NOT_PRODUCT(void print_snapshot_stats(outputStream* st);) + NOT_PRODUCT(void check_staging_data();) + NOT_PRODUCT(void check_malloc_pointers();) + NOT_PRODUCT(bool has_allocation_record(address addr);) + + private: + // copy pointer data from src to dest + void copy_pointer(MemPointerRecord* dest, const MemPointerRecord* src); +}; + + +#endif // SHARE_VM_SERVICES_MEM_SNAPSHOT_HPP diff --git a/hotspot/src/share/vm/services/memTrackWorker.cpp b/hotspot/src/share/vm/services/memTrackWorker.cpp new file mode 100644 index 00000000000..b82a305ed72 --- /dev/null +++ b/hotspot/src/share/vm/services/memTrackWorker.cpp @@ -0,0 +1,199 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "runtime/threadCritical.hpp" +#include "services/memTracker.hpp" +#include "services/memTrackWorker.hpp" +#include "utilities/decoder.hpp" +#include "utilities/vmError.hpp" + +MemTrackWorker::MemTrackWorker() { + // create thread uses cgc thread type for now. We should revisit + // the option, or create new thread type. + _has_error = !os::create_thread(this, os::cgc_thread); + set_name("MemTrackWorker", 0); + + // initial generation circuit buffer + if (!has_error()) { + _head = _tail = 0; + for(int index = 0; index < MAX_GENERATIONS; index ++) { + _gen[index] = NULL; + } + } + NOT_PRODUCT(_sync_point_count = 0;) + NOT_PRODUCT(_merge_count = 0;) + NOT_PRODUCT(_last_gen_in_use = 0;) +} + +MemTrackWorker::~MemTrackWorker() { + for (int index = 0; index < MAX_GENERATIONS; index ++) { + MemRecorder* rc = _gen[index]; + if (rc != NULL) { + delete rc; + } + } +} + +void* MemTrackWorker::operator new(size_t size) { + assert(false, "use nothrow version"); + return NULL; +} + +void* MemTrackWorker::operator new(size_t size, const std::nothrow_t& nothrow_constant) { + return allocate(size, false, mtNMT); +} + +void MemTrackWorker::start() { + os::start_thread(this); +} + +/* + * Native memory tracking worker thread loop: + * 1. merge one generation of memory recorders to staging area + * 2. promote staging data to memory snapshot + * + * This thread can run through safepoint. + */ + +void MemTrackWorker::run() { + assert(MemTracker::is_on(), "native memory tracking is off"); + this->initialize_thread_local_storage(); + this->record_stack_base_and_size(); + MemSnapshot* snapshot = MemTracker::get_snapshot(); + assert(snapshot != NULL, "Worker should not be started"); + MemRecorder* rec; + + while (!MemTracker::shutdown_in_progress()) { + NOT_PRODUCT(_last_gen_in_use = generations_in_use();) + { + // take a recorder from earliest generation in buffer + ThreadCritical tc; + rec = _gen[_head]; + if (rec != NULL) { + _gen[_head] = rec->next(); + } + assert(count_recorder(_gen[_head]) <= MemRecorder::_instance_count, + "infinite loop after dequeue"); + } + if (rec != NULL) { + // merge the recorder into staging area + bool result = snapshot->merge(rec); + assert(result, "merge failed"); + debug_only(_merge_count ++;) + MemTracker::release_thread_recorder(rec); + } else { + // no more recorder to merge, promote staging area + // to snapshot + if (_head != _tail) { + { + ThreadCritical tc; + if (_gen[_head] != NULL || _head == _tail) { + continue; + } + // done with this generation, increment _head pointer + _head = (_head + 1) % MAX_GENERATIONS; + } + // promote this generation data to snapshot + snapshot->promote(); + } else { + snapshot->wait(1000); + ThreadCritical tc; + // check if more data arrived + if (_gen[_head] == NULL) { + _gen[_head] = MemTracker::get_pending_recorders(); + } + } + } + } + assert(MemTracker::shutdown_in_progress(), "just check"); + + // transites to final shutdown + MemTracker::final_shutdown(); +} + +// at synchronization point, where 'safepoint visible' Java threads are blocked +// at a safepoint, and the rest of threads are blocked on ThreadCritical lock. +// The caller MemTracker::sync() already takes ThreadCritical before calling this +// method. +// +// Following tasks are performed: +// 1. add all recorders in pending queue to current generation +// 2. increase generation + +void MemTrackWorker::at_sync_point(MemRecorder* rec) { + NOT_PRODUCT(_sync_point_count ++;) + assert(count_recorder(rec) <= MemRecorder::_instance_count, + "pending queue has infinite loop"); + + bool out_of_generation_buffer = false; + // check shutdown state inside ThreadCritical + if (MemTracker::shutdown_in_progress()) return; + // append the recorders to the end of the generation + if( rec != NULL) { + MemRecorder* cur_head = _gen[_tail]; + if (cur_head == NULL) { + _gen[_tail] = rec; + } else { + while (cur_head->next() != NULL) { + cur_head = cur_head->next(); + } + cur_head->set_next(rec); + } + } + assert(count_recorder(rec) <= MemRecorder::_instance_count, + "after add to current generation has infinite loop"); + // we have collected all recorders for this generation. If there is data, + // we need to increment _tail to start a new generation. + if (_gen[_tail] != NULL || _head == _tail) { + _tail = (_tail + 1) % MAX_GENERATIONS; + out_of_generation_buffer = (_tail == _head); + } + + if (out_of_generation_buffer) { + MemTracker::shutdown(MemTracker::NMT_out_of_generation); + } +} + +#ifndef PRODUCT +int MemTrackWorker::count_recorder(const MemRecorder* head) { + int count = 0; + while(head != NULL) { + count ++; + head = head->next(); + } + return count; +} + +int MemTrackWorker::count_pending_recorders() const { + int count = 0; + for (int index = 0; index < MAX_GENERATIONS; index ++) { + MemRecorder* head = _gen[index]; + if (head != NULL) { + count += count_recorder(head); + } + } + return count; +} +#endif diff --git a/hotspot/src/share/vm/services/memTrackWorker.hpp b/hotspot/src/share/vm/services/memTrackWorker.hpp new file mode 100644 index 00000000000..6c236784e53 --- /dev/null +++ b/hotspot/src/share/vm/services/memTrackWorker.hpp @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_SERVICES_MEM_TRACK_WORKER_HPP +#define SHARE_VM_SERVICES_MEM_TRACK_WORKER_HPP + +#include "memory/allocation.hpp" +#include "runtime/thread.hpp" +#include "services/memRecorder.hpp" + +// Maximum MAX_GENERATIONS generation data can be tracked. +#define MAX_GENERATIONS 512 + + +class MemTrackWorker : public NamedThread { + private: + // circular buffer. This buffer contains recorders to be merged into global + // snaphsot. + // Each slot holds a linked list of memory recorders, that contains one + // generation of memory data. + MemRecorder* _gen[MAX_GENERATIONS]; + int _head, _tail; // head and tail pointers to above circular buffer + + bool _has_error; + + public: + MemTrackWorker(); + ~MemTrackWorker(); + _NOINLINE_ void* operator new(size_t size); + _NOINLINE_ void* operator new(size_t size, const std::nothrow_t& nothrow_constant); + + void start(); + void run(); + + inline bool has_error() const { return _has_error; } + + // task at synchronization point + void at_sync_point(MemRecorder* pending_recorders); + + // for debugging purpose, they are not thread safe. + NOT_PRODUCT(static int count_recorder(const MemRecorder* head);) + NOT_PRODUCT(int count_pending_recorders() const;) + + NOT_PRODUCT(int _sync_point_count;) + NOT_PRODUCT(int _merge_count;) + NOT_PRODUCT(int _last_gen_in_use;) + + inline int generations_in_use() const { + return (_tail <= _head ? (_head - _tail + 1) : (MAX_GENERATIONS - (_tail - _head) + 1)); + } +}; + +#endif // SHARE_VM_SERVICES_MEM_TRACK_WORKER_HPP diff --git a/hotspot/src/share/vm/services/memTracker.cpp b/hotspot/src/share/vm/services/memTracker.cpp new file mode 100644 index 00000000000..55c98596584 --- /dev/null +++ b/hotspot/src/share/vm/services/memTracker.cpp @@ -0,0 +1,617 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ +#include "precompiled.hpp" + +#include "runtime/atomic.hpp" +#include "runtime/interfaceSupport.hpp" +#include "runtime/mutexLocker.hpp" +#include "runtime/safepoint.hpp" +#include "runtime/threadCritical.hpp" +#include "services/memPtr.hpp" +#include "services/memReporter.hpp" +#include "services/memTracker.hpp" +#include "utilities/decoder.hpp" +#include "utilities/globalDefinitions.hpp" + +bool NMT_track_callsite = false; + +// walk all 'known' threads at NMT sync point, and collect their recorders +void SyncThreadRecorderClosure::do_thread(Thread* thread) { + assert(SafepointSynchronize::is_at_safepoint(), "Safepoint required"); + if (thread->is_Java_thread()) { + JavaThread* javaThread = (JavaThread*)thread; + MemRecorder* recorder = javaThread->get_recorder(); + if (recorder != NULL) { + MemTracker::enqueue_pending_recorder(recorder); + javaThread->set_recorder(NULL); + } + } + _thread_count ++; +} + + +MemRecorder* MemTracker::_global_recorder = NULL; +MemSnapshot* MemTracker::_snapshot = NULL; +MemBaseline MemTracker::_baseline; +Mutex MemTracker::_query_lock(Monitor::native, "NMT_queryLock"); +volatile MemRecorder* MemTracker::_merge_pending_queue = NULL; +volatile MemRecorder* MemTracker::_pooled_recorders = NULL; +MemTrackWorker* MemTracker::_worker_thread = NULL; +int MemTracker::_sync_point_skip_count = 0; +MemTracker::NMTLevel MemTracker::_tracking_level = MemTracker::NMT_off; +volatile MemTracker::NMTStates MemTracker::_state = NMT_uninited; +MemTracker::ShutdownReason MemTracker::_reason = NMT_shutdown_none; +int MemTracker::_thread_count = 255; +volatile jint MemTracker::_pooled_recorder_count = 0; +debug_only(intx MemTracker::_main_thread_tid = 0;) +debug_only(volatile jint MemTracker::_pending_recorder_count = 0;) + +void MemTracker::init_tracking_options(const char* option_line) { + _tracking_level = NMT_off; + if (strncmp(option_line, "=summary", 8) == 0) { + _tracking_level = NMT_summary; + } else if (strncmp(option_line, "=detail", 8) == 0) { + _tracking_level = NMT_detail; + } +} + +// first phase of bootstrapping, when VM is still in single-threaded mode. +void MemTracker::bootstrap_single_thread() { + if (_tracking_level > NMT_off) { + assert(_state == NMT_uninited, "wrong state"); + + // NMT is not supported with UseMallocOnly is on. NMT can NOT + // handle the amount of malloc data without significantly impacting + // runtime performance when this flag is on. + if (UseMallocOnly) { + shutdown(NMT_use_malloc_only); + return; + } + + debug_only(_main_thread_tid = os::current_thread_id();) + _state = NMT_bootstrapping_single_thread; + NMT_track_callsite = (_tracking_level == NMT_detail && can_walk_stack()); + } +} + +// second phase of bootstrapping, when VM is about to or already entered multi-theaded mode. +void MemTracker::bootstrap_multi_thread() { + if (_tracking_level > NMT_off && _state == NMT_bootstrapping_single_thread) { + // create nmt lock for multi-thread execution + assert(_main_thread_tid == os::current_thread_id(), "wrong thread"); + _state = NMT_bootstrapping_multi_thread; + NMT_track_callsite = (_tracking_level == NMT_detail && can_walk_stack()); + } +} + +// fully start nmt +void MemTracker::start() { + // Native memory tracking is off from command line option + if (_tracking_level == NMT_off || shutdown_in_progress()) return; + + assert(_main_thread_tid == os::current_thread_id(), "wrong thread"); + assert(_state == NMT_bootstrapping_multi_thread, "wrong state"); + + _snapshot = new (std::nothrow)MemSnapshot(); + if (_snapshot != NULL && !_snapshot->out_of_memory()) { + if (start_worker()) { + _state = NMT_started; + NMT_track_callsite = (_tracking_level == NMT_detail && can_walk_stack()); + return; + } + } + + // fail to start native memory tracking, shut it down + shutdown(NMT_initialization); +} + +/** + * Shutting down native memory tracking. + * We can not shutdown native memory tracking immediately, so we just + * setup shutdown pending flag, every native memory tracking component + * should orderly shut itself down. + * + * The shutdown sequences: + * 1. MemTracker::shutdown() sets MemTracker to shutdown pending state + * 2. Worker thread calls MemTracker::final_shutdown(), which transites + * MemTracker to final shutdown state. + * 3. At sync point, MemTracker does final cleanup, before sets memory + * tracking level to off to complete shutdown. + */ +void MemTracker::shutdown(ShutdownReason reason) { + if (_tracking_level == NMT_off) return; + + if (_state <= NMT_bootstrapping_single_thread) { + // we still in single thread mode, there is not contention + _state = NMT_shutdown_pending; + _reason = reason; + } else { + // we want to know who initialized shutdown + if ((jint)NMT_started == Atomic::cmpxchg((jint)NMT_shutdown_pending, + (jint*)&_state, (jint)NMT_started)) { + _reason = reason; + } + } +} + +// final phase of shutdown +void MemTracker::final_shutdown() { + // delete all pending recorders and pooled recorders + delete_all_pending_recorders(); + delete_all_pooled_recorders(); + + { + // shared baseline and snapshot are the only objects needed to + // create query results + MutexLockerEx locker(&_query_lock, true); + // cleanup baseline data and snapshot + _baseline.clear(); + delete _snapshot; + _snapshot = NULL; + } + + // shutdown shared decoder instance, since it is only + // used by native memory tracking so far. + Decoder::shutdown(); + + MemTrackWorker* worker = NULL; + { + ThreadCritical tc; + // can not delete worker inside the thread critical + if (_worker_thread != NULL && Thread::current() == _worker_thread) { + worker = _worker_thread; + _worker_thread = NULL; + } + } + if (worker != NULL) { + delete worker; + } + _state = NMT_final_shutdown; +} + +// delete all pooled recorders +void MemTracker::delete_all_pooled_recorders() { + // free all pooled recorders + volatile MemRecorder* cur_head = _pooled_recorders; + if (cur_head != NULL) { + MemRecorder* null_ptr = NULL; + while (cur_head != NULL && (void*)cur_head != Atomic::cmpxchg_ptr((void*)null_ptr, + (void*)&_pooled_recorders, (void*)cur_head)) { + cur_head = _pooled_recorders; + } + if (cur_head != NULL) { + delete cur_head; + _pooled_recorder_count = 0; + } + } +} + +// delete all recorders in pending queue +void MemTracker::delete_all_pending_recorders() { + // free all pending recorders + MemRecorder* pending_head = get_pending_recorders(); + if (pending_head != NULL) { + delete pending_head; + } +} + +/* + * retrieve per-thread recorder of specified thread. + * if thread == NULL, it means global recorder + */ +MemRecorder* MemTracker::get_thread_recorder(JavaThread* thread) { + if (shutdown_in_progress()) return NULL; + + MemRecorder* rc; + if (thread == NULL) { + rc = _global_recorder; + } else { + rc = thread->get_recorder(); + } + + if (rc != NULL && rc->is_full()) { + enqueue_pending_recorder(rc); + rc = NULL; + } + + if (rc == NULL) { + rc = get_new_or_pooled_instance(); + if (thread == NULL) { + _global_recorder = rc; + } else { + thread->set_recorder(rc); + } + } + return rc; +} + +/* + * get a per-thread recorder from pool, or create a new one if + * there is not one available. + */ +MemRecorder* MemTracker::get_new_or_pooled_instance() { + MemRecorder* cur_head = const_cast (_pooled_recorders); + if (cur_head == NULL) { + MemRecorder* rec = new (std::nothrow)MemRecorder(); + if (rec == NULL || rec->out_of_memory()) { + shutdown(NMT_out_of_memory); + if (rec != NULL) { + delete rec; + rec = NULL; + } + } + return rec; + } else { + MemRecorder* next_head = cur_head->next(); + if ((void*)cur_head != Atomic::cmpxchg_ptr((void*)next_head, (void*)&_pooled_recorders, + (void*)cur_head)) { + return get_new_or_pooled_instance(); + } + cur_head->set_next(NULL); + Atomic::dec(&_pooled_recorder_count); + debug_only(cur_head->set_generation();) + return cur_head; + } +} + +/* + * retrieve all recorders in pending queue, and empty the queue + */ +MemRecorder* MemTracker::get_pending_recorders() { + MemRecorder* cur_head = const_cast(_merge_pending_queue); + MemRecorder* null_ptr = NULL; + while ((void*)cur_head != Atomic::cmpxchg_ptr((void*)null_ptr, (void*)&_merge_pending_queue, + (void*)cur_head)) { + cur_head = const_cast(_merge_pending_queue); + } + debug_only(Atomic::store(0, &_pending_recorder_count)); + return cur_head; +} + +/* + * release a recorder to recorder pool. + */ +void MemTracker::release_thread_recorder(MemRecorder* rec) { + assert(rec != NULL, "null recorder"); + // we don't want to pool too many recorders + rec->set_next(NULL); + if (shutdown_in_progress() || _pooled_recorder_count > _thread_count * 2) { + delete rec; + return; + } + + rec->clear(); + MemRecorder* cur_head = const_cast(_pooled_recorders); + rec->set_next(cur_head); + while ((void*)cur_head != Atomic::cmpxchg_ptr((void*)rec, (void*)&_pooled_recorders, + (void*)cur_head)) { + cur_head = const_cast(_pooled_recorders); + rec->set_next(cur_head); + } + Atomic::inc(&_pooled_recorder_count); +} + +/* + * This is the most important method in whole nmt implementation. + * + * Create a memory record. + * 1. When nmt is in single-threaded bootstrapping mode, no lock is needed as VM + * still in single thread mode. + * 2. For all threads other than JavaThread, ThreadCritical is needed + * to write to recorders to global recorder. + * 3. For JavaThreads that are not longer visible by safepoint, also + * need to take ThreadCritical and records are written to global + * recorders, since these threads are NOT walked by Threads.do_thread(). + * 4. JavaThreads that are running in native state, have to transition + * to VM state before writing to per-thread recorders. + * 5. JavaThreads that are running in VM state do not need any lock and + * records are written to per-thread recorders. + * 6. For a thread has yet to attach VM 'Thread', they need to take + * ThreadCritical to write to global recorder. + * + * Important note: + * NO LOCK should be taken inside ThreadCritical lock !!! + */ +void MemTracker::create_memory_record(address addr, MEMFLAGS flags, + size_t size, address pc, Thread* thread) { + if (!shutdown_in_progress()) { + // single thread, we just write records direct to global recorder,' + // with any lock + if (_state == NMT_bootstrapping_single_thread) { + assert(_main_thread_tid == os::current_thread_id(), "wrong thread"); + thread = NULL; + } else { + if (thread == NULL) { + // don't use Thread::current(), since it is possible that + // the calling thread has yet to attach to VM 'Thread', + // which will result assertion failure + thread = ThreadLocalStorage::thread(); + } + } + + if (thread != NULL) { +#ifdef ASSERT + // cause assertion on stack base. This ensures that threads call + // Thread::record_stack_base_and_size() method, which will create + // thread native stack records. + thread->stack_base(); +#endif + // for a JavaThread, if it is running in native state, we need to transition it to + // VM state, so it can stop at safepoint. JavaThread running in VM state does not + // need lock to write records. + if (thread->is_Java_thread() && ((JavaThread*)thread)->is_safepoint_visible()) { + if (((JavaThread*)thread)->thread_state() == _thread_in_native) { + ThreadInVMfromNative trans((JavaThread*)thread); + create_record_in_recorder(addr, flags, size, pc, thread); + } else { + create_record_in_recorder(addr, flags, size, pc, thread); + } + } else { + // other threads, such as worker and watcher threads, etc. need to + // take ThreadCritical to write to global recorder + ThreadCritical tc; + create_record_in_recorder(addr, flags, size, pc, NULL); + } + } else { + if (_state == NMT_bootstrapping_single_thread) { + // single thread, no lock needed + create_record_in_recorder(addr, flags, size, pc, NULL); + } else { + // for thread has yet to attach VM 'Thread', we can not use VM mutex. + // use native thread critical instead + ThreadCritical tc; + create_record_in_recorder(addr, flags, size, pc, NULL); + } + } + } +} + +// write a record to proper recorder. No lock can be taken from this method +// down. +void MemTracker::create_record_in_recorder(address addr, MEMFLAGS flags, + size_t size, address pc, Thread* thread) { + assert(thread == NULL || thread->is_Java_thread(), "wrong thread"); + + MemRecorder* rc = get_thread_recorder((JavaThread*)thread); + if (rc != NULL) { + rc->record(addr, flags, size, pc); + } +} + +/** + * enqueue a recorder to pending queue + */ +void MemTracker::enqueue_pending_recorder(MemRecorder* rec) { + assert(rec != NULL, "null recorder"); + + // we are shutting down, so just delete it + if (shutdown_in_progress()) { + rec->set_next(NULL); + delete rec; + return; + } + + MemRecorder* cur_head = const_cast(_merge_pending_queue); + rec->set_next(cur_head); + while ((void*)cur_head != Atomic::cmpxchg_ptr((void*)rec, (void*)&_merge_pending_queue, + (void*)cur_head)) { + cur_head = const_cast(_merge_pending_queue); + rec->set_next(cur_head); + } + debug_only(Atomic::inc(&_pending_recorder_count);) +} + +/* + * The method is called at global safepoint + * during it synchronization process. + * 1. enqueue all JavaThreads' per-thread recorders + * 2. enqueue global recorder + * 3. retrieve all pending recorders + * 4. reset global sequence number generator + * 5. call worker's sync + */ +#define MAX_SAFEPOINTS_TO_SKIP 128 +#define SAFE_SEQUENCE_THRESHOLD 30 +#define HIGH_GENERATION_THRESHOLD 60 + +void MemTracker::sync() { + assert(_tracking_level > NMT_off, "NMT is not enabled"); + assert(SafepointSynchronize::is_at_safepoint(), "Safepoint required"); + + // Some GC tests hit large number of safepoints in short period of time + // without meaningful activities. We should prevent going to + // sync point in these cases, which can potentially exhaust generation buffer. + // Here is the factots to determine if we should go into sync point: + // 1. not to overflow sequence number + // 2. if we are in danger to overflow generation buffer + // 3. how many safepoints we already skipped sync point + if (_state == NMT_started) { + // worker thread is not ready, no one can manage generation + // buffer, so skip this safepoint + if (_worker_thread == NULL) return; + + if (_sync_point_skip_count < MAX_SAFEPOINTS_TO_SKIP) { + int per_seq_in_use = SequenceGenerator::peek() * 100 / max_jint; + int per_gen_in_use = _worker_thread->generations_in_use() * 100 / MAX_GENERATIONS; + if (per_seq_in_use < SAFE_SEQUENCE_THRESHOLD && per_gen_in_use >= HIGH_GENERATION_THRESHOLD) { + _sync_point_skip_count ++; + return; + } + } + _sync_point_skip_count = 0; + // walk all JavaThreads to collect recorders + SyncThreadRecorderClosure stc; + Threads::threads_do(&stc); + + _thread_count = stc.get_thread_count(); + MemRecorder* pending_recorders = get_pending_recorders(); + + { + // This method is running at safepoint, with ThreadCritical lock, + // it should guarantee that NMT is fully sync-ed. + ThreadCritical tc; + if (_global_recorder != NULL) { + _global_recorder->set_next(pending_recorders); + pending_recorders = _global_recorder; + _global_recorder = NULL; + } + SequenceGenerator::reset(); + // check _worker_thread with lock to avoid racing condition + if (_worker_thread != NULL) { + _worker_thread->at_sync_point(pending_recorders); + } + } + } + + // now, it is the time to shut whole things off + if (_state == NMT_final_shutdown) { + _tracking_level = NMT_off; + + // walk all JavaThreads to delete all recorders + SyncThreadRecorderClosure stc; + Threads::threads_do(&stc); + // delete global recorder + { + ThreadCritical tc; + if (_global_recorder != NULL) { + delete _global_recorder; + _global_recorder = NULL; + } + } + + _state = NMT_shutdown; + } +} + +/* + * Start worker thread. + */ +bool MemTracker::start_worker() { + assert(_worker_thread == NULL, "Just Check"); + _worker_thread = new (std::nothrow) MemTrackWorker(); + if (_worker_thread == NULL || _worker_thread->has_error()) { + shutdown(NMT_initialization); + return false; + } + _worker_thread->start(); + return true; +} + +/* + * We need to collect a JavaThread's per-thread recorder + * before it exits. + */ +void MemTracker::thread_exiting(JavaThread* thread) { + if (is_on()) { + MemRecorder* rec = thread->get_recorder(); + if (rec != NULL) { + enqueue_pending_recorder(rec); + thread->set_recorder(NULL); + } + } +} + +// baseline current memory snapshot +bool MemTracker::baseline() { + MutexLockerEx lock(&_query_lock, true); + MemSnapshot* snapshot = get_snapshot(); + if (snapshot != NULL) { + return _baseline.baseline(*snapshot, false); + } + return false; +} + +// print memory usage from current snapshot +bool MemTracker::print_memory_usage(BaselineOutputer& out, size_t unit, bool summary_only) { + MemBaseline baseline; + MutexLockerEx lock(&_query_lock, true); + MemSnapshot* snapshot = get_snapshot(); + if (snapshot != NULL && baseline.baseline(*snapshot, summary_only)) { + BaselineReporter reporter(out, unit); + reporter.report_baseline(baseline, summary_only); + return true; + } + return false; +} + +// compare memory usage between current snapshot and baseline +bool MemTracker::compare_memory_usage(BaselineOutputer& out, size_t unit, bool summary_only) { + MutexLockerEx lock(&_query_lock, true); + if (_baseline.baselined()) { + MemBaseline baseline; + MemSnapshot* snapshot = get_snapshot(); + if (snapshot != NULL && baseline.baseline(*snapshot, summary_only)) { + BaselineReporter reporter(out, unit); + reporter.diff_baselines(baseline, _baseline, summary_only); + return true; + } + } + return false; +} + +#ifndef PRODUCT +void MemTracker::walk_stack(int toSkip, char* buf, int len) { + int cur_len = 0; + char tmp[1024]; + address pc; + + while (cur_len < len) { + pc = os::get_caller_pc(toSkip + 1); + if (pc != NULL && os::dll_address_to_function_name(pc, tmp, sizeof(tmp), NULL)) { + jio_snprintf(&buf[cur_len], (len - cur_len), "%s\n", tmp); + cur_len = (int)strlen(buf); + } else { + buf[cur_len] = '\0'; + break; + } + toSkip ++; + } +} + +void MemTracker::print_tracker_stats(outputStream* st) { + st->print_cr("\nMemory Tracker Stats:"); + st->print_cr("\tMax sequence number = %d", SequenceGenerator::max_seq_num()); + st->print_cr("\tthead count = %d", _thread_count); + st->print_cr("\tArena instance = %d", Arena::_instance_count); + st->print_cr("\tpooled recorder count = %d", _pooled_recorder_count); + st->print_cr("\tqueued recorder count = %d", _pending_recorder_count); + st->print_cr("\tmemory recorder instance count = %d", MemRecorder::_instance_count); + if (_worker_thread != NULL) { + st->print_cr("\tWorker thread:"); + st->print_cr("\t\tSync point count = %d", _worker_thread->_sync_point_count); + st->print_cr("\t\tpending recorder count = %d", _worker_thread->count_pending_recorders()); + st->print_cr("\t\tmerge count = %d", _worker_thread->_merge_count); + } else { + st->print_cr("\tWorker thread is not started"); + } + st->print_cr(" "); + + if (_snapshot != NULL) { + _snapshot->print_snapshot_stats(st); + } else { + st->print_cr("No snapshot"); + } +} +#endif + diff --git a/hotspot/src/share/vm/services/memTracker.hpp b/hotspot/src/share/vm/services/memTracker.hpp new file mode 100644 index 00000000000..b5607c1a0f8 --- /dev/null +++ b/hotspot/src/share/vm/services/memTracker.hpp @@ -0,0 +1,384 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_SERVICES_MEM_TRACKER_HPP +#define SHARE_VM_SERVICES_MEM_TRACKER_HPP + +#include "memory/allocation.hpp" +#include "runtime/globals.hpp" +#include "runtime/mutex.hpp" +#include "runtime/os.hpp" +#include "runtime/thread.hpp" +#include "services/memPtr.hpp" +#include "services/memRecorder.hpp" +#include "services/memSnapshot.hpp" +#include "services/memTrackWorker.hpp" + +#ifdef SOLARIS +#include "thread_solaris.inline.hpp" +#endif + +#ifdef _DEBUG_ + #define DEBUG_CALLER_PC os::get_caller_pc(3) +#else + #define DEBUG_CALLER_PC 0 +#endif + +// The thread closure walks threads to collect per-thread +// memory recorders at NMT sync point +class SyncThreadRecorderClosure : public ThreadClosure { + private: + int _thread_count; + + public: + SyncThreadRecorderClosure() { + _thread_count =0; + } + + void do_thread(Thread* thread); + int get_thread_count() const { + return _thread_count; + } +}; + +class BaselineOutputer; +class MemSnapshot; +class MemTrackWorker; +class Thread; +/* + * MemTracker is the 'gate' class to native memory tracking runtime. + */ +class MemTracker : AllStatic { + friend class MemTrackWorker; + friend class MemSnapshot; + friend class SyncThreadRecorderClosure; + + // NMT state + enum NMTStates { + NMT_uninited, // not yet initialized + NMT_bootstrapping_single_thread, // bootstrapping, VM is in single thread mode + NMT_bootstrapping_multi_thread, // bootstrapping, VM is about to enter multi-thread mode + NMT_started, // NMT fully started + NMT_shutdown_pending, // shutdown pending + NMT_final_shutdown, // in final phase of shutdown + NMT_shutdown // shutdown + }; + + + // native memory tracking level + enum NMTLevel { + NMT_off, // native memory tracking is off + NMT_summary, // don't track callsite + NMT_detail // track callsite also + }; + + public: + enum ShutdownReason { + NMT_shutdown_none, // no shutdown requested + NMT_shutdown_user, // user requested shutdown + NMT_normal, // normal shutdown, process exit + NMT_out_of_memory, // shutdown due to out of memory + NMT_initialization, // shutdown due to initialization failure + NMT_use_malloc_only, // can not combine NMT with UseMallocOnly flag + NMT_error_reporting, // shutdown by vmError::report_and_die() + NMT_out_of_generation, // running out of generation queue + NMT_sequence_overflow // overflow the sequence number + }; + + public: + // initialize NMT tracking level from command line options, called + // from VM command line parsing code + static void init_tracking_options(const char* option_line); + + // if NMT is enabled to record memory activities + static inline bool is_on() { + return (_tracking_level >= NMT_summary && + _state >= NMT_bootstrapping_single_thread); + } + + // user readable reason for shutting down NMT + static const char* reason() { + switch(_reason) { + case NMT_shutdown_none: + return "Native memory tracking is not enabled"; + case NMT_shutdown_user: + return "Native memory tracking has been shutdown by user"; + case NMT_normal: + return "Native memory tracking has been shutdown due to process exiting"; + case NMT_initialization: + return "Native memory tracking failed to initialize"; + case NMT_error_reporting: + return "Native memory tracking has been shutdown due to error reporting"; + case NMT_out_of_generation: + return "Native memory tracking has been shutdown due to running out of generation buffer"; + case NMT_sequence_overflow: + return "Native memory tracking has been shutdown due to overflow the sequence number"; + case NMT_use_malloc_only: + return "Native memory tracking is not supported when UseMallocOnly is on"; + default: + ShouldNotReachHere(); + return NULL; + } + } + + // test if we can walk native stack + static bool can_walk_stack() { + // native stack is not walkable during bootstrapping on sparc +#if defined(SPARC) + return (_state == NMT_started); +#else + return (_state >= NMT_bootstrapping_single_thread && _state <= NMT_started); +#endif + } + + // if native memory tracking tracks callsite + static inline bool track_callsite() { return _tracking_level == NMT_detail; } + + // shutdown native memory tracking capability. Native memory tracking + // can be shutdown by VM when it encounters low memory scenarios. + // Memory tracker should gracefully shutdown itself, and preserve the + // latest memory statistics for post morten diagnosis. + static void shutdown(ShutdownReason reason); + + // if there is shutdown requested + static inline bool shutdown_in_progress() { + return (_state >= NMT_shutdown_pending); + } + + // bootstrap native memory tracking, so it can start to collect raw data + // before worker thread can start + + // the first phase of bootstrapping, when VM still in single-threaded mode + static void bootstrap_single_thread(); + // the second phase of bootstrapping, VM is about or already in multi-threaded mode + static void bootstrap_multi_thread(); + + + // start() has to be called when VM still in single thread mode, but after + // command line option parsing is done. + static void start(); + + // record a 'malloc' call + static inline void record_malloc(address addr, size_t size, MEMFLAGS flags, + address pc = 0, Thread* thread = NULL) { + assert(is_on(), "check by caller"); + if (NMT_CAN_TRACK(flags)) { + create_memory_record(addr, (flags|MemPointerRecord::malloc_tag()), size, pc, thread); + } + } + // record a 'free' call + static inline void record_free(address addr, MEMFLAGS flags, Thread* thread = NULL) { + if (is_on() && NMT_CAN_TRACK(flags)) { + create_memory_record(addr, MemPointerRecord::free_tag(), 0, 0, thread); + } + } + // record a 'realloc' call + static inline void record_realloc(address old_addr, address new_addr, size_t size, + MEMFLAGS flags, address pc = 0, Thread* thread = NULL) { + if (is_on()) { + record_free(old_addr, flags, thread); + record_malloc(new_addr, size, flags, pc, thread); + } + } + + // record arena size + static inline void record_arena_size(address addr, size_t size) { + // we add a positive offset to arena address, so we can have arena size record + // sorted after arena record + if (is_on() && !UseMallocOnly) { + create_memory_record((addr + sizeof(void*)), MemPointerRecord::arena_size_tag(), size, + 0, NULL); + } + } + + // record a virtual memory 'reserve' call + static inline void record_virtual_memory_reserve(address addr, size_t size, + address pc = 0, Thread* thread = NULL) { + if (is_on()) { + assert(size > 0, "reserve szero size"); + create_memory_record(addr, MemPointerRecord::virtual_memory_reserve_tag(), + size, pc, thread); + } + } + + // record a virtual memory 'commit' call + static inline void record_virtual_memory_commit(address addr, size_t size, + address pc = 0, Thread* thread = NULL) { + if (is_on()) { + create_memory_record(addr, MemPointerRecord::virtual_memory_commit_tag(), + size, pc, thread); + } + } + + // record a virtual memory 'uncommit' call + static inline void record_virtual_memory_uncommit(address addr, size_t size, + Thread* thread = NULL) { + if (is_on()) { + create_memory_record(addr, MemPointerRecord::virtual_memory_uncommit_tag(), + size, 0, thread); + } + } + + // record a virtual memory 'release' call + static inline void record_virtual_memory_release(address addr, size_t size, + Thread* thread = NULL) { + if (is_on()) { + create_memory_record(addr, MemPointerRecord::virtual_memory_release_tag(), + size, 0, thread); + } + } + + // record memory type on virtual memory base address + static inline void record_virtual_memory_type(address base, MEMFLAGS flags, + Thread* thread = NULL) { + if (is_on()) { + assert(base > 0, "wrong base address"); + assert((flags & (~mt_masks)) == 0, "memory type only"); + create_memory_record(base, (flags | MemPointerRecord::virtual_memory_type_tag()), + 0, 0, thread); + } + } + + + // create memory baseline of current memory snapshot + static bool baseline(); + // is there a memory baseline + static bool has_baseline() { + return _baseline.baselined(); + } + + // print memory usage from current snapshot + static bool print_memory_usage(BaselineOutputer& out, size_t unit, + bool summary_only = true); + // compare memory usage between current snapshot and baseline + static bool compare_memory_usage(BaselineOutputer& out, size_t unit, + bool summary_only = true); + + // sync is called within global safepoint to synchronize nmt data + static void sync(); + + // called when a thread is about to exit + static void thread_exiting(JavaThread* thread); + + // retrieve global snapshot + static MemSnapshot* get_snapshot() { + assert(is_on(), "native memory tracking is off"); + if (shutdown_in_progress()) { + return NULL; + } + return _snapshot; + } + + // print tracker stats + NOT_PRODUCT(static void print_tracker_stats(outputStream* st);) + NOT_PRODUCT(static void walk_stack(int toSkip, char* buf, int len);) + + private: + // start native memory tracking worker thread + static bool start_worker(); + + // called by worker thread to complete shutdown process + static void final_shutdown(); + + protected: + // retrieve per-thread recorder of the specified thread. + // if the recorder is full, it will be enqueued to overflow + // queue, a new recorder is acquired from recorder pool or a + // new instance is created. + // when thread == NULL, it means global recorder + static MemRecorder* get_thread_recorder(JavaThread* thread); + + // per-thread recorder pool + static void release_thread_recorder(MemRecorder* rec); + static void delete_all_pooled_recorders(); + + // pending recorder queue. Recorders are queued to pending queue + // when they are overflowed or collected at nmt sync point. + static void enqueue_pending_recorder(MemRecorder* rec); + static MemRecorder* get_pending_recorders(); + static void delete_all_pending_recorders(); + + private: + // retrieve a pooled memory record or create new one if there is not + // one available + static MemRecorder* get_new_or_pooled_instance(); + static void create_memory_record(address addr, MEMFLAGS type, + size_t size, address pc, Thread* thread); + static void create_record_in_recorder(address addr, MEMFLAGS type, + size_t size, address pc, Thread* thread); + + private: + // global memory snapshot + static MemSnapshot* _snapshot; + + // a memory baseline of snapshot + static MemBaseline _baseline; + + // query lock + static Mutex _query_lock; + + // a thread can start to allocate memory before it is attached + // to VM 'Thread', those memory activities are recorded here. + // ThreadCritical is required to guard this global recorder. + static MemRecorder* _global_recorder; + + // main thread id + debug_only(static intx _main_thread_tid;) + + // pending recorders to be merged + static volatile MemRecorder* _merge_pending_queue; + + NOT_PRODUCT(static volatile jint _pending_recorder_count;) + + // pooled memory recorders + static volatile MemRecorder* _pooled_recorders; + + // memory recorder pool management, uses following + // counter to determine if a released memory recorder + // should be pooled + + // latest thread count + static int _thread_count; + // pooled recorder count + static volatile jint _pooled_recorder_count; + + + // worker thread to merge pending recorders into snapshot + static MemTrackWorker* _worker_thread; + + // how many safepoints we skipped without entering sync point + static int _sync_point_skip_count; + + // if the tracker is properly intialized + static bool _is_tracker_ready; + // tracking level (off, summary and detail) + static enum NMTLevel _tracking_level; + + // current nmt state + static volatile enum NMTStates _state; + // the reason for shutting down nmt + static enum ShutdownReason _reason; +}; + +#endif // SHARE_VM_SERVICES_MEM_TRACKER_HPP diff --git a/hotspot/src/share/vm/services/memoryManager.cpp b/hotspot/src/share/vm/services/memoryManager.cpp index 0666223bed5..8852f9ffc4b 100644 --- a/hotspot/src/share/vm/services/memoryManager.cpp +++ b/hotspot/src/share/vm/services/memoryManager.cpp @@ -166,15 +166,15 @@ void MemoryManager::oops_do(OopClosure* f) { GCStatInfo::GCStatInfo(int num_pools) { // initialize the arrays for memory usage - _before_gc_usage_array = (MemoryUsage*) NEW_C_HEAP_ARRAY(MemoryUsage, num_pools); - _after_gc_usage_array = (MemoryUsage*) NEW_C_HEAP_ARRAY(MemoryUsage, num_pools); + _before_gc_usage_array = (MemoryUsage*) NEW_C_HEAP_ARRAY(MemoryUsage, num_pools, mtInternal); + _after_gc_usage_array = (MemoryUsage*) NEW_C_HEAP_ARRAY(MemoryUsage, num_pools, mtInternal); _usage_array_size = num_pools; clear(); } GCStatInfo::~GCStatInfo() { - FREE_C_HEAP_ARRAY(MemoryUsage*, _before_gc_usage_array); - FREE_C_HEAP_ARRAY(MemoryUsage*, _after_gc_usage_array); + FREE_C_HEAP_ARRAY(MemoryUsage*, _before_gc_usage_array, mtInternal); + FREE_C_HEAP_ARRAY(MemoryUsage*, _after_gc_usage_array, mtInternal); } void GCStatInfo::set_gc_usage(int pool_index, MemoryUsage usage, bool before_gc) { @@ -214,8 +214,8 @@ GCMemoryManager::~GCMemoryManager() { void GCMemoryManager::initialize_gc_stat_info() { assert(MemoryService::num_memory_pools() > 0, "should have one or more memory pools"); - _last_gc_stat = new(ResourceObj::C_HEAP) GCStatInfo(MemoryService::num_memory_pools()); - _current_gc_stat = new(ResourceObj::C_HEAP) GCStatInfo(MemoryService::num_memory_pools()); + _last_gc_stat = new(ResourceObj::C_HEAP, mtGC) GCStatInfo(MemoryService::num_memory_pools()); + _current_gc_stat = new(ResourceObj::C_HEAP, mtGC) GCStatInfo(MemoryService::num_memory_pools()); // tracking concurrent collections we need two objects: one to update, and one to // hold the publicly available "last (completed) gc" information. } diff --git a/hotspot/src/share/vm/services/memoryManager.hpp b/hotspot/src/share/vm/services/memoryManager.hpp index eb0d9699c1f..bb6a8112d4a 100644 --- a/hotspot/src/share/vm/services/memoryManager.hpp +++ b/hotspot/src/share/vm/services/memoryManager.hpp @@ -40,7 +40,7 @@ class MemoryPool; class GCMemoryManager; class OopClosure; -class MemoryManager : public CHeapObj { +class MemoryManager : public CHeapObj { private: enum { max_num_pools = 10 diff --git a/hotspot/src/share/vm/services/memoryPool.hpp b/hotspot/src/share/vm/services/memoryPool.hpp index 441df25915c..db560dbeded 100644 --- a/hotspot/src/share/vm/services/memoryPool.hpp +++ b/hotspot/src/share/vm/services/memoryPool.hpp @@ -50,7 +50,7 @@ class PSPermGen; class PermGen; class ThresholdSupport; -class MemoryPool : public CHeapObj { +class MemoryPool : public CHeapObj { friend class MemoryManager; public: enum PoolType { diff --git a/hotspot/src/share/vm/services/memoryService.cpp b/hotspot/src/share/vm/services/memoryService.cpp index d1bb9c2d60e..621cb7ab01f 100644 --- a/hotspot/src/share/vm/services/memoryService.cpp +++ b/hotspot/src/share/vm/services/memoryService.cpp @@ -58,9 +58,9 @@ #endif GrowableArray* MemoryService::_pools_list = - new (ResourceObj::C_HEAP) GrowableArray(init_pools_list_size, true); + new (ResourceObj::C_HEAP, mtInternal) GrowableArray(init_pools_list_size, true); GrowableArray* MemoryService::_managers_list = - new (ResourceObj::C_HEAP) GrowableArray(init_managers_list_size, true); + new (ResourceObj::C_HEAP, mtInternal) GrowableArray(init_managers_list_size, true); GCMemoryManager* MemoryService::_minor_gc_manager = NULL; GCMemoryManager* MemoryService::_major_gc_manager = NULL; diff --git a/hotspot/src/share/vm/services/nmtDCmd.cpp b/hotspot/src/share/vm/services/nmtDCmd.cpp new file mode 100644 index 00000000000..47f460e6e97 --- /dev/null +++ b/hotspot/src/share/vm/services/nmtDCmd.cpp @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ +#include "precompiled.hpp" +#include "services/nmtDCmd.hpp" +#include "services/memReporter.hpp" +#include "services/memTracker.hpp" +#include "utilities/globalDefinitions.hpp" + +NMTDCmd::NMTDCmd(outputStream* output, + bool heap): DCmdWithParser(output, heap), + _summary("summary", "request runtime to report current memory summary, " \ + "which includes total reserved and committed memory, along " \ + "with memory usage summary by each subsytem.", + "BOOLEAN", false, "false"), + _detail("detail", "request runtime to report memory allocation >= " + "1K by each callsite.", + "BOOLEAN", false, "false"), + _baseline("baseline", "request runtime to baseline current memory usage, " \ + "so it can be compared against in later time.", + "BOOLEAN", false, "false"), + _summary_diff("summary.diff", "request runtime to report memory summary " \ + "comparison against previous baseline.", + "BOOLEAN", false, "false"), + _detail_diff("detail.diff", "request runtime to report memory detail " \ + "comparison against previous baseline, which shows the memory " \ + "allocation activities at different callsites.", + "BOOLEAN", false, "false"), + _shutdown("shutdown", "request runtime to shutdown itself and free the " \ + "memory used by runtime.", + "BOOLEAN", false, "false"), +#ifndef PRODUCT + _debug("debug", "print tracker statistics. Debug only, not thread safe", \ + "BOOLEAN", false, "false"), +#endif + _scale("scale", "Memory usage in which scale, KB, MB or GB", + "STRING", false, "KB") { + _dcmdparser.add_dcmd_option(&_summary); + _dcmdparser.add_dcmd_option(&_detail); + _dcmdparser.add_dcmd_option(&_baseline); + _dcmdparser.add_dcmd_option(&_summary_diff); + _dcmdparser.add_dcmd_option(&_detail_diff); + _dcmdparser.add_dcmd_option(&_shutdown); +#ifndef PRODUCT + _dcmdparser.add_dcmd_option(&_debug); +#endif + _dcmdparser.add_dcmd_option(&_scale); +} + +void NMTDCmd::execute(TRAPS) { + const char* scale_value = _scale.value(); + size_t scale_unit; + if (strcmp(scale_value, "KB") == 0 || strcmp(scale_value, "kb") == 0) { + scale_unit = K; + } else if (strcmp(scale_value, "MB") == 0 || + strcmp(scale_value, "mb") == 0) { + scale_unit = M; + } else if (strcmp(scale_value, "GB") == 0 || + strcmp(scale_value, "gb") == 0) { + scale_unit = G; + } else { + output()->print_cr("Incorrect scale value: %s", scale_value); + return; + } + + int nopt = 0; + if(_summary.is_set()) { ++nopt; } + if(_detail.is_set()) { ++nopt; } + if(_baseline.is_set()) { ++nopt; } + if(_summary_diff.is_set()) { ++nopt; } + if(_detail_diff.is_set()) { ++nopt; } + if(_shutdown.is_set()) { ++nopt; } +#ifndef PRODUCT + if(_debug.is_set()) { ++nopt; } +#endif + + if(nopt > 1) { + output()->print_cr("At most one of the following option can be specified: " \ + "summary, detail, baseline, summary.diff, detail.diff, shutdown" +#ifndef PRODUCT + " ,debug" +#endif + ); + return; + } + + if(nopt == 0) { + _summary.set_value(true); + } + +#ifndef PRODUCT + if (_debug.value()) { + output()->print_cr("debug command is NOT thread-safe, may cause crash"); + MemTracker::print_tracker_stats(output()); + return; + } +#endif + + // native memory tracking has to be on + if (!MemTracker::is_on() || MemTracker::shutdown_in_progress()) { + // if it is not on, what's the reason? + output()->print_cr(MemTracker::reason()); + return; + } + + if (_summary.value()) { + BaselineTTYOutputer outputer(output()); + MemTracker::print_memory_usage(outputer, scale_unit, true); + } else if (_detail.value()) { + BaselineTTYOutputer outputer(output()); + MemTracker::print_memory_usage(outputer, scale_unit, false); + } else if (_baseline.value()) { + if (MemTracker::baseline()) { + output()->print_cr("Successfully baselined."); + } else { + output()->print_cr("Baseline failed."); + } + } else if (_summary_diff.value()) { + if (MemTracker::has_baseline()) { + BaselineTTYOutputer outputer(output()); + MemTracker::compare_memory_usage(outputer, scale_unit, true); + } else { + output()->print_cr("No baseline to compare, run 'baseline' command first"); + } + } else if (_detail_diff.value()) { + if (MemTracker::has_baseline()) { + BaselineTTYOutputer outputer(output()); + MemTracker::compare_memory_usage(outputer, scale_unit, false); + } else { + output()->print_cr("No baseline to compare to, run 'baseline' command first"); + } + } else if (_shutdown.value()) { + MemTracker::shutdown(MemTracker::NMT_shutdown_user); + output()->print_cr("Shutdown is in progress, it will take a few moments to " \ + "completely shutdown"); + } else { + ShouldNotReachHere(); + output()->print_cr("Unknown command"); + } +} + +int NMTDCmd::num_arguments() { + ResourceMark rm; + NMTDCmd* dcmd = new NMTDCmd(NULL, false); + if (dcmd != NULL) { + DCmdMark mark(dcmd); + return dcmd->_dcmdparser.num_arguments(); + } else { + return 0; + } +} + diff --git a/hotspot/src/share/vm/services/nmtDCmd.hpp b/hotspot/src/share/vm/services/nmtDCmd.hpp new file mode 100644 index 00000000000..0c8c8657a72 --- /dev/null +++ b/hotspot/src/share/vm/services/nmtDCmd.hpp @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_SERVICES_NMT_DCMD_HPP +#define SHARE_VM_SERVICES_NMT_DCMD_HPP + +#include "services/diagnosticArgument.hpp" +#include "services/diagnosticFramework.hpp" + +/** + * Native memory tracking DCmd implementation + */ +class NMTDCmd: public DCmdWithParser { + protected: + DCmdArgument _summary; + DCmdArgument _detail; + DCmdArgument _baseline; + DCmdArgument _summary_diff; + DCmdArgument _detail_diff; + DCmdArgument _shutdown; +#ifndef PRODUCT + DCmdArgument _debug; +#endif + DCmdArgument _scale; + + public: + NMTDCmd(outputStream* output, bool heap); + static const char* name() { return "VM.native_memory"; } + static const char* description() { + return "Print native memory usage"; + } + static const char* impact() { + return "Medium:"; + } + static int num_arguments(); + virtual void execute(TRAPS); +}; + +#endif // SHARE_VM_SERVICES_NMT_DCMD_HPP diff --git a/hotspot/src/share/vm/services/threadService.cpp b/hotspot/src/share/vm/services/threadService.cpp index 5c70fe99baa..325c236b5f7 100644 --- a/hotspot/src/share/vm/services/threadService.cpp +++ b/hotspot/src/share/vm/services/threadService.cpp @@ -437,7 +437,7 @@ StackFrameInfo::StackFrameInfo(javaVFrame* jvf, bool with_lock_info) { GrowableArray* list = jvf->locked_monitors(); int length = list->length(); if (length > 0) { - _locked_monitors = new (ResourceObj::C_HEAP) GrowableArray(length, true); + _locked_monitors = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(length, true); for (int i = 0; i < length; i++) { MonitorInfo* monitor = list->at(i); assert(monitor->owner(), "This monitor must have an owning object"); @@ -491,11 +491,11 @@ public: ThreadStackTrace::ThreadStackTrace(JavaThread* t, bool with_locked_monitors) { _thread = t; - _frames = new (ResourceObj::C_HEAP) GrowableArray(INITIAL_ARRAY_SIZE, true); + _frames = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(INITIAL_ARRAY_SIZE, true); _depth = 0; _with_locked_monitors = with_locked_monitors; if (_with_locked_monitors) { - _jni_locked_monitors = new (ResourceObj::C_HEAP) GrowableArray(INITIAL_ARRAY_SIZE, true); + _jni_locked_monitors = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(INITIAL_ARRAY_SIZE, true); } else { _jni_locked_monitors = NULL; } @@ -689,7 +689,7 @@ void ConcurrentLocksDump::print_locks_on(JavaThread* t, outputStream* st) { ThreadConcurrentLocks::ThreadConcurrentLocks(JavaThread* thread) { _thread = thread; - _owned_locks = new (ResourceObj::C_HEAP) GrowableArray(INITIAL_ARRAY_SIZE, true); + _owned_locks = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(INITIAL_ARRAY_SIZE, true); _next = NULL; } @@ -803,7 +803,7 @@ void ThreadSnapshot::oops_do(OopClosure* f) { DeadlockCycle::DeadlockCycle() { _is_deadlock = false; - _threads = new (ResourceObj::C_HEAP) GrowableArray(INITIAL_ARRAY_SIZE, true); + _threads = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(INITIAL_ARRAY_SIZE, true); _next = NULL; } diff --git a/hotspot/src/share/vm/services/threadService.hpp b/hotspot/src/share/vm/services/threadService.hpp index bd1395a7d4b..9f91edf7a60 100644 --- a/hotspot/src/share/vm/services/threadService.hpp +++ b/hotspot/src/share/vm/services/threadService.hpp @@ -116,7 +116,7 @@ public: }; // Per-thread Statistics for synchronization -class ThreadStatistics : public CHeapObj { +class ThreadStatistics : public CHeapObj { private: // The following contention statistics are only updated by // the thread owning these statistics when contention occurs. @@ -186,7 +186,7 @@ public: }; // Thread snapshot to represent the thread state and statistics -class ThreadSnapshot : public CHeapObj { +class ThreadSnapshot : public CHeapObj { private: JavaThread* _thread; oop _threadObj; @@ -244,7 +244,7 @@ public: void oops_do(OopClosure* f); }; -class ThreadStackTrace : public CHeapObj { +class ThreadStackTrace : public CHeapObj { private: JavaThread* _thread; int _depth; // number of stack frames added @@ -275,7 +275,7 @@ class ThreadStackTrace : public CHeapObj { // StackFrameInfo for keeping methodOop and bci during // stack walking for later construction of StackTraceElement[] // Java instances -class StackFrameInfo : public CHeapObj { +class StackFrameInfo : public CHeapObj { private: methodOop _method; int _bci; @@ -299,7 +299,7 @@ class StackFrameInfo : public CHeapObj { void print_on(outputStream* st) const; }; -class ThreadConcurrentLocks : public CHeapObj { +class ThreadConcurrentLocks : public CHeapObj { private: GrowableArray* _owned_locks; ThreadConcurrentLocks* _next; @@ -356,7 +356,7 @@ class ThreadDumpResult : public StackObj { void oops_do(OopClosure* f); }; -class DeadlockCycle : public CHeapObj { +class DeadlockCycle : public CHeapObj { private: bool _is_deadlock; GrowableArray* _threads; diff --git a/hotspot/src/share/vm/utilities/array.cpp b/hotspot/src/share/vm/utilities/array.cpp index 44782ea8937..b1c7a61d970 100644 --- a/hotspot/src/share/vm/utilities/array.cpp +++ b/hotspot/src/share/vm/utilities/array.cpp @@ -49,7 +49,7 @@ void ResourceArray::init_nesting() { void ResourceArray::sort(size_t esize, ftype f) { if (!is_empty()) qsort(_data, length(), esize, f); } -void CHeapArray::sort(size_t esize, ftype f) { +template void CHeapArray::sort(size_t esize, ftype f) { if (!is_empty()) qsort(_data, length(), esize, f); } @@ -70,14 +70,14 @@ void ResourceArray::expand(size_t esize, int i, int& size) { } -void CHeapArray::expand(size_t esize, int i, int& size) { +template void CHeapArray::expand(size_t esize, int i, int& size) { // determine new size if (size == 0) size = 4; // prevent endless loop while (i >= size) size *= 2; // allocate and initialize new data section - void* data = NEW_C_HEAP_ARRAY(char*, esize * size); + void* data = NEW_C_HEAP_ARRAY(char*, esize * size, F); memcpy(data, _data, esize * length()); - FREE_C_HEAP_ARRAY(char*, _data); + FREE_C_HEAP_ARRAY(char*, _data, F); _data = data; } @@ -91,7 +91,7 @@ void ResourceArray::remove_at(size_t esize, int i) { memmove(dst, src, cnt); } -void CHeapArray::remove_at(size_t esize, int i) { +template void CHeapArray::remove_at(size_t esize, int i) { assert(0 <= i && i < length(), "index out of bounds"); _length--; void* dst = (char*)_data + i*esize; diff --git a/hotspot/src/share/vm/utilities/array.hpp b/hotspot/src/share/vm/utilities/array.hpp index cbc4161a42f..c0fb59283da 100644 --- a/hotspot/src/share/vm/utilities/array.hpp +++ b/hotspot/src/share/vm/utilities/array.hpp @@ -79,7 +79,7 @@ class ResourceArray: public ResourceObj { }; -class CHeapArray: public CHeapObj { +template class CHeapArray: public CHeapObj { protected: int _length; // the number of array elements void* _data; // the array memory @@ -94,7 +94,7 @@ class CHeapArray: public CHeapObj { CHeapArray(size_t esize, int length) { assert(length >= 0, "illegal length"); _length = length; - _data = (void*) NEW_C_HEAP_ARRAY(char *, esize * length); + _data = (void*) NEW_C_HEAP_ARRAY(char *, esize * length, F); } #ifdef ASSERT diff --git a/hotspot/src/share/vm/utilities/bitMap.cpp b/hotspot/src/share/vm/utilities/bitMap.cpp index 3141bc0de34..0b12b118079 100644 --- a/hotspot/src/share/vm/utilities/bitMap.cpp +++ b/hotspot/src/share/vm/utilities/bitMap.cpp @@ -65,8 +65,8 @@ void BitMap::resize(idx_t size_in_bits, bool in_resource_area) { if (in_resource_area) { _map = NEW_RESOURCE_ARRAY(bm_word_t, new_size_in_words); } else { - if (old_map != NULL) FREE_C_HEAP_ARRAY(bm_word_t, _map); - _map = NEW_C_HEAP_ARRAY(bm_word_t, new_size_in_words); + if (old_map != NULL) FREE_C_HEAP_ARRAY(bm_word_t, _map, mtInternal); + _map = NEW_C_HEAP_ARRAY(bm_word_t, new_size_in_words, mtInternal); } Copy::disjoint_words((HeapWord*)old_map, (HeapWord*) _map, MIN2(old_size_in_words, new_size_in_words)); @@ -469,7 +469,7 @@ BitMap::idx_t* BitMap::_pop_count_table = NULL; void BitMap::init_pop_count_table() { if (_pop_count_table == NULL) { - BitMap::idx_t *table = NEW_C_HEAP_ARRAY(idx_t, 256); + BitMap::idx_t *table = NEW_C_HEAP_ARRAY(idx_t, 256, mtInternal); for (uint i = 0; i < 256; i++) { table[i] = num_set_bits(i); } @@ -479,7 +479,7 @@ void BitMap::init_pop_count_table() { (intptr_t) NULL_WORD); if (res != NULL_WORD) { guarantee( _pop_count_table == (void*) res, "invariant" ); - FREE_C_HEAP_ARRAY(bm_word_t, table); + FREE_C_HEAP_ARRAY(bm_word_t, table, mtInternal); } } } diff --git a/hotspot/src/share/vm/utilities/decoder.hpp b/hotspot/src/share/vm/utilities/decoder.hpp index 56ff91907cc..a24f771b7bb 100644 --- a/hotspot/src/share/vm/utilities/decoder.hpp +++ b/hotspot/src/share/vm/utilities/decoder.hpp @@ -29,7 +29,7 @@ #include "memory/allocation.hpp" #include "runtime/mutex.hpp" -class AbstractDecoder : public CHeapObj { +class AbstractDecoder : public CHeapObj { public: // status code for decoding native C frame enum decoder_status { diff --git a/hotspot/src/share/vm/utilities/elfFile.cpp b/hotspot/src/share/vm/utilities/elfFile.cpp index 2e4b68302e9..5faaf83b53a 100644 --- a/hotspot/src/share/vm/utilities/elfFile.cpp +++ b/hotspot/src/share/vm/utilities/elfFile.cpp @@ -47,7 +47,7 @@ ElfFile::ElfFile(const char* filepath) { m_status = NullDecoder::no_error; int len = strlen(filepath) + 1; - m_filepath = (const char*)os::malloc(len * sizeof(char)); + m_filepath = (const char*)os::malloc(len * sizeof(char), mtInternal); if (m_filepath != NULL) { strcpy((char*)m_filepath, filepath); m_file = fopen(filepath, "r"); diff --git a/hotspot/src/share/vm/utilities/elfFile.hpp b/hotspot/src/share/vm/utilities/elfFile.hpp index e6f4ce263d6..f0cba8b6d08 100644 --- a/hotspot/src/share/vm/utilities/elfFile.hpp +++ b/hotspot/src/share/vm/utilities/elfFile.hpp @@ -82,7 +82,7 @@ class ElfSymbolTable; // in "error" state, so there are scenarios, lookup will fail. We want this // part of code to be very defensive, and bait out if anything went wrong. -class ElfFile: public CHeapObj { +class ElfFile: public CHeapObj { friend class ElfDecoder; public: ElfFile(const char* filepath); diff --git a/hotspot/src/share/vm/utilities/elfStringTable.cpp b/hotspot/src/share/vm/utilities/elfStringTable.cpp index 89286cb1883..cba67ddf646 100644 --- a/hotspot/src/share/vm/utilities/elfStringTable.cpp +++ b/hotspot/src/share/vm/utilities/elfStringTable.cpp @@ -42,7 +42,7 @@ ElfStringTable::ElfStringTable(FILE* file, Elf_Shdr shdr, int index) { // try to load the string table long cur_offset = ftell(file); - m_table = (char*)os::malloc(sizeof(char) * shdr.sh_size); + m_table = (char*)os::malloc(sizeof(char) * shdr.sh_size, mtInternal); if (m_table != NULL) { // if there is an error, mark the error if (fseek(file, shdr.sh_offset, SEEK_SET) || diff --git a/hotspot/src/share/vm/utilities/elfStringTable.hpp b/hotspot/src/share/vm/utilities/elfStringTable.hpp index 96f30b159ea..a4cdfc07854 100644 --- a/hotspot/src/share/vm/utilities/elfStringTable.hpp +++ b/hotspot/src/share/vm/utilities/elfStringTable.hpp @@ -35,7 +35,7 @@ // The string table represents a string table section in an elf file. // Whenever there is enough memory, it will load whole string table as // one blob. Otherwise, it will load string from file when requested. -class ElfStringTable: CHeapObj { +class ElfStringTable: CHeapObj { friend class ElfFile; public: ElfStringTable(FILE* file, Elf_Shdr shdr, int index); diff --git a/hotspot/src/share/vm/utilities/elfSymbolTable.cpp b/hotspot/src/share/vm/utilities/elfSymbolTable.cpp index 3ac9b9215f6..5301d5a32a5 100644 --- a/hotspot/src/share/vm/utilities/elfSymbolTable.cpp +++ b/hotspot/src/share/vm/utilities/elfSymbolTable.cpp @@ -40,7 +40,7 @@ ElfSymbolTable::ElfSymbolTable(FILE* file, Elf_Shdr shdr) { long cur_offset = ftell(file); if (cur_offset != -1) { // call malloc so we can back up if memory allocation fails. - m_symbols = (Elf_Sym*)os::malloc(shdr.sh_size); + m_symbols = (Elf_Sym*)os::malloc(shdr.sh_size, mtInternal); if (m_symbols) { if (fseek(file, shdr.sh_offset, SEEK_SET) || fread((void*)m_symbols, shdr.sh_size, 1, file) != 1 || diff --git a/hotspot/src/share/vm/utilities/elfSymbolTable.hpp b/hotspot/src/share/vm/utilities/elfSymbolTable.hpp index a149b99dfd8..4a23cfdeeda 100644 --- a/hotspot/src/share/vm/utilities/elfSymbolTable.hpp +++ b/hotspot/src/share/vm/utilities/elfSymbolTable.hpp @@ -38,7 +38,7 @@ * of the elf file into memory. Otherwise, it will walk the section in file * to look up the symbol that nearest the given address. */ -class ElfSymbolTable: public CHeapObj { +class ElfSymbolTable: public CHeapObj { friend class ElfFile; public: ElfSymbolTable(FILE* file, Elf_Shdr shdr); diff --git a/hotspot/src/share/vm/utilities/events.hpp b/hotspot/src/share/vm/utilities/events.hpp index 5b64e0c5c4d..74a804219fa 100644 --- a/hotspot/src/share/vm/utilities/events.hpp +++ b/hotspot/src/share/vm/utilities/events.hpp @@ -46,7 +46,7 @@ // crash time. This is a very generic interface that is mainly here // for completeness. Normally the templated EventLogBase would be // subclassed to provide different log types. -class EventLog : public CHeapObj { +class EventLog : public CHeapObj { friend class Events; private: diff --git a/hotspot/src/share/vm/utilities/exceptions.hpp b/hotspot/src/share/vm/utilities/exceptions.hpp index f7fece16fb6..568dfd0fb3c 100644 --- a/hotspot/src/share/vm/utilities/exceptions.hpp +++ b/hotspot/src/share/vm/utilities/exceptions.hpp @@ -57,7 +57,7 @@ class JavaCallArguments; // field of the Thread class w/o having access to the Thread's interface (for // include hierachy reasons). -class ThreadShadow: public CHeapObj { +class ThreadShadow: public CHeapObj { friend class VMStructs; protected: diff --git a/hotspot/src/share/vm/utilities/growableArray.cpp b/hotspot/src/share/vm/utilities/growableArray.cpp index a6ad8f3057e..7da659e6f68 100644 --- a/hotspot/src/share/vm/utilities/growableArray.cpp +++ b/hotspot/src/share/vm/utilities/growableArray.cpp @@ -61,7 +61,7 @@ void* GenericGrowableArray::raw_allocate(int elementSize) { if (on_stack()) { return (void*)resource_allocate_bytes(byte_size); } else if (on_C_heap()) { - return (void*)AllocateHeap(byte_size, "GrET in " __FILE__); + return (void*)AllocateHeap(byte_size, _memflags); } else { return _arena->Amalloc(byte_size); } diff --git a/hotspot/src/share/vm/utilities/growableArray.hpp b/hotspot/src/share/vm/utilities/growableArray.hpp index f7379fca551..2a6d6b88f9d 100644 --- a/hotspot/src/share/vm/utilities/growableArray.hpp +++ b/hotspot/src/share/vm/utilities/growableArray.hpp @@ -86,6 +86,9 @@ class GenericGrowableArray : public ResourceObj { // 0 means default ResourceArea // 1 means on C heap // otherwise, allocate in _arena + + MEMFLAGS _memflags; // memory type if allocation in C heap + #ifdef ASSERT int _nesting; // resource area nesting at creation void set_nesting(); @@ -102,9 +105,14 @@ class GenericGrowableArray : public ResourceObj { // This GA will use the resource stack for storage if c_heap==false, // Else it will use the C heap. Use clear_and_deallocate to avoid leaks. - GenericGrowableArray(int initial_size, int initial_len, bool c_heap) { + GenericGrowableArray(int initial_size, int initial_len, bool c_heap, MEMFLAGS flags = mtNone) { _len = initial_len; _max = initial_size; + _memflags = flags; + + // memory type has to be specified for C heap allocation + assert(!(c_heap && flags == mtNone), "memory type not specified for C heap object"); + assert(_len >= 0 && _len <= _max, "initial_len too big"); _arena = (c_heap ? (Arena*)1 : NULL); set_nesting(); @@ -121,6 +129,8 @@ class GenericGrowableArray : public ResourceObj { _max = initial_size; assert(_len >= 0 && _len <= _max, "initial_len too big"); _arena = arena; + _memflags = mtNone; + assert(on_arena(), "arena has taken on reserved value 0 or 1"); // Relax next assert to allow object allocation on resource area, // on stack or embedded into an other object. @@ -152,12 +162,14 @@ template class GrowableArray : public GenericGrowableArray { for (int i = 0; i < _max; i++) ::new ((void*)&_data[i]) E(); } - GrowableArray(int initial_size, bool C_heap = false) : GenericGrowableArray(initial_size, 0, C_heap) { + GrowableArray(int initial_size, bool C_heap = false, MEMFLAGS F = mtInternal) + : GenericGrowableArray(initial_size, 0, C_heap, F) { _data = (E*)raw_allocate(sizeof(E)); for (int i = 0; i < _max; i++) ::new ((void*)&_data[i]) E(); } - GrowableArray(int initial_size, int initial_len, const E& filler, bool C_heap = false) : GenericGrowableArray(initial_size, initial_len, C_heap) { + GrowableArray(int initial_size, int initial_len, const E& filler, bool C_heap = false, MEMFLAGS memflags = mtInternal) + : GenericGrowableArray(initial_size, initial_len, C_heap, memflags) { _data = (E*)raw_allocate(sizeof(E)); int i = 0; for (; i < _len; i++) ::new ((void*)&_data[i]) E(filler); diff --git a/hotspot/src/share/vm/utilities/hashtable.cpp b/hotspot/src/share/vm/utilities/hashtable.cpp index 877e89533c2..9b7db5e9a30 100644 --- a/hotspot/src/share/vm/utilities/hashtable.cpp +++ b/hotspot/src/share/vm/utilities/hashtable.cpp @@ -33,11 +33,6 @@ #include "utilities/hashtable.inline.hpp" -#ifndef USDT2 -HS_DTRACE_PROBE_DECL4(hs_private, hashtable__new_entry, - void*, unsigned int, void*, void*); -#endif /* !USDT2 */ - // This is a generic hashtable, designed to be used for the symbol // and string tables. // @@ -46,8 +41,8 @@ HS_DTRACE_PROBE_DECL4(hs_private, hashtable__new_entry, // %note: // - HashtableEntrys are allocated in blocks to reduce the space overhead. -BasicHashtableEntry* BasicHashtable::new_entry(unsigned int hashValue) { - BasicHashtableEntry* entry; +template BasicHashtableEntry* BasicHashtable::new_entry(unsigned int hashValue) { + BasicHashtableEntry* entry; if (_free_list) { entry = _free_list; @@ -58,10 +53,10 @@ BasicHashtableEntry* BasicHashtable::new_entry(unsigned int hashValue) { int len = _entry_size * block_size; len = 1 << log2_intptr(len); // round down to power of 2 assert(len >= _entry_size, ""); - _first_free_entry = NEW_C_HEAP_ARRAY(char, len); + _first_free_entry = NEW_C_HEAP_ARRAY2(char, len, F, CURRENT_PC); _end_block = _first_free_entry + len; } - entry = (BasicHashtableEntry*)_first_free_entry; + entry = (BasicHashtableEntry*)_first_free_entry; _first_free_entry += _entry_size; } @@ -71,29 +66,21 @@ BasicHashtableEntry* BasicHashtable::new_entry(unsigned int hashValue) { } -template HashtableEntry* Hashtable::new_entry(unsigned int hashValue, T obj) { - HashtableEntry* entry; +template HashtableEntry* Hashtable::new_entry(unsigned int hashValue, T obj) { + HashtableEntry* entry; - entry = (HashtableEntry*)BasicHashtable::new_entry(hashValue); + entry = (HashtableEntry*)BasicHashtable::new_entry(hashValue); entry->set_literal(obj); -#ifndef USDT2 - HS_DTRACE_PROBE4(hs_private, hashtable__new_entry, - this, hashValue, obj, entry); -#else /* USDT2 */ - HS_PRIVATE_HASHTABLE_NEW_ENTRY( - this, hashValue, (uintptr_t) obj, entry); -#endif /* USDT2 */ return entry; } - // Check to see if the hashtable is unbalanced. The caller set a flag to // rehash at the next safepoint. If this bucket is 60 times greater than the // expected average bucket length, it's an unbalanced hashtable. // This is somewhat an arbitrary heuristic but if one bucket gets to // rehash_count which is currently 100, there's probably something wrong. -bool BasicHashtable::check_rehash_table(int count) { +template bool BasicHashtable::check_rehash_table(int count) { assert(table_size() != 0, "underflow"); if (count > (((double)number_of_entries()/(double)table_size())*rehash_multiple)) { // Set a flag for the next safepoint, which should be at some guaranteed @@ -107,13 +94,13 @@ bool BasicHashtable::check_rehash_table(int count) { // with the existing elements. This can be used to change the hash code // and could in the future change the size of the table. -template void Hashtable::move_to(Hashtable* new_table) { - int saved_entry_count = number_of_entries(); +template void Hashtable::move_to(Hashtable* new_table) { + int saved_entry_count = BasicHashtable::number_of_entries(); // Iterate through the table and create a new entry for the new table for (int i = 0; i < new_table->table_size(); ++i) { - for (HashtableEntry* p = bucket(i); p != NULL; ) { - HashtableEntry* next = p->next(); + for (HashtableEntry* p = bucket(i); p != NULL; ) { + HashtableEntry* next = p->next(); T string = p->literal(); // Use alternate hashing algorithm on the symbol in the first table unsigned int hashValue = new_hash(string); @@ -141,16 +128,16 @@ template void Hashtable::move_to(Hashtable* new_table) { // for the elements has been used in a new table and is not // destroyed. The memory reuse will benefit resizing the SystemDictionary // to avoid a memory allocation spike at safepoint. - free_buckets(); + BasicHashtable::free_buckets(); } -void BasicHashtable::free_buckets() { +template void BasicHashtable::free_buckets() { if (NULL != _buckets) { // Don't delete the buckets in the shared space. They aren't // allocated by os::malloc if (!UseSharedSpaces || !FileMapInfo::current_info()->is_in_shared_space(_buckets)) { - FREE_C_HEAP_ARRAY(HashtableBucket, _buckets); + FREE_C_HEAP_ARRAY(HashtableBucket, _buckets, F); } _buckets = NULL; } @@ -159,13 +146,13 @@ void BasicHashtable::free_buckets() { // Reverse the order of elements in the hash buckets. -void BasicHashtable::reverse() { +template void BasicHashtable::reverse() { for (int i = 0; i < _table_size; ++i) { - BasicHashtableEntry* new_list = NULL; - BasicHashtableEntry* p = bucket(i); + BasicHashtableEntry* new_list = NULL; + BasicHashtableEntry* p = bucket(i); while (p != NULL) { - BasicHashtableEntry* next = p->next(); + BasicHashtableEntry* next = p->next(); p->set_next(new_list); new_list = p; p = next; @@ -177,7 +164,7 @@ void BasicHashtable::reverse() { // Copy the table to the shared space. -void BasicHashtable::copy_table(char** top, char* end) { +template void BasicHashtable::copy_table(char** top, char* end) { // Dump the hash table entries. @@ -186,13 +173,13 @@ void BasicHashtable::copy_table(char** top, char* end) { int i; for (i = 0; i < _table_size; ++i) { - for (BasicHashtableEntry** p = _buckets[i].entry_addr(); + for (BasicHashtableEntry** p = _buckets[i].entry_addr(); *p != NULL; p = (*p)->next_addr()) { if (*top + entry_size() > end) { report_out_of_shared_space(SharedMiscData); } - *p = (BasicHashtableEntry*)memcpy(*top, *p, entry_size()); + *p = (BasicHashtableEntry*)memcpy(*top, *p, entry_size()); *top += entry_size(); } } @@ -201,7 +188,7 @@ void BasicHashtable::copy_table(char** top, char* end) { // Set the shared bit. for (i = 0; i < _table_size; ++i) { - for (BasicHashtableEntry* p = bucket(i); p != NULL; p = p->next()) { + for (BasicHashtableEntry* p = bucket(i); p != NULL; p = p->next()) { p->set_shared(); } } @@ -211,15 +198,15 @@ void BasicHashtable::copy_table(char** top, char* end) { // Reverse the order of elements in the hash buckets. -template void Hashtable::reverse(void* boundary) { +template void Hashtable::reverse(void* boundary) { - for (int i = 0; i < table_size(); ++i) { - HashtableEntry* high_list = NULL; - HashtableEntry* low_list = NULL; - HashtableEntry* last_low_entry = NULL; - HashtableEntry* p = bucket(i); + for (int i = 0; i < this->table_size(); ++i) { + HashtableEntry* high_list = NULL; + HashtableEntry* low_list = NULL; + HashtableEntry* last_low_entry = NULL; + HashtableEntry* p = bucket(i); while (p != NULL) { - HashtableEntry* next = p->next(); + HashtableEntry* next = p->next(); if ((void*)p->literal() >= boundary) { p->set_next(high_list); high_list = p; @@ -244,8 +231,8 @@ template void Hashtable::reverse(void* boundary) { // Dump the hash table buckets. -void BasicHashtable::copy_buckets(char** top, char* end) { - intptr_t len = _table_size * sizeof(HashtableBucket); +template void BasicHashtable::copy_buckets(char** top, char* end) { + intptr_t len = _table_size * sizeof(HashtableBucket); *(intptr_t*)(*top) = len; *top += sizeof(intptr_t); @@ -255,18 +242,18 @@ void BasicHashtable::copy_buckets(char** top, char* end) { if (*top + len > end) { report_out_of_shared_space(SharedMiscData); } - _buckets = (HashtableBucket*)memcpy(*top, _buckets, len); + _buckets = (HashtableBucket*)memcpy(*top, _buckets, len); *top += len; } #ifndef PRODUCT -template void Hashtable::print() { +template void Hashtable::print() { ResourceMark rm; - for (int i = 0; i < table_size(); i++) { - HashtableEntry* entry = bucket(i); + for (int i = 0; i < BasicHashtable::table_size(); i++) { + HashtableEntry* entry = bucket(i); while(entry != NULL) { tty->print("%d : ", i); entry->literal()->print(); @@ -277,10 +264,10 @@ template void Hashtable::print() { } -void BasicHashtable::verify() { +template void BasicHashtable::verify() { int count = 0; for (int i = 0; i < table_size(); i++) { - for (BasicHashtableEntry* p = bucket(i); p != NULL; p = p->next()) { + for (BasicHashtableEntry* p = bucket(i); p != NULL; p = p->next()) { ++count; } } @@ -293,7 +280,7 @@ void BasicHashtable::verify() { #ifdef ASSERT -void BasicHashtable::verify_lookup_length(double load) { +template void BasicHashtable::verify_lookup_length(double load) { if ((double)_lookup_length / (double)_lookup_count > load * 2.0) { warning("Performance bug: SystemDictionary lookup_count=%d " "lookup_length=%d average=%lf load=%f", @@ -303,10 +290,22 @@ void BasicHashtable::verify_lookup_length(double load) { } #endif - // Explicitly instantiate these types -template class Hashtable; -template class Hashtable; -template class Hashtable; -template class Hashtable; - +template class Hashtable; +template class Hashtable; +template class Hashtable; +template class Hashtable; +#ifdef SOLARIS +template class Hashtable; +#endif +template class Hashtable; +template class Hashtable; +template class HashtableEntry; +template class HashtableEntry; +template class HashtableEntry; +template class BasicHashtableEntry; +template class BasicHashtableEntry; +template class BasicHashtable; +template class BasicHashtable; +template class BasicHashtable; +template class BasicHashtable; diff --git a/hotspot/src/share/vm/utilities/hashtable.hpp b/hotspot/src/share/vm/utilities/hashtable.hpp index d31c0ff9484..bec5e70984d 100644 --- a/hotspot/src/share/vm/utilities/hashtable.hpp +++ b/hotspot/src/share/vm/utilities/hashtable.hpp @@ -40,7 +40,7 @@ -class BasicHashtableEntry : public CHeapObj { +template class BasicHashtableEntry : public CHeapObj { friend class VMStructs; private: unsigned int _hash; // 32-bit hash for item @@ -52,7 +52,7 @@ private: // shared entries will not change. New entries will always be // unshared and since pointers are align, bit 0 will always remain 0 // with no extra effort. - BasicHashtableEntry* _next; + BasicHashtableEntry* _next; // Windows IA64 compiler requires subclasses to be able to access these protected: @@ -69,19 +69,19 @@ public: void set_hash(unsigned int hash) { _hash = hash; } unsigned int* hash_addr() { return &_hash; } - static BasicHashtableEntry* make_ptr(BasicHashtableEntry* p) { + static BasicHashtableEntry* make_ptr(BasicHashtableEntry* p) { return (BasicHashtableEntry*)((intptr_t)p & -2); } - BasicHashtableEntry* next() const { + BasicHashtableEntry* next() const { return make_ptr(_next); } - void set_next(BasicHashtableEntry* next) { + void set_next(BasicHashtableEntry* next) { _next = next; } - BasicHashtableEntry** next_addr() { + BasicHashtableEntry** next_addr() { return &_next; } @@ -90,13 +90,13 @@ public: } void set_shared() { - _next = (BasicHashtableEntry*)((intptr_t)_next | 1); + _next = (BasicHashtableEntry*)((intptr_t)_next | 1); } }; -template class HashtableEntry : public BasicHashtableEntry { +template class HashtableEntry : public BasicHashtableEntry { friend class VMStructs; private: T _literal; // ref to item in table. @@ -108,20 +108,20 @@ public: void set_literal(T s) { _literal = s; } HashtableEntry* next() const { - return (HashtableEntry*)BasicHashtableEntry::next(); + return (HashtableEntry*)BasicHashtableEntry::next(); } HashtableEntry** next_addr() { - return (HashtableEntry**)BasicHashtableEntry::next_addr(); + return (HashtableEntry**)BasicHashtableEntry::next_addr(); } }; -class HashtableBucket : public CHeapObj { +template class HashtableBucket : public CHeapObj { friend class VMStructs; private: // Instance variable - BasicHashtableEntry* _entry; + BasicHashtableEntry* _entry; public: // Accessing @@ -129,21 +129,21 @@ public: // The following methods use order access methods to avoid race // conditions in multiprocessor systems. - BasicHashtableEntry* get_entry() const; - void set_entry(BasicHashtableEntry* l); + BasicHashtableEntry* get_entry() const; + void set_entry(BasicHashtableEntry* l); // The following method is not MT-safe and must be done under lock. - BasicHashtableEntry** entry_addr() { return &_entry; } + BasicHashtableEntry** entry_addr() { return &_entry; } }; -class BasicHashtable : public CHeapObj { +template class BasicHashtable : public CHeapObj { friend class VMStructs; public: BasicHashtable(int table_size, int entry_size); BasicHashtable(int table_size, int entry_size, - HashtableBucket* buckets, int number_of_entries); + HashtableBucket* buckets, int number_of_entries); // Sharing support. void copy_buckets(char** top, char* end); @@ -162,8 +162,8 @@ public: private: // Instance variables int _table_size; - HashtableBucket* _buckets; - BasicHashtableEntry* _free_list; + HashtableBucket* _buckets; + BasicHashtableEntry* _free_list; char* _first_free_entry; char* _end_block; int _entry_size; @@ -188,20 +188,20 @@ protected: int entry_size() const { return _entry_size; } // The following method is MT-safe and may be used with caution. - BasicHashtableEntry* bucket(int i); + BasicHashtableEntry* bucket(int i); // The following method is not MT-safe and must be done under lock. - BasicHashtableEntry** bucket_addr(int i) { return _buckets[i].entry_addr(); } + BasicHashtableEntry** bucket_addr(int i) { return _buckets[i].entry_addr(); } // Table entry management - BasicHashtableEntry* new_entry(unsigned int hashValue); + BasicHashtableEntry* new_entry(unsigned int hashValue); // Check that the table is unbalanced bool check_rehash_table(int count); // Used when moving the entry to another table // Clean up links, but do not add to free_list - void unlink_entry(BasicHashtableEntry* entry) { + void unlink_entry(BasicHashtableEntry* entry) { entry->set_next(NULL); --_number_of_entries; } @@ -221,11 +221,11 @@ protected: public: int table_size() { return _table_size; } - void set_entry(int index, BasicHashtableEntry* entry); + void set_entry(int index, BasicHashtableEntry* entry); - void add_entry(int index, BasicHashtableEntry* entry); + void add_entry(int index, BasicHashtableEntry* entry); - void free_entry(BasicHashtableEntry* entry); + void free_entry(BasicHashtableEntry* entry); int number_of_entries() { return _number_of_entries; } @@ -233,16 +233,16 @@ public: }; -template class Hashtable : public BasicHashtable { +template class Hashtable : public BasicHashtable { friend class VMStructs; public: Hashtable(int table_size, int entry_size) - : BasicHashtable(table_size, entry_size) { } + : BasicHashtable(table_size, entry_size) { } Hashtable(int table_size, int entry_size, - HashtableBucket* buckets, int number_of_entries) - : BasicHashtable(table_size, entry_size, buckets, number_of_entries) { } + HashtableBucket* buckets, int number_of_entries) + : BasicHashtable(table_size, entry_size, buckets, number_of_entries) { } // Debugging void print() PRODUCT_RETURN; @@ -264,35 +264,35 @@ protected: } // Table entry management - HashtableEntry* new_entry(unsigned int hashValue, T obj); + HashtableEntry* new_entry(unsigned int hashValue, T obj); // The following method is MT-safe and may be used with caution. - HashtableEntry* bucket(int i) { - return (HashtableEntry*)BasicHashtable::bucket(i); + HashtableEntry* bucket(int i) { + return (HashtableEntry*)BasicHashtable::bucket(i); } // The following method is not MT-safe and must be done under lock. - HashtableEntry** bucket_addr(int i) { - return (HashtableEntry**)BasicHashtable::bucket_addr(i); + HashtableEntry** bucket_addr(int i) { + return (HashtableEntry**)BasicHashtable::bucket_addr(i); } // Function to move these elements into the new table. - void move_to(Hashtable* new_table); + void move_to(Hashtable* new_table); virtual unsigned int new_hash(T) { ShouldNotReachHere(); return 0; } // should be overridden }; // Verions of hashtable where two handles are used to compute the index. -template class TwoOopHashtable : public Hashtable { +template class TwoOopHashtable : public Hashtable { friend class VMStructs; protected: TwoOopHashtable(int table_size, int entry_size) - : Hashtable(table_size, entry_size) {} + : Hashtable(table_size, entry_size) {} - TwoOopHashtable(int table_size, int entry_size, HashtableBucket* t, + TwoOopHashtable(int table_size, int entry_size, HashtableBucket* t, int number_of_entries) - : Hashtable(table_size, entry_size, t, number_of_entries) {} + : Hashtable(table_size, entry_size, t, number_of_entries) {} public: unsigned int compute_hash(Symbol* name, Handle loader) { diff --git a/hotspot/src/share/vm/utilities/hashtable.inline.hpp b/hotspot/src/share/vm/utilities/hashtable.inline.hpp index 68741427975..237fa5f41ee 100644 --- a/hotspot/src/share/vm/utilities/hashtable.inline.hpp +++ b/hotspot/src/share/vm/utilities/hashtable.inline.hpp @@ -27,6 +27,7 @@ #include "memory/allocation.inline.hpp" #include "utilities/hashtable.hpp" +#include "utilities/dtrace.hpp" // Inline function definitions for hashtable.hpp. @@ -34,18 +35,18 @@ // Initialize a table. -inline BasicHashtable::BasicHashtable(int table_size, int entry_size) { +template inline BasicHashtable::BasicHashtable(int table_size, int entry_size) { // Called on startup, no locking needed initialize(table_size, entry_size, 0); - _buckets = NEW_C_HEAP_ARRAY(HashtableBucket, table_size); + _buckets = NEW_C_HEAP_ARRAY2(HashtableBucket, table_size, F, CURRENT_PC); for (int index = 0; index < _table_size; index++) { _buckets[index].clear(); } } -inline BasicHashtable::BasicHashtable(int table_size, int entry_size, - HashtableBucket* buckets, +template inline BasicHashtable::BasicHashtable(int table_size, int entry_size, + HashtableBucket* buckets, int number_of_entries) { // Called on startup, no locking needed initialize(table_size, entry_size, number_of_entries); @@ -53,7 +54,7 @@ inline BasicHashtable::BasicHashtable(int table_size, int entry_size, } -inline void BasicHashtable::initialize(int table_size, int entry_size, +template inline void BasicHashtable::initialize(int table_size, int entry_size, int number_of_entries) { // Called on startup, no locking needed _table_size = table_size; @@ -70,12 +71,12 @@ inline void BasicHashtable::initialize(int table_size, int entry_size, // The following method is MT-safe and may be used with caution. -inline BasicHashtableEntry* BasicHashtable::bucket(int i) { +template inline BasicHashtableEntry* BasicHashtable::bucket(int i) { return _buckets[i].get_entry(); } -inline void HashtableBucket::set_entry(BasicHashtableEntry* l) { +template inline void HashtableBucket::set_entry(BasicHashtableEntry* l) { // Warning: Preserve store ordering. The SystemDictionary is read // without locks. The new SystemDictionaryEntry must be // complete before other threads can be allowed to see it @@ -84,27 +85,27 @@ inline void HashtableBucket::set_entry(BasicHashtableEntry* l) { } -inline BasicHashtableEntry* HashtableBucket::get_entry() const { +template inline BasicHashtableEntry* HashtableBucket::get_entry() const { // Warning: Preserve load ordering. The SystemDictionary is read // without locks. The new SystemDictionaryEntry must be // complete before other threads can be allowed to see it // via a store to _buckets[index]. - return (BasicHashtableEntry*) OrderAccess::load_ptr_acquire(&_entry); + return (BasicHashtableEntry*) OrderAccess::load_ptr_acquire(&_entry); } -inline void BasicHashtable::set_entry(int index, BasicHashtableEntry* entry) { +template inline void BasicHashtable::set_entry(int index, BasicHashtableEntry* entry) { _buckets[index].set_entry(entry); } -inline void BasicHashtable::add_entry(int index, BasicHashtableEntry* entry) { +template inline void BasicHashtable::add_entry(int index, BasicHashtableEntry* entry) { entry->set_next(bucket(index)); _buckets[index].set_entry(entry); ++_number_of_entries; } -inline void BasicHashtable::free_entry(BasicHashtableEntry* entry) { +template inline void BasicHashtable::free_entry(BasicHashtableEntry* entry) { entry->set_next(_free_list); _free_list = entry; --_number_of_entries; diff --git a/hotspot/src/share/vm/utilities/histogram.cpp b/hotspot/src/share/vm/utilities/histogram.cpp index ede6817cd40..114d4ac3f41 100644 --- a/hotspot/src/share/vm/utilities/histogram.cpp +++ b/hotspot/src/share/vm/utilities/histogram.cpp @@ -69,7 +69,7 @@ int Histogram::sort_helper(HistogramElement** e1, HistogramElement** e2) { Histogram::Histogram(const char* title,int estimatedCount) { _title = title; - _elements = new (ResourceObj::C_HEAP) GrowableArray(estimatedCount,true); + _elements = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(estimatedCount,true); } void Histogram::add_element(HistogramElement* element) { diff --git a/hotspot/src/share/vm/utilities/histogram.hpp b/hotspot/src/share/vm/utilities/histogram.hpp index 4eaa3d4e21a..5090aa059d4 100644 --- a/hotspot/src/share/vm/utilities/histogram.hpp +++ b/hotspot/src/share/vm/utilities/histogram.hpp @@ -77,7 +77,7 @@ #ifdef ASSERT -class HistogramElement : public CHeapObj { +class HistogramElement : public CHeapObj { protected: jint _count; const char* _name; @@ -91,7 +91,7 @@ class HistogramElement : public CHeapObj { virtual int compare(HistogramElement* e1,HistogramElement* e2); }; -class Histogram : public CHeapObj { +class Histogram : public CHeapObj { protected: GrowableArray* _elements; GrowableArray* elements() { return _elements; } diff --git a/hotspot/src/share/vm/utilities/intHisto.cpp b/hotspot/src/share/vm/utilities/intHisto.cpp index 8476c294d5c..a8508c93458 100644 --- a/hotspot/src/share/vm/utilities/intHisto.cpp +++ b/hotspot/src/share/vm/utilities/intHisto.cpp @@ -27,7 +27,7 @@ IntHistogram::IntHistogram(int est, int max) : _max(max), _tot(0) { assert(0 <= est && est <= max, "Preconditions"); - _elements = new (ResourceObj::C_HEAP) GrowableArray(est, true); + _elements = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(est, true); guarantee(_elements != NULL, "alloc failure"); } diff --git a/hotspot/src/share/vm/utilities/intHisto.hpp b/hotspot/src/share/vm/utilities/intHisto.hpp index 7c2f4ea2d0d..2d5d2834e4d 100644 --- a/hotspot/src/share/vm/utilities/intHisto.hpp +++ b/hotspot/src/share/vm/utilities/intHisto.hpp @@ -47,7 +47,7 @@ // relation) to a count. -class IntHistogram : public CHeapObj { +class IntHistogram : public CHeapObj { protected: int _max; int _tot; diff --git a/hotspot/src/share/vm/utilities/numberSeq.cpp b/hotspot/src/share/vm/utilities/numberSeq.cpp index a2ebc40f180..907c3a15c5e 100644 --- a/hotspot/src/share/vm/utilities/numberSeq.cpp +++ b/hotspot/src/share/vm/utilities/numberSeq.cpp @@ -133,13 +133,13 @@ void NumberSeq::add(double val) { TruncatedSeq::TruncatedSeq(int length, double alpha): AbsSeq(alpha), _length(length), _next(0) { - _sequence = NEW_C_HEAP_ARRAY(double, _length); + _sequence = NEW_C_HEAP_ARRAY(double, _length, mtInternal); for (int i = 0; i < _length; ++i) _sequence[i] = 0.0; } TruncatedSeq::~TruncatedSeq() { - FREE_C_HEAP_ARRAY(double, _sequence); + FREE_C_HEAP_ARRAY(double, _sequence, mtGC); } void TruncatedSeq::add(double val) { diff --git a/hotspot/src/share/vm/utilities/numberSeq.hpp b/hotspot/src/share/vm/utilities/numberSeq.hpp index 3f42a52dc72..f8f2bc1ff63 100644 --- a/hotspot/src/share/vm/utilities/numberSeq.hpp +++ b/hotspot/src/share/vm/utilities/numberSeq.hpp @@ -25,6 +25,8 @@ #ifndef SHARE_VM_UTILITIES_NUMBERSEQ_HPP #define SHARE_VM_UTILITIES_NUMBERSEQ_HPP +#include "memory/allocation.hpp" + /** ** This file contains a few classes that represent number sequence, ** x1, x2, x3, ..., xN, and can calculate their avg, max, and sd. @@ -40,7 +42,7 @@ #define DEFAULT_ALPHA_VALUE 0.7 -class AbsSeq { +class AbsSeq: public CHeapObj { private: void init(double alpha); diff --git a/hotspot/src/share/vm/utilities/ostream.cpp b/hotspot/src/share/vm/utilities/ostream.cpp index 2dc63d0445e..fc1f07eefd2 100644 --- a/hotspot/src/share/vm/utilities/ostream.cpp +++ b/hotspot/src/share/vm/utilities/ostream.cpp @@ -384,7 +384,7 @@ rotatingFileStream::~rotatingFileStream() { if (_file != NULL) { if (_need_close) fclose(_file); _file = NULL; - FREE_C_HEAP_ARRAY(char, _file_name); + FREE_C_HEAP_ARRAY(char, _file_name, mtInternal); _file_name = NULL; } } @@ -392,7 +392,7 @@ rotatingFileStream::~rotatingFileStream() { rotatingFileStream::rotatingFileStream(const char* file_name) { _cur_file_num = 0; _bytes_writen = 0L; - _file_name = NEW_C_HEAP_ARRAY(char, strlen(file_name)+10); + _file_name = NEW_C_HEAP_ARRAY(char, strlen(file_name)+10, mtInternal); jio_snprintf(_file_name, strlen(file_name)+10, "%s.%d", file_name, _cur_file_num); _file = fopen(_file_name, "w"); _need_close = true; @@ -401,7 +401,7 @@ rotatingFileStream::rotatingFileStream(const char* file_name) { rotatingFileStream::rotatingFileStream(const char* file_name, const char* opentype) { _cur_file_num = 0; _bytes_writen = 0L; - _file_name = NEW_C_HEAP_ARRAY(char, strlen(file_name)+10); + _file_name = NEW_C_HEAP_ARRAY(char, strlen(file_name)+10, mtInternal); jio_snprintf(_file_name, strlen(file_name)+10, "%s.%d", file_name, _cur_file_num); _file = fopen(_file_name, opentype); _need_close = true; @@ -524,7 +524,7 @@ static const char* make_log_name(const char* log_name, const char* force_directo } // Create big enough buffer. - char *buf = NEW_C_HEAP_ARRAY(char, buffer_length); + char *buf = NEW_C_HEAP_ARRAY(char, buffer_length, mtInternal); strcpy(buf, ""); if (force_directory != NULL) { @@ -549,7 +549,7 @@ void defaultStream::init_log() { // %%% Need a MutexLocker? const char* log_name = LogFile != NULL ? LogFile : "hotspot.log"; const char* try_name = make_log_name(log_name, NULL); - fileStream* file = new(ResourceObj::C_HEAP) fileStream(try_name); + fileStream* file = new(ResourceObj::C_HEAP, mtInternal) fileStream(try_name); if (!file->is_open()) { // Try again to open the file. char warnbuf[O_BUFLEN*2]; @@ -557,18 +557,18 @@ void defaultStream::init_log() { "Warning: Cannot open log file: %s\n", try_name); // Note: This feature is for maintainer use only. No need for L10N. jio_print(warnbuf); - FREE_C_HEAP_ARRAY(char, try_name); + FREE_C_HEAP_ARRAY(char, try_name, mtInternal); try_name = make_log_name("hs_pid%p.log", os::get_temp_directory()); jio_snprintf(warnbuf, sizeof(warnbuf), "Warning: Forcing option -XX:LogFile=%s\n", try_name); jio_print(warnbuf); delete file; - file = new(ResourceObj::C_HEAP) fileStream(try_name); - FREE_C_HEAP_ARRAY(char, try_name); + file = new(ResourceObj::C_HEAP, mtInternal) fileStream(try_name); + FREE_C_HEAP_ARRAY(char, try_name, mtInternal); } if (file->is_open()) { _log_file = file; - xmlStream* xs = new(ResourceObj::C_HEAP) xmlStream(file); + xmlStream* xs = new(ResourceObj::C_HEAP, mtInternal) xmlStream(file); _outer_xmlStream = xs; if (this == tty) xtty = xs; // Write XML header. @@ -815,7 +815,7 @@ void ttyLocker::break_tty_lock_for_safepoint(intx holder) { void ostream_init() { if (defaultStream::instance == NULL) { - defaultStream::instance = new(ResourceObj::C_HEAP) defaultStream(); + defaultStream::instance = new(ResourceObj::C_HEAP, mtInternal) defaultStream(); tty = defaultStream::instance; // We want to ensure that time stamps in GC logs consider time 0 @@ -833,9 +833,9 @@ void ostream_init_log() { gclog_or_tty = tty; // default to tty if (Arguments::gc_log_filename() != NULL) { fileStream * gclog = UseGCLogFileRotation ? - new(ResourceObj::C_HEAP) + new(ResourceObj::C_HEAP, mtInternal) rotatingFileStream(Arguments::gc_log_filename()) : - new(ResourceObj::C_HEAP) + new(ResourceObj::C_HEAP, mtInternal) fileStream(Arguments::gc_log_filename()); if (gclog->is_open()) { // now we update the time stamp of the GC log to be synced up @@ -940,7 +940,7 @@ void staticBufferStream::vprint_cr(const char* format, va_list argptr) { bufferedStream::bufferedStream(size_t initial_size, size_t bufmax) : outputStream() { buffer_length = initial_size; - buffer = NEW_C_HEAP_ARRAY(char, buffer_length); + buffer = NEW_C_HEAP_ARRAY(char, buffer_length, mtInternal); buffer_pos = 0; buffer_fixed = false; buffer_max = bufmax; @@ -971,7 +971,7 @@ void bufferedStream::write(const char* s, size_t len) { if (end < buffer_length * 2) { end = buffer_length * 2; } - buffer = REALLOC_C_HEAP_ARRAY(char, buffer, end); + buffer = REALLOC_C_HEAP_ARRAY(char, buffer, end, mtInternal); buffer_length = end; } } @@ -989,7 +989,7 @@ char* bufferedStream::as_string() { bufferedStream::~bufferedStream() { if (!buffer_fixed) { - FREE_C_HEAP_ARRAY(char, buffer); + FREE_C_HEAP_ARRAY(char, buffer, mtInternal); } } diff --git a/hotspot/src/share/vm/utilities/stack.hpp b/hotspot/src/share/vm/utilities/stack.hpp index eedaa7280d0..1cf85a51ac9 100644 --- a/hotspot/src/share/vm/utilities/stack.hpp +++ b/hotspot/src/share/vm/utilities/stack.hpp @@ -25,6 +25,7 @@ #ifndef SHARE_VM_UTILITIES_STACK_HPP #define SHARE_VM_UTILITIES_STACK_HPP +#include "memory/allocation.hpp" #include "memory/allocation.inline.hpp" // Class Stack (below) grows and shrinks by linking together "segments" which @@ -51,11 +52,11 @@ // implementation in class Stack assumes that alloc() will terminate the process // if the allocation fails. -template class StackIterator; +template class StackIterator; // StackBase holds common data/methods that don't depend on the element type, // factored out to reduce template code duplication. -class StackBase +template class StackBase { public: size_t segment_size() const { return _seg_size; } // Elements per segment. @@ -89,11 +90,11 @@ protected: #define inline #endif // __GNUC__ -template -class Stack: public StackBase +template +class Stack: public StackBase { public: - friend class StackIterator; + friend class StackIterator; // segment_size: number of items per segment // max_cache_size: maxmium number of *segments* to cache @@ -103,15 +104,15 @@ public: size_t max_cache_size = 4, size_t max_size = 0); inline ~Stack() { clear(true); } - inline bool is_empty() const { return _cur_seg == NULL; } - inline bool is_full() const { return _full_seg_size >= max_size(); } + inline bool is_empty() const { return this->_cur_seg == NULL; } + inline bool is_full() const { return this->_full_seg_size >= this->max_size(); } // Performance sensitive code should use is_empty() instead of size() == 0 and // is_full() instead of size() == max_size(). Using a conditional here allows // just one var to be updated when pushing/popping elements instead of two; // _full_seg_size is updated only when pushing/popping segments. inline size_t size() const { - return is_empty() ? 0 : _full_seg_size + _cur_seg_size; + return is_empty() ? 0 : this->_full_seg_size + this->_cur_seg_size; } inline void push(E elem); @@ -161,18 +162,18 @@ private: E* _cache; // Segment cache to avoid ping-ponging. }; -template class ResourceStack: public Stack, public ResourceObj +template class ResourceStack: public Stack, public ResourceObj { public: // If this class becomes widely used, it may make sense to save the Thread // and use it when allocating segments. - ResourceStack(size_t segment_size = Stack::default_segment_size()): - Stack(segment_size, max_uintx) +// ResourceStack(size_t segment_size = Stack::default_segment_size()): + ResourceStack(size_t segment_size): Stack(segment_size, max_uintx) { } // Set the segment pointers to NULL so the parent dtor does not free them; // that must be done by the ResourceMark code. - ~ResourceStack() { Stack::reset(true); } + ~ResourceStack() { Stack::reset(true); } protected: virtual E* alloc(size_t bytes); @@ -182,13 +183,13 @@ private: void clear(bool clear_cache = false); }; -template +template class StackIterator: public StackObj { public: - StackIterator(Stack& stack): _stack(stack) { sync(); } + StackIterator(Stack& stack): _stack(stack) { sync(); } - Stack& stack() const { return _stack; } + Stack& stack() const { return _stack; } bool is_empty() const { return _cur_seg == NULL; } @@ -198,7 +199,7 @@ public: void sync(); // Sync the iterator's state to the stack's current state. private: - Stack& _stack; + Stack& _stack; size_t _cur_seg_size; E* _cur_seg; size_t _full_seg_size; diff --git a/hotspot/src/share/vm/utilities/stack.inline.hpp b/hotspot/src/share/vm/utilities/stack.inline.hpp index bb97fc9a274..f53fd3c2c02 100644 --- a/hotspot/src/share/vm/utilities/stack.inline.hpp +++ b/hotspot/src/share/vm/utilities/stack.inline.hpp @@ -27,7 +27,7 @@ #include "utilities/stack.hpp" -StackBase::StackBase(size_t segment_size, size_t max_cache_size, +template StackBase::StackBase(size_t segment_size, size_t max_cache_size, size_t max_size): _seg_size(segment_size), _max_cache_size(max_cache_size), @@ -36,7 +36,7 @@ StackBase::StackBase(size_t segment_size, size_t max_cache_size, assert(_max_size % _seg_size == 0, "not a multiple"); } -size_t StackBase::adjust_max_size(size_t max_size, size_t seg_size) +template size_t StackBase::adjust_max_size(size_t max_size, size_t seg_size) { assert(seg_size > 0, "cannot be 0"); assert(max_size >= seg_size || max_size == 0, "max_size too small"); @@ -47,54 +47,54 @@ size_t StackBase::adjust_max_size(size_t max_size, size_t seg_size) return (max_size + seg_size - 1) / seg_size * seg_size; } -template -Stack::Stack(size_t segment_size, size_t max_cache_size, size_t max_size): - StackBase(adjust_segment_size(segment_size), max_cache_size, max_size) +template +Stack::Stack(size_t segment_size, size_t max_cache_size, size_t max_size): + StackBase(adjust_segment_size(segment_size), max_cache_size, max_size) { reset(true); } -template -void Stack::push(E item) +template +void Stack::push(E item) { assert(!is_full(), "pushing onto a full stack"); - if (_cur_seg_size == _seg_size) { + if (this->_cur_seg_size == this->_seg_size) { push_segment(); } - _cur_seg[_cur_seg_size] = item; - ++_cur_seg_size; + this->_cur_seg[this->_cur_seg_size] = item; + ++this->_cur_seg_size; } -template -E Stack::pop() +template +E Stack::pop() { assert(!is_empty(), "popping from an empty stack"); - if (_cur_seg_size == 1) { - E tmp = _cur_seg[--_cur_seg_size]; + if (this->_cur_seg_size == 1) { + E tmp = _cur_seg[--this->_cur_seg_size]; pop_segment(); return tmp; } - return _cur_seg[--_cur_seg_size]; + return this->_cur_seg[--this->_cur_seg_size]; } -template -void Stack::clear(bool clear_cache) +template +void Stack::clear(bool clear_cache) { free_segments(_cur_seg); if (clear_cache) free_segments(_cache); reset(clear_cache); } -template -size_t Stack::default_segment_size() +template +size_t Stack::default_segment_size() { // Number of elements that fit in 4K bytes minus the size of two pointers // (link field and malloc header). return (4096 - 2 * sizeof(E*)) / sizeof(E); } -template -size_t Stack::adjust_segment_size(size_t seg_size) +template +size_t Stack::adjust_segment_size(size_t seg_size) { const size_t elem_sz = sizeof(E); const size_t ptr_sz = sizeof(E*); @@ -105,93 +105,93 @@ size_t Stack::adjust_segment_size(size_t seg_size) return seg_size; } -template -size_t Stack::link_offset() const +template +size_t Stack::link_offset() const { - return align_size_up(_seg_size * sizeof(E), sizeof(E*)); + return align_size_up(this->_seg_size * sizeof(E), sizeof(E*)); } -template -size_t Stack::segment_bytes() const +template +size_t Stack::segment_bytes() const { return link_offset() + sizeof(E*); } -template -E** Stack::link_addr(E* seg) const +template +E** Stack::link_addr(E* seg) const { return (E**) ((char*)seg + link_offset()); } -template -E* Stack::get_link(E* seg) const +template +E* Stack::get_link(E* seg) const { return *link_addr(seg); } -template -E* Stack::set_link(E* new_seg, E* old_seg) +template +E* Stack::set_link(E* new_seg, E* old_seg) { *link_addr(new_seg) = old_seg; return new_seg; } -template -E* Stack::alloc(size_t bytes) +template +E* Stack::alloc(size_t bytes) { - return (E*) NEW_C_HEAP_ARRAY(char, bytes); + return (E*) NEW_C_HEAP_ARRAY(char, bytes, F); } -template -void Stack::free(E* addr, size_t bytes) +template +void Stack::free(E* addr, size_t bytes) { - FREE_C_HEAP_ARRAY(char, (char*) addr); + FREE_C_HEAP_ARRAY(char, (char*) addr, F); } -template -void Stack::push_segment() +template +void Stack::push_segment() { - assert(_cur_seg_size == _seg_size, "current segment is not full"); + assert(this->_cur_seg_size == this->_seg_size, "current segment is not full"); E* next; - if (_cache_size > 0) { + if (this->_cache_size > 0) { // Use a cached segment. next = _cache; _cache = get_link(_cache); - --_cache_size; + --this->_cache_size; } else { next = alloc(segment_bytes()); DEBUG_ONLY(zap_segment(next, true);) } const bool at_empty_transition = is_empty(); - _cur_seg = set_link(next, _cur_seg); - _cur_seg_size = 0; - _full_seg_size += at_empty_transition ? 0 : _seg_size; + this->_cur_seg = set_link(next, _cur_seg); + this->_cur_seg_size = 0; + this->_full_seg_size += at_empty_transition ? 0 : this->_seg_size; DEBUG_ONLY(verify(at_empty_transition);) } -template -void Stack::pop_segment() +template +void Stack::pop_segment() { - assert(_cur_seg_size == 0, "current segment is not empty"); + assert(this->_cur_seg_size == 0, "current segment is not empty"); E* const prev = get_link(_cur_seg); - if (_cache_size < _max_cache_size) { + if (this->_cache_size < this->_max_cache_size) { // Add the current segment to the cache. DEBUG_ONLY(zap_segment(_cur_seg, false);) _cache = set_link(_cur_seg, _cache); - ++_cache_size; + ++this->_cache_size; } else { DEBUG_ONLY(zap_segment(_cur_seg, true);) free(_cur_seg, segment_bytes()); } const bool at_empty_transition = prev == NULL; - _cur_seg = prev; - _cur_seg_size = _seg_size; - _full_seg_size -= at_empty_transition ? 0 : _seg_size; + this->_cur_seg = prev; + this->_cur_seg_size = this->_seg_size; + this->_full_seg_size -= at_empty_transition ? 0 : this->_seg_size; DEBUG_ONLY(verify(at_empty_transition);) } -template -void Stack::free_segments(E* seg) +template +void Stack::free_segments(E* seg) { const size_t bytes = segment_bytes(); while (seg != NULL) { @@ -201,37 +201,37 @@ void Stack::free_segments(E* seg) } } -template -void Stack::reset(bool reset_cache) +template +void Stack::reset(bool reset_cache) { - _cur_seg_size = _seg_size; // So push() will alloc a new segment. - _full_seg_size = 0; + this->_cur_seg_size = this->_seg_size; // So push() will alloc a new segment. + this->_full_seg_size = 0; _cur_seg = NULL; if (reset_cache) { - _cache_size = 0; + this->_cache_size = 0; _cache = NULL; } } #ifdef ASSERT -template -void Stack::verify(bool at_empty_transition) const +template +void Stack::verify(bool at_empty_transition) const { - assert(size() <= max_size(), "stack exceeded bounds"); - assert(cache_size() <= max_cache_size(), "cache exceeded bounds"); - assert(_cur_seg_size <= segment_size(), "segment index exceeded bounds"); + assert(size() <= this->max_size(), "stack exceeded bounds"); + assert(this->cache_size() <= this->max_cache_size(), "cache exceeded bounds"); + assert(this->_cur_seg_size <= this->segment_size(), "segment index exceeded bounds"); - assert(_full_seg_size % _seg_size == 0, "not a multiple"); + assert(this->_full_seg_size % this->_seg_size == 0, "not a multiple"); assert(at_empty_transition || is_empty() == (size() == 0), "mismatch"); - assert((_cache == NULL) == (cache_size() == 0), "mismatch"); + assert((_cache == NULL) == (this->cache_size() == 0), "mismatch"); if (is_empty()) { - assert(_cur_seg_size == segment_size(), "sanity"); + assert(this->_cur_seg_size == this->segment_size(), "sanity"); } } -template -void Stack::zap_segment(E* seg, bool zap_link_field) const +template +void Stack::zap_segment(E* seg, bool zap_link_field) const { if (!ZapStackSegments) return; const size_t zap_bytes = segment_bytes() - (zap_link_field ? 0 : sizeof(E*)); @@ -243,28 +243,28 @@ void Stack::zap_segment(E* seg, bool zap_link_field) const } #endif -template -E* ResourceStack::alloc(size_t bytes) +template +E* ResourceStack::alloc(size_t bytes) { return (E*) resource_allocate_bytes(bytes); } -template -void ResourceStack::free(E* addr, size_t bytes) +template +void ResourceStack::free(E* addr, size_t bytes) { resource_free_bytes((char*) addr, bytes); } -template -void StackIterator::sync() +template +void StackIterator::sync() { _full_seg_size = _stack._full_seg_size; _cur_seg_size = _stack._cur_seg_size; _cur_seg = _stack._cur_seg; } -template -E* StackIterator::next_addr() +template +E* StackIterator::next_addr() { assert(!is_empty(), "no items left"); if (_cur_seg_size == 1) { diff --git a/hotspot/src/share/vm/utilities/taskqueue.hpp b/hotspot/src/share/vm/utilities/taskqueue.hpp index 545c6dbb5e0..9d67af456ff 100644 --- a/hotspot/src/share/vm/utilities/taskqueue.hpp +++ b/hotspot/src/share/vm/utilities/taskqueue.hpp @@ -132,8 +132,8 @@ void TaskQueueStats::reset() { } #endif // TASKQUEUE_STATS -template -class TaskQueueSuper: public CHeapObj { +template +class TaskQueueSuper: public CHeapObj { protected: // Internal type for indexing the queue; also used for the tag. typedef NOT_LP64(uint16_t) LP64_ONLY(uint32_t) idx_t; @@ -249,22 +249,27 @@ public: TASKQUEUE_STATS_ONLY(TaskQueueStats stats;) }; -template -class GenericTaskQueue: public TaskQueueSuper { -protected: - typedef typename TaskQueueSuper::Age Age; - typedef typename TaskQueueSuper::idx_t idx_t; - using TaskQueueSuper::_bottom; - using TaskQueueSuper::_age; - using TaskQueueSuper::increment_index; - using TaskQueueSuper::decrement_index; - using TaskQueueSuper::dirty_size; + +template +class GenericTaskQueue: public TaskQueueSuper { +protected: + typedef typename TaskQueueSuper::Age Age; + typedef typename TaskQueueSuper::idx_t idx_t; + + using TaskQueueSuper::_bottom; + using TaskQueueSuper::_age; + using TaskQueueSuper::increment_index; + using TaskQueueSuper::decrement_index; + using TaskQueueSuper::dirty_size; public: - using TaskQueueSuper::max_elems; - using TaskQueueSuper::size; - TASKQUEUE_STATS_ONLY(using TaskQueueSuper::stats;) + using TaskQueueSuper::max_elems; + using TaskQueueSuper::size; + +#if TASKQUEUE_STATS + using TaskQueueSuper::stats; +#endif private: // Slow paths for push, pop_local. (pop_global has no fast path.) @@ -302,18 +307,18 @@ private: volatile E* _elems; }; -template -GenericTaskQueue::GenericTaskQueue() { +template +GenericTaskQueue::GenericTaskQueue() { assert(sizeof(Age) == sizeof(size_t), "Depends on this."); } -template -void GenericTaskQueue::initialize() { - _elems = NEW_C_HEAP_ARRAY(E, N); +template +void GenericTaskQueue::initialize() { + _elems = NEW_C_HEAP_ARRAY(E, N, F); } -template -void GenericTaskQueue::oops_do(OopClosure* f) { +template +void GenericTaskQueue::oops_do(OopClosure* f) { // tty->print_cr("START OopTaskQueue::oops_do"); uint iters = size(); uint index = _bottom; @@ -329,8 +334,8 @@ void GenericTaskQueue::oops_do(OopClosure* f) { // tty->print_cr("END OopTaskQueue::oops_do"); } -template -bool GenericTaskQueue::push_slow(E t, uint dirty_n_elems) { +template +bool GenericTaskQueue::push_slow(E t, uint dirty_n_elems) { if (dirty_n_elems == N - 1) { // Actually means 0, so do the push. uint localBot = _bottom; @@ -349,8 +354,8 @@ bool GenericTaskQueue::push_slow(E t, uint dirty_n_elems) { // whenever the queue goes empty which it will do here if this thread // gets the last task or in pop_global() if the queue wraps (top == 0 // and pop_global() succeeds, see pop_global()). -template -bool GenericTaskQueue::pop_local_slow(uint localBot, Age oldAge) { +template +bool GenericTaskQueue::pop_local_slow(uint localBot, Age oldAge) { // This queue was observed to contain exactly one element; either this // thread will claim it, or a competing "pop_global". In either case, // the queue will be logically empty afterwards. Create a new Age value @@ -382,8 +387,8 @@ bool GenericTaskQueue::pop_local_slow(uint localBot, Age oldAge) { return false; } -template -bool GenericTaskQueue::pop_global(E& t) { +template +bool GenericTaskQueue::pop_global(E& t) { Age oldAge = _age.get(); uint localBot = _bottom; uint n_elems = size(localBot, oldAge.top()); @@ -402,9 +407,9 @@ bool GenericTaskQueue::pop_global(E& t) { return resAge == oldAge; } -template -GenericTaskQueue::~GenericTaskQueue() { - FREE_C_HEAP_ARRAY(E, _elems); +template +GenericTaskQueue::~GenericTaskQueue() { + FREE_C_HEAP_ARRAY(E, _elems, F); } // OverflowTaskQueue is a TaskQueue that also includes an overflow stack for @@ -418,12 +423,12 @@ GenericTaskQueue::~GenericTaskQueue() { // Note that size() is not hidden--it returns the number of elements in the // TaskQueue, and does not include the size of the overflow stack. This // simplifies replacement of GenericTaskQueues with OverflowTaskQueues. -template -class OverflowTaskQueue: public GenericTaskQueue +template +class OverflowTaskQueue: public GenericTaskQueue { public: - typedef Stack overflow_t; - typedef GenericTaskQueue taskqueue_t; + typedef Stack overflow_t; + typedef GenericTaskQueue taskqueue_t; TASKQUEUE_STATS_ONLY(using taskqueue_t::stats;) @@ -445,8 +450,8 @@ private: overflow_t _overflow_stack; }; -template -bool OverflowTaskQueue::push(E t) +template +bool OverflowTaskQueue::push(E t) { if (!taskqueue_t::push(t)) { overflow_stack()->push(t); @@ -455,15 +460,15 @@ bool OverflowTaskQueue::push(E t) return true; } -template -bool OverflowTaskQueue::pop_overflow(E& t) +template +bool OverflowTaskQueue::pop_overflow(E& t) { if (overflow_empty()) return false; t = overflow_stack()->pop(); return true; } -class TaskQueueSetSuper: public CHeapObj { +class TaskQueueSetSuper { protected: static int randomParkAndMiller(int* seed0); public: @@ -471,8 +476,11 @@ public: virtual bool peek() = 0; }; -template -class GenericTaskQueueSet: public TaskQueueSetSuper { +template class TaskQueueSetSuperImpl: public CHeapObj, public TaskQueueSetSuper { +}; + +template +class GenericTaskQueueSet: public TaskQueueSetSuperImpl { private: uint _n; T** _queues; @@ -482,7 +490,7 @@ public: GenericTaskQueueSet(int n) : _n(n) { typedef T* GenericTaskQueuePtr; - _queues = NEW_C_HEAP_ARRAY(GenericTaskQueuePtr, n); + _queues = NEW_C_HEAP_ARRAY(GenericTaskQueuePtr, n, F); for (int i = 0; i < n; i++) { _queues[i] = NULL; } @@ -506,19 +514,19 @@ public: bool peek(); }; -template void -GenericTaskQueueSet::register_queue(uint i, T* q) { +template void +GenericTaskQueueSet::register_queue(uint i, T* q) { assert(i < _n, "index out of range."); _queues[i] = q; } -template T* -GenericTaskQueueSet::queue(uint i) { +template T* +GenericTaskQueueSet::queue(uint i) { return _queues[i]; } -template bool -GenericTaskQueueSet::steal(uint queue_num, int* seed, E& t) { +template bool +GenericTaskQueueSet::steal(uint queue_num, int* seed, E& t) { for (uint i = 0; i < 2 * _n; i++) { if (steal_best_of_2(queue_num, seed, t)) { TASKQUEUE_STATS_ONLY(queue(queue_num)->stats.record_steal(true)); @@ -529,8 +537,8 @@ GenericTaskQueueSet::steal(uint queue_num, int* seed, E& t) { return false; } -template bool -GenericTaskQueueSet::steal_best_of_all(uint queue_num, int* seed, E& t) { +template bool +GenericTaskQueueSet::steal_best_of_all(uint queue_num, int* seed, E& t) { if (_n > 2) { int best_k; uint best_sz = 0; @@ -553,11 +561,11 @@ GenericTaskQueueSet::steal_best_of_all(uint queue_num, int* seed, E& t) { } } -template bool -GenericTaskQueueSet::steal_1_random(uint queue_num, int* seed, E& t) { +template bool +GenericTaskQueueSet::steal_1_random(uint queue_num, int* seed, E& t) { if (_n > 2) { uint k = queue_num; - while (k == queue_num) k = randomParkAndMiller(seed) % _n; + while (k == queue_num) k = TaskQueueSetSuper::randomParkAndMiller(seed) % _n; return _queues[2]->pop_global(t); } else if (_n == 2) { // Just try the other one. @@ -569,13 +577,13 @@ GenericTaskQueueSet::steal_1_random(uint queue_num, int* seed, E& t) { } } -template bool -GenericTaskQueueSet::steal_best_of_2(uint queue_num, int* seed, E& t) { +template bool +GenericTaskQueueSet::steal_best_of_2(uint queue_num, int* seed, E& t) { if (_n > 2) { uint k1 = queue_num; - while (k1 == queue_num) k1 = randomParkAndMiller(seed) % _n; + while (k1 == queue_num) k1 = TaskQueueSetSuper::randomParkAndMiller(seed) % _n; uint k2 = queue_num; - while (k2 == queue_num || k2 == k1) k2 = randomParkAndMiller(seed) % _n; + while (k2 == queue_num || k2 == k1) k2 = TaskQueueSetSuper::randomParkAndMiller(seed) % _n; // Sample both and try the larger. uint sz1 = _queues[k1]->size(); uint sz2 = _queues[k2]->size(); @@ -591,8 +599,8 @@ GenericTaskQueueSet::steal_best_of_2(uint queue_num, int* seed, E& t) { } } -template -bool GenericTaskQueueSet::peek() { +template +bool GenericTaskQueueSet::peek() { // Try all the queues. for (uint j = 0; j < _n; j++) { if (_queues[j]->peek()) @@ -602,7 +610,7 @@ bool GenericTaskQueueSet::peek() { } // When to terminate from the termination protocol. -class TerminatorTerminator: public CHeapObj { +class TerminatorTerminator: public CHeapObj { public: virtual bool should_exit_termination() = 0; }; @@ -665,8 +673,8 @@ public: #endif }; -template inline bool -GenericTaskQueue::push(E t) { +template inline bool +GenericTaskQueue::push(E t) { uint localBot = _bottom; assert((localBot >= 0) && (localBot < N), "_bottom out of range."); idx_t top = _age.top(); @@ -683,8 +691,8 @@ GenericTaskQueue::push(E t) { } } -template inline bool -GenericTaskQueue::pop_local(E& t) { +template inline bool +GenericTaskQueue::pop_local(E& t) { uint localBot = _bottom; // This value cannot be N-1. That can only occur as a result of // the assignment to bottom in this method. If it does, this method @@ -715,8 +723,8 @@ GenericTaskQueue::pop_local(E& t) { } } -typedef GenericTaskQueue OopTaskQueue; -typedef GenericTaskQueueSet OopTaskQueueSet; +typedef GenericTaskQueue OopTaskQueue; +typedef GenericTaskQueueSet OopTaskQueueSet; #ifdef _MSC_VER #pragma warning(push) @@ -796,11 +804,11 @@ private: #pragma warning(pop) #endif -typedef OverflowTaskQueue OopStarTaskQueue; -typedef GenericTaskQueueSet OopStarTaskQueueSet; +typedef OverflowTaskQueue OopStarTaskQueue; +typedef GenericTaskQueueSet OopStarTaskQueueSet; -typedef OverflowTaskQueue RegionTaskQueue; -typedef GenericTaskQueueSet RegionTaskQueueSet; +typedef OverflowTaskQueue RegionTaskQueue; +typedef GenericTaskQueueSet RegionTaskQueueSet; #endif // SHARE_VM_UTILITIES_TASKQUEUE_HPP diff --git a/hotspot/src/share/vm/utilities/vmError.cpp b/hotspot/src/share/vm/utilities/vmError.cpp index e450676fa7a..2c4b5d36bd1 100644 --- a/hotspot/src/share/vm/utilities/vmError.cpp +++ b/hotspot/src/share/vm/utilities/vmError.cpp @@ -33,6 +33,7 @@ #include "runtime/thread.hpp" #include "runtime/vmThread.hpp" #include "runtime/vm_operations.hpp" +#include "services/memTracker.hpp" #include "utilities/debug.hpp" #include "utilities/decoder.hpp" #include "utilities/defaultStream.hpp" @@ -818,6 +819,9 @@ void VMError::report_and_die() { static bool transmit_report_done = false; // done error reporting static fdStream log; // error log + // disble NMT to avoid further exception + MemTracker::shutdown(MemTracker::NMT_error_reporting); + if (SuppressFatalErrorMessage) { os::abort(); } diff --git a/hotspot/src/share/vm/utilities/workgroup.cpp b/hotspot/src/share/vm/utilities/workgroup.cpp index 0ef1f833d04..4952058b484 100644 --- a/hotspot/src/share/vm/utilities/workgroup.cpp +++ b/hotspot/src/share/vm/utilities/workgroup.cpp @@ -77,7 +77,7 @@ bool WorkGang::initialize_workers() { name(), total_workers()); } - _gang_workers = NEW_C_HEAP_ARRAY(GangWorker*, total_workers()); + _gang_workers = NEW_C_HEAP_ARRAY(GangWorker*, total_workers(), mtInternal); if (gang_workers() == NULL) { vm_exit_out_of_memory(0, "Cannot create GangWorker array."); return false; @@ -241,6 +241,7 @@ void GangWorker::run() { void GangWorker::initialize() { this->initialize_thread_local_storage(); + this->record_stack_base_and_size(); assert(_gang != NULL, "No gang to run in"); os::set_priority(this, NearMaxPriority); if (TraceWorkGang) { @@ -421,7 +422,7 @@ void WorkGangBarrierSync::enter() { SubTasksDone::SubTasksDone(uint n) : _n_tasks(n), _n_threads(1), _tasks(NULL) { - _tasks = NEW_C_HEAP_ARRAY(uint, n); + _tasks = NEW_C_HEAP_ARRAY(uint, n, mtInternal); guarantee(_tasks != NULL, "alloc failure"); clear(); } @@ -476,7 +477,7 @@ void SubTasksDone::all_tasks_completed() { SubTasksDone::~SubTasksDone() { - if (_tasks != NULL) FREE_C_HEAP_ARRAY(jint, _tasks); + if (_tasks != NULL) FREE_C_HEAP_ARRAY(jint, _tasks, mtInternal); } // *** SequentialSubTasksDone diff --git a/hotspot/src/share/vm/utilities/workgroup.hpp b/hotspot/src/share/vm/utilities/workgroup.hpp index 7fc0ddf5674..9bd34e6bc82 100644 --- a/hotspot/src/share/vm/utilities/workgroup.hpp +++ b/hotspot/src/share/vm/utilities/workgroup.hpp @@ -123,7 +123,7 @@ class AbstractGangTaskWOopQueues : public AbstractGangTask { // Class AbstractWorkGang: // An abstract class representing a gang of workers. // You subclass this to supply an implementation of run_task(). -class AbstractWorkGang: public CHeapObj { +class AbstractWorkGang: public CHeapObj { // Here's the public interface to this class. public: // Constructor and destructor. @@ -402,7 +402,7 @@ public: // subtasks will be identified by integer indices, usually elements of an // enumeration type. -class SubTasksDone : public CHeapObj { +class SubTasksDone: public CHeapObj { uint* _tasks; uint _n_tasks; // _n_threads is used to determine when a sub task is done. diff --git a/hotspot/src/share/vm/utilities/xmlstream.cpp b/hotspot/src/share/vm/utilities/xmlstream.cpp index 8646c309bfb..2753b850cbb 100644 --- a/hotspot/src/share/vm/utilities/xmlstream.cpp +++ b/hotspot/src/share/vm/utilities/xmlstream.cpp @@ -43,7 +43,7 @@ void xmlStream::initialize(outputStream* out) { #ifdef ASSERT _element_depth = 0; int init_len = 100; - char* init_buf = NEW_C_HEAP_ARRAY(char, init_len); + char* init_buf = NEW_C_HEAP_ARRAY(char, init_len, mtInternal); _element_close_stack_low = init_buf; _element_close_stack_high = init_buf + init_len; _element_close_stack_ptr = init_buf + init_len - 1; @@ -58,7 +58,7 @@ void xmlStream::initialize(outputStream* out) { #ifdef ASSERT xmlStream::~xmlStream() { - FREE_C_HEAP_ARRAY(char, _element_close_stack_low); + FREE_C_HEAP_ARRAY(char, _element_close_stack_low, mtInternal); } #endif @@ -155,14 +155,14 @@ void xmlStream::see_tag(const char* tag, bool push) { int old_len = _element_close_stack_high - old_ptr; int new_len = old_len * 2; if (new_len < 100) new_len = 100; - char* new_low = NEW_C_HEAP_ARRAY(char, new_len); + char* new_low = NEW_C_HEAP_ARRAY(char, new_len, mtInternal); char* new_high = new_low + new_len; char* new_ptr = new_high - old_len; memcpy(new_ptr, old_ptr, old_len); _element_close_stack_high = new_high; _element_close_stack_low = new_low; _element_close_stack_ptr = new_ptr; - FREE_C_HEAP_ARRAY(char, old_low); + FREE_C_HEAP_ARRAY(char, old_low, mtInternal); push_ptr = new_ptr - (tag_len+1); } assert(push_ptr >= _element_close_stack_low, "in range"); From 4c0c58e59dd164388f575f1cea1e8dee59b30f19 Mon Sep 17 00:00:00 2001 From: Erik Joelsson Date: Thu, 28 Jun 2012 14:59:20 -0700 Subject: [PATCH 042/160] 7180594: Fix GenStubs in langtools for build-infra builds Reviewed-by: ohair --- langtools/make/tools/genstubs/GenStubs.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/langtools/make/tools/genstubs/GenStubs.java b/langtools/make/tools/genstubs/GenStubs.java index f43df55365f..95ffa021b39 100644 --- a/langtools/make/tools/genstubs/GenStubs.java +++ b/langtools/make/tools/genstubs/GenStubs.java @@ -201,7 +201,7 @@ public class GenStubs { */ public void visitTopLevel(JCCompilationUnit tree) { super.visitTopLevel(tree); - tree.docComments = Collections.emptyMap(); + tree.docComments = null; } /** From 9f400835dfd40ababae4ff688b52ca4eb012b409 Mon Sep 17 00:00:00 2001 From: Coleen Phillimore Date: Fri, 29 Jun 2012 14:28:10 -0700 Subject: [PATCH 043/160] 7179759: ENV: Nightly fails during jdk copiyng for solaris platforms after FDS unzipping Libjvm_g_db.so and libjvm_g_dtrace.so links in .diz file still had 64 directory Reviewed-by: kamg, dholmes, sspitsyn --- hotspot/make/solaris/makefiles/dtrace.make | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/hotspot/make/solaris/makefiles/dtrace.make b/hotspot/make/solaris/makefiles/dtrace.make index 1a5726520f9..48bc98d2dc6 100644 --- a/hotspot/make/solaris/makefiles/dtrace.make +++ b/hotspot/make/solaris/makefiles/dtrace.make @@ -137,13 +137,13 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) # implied else here is no stripping at all endif endif - [ -f $(XLIBJVM_DB_G_DEBUGINFO) ] || { ln -s $(XLIBJVM_DB_DEBUGINFO) $(XLIBJVM_DB_G_DEBUGINFO); } + [ -f $(XLIBJVM_DB_G_DEBUGINFO) ] || { cd $(XLIBJVM_DIR) && ln -s $(LIBJVM_DB_DEBUGINFO) $(LIBJVM_DB_G_DEBUGINFO); } ifeq ($(ZIP_DEBUGINFO_FILES),1) # Do this part in the $(XLIBJVM_DIR) subdir so $(XLIBJVM_DIR) is not # in the archived name: ( cd $(XLIBJVM_DIR) && $(ZIPEXE) -q -y $(LIBJVM_DB_DIZ) $(LIBJVM_DB_DEBUGINFO) $(LIBJVM_DB_G_DEBUGINFO) ) $(RM) $(XLIBJVM_DB_DEBUGINFO) $(XLIBJVM_DB_G_DEBUGINFO) - [ -f $(XLIBJVM_DB_G_DIZ) ] || { ln -s $(XLIBJVM_DB_DIZ) $(XLIBJVM_DB_G_DIZ); } + [ -f $(XLIBJVM_DB_G_DIZ) ] || { cd $(XLIBJVM_DIR) && ln -s $(LIBJVM_DB_DIZ) $(LIBJVM_DB_G_DIZ); } endif endif @@ -170,13 +170,13 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) # implied else here is no stripping at all endif endif - [ -f $(XLIBJVM_DTRACE_G_DEBUGINFO) ] || { ln -s $(XLIBJVM_DTRACE_DEBUGINFO) $(XLIBJVM_DTRACE_G_DEBUGINFO); } + [ -f $(XLIBJVM_DTRACE_G_DEBUGINFO) ] || { cd $(XLIBJVM_DIR) && ln -s $(LIBJVM_DTRACE_DEBUGINFO) $(LIBJVM_DTRACE_G_DEBUGINFO); } ifeq ($(ZIP_DEBUGINFO_FILES),1) # Do this part in the $(XLIBJVM_DIR) subdir so $(XLIBJVM_DIR) is not # in the archived name: ( cd $(XLIBJVM_DIR) && $(ZIPEXE) -q -y $(LIBJVM_DTRACE_DIZ) $(LIBJVM_DTRACE_DEBUGINFO) $(LIBJVM_DTRACE_G_DEBUGINFO) ) $(RM) $(XLIBJVM_DTRACE_DEBUGINFO) $(XLIBJVM_DTRACE_G_DEBUGINFO) - [ -f $(XLIBJVM_DTRACE_G_DIZ) ] || { ln -s $(XLIBJVM_DTRACE_DIZ) $(XLIBJVM_DTRACE_G_DIZ); } + [ -f $(XLIBJVM_DTRACE_G_DIZ) ] || { cd $(XLIBJVM_DIR) && ln -s $(LIBJVM_DTRACE_DIZ) $(LIBJVM_DTRACE_G_DIZ); } endif endif From 71eeebb5959aa679e6d0964d45c5c28c2fc3259c Mon Sep 17 00:00:00 2001 From: Alejandro Murillo Date: Fri, 29 Jun 2012 17:04:40 -0700 Subject: [PATCH 044/160] Added tag hs24-b15 for changeset e4f98cec6edd --- hotspot/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/hotspot/.hgtags b/hotspot/.hgtags index b1ba8c68fa9..8ab00c4f0be 100644 --- a/hotspot/.hgtags +++ b/hotspot/.hgtags @@ -257,3 +257,4 @@ e77b8e0ed1f84e3e268239e276c7ab64fa573baa jdk8-b43 5ba29a1db46ecb80a321ca873adb56a3fe6ad320 hs24-b14 831e5c76a20af18f3c08c5a95ed31be0e128a010 jdk8-b44 9d5f20961bc5846fa8d098d534effafbbdae0a58 jdk8-b45 +40e5a3f2907ed02b335c7caa8ecf068cc801380d hs24-b15 From e9301228b489151cdd0c4892d89ed7c00c451af9 Mon Sep 17 00:00:00 2001 From: Alejandro Murillo Date: Fri, 29 Jun 2012 17:12:15 -0700 Subject: [PATCH 045/160] 7180882: new hotspot build - hs24-b16 Reviewed-by: jcoomes --- hotspot/make/hotspot_version | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hotspot/make/hotspot_version b/hotspot/make/hotspot_version index 44b5cbc8375..89e73aff4d8 100644 --- a/hotspot/make/hotspot_version +++ b/hotspot/make/hotspot_version @@ -35,7 +35,7 @@ HOTSPOT_VM_COPYRIGHT=Copyright 2012 HS_MAJOR_VER=24 HS_MINOR_VER=0 -HS_BUILD_NUMBER=15 +HS_BUILD_NUMBER=16 JDK_MAJOR_VER=1 JDK_MINOR_VER=8 From 3511594d3c320636a1366010a310b83d99676782 Mon Sep 17 00:00:00 2001 From: Roland Westrelin Date: Mon, 2 Jul 2012 09:58:06 +0200 Subject: [PATCH 046/160] 7177917: Failed test java/lang/Math/PowTests.java When c2 intrinsifies pow/exp, it should never inline the java implementations. Reviewed-by: kvn --- hotspot/src/share/vm/opto/library_call.cpp | 223 +++++++++++------- .../test/compiler/7177917/Test7177917.java | 142 +++++++++++ 2 files changed, 282 insertions(+), 83 deletions(-) create mode 100644 hotspot/test/compiler/7177917/Test7177917.java diff --git a/hotspot/src/share/vm/opto/library_call.cpp b/hotspot/src/share/vm/opto/library_call.cpp index 785f5a0ae1d..981a241a4f1 100644 --- a/hotspot/src/share/vm/opto/library_call.cpp +++ b/hotspot/src/share/vm/opto/library_call.cpp @@ -160,6 +160,7 @@ class LibraryCallKit : public GraphKit { bool inline_trans(vmIntrinsics::ID id); bool inline_abs(vmIntrinsics::ID id); bool inline_sqrt(vmIntrinsics::ID id); + void finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName); bool inline_pow(vmIntrinsics::ID id); bool inline_exp(vmIntrinsics::ID id); bool inline_min_max(vmIntrinsics::ID id); @@ -1535,40 +1536,79 @@ bool LibraryCallKit::inline_abs(vmIntrinsics::ID id) { return true; } +void LibraryCallKit::finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName) { + //------------------- + //result=(result.isNaN())? funcAddr():result; + // Check: If isNaN() by checking result!=result? then either trap + // or go to runtime + Node* cmpisnan = _gvn.transform(new (C, 3) CmpDNode(result,result)); + // Build the boolean node + Node* bolisnum = _gvn.transform( new (C, 2) BoolNode(cmpisnan, BoolTest::eq) ); + + if (!too_many_traps(Deoptimization::Reason_intrinsic)) { + { + BuildCutout unless(this, bolisnum, PROB_STATIC_FREQUENT); + // End the current control-flow path + push_pair(x); + if (y != NULL) { + push_pair(y); + } + // The pow or exp intrinsic returned a NaN, which requires a call + // to the runtime. Recompile with the runtime call. + uncommon_trap(Deoptimization::Reason_intrinsic, + Deoptimization::Action_make_not_entrant); + } + push_pair(result); + } else { + // If this inlining ever returned NaN in the past, we compile a call + // to the runtime to properly handle corner cases + + IfNode* iff = create_and_xform_if(control(), bolisnum, PROB_STATIC_FREQUENT, COUNT_UNKNOWN); + Node* if_slow = _gvn.transform( new (C, 1) IfFalseNode(iff) ); + Node* if_fast = _gvn.transform( new (C, 1) IfTrueNode(iff) ); + + if (!if_slow->is_top()) { + RegionNode* result_region = new(C, 3) RegionNode(3); + PhiNode* result_val = new (C, 3) PhiNode(result_region, Type::DOUBLE); + + result_region->init_req(1, if_fast); + result_val->init_req(1, result); + + set_control(if_slow); + + const TypePtr* no_memory_effects = NULL; + Node* rt = make_runtime_call(RC_LEAF, call_type, funcAddr, funcName, + no_memory_effects, + x, top(), y, y ? top() : NULL); + Node* value = _gvn.transform(new (C, 1) ProjNode(rt, TypeFunc::Parms+0)); +#ifdef ASSERT + Node* value_top = _gvn.transform(new (C, 1) ProjNode(rt, TypeFunc::Parms+1)); + assert(value_top == top(), "second value must be top"); +#endif + + result_region->init_req(2, control()); + result_val->init_req(2, value); + push_result(result_region, result_val); + } else { + push_pair(result); + } + } +} + //------------------------------inline_exp------------------------------------- // Inline exp instructions, if possible. The Intel hardware only misses // really odd corner cases (+/- Infinity). Just uncommon-trap them. bool LibraryCallKit::inline_exp(vmIntrinsics::ID id) { assert(id == vmIntrinsics::_dexp, "Not exp"); - // If this inlining ever returned NaN in the past, we do not intrinsify it - // every again. NaN results requires StrictMath.exp handling. - if (too_many_traps(Deoptimization::Reason_intrinsic)) return false; - _sp += arg_size(); // restore stack pointer Node *x = pop_math_arg(); Node *result = _gvn.transform(new (C, 2) ExpDNode(0,x)); - //------------------- - //result=(result.isNaN())? StrictMath::exp():result; - // Check: If isNaN() by checking result!=result? then go to Strict Math - Node* cmpisnan = _gvn.transform(new (C, 3) CmpDNode(result,result)); - // Build the boolean node - Node* bolisnum = _gvn.transform( new (C, 2) BoolNode(cmpisnan, BoolTest::eq) ); - - { BuildCutout unless(this, bolisnum, PROB_STATIC_FREQUENT); - // End the current control-flow path - push_pair(x); - // Math.exp intrinsic returned a NaN, which requires StrictMath.exp - // to handle. Recompile without intrinsifying Math.exp - uncommon_trap(Deoptimization::Reason_intrinsic, - Deoptimization::Action_make_not_entrant); - } + finish_pow_exp(result, x, NULL, OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dexp), "EXP"); C->set_has_split_ifs(true); // Has chance for split-if optimization - push_pair(result); - return true; } @@ -1577,17 +1617,12 @@ bool LibraryCallKit::inline_exp(vmIntrinsics::ID id) { bool LibraryCallKit::inline_pow(vmIntrinsics::ID id) { assert(id == vmIntrinsics::_dpow, "Not pow"); - // If this inlining ever returned NaN in the past, we do not intrinsify it - // every again. NaN results requires StrictMath.pow handling. - if (too_many_traps(Deoptimization::Reason_intrinsic)) return false; - - // Do not intrinsify on older platforms which lack cmove. - if (ConditionalMoveLimit == 0) return false; - // Pseudocode for pow // if (x <= 0.0) { - // if ((double)((int)y)==y) { // if y is int - // result = ((1&(int)y)==0)?-DPow(abs(x), y):DPow(abs(x), y) + // long longy = (long)y; + // if ((double)longy == y) { // if y is long + // if (y + 1 == y) longy = 0; // huge number: even + // result = ((1&longy) == 0)?-DPow(abs(x), y):DPow(abs(x), y); // } else { // result = NaN; // } @@ -1595,7 +1630,7 @@ bool LibraryCallKit::inline_pow(vmIntrinsics::ID id) { // result = DPow(x,y); // } // if (result != result)? { - // uncommon_trap(); + // result = uncommon_trap() or runtime_call(); // } // return result; @@ -1603,15 +1638,14 @@ bool LibraryCallKit::inline_pow(vmIntrinsics::ID id) { Node* y = pop_math_arg(); Node* x = pop_math_arg(); - Node *fast_result = _gvn.transform( new (C, 3) PowDNode(0, x, y) ); + Node* result = NULL; - // Short form: if not top-level (i.e., Math.pow but inlining Math.pow - // inside of something) then skip the fancy tests and just check for - // NaN result. - Node *result = NULL; - if( jvms()->depth() >= 1 ) { - result = fast_result; + if (!too_many_traps(Deoptimization::Reason_intrinsic)) { + // Short form: skip the fancy tests and just check for NaN result. + result = _gvn.transform( new (C, 3) PowDNode(0, x, y) ); } else { + // If this inlining ever returned NaN in the past, include all + // checks + call to the runtime. // Set the merge point for If node with condition of (x <= 0.0) // There are four possible paths to region node and phi node @@ -1627,55 +1661,95 @@ bool LibraryCallKit::inline_pow(vmIntrinsics::ID id) { Node *bol1 = _gvn.transform( new (C, 2) BoolNode( cmp, BoolTest::le ) ); // Branch either way IfNode *if1 = create_and_xform_if(control(),bol1, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN); - Node *opt_test = _gvn.transform(if1); - //assert( opt_test->is_If(), "Expect an IfNode"); - IfNode *opt_if1 = (IfNode*)opt_test; // Fast path taken; set region slot 3 - Node *fast_taken = _gvn.transform( new (C, 1) IfFalseNode(opt_if1) ); + Node *fast_taken = _gvn.transform( new (C, 1) IfFalseNode(if1) ); r->init_req(3,fast_taken); // Capture fast-control // Fast path not-taken, i.e. slow path - Node *complex_path = _gvn.transform( new (C, 1) IfTrueNode(opt_if1) ); + Node *complex_path = _gvn.transform( new (C, 1) IfTrueNode(if1) ); // Set fast path result - Node *fast_result = _gvn.transform( new (C, 3) PowDNode(0, y, x) ); + Node *fast_result = _gvn.transform( new (C, 3) PowDNode(0, x, y) ); phi->init_req(3, fast_result); // Complex path - // Build the second if node (if y is int) - // Node for (int)y - Node *inty = _gvn.transform( new (C, 2) ConvD2INode(y)); - // Node for (double)((int) y) - Node *doubleinty= _gvn.transform( new (C, 2) ConvI2DNode(inty)); - // Check (double)((int) y) : y - Node *cmpinty= _gvn.transform(new (C, 3) CmpDNode(doubleinty, y)); - // Check if (y isn't int) then go to slow path + // Build the second if node (if y is long) + // Node for (long)y + Node *longy = _gvn.transform( new (C, 2) ConvD2LNode(y)); + // Node for (double)((long) y) + Node *doublelongy= _gvn.transform( new (C, 2) ConvL2DNode(longy)); + // Check (double)((long) y) : y + Node *cmplongy= _gvn.transform(new (C, 3) CmpDNode(doublelongy, y)); + // Check if (y isn't long) then go to slow path - Node *bol2 = _gvn.transform( new (C, 2) BoolNode( cmpinty, BoolTest::ne ) ); + Node *bol2 = _gvn.transform( new (C, 2) BoolNode( cmplongy, BoolTest::ne ) ); // Branch either way IfNode *if2 = create_and_xform_if(complex_path,bol2, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN); - Node *slow_path = opt_iff(r,if2); // Set region path 2 + Node* ylong_path = _gvn.transform( new (C, 1) IfFalseNode(if2)); - // Calculate DPow(abs(x), y)*(1 & (int)y) + Node *slow_path = _gvn.transform( new (C, 1) IfTrueNode(if2) ); + + // Calculate DPow(abs(x), y)*(1 & (long)y) // Node for constant 1 - Node *conone = intcon(1); - // 1& (int)y - Node *signnode= _gvn.transform( new (C, 3) AndINode(conone, inty) ); + Node *conone = longcon(1); + // 1& (long)y + Node *signnode= _gvn.transform( new (C, 3) AndLNode(conone, longy) ); + + // A huge number is always even. Detect a huge number by checking + // if y + 1 == y and set integer to be tested for parity to 0. + // Required for corner case: + // (long)9.223372036854776E18 = max_jlong + // (double)(long)9.223372036854776E18 = 9.223372036854776E18 + // max_jlong is odd but 9.223372036854776E18 is even + Node* yplus1 = _gvn.transform( new (C, 3) AddDNode(y, makecon(TypeD::make(1)))); + Node *cmpyplus1= _gvn.transform(new (C, 3) CmpDNode(yplus1, y)); + Node *bolyplus1 = _gvn.transform( new (C, 2) BoolNode( cmpyplus1, BoolTest::eq ) ); + Node* correctedsign = NULL; + if (ConditionalMoveLimit != 0) { + correctedsign = _gvn.transform( CMoveNode::make(C, NULL, bolyplus1, signnode, longcon(0), TypeLong::LONG)); + } else { + IfNode *ifyplus1 = create_and_xform_if(ylong_path,bolyplus1, PROB_FAIR, COUNT_UNKNOWN); + RegionNode *r = new (C, 3) RegionNode(3); + Node *phi = new (C, 3) PhiNode(r, TypeLong::LONG); + r->init_req(1, _gvn.transform( new (C, 1) IfFalseNode(ifyplus1))); + r->init_req(2, _gvn.transform( new (C, 1) IfTrueNode(ifyplus1))); + phi->init_req(1, signnode); + phi->init_req(2, longcon(0)); + correctedsign = _gvn.transform(phi); + ylong_path = _gvn.transform(r); + record_for_igvn(r); + } + // zero node - Node *conzero = intcon(0); - // Check (1&(int)y)==0? - Node *cmpeq1 = _gvn.transform(new (C, 3) CmpINode(signnode, conzero)); - // Check if (1&(int)y)!=0?, if so the result is negative + Node *conzero = longcon(0); + // Check (1&(long)y)==0? + Node *cmpeq1 = _gvn.transform(new (C, 3) CmpLNode(correctedsign, conzero)); + // Check if (1&(long)y)!=0?, if so the result is negative Node *bol3 = _gvn.transform( new (C, 2) BoolNode( cmpeq1, BoolTest::ne ) ); // abs(x) Node *absx=_gvn.transform( new (C, 2) AbsDNode(x)); // abs(x)^y - Node *absxpowy = _gvn.transform( new (C, 3) PowDNode(0, y, absx) ); + Node *absxpowy = _gvn.transform( new (C, 3) PowDNode(0, absx, y) ); // -abs(x)^y Node *negabsxpowy = _gvn.transform(new (C, 2) NegDNode (absxpowy)); - // (1&(int)y)==1?-DPow(abs(x), y):DPow(abs(x), y) - Node *signresult = _gvn.transform( CMoveNode::make(C, NULL, bol3, absxpowy, negabsxpowy, Type::DOUBLE)); + // (1&(long)y)==1?-DPow(abs(x), y):DPow(abs(x), y) + Node *signresult = NULL; + if (ConditionalMoveLimit != 0) { + signresult = _gvn.transform( CMoveNode::make(C, NULL, bol3, absxpowy, negabsxpowy, Type::DOUBLE)); + } else { + IfNode *ifyeven = create_and_xform_if(ylong_path,bol3, PROB_FAIR, COUNT_UNKNOWN); + RegionNode *r = new (C, 3) RegionNode(3); + Node *phi = new (C, 3) PhiNode(r, Type::DOUBLE); + r->init_req(1, _gvn.transform( new (C, 1) IfFalseNode(ifyeven))); + r->init_req(2, _gvn.transform( new (C, 1) IfTrueNode(ifyeven))); + phi->init_req(1, absxpowy); + phi->init_req(2, negabsxpowy); + signresult = _gvn.transform(phi); + ylong_path = _gvn.transform(r); + record_for_igvn(r); + } // Set complex path fast result + r->init_req(2, ylong_path); phi->init_req(2, signresult); static const jlong nan_bits = CONST64(0x7ff8000000000000); @@ -1689,27 +1763,10 @@ bool LibraryCallKit::inline_pow(vmIntrinsics::ID id) { result=_gvn.transform(phi); } - //------------------- - //result=(result.isNaN())? uncommon_trap():result; - // Check: If isNaN() by checking result!=result? then go to Strict Math - Node* cmpisnan = _gvn.transform(new (C, 3) CmpDNode(result,result)); - // Build the boolean node - Node* bolisnum = _gvn.transform( new (C, 2) BoolNode(cmpisnan, BoolTest::eq) ); - - { BuildCutout unless(this, bolisnum, PROB_STATIC_FREQUENT); - // End the current control-flow path - push_pair(x); - push_pair(y); - // Math.pow intrinsic returned a NaN, which requires StrictMath.pow - // to handle. Recompile without intrinsifying Math.pow. - uncommon_trap(Deoptimization::Reason_intrinsic, - Deoptimization::Action_make_not_entrant); - } + finish_pow_exp(result, x, y, OptoRuntime::Math_DD_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dpow), "POW"); C->set_has_split_ifs(true); // Has chance for split-if optimization - push_pair(result); - return true; } diff --git a/hotspot/test/compiler/7177917/Test7177917.java b/hotspot/test/compiler/7177917/Test7177917.java new file mode 100644 index 00000000000..7d2c76490a9 --- /dev/null +++ b/hotspot/test/compiler/7177917/Test7177917.java @@ -0,0 +1,142 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/* + * Micro-benchmark for Math.pow() and Math.exp() + */ + +import java.util.*; + +public class Test7177917 { + + static double d; + + static Random r = new Random(0); + + static long m_pow(double[][] values) { + double res = 0; + long start = System.nanoTime(); + for (int i = 0; i < values.length; i++) { + res += Math.pow(values[i][0], values[i][1]); + } + long stop = System.nanoTime(); + d = res; + return (stop - start) / 1000; + } + + static long m_exp(double[] values) { + double res = 0; + long start = System.nanoTime(); + for (int i = 0; i < values.length; i++) { + res += Math.exp(values[i]); + } + long stop = System.nanoTime(); + d = res; + return (stop - start) / 1000; + } + + static double[][] pow_values(int nb) { + double[][] res = new double[nb][2]; + for (int i = 0; i < nb; i++) { + double ylogx = (1 + (r.nextDouble() * 2045)) - 1023; // 2045 rather than 2046 as a safety margin + double x = Math.abs(Double.longBitsToDouble(r.nextLong())); + while (x != x) { + x = Math.abs(Double.longBitsToDouble(r.nextLong())); + } + double logx = Math.log(x) / Math.log(2); + double y = ylogx / logx; + + res[i][0] = x; + res[i][1] = y; + } + return res; + } + + static double[] exp_values(int nb) { + double[] res = new double[nb]; + for (int i = 0; i < nb; i++) { + double ylogx = (1 + (r.nextDouble() * 2045)) - 1023; // 2045 rather than 2046 as a safety margin + double x = Math.E; + double logx = Math.log(x) / Math.log(2); + double y = ylogx / logx; + res[i] = y; + } + return res; + } + + static public void main(String[] args) { + { + // warmup + double[][] warmup_values = pow_values(10); + m_pow(warmup_values); + + for (int i = 0; i < 20000; i++) { + m_pow(warmup_values); + } + // test pow perf + double[][] values = pow_values(1000000); + System.out.println("==> POW " + m_pow(values)); + + // force uncommon trap + double[][] nan_values = new double[1][2]; + nan_values[0][0] = Double.NaN; + nan_values[0][1] = Double.NaN; + m_pow(nan_values); + + // force recompilation + for (int i = 0; i < 20000; i++) { + m_pow(warmup_values); + } + + // test pow perf again + System.out.println("==> POW " + m_pow(values)); + } + { + // warmup + double[] warmup_values = exp_values(10); + m_exp(warmup_values); + + for (int i = 0; i < 20000; i++) { + m_exp(warmup_values); + } + + // test pow perf + double[] values = exp_values(1000000); + System.out.println("==> EXP " + m_exp(values)); + + // force uncommon trap + double[] nan_values = new double[1]; + nan_values[0] = Double.NaN; + m_exp(nan_values); + + // force recompilation + for (int i = 0; i < 20000; i++) { + m_exp(warmup_values); + } + + // test pow perf again + System.out.println("==> EXP " + m_exp(values)); + } + } +} From 4d512adc5e3125b4a479615466a80c079e71ab6b Mon Sep 17 00:00:00 2001 From: Keith McGuigan Date: Mon, 2 Jul 2012 10:54:17 -0400 Subject: [PATCH 047/160] 7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used Send warnings to output stream Reviewed-by: dholmes, fparain --- .../src/share/vm/compiler/compilerOracle.cpp | 13 ++++++++-- hotspot/src/share/vm/runtime/arguments.cpp | 24 +++++++++++++++---- 2 files changed, 30 insertions(+), 7 deletions(-) diff --git a/hotspot/src/share/vm/compiler/compilerOracle.cpp b/hotspot/src/share/vm/compiler/compilerOracle.cpp index 07bc969b872..38ec9b4dab8 100644 --- a/hotspot/src/share/vm/compiler/compilerOracle.cpp +++ b/hotspot/src/share/vm/compiler/compilerOracle.cpp @@ -550,10 +550,12 @@ void CompilerOracle::parse_from_line(char* line) { } } +static const char* default_cc_file = ".hotspot_compiler"; + static const char* cc_file() { #ifdef ASSERT if (CompileCommandFile == NULL) - return ".hotspot_compiler"; + return default_cc_file; #endif return CompileCommandFile; } @@ -636,10 +638,17 @@ void compilerOracle_init() { CompilerOracle::parse_from_string(CompileOnly, CompilerOracle::parse_compile_only); if (CompilerOracle::has_command_file()) { CompilerOracle::parse_from_file(); + } else { + struct stat buf; + if (os::stat(default_cc_file, &buf) == 0) { + warning("%s file is present but has been ignored. " + "Run with -XX:CompileCommandFile=%s to load the file.", + default_cc_file, default_cc_file); + } } if (lists[PrintCommand] != NULL) { if (PrintAssembly) { - warning("CompileCommand and/or .hotspot_compiler file contains 'print' commands, but PrintAssembly is also enabled"); + warning("CompileCommand and/or %s file contains 'print' commands, but PrintAssembly is also enabled", default_cc_file); } else if (FLAG_IS_DEFAULT(DebugNonSafepoints)) { warning("printing of assembly code is enabled; turning on DebugNonSafepoints to gain additional output"); DebugNonSafepoints = true; diff --git a/hotspot/src/share/vm/runtime/arguments.cpp b/hotspot/src/share/vm/runtime/arguments.cpp index 438e783ecfb..74fddd94fd5 100644 --- a/hotspot/src/share/vm/runtime/arguments.cpp +++ b/hotspot/src/share/vm/runtime/arguments.cpp @@ -2971,7 +2971,10 @@ jint Arguments::parse(const JavaVMInitArgs* args) { const char* tail; // If flag "-XX:Flags=flags-file" is used it will be the first option to be processed. + const char* hotspotrc = ".hotspotrc"; bool settings_file_specified = false; + bool needs_hotspotrc_warning = false; + const char* flags_file; int index; for (index = 0; index < args->nOptions; index++) { @@ -3015,16 +3018,19 @@ jint Arguments::parse(const JavaVMInitArgs* args) { if (!process_settings_file(flags_file, true, args->ignoreUnrecognized)) { return JNI_EINVAL; } - } - + } else { #ifdef ASSERT - // Parse default .hotspotrc settings file - if (!settings_file_specified) { + // Parse default .hotspotrc settings file if (!process_settings_file(".hotspotrc", false, args->ignoreUnrecognized)) { return JNI_EINVAL; } - } +#else + struct stat buf; + if (os::stat(hotspotrc, &buf) == 0) { + needs_hotspotrc_warning = true; + } #endif + } if (PrintVMOptions) { for (index = 0; index < args->nOptions; index++) { @@ -3041,6 +3047,14 @@ jint Arguments::parse(const JavaVMInitArgs* args) { return result; } + // Delay warning until here so that we've had a chance to process + // the -XX:-PrintWarnings flag + if (needs_hotspotrc_warning) { + warning("%s file is present but has been ignored. " + "Run with -XX:Flags=%s to load the file.", + hotspotrc, hotspotrc); + } + #if (defined JAVASE_EMBEDDED || defined ARM) UNSUPPORTED_OPTION(UseG1GC, "G1 GC"); #endif From 2a72b6a15fca32248ee3ffbb9159c089a59e3112 Mon Sep 17 00:00:00 2001 From: Rob McKenna Date: Mon, 2 Jul 2012 19:32:35 +0100 Subject: [PATCH 048/160] 7174887: Deadlock in jndi ldap connection cleanup Reviewed-by: xuelei --- .../classes/com/sun/jndi/ldap/Connection.java | 6 ++++-- .../classes/com/sun/jndi/ldap/LdapClient.java | 18 ++++++++++-------- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/jdk/src/share/classes/com/sun/jndi/ldap/Connection.java b/jdk/src/share/classes/com/sun/jndi/ldap/Connection.java index 464e3d1bfdd..2b8b410f4cb 100644 --- a/jdk/src/share/classes/com/sun/jndi/ldap/Connection.java +++ b/jdk/src/share/classes/com/sun/jndi/ldap/Connection.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -680,9 +680,11 @@ public final class Connection implements Runnable { ldr = ldr.next; } } - parent.processConnectionClosure(); } } + if (nparent) { + parent.processConnectionClosure(); + } } diff --git a/jdk/src/share/classes/com/sun/jndi/ldap/LdapClient.java b/jdk/src/share/classes/com/sun/jndi/ldap/LdapClient.java index 0053758c26f..788152929b2 100644 --- a/jdk/src/share/classes/com/sun/jndi/ldap/LdapClient.java +++ b/jdk/src/share/classes/com/sun/jndi/ldap/LdapClient.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -488,14 +488,16 @@ public final class LdapClient implements PooledConnection { */ void processConnectionClosure() { // Notify listeners - if (unsolicited.size() > 0) { - String msg; - if (conn != null) { - msg = conn.host + ":" + conn.port + " connection closed"; - } else { - msg = "Connection closed"; + synchronized (unsolicited) { + if (unsolicited.size() > 0) { + String msg; + if (conn != null) { + msg = conn.host + ":" + conn.port + " connection closed"; + } else { + msg = "Connection closed"; + } + notifyUnsolicited(new CommunicationException(msg)); } - notifyUnsolicited(new CommunicationException(msg)); } // Remove from pool From 761e0b221daf6eb04b084c09174dca122a723e69 Mon Sep 17 00:00:00 2001 From: Vladimir Kozlov Date: Mon, 2 Jul 2012 12:59:43 -0700 Subject: [PATCH 049/160] 7180769: assert(tboth->klass_is_exact()) failed: klass should be exact Use class exactness as part of the condition for class compare optimization instead of assert. Reviewed-by: twisti, roland --- hotspot/src/share/vm/opto/parse2.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/hotspot/src/share/vm/opto/parse2.cpp b/hotspot/src/share/vm/opto/parse2.cpp index 541f26dd537..4982a1d76fc 100644 --- a/hotspot/src/share/vm/opto/parse2.cpp +++ b/hotspot/src/share/vm/opto/parse2.cpp @@ -1278,9 +1278,9 @@ void Parse::sharpen_type_after_if(BoolTest::mask btest, // or the narrowOop equivalent. const Type* obj_type = _gvn.type(obj); const TypeOopPtr* tboth = obj_type->join(con_type)->isa_oopptr(); - if (tboth != NULL && tboth != obj_type && tboth->higher_equal(obj_type)) { + if (tboth != NULL && tboth->klass_is_exact() && tboth != obj_type && + tboth->higher_equal(obj_type)) { // obj has to be of the exact type Foo if the CmpP succeeds. - assert(tboth->klass_is_exact(), "klass should be exact"); int obj_in_map = map()->find_edge(obj); JVMState* jvms = this->jvms(); if (obj_in_map >= 0 && From 9a2ec820dc0824c08ee9f0d41c778260bce2380c Mon Sep 17 00:00:00 2001 From: Mani Sarkar Date: Mon, 2 Jul 2012 14:11:44 -0700 Subject: [PATCH 050/160] 7176907: additional warnings cleanup in java.util, java.util.regexp, java.util.zip Reviewed-by: forax, khazra, smarks --- .../classes/java/util/InvalidPropertiesFormatException.java | 3 +++ jdk/src/share/classes/java/util/regex/Pattern.java | 4 ++++ jdk/src/share/classes/java/util/zip/GZIPInputStream.java | 2 +- 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/jdk/src/share/classes/java/util/InvalidPropertiesFormatException.java b/jdk/src/share/classes/java/util/InvalidPropertiesFormatException.java index 64dde4d42a4..2d92ae66e85 100644 --- a/jdk/src/share/classes/java/util/InvalidPropertiesFormatException.java +++ b/jdk/src/share/classes/java/util/InvalidPropertiesFormatException.java @@ -44,6 +44,9 @@ import java.io.IOException; */ public class InvalidPropertiesFormatException extends IOException { + + private static final long serialVersionUID = 7763056076009360219L; + /** * Constructs an InvalidPropertiesFormatException with the specified * cause. diff --git a/jdk/src/share/classes/java/util/regex/Pattern.java b/jdk/src/share/classes/java/util/regex/Pattern.java index 6c32f6a30bb..1c3d9fe0752 100644 --- a/jdk/src/share/classes/java/util/regex/Pattern.java +++ b/jdk/src/share/classes/java/util/regex/Pattern.java @@ -2026,6 +2026,7 @@ loop: for(int x=0, offset=0; x Date: Tue, 3 Jul 2012 01:41:29 -0400 Subject: [PATCH 051/160] 7179383: MaxDirectMemorySize argument parsing is broken for values >2G Change hotspot flag to be unsigned Reviewed-by: dholmes, sla, fparain, brutisso --- hotspot/src/share/vm/prims/jvm.cpp | 10 +++++++--- hotspot/src/share/vm/runtime/arguments.cpp | 11 +++++++++++ hotspot/src/share/vm/runtime/globals.hpp | 2 +- 3 files changed, 19 insertions(+), 4 deletions(-) diff --git a/hotspot/src/share/vm/prims/jvm.cpp b/hotspot/src/share/vm/prims/jvm.cpp index 3f097819e3d..1dfec11a862 100644 --- a/hotspot/src/share/vm/prims/jvm.cpp +++ b/hotspot/src/share/vm/prims/jvm.cpp @@ -345,9 +345,13 @@ JVM_ENTRY(jobject, JVM_InitProperties(JNIEnv *env, jobject properties)) // Do this after setting user properties to prevent people // from setting the value with a -D option, as requested. { - char as_chars[256]; - jio_snprintf(as_chars, sizeof(as_chars), INTX_FORMAT, MaxDirectMemorySize); - PUTPROP(props, "sun.nio.MaxDirectMemorySize", as_chars); + if (FLAG_IS_DEFAULT(MaxDirectMemorySize)) { + PUTPROP(props, "sun.nio.MaxDirectMemorySize", "-1"); + } else { + char as_chars[256]; + jio_snprintf(as_chars, sizeof(as_chars), UINTX_FORMAT, MaxDirectMemorySize); + PUTPROP(props, "sun.nio.MaxDirectMemorySize", as_chars); + } } // JVM monitoring and management support diff --git a/hotspot/src/share/vm/runtime/arguments.cpp b/hotspot/src/share/vm/runtime/arguments.cpp index 2a13bffc3b1..921b76fd9c2 100644 --- a/hotspot/src/share/vm/runtime/arguments.cpp +++ b/hotspot/src/share/vm/runtime/arguments.cpp @@ -2709,6 +2709,17 @@ SOLARIS_ONLY( return JNI_EINVAL; } FLAG_SET_CMDLINE(uintx, ConcGCThreads, conc_threads); + } else if (match_option(option, "-XX:MaxDirectMemorySize=", &tail)) { + julong max_direct_memory_size = 0; + ArgsRange errcode = parse_memory_size(tail, &max_direct_memory_size, 0); + if (errcode != arg_in_range) { + jio_fprintf(defaultStream::error_stream(), + "Invalid maximum direct memory size: %s\n", + option->optionString); + describe_range_error(errcode); + return JNI_EINVAL; + } + FLAG_SET_CMDLINE(uintx, MaxDirectMemorySize, max_direct_memory_size); } else if (match_option(option, "-XX:", &tail)) { // -XX:xxxx // Skip -XX:Flags= since that case has already been handled if (strncmp(tail, "Flags=", strlen("Flags=")) != 0) { diff --git a/hotspot/src/share/vm/runtime/globals.hpp b/hotspot/src/share/vm/runtime/globals.hpp index 504c4061cc5..f57a9b218c4 100644 --- a/hotspot/src/share/vm/runtime/globals.hpp +++ b/hotspot/src/share/vm/runtime/globals.hpp @@ -3705,7 +3705,7 @@ class CommandLineFlags { \ /* Properties for Java libraries */ \ \ - product(intx, MaxDirectMemorySize, -1, \ + product(uintx, MaxDirectMemorySize, 0, \ "Maximum total size of NIO direct-buffer allocations") \ \ /* temporary developer defined flags */ \ From f51d607e9fe970b9f279ff1d84abdb2cdaa49c48 Mon Sep 17 00:00:00 2001 From: Erik Joelsson Date: Tue, 3 Jul 2012 11:45:34 -0700 Subject: [PATCH 052/160] 7181508: Remove GenerateNativeHeader on awt java file Reviewed-by: ohair --- jdk/src/share/classes/java/awt/image/DirectColorModel.java | 3 --- jdk/src/share/classes/sun/awt/CharsetString.java | 4 ---- jdk/src/share/classes/sun/java2d/pipe/RegionIterator.java | 4 ---- jdk/src/share/native/sun/awt/image/cvutils/img_globals.c | 1 - 4 files changed, 12 deletions(-) diff --git a/jdk/src/share/classes/java/awt/image/DirectColorModel.java b/jdk/src/share/classes/java/awt/image/DirectColorModel.java index 1f6099c59d7..751d780ba64 100644 --- a/jdk/src/share/classes/java/awt/image/DirectColorModel.java +++ b/jdk/src/share/classes/java/awt/image/DirectColorModel.java @@ -27,7 +27,6 @@ package java.awt.image; import java.awt.color.ColorSpace; import java.awt.Transparency; -import javax.tools.annotation.GenerateNativeHeader; /** * The DirectColorModel class is a ColorModel @@ -107,8 +106,6 @@ import javax.tools.annotation.GenerateNativeHeader; * @see ColorModel#getRGBdefault * */ -/* No native methods here, but the constants are needed in the supporting JNI code */ -@GenerateNativeHeader public class DirectColorModel extends PackedColorModel { private int red_mask; private int green_mask; diff --git a/jdk/src/share/classes/sun/awt/CharsetString.java b/jdk/src/share/classes/sun/awt/CharsetString.java index aba0cbdb611..434ac731377 100644 --- a/jdk/src/share/classes/sun/awt/CharsetString.java +++ b/jdk/src/share/classes/sun/awt/CharsetString.java @@ -24,10 +24,6 @@ */ package sun.awt; -import javax.tools.annotation.GenerateNativeHeader; - -/* No native methods here, but the constants are needed in the supporting JNI code */ -@GenerateNativeHeader public class CharsetString { /** * chars for this string. See also offset, length. diff --git a/jdk/src/share/classes/sun/java2d/pipe/RegionIterator.java b/jdk/src/share/classes/sun/java2d/pipe/RegionIterator.java index 9fdef6ae7af..b46cb11f3a4 100644 --- a/jdk/src/share/classes/sun/java2d/pipe/RegionIterator.java +++ b/jdk/src/share/classes/sun/java2d/pipe/RegionIterator.java @@ -27,14 +27,10 @@ package sun.java2d.pipe; import java.awt.Rectangle; -import javax.tools.annotation.GenerateNativeHeader; - /** * This class defines the API for iterating through the bands * of a region object. */ -/* No native methods here, but the constants are needed in the supporting JNI code */ -@GenerateNativeHeader public class RegionIterator { Region region; int curIndex; diff --git a/jdk/src/share/native/sun/awt/image/cvutils/img_globals.c b/jdk/src/share/native/sun/awt/image/cvutils/img_globals.c index 7183f372902..e7ecd3f49c0 100644 --- a/jdk/src/share/native/sun/awt/image/cvutils/img_globals.c +++ b/jdk/src/share/native/sun/awt/image/cvutils/img_globals.c @@ -31,7 +31,6 @@ #include "img_globals.h" #include "java_awt_image_IndexColorModel.h" -#include "java_awt_image_DirectColorModel.h" #include "java_awt_Transparency.h" /* From 0c7c3bb2c554af9e7f4bd5f6998e321c96e3b87b Mon Sep 17 00:00:00 2001 From: Jason Uh Date: Tue, 3 Jul 2012 14:56:58 -0400 Subject: [PATCH 053/160] 7133344: Document the java.security.properties system property feature in the java.security file Reviewed-by: hawtin, mullan, weijun --- jdk/src/share/lib/security/java.security | 22 +++++++++++++++++++ .../share/lib/security/java.security-macosx | 22 +++++++++++++++++++ .../share/lib/security/java.security-solaris | 22 +++++++++++++++++++ .../share/lib/security/java.security-windows | 22 +++++++++++++++++++ 4 files changed, 88 insertions(+) diff --git a/jdk/src/share/lib/security/java.security b/jdk/src/share/lib/security/java.security index 52f3067408d..e8ca7bd7eea 100644 --- a/jdk/src/share/lib/security/java.security +++ b/jdk/src/share/lib/security/java.security @@ -1,6 +1,28 @@ # # This is the "master security properties file". # +# An alternate java.security properties file may be specified +# from the command line via the system property +# +# -Djava.security.properties= +# +# This properties file appends to the master security properties file. +# If both properties files specify values for the same key, the value +# from the command-line properties file is selected, as it is the last +# one loaded. +# +# Also, if you specify +# +# -Djava.security.properties== (2 equals), +# +# then that properties file completely overrides the master security +# properties file. +# +# To disable the ability to specify an additional properties file from +# the command line, set the key security.overridePropertiesFile +# to false in the master security properties file. It is set to true +# by default. + # In this file, various security properties are set for use by # java.security classes. This is where users can statically register # Cryptography Package Providers ("providers" for short). The term diff --git a/jdk/src/share/lib/security/java.security-macosx b/jdk/src/share/lib/security/java.security-macosx index 6c16c2ca0d6..1c04236e5d6 100644 --- a/jdk/src/share/lib/security/java.security-macosx +++ b/jdk/src/share/lib/security/java.security-macosx @@ -1,6 +1,28 @@ # # This is the "master security properties file". # +# An alternate java.security properties file may be specified +# from the command line via the system property +# +# -Djava.security.properties= +# +# This properties file appends to the master security properties file. +# If both properties files specify values for the same key, the value +# from the command-line properties file is selected, as it is the last +# one loaded. +# +# Also, if you specify +# +# -Djava.security.properties== (2 equals), +# +# then that properties file completely overrides the master security +# properties file. +# +# To disable the ability to specify an additional properties file from +# the command line, set the key security.overridePropertiesFile +# to false in the master security properties file. It is set to true +# by default. + # In this file, various security properties are set for use by # java.security classes. This is where users can statically register # Cryptography Package Providers ("providers" for short). The term diff --git a/jdk/src/share/lib/security/java.security-solaris b/jdk/src/share/lib/security/java.security-solaris index 1191aff8403..87a6f1ea5b4 100644 --- a/jdk/src/share/lib/security/java.security-solaris +++ b/jdk/src/share/lib/security/java.security-solaris @@ -1,6 +1,28 @@ # # This is the "master security properties file". # +# An alternate java.security properties file may be specified +# from the command line via the system property +# +# -Djava.security.properties= +# +# This properties file appends to the master security properties file. +# If both properties files specify values for the same key, the value +# from the command-line properties file is selected, as it is the last +# one loaded. +# +# Also, if you specify +# +# -Djava.security.properties== (2 equals), +# +# then that properties file completely overrides the master security +# properties file. +# +# To disable the ability to specify an additional properties file from +# the command line, set the key security.overridePropertiesFile +# to false in the master security properties file. It is set to true +# by default. + # In this file, various security properties are set for use by # java.security classes. This is where users can statically register # Cryptography Package Providers ("providers" for short). The term diff --git a/jdk/src/share/lib/security/java.security-windows b/jdk/src/share/lib/security/java.security-windows index 3793e79be29..e7c36d8c470 100644 --- a/jdk/src/share/lib/security/java.security-windows +++ b/jdk/src/share/lib/security/java.security-windows @@ -1,6 +1,28 @@ # # This is the "master security properties file". # +# An alternate java.security properties file may be specified +# from the command line via the system property +# +# -Djava.security.properties= +# +# This properties file appends to the master security properties file. +# If both properties files specify values for the same key, the value +# from the command-line properties file is selected, as it is the last +# one loaded. +# +# Also, if you specify +# +# -Djava.security.properties== (2 equals), +# +# then that properties file completely overrides the master security +# properties file. +# +# To disable the ability to specify an additional properties file from +# the command line, set the key security.overridePropertiesFile +# to false in the master security properties file. It is set to true +# by default. + # In this file, various security properties are set for use by # java.security classes. This is where users can statically register # Cryptography Package Providers ("providers" for short). The term From d85c0b6f6fc99c3c707ea120893b088231fa4f5e Mon Sep 17 00:00:00 2001 From: Erik Joelsson Date: Tue, 3 Jul 2012 16:01:59 -0700 Subject: [PATCH 054/160] 7181501: Add some GenerateNativeHeader annotations and misc Mac adjustments to makefiles Reviewed-by: ohair --- jdk/src/macosx/native/jobjc/build.xml | 12 +++++-- .../native/jobjc/src/core/PrimitiveCoder.hs | 7 ++++- .../src/core/java/com/apple/jobjc/CFType.java | 4 +++ .../src/core/java/com/apple/jobjc/Coder.java | 17 ++++++++++ .../core/java/com/apple/jobjc/FFIType.java | 4 +++ .../core/java/com/apple/jobjc/Function.java | 4 +++ .../src/core/java/com/apple/jobjc/ID.java | 4 +++ .../src/core/java/com/apple/jobjc/Invoke.java | 10 ++++++ .../java/com/apple/jobjc/JObjCRuntime.java | 6 ++++ .../java/com/apple/jobjc/MacOSXFramework.java | 4 +++ .../core/java/com/apple/jobjc/NSClass.java | 6 ++++ .../com/apple/jobjc/NativeArgumentBuffer.java | 4 +++ .../java/com/apple/jobjc/NativeBuffer.java | 4 +++ .../jobjc/NativeObjectLifecycleManager.java | 10 ++++++ .../src/core/java/com/apple/jobjc/Opaque.java | 4 +++ .../core/java/com/apple/jobjc/Pointer.java | 4 +++ .../java/com/apple/jobjc/PrimitiveCoder.java | 31 ++++++++++++++++++- .../src/core/java/com/apple/jobjc/SEL.java | 4 +++ .../src/core/java/com/apple/jobjc/Struct.java | 4 +++ .../java/com/apple/jobjc/Subclassing.java | 4 +++ .../generator/classes/FrameworkClassFile.java | 7 ++++- .../internal/jobjc/generator/model/Clazz.java | 4 +++ .../model/coders/ComplexCoderDescriptor.java | 7 +++-- 23 files changed, 157 insertions(+), 8 deletions(-) diff --git a/jdk/src/macosx/native/jobjc/build.xml b/jdk/src/macosx/native/jobjc/build.xml index 46e726c6278..19e29ad51af 100644 --- a/jdk/src/macosx/native/jobjc/build.xml +++ b/jdk/src/macosx/native/jobjc/build.xml @@ -140,8 +140,16 @@ - + includeantruntime="false"> + + + + + + + + + diff --git a/jdk/src/macosx/native/jobjc/src/core/PrimitiveCoder.hs b/jdk/src/macosx/native/jobjc/src/core/PrimitiveCoder.hs index 544998ee859..2759733ec6f 100644 --- a/jdk/src/macosx/native/jobjc/src/core/PrimitiveCoder.hs +++ b/jdk/src/macosx/native/jobjc/src/core/PrimitiveCoder.hs @@ -2,7 +2,7 @@ {- /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011,2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -196,6 +196,8 @@ sizeofRet nt = c2java ntype = unlines [ "// native " ++ ntypeS ++ " -> java " ++ jprimS, + "/* No native methods here, but the constants are needed in the supporting JNI code */", + "@GenerateNativeHeader", "public static final class " ++ className ++ " extends PrimitiveCoder<" ++ jclassS ++ ">{", "\tpublic static final " ++ className ++ " INST = new " ++ className ++ "();", "\tpublic " ++ className ++ "(){ super("++ffitypeVal ntype++", \"" ++ [encoding ntype] ++ "\", "++jclassS++".class, "++jprimS++".class); }", @@ -246,10 +248,13 @@ main = do putStrLn "package com.apple.jobjc;" putStrLn "import com.apple.jobjc.JObjCRuntime.Width;" + putStrLn "import javax.tools.annotation.GenerateNativeHeader;" putStrLn "// Auto generated by PrimitiveCoder.hs" putStrLn "// Do not edit by hand." + putStrLn "/* No native methods here, but the constants are needed in the supporting JNI code */" + putStrLn "@GenerateNativeHeader" putStrLn "public abstract class PrimitiveCoder extends Coder{" putStrLn "\tpublic PrimitiveCoder(int ffiTypeCode, String objCEncoding, Class jclass, Class jprim){" diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/CFType.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/CFType.java index aeeca30d29e..835b3793538 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/CFType.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/CFType.java @@ -24,6 +24,10 @@ */ package com.apple.jobjc; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public class CFType extends Pointer { protected CFType(long ptr) { super(ptr); } protected CFType(Pointer ptr) { super(ptr.ptr); } diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Coder.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Coder.java index a6a714f3933..f1bc68283ac 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Coder.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Coder.java @@ -35,6 +35,7 @@ import com.apple.jobjc.PrimitiveCoder.SCharCoder; import com.apple.jobjc.PrimitiveCoder.SIntCoder; import com.apple.jobjc.PrimitiveCoder.SLongLongCoder; import com.apple.jobjc.PrimitiveCoder.SShortCoder; +import javax.tools.annotation.GenerateNativeHeader; public abstract class Coder { private static native long getNativeFFITypePtrForCode(final int code); @@ -142,6 +143,8 @@ public abstract class Coder { // + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class VoidCoder extends Coder{ public static final VoidCoder INST = new VoidCoder(); public VoidCoder(){ super(FFI_VOID, "v", Void.class, void.class); } @@ -150,6 +153,8 @@ public abstract class Coder { @Override public void push(JObjCRuntime runtime, long addr, Object x) { throw new RuntimeException("Trying to push a Void."); } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class UnknownCoder extends Coder { public static final UnknownCoder INST = new UnknownCoder(); public UnknownCoder(){ super(-1, "?", null, null); } @@ -158,6 +163,8 @@ public abstract class Coder { @Override public Object pop(JObjCRuntime runtime, long addr) { throw new RuntimeException("Coder not implemented"); } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class PrimitivePointerCoder extends Coder { public static final PrimitivePointerCoder INST = new PrimitivePointerCoder(); public PrimitivePointerCoder(){ super(Coder.FFI_PTR, "^?", Long.class, long.class); } @@ -187,6 +194,8 @@ public abstract class Coder { @Override public void push(JObjCRuntime runtime, long addr, Long x) { push(runtime, addr, (long) x); } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class PointerCoder extends Coder { public static final PointerCoder INST = new PointerCoder(); public PointerCoder(){ super(FFI_PTR, "^?", Pointer.class); } @@ -200,6 +209,8 @@ public abstract class Coder { } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class SELCoder extends Coder { public static final SELCoder INST = new SELCoder(); public SELCoder(){ super(FFI_PTR, ":", SEL.class); } @@ -213,6 +224,8 @@ public abstract class Coder { } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static abstract class StructCoder extends Coder { private final FFIType ffiType; final int sizeof; @@ -254,6 +267,8 @@ public abstract class Coder { } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class IDCoder extends Coder{ public static final IDCoder INST = new IDCoder(); public IDCoder(){ super(FFI_PTR, "@", ID.class); } @@ -272,6 +287,8 @@ public abstract class Coder { } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class NSClassCoder extends Coder{ public static final NSClassCoder INST = new NSClassCoder(); public NSClassCoder(){ super(FFI_PTR, "#", NSClass.class); } diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/FFIType.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/FFIType.java index fcfddd6edec..c045b210c6c 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/FFIType.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/FFIType.java @@ -26,6 +26,10 @@ package com.apple.jobjc; import com.apple.jobjc.Coder.PrimitivePointerCoder; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader class FFIType{ private static native void makeFFIType(long ffi_type_buf, long elements_buf); private static native int getFFITypeSizeof(); diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Function.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Function.java index 0acfccce91d..b5257cc83ef 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Function.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Function.java @@ -24,6 +24,10 @@ */ package com.apple.jobjc; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public class Function { private static native long getFxnPtrForFunctionName(final String functionName); private static native long getFxnPtrForFunctionNameAndLib(final long libPtr, final String functionName); diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/ID.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/ID.java index f2b3718df7e..192e6feafa0 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/ID.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/ID.java @@ -29,6 +29,10 @@ import java.lang.reflect.Constructor; import java.util.LinkedHashMap; import java.util.Map; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public class ID extends Pointer{ static native String getNativeDescription(final long objPtr); diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Invoke.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Invoke.java index c6cab308a93..19e79ddc165 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Invoke.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Invoke.java @@ -30,12 +30,18 @@ import com.apple.jobjc.Coder.PrimitivePointerCoder; import com.apple.jobjc.Coder.SELCoder; import com.apple.jobjc.Coder.StructCoder; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public abstract class Invoke { public abstract void invoke(NativeArgumentBuffer argBuf); public abstract void invoke(NativeArgumentBuffer buffer, Struct retvalStruct); // + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class FunCall extends Invoke{ static native void invoke(long cifPtr, long fxnPtr, long retValPtr, long argsPtr); @@ -72,6 +78,8 @@ public abstract class Invoke { } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class MsgSend extends Invoke{ static{ System.load("/usr/lib/libobjc.dylib"); } @@ -157,6 +165,8 @@ public abstract class Invoke { } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static final class MsgSendSuper extends Invoke{ static{ System.load("/usr/lib/libobjc.dylib"); } diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/JObjCRuntime.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/JObjCRuntime.java index b5e08478c1c..03f636696b2 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/JObjCRuntime.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/JObjCRuntime.java @@ -31,10 +31,16 @@ import java.util.List; import sun.misc.Unsafe; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public final class JObjCRuntime { static { System.loadLibrary("JObjC"); } + @GenerateNativeHeader public static enum Arch{ ppc, i386, x86_64 }; + @GenerateNativeHeader public static enum Width{ W32, W64 }; public static final Arch ARCH = getArch(); diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/MacOSXFramework.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/MacOSXFramework.java index bfc77501db8..09737c80925 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/MacOSXFramework.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/MacOSXFramework.java @@ -25,6 +25,10 @@ package com.apple.jobjc; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public class MacOSXFramework { private static native long retainFramework(final String frameworkName); private static native void releaseFramework(final long frameworkPtr); diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NSClass.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NSClass.java index dbc784f6940..15de180200d 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NSClass.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NSClass.java @@ -27,7 +27,13 @@ package com.apple.jobjc; import java.lang.ref.WeakReference; import java.lang.reflect.Constructor; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public class NSClass extends ID { + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static class NSClassNotFoundException extends RuntimeException{ public NSClassNotFoundException(String m){ super(m); } public NSClassNotFoundException(String m, Throwable cause){ super(m, cause); } diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeArgumentBuffer.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeArgumentBuffer.java index 1e3c42452bf..3a6a792af56 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeArgumentBuffer.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeArgumentBuffer.java @@ -28,6 +28,10 @@ import java.nio.ByteOrder; import com.apple.jobjc.Coder.PrimitivePointerCoder; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public final class NativeArgumentBuffer{ private static final ThreadLocal threadLocal = new ThreadLocal(); diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeBuffer.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeBuffer.java index ee0ac05d687..f7285f145a5 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeBuffer.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeBuffer.java @@ -27,9 +27,13 @@ package com.apple.jobjc; import java.nio.ByteBuffer; import java.nio.ByteOrder; +import javax.tools.annotation.GenerateNativeHeader; + /** * A wrapper around a direct ByteBuffer and its native pointer. For documentation, @see java.nio.ByteBuffer */ +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public class NativeBuffer { static native long getPtrOfBuffer(final ByteBuffer byteBuffer); diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeObjectLifecycleManager.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeObjectLifecycleManager.java index b4d3dbfe0b8..928f0012425 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeObjectLifecycleManager.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/NativeObjectLifecycleManager.java @@ -24,6 +24,10 @@ */ package com.apple.jobjc; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public abstract class NativeObjectLifecycleManager { private static native void retainNativeObject(final long ptr); private static native void releaseNativeObject(final long ptr); @@ -33,6 +37,8 @@ public abstract class NativeObjectLifecycleManager { abstract void end(final long ptr); boolean shouldPreRetain() { return false; } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static class CFRetainRelease extends NativeObjectLifecycleManager { public static final NativeObjectLifecycleManager INST = new CFRetainRelease(); @Override void begin(final long ptr) { retainNativeObject(ptr); } @@ -40,12 +46,16 @@ public abstract class NativeObjectLifecycleManager { @Override boolean shouldPreRetain() { return true; } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static class Free extends NativeObjectLifecycleManager { public static final NativeObjectLifecycleManager INST = new Free(); @Override void begin(final long ptr) { } @Override void end(final long ptr) { freeNativeObject(ptr); } } + /* No native methods here, but the constants are needed in the supporting JNI code */ + @GenerateNativeHeader public static class Nothing extends NativeObjectLifecycleManager { public static final NativeObjectLifecycleManager INST = new Nothing(); @Override void begin(final long ptr) { } diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Opaque.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Opaque.java index cbc5acca39e..82bceb93ce8 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Opaque.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Opaque.java @@ -24,6 +24,10 @@ */ package com.apple.jobjc; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public class Opaque extends Pointer { protected Opaque(long ptr) { super(ptr); } protected Opaque(Pointer ptr) { super(ptr.ptr); } diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Pointer.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Pointer.java index 5d8c3c85c2e..cc0487f2e69 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Pointer.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Pointer.java @@ -24,6 +24,10 @@ */ package com.apple.jobjc; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public class Pointer implements Comparable>{ long ptr; diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/PrimitiveCoder.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/PrimitiveCoder.java index 8dcc42482da..975b88848d5 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/PrimitiveCoder.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/PrimitiveCoder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011,2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,8 +24,11 @@ */ package com.apple.jobjc; import com.apple.jobjc.JObjCRuntime.Width; +import javax.tools.annotation.GenerateNativeHeader; // Auto generated by PrimitiveCoder.hs // Do not edit by hand. +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public abstract class PrimitiveCoder extends Coder{ public PrimitiveCoder(int ffiTypeCode, String objCEncoding, Class jclass, Class jprim){ super(ffiTypeCode, objCEncoding, jclass, jprim); @@ -127,6 +130,8 @@ public abstract class PrimitiveCoder extends Coder{ // native BOOL -> java boolean +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class BoolCoder extends PrimitiveCoder{ public static final BoolCoder INST = new BoolCoder(); public BoolCoder(){ super(FFI_SINT8, "B", Boolean.class, boolean.class); } @@ -170,6 +175,8 @@ public static final class BoolCoder extends PrimitiveCoder{ } // native schar -> java byte +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class SCharCoder extends PrimitiveCoder{ public static final SCharCoder INST = new SCharCoder(); public SCharCoder(){ super(FFI_SINT8, "c", Byte.class, byte.class); } @@ -213,6 +220,8 @@ public static final class SCharCoder extends PrimitiveCoder{ } // native uchar -> java byte +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class UCharCoder extends PrimitiveCoder{ public static final UCharCoder INST = new UCharCoder(); public UCharCoder(){ super(FFI_UINT8, "C", Byte.class, byte.class); } @@ -256,6 +265,8 @@ public static final class UCharCoder extends PrimitiveCoder{ } // native sshort -> java short +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class SShortCoder extends PrimitiveCoder{ public static final SShortCoder INST = new SShortCoder(); public SShortCoder(){ super(FFI_SINT16, "s", Short.class, short.class); } @@ -299,6 +310,8 @@ public static final class SShortCoder extends PrimitiveCoder{ } // native ushort -> java short +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class UShortCoder extends PrimitiveCoder{ public static final UShortCoder INST = new UShortCoder(); public UShortCoder(){ super(FFI_UINT16, "S", Short.class, short.class); } @@ -342,6 +355,8 @@ public static final class UShortCoder extends PrimitiveCoder{ } // native sint -> java int +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class SIntCoder extends PrimitiveCoder{ public static final SIntCoder INST = new SIntCoder(); public SIntCoder(){ super(FFI_SINT32, "i", Integer.class, int.class); } @@ -385,6 +400,8 @@ public static final class SIntCoder extends PrimitiveCoder{ } // native uint -> java int +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class UIntCoder extends PrimitiveCoder{ public static final UIntCoder INST = new UIntCoder(); public UIntCoder(){ super(FFI_UINT32, "I", Integer.class, int.class); } @@ -428,6 +445,8 @@ public static final class UIntCoder extends PrimitiveCoder{ } // native slong -> java long +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class SLongCoder extends PrimitiveCoder{ public static final SLongCoder INST = new SLongCoder(); public SLongCoder(){ super((JObjCRuntime.IS64 ? (FFI_SINT64) : (FFI_SINT32)), "l", Long.class, long.class); } @@ -477,6 +496,8 @@ public static final class SLongCoder extends PrimitiveCoder{ } // native ulong -> java long +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class ULongCoder extends PrimitiveCoder{ public static final ULongCoder INST = new ULongCoder(); public ULongCoder(){ super((JObjCRuntime.IS64 ? (FFI_UINT64) : (FFI_UINT32)), "L", Long.class, long.class); } @@ -526,6 +547,8 @@ public static final class ULongCoder extends PrimitiveCoder{ } // native slonglong -> java long +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class SLongLongCoder extends PrimitiveCoder{ public static final SLongLongCoder INST = new SLongLongCoder(); public SLongLongCoder(){ super(FFI_SINT64, "q", Long.class, long.class); } @@ -569,6 +592,8 @@ public static final class SLongLongCoder extends PrimitiveCoder{ } // native ulonglong -> java long +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class ULongLongCoder extends PrimitiveCoder{ public static final ULongLongCoder INST = new ULongLongCoder(); public ULongLongCoder(){ super(FFI_UINT64, "Q", Long.class, long.class); } @@ -612,6 +637,8 @@ public static final class ULongLongCoder extends PrimitiveCoder{ } // native float -> java float +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class FloatCoder extends PrimitiveCoder{ public static final FloatCoder INST = new FloatCoder(); public FloatCoder(){ super(FFI_FLOAT, "f", Float.class, float.class); } @@ -655,6 +682,8 @@ public static final class FloatCoder extends PrimitiveCoder{ } // native double -> java double +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public static final class DoubleCoder extends PrimitiveCoder{ public static final DoubleCoder INST = new DoubleCoder(); public DoubleCoder(){ super(FFI_DOUBLE, "d", Double.class, double.class); } diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/SEL.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/SEL.java index b6d719e1158..44d679ab539 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/SEL.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/SEL.java @@ -24,6 +24,10 @@ */ package com.apple.jobjc; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public class SEL { static native long getSelectorPtr(String selectorName); static native String getSelectorName(long ptr); diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Struct.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Struct.java index 8329cf17f04..117710402e8 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Struct.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Struct.java @@ -24,9 +24,13 @@ */ package com.apple.jobjc; +import javax.tools.annotation.GenerateNativeHeader; + /** * A struct is malloced on the C heap and accessed in Java through a ByteBuffer. */ +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader public abstract class Struct{ protected final NativeBuffer raw; private final JObjCRuntime runtime; diff --git a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Subclassing.java b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Subclassing.java index b2084dfd706..d3bfc1b0e41 100644 --- a/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Subclassing.java +++ b/jdk/src/macosx/native/jobjc/src/core/java/com/apple/jobjc/Subclassing.java @@ -33,6 +33,10 @@ import com.apple.jobjc.Coder.PrimitivePointerCoder; import com.apple.jobjc.Coder.VoidCoder; import com.apple.jobjc.Invoke.MsgSend; +import javax.tools.annotation.GenerateNativeHeader; + +/* No native methods here, but the constants are needed in the supporting JNI code */ +@GenerateNativeHeader final class Subclassing { static native long allocateClassPair(long superClass, String name); static native boolean addIVarForJObj(long clazz); diff --git a/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/classes/FrameworkClassFile.java b/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/classes/FrameworkClassFile.java index 20b27b6c548..8a27daaa0af 100644 --- a/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/classes/FrameworkClassFile.java +++ b/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/classes/FrameworkClassFile.java @@ -28,6 +28,7 @@ import java.io.File; import java.io.PrintStream; import java.util.ArrayList; import java.util.List; +import java.util.TreeSet; import com.apple.internal.jobjc.generator.FunctionGenerator; import com.apple.internal.jobjc.generator.Utils; @@ -130,7 +131,11 @@ public class FrameworkClassFile extends GeneratedClassFile { } } - for (final Clazz clazz : framework.classes) { + /** + * Order classes to get stable output + */ + TreeSet sortedClasses = new TreeSet(framework.classes); + for (final Clazz clazz : sortedClasses) { final String classClassName = clazz.name + "Class"; out.println(JavaLang.makeSingleton("_" + classClassName, clazz.name, classClassName, "getRuntime()")); } diff --git a/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/model/Clazz.java b/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/model/Clazz.java index 9dfb8228a82..be4278ffef9 100644 --- a/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/model/Clazz.java +++ b/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/model/Clazz.java @@ -147,4 +147,8 @@ public class Clazz extends Element implements OutputFileGenerator { return null; } + + int compareTo(Clazz o) { + return toString().compareTo(o.toString()); + } } diff --git a/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/model/coders/ComplexCoderDescriptor.java b/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/model/coders/ComplexCoderDescriptor.java index 11ee8cc9fe3..7ffb14b0f31 100644 --- a/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/model/coders/ComplexCoderDescriptor.java +++ b/jdk/src/macosx/native/jobjc/src/generator/java/com/apple/internal/jobjc/generator/model/coders/ComplexCoderDescriptor.java @@ -25,7 +25,7 @@ package com.apple.internal.jobjc.generator.model.coders; import java.util.HashMap; -import java.util.HashSet; +import java.util.TreeSet; import java.util.Map; import java.util.Set; @@ -40,7 +40,7 @@ import com.apple.jobjc.JObjCRuntime; */ public class ComplexCoderDescriptor extends CoderDescriptor { static Map, ComplexCoderDescriptor> cache = new HashMap, ComplexCoderDescriptor>(); - static Set mixedEncodingDescriptors = new HashSet(); + static Set mixedEncodingDescriptors = new TreeSet(); public static Set getMixedEncoders() { return mixedEncodingDescriptors; } @@ -76,7 +76,7 @@ public class ComplexCoderDescriptor extends CoderDescriptor { // ** Subclasses // ------------- - public static class MixedEncodingDescriptor extends ComplexCoderDescriptor { + public static class MixedEncodingDescriptor extends ComplexCoderDescriptor implements java.lang.Comparable { protected final PrimitiveCoderDescriptor desc32; public MixedEncodingDescriptor(final PrimitiveCoderDescriptor desc32, final PrimitiveCoderDescriptor desc64) { @@ -97,5 +97,6 @@ public class ComplexCoderDescriptor extends CoderDescriptor { } static String getBaseNameOfCoder(final String coderName) { return coderName.substring(0, coderName.indexOf("Coder")); } + public int compareTo(Object _o) { MixedEncodingDescriptor o = (MixedEncodingDescriptor)_o; return getMixedName().compareTo(o.getMixedName()); } } } From 4e7263a44ae4d50815de7e26a4ee396564e5eec0 Mon Sep 17 00:00:00 2001 From: Erik Joelsson Date: Tue, 3 Jul 2012 16:10:44 -0700 Subject: [PATCH 055/160] 7181504: Update of latest build-infra Makefiles Reviewed-by: ohair --- jdk/makefiles/CompileDemos.gmk | 27 +- jdk/makefiles/CompileJavaClasses.gmk | 94 +- jdk/makefiles/CompileLaunchers.gmk | 169 +- jdk/makefiles/CompileNativeLibraries.gmk | 4411 +++++++++-------- jdk/makefiles/CopyFiles.gmk | 71 +- jdk/makefiles/CopyIntoClasses.gmk | 24 +- jdk/makefiles/CopySamples.gmk | 3 +- jdk/makefiles/CreateJars.gmk | 87 +- jdk/makefiles/GendataBreakIterator.gmk | 8 +- jdk/makefiles/GendataFontConfig.gmk | 12 +- jdk/makefiles/GendataHtml32dtd.gmk | 3 +- jdk/makefiles/GenerateClasses.gmk | 8 +- jdk/makefiles/GenerateData.gmk | 1 + jdk/makefiles/GenerateJavaSources.gmk | 12 +- jdk/makefiles/GensrcBuffer.gmk | 1 + jdk/makefiles/GensrcIcons.gmk | 8 +- jdk/makefiles/GensrcJObjC.gmk | 80 + jdk/makefiles/GensrcMisc.gmk | 105 +- jdk/makefiles/GensrcProperties.gmk | 10 +- jdk/makefiles/GensrcX11Wrappers.gmk | 25 +- jdk/makefiles/Images.gmk | 106 +- jdk/makefiles/Import.gmk | 243 + jdk/makefiles/LegacyMakefiles.gmk | 42 - jdk/makefiles/Makefile | 24 +- jdk/makefiles/OldImages.gmk | 175 - jdk/makefiles/Tools.gmk | 24 + .../com/sun/crypto/provider/Makefile | 275 - jdk/makefiles/common/Classes.gmk | 67 - jdk/makefiles/common/Cscope.gmk | 100 - jdk/makefiles/common/Defs-embedded.gmk | 76 - jdk/makefiles/common/Defs-linux.gmk | 430 -- jdk/makefiles/common/Defs-macosx.gmk | 402 -- jdk/makefiles/common/Defs-solaris.gmk | 757 --- jdk/makefiles/common/Defs-windows.gmk | 418 -- jdk/makefiles/common/Defs.gmk | 577 --- jdk/makefiles/common/Demo.gmk | 415 -- jdk/makefiles/common/Library.gmk | 326 -- jdk/makefiles/common/Mapfile-vers.gmk | 97 - jdk/makefiles/common/Modules.gmk | 479 -- jdk/makefiles/common/Program.gmk | 319 -- jdk/makefiles/common/Release-embedded.gmk | 230 - jdk/makefiles/common/Release-macosx.gmk | 75 - jdk/makefiles/common/Release.gmk | 1401 ------ jdk/makefiles/common/Rules.gmk | 357 -- jdk/makefiles/common/Subdirs.gmk | 148 - jdk/makefiles/common/internal/Defs-corba.gmk | 63 - jdk/makefiles/common/internal/Defs-jaxp.gmk | 53 - jdk/makefiles/common/internal/Defs-jaxws.gmk | 63 - .../common/internal/Defs-langtools.gmk | 42 - .../common/internal/ImportComponents.gmk | 173 - .../common/internal/NativeCompileRules.gmk | 238 - jdk/makefiles/common/internal/Resources.gmk | 262 - jdk/makefiles/common/shared/Compiler-gcc.gmk | 98 - jdk/makefiles/common/shared/Compiler-llvm.gmk | 59 - jdk/makefiles/common/shared/Compiler-msvc.gmk | 93 - jdk/makefiles/common/shared/Compiler-sun.gmk | 138 - jdk/makefiles/common/shared/Defs-control.gmk | 143 - jdk/makefiles/common/shared/Defs-java.gmk | 249 - jdk/makefiles/common/shared/Defs-javadoc.gmk | 71 - jdk/makefiles/common/shared/Defs-linux.gmk | 213 - jdk/makefiles/common/shared/Defs-macosx.gmk | 252 - jdk/makefiles/common/shared/Defs-solaris.gmk | 239 - jdk/makefiles/common/shared/Defs-versions.gmk | 215 - jdk/makefiles/common/shared/Defs-windows.gmk | 696 --- jdk/makefiles/common/shared/Defs.gmk | 662 --- jdk/makefiles/common/shared/Platform.gmk | 526 -- .../common/shared/PrivateDefs.gmk-example | 19 - .../common/shared/Sanity-Settings.gmk | 267 - jdk/makefiles/java/Makefile | 58 - jdk/makefiles/java/invoke/Makefile | 42 - jdk/makefiles/java/redist/Makefile | 497 -- jdk/makefiles/java/redist/sajdi/Makefile | 116 - jdk/makefiles/javax/crypto/Defs-jce.gmk | 105 - jdk/makefiles/javax/crypto/Makefile | 484 -- .../javax/crypto/policy/limited/LIMITED | 1 - .../policy/limited/default_local.policy | 14 - .../crypto/policy/limited/exempt_local.policy | 13 - .../javax/crypto/policy/unlimited/UNLIMITED | 1 - .../policy/unlimited/default_US_export.policy | 5 - .../policy/unlimited/default_local.policy | 5 - jdk/makefiles/mapfiles/libjava/mapfile-vers | 1 - jdk/makefiles/mapfiles/libjfr/mapfile-vers | 58 +- jdk/makefiles/mapfiles/libnio/mapfile-linux | 3 +- jdk/makefiles/mapfiles/libnio/mapfile-solaris | 17 +- jdk/makefiles/mkdemo/Makefile | 68 - jdk/makefiles/mkdemo/jni/Makefile | 44 - jdk/makefiles/mkdemo/jni/Poller/Makefile | 45 - jdk/makefiles/mkdemo/jvmti/Makefile | 51 - jdk/makefiles/mkdemo/jvmti/README.txt | 58 - jdk/makefiles/mkdemo/jvmti/hprof/Makefile | 52 - jdk/makefiles/mkdemo/jvmti/mapfile-vers | 34 - jdk/makefiles/mkdemo/management/README.txt | 57 - jdk/makefiles/sun/jkernel/Makefile | 94 - jdk/makefiles/sun/security/ec/Makefile | 333 -- jdk/makefiles/sun/security/pkcs11/FILES_c.gmk | 41 - jdk/makefiles/sun/security/pkcs11/Makefile | 313 -- .../sun/security/pkcs11/mapfile-vers | 110 - 97 files changed, 3245 insertions(+), 17031 deletions(-) create mode 100644 jdk/makefiles/GensrcJObjC.gmk create mode 100644 jdk/makefiles/Import.gmk delete mode 100644 jdk/makefiles/LegacyMakefiles.gmk delete mode 100644 jdk/makefiles/OldImages.gmk delete mode 100644 jdk/makefiles/com/sun/crypto/provider/Makefile delete mode 100644 jdk/makefiles/common/Classes.gmk delete mode 100644 jdk/makefiles/common/Cscope.gmk delete mode 100644 jdk/makefiles/common/Defs-embedded.gmk delete mode 100644 jdk/makefiles/common/Defs-linux.gmk delete mode 100644 jdk/makefiles/common/Defs-macosx.gmk delete mode 100644 jdk/makefiles/common/Defs-solaris.gmk delete mode 100644 jdk/makefiles/common/Defs-windows.gmk delete mode 100644 jdk/makefiles/common/Defs.gmk delete mode 100644 jdk/makefiles/common/Demo.gmk delete mode 100644 jdk/makefiles/common/Library.gmk delete mode 100644 jdk/makefiles/common/Mapfile-vers.gmk delete mode 100644 jdk/makefiles/common/Modules.gmk delete mode 100644 jdk/makefiles/common/Program.gmk delete mode 100644 jdk/makefiles/common/Release-embedded.gmk delete mode 100644 jdk/makefiles/common/Release-macosx.gmk delete mode 100644 jdk/makefiles/common/Release.gmk delete mode 100644 jdk/makefiles/common/Rules.gmk delete mode 100644 jdk/makefiles/common/Subdirs.gmk delete mode 100644 jdk/makefiles/common/internal/Defs-corba.gmk delete mode 100644 jdk/makefiles/common/internal/Defs-jaxp.gmk delete mode 100644 jdk/makefiles/common/internal/Defs-jaxws.gmk delete mode 100644 jdk/makefiles/common/internal/Defs-langtools.gmk delete mode 100644 jdk/makefiles/common/internal/ImportComponents.gmk delete mode 100644 jdk/makefiles/common/internal/NativeCompileRules.gmk delete mode 100644 jdk/makefiles/common/internal/Resources.gmk delete mode 100644 jdk/makefiles/common/shared/Compiler-gcc.gmk delete mode 100644 jdk/makefiles/common/shared/Compiler-llvm.gmk delete mode 100644 jdk/makefiles/common/shared/Compiler-msvc.gmk delete mode 100644 jdk/makefiles/common/shared/Compiler-sun.gmk delete mode 100644 jdk/makefiles/common/shared/Defs-control.gmk delete mode 100644 jdk/makefiles/common/shared/Defs-java.gmk delete mode 100644 jdk/makefiles/common/shared/Defs-javadoc.gmk delete mode 100644 jdk/makefiles/common/shared/Defs-linux.gmk delete mode 100644 jdk/makefiles/common/shared/Defs-macosx.gmk delete mode 100644 jdk/makefiles/common/shared/Defs-solaris.gmk delete mode 100644 jdk/makefiles/common/shared/Defs-versions.gmk delete mode 100644 jdk/makefiles/common/shared/Defs-windows.gmk delete mode 100644 jdk/makefiles/common/shared/Defs.gmk delete mode 100644 jdk/makefiles/common/shared/Platform.gmk delete mode 100644 jdk/makefiles/common/shared/PrivateDefs.gmk-example delete mode 100644 jdk/makefiles/common/shared/Sanity-Settings.gmk delete mode 100644 jdk/makefiles/java/Makefile delete mode 100644 jdk/makefiles/java/invoke/Makefile delete mode 100644 jdk/makefiles/java/redist/Makefile delete mode 100644 jdk/makefiles/java/redist/sajdi/Makefile delete mode 100644 jdk/makefiles/javax/crypto/Defs-jce.gmk delete mode 100644 jdk/makefiles/javax/crypto/Makefile delete mode 100644 jdk/makefiles/javax/crypto/policy/limited/LIMITED delete mode 100644 jdk/makefiles/javax/crypto/policy/limited/default_local.policy delete mode 100644 jdk/makefiles/javax/crypto/policy/limited/exempt_local.policy delete mode 100644 jdk/makefiles/javax/crypto/policy/unlimited/UNLIMITED delete mode 100644 jdk/makefiles/javax/crypto/policy/unlimited/default_US_export.policy delete mode 100644 jdk/makefiles/javax/crypto/policy/unlimited/default_local.policy delete mode 100644 jdk/makefiles/mkdemo/Makefile delete mode 100644 jdk/makefiles/mkdemo/jni/Makefile delete mode 100644 jdk/makefiles/mkdemo/jni/Poller/Makefile delete mode 100644 jdk/makefiles/mkdemo/jvmti/Makefile delete mode 100644 jdk/makefiles/mkdemo/jvmti/README.txt delete mode 100644 jdk/makefiles/mkdemo/jvmti/hprof/Makefile delete mode 100644 jdk/makefiles/mkdemo/jvmti/mapfile-vers delete mode 100644 jdk/makefiles/mkdemo/management/README.txt delete mode 100644 jdk/makefiles/sun/jkernel/Makefile delete mode 100644 jdk/makefiles/sun/security/ec/Makefile delete mode 100644 jdk/makefiles/sun/security/pkcs11/FILES_c.gmk delete mode 100644 jdk/makefiles/sun/security/pkcs11/Makefile delete mode 100644 jdk/makefiles/sun/security/pkcs11/mapfile-vers diff --git a/jdk/makefiles/CompileDemos.gmk b/jdk/makefiles/CompileDemos.gmk index 4a11f38795e..beda0452992 100644 --- a/jdk/makefiles/CompileDemos.gmk +++ b/jdk/makefiles/CompileDemos.gmk @@ -215,7 +215,7 @@ define SetupJVMTIDemo # Param 5 = libs for posix # Param 6 = libs for winapi # Param 7 = libs for solaris - BUILD_DEMO_JVMTI_$1_EXTRA_SRC:= $$(wildcard $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/demo/jvmti/$1) \ + BUILD_DEMO_JVMTI_$1_EXTRA_SRC:= $$(wildcard $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/demo/jvmti/$1) \ $$(wildcard $$(addprefix $(JDK_TOPDIR)/src/share/demo/jvmti/,$2)) BUILD_DEMO_JVMTI_$1_EXTRA_INC:=$$(addprefix -I,$$(BUILD_DEMO_JVMTI_$1_EXTRA_SRC)) BUILD_DEMO_JVMTI_$1_LANG:=C @@ -227,18 +227,26 @@ define SetupJVMTIDemo $1_EXTRA_CXX:=$(LIBCXX) BUILD_DEMO_JVMTI_$1_O_FLAG:=$(CXX_O_FLAG_NORM) endif + + $1_CXXFLAGS:=$(CXXFLAGS_JDKLIB) $$(BUILD_DEMO_JVMTI_$1_O_FLAG) -I$(JDK_TOPDIR)/src/share/demo/jvmti/$1 $$(BUILD_DEMO_JVMTI_$1_EXTRA_INC) $3 + ifeq ($1-$(OPENJDK_TARGET_CPU_ARCH),waiters-sparc) + $1_FILTER:=-xregs=no%appl + $1_CXXFLAGS:=$$(filter-out $$($1_FILTER),$$($1_CXXFLAGS)) + endif + $$(eval $$(call SetupNativeCompilation,BUILD_DEMO_JVMTI_$1,\ SRC:=$(JDK_TOPDIR)/src/share/demo/jvmti/$1 $$(BUILD_DEMO_JVMTI_$1_EXTRA_SRC),\ LANG:=$$(BUILD_DEMO_JVMTI_$1_LANG),\ CFLAGS:=$(CFLAGS_JDKLIB) $$(BUILD_DEMO_JVMTI_$1_O_FLAG) -I$(JDK_TOPDIR)/src/share/demo/jvmti/$1 $$(BUILD_DEMO_JVMTI_$1_EXTRA_INC) $3,\ - CXXFLAGS:=$(CXXFLAGS_JDKLIB) $$(BUILD_DEMO_JVMTI_$1_O_FLAG) -I$(JDK_TOPDIR)/src/share/demo/jvmti/$1 $$(BUILD_DEMO_JVMTI_$1_EXTRA_INC) $3,\ + CXXFLAGS:=$$($1_CXXFLAGS),\ LDFLAGS:=$(LDFLAGS_JDKLIB),\ LDFLAGS_SUFFIX:=$$($1_EXTRA_CXX),\ LDFLAGS_SUFFIX_posix:=$5,\ LDFLAGS_SUFFIX_winapi:=$6,\ LDFLAGS_SUFFIX_solaris:=-lc $7,\ - BIN:=$(JDK_OUTPUTDIR)/newdemoobjs/jvmti/$1,\ - LIB:=$(JDK_OUTPUTDIR)/newdemo/jvmti/$1/lib/$(LIBRARY_PREFIX)$1$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/newdemoobjs/jvmti/$1,\ + OUTPUT_DIR:=$(JDK_OUTPUTDIR)/newdemo/jvmti/$1/lib,\ + LIBRARY:=$1)) $$(eval $$(call SetupZipArchive,BUILD_DEMO_JVMTI_SRC_$1,\ SRC:=$(JDK_TOPDIR)/src/share/demo/jvmti/$1 $$(BUILD_DEMO_JVMTI_$1_EXTRA_SRC),\ @@ -262,7 +270,7 @@ define SetupJVMTIDemo BUILD_DEMOS += $(JDK_OUTPUTDIR)/newdemo/jvmti/$1/$1.jar endif - BUILD_DEMOS += $(JDK_OUTPUTDIR)/newdemo/jvmti/$1/lib/$(LIBRARY_PREFIX)$1$(SHARED_LIBRARY_SUFFIX) \ + BUILD_DEMOS += $$(BUILD_DEMO_JVMTI_$1) \ $(JDK_OUTPUTDIR)/newdemo/jvmti/$1/src.zip \ $(JDK_OUTPUTDIR)/newdemo/jvmti/$1/README.txt endef @@ -274,7 +282,7 @@ $(eval $(call SetupJVMTIDemo,heapViewer, agent_util)) # hprof contains error messages using __FILE__ macro. These expand to the absolute path # in the new build system and relative in the old, causing the binaries to differ. $(eval $(call SetupJVMTIDemo,hprof, java_crw_demo,\ - -I$(JDK_TOPDIR)/src/share/npt -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/npt,C,\ + -I$(JDK_TOPDIR)/src/share/npt -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/npt,C,\ -ldl,ws2_32.lib winmm.lib,-lsocket -lnsl)) $(eval $(call SetupJVMTIDemo,minst, agent_util java_crw_demo)) @@ -349,7 +357,7 @@ BUILD_DEMOS += $(JDK_OUTPUTDIR)/newdemo/README ################################################################################################## -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) $(JDK_OUTPUTDIR)/newdemoclasses/jni/Poller/% : $(JDK_TOPDIR)/src/solaris/demo/jni/Poller/% $(MKDIR) -p $(@D) @@ -386,8 +394,9 @@ $(eval $(call SetupNativeCompilation,BUILD_LIBPOLLER,\ CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ -I$(JDK_OUTPUTDIR)/newdemoclasses/jni/Poller, \ LDFLAGS:=$(LDFLAGS_JDKLIB), \ - BIN:=$(JDK_OUTPUTDIR)/newdemoobjs/jni/Poller,\ - LIB:=$(JDK_OUTPUTDIR)/newdemoobjs/$(LIBRARY_PREFIX)Poller$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/newdemoobjs/jni/Poller,\ + OUTPUT_DIR:=$(JDK_OUTPUTDIR)/newdemoobjs, \ + LIBRARY:=Poller)) # # We can only compile native code after jar has been build (since we depend on generated .h files) diff --git a/jdk/makefiles/CompileJavaClasses.gmk b/jdk/makefiles/CompileJavaClasses.gmk index cd676e289b6..da8f4468fab 100644 --- a/jdk/makefiles/CompileJavaClasses.gmk +++ b/jdk/makefiles/CompileJavaClasses.gmk @@ -45,7 +45,7 @@ EXCLUDES += com/sun/pept \ com/sun/tools/example/debug/gui \ com/oracle/security -ifeq ($(PLATFORM)-$(ARCH_DATA_MODEL),windows-64) +ifeq ($(OPENJDK_TARGET_OS)-$(ARCH_DATA_MODEL),windows-64) EXCLUDES += sun/security/pkcs11 endif @@ -61,7 +61,7 @@ ifndef OPENJDK EXFILES := $(JDK_TOPDIR)/src/share/classes/javax/crypto/JarVerifier.java endif -ifneq ($(PLATFORM),solaris) +ifneq ($(OPENJDK_TARGET_OS),solaris) # Exclude Solaris nio and two security related files in src/share/classes EXFILES += SolarisAclFileAttributeView.java \ SolarisFileStore.java \ @@ -71,37 +71,34 @@ ifneq ($(PLATFORM),solaris) SolarisUserDefinedFileAttributeView.java \ SolarisWatchService.java \ SolarisAclFileAttributeView.java \ - SolarisFileStore.java \ - SolarisFileSystem.java \ - SolarisFileSystemProvider.java \ - SolarisUserDefinedFileAttributeView.java \ - SolarisNativeDispatcher.java \ - SolarisWatchService.java \ SolarisLoginModule.java \ SolarisSystem.java \ + sun/nio/ch/EventPortSelectorImpl.java \ + sun/nio/ch/EventPortSelectorProvider.java \ + sun/nio/ch/EventPortWrapper.java \ sun/tools/attach/SolarisAttachProvider.java \ sun/tools/attach/SolarisVirtualMachine.java endif # In the old build, this isn't excluded on macosx, even though it probably # should be. -ifneq ($(PLATFORM),macosx) +ifneq ($(OPENJDK_TARGET_OS),macosx) EXFILES+=WrapperGenerator.java endif -ifneq ($(PLATFORM),windows) +ifneq ($(OPENJDK_TARGET_OS),windows) # Exclude Window security related files in src/share/classes EXFILES+=NTLoginModule.java \ NTSystem.java endif -ifeq ($(PLATFORM),windows) +ifeq ($(OPENJDK_TARGET_OS),windows) # Don't build GTK L&F on Windows EXCLUDES+= com/sun/java/swing/plaf/gtk endif -ifneq ($(PLATFORM),linux) +ifneq ($(OPENJDK_TARGET_OS),linux) EXFILES+=sun/tools/attach/LinuxAttachProvider.java \ sun/tools/attach/LinuxVirtualMachine.java \ sun/nio/fs/LinuxDosFileAttributeView.java \ @@ -113,7 +110,7 @@ ifneq ($(PLATFORM),linux) sun/nio/fs/LinuxWatchService.java endif -ifneq ($(PLATFORM),macosx) +ifneq ($(OPENJDK_TARGET_OS),macosx) EXFILES+=sun/nio/fs/BsdFileStore.java \ sun/nio/fs/BsdFileSystem.java \ sun/nio/fs/BsdFileSystemProvider.java \ @@ -137,11 +134,11 @@ ifdef OPENJDK endif # Used on windows and macosx -ifeq (,$(filter $(PLATFORM), windows macosx)) +ifeq (,$(filter $(OPENJDK_TARGET_OS), windows macosx)) EXFILES+=sun/awt/AWTCharset.java endif -ifneq ($(PLATFORM), macosx) +ifneq ($(OPENJDK_TARGET_OS), macosx) # # Not in rt.jar on solaris and linux...(windows not checked) # in rt.jar on macosx ?? @@ -192,7 +189,7 @@ endif # Exclude another implicitly not included file. EXFILES+=sun/util/locale/AsciiUtil.java -ifeq (,$(filter $(PLATFORM), solaris macosx)) +ifeq (,$(filter $(OPENJDK_TARGET_OS), solaris macosx)) # # only solaris and macosx # @@ -205,7 +202,7 @@ EXFILES+=-linux-arm.java \ -linux-ppc.java # TODO: Is this necessary? -ifeq ($(PLATFORM), windows) +ifeq ($(OPENJDK_TARGET_OS), windows) EXFILES+=sun/nio/ch/AbstractPollSelectorImpl.java \ sun/nio/ch/DevPollArrayWrapper.java \ sun/nio/ch/DevPollSelectorImpl.java \ @@ -248,18 +245,24 @@ include CopyIntoClasses.gmk ifndef OPENJDK CLOSED_SRC_DIRS:=$(JDK_TOPDIR)/src/closed/share/classes \ - $(JDK_TOPDIR)/src/closed/$(LEGACY_HOST_OS_API)/classes + $(JDK_TOPDIR)/src/closed/$(LEGACY_OPENJDK_TARGET_OS_API)/classes endif MACOSX_SRC_DIRS := -ifeq ($(PLATFORM),macosx) +ifeq ($(OPENJDK_TARGET_OS),macosx) MACOSX_SRC_DIRS += $(JDK_TOPDIR)/src/macosx/classes # this files are duplicated in MACOSX_SRC_DIRS EXFILES+= $(JDK_TOPDIR)/src/solaris/classes/sun/nio/ch/DefaultSelectorProvider.java \ $(JDK_TOPDIR)/src/solaris/classes/sun/java2d/BackBufferCapsProvider.java \ $(JDK_TOPDIR)/src/solaris/classes/java/net/DefaultInterface.java \ - $(JDK_TOPDIR)/src/solaris/classes/java/lang/ClassLoaderHelper.java + $(JDK_TOPDIR)/src/solaris/classes/java/lang/ClassLoaderHelper.java + + # JObjC.jar contains 1.5 byte-code...so skip it here :-( + # MACOSX_SRC_DIRS += $(JDK_TOPDIR)/src/macosx/native/jobjc/src + # EXCLUDES+= tests/java/com/apple/jobjc + + EXCLUDES+= com/apple/jobjc endif # The exception handling of swing beaninfo @@ -272,7 +275,7 @@ $(JDK_OUTPUTDIR)/classes/javax/swing/beaninfo/images/%.gif: $(JDK_TOPDIR)/make/t $(eval $(call SetupJavaCompilation,BUILD_JDK,\ SETUP:=GENERATE_JDKBYTECODE,\ SRC:=$(JDK_TOPDIR)/src/share/classes \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes \ $(MACOSX_SRC_DIRS) \ $(JDK_OUTPUTDIR)/gensrc \ $(JDK_OUTPUTDIR)/gensrc_swing/javax/swing/beaninfo \ @@ -297,7 +300,7 @@ JDK_BASE_HEADER_CLASSES:=java.lang.Integer \ JDK_BASE_HEADER_JAVA_FILES:=$(patsubst %,$(JDK_TOPDIR)/src/share/classes/%.java,\ $(subst .,/,$(JDK_BASE_HEADER_CLASSES))) -ifeq ($(PLATFORM),windows) +ifeq ($(OPENJDK_TARGET_OS),windows) JDK_BASE_HEADER_CLASSES_WINDOWS:=sun.nio.ch.PollArrayWrapper JDK_BASE_HEADER_CLASSES+=$(JDK_BASE_HEADER_CLASSES_WINDOWS) JDK_BASE_HEADER_JAVA_FILES+=$(patsubst %,$(JDK_TOPDIR)/src/windows/classes/%.java,\ @@ -348,6 +351,53 @@ $(JDK_OUTPUTDIR)/classes/META-INF/services/com.sun.tools.xjc.Plugin: ########################################################################################## +ifeq ($(OPENJDK_TARGET_OS),macosx) +# +# JObjC.jar is compiled with BOOT_JAVAC which (may) not support the "-h" flag. +# so we first compile classes with BOOT_JAVAC and then with JDK_JAVAC :-( +# +$(eval $(call SetupJavaCompiler,GENERATE_15BYTECODE,\ + JAVAC:=$(JAVAC),\ + FLAGS:=-source 1.5 -target 1.5 -g -bootclasspath $(BOOT_RTJAR) -cp $(JDK_OUTPUTDIR)/../langtools/dist/lib/classes.jar $(DISABLE_WARNINGS),\ + SERVER_DIR:=$(JAVAC_SERVERS),\ + SERVER_JVM:=$(SERVER_JAVA),\ + MODE:=$(JAVAC_USE_MODE),\ + USE_DEPS:=$(JAVAC_USE_DEPS))) + +$(eval $(call SetupJavaCompilation,BUILD_JOBJC_JAR,\ + SETUP:=GENERATE_15BYTECODE,\ + SRC:=$(JDK_TOPDIR)/src/macosx/native/jobjc/src/core/java \ + $(JDK_TOPDIR)/src/macosx/native/jobjc/src/runtime-additions/java \ + $(JDK_OUTPUTDIR)/gensrc, \ + INCLUDES := com/apple/jobjc,\ + EXCLUDES := tests/java/com/apple/jobjc,\ + BIN:=$(JDK_OUTPUTDIR)/jobjc_classes,\ + JAR:=$(JDK_OUTPUTDIR)/lib/JObjC.jar, \ + JARINDEX := true)) + +$(BUILD_JOBJC_JAR) : $(BUILD_JDK) + +JARS += $(JDK_OUTPUTDIR)/lib/JObjC.jar + +$(eval $(call SetupJavaCompilation,BUILD_JOBJC_HEADERS_JAR,\ + SETUP:=GENERATE_JDKBYTECODE,\ + SRC:=$(JDK_TOPDIR)/src/macosx/native/jobjc/src/core/java \ + $(JDK_TOPDIR)/src/macosx/native/jobjc/src/runtime-additions/java \ + $(JDK_OUTPUTDIR)/gensrc, \ + INCLUDES := com/apple/jobjc,\ + EXCLUDES := tests/java/com/apple/jobjc,\ + BIN:=$(JDK_OUTPUTDIR)/jobjc_classes_headers,\ + JAR:=$(JDK_OUTPUTDIR)/jobjc_classes_headers/dummy.jar, \ + HEADERS:=$(JDK_OUTPUTDIR)/gensrc_headers)) + +$(BUILD_JOBJC_HEADERS_JAR) : $(BUILD_JDK) + +JARS += $(JDK_OUTPUTDIR)/jobjc_classes_headers/dummy.jar + +endif + +########################################################################################## + # copy with -a to preserve timestamps so dependencies down the line aren't messed up all: $(BUILD_JDK) $(JARS) $(COPY_EXTRA) $(JDK_OUTPUTDIR)/classes/META-INF/services/com.sun.tools.xjc.Plugin \ $(JDK_OUTPUTDIR)/classes/_the.jdk.base.headers diff --git a/jdk/makefiles/CompileLaunchers.gmk b/jdk/makefiles/CompileLaunchers.gmk index bb6ef245e62..2b79e5907d3 100644 --- a/jdk/makefiles/CompileLaunchers.gmk +++ b/jdk/makefiles/CompileLaunchers.gmk @@ -32,17 +32,25 @@ include NativeCompilation.gmk # Setup the java compilers for the JDK build. include Setup.gmk +# Build tools +include Tools.gmk + BUILD_LAUNCHERS= define SetupLauncher # TODO: Fix mapfile on solaris. Won't work with ld as linker. # Parameter 1 is the name of the launcher (java,javac,jar...) - # Parameter 2 are extra CFLAGS - # Parameter 3 are extra LDFLAGS - # Parameter 4 are extra LDFLAGS_SUFFIX_posix - # Parameter 5 are extra LDFLAGS_SUFFIX_winapi + # Parameter 2 is extra CFLAGS + # Parameter 3 is extra LDFLAGS + # Parameter 4 is extra LDFLAGS_SUFFIX_posix + # Parameter 5 is extra LDFLAGS_SUFFIX_winapi + # Parameter 6 is optional Windows JLI library (full path) + # Parameter 7 is optional Windows resource (RC) flags + # Parameter 8 is optional Windows version resource file (.rc) + # Parameter 9 is different output dir + # Parameter 10 is FULL DEBUG SYMBOLS (set value to turn OFF, since most(all) seems to have it) - $1_WINDOWS_JLI_LIB:=$(JDK_OUTPUTDIR)/objs/jli.lib + $1_WINDOWS_JLI_LIB:=$(JDK_OUTPUTDIR)/objs/libjli/jli.lib ifneq ($6,) $1_WINDOWS_JLI_LIB:=$6 endif @@ -51,33 +59,73 @@ define SetupLauncher $1_VERSION_INFO_RESOURCE:=$8 endif + $1_LDFLAGS := $3 + ifeq ($(OPENJDK_TARGET_OS), macosx) + $1_LDFLAGS += -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ + -F/System/Library/Frameworks/ApplicationServices.framework/Frameworks + endif + + $1_LDFLAGS_SUFFIX := + ifeq ($(USE_EXTERNAL_LIBZ), true) + $1_LDFLAGS_SUFFIX += -lz + endif + + ifeq ($(OPENJDK_TARGET_OS), macosx) + $1_LDFLAGS_SUFFIX += -Wl,-all_load $(JDK_OUTPUTDIR)/objs/libjli_static.a \ + -framework Cocoa -framework Security -framework ApplicationServices \ + -sectcreate __TEXT __info_plist $(JDK_TOPDIR)/src/macosx/lib/Info-cmdline.plist + endif + + + $1_OUTPUT_DIR_ARG:=$9 + ifeq (,$$($1_OUTPUT_DIR_ARG)) + $1_OUTPUT_DIR_ARG:=$(JDK_OUTPUTDIR)/bin + endif + + $1_DEBUG_SYMBOLS:=yes + ifneq (,$(10)) + $1_DEBUG_SYMBOLS:= + endif + + $1_OPTIMIZATION:= LOW + + # TODO: maybe it's better to move this if-statement out of this function + ifeq ($(1),java) + $1_OPTIMIZATION:=HIGH + endif + $(call SetupNativeCompilation,BUILD_LAUNCHER_$1,\ SRC:=$(JDK_TOPDIR)/src/share/bin,\ INCLUDE_FILES:=main.c,\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKEXE) $(C_O_FLAG_NORM) \ + OPTIMIZATION :=$$($1_OPTIMIZATION), \ + CFLAGS:=$(CFLAGS_JDKEXE) \ -I$(JDK_TOPDIR)/src/share/bin \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/bin \ - -I$(JDK_TOPDIR)/src/$(PLATFORM)/bin \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/bin \ + -I$(JDK_TOPDIR)/src/$(OPENJDK_TARGET_OS)/bin \ -DFULL_VERSION='"$(FULL_VERSION)"' \ -DJDK_MAJOR_VERSION='"$(JDK_MAJOR_VERSION)"' \ -DJDK_MINOR_VERSION='"$(JDK_MINOR_VERSION)"' \ -DLIBARCHNAME='"$(ARCH)"' \ - -DLAUNCHER_NAME='"openjdk"' \ + -DLAUNCHER_NAME='"java"' \ -DPROGNAME='"$1"' $(DPACKAGEPATH) \ $2,\ CFLAGS_linux:=-fPIC,\ + CFLAGS_solaris:=-KPIC -DHAVE_GETHRTIME,\ LDFLAGS:=$(LDFLAGS_JDKEXE) \ $(call SET_SHARED_LIBRARY_ORIGIN,../lib/$(LIBARCH)/jli) \ $(call SET_SHARED_LIBRARY_ORIGIN,../jre/lib/$(LIBARCH)/jli) \ - $3,\ + $$($1_LDFLAGS),\ MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/launchers/mapfile-$(ARCH), \ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKEXE_SUFFIX),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKEXE_SUFFIX) $$($1_LDFLAGS_SUFFIX),\ LDFLAGS_SUFFIX_posix:=$4 -lc,\ LDFLAGS_SUFFIX_winapi:=$$($1_WINDOWS_JLI_LIB) \ - $(JDK_OUTPUTDIR)/objs/java.lib advapi32.lib $5,\ - BIN:=$(JDK_OUTPUTDIR)/objs/$1_objs,\ - EXE:=$(JDK_OUTPUTDIR)/objs/$1$(EXE_SUFFIX),\ + $(JDK_OUTPUTDIR)/objs/libjava/java.lib advapi32.lib $5,\ + LDFLAGS_SUFFIX_solaris := -lthread $(LIBDL), \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/$1_objs,\ + OUTPUT_DIR:=$$($1_OUTPUT_DIR_ARG),\ + PROGRAM:=$1,\ + DEBUG_SYMBOLS:=$$($1_DEBUG_SYMBOLS),\ VERSIONINFO_RESOURCE:=$$($1_VERSION_INFO_RESOURCE),\ RC_FLAGS:=$(RC_FLAGS)\ /D "JDK_FNAME=$1$(EXE_SUFFIX)" \ @@ -86,13 +134,22 @@ define SetupLauncher $7,\ MANIFEST:=$(JDK_TOPDIR)/src/windows/resource/java.manifest) - BUILD_LAUNCHERS += $(JDK_OUTPUTDIR)/bin/$1$(EXE_SUFFIX) + BUILD_LAUNCHERS += $$(BUILD_LAUNCHER_$1) + + ifeq ($(OPENJDK_TARGET_OS),macosx) + $$(BUILD_LAUNCHER_$1) : $(JDK_OUTPUTDIR)/objs/libjli_static.a + endif + + ifeq ($(OPENJDK_TARGET_OS),windows) + $$(BUILD_LAUNCHER_$1) : $(JDK_OUTPUTDIR)/objs/libjava/java.lib \ + $$($1_WINDOWS_JLI_LIB) + endif endef ########################################################################################## -XLIBS:=-lX11 -ifeq ($(PLATFORM),macosx) +XLIBS:=$(X_LIBS) -lX11 +ifeq ($(OPENJDK_TARGET_OS),macosx) DPACKAGEPATH:=-DPACKAGE_PATH='"$(PACKAGE_PATH)"' XLIBS:= endif @@ -108,17 +165,17 @@ $(eval $(call SetupLauncher,java,\ $(JDK_OUTPUTDIR)/objs/jli_static.lib,$(JAVA_RC_FLAGS),\ $(JDK_TOPDIR)/src/windows/resource/java.rc)) -ifeq ($(HOST_OS),windows) +ifeq ($(OPENJDK_TARGET_OS),windows) $(eval $(call SetupLauncher,javaw,\ -DEXPAND_CLASSPATH_WILDCARDS,,,user32.lib comctl32.lib,\ $(JDK_OUTPUTDIR)/objs/jli_static.lib,$(JAVA_RC_FLAGS),\ $(JDK_TOPDIR)/src/windows/resource/java.rc)) endif -ifeq ($(PLATFORM),solaris) +ifeq ($(OPENJDK_TARGET_OS),solaris) THREAD_LIB:=-lthread endif -ifeq ($(PLATFORM),linux) +ifeq ($(OPENJDK_TARGET_OS),linux) THREAD_LIB:=-lpthread endif @@ -271,7 +328,7 @@ $(eval $(call SetupLauncher,rmiregistry,\ $(eval $(call SetupLauncher,jcmd,\ -DJAVA_ARGS='{ "-J-ms8m"$(COMMA) "sun.tools.jcmd.JCmd"$(COMMA) }')) -ifeq ($(PLATFORM),windows) +ifeq ($(OPENJDK_TARGET_OS),windows) $(eval $(call SetupLauncher,kinit,\ -DJAVA_ARGS='{ "-J-ms8m"$(COMMA) "sun.security.krb5.internal.tools.Kinit"$(COMMA) }')) @@ -286,8 +343,10 @@ endif # The order of the object files on the link command line affects the size of the resulting # binary (at least on linux) which causes the size to differ between old and new build. ifeq ($(USE_EXTERNAL_LIBZ), true) +UNPACKEXE_CFLAGS := -DSYSTEM_ZLIB UNPACKEXE_ZIPOBJS := -lz else +UNPACKEXE_CFLAGS := -I$(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5 UNPACKEXE_ZIPOBJS := $(JDK_OUTPUTDIR)/objs/libzip/zcrc32$(OBJ_SUFFIX) \ $(JDK_OUTPUTDIR)/objs/libzip/deflate$(OBJ_SUFFIX) \ $(JDK_OUTPUTDIR)/objs/libzip/trees$(OBJ_SUFFIX) \ @@ -299,27 +358,31 @@ UNPACKEXE_ZIPOBJS := $(JDK_OUTPUTDIR)/objs/libzip/zcrc32$(OBJ_SUFFIX) \ $(JDK_OUTPUTDIR)/objs/libzip/inftrees$(OBJ_SUFFIX) \ $(JDK_OUTPUTDIR)/objs/libzip/inffast$(OBJ_SUFFIX) +endif -$(JDK_OUTPUTDIR)/bin/unpack200$(EXE_SUFFIX): $(UNPACKEXE_ZIPOBJS) - +ifeq ($(OPENJDK_TARGET_CPU_ARCH), sparc) + UNPACKEXE_CFLAGS += -xregs=no%appl endif $(eval $(call SetupNativeCompilation,BUILD_UNPACKEXE,\ SRC:=$(JDK_TOPDIR)/src/share/native/com/sun/java/util/jar/pack,\ EXCLUDE_FILES:=jni.cpp,\ LANG:=C,\ - CFLAGS:=$(CXXFLAGS_JDKEXE) $(CXX_O_FLAG_NORM) \ - -DFULL \ - -I$(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5,\ + OPTIMIZATION := LOW, \ + CFLAGS:=$(UNPACKEXE_CFLAGS) $(CXXFLAGS_JDKEXE)\ + -DFULL, \ CFLAGS_release:=-DPRODUCT,\ CFLAGS_linux:=-fPIC,\ + CFLAGS_solaris := -KPIC, \ + CFLAGS_macosx := -fPIC, \ MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libunpack/mapfile-vers-unpack200, \ LDFLAGS:=$(LDFLAGS_JDKEXE) \ $(call SET_SHARED_LIBRARY_ORIGIN), \ LDFLAGS_SUFFIX:=$(UNPACKEXE_ZIPOBJS) $(LIBCXX),\ LDFLAGS_SUFFIX_solaris:=-lc,\ - BIN:=$(JDK_OUTPUTDIR)/objs/unpackexe,\ - EXE:=$(JDK_OUTPUTDIR)/objs/unpack200$(EXE_SUFFIX),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/unpackexe,\ + OUTPUT_DIR:=$(JDK_OUTPUTDIR)/bin,\ + PROGRAM:=unpack200,\ VERSIONINFO_RESOURCE:=$(JDK_TOPDIR)/src/windows/resource/version.rc,\ RC_FLAGS:=$(RC_FLAGS)\ /D "JDK_FNAME=unpack200.exe" \ @@ -327,7 +390,13 @@ $(eval $(call SetupNativeCompilation,BUILD_UNPACKEXE,\ /D "JDK_FTYPE=0x1L",\ MANIFEST:=$(JDK_TOPDIR)/src/windows/resource/unpack200_proto.exe.manifest)) -BUILD_LAUNCHERS += $(JDK_OUTPUTDIR)/bin/unpack200$(EXE_SUFFIX) +ifneq ($(USE_EXTERNAL_LIBZ), true) + +$(BUILD_UNPACKEXE) : $(UNPACKEXE_ZIPOBJS) + +endif + +BUILD_LAUNCHERS += $(BUILD_UNPACKEXE) ########################################################################################## @@ -335,7 +404,7 @@ BUILD_LAUNCHERS += $(JDK_OUTPUTDIR)/bin/unpack200$(EXE_SUFFIX) BUILD_JEXEC := BUILD_JEXEC_SRC := BUILD_JEXEC_INC := -BUILD_JEXEC_DST := $(JDK_OUTPUTDIR)/lib/$(LIBARCH)/jexec$(EXE_SUFFIX) +BUILD_JEXEC_DST_DIR := $(JDK_OUTPUTDIR)/lib/$(LIBARCH) # # UNHANDLED: @@ -345,30 +414,30 @@ BUILD_JEXEC_DST := $(JDK_OUTPUTDIR)/lib/$(LIBARCH)/jexec$(EXE_SUFFIX) # # jdk/make/java/Makefile # -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) ifeq ($(ARCH_DATA_MODEL), 32) BUILD_JEXEC := 1 endif endif -ifeq ($(PLATFORM), linux) +ifeq ($(OPENJDK_TARGET_OS), linux) BUILD_JEXEC := 1 -endif # PLATFORM +endif # OPENJDK_TARGET_OS # # jdk/make/java/jexec/Makefile # ifeq ($(BUILD_JEXEC), 1) - ifeq ($(PLATFORM),windows) - else ifeq ($(PLATFORM),macosx) + ifeq ($(OPENJDK_TARGET_OS),windows) + else ifeq ($(OPENJDK_TARGET_OS),macosx) BUILD_JEXEC_SRC := $(JDK_TOPDIR)/src/macosx/bin else BUILD_JEXEC_SRC := $(JDK_TOPDIR)/src/solaris/bin endif - ifeq ($(PLATFORM), linux) - BUILD_JEXEC_DST := $(JDK_OUTPUTDIR)/lib/jexec$(EXE_SUFFIX) + ifeq ($(OPENJDK_TARGET_OS), linux) + BUILD_JEXEC_DST_DIR := $(JDK_OUTPUTDIR)/lib BUILD_JEXEC_INC += -I$(JDK_TOPDIR)/src/share/bin endif endif @@ -382,13 +451,15 @@ ifneq ($(BUILD_JEXEC_SRC),) SRC:=$(BUILD_JEXEC_SRC),\ INCLUDE_FILES:=jexec.c,\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKEXE) $(C_O_FLAG_NORM) \ + OPTIMIZATION := LOW, \ + CFLAGS:=$(CFLAGS_JDKEXE)\ $(BUILD_JEXEC_INC), \ LDFLAGS:=$(LDFLAGS_JDKEXE), \ - BIN:=$(JDK_OUTPUTDIR)/objs/jexec_obj,\ - EXE:=$(BUILD_JEXEC_DST))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/jexec_obj,\ + OUTPUT_DIR:=$(BUILD_JEXEC_DST_DIR),\ + PROGRAM:=jexec)) - BUILD_LAUNCHERS += $(BUILD_JEXEC_DST) + BUILD_LAUNCHERS += $(BUILD_JEXEC) endif ########################################################################################## @@ -397,10 +468,10 @@ endif # The java-rmi.cgi script in bin/ only gets delivered in certain situations # JAVA_RMI_CGI:=$(JDK_OUTPUTDIR)/bin/java-rmi.cgi -ifeq ($(PLATFORM), linux) +ifeq ($(OPENJDK_TARGET_OS), linux) BUILD_LAUNCHERS += $(JAVA_RMI_CGI) endif -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) ifeq ($(ARCH_DATA_MODEL), 32) BUILD_LAUNCHERS += $(JAVA_RMI_CGI) endif @@ -413,12 +484,13 @@ endif # images bin dir. This weird behavior is mimicked here in the converted makefiles for # now. Should probably just be deleted. # http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6512052 -ifeq ($(HOST_OS_API),winapi) +ifeq ($(OPENJDK_TARGET_OS_API),winapi) $(eval $(call SetupLauncher,java-rmi,\ -DEXPAND_CLASSPATH_WILDCARDS,\ - $(call SET_SHARED_LIBRARY_MAPFILE,$(JDK_TOPDIR)/makefiles/java/main/java/mapfile-$(ARCH)))) + $(call SET_SHARED_LIBRARY_MAPFILE,$(JDK_TOPDIR)/makefiles/java/main/java/mapfile-$(ARCH)),\ + ,,,,,$(JDK_OUTPUTDIR)/objs)) - $(JAVA_RMI_CGI): $(JDK_OUTPUTDIR)/objs/java-rmi$(EXE_SUFFIX) + $(JAVA_RMI_CGI): $(BUILD_LAUNCHER_java-rmi) $(MKDIR) -p $(@D) $(CP) $< $@ @@ -432,11 +504,6 @@ endif ########################################################################################## -$(JDK_OUTPUTDIR)/bin/% : $(JDK_OUTPUTDIR)/objs/% - $(ECHO) Copying $(@F) - $(MKDIR) -p $(@D) - $(CP) $< $@ - $(BUILD_LAUNCHERS) : $(JDK_TOPDIR)/makefiles/CompileLaunchers.gmk all: $(BUILD_LAUNCHERS) diff --git a/jdk/makefiles/CompileNativeLibraries.gmk b/jdk/makefiles/CompileNativeLibraries.gmk index 3851ab99eca..be523544712 100644 --- a/jdk/makefiles/CompileNativeLibraries.gmk +++ b/jdk/makefiles/CompileNativeLibraries.gmk @@ -35,13 +35,16 @@ include Setup.gmk # Copy files (can now depend on $(COPY_FILES)) include CopyFiles.gmk +# Build tools +include Tools.gmk + # Include the javah generated headers. CFLAGS_JDKLIB += -I$(JDK_OUTPUTDIR)/gensrc_headers CXXFLAGS_JDKLIB += -I$(JDK_OUTPUTDIR)/gensrc_headers -# Put the libraries here. Different locations for different host apis. -ifeq ($(HOST_OS_API),posix) - ifneq ($(HOST_OS),macosx) +# Put the libraries here. Different locations for different target apis. +ifeq ($(OPENJDK_TARGET_OS_API),posix) + ifneq ($(OPENJDK_TARGET_OS),macosx) INSTALL_LIBRARIES_HERE:=$(JDK_OUTPUTDIR)/lib/$(LIBARCH) LIBARCHDIR=$(LIBARCH)/ else @@ -52,465 +55,213 @@ else INSTALL_LIBRARIES_HERE:=$(JDK_OUTPUTDIR)/bin endif -$(INSTALL_LIBRARIES_HERE)/%$(SHARED_LIBRARY_SUFFIX) : $(JDK_OUTPUTDIR)/objs/%$(SHARED_LIBRARY_SUFFIX) - $(ECHO) Copying $(@F) - $(CP) $< $@ - BUILD_LIBRARIES= -# TODO: Temporary until awt is converted: -# OBJDIRNAME is the name of the directory where the object code is to -# be placed. It's name depends on whether the data model architecture -# is 32-bit or not. -ifneq ($(ARCH_DATA_MODEL), 32) - OBJDIRNAME = obj$(ARCH_DATA_MODEL)$(OBJDIRNAME_SUFFIX) -else - OBJDIRNAME = obj$(OBJDIRNAME_SUFFIX) -endif +# Absolute paths to lib files on windows for use in LDFLAGS. Should figure out a more +# elegant solution to this. +WIN_VERIFY_LIB := $(JDK_OUTPUTDIR)/objs/libverify/verify.lib +WIN_JAVA_LIB := $(JDK_OUTPUTDIR)/objs/libjava/java.lib +WIN_AWT_LIB := $(JDK_OUTPUTDIR)/objs/libawt/awt.lib ########################################################################################## -BUILD_LIBZIP_FILES := \ - CRC32.c \ - Adler32.c \ - Deflater.c \ - Inflater.c \ - ZipFile.c \ - zip_util.c +BUILD_LIBFDLIBM_OPTIMIZATION:=HIGH -ifeq ($(USE_EXTERNAL_LIBZ),true) - LIBZ := -lz -else -BUILD_LIBZIP_FILES += \ - compress.c \ - deflate.c \ - gzclose.c \ - gzlib.c \ - gzread.c \ - gzwrite.c \ - infback.c \ - inffast.c \ - inflate.c \ - inftrees.c \ - trees.c \ - uncompr.c \ - zadler32.c \ - zcrc32.c \ - zutil.c - LIBZ_INCLUDE := -I$(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5 +ifneq ($(OPENJDK_TARGET_OS), solaris) + BUILD_LIBFDLIBM_OPTIMIZATION:=NONE endif -$(eval $(call SetupNativeCompilation,BUILD_LIBZIP,\ - SRC:=$(JDK_TOPDIR)/src/share/native/java/util/zip \ - $(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5,\ - INCLUDE_FILES := $(BUILD_LIBZIP_FILES), \ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - $(LIBZ_INCLUDE) \ - -I$(JDK_TOPDIR)/src/share/native/java/io \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/java/io,\ - CFLAGS_posix:=-DUSE_MMAP -UDEBUG,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libzip/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(EXPORT_ZIP_FUNCS), \ - LDFLAGS_winapi:=-export:ZIP_Open -export:ZIP_Close -export:ZIP_FindEntry \ - -export:ZIP_ReadEntry -export:ZIP_GetNextEntry jvm.lib \ - java.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBZ),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libzip,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)zip$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)zip$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)zip$(SHARED_LIBRARY_SUFFIX) - -########################################################################################## - -LIBUNPACK_LIB_FILE := $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)unpack$(SHARED_LIBRARY_SUFFIX) - -$(eval $(call SetupNativeCompilation,BUILD_LIBUNPACK,\ - SRC:=$(JDK_TOPDIR)/src/share/native/com/sun/java/util/jar/pack,\ - EXCLUDE_FILES:=main.cpp,\ - LANG:=C++,\ - CFLAGS:=$(CXXFLAGS_JDKLIB) $(CXX_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - -DNO_ZLIB -DUNPACK_JNI -DFULL,\ - CFLAGS_release:=-DPRODUCT,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libunpack/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB)\ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_winapi:=-map:$(JDK_OUTPUTDIR)/objs/unpack.map /debug \ - jvm.lib java.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - LDFLAGS_SUFFIX_posix:=$(LIBCXX),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libunpack,\ - LIB:=$(LIBUNPACK_LIB_FILE),\ - VERSIONINFO_RESOURCE:=$(JDK_TOPDIR)/src/windows/resource/version.rc,\ - RC_FLAGS:=$(RC_FLAGS)\ - /D "JDK_FNAME=unpack.dll" \ - /D "JDK_INTERNAL_NAME=unpack" \ - /D "JDK_FTYPE=0x2L")) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)unpack$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)unpack$(SHARED_LIBRARY_SUFFIX) - -ifeq ($(HOST_OS_API),winapi) - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)unpack.map: $(LIBUNPACK_LIB_FILE) - $(ECHO) Copying $(@F) - $(CP) $(patsubst %$(SHARED_LIBRARY_SUFFIX),%.map,$<) $@ - - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)unpack.pdb: $(LIBUNPACK_LIB_FILE) - $(ECHO) Copying $(@F) - $(CP) $(patsubst %$(SHARED_LIBRARY_SUFFIX),%.pdb,$<) $@ -endif - -########################################################################################## - -BUILD_LIBFDLIBM_OPTIMIZATION:= $(C_O_FLAG_HI) - -ifneq ($(PLATFORM), solaris) - BUILD_LIBFDLIBM_OPTIMIZATION := $(C_O_FLAG_NONE) -endif - -ifneq ($(PLATFORM),macosx) +ifneq ($(OPENJDK_TARGET_OS),macosx) $(eval $(call SetupNativeCompilation,BUILD_LIBFDLIBM,\ + STATIC_LIBRARY:=fdlibm,\ + OUTPUT_DIR:=$(JDK_OUTPUTDIR)/objs,\ SRC:=$(JDK_TOPDIR)/src/share/native/java/lang/fdlibm/src,\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(BUILD_LIBFDLIBM_OPTIMIZATION) \ + OPTIMIZATION:=$(BUILD_LIBFDLIBM_OPTIMIZATION), \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/share/native/java/lang/fdlibm/include,\ CFLAGS_winapi_debug:=-DLOGGING,\ ARFLAGS:=$(ARFLAGS),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libfdlibm,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fdlibm$(STATIC_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libfdlibm)) + +BUILD_LIBRARIES += $(BUILD_LIBFDLIBM) + else # # On macosx they do partial (incremental) linking of fdlibm # code it here...rather than add support to NativeCompilation # as this is firt time I see it $(eval $(call SetupNativeCompilation,BUILD_LIBFDLIBM,\ + LIBRARY:=fdlibm,\ + OUTPUT_DIR:=$(JDK_OUTPUTDIR)/objs/libfdlibm,\ SRC:=$(JDK_TOPDIR)/src/share/native/java/lang/fdlibm/src,\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(BUILD_LIBFDLIBM_OPTIMIZATION) \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/share/native/java/lang/fdlibm/include,\ - LDFLAGS := -nostdlib -r,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libfdlibm,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fdlibm$(SHARED_LIBRARY_SUFFIX))) + LDFLAGS:=-nostdlib -r,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libfdlibm)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fdlibm$(STATIC_LIBRARY_SUFFIX) : \ - $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fdlibm$(SHARED_LIBRARY_SUFFIX) +$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fdlibm$(STATIC_LIBRARY_SUFFIX) : $(BUILD_LIBFDLIBM) $(CP) -a $< $@ -endif - BUILD_LIBRARIES += $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fdlibm$(STATIC_LIBRARY_SUFFIX) +endif ########################################################################################## -LIBATTACH_EXCLUDE_FILES:= -ifneq ($(PLATFORM),solaris) - LIBATTACH_EXCLUDE_FILES+=SolarisVirtualMachine.c -endif -ifneq ($(PLATFORM),linux) - LIBATTACH_EXCLUDE_FILES+=LinuxVirtualMachine.c -endif -ifneq ($(PLATFORM),macosx) - LIBATTACH_EXCLUDE_FILES+=BsdVirtualMachine.c +BUILD_LIBVERIFY_SRC:=check_code.c check_format.c + +ifeq ($(OPENJDK_TARGET_OS), solaris) + ifneq ($(ARCH), amd64) + BUILD_LIBVERIFY_REORDER:=$(JDK_TOPDIR)/makefiles/mapfiles/libverify/reorder-$(ARCH) + endif endif -$(eval $(call SetupNativeCompilation,BUILD_LIBATTACH,\ - SRC:=$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/tools/attach,\ - EXCLUDE_FILES:=$(LIBATTACH_EXCLUDE_FILES),\ + +$(eval $(call SetupNativeCompilation,BUILD_LIBVERIFY,\ + LIBRARY:=verify, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/native/common,\ + INCLUDE_FILES:=$(BUILD_LIBVERIFY_SRC),\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libattach/mapfile-$(PLATFORM), \ + OPTIMIZATION:=HIGH, \ + CFLAGS:=$(CFLAGS_JDKLIB),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libverify/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_solaris:=-ldoor,\ - LDFLAGS_winapi:=psapi.lib advapi32.lib java.lib jvm.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libattach,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)attach$(SHARED_LIBRARY_SUFFIX))) + $(call SET_SHARED_LIBRARY_ORIGIN), \ + LDFLAGS_SUFFIX_posix:=-ljvm -lc,\ + LDFLAGS_SUFFIX_windows:=jvm.lib,\ + REORDER:=$(BUILD_LIBVERIFY_REORDER),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libverify,\ + DEBUG_SYMBOLS:=true)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)attach$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)attach$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBVERIFY) ########################################################################################## -$(eval $(call SetupNativeCompilation,BUILD_LIBDT_SOCKET,\ - SRC:=$(JDK_TOPDIR)/src/share/transport/socket \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/transport/socket,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) -DUSE_MMAP $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - -I$(INCLUDEDIR) -I$(JDK_OUTPUTDIR)/include/$(PLATFORM) \ - -I$(JDK_TOPDIR)/src/share/transport/socket \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/transport/socket \ - -I$(JDK_TOPDIR)/src/share/back/export \ - -I$(JDK_TOPDIR)/src/share/back,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libdt_socket/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB), \ - LDFLAGS_SUFFIX_linux:=-lpthread,\ - LDFLAGS_SUFFIX_solaris:=-lnsl -lsocket,\ - LDFLAGS_SUFFIX_winapi:=-export:jdwpTransport_OnLoad ws2_32.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libdt_socket,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)dt_socket$(SHARED_LIBRARY_SUFFIX))) +LIBJAVA_SRC_DIRS:=$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/java/lang \ + $(JDK_TOPDIR)/src/share/native/java/lang \ + $(JDK_TOPDIR)/src/share/native/java/lang/ref \ + $(JDK_TOPDIR)/src/share/native/java/lang/reflect \ + $(JDK_TOPDIR)/src/share/native/java/io \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/java/io \ + $(JDK_TOPDIR)/src/share/native/java/nio \ + $(JDK_TOPDIR)/src/share/native/java/security \ + $(JDK_TOPDIR)/src/share/native/common \ + $(JDK_TOPDIR)/src/share/native/sun/misc \ + $(JDK_TOPDIR)/src/share/native/sun/reflect \ + $(JDK_TOPDIR)/src/share/native/java/sql \ + $(JDK_TOPDIR)/src/share/native/java/util \ + $(JDK_TOPDIR)/src/share/native/java/util/concurrent/atomic \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/common \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/java/util \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/provider \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/io -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)dt_socket$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +# +# TODO +# +ARCHPROPNAME:=$(LIBARCH) +ifeq ($(OPENJDK_TARGET_OS)-$(ARCH), solaris-i586) + ARCHPROPNAME:=x86 +else ifeq ($(OPENJDK_TARGET_OS)-$(ARCH_DATA_MODEL), windows-32) + ARCHPROPNAME:=x86 +else ifeq ($(OPENJDK_TARGET_OS), macosx) + ARCHPROPNAME:=$(ARCH) +endif -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)dt_socket$(SHARED_LIBRARY_SUFFIX) +LIBJAVA_CFLAGS:=$(foreach dir,$(LIBJAVA_SRC_DIRS),-I$(dir)) \ + -I$(JDK_TOPDIR)/src/share/native/java/lang/fdlibm/include \ + -DARCHPROPNAME='"$(ARCHPROPNAME)"' -########################################################################################## +LIBJAVA_CFLAGS += -DJDK_MAJOR_VERSION='"$(JDK_MAJOR_VERSION)"' \ + -DJDK_MINOR_VERSION='"$(JDK_MINOR_VERSION)"' \ + -DJDK_MICRO_VERSION='"$(JDK_MICRO_VERSION)"' \ + -DJDK_BUILD_NUMBER='"$(JDK_BUILD_NUMBER)"' -ifeq ($(HOST_OS_API),winapi) +ifneq (,$(JDK_UPDATE_VERSION)) + LIBJAVA_CFLAGS += -DJDK_UPDATE_VERSION='"$(JDK_UPDATE_VERSION)"' +endif - $(eval $(call SetupNativeCompilation,BUILD_LIBDT_SHMEM,\ - SRC:= $(JDK_TOPDIR)/src/share/native/com/sun/tools/jdi \ - $(JDK_TOPDIR)/src/share/transport/shmem \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/transport/shmem,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) -DUSE_MMAP $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS)\ - -I$(INCLUDEDIR) -I$(JDK_OUTPUTDIR)/include/$(PLATFORM) \ - -I$(JDK_TOPDIR)/src/share/transport/shmem \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/transport/shmem \ - -I$(JDK_TOPDIR)/src/share/back/export, \ - LDFLAGS:=$(LDFLAGS_JDKLIB),\ - LDFLAGS_winapi:=-export:jdwpTransport_OnLoad,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libdt_shmem,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)dt_shmem$(SHARED_LIBRARY_SUFFIX))) +LIBJAVA_EXCLUDE_FILES:=check_code.c check_format.c - BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)dt_shmem$(SHARED_LIBRARY_SUFFIX) - -endif # PLATFORM - -########################################################################################## -# JDWP_LOGGING causes log messages to be compiled into the library. These reference the -# __FILE__ macro which here expands to the absolute path of the file while the old build -# system used a relative path. This causes the binaries to differ in size. -$(eval $(call SetupNativeCompilation,BUILD_LIBJDWP,\ - SRC:=$(JDK_TOPDIR)/src/share/back $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/back,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) -DJDWP_LOGGING $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS)\ - -I$(JDK_TOPDIR)/src/share/transport/export \ - -I$(JDK_TOPDIR)/src/share/back/export \ - -I$(JDK_TOPDIR)/src/share/npt \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/npt \ - -I$(JDK_TOPDIR)/src/share/back \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/back \ - -I$(JDK_OUTPUTDIR)/gensrc_jdwp_headers,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjdwp/mapfile-vers, \ - LDFLAGS:=$(filter-out -ljava,$(LDFLAGS_JDKLIB)), \ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - LDFLAGS_SUFFIX_linux:=$(LIBDL),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjdwp,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jdwp$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jdwp$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)jdwp$(SHARED_LIBRARY_SUFFIX) - -########################################################################################## - -LIBJAAS_MAPFILE := -ifneq ($(PLATFORM),solaris) - LIBJAAS_EXCLUDE_FILES:=Solaris.c +ifneq ($(OPENJDK_TARGET_OS),macosx) + LIBJAVA_EXCLUDE_FILES += java_props_macosx.c else - # only on solaris...wonder why - LIBJAAS_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjaas/mapfile-vers + BUILD_LIBJAVA_java_props_md.c_CFLAGS:=-x objective-c endif -$(eval $(call SetupNativeCompilation,BUILD_LIBJAAS,\ - SRC:=$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/com/sun/security/auth/module,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS),\ - MAPFILE := $(LIBJAAS_MAPFILE),\ - LDFLAGS:=$(filter-out -ljava,$(LDFLAGS_JDKLIB)) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_winapi:=netapi32.lib user32.lib mpr.lib advapi32.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - EXCLUDE_FILES:=$(LIBJAAS_EXCLUDE_FILES),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjaas,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jaas$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jaas$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jaas$(SHARED_LIBRARY_SUFFIX) - -# Oddly enough, it is called jaas_nt.dll under winapi and libjaas_unix.so under posix. -ifeq ($(PLATFORM),windows) - $(INSTALL_LIBRARIES_HERE)/jaas_nt.dll : $(JDK_OUTPUTDIR)/objs/jaas.dll - $(ECHO) Copying $(@F) - $(CP) $< $@ - BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/jaas_nt.dll +ifeq ($(OPENJDK_TARGET_OS),windows) + LIBJAVA_EXCLUDE_FILES += \ + UNIXProcess_md.c \ + UnixFileSystem_md.c \ + FileSystemPreferences.c else - $(INSTALL_LIBRARIES_HERE)/libjaas_unix$(SHARED_LIBRARY_SUFFIX) : $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jaas$(SHARED_LIBRARY_SUFFIX) - $(ECHO) Copying $(@F) - $(CP) $< $@ - BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/libjaas_unix$(SHARED_LIBRARY_SUFFIX) + LIBJAVA_EXCLUDE_FILES += \ + ProcessImpl_md.c \ + Win32FileSystem_md.c \ + WinNTFileSystem_md.c \ + dirent_md.c \ + WindowsPreferences.c \ + sun/security/provider/WinCAPISeedGenerator.c \ + sun/io/Win32ErrorMode.c endif -########################################################################################## - -ifeq ($(HOST_OS_API),posix) - # TODO make this work on macosx - ifneq ($(HOST_OS),macosx) - - $(eval $(call SetupNativeCompilation,BUILD_LIBSCTP,\ - SRC:=$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/nio/ch/sctp,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS)\ - -I$(JDK_TOPDIR)/src/share/native/sun/nio/ch \ - -I$(JDK_TOPDIR)/src/share/native/sun/nio/ch/sctp \ - -I$(JDK_TOPDIR)/src/share/native/java/net \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/nio/ch \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/java/net,\ - CFLAGS_linux:=-Werror,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libsctp/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX_linux:=-lpthread,\ - LDFLAGS_SUFFIX_posix:=$(LIBDL) -lnio -lnet,\ - LDFLAGS_SUFFIX_solaris:=-lsocket,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - INCLUDE_FILES:=SctpNet.c SctpChannelImpl.c SctpServerChannelImpl.c,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libsctp,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)sctp$(SHARED_LIBRARY_SUFFIX))) - - BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)sctp$(SHARED_LIBRARY_SUFFIX) - - $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)sctp$(SHARED_LIBRARY_SUFFIX) : $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)nio$(SHARED_LIBRARY_SUFFIX) - endif -endif - -########################################################################################## - -$(eval $(call SetupNativeCompilation,BUILD_LIBJSDT,\ - SRC:=$(JDK_TOPDIR)/src/share/native/sun/tracing/dtrace\ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/tracing/dtrace,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS)\ - -I$(JDK_TOPDIR)/src/share/native/sun/tracing/dtrace,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjsdt/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBDL),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjsdt,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jsdt$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jsdt$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)jsdt$(SHARED_LIBRARY_SUFFIX) - -########################################################################################## - -ifdef OPENJDK - # TODO: Update awt lib path when awt is converted - $(eval $(call SetupNativeCompilation,BUILD_LIBLCMS,\ - SRC:=$(JDK_TOPDIR)/src/share/native/sun/java2d/cmm/lcms \ - $(JDK_TOPDIR)/src/share/native/sun/java2d/,\ - INCLUDE_FILES:=cmscam02.c cmscgats.c cmscnvrt.c cmserr.c \ - cmsgamma.c cmsgmt.c cmsintrp.c cmsio0.c \ - cmsio1.c cmslut.c cmsmd5.c cmsmtrx.c \ - cmsnamed.c cmsopt.c cmspack.c cmspcs.c \ - cmsplugin.c cmsps2.c cmssamp.c cmssm.c \ - cmstypes.c cmsvirt.c cmswtpnt.c cmsxform.c \ - LCMS.c,\ - LANG:=C,\ - CFLAGS:=$(filter-out -xc99=%none,$(CFLAGS_JDKLIB)) $(C_O_FLAG_NORM) \ - $(SHARED_LIBRARY_FLAGS) \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug,\ - CFLAGS_solaris:=-xc99=no_lib,\ - CFLAGS_winapi:=-DCMS_IS_WINDOWS_,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/liblcms/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB), \ - LDFLAGS_solaris:=/usr/lib$(ISA_DIR)/libm.so.2,\ - LDFLAGS_winapi:=awt.lib java.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - LDFLAGS_SUFFIX_posix:=-lawt,\ - LDFLAGS_SUFFIX_linux:=-lm,\ - BIN:=$(JDK_OUTPUTDIR)/objs/liblcms,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)lcms$(SHARED_LIBRARY_SUFFIX))) - - BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)lcms$(SHARED_LIBRARY_SUFFIX) - - $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)lcms$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX) -endif - -########################################################################################## - -ifdef OPENJDK - BUILD_LIBJPEG_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjpeg/mapfile-vers -else - BUILD_LIBJPEG_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjpeg/mapfile-vers-closed - BUILD_LIBJPEG_CLOSED_SRC := $(JDK_TOPDIR)/src/closed/share/native/sun/awt/image/jpeg - BUILD_LIBJPEG_CLOSED_INCLUDES := -I$(BUILD_LIBJPEG_CLOSED_SRC) -endif - -BUILD_LIBJPEG_REORDER := -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) ifneq ($(ARCH), amd64) - BUILD_LIBJPEG_REORDER := $(JDK_TOPDIR)/makefiles/mapfiles/libjpeg/reorder-$(ARCH) + LIBJAVA_REORDER:=$(JDK_TOPDIR)/makefiles/mapfiles/libjava/reorder-$(ARCH) endif endif -# Suppress gcc warnings like "variable might be clobbered by 'longjmp' -# or 'vfork'": this warning indicates that some variable is placed to -# a register by optimized compiler and it's value might be lost on longjmp(). -# Recommended way to avoid such warning is to declare the variable as -# volatile to prevent the optimization. However, this approach does not -# work because we have to declare all variables as volatile in result. -#ifndef CROSS_COMPILE_ARCH -# CC_43_OR_NEWER := \ -# $(shell $(EXPR) $(CC_MAJORVER) \> 4 \| \ -# \( $(CC_MAJORVER) = 4 \& $(CC_MINORVER) \>= 3 \) ) -# ifeq ($(CC_43_OR_NEWER),1) -# BUILD_LIBJPEG_CFLAGS_linux += -Wno-clobbered -# endif -#endif - -$(eval $(call SetupNativeCompilation,BUILD_LIBJPEG,\ - SRC:=$(BUILD_LIBJPEG_CLOSED_SRC) \ - $(JDK_TOPDIR)/src/share/native/sun/awt/image/jpeg,\ +$(eval $(call SetupNativeCompilation,BUILD_LIBJAVA,\ + LIBRARY:=java,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(LIBJAVA_SRC_DIRS),\ + EXCLUDES:=fdlibm/src zip, \ + EXCLUDE_FILES:=$(LIBJAVA_EXCLUDE_FILES), \ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HIGHEST) $(SHARED_LIBRARY_FLAGS) \ - $(BUILD_LIBJPEG_CLOSED_INCLUDES) \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/jpeg,\ - MAPFILE := $(BUILD_LIBJPEG_MAPFILE), \ + OPTIMIZATION:=HIGH, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + $(LIBJAVA_CFLAGS),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjava/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_linux:=$(LIBDL),\ - LDFLAGS_winapi:=java.lib jvm.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - REORDER := $(BUILD_LIBJPEG_REORDER),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjpeg,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jpeg$(SHARED_LIBRARY_SUFFIX))) + $(call SET_SHARED_LIBRARY_ORIGIN), \ + LDFLAGS_windows:=-export:winFileHandleOpen -export:handleLseek \ + $(BUILD_LIBFDLIBM) $(WIN_VERIFY_LIB) jvm.lib \ + shell32.lib delayimp.lib /DELAYLOAD:shell32.dll \ + advapi32.lib,\ + LDFLAGS_SUFFIX_posix:=-ljvm -lverify, \ + LDFLAGS_SUFFIX_solaris:=-lnsl -lsocket -lscf $(LIBDL) $(BUILD_LIBFDLIBM) -lc,\ + LDFLAGS_SUFFIX_linux:=$(LIBDL) $(BUILD_LIBFDLIBM),\ + LDFLAGS_SUFFIX_macosx:=$(BUILD_LIBFDLIBM) \ + -framework CoreFoundation \ + -framework Security -framework SystemConfiguration, \ + REORDER:=$(LIBJAVA_REORDER), \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjava)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jpeg$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBJAVA) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)jpeg$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBJAVA) : $(LIBJLI_BINARY) + +$(BUILD_LIBJAVA) : $(BUILD_LIBVERIFY) + +$(BUILD_LIBJAVA) : $(BUILD_LIBFDLIBM) ########################################################################################## -BUILD_LIBMLIB_SRC := $(JDK_TOPDIR)/src/share/native/sun/awt/medialib -BUILD_LIBMLIB_CFLAGS := -D__USE_J2D_NAMES -D__MEDIALIB_OLD_NAMES \ +BUILD_LIBMLIB_SRC:=$(JDK_TOPDIR)/src/share/native/sun/awt/medialib +BUILD_LIBMLIB_CFLAGS:=-D__USE_J2D_NAMES -D__MEDIALIB_OLD_NAMES \ -I$(BUILD_LIBMLIB_SRC) \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/awt/medialib + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/awt/medialib -BUILD_LIBMLIB_LDLIBS := -BUILD_LIBMLIB_IMAGE_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libmlib_image/mapfile-vers +BUILD_LIBMLIB_LDLIBS:= +BUILD_LIBMLIB_IMAGE_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libmlib_image/mapfile-vers -ifneq ($(PLATFORM), sparc) +ifneq ($(OPENJDK_TARGET_OS), sparc) +# +# Yes, this will always be true (until someone makes an OS called sparc) +# but this is how it was writtin in old system...keep it like this for now +# BUILD_LIBMLIB_CFLAGS += -DMLIB_NO_LIBSUNMATH endif @@ -518,43 +269,44 @@ ifeq ($(ARCH_DATA_MODEL), 64) BUILD_LIBMLIB_CFLAGS += -DMLIB_OS64BIT endif -ifneq ($(PLATFORM), windows) +ifneq ($(OPENJDK_TARGET_OS), windows) BUILD_LIBMLIB_LDLIBS += $(LIBM) $(LIBDL) endif $(eval $(call SetupNativeCompilation,BUILD_LIBMLIB_IMAGE,\ - SRC:=$(BUILD_LIBMLIB_SRC),\ + LIBRARY:=mlib_image,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(BUILD_LIBMLIB_SRC),\ EXCLUDE_FILES:=awt_ImagingLib.c mlib_c_ImageBlendTable.c,\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HIGHEST) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=HIGHEST, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ $(BUILD_LIBMLIB_CFLAGS),\ - MAPFILE := $(BUILD_LIBMLIB_IMAGE_MAPFILE), \ + MAPFILE:=$(BUILD_LIBMLIB_IMAGE_MAPFILE), \ LDFLAGS:=$(LDFLAGS_JDKLIB) \ $(BUILD_LIBMLIB_LDLIBS) \ $(call SET_SHARED_LIBRARY_ORIGIN),\ LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - LDFLAGS_SUFFIX_posix := -lm,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libmlib_image,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)mlib_image$(SHARED_LIBRARY_SUFFIX))) + LDFLAGS_SUFFIX_posix:=-lm,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libmlib_image)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)mlib_image$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBMLIB_IMAGE) : $(BUILD_LIBJAVA) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)mlib_image$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBMLIB_IMAGE) ########################################################################################## -ifeq ($(PLATFORM),solaris) +ifeq ($(OPENJDK_TARGET_OS),solaris) ifeq ($(ARCH),sparc) - BUILD_LIBMLIB_IMAGE_V := 1 + BUILD_LIBMLIB_IMAGE_V:=1 else ifeq ($(ARCH), sparcv9) - BUILD_LIBMLIB_IMAGE_V := 1 + BUILD_LIBMLIB_IMAGE_V:=1 endif endif ifeq ($(BUILD_LIBMLIB_IMAGE_V), 1) -BUILD_LIBMLIB_IMAGE_V_FILES := \ +BUILD_LIBMLIB_IMAGE_V_FILES:=\ mlib_v_ImageLookUp.c \ mlib_ImageCreate.c \ mlib_ImageAffine.c \ @@ -648,1460 +400,35 @@ BUILD_LIBMLIB_IMAGE_V_FILES := \ mlib_ImageUtils.c \ mlib_ImageDivTables.c -# -# TODO -# -# ASFLAGS += -P -# INLINE = $(PLATFORM_SRC)/native/sun/awt/medialib/vis_$(ARCH_DATA_MODEL).il +BUILD_LIBMLIB_V_CFLAGS := $(filter-out -DMLIB_NO_LIBSUNMATH,$(BUILD_LIBMLIB_CFLAGS)) $(eval $(call SetupNativeCompilation,BUILD_LIBMLIB_IMAGE_V,\ - SRC:=$(JDK_TOPDIR)/src/share/native/sun/awt/medialib \ + LIBRARY:=mlib_image_v, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/native/sun/awt/medialib \ $(JDK_TOPDIR)/src/solaris/native/sun/awt/medialib,\ LANG:=C,\ - INCLUDE_FILES := $(BUILD_LIBMLIB_IMAGE_V_FILES),\ - CFLAGS:=$(BUILD_LIBMLIB_CFLAGS) \ - $(CFLAGS_JDKLIB) $(C_O_FLAG_HI) $(SHARED_LIBRARY_FLAGS) \ - MAPFILE := $(JDK_TOPDIR)/$(BUILD_LIBMLIB_IMAGE_MAPFILE), \ + INCLUDE_FILES:=$(BUILD_LIBMLIB_IMAGE_V_FILES),\ + OPTIMIZATION:=HIGHEST, \ + CFLAGS:=-xarch=sparcvis \ + $(JDK_TOPDIR)/src/solaris/native/sun/awt/medialib/vis_$(ARCH_DATA_MODEL).il\ + $(BUILD_LIBMLIB_V_CFLAGS) \ + $(CFLAGS_JDKLIB), \ + MAPFILE:=$(BUILD_LIBMLIB_IMAGE_MAPFILE), \ LDFLAGS:=$(LDFLAGS_JDKLIB) \ $(BUILD_LIBMLIB_LDLIBS) \ $(call SET_SHARED_LIBRARY_ORIGIN),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libmlib_image_v,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)mlib_image_v$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libmlib_image_v)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)mlib_image_v$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBMLIB_IMAGE_V) endif ########################################################################################## -ifndef OPENJDK - FONT_HEADERS := -I$(CLOSED_SRC)/share/native/$(PKGDIR)/t2k - BUILD_LIBFONTMANAGER_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libfontmanager/mapfile-vers - LIBFONTMANAGER_EXCLUDE_FILES += freetypeScaler.c -else - FONT_HEADERS := $(FREETYPE2_CFLAGS) - BUILD_LIBFONTMANAGER_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libfontmanager/mapfile-vers.openjdk - BUILD_LIBFONTMANAGER_FONTLIB := $(FREETYPE2_LIBS) -endif - -ifeq ($(PLATFORM),windows) - LIBFONTMANAGER_EXCLUDE_FILES += X11FontScaler.c \ - X11TextRenderer.c -else - LIBFONTMANAGER_EXCLUDE_FILES += fontpath.c \ - lcdglyph.c -endif - -BUILD_LIBFONTMANAGER_CFLAGS_COMMON := $(SHARED_LIBRARY_FLAGS) \ - -DLE_STANDALONE -DHEADLESS \ - $(FONT_HEADERS) \ - -I$(JDK_TOPDIR)/src/share/native/sun/font \ - -I$(JDK_TOPDIR)/src/share/native/sun/font/layout \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/awt \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d/loops \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d/pipe \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d - -$(eval $(call SetupNativeCompilation,BUILD_LIBFONTMANAGER,\ - SRC:=$(JDK_TOPDIR)/src/share/native/sun/font\ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/font,\ - EXCLUDE_FILES:=$(LIBFONTMANAGER_EXCLUDE_FILES) \ - AccelGlyphCache.c,\ - LANG:=C++,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(BUILD_LIBFONTMANAGER_CFLAGS_COMMON),\ - CXXFLAGS:=$(CXXFLAGS_JDKLIB) $(BUILD_LIBFONTMANAGER_CFLAGS_COMMON),\ - CFLAGS_posix:=$(C_O_FLAG_HI),\ - CXXFLAGS_posix:=$(CXX_O_FLAG_HI),\ - CFLAGS_windows=$(C_O_FLAG_NORM)\ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/windows \ - -DCC_NOEX, \ - MAPFILE := $(BUILD_LIBFONTMANAGER_MAPFILE), \ - LDFLAGS:=$(subst -Xlinker -z -Xlinker defs,,$(LDFLAGS_JDKLIB)) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_windows:=advapi32.lib user32.lib gdi32.lib awt.lib java.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) \ - $(BUILD_LIBFONTMANAGER_FONTLIB),\ - LDFLAGS_SUFFIX_linux:=-lawt $(LIBM) $(LIBCXX),\ - LDFLAGS_SUFFIX_solaris:=-lawt -lawt_xawt -lc $(LIBM) $(LIBCXX),\ - LDFLAGS_SUFFIX_macosx:=-lawt $(LIBM) $(LIBCXX) -undefined dynamic_lookup,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libfontmanager,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fontmanager$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fontmanager$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX) - -ifneq (,$(findstring $(PLATFORM),solaris macosx)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fontmanager$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt_xawt$(SHARED_LIBRARY_SUFFIX) -endif - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)fontmanager$(SHARED_LIBRARY_SUFFIX) - -########################################################################################## - -ifndef OPENJDK - -# ifeq ($(PLATFORM), linux) -# ifeq ("$(CC_VER_MAJOR)", "3") -# OTHER_LDLIBS += -Wl,-Bstatic -lgcc_eh -Wl,-Bdynamic -# endif -# endif -# -# The resulting size of the t2k lib file is (at least on linux) dependant on the order of -# the input .o files. Because of this the new build will differ in size to the old build. - BUILD_LIBT2K_CFLAGS_COMMON:=-I$(JDK_TOPDIR)/src/share/native/sun/font \ - -I$(JDK_TOPDIR)/src/closed/share/native/sun/font/t2k \ - -I$(JDK_TOPDIR)/src/closed/share/native/sun/font \ - -I$(JDK_TOPDIR)/src/share/share/native/sun/font \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/font \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d/loops \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d/pipe \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d - - $(eval $(call SetupNativeCompilation,BUILD_LIBT2K,\ - SRC:=$(JDK_TOPDIR)/src/closed/share/native/sun/font \ - $(JDK_TOPDIR)/src/closed/share/native/sun/font/t2k \ - $(JDK_TOPDIR)/src/closed/share/native/sun/font/t2k/ttHints,\ - EXCLUDE_FILES:=orion.c,\ - LANG:=C++,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(BUILD_LIBT2K_CFLAGS_COMMON) $(C_O_FLAG_HI),\ - CXXFLAGS:=$(CXXFLAGS_JDKLIB) $(BUILD_LIBT2K_CFLAGS_COMMON) $(CXX_O_FLAG_HI),\ - CFLAGS_windows=-DCC_NOEX, \ - CXXFLAGS_windows=-DCC_NOEX, \ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libt2k/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_windows:=user32.lib $(JDK_OUTPUTDIR)/objs/fontmanager.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - LDFLAGS_SUFFIX_macosx:=$(LIBCXX) $(LIBM) -lfontmanager,\ - LDFLAGS_SUFFIX_linux:=$(LIBCXX) $(LIBM) -lfontmanager,\ - LDFLAGS_SUFFIX_solaris:=$(LIBCXX) $(LIBM) -lfontmanager -lawt \ - -lawt_xawt,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libt2k,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)t2k$(SHARED_LIBRARY_SUFFIX))) - - # t2k is linked against fontmanager - $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)t2k$(SHARED_LIBRARY_SUFFIX): \ - $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fontmanager$(SHARED_LIBRARY_SUFFIX) - - BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)t2k$(SHARED_LIBRARY_SUFFIX) -endif - -########################################################################################## - -# -# TODO replace with X_FLAGS / X_LIBS -# and add them to configure -# -OPENWIN_LIB := $(OPENWIN_HOME)/lib - -BUILD_LIBJAWT_LIB := $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jawt$(SHARED_LIBRARY_SUFFIX) - -ifeq ($(PLATFORM), windows) - ifeq ($(ARCH_DATA_MODEL), 32) - KERNEL32_LIB := kernel32.lib - endif - $(eval $(call SetupNativeCompilation,BUILD_LIBJAWT,\ - SRC:=$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/windows,\ - INCLUDE_FILES:=jawt.cpp,\ - LANG:=C++,\ - CFLAGS:=$(CXXFLAGS_JDKLIB) $(CXX_O_FLAG_NORM) \ - -EHsc -DUNICODE -D_UNICODE \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/windows \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d/windows, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) $(KERNEL32_LIB) \ - advapi32.lib awt.lib,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjawt,\ - LIB:=$(BUILD_LIBJAWT_LIB))) - -$(BUILD_LIBJAWT_LIB) : $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX) - -$(JDK_OUTPUTDIR)/lib/$(LIBRARY_PREFIX)jawt$(STATIC_LIBRARY_SUFFIX): $(BUILD_LIBJAWT_LIB) - $(ECHO) Copying $(@F) - $(CP) $< $@ - -BUILD_LIBRARIES += $(JDK_OUTPUTDIR)/lib/$(LIBRARY_PREFIX)jawt$(STATIC_LIBRARY_SUFFIX) - -else # PLATFORM not windows - - JAWT_LIBS := -lawt - ifndef BUILD_HEADLESS_ONLY - JAWT_LIBS += -lawt_xawt - else - JAWT_LIBS += -lawt_headless - HEADLESS_CFLAG += -DHEADLESS - endif - - JAWT_FILES := jawt.c - ifeq ($(PLATFORM), macosx) - JAWT_FILES := jawt.m - JAWT_LIBS := -lawt_lwawt - endif - - $(eval $(call SetupNativeCompilation,BUILD_LIBJAWT,\ - SRC:=$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/awt \ - $(JDK_TOPDIR)/src/macosx/native/sun/awt,\ - INCLUDE_FILES:=$(JAWT_FILES),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM), \ - CFLAGS_linux:=$(HEADLESS_CFLAG),\ - CFLAGS_macosx := -I$(JDK_TOPDIR)/src/solaris/native/sun/awt ,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjawt/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_solaris:=-L$(OPENWIN_HOME)/sfw/lib$(ISA_DIR) -L$(OPENWIN_LIB)$(ISA_DIR),\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(JAWT_LIBS),\ - LDFLAGS_SUFFIX_solaris:=-lXrender,\ - LDFLAGS_SUFFIX_macosx:= -framework Cocoa, \ - BIN:=$(JDK_OUTPUTDIR)/objs/libjawt,\ - LIB:=$(BUILD_LIBJAWT_LIB))) - -ifndef BUILD_HEADLESS_ONLY -$(BUILD_LIBJAWT_LIB) : $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt_xawt$(SHARED_LIBRARY_SUFFIX) -else -$(BUILD_LIBJAWT_LIB) : $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt_headless$(SHARED_LIBRARY_SUFFIX) -endif - -endif # PLATFORM - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)jawt$(SHARED_LIBRARY_SUFFIX) - - -########################################################################################## - -BUILD_LIBVERIFY_SRC := check_code.c check_format.c - -ifeq ($(PLATFORM), solaris) - ifneq ($(ARCH), amd64) - BUILD_LIBVERIFY_REORDER := $(JDK_TOPDIR)/makefiles/mapfiles/libverify/reorder-$(ARCH) - endif -endif - - -$(eval $(call SetupNativeCompilation,BUILD_LIBVERIFY,\ - SRC:=$(JDK_TOPDIR)/src/share/native/common,\ - INCLUDE_FILES:=$(BUILD_LIBVERIFY_SRC),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HI) $(SHARED_LIBRARY_FLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libverify/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN), \ - LDFLAGS_SUFFIX_posix:=-ljvm -lc,\ - LDFLAGS_SUFFIX_windows:=jvm.lib,\ - REORDER := $(BUILD_LIBVERIFY_REORDER),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libverify,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)verify$(SHARED_LIBRARY_SUFFIX))) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)verify$(SHARED_LIBRARY_SUFFIX) - -########################################################################################## - -ifndef OPENJDK -ifneq ($(PLATFORM), macosx) - -BUILD_LIBJDBCODBC_DIR := $(JDK_OUTPUTDIR)/objs/libjdbcodbc -BUILD_LIBJDBCODBC_NAME := $(LIBRARY_PREFIX)JdbcOdbc$(SHARED_LIBRARY_SUFFIX) -BUILD_LIBJDBCODBC_CFLAGS := -BUILD_LIBJDBCODBC_TARGET := $(JDK_OUTPUTDIR)/objs/$(BUILD_LIBJDBCODBC_NAME) -BUILD_LIBJDBCODBC_LIBS := -BUILD_LIBJDBCODBC_LDFLAGS := - -ifeq ($(PLATFORM), windows) - BUILD_LIBJDBCODBC_LDFLAGS := $(LDFLAGS_JDKLIB) - BUILD_LIBJDBCODBC_LIBS += odbc32.lib odbccp32.lib java.lib advapi32.lib -else - BUILD_LIBJDBCODBC_CFLAGS := -DUNIX - -# -# This mimics "current" build system exactly. Link against fake -lodbcinst -lodbc -# but...those are linked with the -soname, causing the dependency to be dropped on linux (gnu ld) -# but kept with other linker (solaris) -# -# IMO very weird behaviour...very weird -# - BUILD_LIBJDBCODBC_LDFLAGS += $(patsubst defs,nodefs,$(LDFLAGS_JDKLIB)) \ - -Xlinker -z -Xlinker nodefs - BUILD_LIBJDBCODBC_LIBS += -L$(BUILD_LIBJDBCODBC_DIR) -lodbcinst -lodbc - BUILD_LIBJDBCODBC_FAKE_LIBS := $(BUILD_LIBJDBCODBC_DIR)/$(LIBRARY_PREFIX)odbcinst$(SHARED_LIBRARY_SUFFIX) \ - $(BUILD_LIBJDBCODBC_DIR)/$(LIBRARY_PREFIX)odbc$(SHARED_LIBRARY_SUFFIX) - - BUILD_LIBJDBCODBC_SONAME := $(call SET_SHARED_LIBRARY_NAME,$(BUILD_LIBJDBCODBC_NAME)) -endif - -ifneq ($(PLATFORM), windows) - -$(eval $(call SetupNativeCompilation,BUILD_FAKEODBCINST,\ - SRC:=$(JDK_OUTPUTDIR)/gensrc_c/libjdbcodbc,\ - INCLUDE_FILES := dummyodbc1.c,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS),\ - LDFLAGS:=$(LDFLAGS_JDKLIB) $(call SET_SHARED_LIBRARY_ORIGIN) $(BUILD_LIBJDBCODBC_LDFLAGS),\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(BUILD_LIBJDBCODBC_SONAME),\ - BIN:=$(BUILD_LIBJDBCODBC_DIR),\ - LIB:=$(BUILD_LIBJDBCODBC_DIR)/$(LIBRARY_PREFIX)odbcinst$(SHARED_LIBRARY_SUFFIX))) - -$(eval $(call SetupNativeCompilation,BUILD_FAKEODBC,\ - SRC:=$(JDK_OUTPUTDIR)/gensrc_c/libjdbcodbc,\ - INCLUDE_FILES := dummyodbc2.c,\ - LANG:=C,\ - CFLAGS:=$(BUILD_LIBJDBCODBC_CFLAGS) $(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS),\ - LDFLAGS:=$(LDFLAGS_JDKLIB) $(call SET_SHARED_LIBRARY_ORIGIN) $(BUILD_LIBJDBCODBC_LDFLAGS),\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(BUILD_LIBJDBCODBC_SONAME),\ - BIN:=$(BUILD_LIBJDBCODBC_DIR),\ - LIB:=$(BUILD_LIBJDBCODBC_DIR)/$(LIBRARY_PREFIX)odbc$(SHARED_LIBRARY_SUFFIX))) - -$(BUILD_LIBJDBCODBC_FAKE_LIBS) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -$(BUILD_LIBJDBCODBC_TARGET) : $(BUILD_LIBJDBCODBC_FAKE_LIBS) - -endif - -$(eval $(call SetupNativeCompilation,BUILD_LIBJDBCODBC,\ - SRC:=$(JDK_TOPDIR)/src/closed/share/classes/sun/jdbc/odbc,\ - EXCLUDE_FILES := dummyodbc.c,\ - LANG:=C,\ - CFLAGS:=$(BUILD_LIBJDBCODBC_CFLAGS) $(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) \ - $(SHARED_LIBRARY_FLAGS),\ - LDFLAGS:=$(BUILD_LIBJDBCODBC_LDFLAGS) \ - $(call SET_SHARED_LIBRARY_ORIGIN) $(BUILD_LIBJDBCODBC_LIBS),\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(BUILD_LIBJDBCODBC_SONAME),\ - BIN:=$(BUILD_LIBJDBCODBC_DIR),\ - LIB:=$(BUILD_LIBJDBCODBC_TARGET))) - -$(BUILD_LIBJDBCODBC_TARGET) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)JdbcOdbc$(SHARED_LIBRARY_SUFFIX) - -endif -endif - -########################################################################################## - -BUILD_LIBINSTRUMENT_SRC := $(JDK_TOPDIR)/src/share/instrument \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/java/io \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/instrument - -BUILD_LIBINSTRUMENT_FILES := \ - EncodingSupport.c \ - EncodingSupport_md.c \ - FileSystemSupport_md.c \ - InstrumentationImplNativeMethods.c \ - InvocationAdapter.c \ - JarFacade.c \ - JPLISAgent.c \ - JPLISAssert.c \ - JavaExceptions.c \ - PathCharsValidator.c \ - Reentrancy.c \ - Utilities.c \ - canonicalize_md.c - -BUILD_LIBINSTRUMENT_DIR := $(JDK_OUTPUTDIR)/objs/libinstrument -BUILD_LIBINSTRUMENT_NAME := $(LIBRARY_PREFIX)instrument$(SHARED_LIBRARY_SUFFIX) -BUILD_LIBINSTRUMENT_CFLAGS := -I$(JDK_TOPDIR)/src/share/instrument \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/instrument \ - -I$(JDK_TOPDIR)/src/share/bin - -BUILD_LIBINSTRUMENT_TARGET := $(JDK_OUTPUTDIR)/objs/$(BUILD_LIBINSTRUMENT_NAME) -BUILD_LIBINSTRUMENT_LDFLAGS := -BUILD_LIBINSTRUMENT_LDFLAGS_SUFFIX := - -ifeq ($(PLATFORM), windows) - BUILD_LIBINSTRUMENT_LDFLAGS += jli_static.lib java.lib \ - -export:Agent_OnAttach - # equivalent of strcasecmp is stricmp on Windows - BUILD_LIBINSTRUMENT_CFLAGS += -Dstrcasecmp=stricmp -else - -ifneq (,$(findstring $(PLATFORM), macosx)) - ifneq ($(ARCH), universal) - BUILD_LIBINSTRUMENT_LDFLAGS += -Wl,-all_load - endif - - BUILD_LIBINSTRUMENT_LDFLAGS += $(JDK_OUTPUTDIR)/objs/libjli_static.a - BUILD_LIBINSTRUMENT_LDFLAGS += -liconv - BUILD_LIBINSTRUMENT_LDFLAGS += -framework Cocoa -framework Security -framework ApplicationServices - BUILD_LIBINSTRUMENT_LDFLAGS += $(LIBZ) -else - BUILD_LIBINSTRUMENT_LDFLAGS_SUFFIX += -ljli $(LIBDL) -endif -endif - -$(eval $(call SetupNativeCompilation,BUILD_LIBINSTRUMENT,\ - SRC:=$(BUILD_LIBINSTRUMENT_SRC),\ - INCLUDE_FILES:=$(BUILD_LIBINSTRUMENT_FILES),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - $(BUILD_LIBINSTRUMENT_CFLAGS),\ - CFLAGS_debug := -DJPLIS_LOGGING,\ - CFLAGS_release := -DNO_JPLIS_LOGGING,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libinstrument/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) $(call SET_SHARED_LIBRARY_ORIGIN)\ - $(call SET_SHARED_LIBRARY_ORIGIN,jli) \ - $(BUILD_LIBINSTRUMENT_LDFLAGS),\ - LDFLAGS_SUFFIX:=$(LIBZ) $(BUILD_LIBINSTRUMENT_LDFLAGS_SUFFIX),\ - BIN:=$(BUILD_LIBINSTRUMENT_DIR),\ - LIB:=$(BUILD_LIBINSTRUMENT_TARGET))) - -$(BUILD_LIBINSTRUMENT_TARGET) : $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jli_static$(STATIC_LIBRARY_SUFFIX) -$(BUILD_LIBINSTRUMENT_TARGET) : $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jli$(SHARED_LIBRARY_SUFFIX) -$(BUILD_LIBINSTRUMENT_TARGET) : $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(BUILD_LIBINSTRUMENT_NAME) - -########################################################################################## - -BUILD_LIBMANAGEMENT_SRC := $(JDK_TOPDIR)/src/share/native/sun/management \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/management \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/com/sun/management - -BUILD_LIBMANAGEMENT_EXCLUDES := - -BUILD_LIBMANAGEMENT_CFLAGS := -I$(JDK_TOPDIR)/src/share/native/sun/management - -ifneq ($(PLATFORM), windows) - BUILD_LIBMANAGEMENT_EXCLUDES += OperatingSystem_md.c -else - BUILD_LIBMANAGEMENT_EXCLUDES += UnixOperatingSystem_md.c -endif - -ifneq ($(PLATFORM),solaris) - BUILD_LIBMANAGEMENT_EXCLUDES += SolarisOperatingSystem.c -endif - -ifneq ($(PLATFORM),linux) - BUILD_LIBMANAGEMENT_EXCLUDES += LinuxOperatingSystem.c -endif - -ifneq ($(PLATFORM),macosx) - BUILD_LIBMANAGEMENT_EXCLUDES += MacosxOperatingSystem.c -endif - - -$(eval $(call SetupNativeCompilation,BUILD_LIBMANAGEMENT,\ - SRC:=$(BUILD_LIBMANAGEMENT_SRC),\ - EXCLUDE_FILES:=$(BUILD_LIBMANAGEMENT_EXCLUDES),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HI) $(SHARED_LIBRARY_FLAGS) $(BUILD_LIBMANAGEMENT_CFLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libmanagement/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_windows := java.lib jvm.lib advapi32.lib psapi.lib,\ - LDFLAGS_solaris := -lkstat,\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libmanagement,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)management$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)management$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)management$(SHARED_LIBRARY_SUFFIX) - -########################################################################################## - -BUILD_LIBHPROF_SRC := $(JDK_TOPDIR)/src/share/demo/jvmti/hprof $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/demo/jvmti/hprof -BUILD_LIBHPROF_CFLAGS := -I$(JDK_TOPDIR)/src/share/demo/jvmti/hprof \ - -I$(JDK_TOPDIR)/src/share/npt \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/npt \ - -I$(JDK_TOPDIR)/src/share/demo/jvmti/java_crw_demo - -BUILD_LIBHPROF_LDFLAGS := - -ifeq ($(PLATFORM),solaris) - BUILD_LIBHPROF_LDFLAGS += -lsocket -lnsl -endif - -ifneq ($(PLATFORM),windows) - BUILD_LIBHPROF_LDFLAGS += $(LIBDL) -endif - -$(eval $(call SetupNativeCompilation,BUILD_LIBHPROF,\ - SRC:=$(BUILD_LIBHPROF_SRC),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HIGHEST) $(SHARED_LIBRARY_FLAGS) \ - $(BUILD_LIBHPROF_CFLAGS),\ - CFLAGS_debug := -DHPROF_LOGGING,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libhprof/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_windows:=wsock32.lib winmm.lib advapi32.lib,\ - LDFLAGS_SUFFIX:=$(BUILD_LIBHPROF_LDFLAGS),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libhprof,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)hprof$(SHARED_LIBRARY_SUFFIX))) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)hprof$(SHARED_LIBRARY_SUFFIX) - -########################################################################################## - -$(eval $(call SetupNativeCompilation,BUILD_LIBJAVA_CRW_DEMO,\ - SRC:=$(JDK_TOPDIR)/src/share/demo/jvmti/java_crw_demo,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - -I$(JDK_TOPDIR)/src/share/demo/jvmti/java_crw_demo,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjava_crw_demo/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX:=,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjava_crw_demo,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)java_crw_demo$(SHARED_LIBRARY_SUFFIX))) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java_crw_demo$(SHARED_LIBRARY_SUFFIX) - -########################################################################################## - -$(eval $(call SetupNativeCompilation,BUILD_LIBNPT,\ - SRC:=$(JDK_TOPDIR)/src/share/npt $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/npt,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - -I$(JDK_TOPDIR)/src/share/npt \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/npt,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libnpt/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_macosx := -liconv,\ - LDFLAGS_SUFFIX_windows := -export:nptInitialize -export:nptTerminate,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libnpt,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)npt$(SHARED_LIBRARY_SUFFIX))) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)npt$(SHARED_LIBRARY_SUFFIX) - -########################################################################################## - -BUILD_LIBNIO_SRC := \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/java/nio \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/nio/ch \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/nio/fs - -BUILD_LIBNIO_CFLAGS := \ - -I$(JDK_TOPDIR)/src/share/native/sun/nio/ch \ - -I$(JDK_TOPDIR)/src/share/native/java/io \ - -I$(JDK_TOPDIR)/src/share/native/java/net \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/java/net - -BUILD_LIBNIO_FILES := \ - DatagramChannelImpl.c \ - DatagramDispatcher.c \ - FileChannelImpl.c \ - FileDispatcherImpl.c \ - FileKey.c \ - IOUtil.c \ - MappedByteBuffer.c \ - Net.c \ - ServerSocketChannelImpl.c \ - SocketChannelImpl.c \ - SocketDispatcher.c - -ifeq ($(PLATFORM), windows) - BUILD_LIBNIO_FILES += \ - Iocp.c \ - RegistryFileTypeDetector.c \ - WindowsAsynchronousFileChannelImpl.c \ - WindowsAsynchronousServerSocketChannelImpl.c \ - WindowsAsynchronousSocketChannelImpl.c \ - WindowsNativeDispatcher.c \ - WindowsSelectorImpl.c -endif - -ifeq ($(PLATFORM), linux) - BUILD_LIBNIO_LDFLAGS_SUFFIX := -lpthread $(LIBDL) - BUILD_LIBNIO_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libnio/mapfile-linux - BUILD_LIBNIO_FILES += \ - EPoll.c \ - EPollArrayWrapper.c \ - EPollPort.c \ - InheritedChannel.c \ - NativeThread.c \ - PollArrayWrapper.c \ - UnixAsynchronousServerSocketChannelImpl.c \ - UnixAsynchronousSocketChannelImpl.c \ - GnomeFileTypeDetector.c \ - LinuxNativeDispatcher.c \ - LinuxWatchService.c \ - UnixCopyFile.c \ - UnixNativeDispatcher.c -endif - -ifeq ($(PLATFORM), macosx) - BUILD_LIBNIO_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libnio/mapfile-bsd - BUILD_LIBNIO_SRC += $(JDK_TOPDIR)/src/macosx/native/sun/nio/ch - BUILD_LIBNIO_FILES += \ - InheritedChannel.c \ - NativeThread.c \ - PollArrayWrapper.c \ - UnixAsynchronousServerSocketChannelImpl.c \ - UnixAsynchronousSocketChannelImpl.c \ - GnomeFileTypeDetector.c \ - BsdNativeDispatcher.c \ - UnixCopyFile.c \ - UnixNativeDispatcher.c \ - KQueue.c \ - KQueuePort.c \ - KQueueArrayWrapper.c -endif - -ifeq ($(PLATFORM), solaris) - BUILD_LIBNIO_LDFLAGS_SUFFIX := $(LIBDL) - BUILD_LIBNIO_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libnio/mapfile-solaris - BUILD_LIBNIO_FILES += \ - DevPollArrayWrapper.c \ - InheritedChannel.c \ - NativeThread.c \ - PollArrayWrapper.c \ - SolarisEventPort.c \ - UnixAsynchronousServerSocketChannelImpl.c \ - UnixAsynchronousSocketChannelImpl.c \ - GnomeFileTypeDetector.c \ - SolarisNativeDispatcher.c \ - SolarisWatchService.c \ - UnixCopyFile.c \ - UnixNativeDispatcher.c -endif - -BUILD_LIBNIO_LDFLAGS := -ifeq ($(PLATFORM),windows) - BUILD_LIBNIO_LDFLAGS += \ - java.lib net.lib advapi32.lib jvm.lib ws2_32.lib\ - $(JDK_OUTPUTDIR)/objs/libjava/io_util.obj \ - $(JDK_OUTPUTDIR)/objs/libjava/FileDescriptor_md.obj -endif - -ifeq ($(PLATFORM), linux) - BUILD_LIBNIO_LDFLAGS_SUFFIX += -ljava -lnet -lpthread $(LIBDL) -endif -ifeq ($(PLATFORM), macosx) - BUILD_LIBNIO_LDFLAGS_SUFFIX += -ljava -lnet -pthread -endif - -ifeq ($(PLATFORM), solaris) - BUILD_LIBNIO_LDFLAGS_SUFFIX += $(JVMLIB) $(LIBSOCKET) -lposix4 $(LIBDL) -lsendfile \ - -ljava -lnet -endif # PLATFORM - - -$(eval $(call SetupNativeCompilation,BUILD_LIBNIO,\ - SRC:=$(BUILD_LIBNIO_SRC),\ - INCLUDE_FILES := $(BUILD_LIBNIO_FILES), \ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HI) $(SHARED_LIBRARY_FLAGS) \ - $(BUILD_LIBNIO_CFLAGS),\ - MAPFILE := $(BUILD_LIBNIO_MAPFILE), \ - LDFLAGS:=$(LDFLAGS_JDKLIB) $(BUILD_LIBNIO_LDFLAGS) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(BUILD_LIBNIO_LDFLAGS_SUFFIX),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libnio,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)nio$(SHARED_LIBRARY_SUFFIX))) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)nio$(SHARED_LIBRARY_SUFFIX) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)nio$(SHARED_LIBRARY_SUFFIX) : $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)net$(SHARED_LIBRARY_SUFFIX) $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - - -########################################################################################## - -LIBNET_SRC_DIRS := $(JDK_TOPDIR)/src/share/native/java/net \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/java/net \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/net/dns \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/net/www/protocol/http/ntlm \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/net/sdp \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/net/spi - -LIBNET_CFLAGS := $(foreach dir,$(LIBNET_SRC_DIRS),-I$(dir)) - -LIBNET_EXCLUDE_FILES:= -ifneq ($(PLATFORM),linux) - LIBNET_EXCLUDE_FILES += linux_close.c -endif - -ifneq ($(PLATFORM),macosx) - LIBNET_EXCLUDE_FILES += bsd_close.c -endif - -ifeq ($(PLATFORM),windows) - LIBNET_EXCLUDE_FILES += PlainSocketImpl.c PlainDatagramSocketImpl.c SdpSupport.c -else - LIBNET_EXCLUDE_FILES += TwoStacksPlainSocketImpl.c DualStackPlainSocketImpl.c \ - TwoStacksPlainDatagramSocketImpl.c DualStackPlainDatagramSocketImpl.c \ - NTLMAuthSequence.c NetworkInterface_winXP.c -endif - -LIBNET_LDFLAGS_SUFFIX := - -$(eval $(call SetupNativeCompilation,BUILD_LIBNET,\ - SRC:=$(LIBNET_SRC_DIRS),\ - EXCLUDE_FILES := $(LIBNET_EXCLUDE_FILES), \ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - $(LIBNET_CFLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libnet/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBNET_LDFLAGS_SUFFIX),\ - LDFLAGS_SUFFIX_solaris := -lnsl -lsocket $(LIBDL) ,\ - LDFLAGS_SUFFIX_linux := $(LIBDL) -lpthread ,\ - LDFLAGS_SUFFIX_windows := ws2_32.lib $(JVMLIB) secur32.lib iphlpapi.lib \ - delayimp.lib java.lib jvm.lib advapi32.lib \ - /DELAYLOAD:secur32.dll /DELAYLOAD:iphlpapi.dll, \ - BIN:=$(JDK_OUTPUTDIR)/objs/libnet,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)net$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)net$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)net$(SHARED_LIBRARY_SUFFIX) - -$(JDK_OUTPUTDIR)/lib/net.properties: $(JDK_TOPDIR)/src/share/lib/net.properties - $(ECHO) Copying $(@F) - $(MKDIR) -p $(@D) - $(CP) $< $@ - -COPY_FILES += $(JDK_OUTPUTDIR)/lib/net.properties - -ifeq ($(PLATFORM), solaris) -$(JDK_OUTPUTDIR)/lib/sdp/sdp.conf.template : $(JDK_TOPDIR)/src/${LEGACY_HOST_OS_API}/lib/sdp/sdp.conf.template - $(ECHO) Copying $(@F) - $(MKDIR) -p $(@D) - $(CP) $< $@ - -COPY_FILES += $(JDK_OUTPUTDIR)/lib/sdp/sdp.conf.template -endif - -########################################################################################## - -LIBJAVA_SRC_DIRS := $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/java/lang \ - $(JDK_TOPDIR)/src/share/native/java/lang \ - $(JDK_TOPDIR)/src/share/native/java/lang/ref \ - $(JDK_TOPDIR)/src/share/native/java/lang/reflect \ - $(JDK_TOPDIR)/src/share/native/java/io \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/java/io \ - $(JDK_TOPDIR)/src/share/native/java/nio \ - $(JDK_TOPDIR)/src/share/native/java/security \ - $(JDK_TOPDIR)/src/share/native/common \ - $(JDK_TOPDIR)/src/share/native/sun/misc \ - $(JDK_TOPDIR)/src/share/native/sun/reflect \ - $(JDK_TOPDIR)/src/share/native/java/sql \ - $(JDK_TOPDIR)/src/share/native/java/util \ - $(JDK_TOPDIR)/src/share/native/java/util/concurrent/atomic \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/common \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/java/util \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/provider \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/io - -LIBJAVA_CFLAGS := $(foreach dir,$(LIBJAVA_SRC_DIRS),-I$(dir)) \ - -I$(JDK_TOPDIR)/src/share/native/java/lang/fdlibm/include \ - -DARCHPROPNAME='"$(ARCH)"' - -LIBJAVA_CFLAGS += -DJDK_MAJOR_VERSION='"$(JDK_MAJOR_VERSION)"' \ - -DJDK_MINOR_VERSION='"$(JDK_MINOR_VERSION)"' \ - -DJDK_MICRO_VERSION='"$(JDK_MICRO_VERSION)"' \ - -DJDK_BUILD_NUMBER='"$(JDK_BUILD_NUMBER)"' - -ifneq (,$(JDK_UPDATE_VERSION)) - LIBJAVA_CFLAGS += -DJDK_UPDATE_VERSION='"$(JDK_UPDATE_VERSION)"' -endif - -LIBJAVA_EXCLUDE_FILES:= check_code.c check_format.c - -ifneq ($(PLATFORM),macosx) - LIBJAVA_EXCLUDE_FILES += java_props_macosx.c -else - BUILD_LIBJAVA_java_props_md.c_CFLAGS := -x objective-c -endif - -ifeq ($(PLATFORM),windows) - LIBJAVA_EXCLUDE_FILES += \ - UNIXProcess_md.c \ - UnixFileSystem_md.c \ - FileSystemPreferences.c -else - LIBJAVA_EXCLUDE_FILES += \ - ProcessImpl_md.c \ - Win32FileSystem_md.c \ - WinNTFileSystem_md.c \ - dirent_md.c \ - WindowsPreferences.c \ - sun/security/provider/WinCAPISeedGenerator.c \ - sun/io/Win32ErrorMode.c -endif - -ifeq ($(PLATFORM), solaris) - ifneq ($(ARCH), amd64) - LIBJAVA_REORDER := $(JDK_TOPDIR)/makefiles/mapfiles/libjava/reorder-$(ARCH) - endif -endif - -LIBJAVA_FDLIBM := $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)fdlibm$(STATIC_LIBRARY_SUFFIX) -LIBJAVA_VERIFY := $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)verify$(STATIC_LIBRARY_SUFFIX) - -$(eval $(call SetupNativeCompilation,BUILD_LIBJAVA,\ - SRC:=$(LIBJAVA_SRC_DIRS),\ - EXCLUDES := fdlibm/src zip, \ - EXCLUDE_FILES := $(LIBJAVA_EXCLUDE_FILES), \ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HI) $(SHARED_LIBRARY_FLAGS) \ - $(LIBJAVA_CFLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjava/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN), \ - LDFLAGS_windows:=-export:winFileHandleOpen -export:handleLseek \ - $(LIBJAVA_FDLIBM) $(LIBJAVA_VERIFY) jvm.lib \ - shell32.lib delayimp.lib /DELAYLOAD:shell32.dll \ - advapi32.lib,\ - LDFLAGS_SUFFIX_posix:=-ljvm -lverify, \ - LDFLAGS_SUFFIX_solaris := -lnsl -lsocket -lscf $(LIBDL) $(LIBJAVA_FDLIBM) -lc,\ - LDFLAGS_SUFFIX_linux := $(LIBDL) $(LIBJAVA_FDLIBM),\ - LDFLAGS_SUFFIX_macosx := $(LIBJAVA_FDLIBM) \ - -framework CoreFoundation \ - -framework Security -framework SystemConfiguration, \ - REORDER := $(LIBJAVA_REORDER), \ - BIN:=$(JDK_OUTPUTDIR)/objs/libjava,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX))) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) : $(LIBJLI_BINARY) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)verify$(SHARED_LIBRARY_SUFFIX) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) : $(LIBJAVA_FDLIBM) - -########################################################################################## - -BUILD_LIBJLI_SRC_DIRS := $(JDK_TOPDIR)/src/share/bin $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/bin -BUILD_LIBJLI_CFLAGS := $(foreach dir,$(BUILD_LIBJLI_SRC_DIRS),-I$(dir)) - -BUILD_LIBJLI_FILES := \ - java.c \ - splashscreen_stubs.c \ - parse_manifest.c \ - version_comp.c \ - wildcard.c \ - jli_util.c - -ifeq ($(JVM_VARIANT_ZERO), true) - ERGO_FAMILY := zero -else # !ZERO_BUILD - ifneq (,$(findstring $(ARCH), amd64 x86_64)) - ERGO_FAMILY := i586 - else # !X86 FAMILY - ERGO_FAMILY := $(ARCH) - endif #ARCH_FAMILY -endif # ZERO_BUILD - -ifeq ($(PLATFORM), macosx) - BUILD_LIBJLI_CFLAGS += -I$(JDK_TOPDIR)/src/macosx/bin - BUILD_LIBJLI_SRC_DIRS += $(JDK_TOPDIR)/src/macosx/bin - BUILD_LIBJLI_FILES += java_md_common.c java_md_macosx.c - - BUILD_LIBJLI_java_md_macosx.c_CFLAGS := -x objective-c - BUILD_LIBJLI_A_java_md_macosx.c_CFLAGS := -x objective-c -endif - -ifeq ($(PLATFORM), windows) - BUILD_LIBJLI_FILES += java_md.c -else ifneq ($(PLATFORM), macosx) - - BUILD_LIBJLI_FILES += java_md_common.c - BUILD_LIBJLI_FILES += java_md_solinux.c ergo.c - - ERGO_ARCH_FILE = ergo_$(ERGO_FAMILY).c - - # if the architecture specific ergo file exists then - # use it, else use the generic definitions from ergo.c - ifneq ($(wildcard $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/bin/$(ERGO_ARCH_FILE)),) - BUILD_LIBJLI_FILES += $(ERGO_ARCH_FILE) - else # !ERGO_ARCH_FILE - BUILD_LIBJLI_CFLAGS += -DUSE_GENERIC_ERGO - endif # ERGO_ARCH_FILE -endif #WINDOWS - -# Names of arch directories -BUILD_LIBJLI_CFLAGS += -DLIBARCHNAME='"$(LIBARCH)"' -ifeq ($(PLATFORM), solaris) - ifneq (,$(findstring $(ARCH),sparc)) - BUILD_LIBJLI_CFLAGS += -DLIBARCH32NAME='"sparc"' - BUILD_LIBJLI_CFLAGS += -DLIBARCH64NAME='"sparcv9"' - else - BUILD_LIBJLI_CFLAGS += -DLIBARCH32NAME='"i386"' - BUILD_LIBJLI_CFLAGS += -DLIBARCH64NAME='"amd64"' - endif -endif # PLATFORM - -ifeq ($(PLATFORM), macosx) - BUILD_LIBJLI_CFLAGS += -DPACKAGE_PATH=\"$(PACKAGE_PATH)\" -endif - -ifneq ($(USE_EXTERNAL_LIBZ),true) - BUILD_LIBJLI_SRC_DIRS += $(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5 - BUILD_LIBJLI_CFLAGS += $(LIBZ_INCLUDE) - BUILD_LIBJLI_FILES += \ - inflate.c \ - inftrees.c \ - inffast.c \ - zadler32.c \ - zcrc32.c \ - zutil.c -endif - -$(eval $(call SetupNativeCompilation,BUILD_LIBJLI,\ - SRC:=$(BUILD_LIBJLI_SRC_DIRS),\ - INCLUDE_FILES := $(BUILD_LIBJLI_FILES),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HI) $(SHARED_LIBRARY_FLAGS) $(BUILD_LIBJLI_CFLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjli/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX := $(LIBZ),\ - LDFLAGS_SUFFIX_posix := $(LIBDL) -lc,\ - LDFLAGS_SUFFIX_linux := -lpthread,\ - LDFLAGS_SUFFIX_windows := \ - -export:JLI_Launch \ - -export:JLI_ManifestIterate \ - -export:JLI_SetTraceLauncher \ - -export:JLI_ReportErrorMessage \ - -export:JLI_ReportErrorMessageSys \ - -export:JLI_ReportMessage \ - -export:JLI_ReportExceptionDescription \ - advapi32.lib \ - comctl32.lib \ - user32.lib,\ - LDFLAGS_SUFFIX_macosx := -framework Cocoa -framework Security -framework ApplicationServices, \ - BIN:=$(JDK_OUTPUTDIR)/objs/libjli,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jli$(SHARED_LIBRARY_SUFFIX))) - -ifeq ($(HOST_OS), windows) - LIBJLI_BINARY := $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)jli$(SHARED_LIBRARY_SUFFIX) -else - LIBJLI_BINARY := $(INSTALL_LIBRARIES_HERE)/jli/$(LIBRARY_PREFIX)jli$(SHARED_LIBRARY_SUFFIX) - - $(LIBJLI_BINARY) : $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jli$(SHARED_LIBRARY_SUFFIX) - $(MKDIR) -p $(@D) - $(ECHO) Copying $(@F) - $(CP) $< $@ -endif -BUILD_LIBRARIES += $(LIBJLI_BINARY) - -# On windows, the static library has the same suffix as the import library created by -# with the shared library, so the static library is given a different name. No harm -# in doing it for all platform to reduce complexity. -ifneq ($(HOST_OS),macosx) - $(eval $(call SetupNativeCompilation,BUILD_LIBJLI_STATIC,\ - SRC:=$(BUILD_LIBJLI_SRC_DIRS),\ - INCLUDE_FILES := $(BUILD_LIBJLI_FILES),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HI) $(STATIC_LIBRARY_FLAGS) $(BUILD_LIBJLI_CFLAGS),\ - ARFLAGS:=$(ARFLAGS),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjli_static,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jli_static$(STATIC_LIBRARY_SUFFIX))) -else - # - # On macosx they do partial (incremental) linking of fdlibm - # code it here...rather than add support to NativeCompilation - # as this is first time I see it - $(eval $(call SetupNativeCompilation,BUILD_LIBJLI_A,\ - SRC:=$(BUILD_LIBJLI_SRC_DIRS),\ - INCLUDE_FILES := $(BUILD_LIBJLI_FILES),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_HI) $(BUILD_LIBJLI_CFLAGS),\ - LDFLAGS := -nostdlib -r,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjli_static,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jli_static$(STATIC_LIBRARY_SUFFIX))) -endif - -BUILD_LIBRARIES += $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jli_static$(STATIC_LIBRARY_SUFFIX) - -########################################################################################## - -ifndef OPENJDK -ifndef JAVASE_EMBEDDED - -$(eval $(call SetupNativeCompilation,BUILD_LIBJFR,\ - SRC:=$(JDK_TOPDIR)/src/closed/share/native/oracle/jfr,\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - -I$(JDK_TOPDIR)/src/closed/share/javavm/export, \ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjfr/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjfr,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jfr$(SHARED_LIBRARY_SUFFIX))) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)jfr$(SHARED_LIBRARY_SUFFIX) - -endif -endif - -########################################################################################## - -ifndef OPENJDK - -BUILD_LIBKCMS_EXCLUDE_FILES := -ifeq ($(PLATFORM),windows) - BUILD_LIBKCMS_EXCLUDE_FILES += ukcpmgr.c unixmem.c -else - BUILD_LIBKCMS_EXCLUDE_FILES += cmmdll.c registry.c spxffile.c sysinfo.c winmem.c wkcpmgr.c -endif - -$(eval $(call SetupNativeCompilation,BUILD_LIBKCMS,\ - SRC:=$(JDK_TOPDIR)/src/closed/share/native/sun/java2d/cmm/kcms,\ - LANG:=C,\ - EXCLUDE_FILES := $(BUILD_LIBKCMS_EXCLUDE_FILES),\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - -DJAVACMM -DFUT_CALC_EX -DNO_FUT_GCONST,\ - CFLAGS_linux := -Wno-missing-field-initializers,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libkcms/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX_linux := -lpthread,\ - LDFLAGS_SUFFIX_windows := java.lib advapi32.lib user32.lib version.lib, \ - LDFLAGS_SUFFIX:= -lm $(LDFLAGS_JDKLIB_SUFFIX),\ - VERSIONINFO_RESOURCE := $(JDK_TOPDIR)/src/closed/share/native/sun/java2d/cmm/kcms/cmm.rc,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libkcms,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)kcms$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)kcms$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)kcms$(SHARED_LIBRARY_SUFFIX) - -endif - -########################################################################################## - -ifndef OPENJDK -ifeq ($(PLATFORM), solaris) -ifneq ($(ARCH), amd64) - -ifeq ($(shell if test "$(OS_VERSION_MAJOR)" -eq 5 -a "$(OS_VERSION_MINOR)" -le 10; then $(ECHO) ok; fi), ok) - -SUNWJDGA_MAPFILE := -ifneq (,$(findstring $(ARCH),sparc)) - SUNWJDGA_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjdga/mapfile-vers -endif - -$(eval $(call SetupNativeCompilation,BUILD_LIBSUNWJDGA, \ - SRC:=$(JDK_TOPDIR)/src/solaris/native/sun/jdga, \ - LANG:=C, \ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - -I$(JDK_TOPDIR)/src/share/javavm/export \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/javavm/export \ - -I$(OPENWIN_HOME)/include, \ - MAPFILE := $(SUNWJDGA_MAPFILE), \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN), \ - LDFLAGS_SUFFIX:= -L$(OPENWIN_LIB)$(ISA_DIR) -R$(OPENWIN_LIB)$(ISA_DIR) -ldga -lX11 $(LIBDL) -lc, \ - BIN:=$(JDK_OUTPUTDIR)/objs/libsunwjdga, \ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)sunwjdga$(SHARED_LIBRARY_SUFFIX))) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)sunwjdga$(SHARED_LIBRARY_SUFFIX) - -endif -endif -endif -endif - -########################################################################################## - -ifeq ($(BUILD_HEADLESS), true) -ifneq ($(PLATFORM), windows) - -# TODO!! -X11_PATH := /usr/X11R6 - -LIBAWT_HEADLESS_DIRS := $(JDK_TOPDIR)/src/share/native/sun/font \ - $(JDK_TOPDIR)/src/share/native/sun/java2d/opengl \ - $(JDK_TOPDIR)/src/solaris/native/sun/font \ - $(JDK_TOPDIR)/src/solaris/native/sun/awt \ - $(JDK_TOPDIR)/src/solaris/native/sun/java2d/opengl \ - $(JDK_TOPDIR)/src/solaris/native/sun/java2d/x11 - -LIBAWT_HEADLESS_CFLAGS := -DHEADLESS=true \ - -DX11_PATH=\"$(X11_PATH)\" -DPACKAGE_PATH=\"$(PACKAGE_PATH)\" \ - $(CUPS_CFLAGS) \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d/loops \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d/pipe \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/image \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/jdga \ - $(foreach dir,$(LIBAWT_HEADLESS_DIRS),-I$(dir)) - -LIBAWT_HEADLESS_FILES := \ - awt_Font.c \ - HeadlessToolkit.c \ - fontpath.c \ - VDrawingArea.c \ - X11Color.c \ - X11Renderer.c \ - X11PMBlitLoops.c \ - X11SurfaceData.c \ - X11FontScaler_md.c \ - X11TextRenderer_md.c \ - OGLBlitLoops.c \ - OGLBufImgOps.c \ - OGLContext.c \ - OGLFuncs.c \ - OGLMaskBlit.c \ - OGLMaskFill.c \ - OGLPaints.c \ - OGLRenderQueue.c \ - OGLRenderer.c \ - OGLSurfaceData.c \ - OGLTextRenderer.c \ - OGLVertexCache.c \ - GLXGraphicsConfig.c \ - GLXSurfaceData.c \ - AccelGlyphCache.c \ - CUPSfuncs.c - -LIBAWT_HEADLESS_LDFLAGS_SUFFIX := $(LDFLAGS_JDKLIB_SUFFIX) -lawt -lm - -LIBAWT_HEADLESS_REORDER := -ifeq ($(PLATFORM), solaris) - ifneq ($(ARCH), amd64) - LIBAWT_HEADLESS_REORDER := $(JDK_TOPDIR)/makefiles/mapfiles/libawt_headless/reorder-$(ARCH) - endif -endif - -$(eval $(call SetupNativeCompilation,BUILD_LIBAWT_HEADLESS,\ - SRC:=$(LIBAWT_HEADLESS_DIRS),\ - INCLUDE_FILES := $(LIBAWT_HEADLESS_FILES),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) $(LIBAWT_HEADLESS_CFLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libawt_headless/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - REORDER := $(LIBAWT_HEADLESS_REORDER), \ - LDFLAGS_SUFFIX := $(LIBAWT_HEADLESS_LDFLAGS_SUFFIX),\ - LDFLAGS_SUFFIX_posix := $(LIBDL),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libawt_headless,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_headless$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_headless$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt_headless$(SHARED_LIBRARY_SUFFIX) - -endif -endif - -########################################################################################## - -ifneq ($(PLATFORM), windows) -ifndef BUILD_HEADLESS_ONLY - -LIBAWT_XAWT_DIRS := \ - $(JDK_TOPDIR)/src/share/native/sun/awt/debug \ - $(JDK_TOPDIR)/src/share/native/sun/awt/utility \ - $(JDK_TOPDIR)/src/share/native/sun/font \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/font \ - $(JDK_TOPDIR)/src/share/native/sun/java2d/opengl \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/awt \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d/opengl \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d/x11 \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/xawt \ - -LIBAWT_XAWT_CFLAGS := -DXAWT -DXAWT_HACK \ - -DX11_PATH=\"$(X11_PATH)\" -DPACKAGE_PATH=\"$(PACKAGE_PATH)\" \ - $(CUPS_CFLAGS) \ - $(foreach dir,$(LIBAWT_XAWT_DIRS),-I$(dir)) \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d/loops \ - -I$(JDK_TOPDIR)/src/share/native/sun/java2d/pipe \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/image \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils \ - -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/jdga - -ifeq ($(PLATFORM),solaris) - LIBAWT_XAWT_CFLAGS += -DFUNCPROTO=15 -endif - -ifeq ($(MILESTONE),internal) - LIBAWT_XAWT_CFLAGS += -DINTERNAL_BUILD -endif - -LIBAWT_XAWT_FILES := \ - XlibWrapper.c \ - XWindow.c \ - XToolkit.c \ - X11Color.c \ - X11SurfaceData.c \ - awt_GraphicsEnv.c \ - awt_InputMethod.c \ - robot_common.c \ - awt_Robot.c \ - list.c \ - multiVis.c \ - initIDs.c \ - awt_util.c \ - awt_Desktop.c \ - awt_UNIXToolkit.c \ - X11FontScaler_md.c \ - X11TextRenderer_md.c \ - fontpath.c \ - awt_Insets.c \ - awt_Event.c \ - X11Renderer.c \ - X11PMBlitLoops.c \ - OGLBlitLoops.c \ - OGLBufImgOps.c \ - OGLContext.c \ - OGLFuncs.c \ - OGLMaskBlit.c \ - OGLMaskFill.c \ - OGLPaints.c \ - OGLRenderQueue.c \ - OGLRenderer.c \ - OGLSurfaceData.c \ - OGLTextRenderer.c \ - OGLVertexCache.c \ - GLXGraphicsConfig.c \ - GLXSurfaceData.c \ - AccelGlyphCache.c \ - awt_Font.c \ - multi_font.c \ - awt_AWTEvent.c \ - awt_DrawingSurface.c \ - jawt.c \ - CUPSfuncs.c \ - debug_assert.c \ - debug_mem.c \ - debug_trace.c \ - debug_util.c \ - awt_Plugin.c \ - gtk2_interface.c \ - swing_GTKEngine.c \ - swing_GTKStyle.c \ - rect.c \ - sun_awt_X11_GtkFileDialogPeer.c \ - XRSurfaceData.c \ - XRBackendNative.c - -LIBAWT_XAWT_LDFLAGS_SUFFIX := $(LIBM) -lawt -lXext -lX11 -lXrender $(LIBDL) -lXtst -lXi -ljava -lverify -ljvm -lc - -ifeq ($(PLATFORM), linux) - LIBAWT_XAWT_LDFLAGS_SUFFIX += -lpthread -endif - -ifeq ($(PLATFORM), macosx) - LIBAWT_XAWT_LDFLAGS_SUFFIX += -lpthread -endif - -$(eval $(call SetupNativeCompilation,BUILD_LIBAWT_XAWT,\ - SRC:=$(LIBAWT_XAWT_DIRS),\ - INCLUDE_FILES := $(LIBAWT_XAWT_FILES),\ - LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) $(LIBAWT_XAWT_CFLAGS) \ - $(X_CFLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libawt_xawt/mapfile-vers, \ - LDFLAGS:=$(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN) \ - $(X_LIBS),\ - LDFLAGS_solaris:=-L$(OPENWIN_HOME)/sfw/lib$(ISA_DIR) -L$(OPENWIN_LIB)$(ISA_DIR) \ - -R$(OPENWIN_HOME)/sfw/lib$(ISA_DIR) -R$(OPENWIN_LIB)$(ISA_DIR) \ - -R/usr/dt/lib$(ISA_DIR),\ - LDFLAGS_SUFFIX := $(LIBAWT_XAWT_LDFLAGS_SUFFIX),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libawt_xawt,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_xawt$(SHARED_LIBRARY_SUFFIX))) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_xawt$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) - -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_xawt$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt_xawt$(SHARED_LIBRARY_SUFFIX) - -endif -endif - -########################################################################################## - -ifndef BUILD_HEADLESS_ONLY -LIBSPLASHSCREEN_DIRS := \ - $(JDK_TOPDIR)/src/share/native/sun/awt/giflib \ - $(JDK_TOPDIR)/src/share/native/sun/awt/image/jpeg \ - $(JDK_TOPDIR)/src/share/native/sun/awt/libpng \ - $(JDK_TOPDIR)/src/share/native/sun/awt/splashscreen \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/awt/splashscreen - -LIBSPLASHSCREEN_CFLAGS := -DSPLASHSCREEN -DPNG_NO_MMX_CODE \ - $(foreach dir,$(LIBSPLASHSCREEN_DIRS),-I$(dir)) - -ifeq ($(PLATFORM), macosx) - LIBSPLASHSCREEN_CFLAGS := -I$(JDK_TOPDIR)/src/macosx/native/sun/awt/splashscreen \ - $(LIBSPLASHSCREEN_CFLAGS) \ - -F/System/Library/Frameworks/JavaVM.framework/Frameworks - LIBSPLASHSCREEN_CFLAGS += -DWITH_MACOSX - LIBSPLASHSCREEN_CFLAGS += -I$(JDK_TOPDIR)/src/macosx/native/sun/osxapp - - LIBSPLASHSCREEN_java_awt_SplashScreen.c_CFLAGS := -x objective-c -O0 - LIBSPLASHSCREEN_splashscreen_gfx_impl.c_CFLAGS := -x objective-c -O0 - LIBSPLASHSCREEN_splashscreen_gif.c_CFLAGS := -x objective-c -O0 - LIBSPLASHSCREEN_splashscreen_impl.c_CFLAGS := -x objective-c -O0 - LIBSPLASHSCREEN_splashscreen_jpeg.c_CFLAGS := -x objective-c -O0 - LIBSPLASHSCREEN_splashscreen_png.c_CFLAGS := -x objective-c -O0 - LIBSPLASHSCREEN_splashscreen_sys.m_CFLAGS := -O0 - -else ifneq ($(PLATFORM), windows) - LIBSPLASHSCREEN_CFLAGS += -DWITH_X11 -I$(OPENWIN_HOME)/include -I$(OPENWIN_HOME)/include/X11/extensions -else - LIBSPLASHSCREEN_CFLAGS += -DWITH_WIN32 -endif - -LIBSPLASHSCREEN_FILES := \ - java_awt_SplashScreen.c \ - splashscreen_gfx_impl.c \ - splashscreen_gif.c \ - splashscreen_impl.c \ - splashscreen_jpeg.c \ - splashscreen_png.c \ - png.c \ - pngerror.c \ - pngget.c \ - pngmem.c \ - pngpread.c \ - pngread.c \ - pngrio.c \ - pngrtran.c \ - pngrutil.c \ - pngset.c \ - pngtrans.c \ - pngwio.c \ - pngwrite.c \ - pngwtran.c \ - pngwutil.c \ - dgif_lib.c \ - gif_err.c \ - gifalloc.c \ - jcomapi.c \ - jdapimin.c \ - jdapistd.c \ - jdcoefct.c \ - jdcolor.c \ - jddctmgr.c \ - jdhuff.c \ - jdinput.c \ - jdmainct.c \ - jdmarker.c \ - jdmaster.c \ - jdmerge.c \ - jdphuff.c \ - jdpostct.c \ - jdsample.c \ - jerror.c \ - jidctflt.c \ - jidctfst.c \ - jidctint.c \ - jidctred.c \ - jmemmgr.c \ - jmemnobs.c \ - jquant1.c \ - jquant2.c \ - jutils.c \ - jcapimin.c \ - jcapistd.c \ - jccoefct.c \ - jccolor.c \ - jcdctmgr.c \ - jchuff.c \ - jcinit.c \ - jcmainct.c \ - jcmarker.c \ - jcmaster.c \ - jcparam.c \ - jcphuff.c \ - jcprepct.c \ - jcsample.c \ - jctrans.c \ - jdtrans.c \ - jfdctflt.c \ - jfdctfst.c \ - jfdctint.c - -ifneq ($(PLATFORM), macosx) -LIBSPLASHSCREEN_FILES += splashscreen_sys.c -else -LIBSPLASHSCREEN_DIRS += $(JDK_TOPDIR)/src/macosx/native/sun/awt/splashscreen -LIBSPLASHSCREEN_FILES += splashscreen_sys.m -endif - -LIBSPLASHSCREEN_LDFLAGS_SUFFIX := - -ifneq ($(USE_EXTERNAL_LIBZ),true) - LIBSPLASHSCREEN_DIRS += $(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5 - LIBSPLASHSCREEN_CFLAGS += $(LIBZ_INCLUDE) - LIBSPLASHSCREEN_FILES += \ - compress.c \ - deflate.c \ - gzclose.c \ - gzlib.c \ - gzread.c \ - gzwrite.c \ - infback.c \ - inffast.c \ - inflate.c \ - inftrees.c \ - trees.c \ - uncompr.c \ - zadler32.c \ - zcrc32.c \ - zutil.c -endif - -ifeq ($(PLATFORM), macosx) - LIBSPLASHSCREEN_LDFLAGS_SUFFIX += $(LIBM) -lpthread -liconv -losxapp \ - -framework ApplicationServices \ - -framework Foundation \ - -framework Cocoa \ - -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ - -framework JavaNativeFoundation -else ifneq ($(PLATFORM), windows) - LIBSPLASHSCREEN_LDFLAGS_SUFFIX += -L$(OPENWIN_LIB)$(ISA_DIR) -lX11 -lXext $(LIBM) -lpthread $(LIBDL) -else # PLATFORM - LIBSPLASHSCREEN_LDFLAGS_SUFFIX += kernel32.lib user32.lib gdi32.lib delayimp.lib /DELAYLOAD:user32.dll -endif # PLATFORM - -$(eval $(call SetupNativeCompilation,LIBSPLASHSCREEN,\ - SRC:=$(LIBSPLASHSCREEN_DIRS),\ - INCLUDE_FILES := $(LIBSPLASHSCREEN_FILES),\ - LANG:=C,\ - CFLAGS:= $(LIBSPLASHSCREEN_CFLAGS) $(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libsplashscreen/mapfile-vers, \ - LDFLAGS:= $(LDFLAGS_JDKLIB) \ - $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX := $(LIBSPLASHSCREEN_LDFLAGS_SUFFIX) $(LIBZ),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libsplashscreen,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)splashscreen$(SHARED_LIBRARY_SUFFIX))) - -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)splashscreen$(SHARED_LIBRARY_SUFFIX) - -ifeq ($(PLATFORM),macosx) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)splashscreen$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)osxapp$(SHARED_LIBRARY_SUFFIX) -endif - -endif - -########################################################################################## - -LIBAWT_DIRS := \ +LIBAWT_DIRS:=\ $(JDK_TOPDIR)/src/share/native/sun/awt \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/awt \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/awt \ $(JDK_TOPDIR)/src/share/native/sun/awt/image \ $(JDK_TOPDIR)/src/share/native/sun/awt/image/gif \ $(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils \ @@ -2110,23 +437,24 @@ LIBAWT_DIRS := \ $(JDK_TOPDIR)/src/share/native/sun/awt/debug \ $(JDK_TOPDIR)/src/share/native/sun/awt/utility \ $(JDK_TOPDIR)/src/share/native/sun/java2d \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d \ $(JDK_TOPDIR)/src/share/native/sun/java2d/loops \ $(JDK_TOPDIR)/src/share/native/sun/java2d/pipe \ $(JDK_TOPDIR)/src/share/native/sun/awt/image \ $(JDK_TOPDIR)/src/share/native/sun/java2d/opengl \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d/opengl \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d/x11 \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d/opengl \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d/x11 \ $(JDK_TOPDIR)/src/share/native/sun/font \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/windows \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d/windows \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/java2d/d3d + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/windows \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d/windows \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d/d3d -LIBAWT_CFLAGS := -D__MEDIALIB_OLD_NAMES -D__USE_J2D_NAMES \ +LIBAWT_CFLAGS:=-D__MEDIALIB_OLD_NAMES -D__USE_J2D_NAMES \ + $(X_CFLAGS) \ $(foreach dir,$(LIBAWT_DIRS),-I$(dir)) -LIBAWT_FILES := \ +LIBAWT_FILES:=\ gifdecoder.c \ imageInitIDs.c \ img_globals.c \ @@ -2196,40 +524,89 @@ LIBAWT_FILES := \ debug_trace.c \ debug_util.c -ifneq (,$(filter $(PLATFORM), solaris linux)) +ifneq (,$(filter $(OPENJDK_TARGET_OS), solaris linux macosx)) LIBAWT_FILES += awt_LoadLibrary.c initIDs.c img_colors.c endif -ifeq ($(PLATFORM),macosx) +ifeq ($(OPENJDK_TARGET_OS),macosx) LIBAWT_DIRS += $(JDK_TOPDIR)/src/macosx/native/com/apple/resources LIBAWT_FILES += awt_LoadLibrary.c MacOSXResourceBundle.m LIBAWT_CFLAGS += -F/System/Library/Frameworks/JavaVM.framework/Frameworks - LIBAWT_MacOSXResourceBundle.m_CFLAGS := -O0 + LIBAWT_MacOSXResourceBundle.m_CFLAGS:=-O0 endif -ifeq ($(PLATFORM)-$(ARCH_FAMILY), solaris-sparc) -# -# TODO... -# +ifeq ($(OPENJDK_TARGET_OS)-$(OPENJDK_TARGET_CPU_ARCH), solaris-sparc) + LIBAWT_CFLAGS += -DMLIB_ADD_SUFF + LIBAWT_CFLAGS += -xarch=sparcvis + LIBAWT_CFLAGS += $(JDK_TOPDIR)/src/solaris/native/sun/awt/medialib/vis_$(ARCH_DATA_MODEL).il + LIBAWT_CFLAGS += \ + -I$(JDK_TOPDIR)/src/solaris/native/sun/awt/medialib \ + -I$(JDK_TOPDIR)/src/solaris/native/sun/java2d/medialib \ + -I$(JDK_TOPDIR)/src/solaris/native/sun/java2d/loops -# FILES_c += $(FILES_2D_vis) -# ASFLAGS += -P -# FILES_s += mlib_v_ImageCopy_blk.s -# INLINE_VIS = $(PLATFORM_SRC)/native/sun/awt/medialib/vis_$(ARCH_DATA_MODEL).il -# CFLAGS_sparcv9 = -DMLIB_OS64BIT -# CFLAGS += $(CFLAGS_$(ARCH)) -DMLIB_ADD_SUFF $(INLINE_VIS) + LIBAWT_DIRS += $(JDK_TOPDIR)/src/solaris/native/sun/awt/medialib \ + $(JDK_TOPDIR)/src/solaris/native/sun/java2d/loops + + LIBAWT_FILES += \ + vis_FuncArray.c \ + java2d_Mlib.c \ + mlib_ImageCreate.c \ + mlib_ImageZoom_NN.c \ + mlib_ImageCopy_Bit.c \ + mlib_sys.c \ + mlib_v_ImageClear.c \ + mlib_v_ImageClear_f.c \ + mlib_v_ImageConstXor.c \ + mlib_v_ImageCopy.c \ + mlib_v_ImageCopy_f.c \ + mlib_v_ImageXor.c \ + mlib_v_ImageZoom_NN_f.c \ + vis_Interp.c \ + vis_AlphaMacros.c \ + vis_AlphaMaskBlit.c \ + vis_AlphaMaskFill.c \ + vis_ByteGray.c \ + vis_ByteGray_FromRgb.c \ + vis_ByteGray_Mask.c \ + vis_ByteIndexed.c \ + vis_DrawLine.c \ + vis_FourByteAbgr.c \ + vis_IntArgb.c \ + vis_IntArgbPre.c \ + vis_IntArgbPre_Mask.c \ + vis_IntBgr.c \ + vis_IntRgb.c \ + vis_IntRgbx.c \ + vis_SrcMaskFill.c \ + vis_SrcOverMaskBlit.c \ + vis_SrcOverMaskFill.c \ + vis_FourByteAbgrPre.c \ + vis_GlyphList.c \ + vis_GlyphListXor.c \ + vis_IntArgbBm.c \ + vis_ThreeByteBgr.c \ + vis_UshortGray.c \ + vis_UshortGray_FromRgb.c \ + vis_XorBlit.c \ + mlib_v_ImageCopy_blk.s + + ifeq ($(OPENJDK_TARGET_CPU_BITS),64) + LIBAWT_ASFLAGS=-P -xarch=v9a + else + LIBAWT_ASFLAGS=-P -xarch=v8plusa + endif else LIBAWT_FILES += MapAccelFunc.c endif -ifneq ($(PLATFORM),solaris) +ifneq ($(OPENJDK_TARGET_OS),solaris) LIBAWT_CFLAGS += -DMLIB_NO_LIBSUNMATH endif -LIBAWT_LANG := C +LIBAWT_LANG:=C -ifeq ($(PLATFORM),windows) +ifeq ($(OPENJDK_TARGET_OS),windows) LIBAWT_FILES += AccelGlyphCache.c \ ShaderList.c \ CmdIDList.cpp \ @@ -2266,219 +643,2012 @@ ifeq ($(PLATFORM),windows) initIDs.cpp \ MouseInfo.cpp \ rect.c - LIBAWT_LANG := C++ + LIBAWT_LANG:=C++ LIBAWT_CFLAGS += $(GX_OPTION) -DUNICODE -D_UNICODE ifeq ($(ARCH_DATA_MODEL), 64) LIBAWT_CFLAGS += -DMLIB_OS64BIT endif ifdef OPENJDK - LIBAWT_RC_FLAGS := -i "$(JDK_TOPDIR)/src/windows/resource/icons" + LIBAWT_RC_FLAGS:=-i "$(JDK_TOPDIR)/src/windows/resource/icons" else - LIBAWT_RC_FLAGS := -i "$(JDK_TOPDIR)/src/closed/windows/native/sun/windows" + LIBAWT_RC_FLAGS:=-i "$(JDK_TOPDIR)/src/closed/windows/native/sun/windows" endif - LIBAWT_VERSIONINFO_RESOURCE := $(JDK_TOPDIR)/src/windows/native/sun/windows/awt.rc + LIBAWT_VERSIONINFO_RESOURCE:=$(JDK_TOPDIR)/src/windows/native/sun/windows/awt.rc endif ifeq ($(MILESTONE), internal) LIBAWT_CFLAGS += -DINTERNAL_BUILD endif -LIBAWT_MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libawt/mapfile-vers -ifeq ($(PLATFORM),linux) - LIBAWT_MAPFILE := +LIBAWT_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libawt/mapfile-vers +ifeq ($(OPENJDK_TARGET_OS),linux) + LIBAWT_MAPFILE:= endif $(eval $(call SetupNativeCompilation,BUILD_LIBAWT,\ + LIBRARY:=awt,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(LIBAWT_DIRS),\ - INCLUDE_FILES := $(LIBAWT_FILES),\ + INCLUDE_FILES:=$(LIBAWT_FILES),\ LANG:=$(LIBAWT_LANG),\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) $(LIBAWT_CFLAGS),\ - MAPFILE := $(LIBAWT_MAPFILE), \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) $(LIBAWT_CFLAGS),\ + ASFLAGS:=$(LIBAWT_ASFLAGS),\ + MAPFILE:=$(LIBAWT_MAPFILE), \ LDFLAGS:=$(LDFLAGS_JDKLIB) $(call SET_SHARED_LIBRARY_ORIGIN),\ LDFLAGS_windows:=advapi32.lib kernel32.lib user32.lib gdi32.lib winspool.lib \ imm32.lib ole32.lib uuid.lib shell32.lib \ comdlg32.lib winmm.lib comctl32.lib \ - shlwapi.lib delayimp.lib java.lib jvm.lib \ + shlwapi.lib delayimp.lib $(WIN_JAVA_LIB) jvm.lib \ /DELAYLOAD:user32.dll /DELAYLOAD:gdi32.dll \ /DELAYLOAD:shell32.dll /DELAYLOAD:winmm.dll \ /DELAYLOAD:winspool.drv /DELAYLOAD:imm32.dll \ /DELAYLOAD:ole32.dll /DELAYLOAD:comdlg32.dll \ /DELAYLOAD:comctl32.dll /DELAYLOAD:shlwapi.dll,\ - LDFLAGS_macosx :=-framework Cocoa \ + LDFLAGS_macosx:=-lmlib_image \ + -framework Cocoa \ -framework OpenGL \ -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ -framework JavaNativeFoundation \ -framework JavaRuntimeSupport \ -framework ApplicationServices \ -framework AudioToolbox,\ - LDFLAGS_solaris := -R/usr/dt/lib$(ISA_DIR) -R$(OPENWIN_LIB)$(ISA_DIR),\ - LDFLAGS_SUFFIX_posix := -ljvm $(LIBM) -ljava $(LIBDL),\ - VERSIONINFO_RESOURCE := $(LIBAWT_VERSIONINFO_RESOURCE),\ - RC_FLAGS := $(RC_FLAGS) $(LIBAWT_RC_FLAGS) \ + LDFLAGS_solaris:=-R/usr/dt/lib$(ISA_DIR) -R$(OPENWIN_LIB)$(ISA_DIR),\ + LDFLAGS_SUFFIX_posix:=-ljvm $(LIBM) -ljava $(LIBDL),\ + VERSIONINFO_RESOURCE:=$(LIBAWT_VERSIONINFO_RESOURCE),\ + RC_FLAGS:=$(RC_FLAGS) $(LIBAWT_RC_FLAGS) \ /D "JDK_FNAME=awt.dll" \ /D "JDK_INTERNAL_NAME=awt" \ /D "JDK_FTYPE=0x2L",\ - BIN:=$(JDK_OUTPUTDIR)/objs/libawt,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libawt)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBAWT) : $(BUILD_LIBJAVA) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX) +ifeq ($(OPENJDK_TARGET_OS), macosx) +$(BUILD_LIBAWT) : $(BUILD_LIBMLIB_IMAGE) +endif + +BUILD_LIBRARIES += $(BUILD_LIBAWT) + +########################################################################################## + +# TODO!! +# Even though this variable as a general name, it is +# only used on macos, in fontpath.c, as prefix for where to find fonts. +# +# It's used for libawt_headless _and_ libawt_xawt +# +X11_PATH:=/usr/X11R6 + +ifneq ($(OPENJDK_TARGET_OS), windows) +ifndef BUILD_HEADLESS_ONLY + +LIBAWT_XAWT_DIRS:=\ + $(JDK_TOPDIR)/src/share/native/sun/awt/debug \ + $(JDK_TOPDIR)/src/share/native/sun/awt/utility \ + $(JDK_TOPDIR)/src/share/native/sun/font \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/font \ + $(JDK_TOPDIR)/src/share/native/sun/java2d/opengl \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/awt \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d/opengl \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d/x11 \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/xawt \ + +LIBAWT_XAWT_CFLAGS:=-DXAWT -DXAWT_HACK \ + -DX11_PATH=\"$(X11_PATH)\" -DPACKAGE_PATH=\"$(PACKAGE_PATH)\" \ + $(CUPS_CFLAGS) \ + $(foreach dir,$(LIBAWT_XAWT_DIRS),-I$(dir)) \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d/loops \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d/pipe \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/image \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/jdga + +ifeq ($(OPENJDK_TARGET_OS),solaris) + LIBAWT_XAWT_CFLAGS += -DFUNCPROTO=15 +endif + +ifeq ($(MILESTONE),internal) + LIBAWT_XAWT_CFLAGS += -DINTERNAL_BUILD +endif + +LIBAWT_XAWT_FILES:=\ + XlibWrapper.c \ + XWindow.c \ + XToolkit.c \ + X11Color.c \ + X11SurfaceData.c \ + awt_GraphicsEnv.c \ + awt_InputMethod.c \ + robot_common.c \ + awt_Robot.c \ + list.c \ + multiVis.c \ + initIDs.c \ + awt_util.c \ + awt_Desktop.c \ + awt_UNIXToolkit.c \ + X11FontScaler_md.c \ + X11TextRenderer_md.c \ + fontpath.c \ + awt_Insets.c \ + awt_Event.c \ + X11Renderer.c \ + X11PMBlitLoops.c \ + OGLBlitLoops.c \ + OGLBufImgOps.c \ + OGLContext.c \ + OGLFuncs.c \ + OGLMaskBlit.c \ + OGLMaskFill.c \ + OGLPaints.c \ + OGLRenderQueue.c \ + OGLRenderer.c \ + OGLSurfaceData.c \ + OGLTextRenderer.c \ + OGLVertexCache.c \ + GLXGraphicsConfig.c \ + GLXSurfaceData.c \ + AccelGlyphCache.c \ + awt_Font.c \ + multi_font.c \ + awt_AWTEvent.c \ + awt_DrawingSurface.c \ + jawt.c \ + CUPSfuncs.c \ + debug_assert.c \ + debug_mem.c \ + debug_trace.c \ + debug_util.c \ + awt_Plugin.c \ + gtk2_interface.c \ + swing_GTKEngine.c \ + swing_GTKStyle.c \ + rect.c \ + sun_awt_X11_GtkFileDialogPeer.c \ + XRSurfaceData.c \ + XRBackendNative.c + +LIBAWT_XAWT_LDFLAGS_SUFFIX:=$(LIBM) -lawt -lXext -lX11 -lXrender $(LIBDL) -lXtst -lXi -ljava -ljvm -lc + +ifeq ($(OPENJDK_TARGET_OS), linux) + LIBAWT_XAWT_LDFLAGS_SUFFIX += -lpthread +endif + +ifeq ($(OPENJDK_TARGET_OS), macosx) + LIBAWT_XAWT_LDFLAGS_SUFFIX += -lpthread +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBAWT_XAWT,\ + LIBRARY:=awt_xawt,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(LIBAWT_XAWT_DIRS),\ + INCLUDE_FILES:=$(LIBAWT_XAWT_FILES),\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) $(LIBAWT_XAWT_CFLAGS) \ + $(X_CFLAGS),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libawt_xawt/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN) \ + $(X_LIBS),\ + LDFLAGS_solaris:=-L$(OPENWIN_HOME)/sfw/lib$(ISA_DIR) -L$(OPENWIN_HOME)/lib$(ISA_DIR) \ + -R$(OPENWIN_HOME)/sfw/lib$(ISA_DIR) -R$(OPENWIN_HOME)/lib$(ISA_DIR) \ + -R/usr/dt/lib$(ISA_DIR),\ + LDFLAGS_SUFFIX:=$(LIBAWT_XAWT_LDFLAGS_SUFFIX),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libawt_xawt)) + +$(BUILD_LIBAWT_XAWT) : $(BUILD_LIBJAVA) + +$(BUILD_LIBAWT_XAWT) : $(BUILD_LIBAWT) + +BUILD_LIBRARIES += $(BUILD_LIBAWT_XAWT) + +endif +endif + +########################################################################################## + +BUILD_LIBZIP_FILES:=\ + CRC32.c \ + Adler32.c \ + Deflater.c \ + Inflater.c \ + ZipFile.c \ + zip_util.c + +ifeq ($(USE_EXTERNAL_LIBZ),true) + LIBZ:=-lz +else +BUILD_LIBZIP_FILES += \ + compress.c \ + deflate.c \ + gzclose.c \ + gzlib.c \ + gzread.c \ + gzwrite.c \ + infback.c \ + inffast.c \ + inflate.c \ + inftrees.c \ + trees.c \ + uncompr.c \ + zadler32.c \ + zcrc32.c \ + zutil.c +LIBZ_INCLUDE:=-I$(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5 +endif + +BUILD_LIBZIP_REORDER:= +ifeq ($(OPENJDK_TARGET_OS), solaris) + ifneq ($(ARCH), amd64) + BUILD_LIBZIP_REORDER:=$(JDK_TOPDIR)/makefiles/mapfiles/libzip/reorder-$(ARCH) + endif +endif + +ifeq ($(LIBZIP_CAN_USE_MMAP), true) + BUILD_LIBZIP_MMAP:=-DUSE_MMAP +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBZIP,\ + LIBRARY:=zip,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/native/java/util/zip \ + $(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5,\ + INCLUDE_FILES:=$(BUILD_LIBZIP_FILES), \ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + $(LIBZ_INCLUDE) \ + -I$(JDK_TOPDIR)/src/share/native/java/io \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/java/io,\ + CFLAGS_posix:=$(BUILD_LIBZIP_MMAP) -UDEBUG,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libzip/mapfile-vers, \ + REORDER:=$(BUILD_LIBZIP_REORDER), \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(EXPORT_ZIP_FUNCS), \ + LDFLAGS_winapi:=-export:ZIP_Open -export:ZIP_Close -export:ZIP_FindEntry \ + -export:ZIP_ReadEntry -export:ZIP_GetNextEntry jvm.lib \ + $(WIN_JAVA_LIB),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBZ),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libzip)) + +$(BUILD_LIBZIP) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBZIP) + +########################################################################################## + +$(eval $(call SetupNativeCompilation,BUILD_LIBUNPACK,\ + LIBRARY:=unpack, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/native/com/sun/java/util/jar/pack,\ + EXCLUDE_FILES:=main.cpp,\ + LANG:=C++,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CXXFLAGS_JDKLIB) \ + -DNO_ZLIB -DUNPACK_JNI -DFULL,\ + CFLAGS_release:=-DPRODUCT,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libunpack/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB)\ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_winapi:=-map:$(JDK_OUTPUTDIR)/objs/unpack.map /debug \ + jvm.lib $(WIN_JAVA_LIB),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ + LDFLAGS_SUFFIX_posix:=$(LIBCXX),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libunpack,\ + VERSIONINFO_RESOURCE:=$(JDK_TOPDIR)/src/windows/resource/version.rc,\ + RC_FLAGS:=$(RC_FLAGS)\ + /D "JDK_FNAME=unpack.dll" \ + /D "JDK_INTERNAL_NAME=unpack" \ + /D "JDK_FTYPE=0x2L")) + +$(BUILD_LIBUNPACK) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBUNPACK) + +ifeq ($(OPENJDK_TARGET_OS_API),winapi) + $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)unpack.map: $(BUILD_LIBUNPACK) + $(ECHO) Copying $(@F) + $(CP) $(patsubst %$(SHARED_LIBRARY_SUFFIX),%.map,$<) $@ + + $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)unpack.pdb: $(BUILD_LIBUNPACK) + $(ECHO) Copying $(@F) + $(CP) $(patsubst %$(SHARED_LIBRARY_SUFFIX),%.pdb,$<) $@ +endif + +########################################################################################## + +LIBATTACH_EXCLUDE_FILES:= +ifneq ($(OPENJDK_TARGET_OS),solaris) + LIBATTACH_EXCLUDE_FILES+=SolarisVirtualMachine.c +endif +ifneq ($(OPENJDK_TARGET_OS),linux) + LIBATTACH_EXCLUDE_FILES+=LinuxVirtualMachine.c +endif +ifneq ($(OPENJDK_TARGET_OS),macosx) + LIBATTACH_EXCLUDE_FILES+=BsdVirtualMachine.c +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBATTACH,\ + LIBRARY:=attach, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/tools/attach,\ + EXCLUDE_FILES:=$(LIBATTACH_EXCLUDE_FILES),\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libattach/mapfile-$(OPENJDK_TARGET_OS), \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_solaris:=-ldoor,\ + LDFLAGS_winapi:=psapi.lib advapi32.lib $(WIN_JAVA_LIB) jvm.lib,\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libattach,\ + DEBUG_SYMBOLS:=true)) + +$(BUILD_LIBATTACH) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBATTACH) + +########################################################################################## + +$(eval $(call SetupNativeCompilation,BUILD_LIBDT_SOCKET,\ + LIBRARY:=dt_socket,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/transport/socket \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/transport/socket,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) -DUSE_MMAP \ + -I$(INCLUDEDIR) -I$(JDK_OUTPUTDIR)/include/$(OPENJDK_TARGET_OS) \ + -I$(JDK_TOPDIR)/src/share/transport/socket \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/transport/socket \ + -I$(JDK_TOPDIR)/src/share/back/export \ + -I$(JDK_TOPDIR)/src/share/back,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libdt_socket/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB), \ + LDFLAGS_SUFFIX_linux:=$(LDFLAGS_JDKLIB_SUFFIX) -lpthread,\ + LDFLAGS_SUFFIX_solaris:=-lnsl -lsocket,\ + LDFLAGS_SUFFIX_winapi:=$(LDFLAGS_JDKLIB_SUFFIX) -export:jdwpTransport_OnLoad ws2_32.lib,\ + LDFLAGS_SUFFIX:=,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libdt_socket,\ + DEBUG_SYMBOLS:=true)) + +$(BUILD_LIBDT_SOCKET) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBDT_SOCKET) + +########################################################################################## + +ifeq ($(OPENJDK_TARGET_OS_API),winapi) + + $(eval $(call SetupNativeCompilation,BUILD_LIBDT_SHMEM,\ + LIBRARY:=dt_shmem,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/native/com/sun/tools/jdi \ + $(JDK_TOPDIR)/src/share/transport/shmem \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/transport/shmem,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) -DUSE_MMAP\ + -I$(INCLUDEDIR) -I$(JDK_OUTPUTDIR)/include/$(OPENJDK_TARGET_OS) \ + -I$(JDK_TOPDIR)/src/share/transport/shmem \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/transport/shmem \ + -I$(JDK_TOPDIR)/src/share/back/export, \ + LDFLAGS:=$(LDFLAGS_JDKLIB),\ + LDFLAGS_winapi:=-export:jdwpTransport_OnLoad,\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libdt_shmem)) + + BUILD_LIBRARIES += $(BUILD_LIBDT_SHMEM) + +endif # OPENJDK_TARGET_OS + +########################################################################################## +# JDWP_LOGGING causes log messages to be compiled into the library. These reference the +# __FILE__ macro which here expands to the absolute path of the file while the old build +# system used a relative path. This causes the binaries to differ in size. +$(eval $(call SetupNativeCompilation,BUILD_LIBJDWP,\ + LIBRARY:=jdwp, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/back $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/back,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) -DJDWP_LOGGING\ + -I$(JDK_TOPDIR)/src/share/transport/export \ + -I$(JDK_TOPDIR)/src/share/back/export \ + -I$(JDK_TOPDIR)/src/share/npt \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/npt \ + -I$(JDK_TOPDIR)/src/share/back \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/back \ + -I$(JDK_OUTPUTDIR)/gensrc_jdwp_headers,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjdwp/mapfile-vers, \ + LDFLAGS:=$(filter-out -ljava,$(LDFLAGS_JDKLIB)), \ + LDFLAGS_SUFFIX_linux:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBDL),\ + LDFLAGS_SUFFIX_solaris:=$(LIBDL),\ + LDFLAGS_SUFFIX_windows:=$(LDFLAGS_JDKLIB_SUFFIX),\ + LDFLAGS_SUFFIX:=,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjdwp)) + +$(BUILD_LIBJDWP) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBJDWP) + +########################################################################################## + +LIBJAAS_MAPFILE:= +ifneq ($(OPENJDK_TARGET_OS),solaris) + LIBJAAS_EXCLUDE_FILES:=Solaris.c +else + # only on solaris...wonder why + LIBJAAS_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjaas/mapfile-vers +endif + +LIBJAAS_NAME:=jaas_unix +ifeq ($(OPENJDK_TARGET_OS), windows) + LIBJAAS_NAME:=jaas_nt +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBJAAS,\ + LIBRARY:=$(LIBJAAS_NAME),\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/com/sun/security/auth/module,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB),\ + MAPFILE:=$(LIBJAAS_MAPFILE),\ + LDFLAGS:=$(filter-out -ljava,$(LDFLAGS_JDKLIB)) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_winapi:=netapi32.lib user32.lib mpr.lib advapi32.lib,\ + LDFLAGS_SUFFIX_linux:=$(LDFLAGS_JDKLIB_SUFFIX),\ + LDFLAGS_SUFFIX_windows:=$(LDFLAGS_JDKLIB_SUFFIX),\ + LDFLAGS_SUFFIX:=,\ + EXCLUDE_FILES:=$(LIBJAAS_EXCLUDE_FILES),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjaas)) + +$(BUILD_LIBJAAS) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBJAAS) + +########################################################################################## + +$(eval $(call SetupNativeCompilation,BUILD_LIBJSDT,\ + LIBRARY:=jsdt,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/native/sun/tracing/dtrace\ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/tracing/dtrace,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB)\ + -I$(JDK_TOPDIR)/src/share/native/sun/tracing/dtrace,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjsdt/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_SUFFIX_linux:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBDL),\ + LDFLAGS_SUFFIX_winapi:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBDL),\ + LDFLAGS_SUFFIX_macosx:= $(LIBDL),\ + LDFLAGS_SUFFIX:=,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjsdt, \ + DEBUG_SYMBOLS:= yes)) + +$(BUILD_LIBJSDT) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBJSDT) + +########################################################################################## + +ifdef OPENJDK + # TODO: Update awt lib path when awt is converted + $(eval $(call SetupNativeCompilation,BUILD_LIBLCMS,\ + LIBRARY:=lcms,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/native/sun/java2d/cmm/lcms \ + $(JDK_TOPDIR)/src/share/native/sun/java2d/,\ + INCLUDE_FILES:=cmscam02.c cmscgats.c cmscnvrt.c cmserr.c \ + cmsgamma.c cmsgmt.c cmsintrp.c cmsio0.c \ + cmsio1.c cmslut.c cmsmd5.c cmsmtrx.c \ + cmsnamed.c cmsopt.c cmspack.c cmspcs.c \ + cmsplugin.c cmsps2.c cmssamp.c cmssm.c \ + cmstypes.c cmsvirt.c cmswtpnt.c cmsxform.c \ + LCMS.c,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(filter-out -xc99=%none,$(CFLAGS_JDKLIB)) \ + $(SHARED_LIBRARY_FLAGS) \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug,\ + CFLAGS_solaris:=-xc99=no_lib,\ + CFLAGS_winapi:=-DCMS_IS_WINDOWS_,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/liblcms/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB), \ + LDFLAGS_solaris:=/usr/lib$(ISA_DIR)/libm.so.2,\ + LDFLAGS_winapi:=$(WIN_AWT_LIB) $(WIN_JAVA_LIB),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ + LDFLAGS_SUFFIX_posix:=-lawt,\ + LDFLAGS_SUFFIX_linux:=-lm,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/liblcms)) + + BUILD_LIBRARIES += $(BUILD_LIBLCMS) + + $(BUILD_LIBLCMS) : $(BUILD_LIBAWT) +endif + +########################################################################################## + +ifdef OPENJDK + BUILD_LIBJPEG_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjpeg/mapfile-vers +else + BUILD_LIBJPEG_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjpeg/mapfile-vers-closed + BUILD_LIBJPEG_CLOSED_SRC:=$(JDK_TOPDIR)/src/closed/share/native/sun/awt/image/jpeg + BUILD_LIBJPEG_CLOSED_INCLUDES:=-I$(BUILD_LIBJPEG_CLOSED_SRC) +endif + +BUILD_LIBJPEG_REORDER:= +ifeq ($(OPENJDK_TARGET_OS), solaris) + ifneq ($(ARCH), amd64) + BUILD_LIBJPEG_REORDER:=$(JDK_TOPDIR)/makefiles/mapfiles/libjpeg/reorder-$(ARCH) + endif +endif + +# Suppress gcc warnings like "variable might be clobbered by 'longjmp' +# or 'vfork'": this warning indicates that some variable is placed to +# a register by optimized compiler and it's value might be lost on longjmp(). +# Recommended way to avoid such warning is to declare the variable as +# volatile to prevent the optimization. However, this approach does not +# work because we have to declare all variables as volatile in result. +#ifndef CROSS_COMPILE_ARCH +# CC_43_OR_NEWER:=\ +# $(shell $(EXPR) $(CC_MAJORVER) \> 4 \| \ +# \( $(CC_MAJORVER) = 4 \& $(CC_MINORVER) \>= 3 \) ) +# ifeq ($(CC_43_OR_NEWER),1) +# BUILD_LIBJPEG_CFLAGS_linux += -Wno-clobbered +# endif +#endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBJPEG,\ + LIBRARY:=jpeg, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(BUILD_LIBJPEG_CLOSED_SRC) \ + $(JDK_TOPDIR)/src/share/native/sun/awt/image/jpeg,\ + LANG:=C,\ + OPTIMIZATION:=HIGHEST, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + $(BUILD_LIBJPEG_CLOSED_INCLUDES) \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/jpeg,\ + MAPFILE:=$(BUILD_LIBJPEG_MAPFILE), \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_linux:=$(LIBDL),\ + LDFLAGS_winapi:=$(WIN_JAVA_LIB) jvm.lib,\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ + REORDER:=$(BUILD_LIBJPEG_REORDER),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjpeg)) + +$(BUILD_LIBJPEG) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBJPEG) + +########################################################################################## + +ifndef OPENJDK + FONT_HEADERS:=-I$(CLOSED_SRC)/share/native/$(PKGDIR)/t2k + BUILD_LIBFONTMANAGER_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libfontmanager/mapfile-vers + LIBFONTMANAGER_EXCLUDE_FILES += freetypeScaler.c +else + FONT_HEADERS:=$(FREETYPE2_CFLAGS) + BUILD_LIBFONTMANAGER_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libfontmanager/mapfile-vers.openjdk + BUILD_LIBFONTMANAGER_FONTLIB:=$(FREETYPE2_LIBS) +endif + +LIBFONTMANAGER_OPTIMIZATION:=HIGH + +ifeq ($(OPENJDK_TARGET_OS),windows) + LIBFONTMANAGER_EXCLUDE_FILES += X11FontScaler.c \ + X11TextRenderer.c + LIBFONTMANAGER_OPTIMIZATION:=LOW +else + LIBFONTMANAGER_EXCLUDE_FILES += fontpath.c \ + lcdglyph.c +endif + +BUILD_LIBFONTMANAGER_CFLAGS_COMMON:=\ + $(X_CFLAGS) \ + -DLE_STANDALONE -DHEADLESS \ + $(FONT_HEADERS) \ + -I$(JDK_TOPDIR)/src/share/native/sun/font \ + -I$(JDK_TOPDIR)/src/share/native/sun/font/layout \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/awt \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d/loops \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d/pipe \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d + +# Turn off aliasing with GCC for ExtensionSubtables.cpp +ifeq ($(OPENJDK_TARGET_OS), linux) + BUILD_LIBFONTMANAGER_ExtensionSubtables.cpp_CXXFLAGS:=-fno-strict-aliasing +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBFONTMANAGER,\ + LIBRARY:=fontmanager, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/native/sun/font\ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/font,\ + EXCLUDE_FILES:=$(LIBFONTMANAGER_EXCLUDE_FILES) \ + AccelGlyphCache.c,\ + LANG:=C++,\ + CFLAGS:=$(CFLAGS_JDKLIB) $(BUILD_LIBFONTMANAGER_CFLAGS_COMMON),\ + CXXFLAGS:=$(CXXFLAGS_JDKLIB) $(BUILD_LIBFONTMANAGER_CFLAGS_COMMON),\ + OPTIMIZATION:=$(LIBFONTMANAGER_OPTIMIZATION), \ + CFLAGS_windows= -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/windows \ + -DCC_NOEX, \ + MAPFILE:=$(BUILD_LIBFONTMANAGER_MAPFILE), \ + LDFLAGS:=$(subst -Xlinker -z -Xlinker defs,,$(LDFLAGS_JDKLIB)) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_windows:=advapi32.lib user32.lib gdi32.lib $(WIN_AWT_LIB) $(WIN_JAVA_LIB),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) \ + $(BUILD_LIBFONTMANAGER_FONTLIB),\ + LDFLAGS_SUFFIX_linux:=-lawt $(LIBM) $(LIBCXX),\ + LDFLAGS_SUFFIX_solaris:=-lawt -lawt_xawt -lc $(LIBM) $(LIBCXX),\ + LDFLAGS_SUFFIX_macosx:=-lawt $(LIBM) $(LIBCXX) -undefined dynamic_lookup,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libfontmanager)) + +$(BUILD_LIBFONTMANAGER) : $(BUILD_LIBAWT) + +ifneq (,$(findstring $(OPENJDK_TARGET_OS),solaris macosx)) +$(BUILD_LIBFONTMANAGER) : $(BUILD_LIBAWT_XAWT) +endif + +BUILD_LIBRARIES += $(BUILD_LIBFONTMANAGER) ########################################################################################## ifndef OPENJDK -LIBDCPR_SRC_DIRS := \ +# ifeq ($(OPENJDK_TARGET_OS), linux) +# ifeq ("$(CC_VER_MAJOR)", "3") +# OTHER_LDLIBS += -Wl,-Bstatic -lgcc_eh -Wl,-Bdynamic +# endif +# endif +# +# The resulting size of the t2k lib file is (at least on linux) dependant on the order of +# the input .o files. Because of this the new build will differ in size to the old build. + BUILD_LIBT2K_CFLAGS_COMMON:=-I$(JDK_TOPDIR)/src/share/native/sun/font \ + -I$(JDK_TOPDIR)/src/closed/share/native/sun/font/t2k \ + -I$(JDK_TOPDIR)/src/closed/share/native/sun/font \ + -I$(JDK_TOPDIR)/src/share/share/native/sun/font \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/font \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d/loops \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d/pipe \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d + + $(eval $(call SetupNativeCompilation,BUILD_LIBT2K,\ + LIBRARY:=t2k, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/closed/share/native/sun/font \ + $(JDK_TOPDIR)/src/closed/share/native/sun/font/t2k \ + $(JDK_TOPDIR)/src/closed/share/native/sun/font/t2k/ttHints,\ + EXCLUDE_FILES:=orion.c,\ + LANG:=C++,\ + OPTIMIZATION:=HIGH, \ + CFLAGS:=$(CFLAGS_JDKLIB) $(BUILD_LIBT2K_CFLAGS_COMMON),\ + CXXFLAGS:=$(CXXFLAGS_JDKLIB) $(BUILD_LIBT2K_CFLAGS_COMMON),\ + CFLAGS_windows=-DCC_NOEX, \ + CXXFLAGS_windows=-DCC_NOEX, \ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libt2k/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_windows:=user32.lib $(JDK_OUTPUTDIR)/objs/libfontmanager/fontmanager.lib,\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ + LDFLAGS_SUFFIX_macosx:=$(LIBCXX) $(LIBM) -lfontmanager,\ + LDFLAGS_SUFFIX_linux:=$(LIBCXX) $(LIBM) -lfontmanager,\ + LDFLAGS_SUFFIX_solaris:=$(LIBCXX) $(LIBM) -lfontmanager -lawt \ + -lawt_xawt,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libt2k)) + + # t2k is linked against fontmanager + $(BUILD_LIBT2K) : $(BUILD_LIBFONTMANAGER) + + BUILD_LIBRARIES += $(BUILD_LIBT2K) +endif + +########################################################################################## + +# +# TODO replace with X_FLAGS / X_LIBS +# and add them to configure +# +OPENWIN_LIB:=$(OPENWIN_HOME)/lib + +ifeq ($(OPENJDK_TARGET_OS), windows) + ifeq ($(ARCH_DATA_MODEL), 32) + KERNEL32_LIB:=kernel32.lib + endif + $(eval $(call SetupNativeCompilation,BUILD_LIBJAWT,\ + LIBRARY:=jawt, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/windows,\ + INCLUDE_FILES:=jawt.cpp,\ + LANG:=C++,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CXXFLAGS_JDKLIB) \ + -EHsc -DUNICODE -D_UNICODE \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/windows \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d/windows, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) $(KERNEL32_LIB) \ + advapi32.lib $(WIN_AWT_LIB),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjawt)) + +$(BUILD_LIBJAWT) : $(BUILD_LIBAWT) + +$(JDK_OUTPUTDIR)/lib/$(LIBRARY_PREFIX)jawt$(STATIC_LIBRARY_SUFFIX): $(BUILD_LIBJAWT) + $(ECHO) Copying $(@F) + $(CP) $< $@ + +BUILD_LIBRARIES += $(JDK_OUTPUTDIR)/lib/$(LIBRARY_PREFIX)jawt$(STATIC_LIBRARY_SUFFIX) + +else # OPENJDK_TARGET_OS not windows + + JAWT_LIBS:= + ifneq ($(OPENJDK_TARGET_OS), solaris) + JAWT_LIBS += -lawt + endif + + ifndef BUILD_HEADLESS_ONLY + JAWT_LIBS += -lawt_xawt + else + JAWT_LIBS += -lawt_headless + HEADLESS_CFLAG += -DHEADLESS + endif + + JAWT_FILES:=jawt.c + ifeq ($(OPENJDK_TARGET_OS), macosx) + JAWT_FILES:=jawt.m + JAWT_LIBS:=-lawt_lwawt + endif + + $(eval $(call SetupNativeCompilation,BUILD_LIBJAWT,\ + LIBRARY:=jawt, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/awt \ + $(JDK_TOPDIR)/src/macosx/native/sun/awt,\ + INCLUDE_FILES:=$(JAWT_FILES),\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB), \ + CFLAGS_linux:=$(HEADLESS_CFLAG),\ + CFLAGS_macosx:=-I$(JDK_TOPDIR)/src/solaris/native/sun/awt ,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjawt/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_solaris:=-L$(OPENWIN_HOME)/sfw/lib$(ISA_DIR) -L$(OPENWIN_LIB)$(ISA_DIR),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(JAWT_LIBS),\ + LDFLAGS_SUFFIX_solaris:=-lXrender,\ + LDFLAGS_SUFFIX_macosx:=-framework Cocoa, \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjawt)) + +ifndef BUILD_HEADLESS_ONLY +$(BUILD_LIBJAWT) : $(BUILD_LIBAWT_XAWT) +else +$(BUILD_LIBJAWT) : $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt_headless$(SHARED_LIBRARY_SUFFIX) +endif + +ifeq ($(OPENJDK_TARGET_OS),macosx) +$(BUILD_LIBJAWT) : $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt_lwawt$(SHARED_LIBRARY_SUFFIX) +endif + +endif # OPENJDK_TARGET_OS + +BUILD_LIBRARIES += $(BUILD_LIBJAWT) + +########################################################################################## + +ifndef OPENJDK +ifneq ($(OPENJDK_TARGET_OS), macosx) + +LIBJDBCODBC_DIR :=$(JDK_OUTPUTDIR)/objs/libjdbcodbc +LIBJDBCODBC_NAME :=$(LIBRARY_PREFIX)JdbcOdbc$(SHARED_LIBRARY_SUFFIX) +LIBJDBCODBC_CFLAGS:= +LIBJDBCODBC_LIBS := +LIBJDBCODBC_LDFLAGS:= + +ifeq ($(OPENJDK_TARGET_OS), windows) + LIBJDBCODBC_LDFLAGS:=$(LDFLAGS_JDKLIB) + LIBJDBCODBC_LIBS += odbc32.lib odbccp32.lib $(WIN_JAVA_LIB) advapi32.lib +else + LIBJDBCODBC_CFLAGS:=-DUNIX + +# +# This mimics "current" build system exactly. Link against fake -lodbcinst -lodbc +# but...those are linked with the -soname, causing the dependency to be dropped on linux (gnu ld) +# but kept with other linker (solaris) +# +# IMO very weird behaviour...very weird +# + LIBJDBCODBC_LDFLAGS:=$(patsubst defs,nodefs,$(LDFLAGS_JDKLIB)) \ + -Xlinker -z -Xlinker nodefs + LIBJDBCODBC_LIBS += -L$(LIBJDBCODBC_DIR) -lodbcinst -lodbc + LIBJDBCODBC_SONAME:=$(call SET_SHARED_LIBRARY_NAME,$(LIBJDBCODBC_NAME)) +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBJDBCODBC,\ + LIBRARY:=JdbcOdbc,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/closed/share/classes/sun/jdbc/odbc,\ + EXCLUDE_FILES:=dummyodbc.c,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(LIBJDBCODBC_CFLAGS) $(CFLAGS_JDKLIB) \ + $(SHARED_LIBRARY_FLAGS),\ + LDFLAGS:=$(LIBJDBCODBC_LDFLAGS) \ + $(call SET_SHARED_LIBRARY_ORIGIN) $(LIBJDBCODBC_LIBS),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBJDBCODBC_SONAME),\ + OBJECT_DIR:=$(LIBJDBCODBC_DIR))) + +$(BUILD_LIBJDBCODBC) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBJDBCODBC) + +ifneq ($(OPENJDK_TARGET_OS), windows) + +$(eval $(call SetupNativeCompilation,BUILD_FAKEODBCINST,\ + LIBRARY:=odbcinst,\ + OUTPUT_DIR:=$(LIBJDBCODBC_DIR),\ + SRC:=$(JDK_OUTPUTDIR)/gensrc_c/libjdbcodbc,\ + INCLUDE_FILES:=dummyodbc1.c,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB),\ + LDFLAGS:=$(LDFLAGS_JDKLIB) $(call SET_SHARED_LIBRARY_ORIGIN) $(LIBJDBCODBC_LDFLAGS),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBJDBCODBC_SONAME),\ + OBJECT_DIR:=$(LIBJDBCODBC_DIR))) + +$(eval $(call SetupNativeCompilation,BUILD_FAKEODBC,\ + LIBRARY:=odbc,\ + OUTPUT_DIR:=$(LIBJDBCODBC_DIR),\ + SRC:=$(JDK_OUTPUTDIR)/gensrc_c/libjdbcodbc,\ + INCLUDE_FILES:=dummyodbc2.c,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(LIBJDBCODBC_CFLAGS) $(CFLAGS_JDKLIB),\ + LDFLAGS:=$(LDFLAGS_JDKLIB) $(call SET_SHARED_LIBRARY_ORIGIN) $(LIBJDBCODBC_LDFLAGS),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBJDBCODBC_SONAME),\ + OBJECT_DIR:=$(LIBJDBCODBC_DIR))) + +$(BUILD_FAKEODBCINST) $(BUILD_FAKEODBC) : \ + $(BUILD_LIBJAVA) + +$(BUILD_LIBJDBCODBC) : $(BUILD_FAKEODBCINST) $(BUILD_FAKEODBC) + +endif + +endif +endif + +########################################################################################## + +BUILD_LIBINSTRUMENT_SRC :=$(JDK_TOPDIR)/src/share/instrument \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/java/io \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/instrument + +BUILD_LIBINSTRUMENT_FILES :=\ + EncodingSupport.c \ + EncodingSupport_md.c \ + FileSystemSupport_md.c \ + InstrumentationImplNativeMethods.c \ + InvocationAdapter.c \ + JarFacade.c \ + JPLISAgent.c \ + JPLISAssert.c \ + JavaExceptions.c \ + PathCharsValidator.c \ + Reentrancy.c \ + Utilities.c \ + canonicalize_md.c + +BUILD_LIBINSTRUMENT_DIR :=$(JDK_OUTPUTDIR)/objs/libinstrument +BUILD_LIBINSTRUMENT_CFLAGS:=-I$(JDK_TOPDIR)/src/share/instrument \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/instrument \ + -I$(JDK_TOPDIR)/src/share/bin + +BUILD_LIBINSTRUMENT_LDFLAGS:= +BUILD_LIBINSTRUMENT_LDFLAGS_SUFFIX:= + +ifeq ($(OPENJDK_TARGET_OS), windows) + BUILD_LIBINSTRUMENT_LDFLAGS += $(JDK_OUTPUTDIR)/objs/jli_static.lib $(WIN_JAVA_LIB) \ + -export:Agent_OnAttach + # equivalent of strcasecmp is stricmp on Windows + BUILD_LIBINSTRUMENT_CFLAGS += -Dstrcasecmp=stricmp +else ifneq (,$(findstring $(OPENJDK_TARGET_OS), macosx)) + ifneq ($(ARCH), universal) + BUILD_LIBINSTRUMENT_LDFLAGS += -Wl,-all_load + endif + + BUILD_LIBINSTRUMENT_LDFLAGS += $(JDK_OUTPUTDIR)/objs/libjli_static.a + BUILD_LIBINSTRUMENT_LDFLAGS += -liconv + BUILD_LIBINSTRUMENT_LDFLAGS += -framework Cocoa -framework Security -framework ApplicationServices + BUILD_LIBINSTRUMENT_LDFLAGS += $(LIBZ) +else + BUILD_LIBINSTRUMENT_LDFLAGS += -L $(INSTALL_LIBRARIES_HERE)/jli + BUILD_LIBINSTRUMENT_LDFLAGS_SUFFIX += -ljli $(LIBDL) +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBINSTRUMENT,\ + LIBRARY:=instrument, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(BUILD_LIBINSTRUMENT_SRC),\ + INCLUDE_FILES:=$(BUILD_LIBINSTRUMENT_FILES),\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + $(BUILD_LIBINSTRUMENT_CFLAGS),\ + CFLAGS_debug:=-DJPLIS_LOGGING,\ + CFLAGS_release:=-DNO_JPLIS_LOGGING,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libinstrument/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) $(call SET_SHARED_LIBRARY_ORIGIN)\ + $(call SET_SHARED_LIBRARY_ORIGIN,jli) \ + $(BUILD_LIBINSTRUMENT_LDFLAGS),\ + LDFLAGS_SUFFIX:=$(LIBZ) $(BUILD_LIBINSTRUMENT_LDFLAGS_SUFFIX),\ + OBJECT_DIR:=$(BUILD_LIBINSTRUMENT_DIR),\ + DEBUG_SYMBOLS:=true)) + +ifneq (,$(findstring $(OPENJDK_TARGET_OS), macosx windows)) +$(BUILD_LIBINSTRUMENT) : $(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jli_static$(STATIC_LIBRARY_SUFFIX) +else +$(BUILD_LIBINSTRUMENT) : $(INSTALL_LIBRARIES_HERE)/jli/$(LIBRARY_PREFIX)jli$(SHARED_LIBRARY_SUFFIX) +endif +$(BUILD_LIBINSTRUMENT) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBINSTRUMENT) + +########################################################################################## + +BUILD_LIBMANAGEMENT_SRC:=$(JDK_TOPDIR)/src/share/native/sun/management \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/management \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/com/sun/management + +BUILD_LIBMANAGEMENT_EXCLUDES:= + +BUILD_LIBMANAGEMENT_CFLAGS:=-I$(JDK_TOPDIR)/src/share/native/sun/management + +ifneq ($(OPENJDK_TARGET_OS), windows) + BUILD_LIBMANAGEMENT_EXCLUDES += OperatingSystem_md.c +else + BUILD_LIBMANAGEMENT_EXCLUDES += UnixOperatingSystem_md.c +endif + +ifneq ($(OPENJDK_TARGET_OS),solaris) + BUILD_LIBMANAGEMENT_EXCLUDES += SolarisOperatingSystem.c +endif + +ifneq ($(OPENJDK_TARGET_OS),linux) + BUILD_LIBMANAGEMENT_EXCLUDES += LinuxOperatingSystem.c +endif + +ifneq ($(OPENJDK_TARGET_OS),macosx) + BUILD_LIBMANAGEMENT_EXCLUDES += MacosxOperatingSystem.c +endif + + +$(eval $(call SetupNativeCompilation,BUILD_LIBMANAGEMENT,\ + LIBRARY:=management,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(BUILD_LIBMANAGEMENT_SRC),\ + EXCLUDE_FILES:=$(BUILD_LIBMANAGEMENT_EXCLUDES),\ + LANG:=C,\ + OPTIMIZATION:=HIGH, \ + CFLAGS:=$(CFLAGS_JDKLIB) $(BUILD_LIBMANAGEMENT_CFLAGS),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libmanagement/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_windows:=$(WIN_JAVA_LIB) jvm.lib advapi32.lib psapi.lib,\ + LDFLAGS_solaris:=-lkstat,\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libmanagement,\ + DEBUG_SYMBOLS:=true)) + +$(BUILD_LIBMANAGEMENT) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBMANAGEMENT) + +########################################################################################## + +BUILD_LIBHPROF_SRC:=$(JDK_TOPDIR)/src/share/demo/jvmti/hprof $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/demo/jvmti/hprof +BUILD_LIBHPROF_CFLAGS:=-I$(JDK_TOPDIR)/src/share/demo/jvmti/hprof \ + -I$(JDK_TOPDIR)/src/share/npt \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/npt \ + -I$(JDK_TOPDIR)/src/share/demo/jvmti/java_crw_demo + +BUILD_LIBHPROF_LDFLAGS:= + +ifeq ($(OPENJDK_TARGET_OS),solaris) + BUILD_LIBHPROF_LDFLAGS += -lsocket -lnsl +endif + +ifneq ($(OPENJDK_TARGET_OS),windows) + BUILD_LIBHPROF_LDFLAGS += $(LIBDL) +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBHPROF,\ + LIBRARY:=hprof, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(BUILD_LIBHPROF_SRC),\ + LANG:=C,\ + OPTIMIZATION:=HIGHEST, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + $(BUILD_LIBHPROF_CFLAGS),\ + CFLAGS_debug:=-DHPROF_LOGGING,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libhprof/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_windows:=wsock32.lib winmm.lib advapi32.lib,\ + LDFLAGS_SUFFIX:=$(BUILD_LIBHPROF_LDFLAGS),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libhprof_jvmti,\ + DEBUG_SYMBOLS:=true)) + +BUILD_LIBRARIES += $(BUILD_LIBHPROF) + +########################################################################################## + +$(eval $(call SetupNativeCompilation,BUILD_LIBJAVA_CRW_DEMO,\ + LIBRARY:=java_crw_demo, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/demo/jvmti/java_crw_demo,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + -I$(JDK_TOPDIR)/src/share/demo/jvmti/java_crw_demo,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjava_crw_demo/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_SUFFIX:=,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjava_crw_demo,\ + DEBUG_SYMBOLS:=true)) + +BUILD_LIBRARIES += $(BUILD_LIBJAVA_CRW_DEMO) + +########################################################################################## + +$(eval $(call SetupNativeCompilation,BUILD_LIBNPT,\ + LIBRARY:=npt, \ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/share/npt $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/npt,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + -I$(JDK_TOPDIR)/src/share/npt \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/npt,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libnpt/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_macosx:=-liconv,\ + LDFLAGS_SUFFIX_windows:=-export:nptInitialize -export:nptTerminate,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libnpt,\ + DEBUG_SYMBOLS:=true)) + +BUILD_LIBRARIES += $(BUILD_LIBNPT) + +########################################################################################## + +LIBNET_SRC_DIRS:=$(JDK_TOPDIR)/src/share/native/java/net \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/java/net \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/net/dns \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/net/www/protocol/http/ntlm \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/net/sdp \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/net/spi + +LIBNET_CFLAGS:=$(foreach dir,$(LIBNET_SRC_DIRS),-I$(dir)) + +LIBNET_EXCLUDE_FILES:= +ifneq ($(OPENJDK_TARGET_OS),linux) + LIBNET_EXCLUDE_FILES += linux_close.c +endif + +ifneq ($(OPENJDK_TARGET_OS),macosx) + LIBNET_EXCLUDE_FILES += bsd_close.c +endif + +ifeq ($(OPENJDK_TARGET_OS),windows) + LIBNET_EXCLUDE_FILES += PlainSocketImpl.c PlainDatagramSocketImpl.c SdpSupport.c +else + LIBNET_EXCLUDE_FILES += TwoStacksPlainSocketImpl.c DualStackPlainSocketImpl.c \ + TwoStacksPlainDatagramSocketImpl.c DualStackPlainDatagramSocketImpl.c \ + NTLMAuthSequence.c NetworkInterface_winXP.c +endif + +LIBNET_LDFLAGS_SUFFIX:= + +$(eval $(call SetupNativeCompilation,BUILD_LIBNET,\ + LIBRARY:=net,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(LIBNET_SRC_DIRS),\ + EXCLUDE_FILES:=$(LIBNET_EXCLUDE_FILES), \ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + $(LIBNET_CFLAGS),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libnet/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) $(LIBNET_LDFLAGS_SUFFIX),\ + LDFLAGS_SUFFIX_solaris:=-lnsl -lsocket $(LIBDL) ,\ + LDFLAGS_SUFFIX_linux:=$(LIBDL) -lpthread ,\ + LDFLAGS_SUFFIX_windows:=ws2_32.lib $(JVMLIB) secur32.lib iphlpapi.lib \ + delayimp.lib $(WIN_JAVA_LIB) jvm.lib advapi32.lib \ + /DELAYLOAD:secur32.dll /DELAYLOAD:iphlpapi.dll, \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libnet)) + +$(BUILD_LIBNET) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBNET) + +$(JDK_OUTPUTDIR)/lib/net.properties: $(JDK_TOPDIR)/src/share/lib/net.properties + $(ECHO) Copying $(@F) + $(MKDIR) -p $(@D) + $(CP) $< $@ + +COPY_FILES += $(JDK_OUTPUTDIR)/lib/net.properties + +ifeq ($(OPENJDK_TARGET_OS), solaris) +$(JDK_OUTPUTDIR)/lib/sdp/sdp.conf.template : $(JDK_TOPDIR)/src/${LEGACY_OPENJDK_TARGET_OS_API}/lib/sdp/sdp.conf.template + $(ECHO) Copying $(@F) + $(MKDIR) -p $(@D) + $(CP) $< $@ + +COPY_FILES += $(JDK_OUTPUTDIR)/lib/sdp/sdp.conf.template +endif + +########################################################################################## + +BUILD_LIBNIO_SRC:=\ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/java/nio \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/nio/ch \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/nio/fs + +BUILD_LIBNIO_CFLAGS:=\ + -I$(JDK_TOPDIR)/src/share/native/sun/nio/ch \ + -I$(JDK_TOPDIR)/src/share/native/java/io \ + -I$(JDK_TOPDIR)/src/share/native/java/net \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/java/net + +BUILD_LIBNIO_FILES:=\ + DatagramChannelImpl.c \ + DatagramDispatcher.c \ + FileChannelImpl.c \ + FileDispatcherImpl.c \ + FileKey.c \ + IOUtil.c \ + MappedByteBuffer.c \ + Net.c \ + ServerSocketChannelImpl.c \ + SocketChannelImpl.c \ + SocketDispatcher.c + +ifeq ($(OPENJDK_TARGET_OS), windows) + BUILD_LIBNIO_FILES += \ + Iocp.c \ + RegistryFileTypeDetector.c \ + WindowsAsynchronousFileChannelImpl.c \ + WindowsAsynchronousServerSocketChannelImpl.c \ + WindowsAsynchronousSocketChannelImpl.c \ + WindowsNativeDispatcher.c \ + WindowsSelectorImpl.c +endif + +ifeq ($(OPENJDK_TARGET_OS), linux) + BUILD_LIBNIO_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libnio/mapfile-linux + BUILD_LIBNIO_FILES += \ + EPoll.c \ + EPollArrayWrapper.c \ + EPollPort.c \ + InheritedChannel.c \ + NativeThread.c \ + PollArrayWrapper.c \ + UnixAsynchronousServerSocketChannelImpl.c \ + UnixAsynchronousSocketChannelImpl.c \ + GnomeFileTypeDetector.c \ + LinuxNativeDispatcher.c \ + LinuxWatchService.c \ + UnixCopyFile.c \ + UnixNativeDispatcher.c +endif + +ifeq ($(OPENJDK_TARGET_OS), macosx) + BUILD_LIBNIO_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libnio/mapfile-bsd + BUILD_LIBNIO_SRC += $(JDK_TOPDIR)/src/macosx/native/sun/nio/ch + BUILD_LIBNIO_FILES += \ + InheritedChannel.c \ + NativeThread.c \ + PollArrayWrapper.c \ + UnixAsynchronousServerSocketChannelImpl.c \ + UnixAsynchronousSocketChannelImpl.c \ + GnomeFileTypeDetector.c \ + BsdNativeDispatcher.c \ + UnixCopyFile.c \ + UnixNativeDispatcher.c \ + KQueue.c \ + KQueuePort.c \ + KQueueArrayWrapper.c +endif + +ifeq ($(OPENJDK_TARGET_OS), solaris) + BUILD_LIBNIO_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libnio/mapfile-solaris + BUILD_LIBNIO_FILES += \ + DevPollArrayWrapper.c \ + InheritedChannel.c \ + NativeThread.c \ + PollArrayWrapper.c \ + SolarisEventPort.c \ + UnixAsynchronousServerSocketChannelImpl.c \ + UnixAsynchronousSocketChannelImpl.c \ + GnomeFileTypeDetector.c \ + SolarisNativeDispatcher.c \ + SolarisWatchService.c \ + UnixCopyFile.c \ + UnixNativeDispatcher.c +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBNIO,\ + LIBRARY:=nio,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(BUILD_LIBNIO_SRC),\ + INCLUDE_FILES:=$(BUILD_LIBNIO_FILES), \ + LANG:=C,\ + OPTIMIZATION:=HIGH, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + $(BUILD_LIBNIO_CFLAGS),\ + MAPFILE:=$(BUILD_LIBNIO_MAPFILE), \ + LDFLAGS:=$(LDFLAGS_JDKLIB) $(BUILD_LIBNIO_LDFLAGS) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_SUFFIX_linux:=-ljava -lnet -lpthread $(LIBDL),\ + LDFLAGS_SUFFIX_solaris:=$(LDFLAGS_JDKLIB_SUFFIX) \ + $(JVMLIB) -lsocket -lposix4 $(LIBDL) -lsendfile \ + -ljava -lnet,\ + LDFLAGS_SUFFIX_windows:=$(LDFLAGS_JDKLIB_SUFFIX) \ + $(WIN_JAVA_LIB) $(JDK_OUTPUTDIR)/objs/libnet/net.lib \ + advapi32.lib jvm.lib ws2_32.lib\ + $(JDK_OUTPUTDIR)/objs/libjava/io_util.obj \ + $(JDK_OUTPUTDIR)/objs/libjava/FileDescriptor_md.obj ,\ + LDFLAGS_SUFFIX_macosx:=-ljava -lnet -pthread,\ + LDFLAGS_SUFFIX:=,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libnio)) + +BUILD_LIBRARIES += $(BUILD_LIBNIO) + +$(BUILD_LIBNIO) : $(BUILD_LIBNET) + +########################################################################################## + +ifeq ($(OPENJDK_TARGET_OS_API),posix) + # TODO make this work on macosx + ifneq ($(OPENJDK_TARGET_OS),macosx) + + SCTP_WERROR := -Werror + ifeq ($(OPENJDK_TARGET_CPU_ARCH), ppc) + SCTP_WERROR := + endif + + $(eval $(call SetupNativeCompilation,BUILD_LIBSCTP,\ + LIBRARY:=sctp,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/nio/ch/sctp,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB)\ + -I$(JDK_TOPDIR)/src/share/native/sun/nio/ch \ + -I$(JDK_TOPDIR)/src/share/native/sun/nio/ch/sctp \ + -I$(JDK_TOPDIR)/src/share/native/java/net \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/nio/ch \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/java/net,\ + CFLAGS_linux:=$(SCTP_WERROR),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libsctp/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_SUFFIX_linux:=$(LIBDL) -lpthread,\ + LDFLAGS_SUFFIX_posix:=-lnio -lnet,\ + LDFLAGS_SUFFIX_solaris:=-lsocket,\ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ + INCLUDE_FILES:=SctpNet.c SctpChannelImpl.c SctpServerChannelImpl.c,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libsctp)) + + BUILD_LIBRARIES += $(BUILD_LIBSCTP) + + $(BUILD_LIBSCTP) : $(BUILD_LIBNIO) + endif +endif + +########################################################################################## + +BUILD_LIBJLI_SRC_DIRS:=$(JDK_TOPDIR)/src/share/bin $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/bin +BUILD_LIBJLI_CFLAGS:=$(foreach dir,$(BUILD_LIBJLI_SRC_DIRS),-I$(dir)) + +BUILD_LIBJLI_FILES:=\ + java.c \ + splashscreen_stubs.c \ + parse_manifest.c \ + version_comp.c \ + wildcard.c \ + jli_util.c + +ifeq ($(JVM_VARIANT_ZERO), true) + ERGO_FAMILY:=zero +else # !ZERO_BUILD + ifneq (,$(findstring $(ARCH), amd64 x86_64)) + ERGO_FAMILY:=i586 + else # !X86 FAMILY + ERGO_FAMILY:=$(ARCH) + endif #ARCH_FAMILY +endif # ZERO_BUILD + +ifeq ($(OPENJDK_TARGET_OS), macosx) + BUILD_LIBJLI_CFLAGS += -I$(JDK_TOPDIR)/src/macosx/bin + BUILD_LIBJLI_SRC_DIRS += $(JDK_TOPDIR)/src/macosx/bin + BUILD_LIBJLI_FILES += java_md_common.c java_md_macosx.c + + BUILD_LIBJLI_java_md_macosx.c_CFLAGS:=-x objective-c + BUILD_LIBJLI_STATIC_java_md_macosx.c_CFLAGS:=-x objective-c +endif + +ifeq ($(OPENJDK_TARGET_OS), windows) + BUILD_LIBJLI_FILES += java_md.c +else ifneq ($(OPENJDK_TARGET_OS), macosx) + + BUILD_LIBJLI_FILES += java_md_common.c + BUILD_LIBJLI_FILES += java_md_solinux.c ergo.c + + ERGO_ARCH_FILE = ergo_$(ERGO_FAMILY).c + + # if the architecture specific ergo file exists then + # use it, else use the generic definitions from ergo.c + ifneq ($(wildcard $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/bin/$(ERGO_ARCH_FILE)),) + BUILD_LIBJLI_FILES += $(ERGO_ARCH_FILE) + else # !ERGO_ARCH_FILE + BUILD_LIBJLI_CFLAGS += -DUSE_GENERIC_ERGO + endif # ERGO_ARCH_FILE +endif #WINDOWS + +# Names of arch directories +ifneq ($(OPENJDK_TARGET_OS), macosx) + BUILD_LIBJLI_CFLAGS += -DLIBARCHNAME='"$(LIBARCH)"' +else + BUILD_LIBJLI_CFLAGS += -DLIBARCHNAME='"$(ARCH)"' +endif +ifeq ($(OPENJDK_TARGET_OS), solaris) + ifeq ($(OPENJDK_TARGET_CPU_ARCH), sparc) + BUILD_LIBJLI_CFLAGS += -DLIBARCH32NAME='"sparc"' + BUILD_LIBJLI_CFLAGS += -DLIBARCH64NAME='"sparcv9"' + else + BUILD_LIBJLI_CFLAGS += -DLIBARCH32NAME='"i386"' + BUILD_LIBJLI_CFLAGS += -DLIBARCH64NAME='"amd64"' + endif +endif # OPENJDK_TARGET_OS + +ifeq ($(OPENJDK_TARGET_OS), macosx) + BUILD_LIBJLI_CFLAGS += -DPACKAGE_PATH=\"$(PACKAGE_PATH)\" +endif + +ifneq ($(USE_EXTERNAL_LIBZ),true) + BUILD_LIBJLI_SRC_DIRS += $(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5 + BUILD_LIBJLI_CFLAGS += $(LIBZ_INCLUDE) + BUILD_LIBJLI_FILES += \ + inflate.c \ + inftrees.c \ + inffast.c \ + zadler32.c \ + zcrc32.c \ + zutil.c +endif + +ifeq ($(OPENJDK_TARGET_OS), windows) + LIBJLI_OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE) +else + LIBJLI_OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE)/jli +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBJLI,\ + LIBRARY:=jli,\ + OUTPUT_DIR:=$(LIBJLI_OUTPUT_DIR),\ + SRC:=$(BUILD_LIBJLI_SRC_DIRS),\ + INCLUDE_FILES:=$(BUILD_LIBJLI_FILES),\ + LANG:=C,\ + OPTIMIZATION:=HIGH, \ + CFLAGS:=$(CFLAGS_JDKLIB) $(BUILD_LIBJLI_CFLAGS),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjli/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_SUFFIX:=$(LIBZ),\ + LDFLAGS_SUFFIX_posix:=$(LIBDL) -lc,\ + LDFLAGS_SUFFIX_linux:=-lpthread,\ + LDFLAGS_SUFFIX_windows:=\ + -export:JLI_Launch \ + -export:JLI_ManifestIterate \ + -export:JLI_SetTraceLauncher \ + -export:JLI_ReportErrorMessage \ + -export:JLI_ReportErrorMessageSys \ + -export:JLI_ReportMessage \ + -export:JLI_ReportExceptionDescription \ + advapi32.lib \ + comctl32.lib \ + user32.lib,\ + LDFLAGS_SUFFIX_macosx:=-framework Cocoa -framework Security -framework ApplicationServices, \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjli)) + +BUILD_LIBRARIES += $(BUILD_LIBJLI) + +# On windows, the static library has the same suffix as the import library created by +# with the shared library, so the static library is given a different name. No harm +# in doing it for all platform to reduce complexity. +ifeq ($(OPENJDK_TARGET_OS), windows) + $(eval $(call SetupNativeCompilation,BUILD_LIBJLI_STATIC,\ + STATIC_LIBRARY:=jli_static,\ + OUTPUT_DIR:=$(JDK_OUTPUTDIR)/objs,\ + SRC:=$(BUILD_LIBJLI_SRC_DIRS),\ + INCLUDE_FILES:=$(BUILD_LIBJLI_FILES),\ + LANG:=C,\ + OPTIMIZATION:=HIGH, \ + CFLAGS:=$(CFLAGS_JDKLIB) $(STATIC_LIBRARY_FLAGS) $(BUILD_LIBJLI_CFLAGS),\ + ARFLAGS:=$(ARFLAGS),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjli_static)) + +BUILD_LIBRARIES += $(BUILD_LIBJLI_STATIC) + +else ifeq ($(OPENJDK_TARGET_OS),macosx) + # + # On macosx they do partial (incremental) linking of libjli_static.a + # code it here...rather than add support to NativeCompilation + # as this is first time I see it + $(eval $(call SetupNativeCompilation,BUILD_LIBJLI_STATIC,\ + LIBRARY:=jli_static, \ + OUTPUT_DIR:=$(JDK_OUTPUTDIR)/objs,\ + SRC:=$(BUILD_LIBJLI_SRC_DIRS),\ + INCLUDE_FILES:=$(BUILD_LIBJLI_FILES),\ + LANG:=C,\ + OPTIMIZATION:=HIGH, \ + CFLAGS:=$(CFLAGS_JDKLIB) $(BUILD_LIBJLI_CFLAGS),\ + LDFLAGS:=-nostdlib -r,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjli_static)) + +$(JDK_OUTPUTDIR)/objs/libjli_static.a : $(BUILD_LIBJLI_STATIC) + $(CP) -a $< $@ + +BUILD_LIBRARIES += $(JDK_OUTPUTDIR)/objs/libjli_static.a +endif + +########################################################################################## + +ifeq ($(ENABLE_JFR), true) + +$(eval $(call SetupNativeCompilation,BUILD_LIBJFR,\ + LIBRARY:=jfr,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/closed/share/native/oracle/jfr,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + -I$(JDK_TOPDIR)/src/closed/share/javavm/export, \ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjfr/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjfr)) + +BUILD_LIBRARIES += $(BUILD_LIBJFR) + +endif + +########################################################################################## + +ifndef OPENJDK + +BUILD_LIBKCMS_EXCLUDE_FILES:= +ifeq ($(OPENJDK_TARGET_OS),windows) + BUILD_LIBKCMS_EXCLUDE_FILES += ukcpmgr.c unixmem.c +else + BUILD_LIBKCMS_EXCLUDE_FILES += cmmdll.c registry.c spxffile.c sysinfo.c winmem.c wkcpmgr.c +endif + +BUILD_LIBKCMS_FLAGS:=$(CFLAGS_JDKLIB) + +ifeq ($(OPENJDK_TARGET_OS),solaris) + # This particular library uses a feature called PIC_CODE_SMALL (on solaris) + # implement it like this...since it's only used here + BUILD_LIBKCMS_FLAGS:=$(patsubst -KPIC,-Kpic,$(BUILD_LIBKCMS_FLAGS)) +else ifeq ($(OPENJDK_TARGET_CPU_ARCH), ppc) + BUILD_LIBKCMS_FLAGS:=$(patsubst -fPIC,-fpic,$(BUILD_LIBKCMS_FLAGS)) +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBKCMS,\ + LIBRARY:=kcms,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/closed/share/native/sun/java2d/cmm/kcms,\ + LANG:=C,\ + EXCLUDE_FILES:=$(BUILD_LIBKCMS_EXCLUDE_FILES),\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(BUILD_LIBKCMS_FLAGS) \ + -DJAVACMM -DFUT_CALC_EX -DNO_FUT_GCONST,\ + CFLAGS_linux:=-Wno-missing-field-initializers,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libkcms/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_SUFFIX_linux:=-lpthread,\ + LDFLAGS_SUFFIX_windows:=$(WIN_JAVA_LIB) advapi32.lib user32.lib version.lib, \ + LDFLAGS_SUFFIX:=-lm $(LDFLAGS_JDKLIB_SUFFIX),\ + VERSIONINFO_RESOURCE:=$(JDK_TOPDIR)/src/closed/share/native/sun/java2d/cmm/kcms/cmm.rc,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libkcms)) + +$(BUILD_LIBKCMS) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBKCMS) + +endif + +########################################################################################## + +ifndef OPENJDK +ifeq ($(OPENJDK_TARGET_OS), solaris) +ifneq ($(ARCH), amd64) + +ifeq ($(shell if test "$(OS_VERSION_MAJOR)" -eq 5 -a "$(OS_VERSION_MINOR)" -le 10; then $(ECHO) ok; fi), ok) + +SUNWJDGA_MAPFILE:= +ifneq (,$(findstring $(ARCH),sparc)) + SUNWJDGA_MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjdga/mapfile-vers +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBSUNWJDGA, \ + LIBRARY:=sunwjdga,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/solaris/native/sun/jdga, \ + LANG:=C, \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ + -I$(JDK_TOPDIR)/src/share/javavm/export \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/javavm/export \ + -I$(OPENWIN_HOME)/include, \ + MAPFILE:=$(SUNWJDGA_MAPFILE), \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN), \ + LDFLAGS_SUFFIX:=-L$(OPENWIN_LIB)$(ISA_DIR) -R$(OPENWIN_LIB)$(ISA_DIR) -ldga -lX11 $(LIBDL) -lc, \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libsunwjdga)) + +BUILD_LIBRARIES += $(BUILD_LIBSUNWJDGA) + +endif +endif +endif +endif + +########################################################################################## + +ifeq ($(BUILD_HEADLESS), true) +ifneq ($(OPENJDK_TARGET_OS), windows) + +LIBAWT_HEADLESS_DIRS:=$(JDK_TOPDIR)/src/share/native/sun/font \ + $(JDK_TOPDIR)/src/share/native/sun/java2d/opengl \ + $(JDK_TOPDIR)/src/solaris/native/sun/font \ + $(JDK_TOPDIR)/src/solaris/native/sun/awt \ + $(JDK_TOPDIR)/src/solaris/native/sun/java2d/opengl \ + $(JDK_TOPDIR)/src/solaris/native/sun/java2d/x11 + +LIBAWT_HEADLESS_CFLAGS:=-DHEADLESS=true \ + -DX11_PATH=\"$(X11_PATH)\" -DPACKAGE_PATH=\"$(PACKAGE_PATH)\" \ + $(CUPS_CFLAGS) \ + $(X_CFLAGS) \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/java2d \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d/loops \ + -I$(JDK_TOPDIR)/src/share/native/sun/java2d/pipe \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/image \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils \ + -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/jdga \ + $(foreach dir,$(LIBAWT_HEADLESS_DIRS),-I$(dir)) + +LIBAWT_HEADLESS_FILES:=\ + awt_Font.c \ + HeadlessToolkit.c \ + fontpath.c \ + VDrawingArea.c \ + X11Color.c \ + X11Renderer.c \ + X11PMBlitLoops.c \ + X11SurfaceData.c \ + X11FontScaler_md.c \ + X11TextRenderer_md.c \ + OGLBlitLoops.c \ + OGLBufImgOps.c \ + OGLContext.c \ + OGLFuncs.c \ + OGLMaskBlit.c \ + OGLMaskFill.c \ + OGLPaints.c \ + OGLRenderQueue.c \ + OGLRenderer.c \ + OGLSurfaceData.c \ + OGLTextRenderer.c \ + OGLVertexCache.c \ + GLXGraphicsConfig.c \ + GLXSurfaceData.c \ + AccelGlyphCache.c \ + CUPSfuncs.c + +LIBAWT_HEADLESS_LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) -lawt -lm + +LIBAWT_HEADLESS_REORDER:= +ifeq ($(OPENJDK_TARGET_OS), solaris) + ifneq ($(ARCH), amd64) + LIBAWT_HEADLESS_REORDER:=$(JDK_TOPDIR)/makefiles/mapfiles/libawt_headless/reorder-$(ARCH) + endif +endif + +$(eval $(call SetupNativeCompilation,BUILD_LIBAWT_HEADLESS,\ + LIBRARY:=awt_headless,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(LIBAWT_HEADLESS_DIRS),\ + INCLUDE_FILES:=$(LIBAWT_HEADLESS_FILES),\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) $(LIBAWT_HEADLESS_CFLAGS),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libawt_headless/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + REORDER:=$(LIBAWT_HEADLESS_REORDER), \ + LDFLAGS_SUFFIX:=$(LIBAWT_HEADLESS_LDFLAGS_SUFFIX),\ + LDFLAGS_SUFFIX_posix:=$(LIBDL),\ + LDFLAGS_SUFFIX_macosx:=$(LIBCXX), \ + LDFLAGS_SUFFIX_solaris:=$(LIBCXX), \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libawt_headless)) + +$(BUILD_LIBAWT_HEADLESS) : $(BUILD_LIBAWT) + +BUILD_LIBRARIES += $(BUILD_LIBAWT_HEADLESS) + +endif +endif + +########################################################################################## + +ifndef BUILD_HEADLESS_ONLY +LIBSPLASHSCREEN_DIRS:=\ + $(JDK_TOPDIR)/src/share/native/sun/awt/giflib \ + $(JDK_TOPDIR)/src/share/native/sun/awt/image/jpeg \ + $(JDK_TOPDIR)/src/share/native/sun/awt/libpng \ + $(JDK_TOPDIR)/src/share/native/sun/awt/splashscreen \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/awt/splashscreen + +LIBSPLASHSCREEN_CFLAGS:=-DSPLASHSCREEN -DPNG_NO_MMX_CODE \ + $(foreach dir,$(LIBSPLASHSCREEN_DIRS),-I$(dir)) + +ifeq ($(OPENJDK_TARGET_OS), macosx) + LIBSPLASHSCREEN_CFLAGS:=-I$(JDK_TOPDIR)/src/macosx/native/sun/awt/splashscreen \ + $(LIBSPLASHSCREEN_CFLAGS) \ + -F/System/Library/Frameworks/JavaVM.framework/Frameworks + LIBSPLASHSCREEN_CFLAGS += -DWITH_MACOSX + LIBSPLASHSCREEN_CFLAGS += -I$(JDK_TOPDIR)/src/macosx/native/sun/osxapp + + LIBSPLASHSCREEN_java_awt_SplashScreen.c_CFLAGS:=-x objective-c -O0 + LIBSPLASHSCREEN_splashscreen_gfx_impl.c_CFLAGS:=-x objective-c -O0 + LIBSPLASHSCREEN_splashscreen_gif.c_CFLAGS:=-x objective-c -O0 + LIBSPLASHSCREEN_splashscreen_impl.c_CFLAGS:=-x objective-c -O0 + LIBSPLASHSCREEN_splashscreen_jpeg.c_CFLAGS:=-x objective-c -O0 + LIBSPLASHSCREEN_splashscreen_png.c_CFLAGS:=-x objective-c -O0 + LIBSPLASHSCREEN_splashscreen_sys.m_CFLAGS:=-O0 + +else ifneq ($(OPENJDK_TARGET_OS), windows) + LIBSPLASHSCREEN_CFLAGS += -DWITH_X11 -I$(OPENWIN_HOME)/include -I$(OPENWIN_HOME)/include/X11/extensions +else + LIBSPLASHSCREEN_CFLAGS += -DWITH_WIN32 +endif + +LIBSPLASHSCREEN_FILES:=\ + java_awt_SplashScreen.c \ + splashscreen_gfx_impl.c \ + splashscreen_gif.c \ + splashscreen_impl.c \ + splashscreen_jpeg.c \ + splashscreen_png.c \ + png.c \ + pngerror.c \ + pngget.c \ + pngmem.c \ + pngpread.c \ + pngread.c \ + pngrio.c \ + pngrtran.c \ + pngrutil.c \ + pngset.c \ + pngtrans.c \ + pngwio.c \ + pngwrite.c \ + pngwtran.c \ + pngwutil.c \ + dgif_lib.c \ + gif_err.c \ + gifalloc.c \ + jcomapi.c \ + jdapimin.c \ + jdapistd.c \ + jdcoefct.c \ + jdcolor.c \ + jddctmgr.c \ + jdhuff.c \ + jdinput.c \ + jdmainct.c \ + jdmarker.c \ + jdmaster.c \ + jdmerge.c \ + jdphuff.c \ + jdpostct.c \ + jdsample.c \ + jerror.c \ + jidctflt.c \ + jidctfst.c \ + jidctint.c \ + jidctred.c \ + jmemmgr.c \ + jmemnobs.c \ + jquant1.c \ + jquant2.c \ + jutils.c \ + jcapimin.c \ + jcapistd.c \ + jccoefct.c \ + jccolor.c \ + jcdctmgr.c \ + jchuff.c \ + jcinit.c \ + jcmainct.c \ + jcmarker.c \ + jcmaster.c \ + jcparam.c \ + jcphuff.c \ + jcprepct.c \ + jcsample.c \ + jctrans.c \ + jdtrans.c \ + jfdctflt.c \ + jfdctfst.c \ + jfdctint.c + +ifneq ($(OPENJDK_TARGET_OS), macosx) +LIBSPLASHSCREEN_FILES += splashscreen_sys.c +else +LIBSPLASHSCREEN_DIRS += $(JDK_TOPDIR)/src/macosx/native/sun/awt/splashscreen +LIBSPLASHSCREEN_FILES += splashscreen_sys.m +endif + +LIBSPLASHSCREEN_LDFLAGS_SUFFIX:= + +ifneq ($(USE_EXTERNAL_LIBZ),true) + LIBSPLASHSCREEN_DIRS += $(JDK_TOPDIR)/src/share/native/java/util/zip/zlib-1.2.5 + LIBSPLASHSCREEN_CFLAGS += $(LIBZ_INCLUDE) + LIBSPLASHSCREEN_FILES += \ + compress.c \ + deflate.c \ + gzclose.c \ + gzlib.c \ + gzread.c \ + gzwrite.c \ + infback.c \ + inffast.c \ + inflate.c \ + inftrees.c \ + trees.c \ + uncompr.c \ + zadler32.c \ + zcrc32.c \ + zutil.c +endif + +ifeq ($(OPENJDK_TARGET_OS), macosx) + LIBSPLASHSCREEN_LDFLAGS_SUFFIX += $(LIBM) -lpthread -liconv -losxapp \ + -framework ApplicationServices \ + -framework Foundation \ + -framework Cocoa \ + -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ + -framework JavaNativeFoundation +else ifneq ($(OPENJDK_TARGET_OS), windows) + LIBSPLASHSCREEN_LDFLAGS_SUFFIX += -L$(OPENWIN_LIB)$(ISA_DIR) -lX11 -lXext $(LIBM) -lpthread +else # OPENJDK_TARGET_OS + LIBSPLASHSCREEN_LDFLAGS_SUFFIX += kernel32.lib user32.lib gdi32.lib delayimp.lib /DELAYLOAD:user32.dll +endif # OPENJDK_TARGET_OS + +$(eval $(call SetupNativeCompilation,LIBSPLASHSCREEN,\ + LIBRARY:=splashscreen,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(LIBSPLASHSCREEN_DIRS),\ + INCLUDE_FILES:=$(LIBSPLASHSCREEN_FILES),\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(LIBSPLASHSCREEN_CFLAGS) $(CFLAGS_JDKLIB),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libsplashscreen/mapfile-vers, \ + LDFLAGS:=$(LDFLAGS_JDKLIB) \ + $(call SET_SHARED_LIBRARY_ORIGIN),\ + LDFLAGS_SUFFIX_linux:=$(LIBDL), \ + LDFLAGS_SUFFIX:=$(LIBSPLASHSCREEN_LDFLAGS_SUFFIX) $(LIBZ),\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libsplashscreen)) + +BUILD_LIBRARIES += $(LIBSPLASHSCREEN) + +ifeq ($(OPENJDK_TARGET_OS),macosx) +$(LIBSPLASHSCREEN) : $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)osxapp$(SHARED_LIBRARY_SUFFIX) +endif + +endif + +########################################################################################## + +ifndef OPENJDK + +LIBDCPR_SRC_DIRS:=\ $(JDK_TOPDIR)/src/closed/share/native/sun/dc/doe \ $(JDK_TOPDIR)/src/closed/share/native/sun/dc/path \ $(JDK_TOPDIR)/src/closed/share/native/sun/dc/pr \ $(JDK_TOPDIR)/src/closed/share/native/sun/dc/util -LIBDCPR_CFLAGS := $(foreach dir,$(LIBDCPR_SRC_DIRS),-I$(dir)) \ +LIBDCPR_CFLAGS:=$(foreach dir,$(LIBDCPR_SRC_DIRS),-I$(dir)) \ -I$(JDK_TOPDIR)/src/share/native/sun/java2d/pipe $(eval $(call SetupNativeCompilation,BUILD_LIBDCPR,\ + LIBRARY:=dcpr,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(LIBDCPR_SRC_DIRS),\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ $(LIBDCPR_CFLAGS), \ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libdcpr/mapfile-vers, \ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libdcpr/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB) $(LIBM)\ $(call SET_SHARED_LIBRARY_ORIGIN),\ LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ - LDFLAGS_SUFFIX_posix := $(LIBDL) -lm,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libdcpr,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)dcpr$(SHARED_LIBRARY_SUFFIX))) + LDFLAGS_SUFFIX_posix:=-lm,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libdcpr)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)dcpr$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBDCPR) : $(BUILD_LIBJAVA) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)dcpr$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBDCPR) endif ########################################################################################## $(eval $(call SetupNativeCompilation,BUILD_LIBJ2PCSC,\ + LIBRARY:=j2pcsc,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/share/native/sun/security/smartcardio \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/smartcardio,\ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/smartcardio,\ LANG:=C,\ - CFLAGS_posix:= -D__sun_jdk,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + CFLAGS_posix:=-D__sun_jdk,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/share/native/sun/security/smartcardio \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/smartcardio\ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/smartcardio/MUSCLE,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libj2pcsc/mapfile-vers, \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/smartcardio\ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/smartcardio/MUSCLE,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libj2pcsc/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB) \ $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX_posix := $(LIBDL), \ - LDFLAGS_SUFFIX_windows := winscard.lib,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libj2pcsc,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)j2pcsc$(SHARED_LIBRARY_SUFFIX))) + LDFLAGS_SUFFIX_posix:=$(LIBDL), \ + LDFLAGS_SUFFIX_windows:=winscard.lib,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libj2pcsc)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)j2pcsc$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBJ2PCSC) ########################################################################################## -ifneq ($(PLATFORM), windows) +ifneq ($(OPENJDK_TARGET_OS), windows) $(eval $(call SetupNativeCompilation,BUILD_LIBJ2GSS,\ + LIBRARY:=j2gss,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/share/native/sun/security/jgss/wrapper \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/jgss/wrapper,\ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/jgss/wrapper,\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/share/native/sun/security/jgss/wrapper \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/jgss/wrapper,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libj2gss/mapfile-vers, \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/jgss/wrapper,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libj2gss/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB) \ $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX := $(LIBDL), \ - BIN:=$(JDK_OUTPUTDIR)/objs/libj2gss,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)j2gss$(SHARED_LIBRARY_SUFFIX))) + LDFLAGS_SUFFIX:=$(LIBDL), \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libj2gss)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)j2gss$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBJ2GSS) endif ########################################################################################## -BUILD_LIBKRB5_NAME := -ifeq ($(PLATFORM), windows) - BUILD_LIBKRB5_NAME := w2k_lsa_auth - BUILD_LIBKRB5_FILES := NativeCreds.c WindowsDirectory.c - BUILD_LIBKRB5_SRC := $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/krb5 - BUILD_LIBKRB5_LIBS := Secur32.lib netapi32.lib \ +BUILD_LIBKRB5_NAME:= +ifeq ($(OPENJDK_TARGET_OS), windows) + BUILD_LIBKRB5_NAME:=w2k_lsa_auth + BUILD_LIBKRB5_FILES:=NativeCreds.c WindowsDirectory.c + BUILD_LIBKRB5_SRC:=$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/krb5 + BUILD_LIBKRB5_LIBS:=Secur32.lib netapi32.lib \ kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib \ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib \ odbccp32.lib wsock32.lib -else ifeq ($(PLATFORM), macosx) - BUILD_LIBKRB5_NAME := osxkrb5 - BUILD_LIBKRB5_FILES := nativeccache.c - BUILD_LIBKRB5_LIBS := -framework Kerberos +else ifeq ($(OPENJDK_TARGET_OS), macosx) + BUILD_LIBKRB5_NAME:=osxkrb5 + BUILD_LIBKRB5_FILES:=nativeccache.c + BUILD_LIBKRB5_LIBS:=-framework Kerberos endif ifneq ($(BUILD_LIBKRB5_NAME),) $(eval $(call SetupNativeCompilation,BUILD_LIBKRB5,\ + LIBRARY:=$(BUILD_LIBKRB5_NAME),\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/share/native/sun/security/krb5 \ $(BUILD_LIBKRB5_SRC) ,\ - INCLUDE_FILES := $(BUILD_LIBKRB5_FILES),\ + INCLUDE_FILES:=$(BUILD_LIBKRB5_FILES),\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/share/native/sun/security/krb5 \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/krb5 ,\ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/krb5 ,\ LDFLAGS:=$(LDFLAGS_JDKLIB) \ $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX := $(BUILD_LIBKRB5_LIBS) ,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libkrb5,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)$(BUILD_LIBKRB5_NAME)$(SHARED_LIBRARY_SUFFIX))) + LDFLAGS_SUFFIX:=$(BUILD_LIBKRB5_LIBS) ,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libkrb5)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)$(BUILD_LIBKRB5_NAME)$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBKRB5) endif ########################################################################################## -ifeq ($(PLATFORM), windows) +ifeq ($(OPENJDK_TARGET_OS), windows) $(eval $(call SetupNativeCompilation,BUILD_LIBSUNMSCAPI,\ + LIBRARY:=sunmscapi,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/share/native/sun/security/mscapi \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/mscapi,\ - INCLUDE_FILES := security.cpp, \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/mscapi,\ + INCLUDE_FILES:=security.cpp, \ LANG:=C++,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/share/native/sun/security/mscapi \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/mscapi ,\ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/mscapi ,\ LDFLAGS:=$(LDFLAGS_JDKLIB) \ $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX := Crypt32.Lib advapi32.lib,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libsunmscapi,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)sunmscapi$(SHARED_LIBRARY_SUFFIX))) + LDFLAGS_SUFFIX:=Crypt32.Lib advapi32.lib,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libsunmscapi)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)sunmscapi$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBSUNMSCAPI) endif ########################################################################################## -ifneq ($(PLATFORM)-$(ARCH_DATA_MODEL), windows-64) +ifneq ($(OPENJDK_TARGET_OS)-$(ARCH_DATA_MODEL), windows-64) $(eval $(call SetupNativeCompilation,BUILD_LIBJ2PKCS11,\ + LIBRARY:=j2pkcs11,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/share/native/sun/security/pkcs11 \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/pkcs11 \ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/pkcs11 \ $(JDK_TOPDIR)/src/share/native/sun/security/pkcs11/wrapper \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/pkcs11/wrapper,\ + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/pkcs11/wrapper,\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/share/native/sun/security/pkcs11 \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/pkcs11 \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/pkcs11 \ -I$(JDK_TOPDIR)/src/share/native/sun/security/pkcs11/wrapper \ - -I$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/security/pkcs11/wrapper,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libj2pkcs11/mapfile-vers, \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/security/pkcs11/wrapper,\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libj2pkcs11/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB) \ $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX_posix := $(LIBDL), \ - BIN:=$(JDK_OUTPUTDIR)/objs/libj2pkcs11,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)j2pkcs11$(SHARED_LIBRARY_SUFFIX))) + LDFLAGS_SUFFIX_posix:=$(LIBDL), \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libj2pkcs11)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)j2pkcs11$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBJ2PKCS11) endif ########################################################################################## @@ -2488,40 +2658,56 @@ ifndef DISABLE_INTREE_EC # TODO Set DISABLE_INTREE_EC in configure if src/share/native/sun/security/ec/impl # is not present # -BUILD_LIBSUNEC_FLAGS := -DMP_API_COMPATIBLE -DNSS_ECC_MORE_THAN_SUITE_B \ - -I$(JDK_TOPDIR)/src/share/native/sun/security/ec \ - -I$(JDK_TOPDIR)/src/share/native/sun/security/ec/impl +BUILD_LIBSUNEC_FLAGS:= -I$(JDK_TOPDIR)/src/share/native/sun/security/ec \ + -I$(JDK_TOPDIR)/src/share/native/sun/security/ec/impl + +# +# On sol-sparc...all libraries are compiled with -xregs=no%appl +# (set in CFLAGS_REQUIRED_sparc) +# +# except!!! libsunec.so +# +ECC_JNI_SOLSPARC_FILTER:= +ifeq ($(OPENJDK_TARGET_CPU_ARCH), sparc) + ECC_JNI_SOLSPARC_FILTER:=-xregs=no%appl +endif $(eval $(call SetupNativeCompilation,BUILD_LIBSUNEC,\ + LIBRARY:=sunec,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/share/native/sun/security/ec \ $(JDK_TOPDIR)/src/share/native/sun/security/ec/impl, \ - LANG := C++, \ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) $(BUILD_LIBSUNEC_FLAGS),\ - CXXFLAGS:=$(CXXFLAGS_JDKLIB) $(CXX_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) $(BUILD_LIBSUNEC_FLAGS),\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libsunec/mapfile-vers, \ + LANG:=C++, \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(filter-out $(ECC_JNI_SOLSPARC_FILTER), $(CFLAGS_JDKLIB))\ + $(BUILD_LIBSUNEC_FLAGS) \ + -DMP_API_COMPATIBLE -DNSS_ECC_MORE_THAN_SUITE_B,\ + CXXFLAGS:=$(filter-out $(ECC_JNI_SOLSPARC_FILTER), $(CXXFLAGS_JDKLIB)) \ + $(BUILD_LIBSUNEC_FLAGS),\ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libsunec/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB) \ $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_SUFFIX := $(LIBCXX),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libsunec,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)sunec$(SHARED_LIBRARY_SUFFIX))) + LDFLAGS_SUFFIX:=$(LIBCXX),\ + LDFLAGS_SUFFIX_solaris:=-lc ,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libsunec)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)sunec$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBSUNEC) endif ########################################################################################## -LIBJSOUND_SRC_DIRS := \ +LIBJSOUND_SRC_DIRS:=\ $(JDK_TOPDIR)/src/share/native/com/sun/media/sound \ - $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/com/sun/media/sound + $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/com/sun/media/sound -LIBJSOUND_SRC_FILES := Utilities.c Platform.c +LIBJSOUND_SRC_FILES:=Utilities.c Platform.c -LIBJSOUND_LANG := C -LIBJSOUND_CFLAGS := $(foreach dir,$(LIBJSOUND_SRC_DIRS),-I$(dir)) +LIBJSOUND_LANG:=C +LIBJSOUND_CFLAGS:=$(foreach dir,$(LIBJSOUND_SRC_DIRS),-I$(dir)) -EXTRA_SOUND_JNI_LIBS := +EXTRA_SOUND_JNI_LIBS:= -LIBJSOUND_MIDIFILES := \ +LIBJSOUND_MIDIFILES:=\ MidiInDevice.c \ MidiInDeviceProvider.c \ MidiOutDevice.c \ @@ -2529,16 +2715,16 @@ LIBJSOUND_MIDIFILES := \ PlatformMidi.c # files needed for ports -LIBJSOUND_PORTFILES := \ +LIBJSOUND_PORTFILES:=\ PortMixerProvider.c \ PortMixer.c # files needed for direct audio -LIBJSOUND_DAUDIOFILES := \ +LIBJSOUND_DAUDIOFILES:=\ DirectAudioDeviceProvider.c \ DirectAudioDevice.c -ifeq ($(PLATFORM), windows) +ifeq ($(OPENJDK_TARGET_OS), windows) EXTRA_SOUND_JNI_LIBS += jsoundds LIBJSOUND_CFLAGS += -DX_PLATFORM=X_WINDOWS \ -DUSE_PLATFORM_MIDI_OUT=TRUE \ @@ -2551,15 +2737,15 @@ ifeq ($(PLATFORM), windows) PLATFORM_API_WinOS_Ports.c LIBJSOUND_SRC_FILES += $(LIBJSOUND_MIDIFILES) LIBJSOUND_SRC_FILES += $(LIBJSOUND_PORTFILES) -endif # PLATFORM windows +endif # OPENJDK_TARGET_OS windows -ifeq ($(PLATFORM), linux) +ifeq ($(OPENJDK_TARGET_OS), linux) EXTRA_SOUND_JNI_LIBS += jsoundalsa LIBJSOUND_CFLAGS += -DX_PLATFORM=X_LINUX -endif # PLATFORM linux +endif # OPENJDK_TARGET_OS linux -ifeq ($(PLATFORM), macosx) - LIBJSOUND_LANG := C++ +ifeq ($(OPENJDK_TARGET_OS), macosx) + LIBJSOUND_LANG:=C++ LIBJSOUND_CFLAGS += -DX_PLATFORM=X_MACOSX \ -DUSE_PORTS=TRUE \ -DUSE_DAUDIO=TRUE \ @@ -2576,9 +2762,9 @@ ifeq ($(PLATFORM), macosx) LIBJSOUND_SRC_FILES += $(LIBJSOUND_MIDIFILES) LIBJSOUND_SRC_FILES += $(LIBJSOUND_PORTFILES) LIBJSOUND_SRC_FILES += $(LIBJSOUND_DAUDIOFILES) -endif # PLATFORM macosx +endif # OPENJDK_TARGET_OS macosx -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) LIBJSOUND_CFLAGS += -DX_PLATFORM=X_SOLARIS \ -DUSE_PORTS=TRUE \ -DUSE_DAUDIO=TRUE @@ -2589,7 +2775,7 @@ ifeq ($(PLATFORM), solaris) LIBJSOUND_SRC_FILES += $(LIBJSOUND_MIDIFILES) LIBJSOUND_SRC_FILES += $(LIBJSOUND_PORTFILES) LIBJSOUND_SRC_FILES += $(LIBJSOUND_DAUDIOFILES) -endif # PLATFORM solaris +endif # OPENJDK_TARGET_OS solaris ifeq ($(JVM_VARIANT_ZERO), true) @@ -2623,37 +2809,38 @@ endif LIBJSOUND_CFLAGS += -DEXTRA_SOUND_JNI_LIBS='"$(EXTRA_SOUND_JNI_LIBS)"' $(eval $(call SetupNativeCompilation,BUILD_LIBJSOUND,\ + LIBRARY:=jsound,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(LIBJSOUND_SRC_DIRS),\ - INCLUDE_FILES := $(LIBJSOUND_SRC_FILES),\ + INCLUDE_FILES:=$(LIBJSOUND_SRC_FILES),\ LANG:=$(LIBJSOUND_LANG),\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - $(LIBJSOUND_CFLAGS), \ - CXXFLAGS:=$(CXXFLAGS_JDKLIB) $(CXX_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ - $(LIBJSOUND_CFLAGS), \ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjsound/mapfile-vers, \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) $(LIBJSOUND_CFLAGS), \ + CXXFLAGS:=$(CXXFLAGS_JDKLIB) $(LIBJSOUND_CFLAGS), \ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjsound/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB)\ $(call SET_SHARED_LIBRARY_ORIGIN),\ - LDFLAGS_windows:=java.lib advapi32.lib winmm.lib,\ + LDFLAGS_windows:=$(WIN_JAVA_LIB) advapi32.lib winmm.lib,\ LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX),\ LDFLAGS_SUFFIX_solaris:=-lc ,\ - LDFLAGS_SUFFIX_macosx := -framework CoreAudio -framework CoreFoundation \ + LDFLAGS_SUFFIX_macosx:=-framework CoreAudio -framework CoreFoundation \ -framework CoreServices -framework AudioUnit $(LIBCXX) \ -framework CoreMIDI -framework AudioToolbox ,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjsound,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jsound$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjsound)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jsound$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBJSOUND) : $(BUILD_LIBJAVA) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)jsound$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBJSOUND) ########################################################################################## ifneq ($(filter jsoundalsa, $(EXTRA_SOUND_JNI_LIBS)),) $(eval $(call SetupNativeCompilation,BUILD_LIBJSOUNDALSA,\ + LIBRARY:=jsoundalsa,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(LIBJSOUND_SRC_DIRS),\ - INCLUDE_FILES := Utilities.c $(LIBJSOUND_MIDIFILES) $(LIBJSOUND_PORTFILES) \ + INCLUDE_FILES:=Utilities.c $(LIBJSOUND_MIDIFILES) $(LIBJSOUND_PORTFILES) \ $(LIBJSOUND_DAUDIOFILES) \ PLATFORM_API_LinuxOS_ALSA_CommonUtils.c \ PLATFORM_API_LinuxOS_ALSA_PCM.c \ @@ -2662,24 +2849,23 @@ $(eval $(call SetupNativeCompilation,BUILD_LIBJSOUNDALSA,\ PLATFORM_API_LinuxOS_ALSA_MidiOut.c \ PLATFORM_API_LinuxOS_ALSA_MidiUtils.c \ PLATFORM_API_LinuxOS_ALSA_Ports.c,\ - LANG := C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ $(LIBJSOUND_CFLAGS) \ -DUSE_DAUDIO=TRUE \ -DUSE_PORTS=TRUE \ -DUSE_PLATFORM_MIDI_OUT=TRUE \ -DUSE_PLATFORM_MIDI_IN=TRUE, \ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libjsoundalsa/mapfile-vers, \ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libjsoundalsa/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB)\ $(call SET_SHARED_LIBRARY_ORIGIN),\ LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) -lasound,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjsoundalsa,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jsoundalsa$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjsoundalsa)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jsoundalsa$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBJSOUNDALSA) : $(BUILD_LIBJAVA) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)jsoundalsa$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBJSOUNDALSA) endif @@ -2688,104 +2874,113 @@ endif ifneq ($(filter jsoundds, $(EXTRA_SOUND_JNI_LIBS)),) $(eval $(call SetupNativeCompilation,BUILD_LIBJSOUNDDS,\ + LIBRARY:=jsoundds,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(LIBJSOUND_SRC_DIRS),\ - INCLUDE_FILES := Utilities.c $(LIBJSOUND_DAUDIOFILES) \ + INCLUDE_FILES:=Utilities.c $(LIBJSOUND_DAUDIOFILES) \ PLATFORM_API_WinOS_DirectSound.cpp, \ - LANG := C++,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + LANG:=C++,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ $(LIBJSOUND_CFLAGS) \ -DUSE_DAUDIO=TRUE, \ LDFLAGS:=$(LDFLAGS_JDKLIB)\ $(call SET_SHARED_LIBRARY_ORIGIN),\ LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) dsound.lib winmm.lib user32.lib ole32.lib,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libjsoundds,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jsoundds$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjsoundds)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)jsoundds$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBJSOUNDDS) : $(BUILD_LIBJAVA) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)jsoundds$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBJSOUNDDS) endif ########################################################################################## -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) ifndef OPENJDK $(eval $(call SetupNativeCompilation,BUILD_LIBJ2UCRYPTO,\ + LIBRARY:=j2ucrypto,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/closed/solaris/native/com/oracle/security/ucrypto,\ - LANG := C,\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/closed/solaris/native/com/oracle/security/ucrypto ,\ - MAPFILE := $(JDK_TOPDIR)/makefiles/mapfiles/libj2ucrypto/mapfile-vers, \ + MAPFILE:=$(JDK_TOPDIR)/makefiles/mapfiles/libj2ucrypto/mapfile-vers, \ LDFLAGS:=$(LDFLAGS_JDKLIB)\ $(call SET_SHARED_LIBRARY_ORIGIN), \ LDFLAGS_SUFFIX:=$(LIBDL),\ - BIN:=$(JDK_OUTPUTDIR)/objs/libj2ucrypto,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)j2ucrypto$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libj2ucrypto)) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)j2ucrypto$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBJ2UCRYPTO) : $(BUILD_LIBJAVA) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)j2ucrypto$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBJ2UCRYPTO) endif endif ########################################################################################## -ifeq ($(PLATFORM), macosx) +ifeq ($(OPENJDK_TARGET_OS), macosx) -LIBAPPLESCRIPTENGINE_FILES := \ +LIBAPPLESCRIPTENGINE_FILES:=\ AppleScriptEngine.m \ AppleScriptExecutionContext.m \ AS_NS_ConversionUtils.m \ NS_Java_ConversionUtils.m $(eval $(call SetupNativeCompilation,BUILD_LIBAPPLESCRIPTENGINE,\ + LIBRARY:=AppleScriptEngine,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/macosx/native/apple/applescript,\ - LANG := C,\ + LANG:=C,\ INCLUDE_FILES:=$(LIBAPPLESCRIPTENGINE_FILES),\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/macosx/native/apple/applescript \ -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ -F/System/Library/Frameworks/ApplicationServices.framework/Frameworks, \ LDFLAGS:=$(LDFLAGS_JDKLIB)\ $(call SET_SHARED_LIBRARY_ORIGIN), \ - LDFLAGS_SUFFIX:= \ + LDFLAGS_SUFFIX:=$(LDFLAGS_JDKLIB_SUFFIX) \ -framework Cocoa \ -framework Carbon \ -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ -framework JavaNativeFoundation, \ - BIN:=$(JDK_OUTPUTDIR)/objs/libAppleScriptEngine,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)AppleScriptEngine$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libAppleScriptEngine)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)AppleScriptEngine$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBAPPLESCRIPTENGINE) : $(BUILD_LIBJAVA) + +BUILD_LIBRARIES += $(BUILD_LIBAPPLESCRIPTENGINE) endif ########################################################################################## -ifeq ($(PLATFORM), macosx) +ifeq ($(OPENJDK_TARGET_OS), macosx) -LIBOSXAPP_FILES := \ +LIBOSXAPP_FILES:=\ NSApplicationAWT.m \ QueuingApplicationDelegate.m \ PropertiesUtilities.m \ ThreadUtilities.m $(eval $(call SetupNativeCompilation,BUILD_LIBOSXAPP,\ + LIBRARY:=osxapp,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/macosx/native/sun/osxapp,\ - LANG := C,\ + LANG:=C,\ INCLUDE_FILES:=$(LIBOSXAPP_FILES),\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/macosx/native/sun/osxapp \ -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ -F/System/Library/Frameworks/ApplicationServices.framework/Frameworks,\ LDFLAGS:=$(LDFLAGS_JDKLIB)\ $(call SET_SHARED_LIBRARY_ORIGIN), \ - LDFLAGS_SUFFIX_macosx := \ + LDFLAGS_SUFFIX_macosx:=\ -framework Accelerate \ -framework ApplicationServices \ -framework AudioToolbox \ @@ -2799,18 +2994,17 @@ $(eval $(call SetupNativeCompilation,BUILD_LIBOSXAPP,\ -framework OpenGL \ -framework IOSurface \ -framework QuartzCore, \ - BIN:=$(JDK_OUTPUTDIR)/objs/libosxapp,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)osxapp$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libosxapp)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)osxapp$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBOSXAPP) endif ########################################################################################## -ifeq ($(PLATFORM), macosx) +ifeq ($(OPENJDK_TARGET_OS), macosx) -LIBOSX_FILES := \ +LIBOSX_FILES:=\ Dispatch.m \ CFileManager.m \ KeystoreImpl.m \ @@ -2818,7 +3012,7 @@ LIBOSX_FILES := \ MacOSXPreferencesFile.m \ SCDynamicStoreConfig.m -LIBOSX_DIRS := \ +LIBOSX_DIRS:=\ $(JDK_TOPDIR)/src/macosx/native/com/apple/concurrent \ $(JDK_TOPDIR)/src/macosx/native/java/util \ $(JDK_TOPDIR)/src/macosx/native/com/apple/eio \ @@ -2826,17 +3020,20 @@ LIBOSX_DIRS := \ $(JDK_TOPDIR)/src/macosx/native/apple/launcher $(eval $(call SetupNativeCompilation,BUILD_LIBOSX,\ + LIBRARY:=osx,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(LIBOSX_DIRS),\ - LANG := C,\ + LANG:=C,\ INCLUDE_FILES:=$(LIBOSX_FILES),\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ $(foreach dir,$(LIBOSX_DIRS),-I$(dir)) \ -I$(JDK_TOPDIR)/src/macosx/native/sun/osxapp \ -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ -F/System/Library/Frameworks/ApplicationServices.framework/Frameworks,\ LDFLAGS:=$(LDFLAGS_JDKLIB)\ $(call SET_SHARED_LIBRARY_ORIGIN), \ - LDFLAGS_SUFFIX_macosx := \ + LDFLAGS_SUFFIX_macosx:=\ -losxapp \ -framework Cocoa \ -framework ApplicationServices \ @@ -2846,24 +3043,21 @@ $(eval $(call SetupNativeCompilation,BUILD_LIBOSX,\ -framework Security \ -framework SystemConfiguration \ $(LDFLAGS_JDKLIB_SUFFIX), \ - BIN:=$(JDK_OUTPUTDIR)/objs/libosx,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)osx$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libosx)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)osx$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBOSX) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)osx$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)osxapp$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBOSX) : $(BUILD_LIBOSXAPP) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)osx$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBOSX) : $(BUILD_LIBJAVA) endif ########################################################################################## -ifeq ($(PLATFORM), macosx) +ifeq ($(OPENJDK_TARGET_OS), macosx) -LIBAWT_LWAWT_FILES := \ +LIBAWT_LWAWT_FILES:=\ awt.m \ ApplicationDelegate.m \ CFRetainedResource.m \ @@ -2938,7 +3132,7 @@ LIBAWT_LWAWT_FILES := \ CUPSfuncs.c -LIBAWT_LWAWT_DIRS := \ +LIBAWT_LWAWT_DIRS:=\ $(JDK_TOPDIR)/src/macosx/native/sun/awt \ $(JDK_TOPDIR)/src/macosx/native/sun/font \ $(JDK_TOPDIR)/src/macosx/native/sun/java2d/opengl \ @@ -2947,10 +3141,13 @@ LIBAWT_LWAWT_DIRS := \ $(JDK_TOPDIR)/src/share/native/sun/java2d/opengl \ $(eval $(call SetupNativeCompilation,BUILD_LIBAWT_LWAWT,\ + LIBRARY:=awt_lwawt,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(LIBAWT_LWAWT_DIRS),\ - LANG := C,\ + LANG:=C,\ INCLUDE_FILES:=$(LIBAWT_LWAWT_FILES),\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ $(foreach dir,$(LIBAWT_LWAWT_DIRS),-I$(dir)) \ -I$(JDK_TOPDIR)/src/macosx/native/sun/osxapp \ -I$(JDK_TOPDIR)/src/share/native/sun/java2d \ @@ -2964,7 +3161,7 @@ $(eval $(call SetupNativeCompilation,BUILD_LIBAWT_LWAWT,\ -F/System/Library/Frameworks/ApplicationServices.framework/Frameworks,\ LDFLAGS:=$(LDFLAGS_JDKLIB)\ $(call SET_SHARED_LIBRARY_ORIGIN), \ - LDFLAGS_SUFFIX_macosx := \ + LDFLAGS_SUFFIX_macosx:=\ -lawt -lmlib_image -losxapp $(LDFLAGS_JDKLIB_SUFFIX) $(LIBM) \ -framework Accelerate \ -framework ApplicationServices \ @@ -2978,30 +3175,25 @@ $(eval $(call SetupNativeCompilation,BUILD_LIBAWT_LWAWT,\ -framework JavaRuntimeSupport \ -framework OpenGL \ -framework QuartzCore ,\ - BIN:=$(JDK_OUTPUTDIR)/objs/libawt_lwawt,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_lwawt$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libawt_lwawt)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt_lwawt$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBAWT_LWAWT) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_lwawt$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBAWT_LWAWT) : $(BUILD_LIBAWT) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_lwawt$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)mlib_image$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBAWT_LWAWT) : $(BUILD_LIBMLIB_IMAGE) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_lwawt$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)osxapp$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBAWT_LWAWT) : $(BUILD_LIBOSXAPP) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)awt_lwawt$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBAWT_LWAWT) : $(BUILD_LIBJAVA) endif ########################################################################################## -ifeq ($(PLATFORM), macosx) +ifeq ($(OPENJDK_TARGET_OS), macosx) -LIBOSXUI_FILES := \ +LIBOSXUI_FILES:=\ AquaFileView.m \ AquaLookAndFeel.m \ AquaNativeResources.m \ @@ -3012,17 +3204,21 @@ LIBOSXUI_FILES := \ ScreenMenu.m $(eval $(call SetupNativeCompilation,BUILD_LIBOSXUI,\ + LIBRARY:=osxui,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ SRC:=$(JDK_TOPDIR)/src/macosx/native/com/apple/laf,\ - LANG := C,\ + LANG:=C,\ INCLUDE_FILES:=$(LIBOSXUI_FILES),\ - CFLAGS:=$(CFLAGS_JDKLIB) $(C_O_FLAG_NORM) $(SHARED_LIBRARY_FLAGS) \ + OPTIMIZATION:=LOW, \ + CFLAGS:=$(CFLAGS_JDKLIB) \ -I$(JDK_TOPDIR)/src/macosx/native/com/apple/laf \ -I$(JDK_TOPDIR)/src/macosx/native/sun/osxapp \ -I$(JDK_TOPDIR)/src/macosx/native/sun/awt \ -F/System/Library/Frameworks/JavaVM.framework/Frameworks, \ LDFLAGS:=$(LDFLAGS_JDKLIB)\ $(call SET_SHARED_LIBRARY_ORIGIN), \ - LDFLAGS_SUFFIX_macosx := \ + LDFLAGS_SUFFIX_macosx:=\ + $(LDFLAGS_JDKLIB_SUFFIX) \ -lawt -losxapp -lawt_lwawt \ -framework Cocoa \ -framework Carbon \ @@ -3030,22 +3226,49 @@ $(eval $(call SetupNativeCompilation,BUILD_LIBOSXUI,\ -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ -framework JavaNativeFoundation \ -framework JavaRuntimeSupport, \ - BIN:=$(JDK_OUTPUTDIR)/objs/libosxui,\ - LIB:=$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)osxui$(SHARED_LIBRARY_SUFFIX))) + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libosxui)) -BUILD_LIBRARIES += $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)osxui$(SHARED_LIBRARY_SUFFIX) +BUILD_LIBRARIES += $(BUILD_LIBOSXUI) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)osxui$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBOSXUI) : $(BUILD_LIBAWT) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)osxui$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)osxapp$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBOSXUI) : $(BUILD_LIBOSXAPP) -$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)osxui$(SHARED_LIBRARY_SUFFIX) : \ - $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)awt_lwawt$(SHARED_LIBRARY_SUFFIX) +$(BUILD_LIBOSXUI) : $(BUILD_LIBAWT_LWAWT) -#$(JDK_OUTPUTDIR)/objs/$(LIBRARY_PREFIX)osxui$(SHARED_LIBRARY_SUFFIX) : \ -# $(INSTALL_LIBRARIES_HERE)/$(LIBRARY_PREFIX)java$(SHARED_LIBRARY_SUFFIX) +#$(BUILD_LIBOSXUI) : $(BUILD_LIBJAVA) + +endif + +########################################################################################## + +ifeq ($(OPENJDK_TARGET_OS), macosx) + +$(eval $(call SetupNativeCompilation,BUILD_LIBJOBJC,\ + LIBRARY:=JObjC,\ + OUTPUT_DIR:=$(INSTALL_LIBRARIES_HERE),\ + SRC:=$(JDK_TOPDIR)/src/macosx/native/jobjc/src/core/native \ + $(JDK_TOPDIR)/src/macosx/native/jobjc/src/runtime-additions/native ,\ + LANG:=C,\ + OPTIMIZATION:=LOW, \ + CFLAGS:=-fpascal-strings \ + -fobjc-gc \ + -gdwarf-2 \ + $(CFLAGS_JDKLIB) \ + -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ + , \ + LDFLAGS:=-fpascal-strings \ + -fobjc-gc \ + -gdwarf-2 \ + $(LDFLAGS_JDKLIB)\ + $(call SET_SHARED_LIBRARY_ORIGIN), \ + LDFLAGS_SUFFIX:=-framework Foundation -framework JavaVM \ + -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ + -framework JavaNativeFoundation \ + -lffi, \ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/libjobjc)) + +BUILD_LIBRARIES += $(BUILD_LIBJOBJC) endif diff --git a/jdk/makefiles/CopyFiles.gmk b/jdk/makefiles/CopyFiles.gmk index 7f8fea433c9..63ffaa5a263 100644 --- a/jdk/makefiles/CopyFiles.gmk +++ b/jdk/makefiles/CopyFiles.gmk @@ -25,12 +25,12 @@ INCLUDEDIR = $(JDK_OUTPUTDIR)/include -PLATFORM_INCLUDE = $(INCLUDEDIR)/$(PLATFORM) +OPENJDK_TARGET_OS_INCLUDE = $(INCLUDEDIR)/$(OPENJDK_TARGET_OS) -ifeq ($(PLATFORM), windows) - PLATFORM_INCLUDE = $(INCLUDEDIR)/win32 -else ifeq ($(PLATFORM), macosx) - PLATFORM_INCLUDE = $(INCLUDEDIR)/darwin +ifeq ($(OPENJDK_TARGET_OS), windows) + OPENJDK_TARGET_OS_INCLUDE = $(INCLUDEDIR)/win32 +else ifeq ($(OPENJDK_TARGET_OS), macosx) + OPENJDK_TARGET_OS_INCLUDE = $(INCLUDEDIR)/darwin endif # @@ -42,15 +42,15 @@ H_TARGET_FILES =$(INCLUDEDIR)/jdwpTransport.h \ $(INCLUDEDIR)/jvmticmlr.h \ $(INCLUDEDIR)/classfile_constants.h \ $(INCLUDEDIR)/jawt.h \ - $(PLATFORM_INCLUDE)/jni_md.h \ - $(PLATFORM_INCLUDE)/jawt_md.h + $(OPENJDK_TARGET_OS_INCLUDE)/jni_md.h \ + $(OPENJDK_TARGET_OS_INCLUDE)/jawt_md.h $(INCLUDEDIR)/%.h: $(JDK_TOPDIR)/src/share/javavm/export/%.h $(MKDIR) -p $(@D) $(RM) -f $@ $(CP) $< $@ -$(PLATFORM_INCLUDE)/%.h: $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/javavm/export/%.h +$(OPENJDK_TARGET_OS_INCLUDE)/%.h: $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/javavm/export/%.h $(MKDIR) -p $(@D) $(RM) -f $@ $(CP) $< $@ @@ -83,6 +83,13 @@ $(MGMT_LIBDIR)/management.properties: $(MGMT_LIB_SRC)/management.properties $(CP) $< $@ $(CHMOD) 644 $@ +# this file has different permissions...don't know why... +$(MGMT_LIBDIR)/jmxremote.access: $(MGMT_LIB_SRC)/jmxremote.access + $(MKDIR) -p $(@D) + $(RM) -f $@ + $(CP) $< $@ + $(CHMOD) 644 $@ + $(MGMT_LIBDIR)/%: $(MGMT_LIB_SRC)/% $(MKDIR) -p $(@D) $(RM) -f $@ @@ -121,9 +128,13 @@ COPY_FILES += $(PSFONTPROPFILE_TARGET_FILES) # # Copy flavormap.properties, cursor.properties and cursors gif files to LIBDIR # -PLATFORM_LIB_SRC = $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/lib +ifneq ($(OPENJDK_TARGET_OS), macosx) +OPENJDK_TARGET_OS_LIB_SRC = $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/lib +else +OPENJDK_TARGET_OS_LIB_SRC = $(JDK_TOPDIR)/src/macosx/lib +endif -$(LIBDIR)/flavormap.properties: $(PLATFORM_LIB_SRC)/flavormap.properties +$(LIBDIR)/flavormap.properties: $(OPENJDK_TARGET_OS_LIB_SRC)/flavormap.properties $(MKDIR) -p $(@D) $(RM) -f $@ $(CP) $< $@ @@ -131,9 +142,9 @@ $(LIBDIR)/flavormap.properties: $(PLATFORM_LIB_SRC)/flavormap.properties COPY_FILES += $(LIBDIR)/flavormap.properties CURSORS_DEST_DIR = $(LIBDIR)/images/cursors -CURSORS_PLATFORM_LIB_SRC = $(PLATFORM_LIB_SRC)/images/cursors +CURSORS_OPENJDK_TARGET_OS_LIB_SRC = $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/lib/images/cursors -$(CURSORS_DEST_DIR)/cursors.properties: $(CURSORS_PLATFORM_LIB_SRC)/cursors.properties +$(CURSORS_DEST_DIR)/cursors.properties: $(CURSORS_OPENJDK_TARGET_OS_LIB_SRC)/cursors.properties $(MKDIR) -p $(@D) $(RM) -f $@ $(CP) $< $@ @@ -141,11 +152,11 @@ $(CURSORS_DEST_DIR)/cursors.properties: $(CURSORS_PLATFORM_LIB_SRC)/cursors.prop COPY_FILES += $(CURSORS_DEST_DIR)/cursors.properties CURSORS_LIB_SRC = $(JDK_TOPDIR)/src/share/lib/images/cursors -ifeq ($(PLATFORM), windows) +ifeq ($(OPENJDK_TARGET_OS), windows) CURSORS_SRC_FILES = $(CURSORS_LIB_SRC)/invalid32x32.gif $(wildcard $(CURSORS_LIB_SRC)/win32_*.gif) -else # PLATFORM +else # OPENJDK_TARGET_OS CURSORS_SRC_FILES = $(CURSORS_LIB_SRC)/invalid32x32.gif $(wildcard $(CURSORS_LIB_SRC)/motif_*.gif) -endif # PLATFORM +endif # OPENJDK_TARGET_OS CURSORS_TARGET_FILES = $(subst $(CURSORS_LIB_SRC),$(CURSORS_DEST_DIR),$(CURSORS_SRC_FILES)) $(CURSORS_DEST_DIR)/%: $(CURSORS_LIB_SRC)/% @@ -157,7 +168,7 @@ COPY_FILES += $(CURSORS_TARGET_FILES) ########################################################################################## -CONTENT_TYPES_SRC=$(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/lib +CONTENT_TYPES_SRC=$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/lib $(LIBDIR)/content-types.properties: $(CONTENT_TYPES_SRC)/content-types.properties $(MKDIR) -p $(@D) @@ -179,9 +190,9 @@ COPY_FILES += $(LIBDIR)/calendars.properties ########################################################################################## -ifeq ($(PLATFORM),windows) +ifeq ($(OPENJDK_TARGET_OS),windows) -TZMAPPINGS_SRC := $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/lib +TZMAPPINGS_SRC := $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/lib $(LIBDIR)/tzmappings: $(TZMAPPINGS_SRC)/tzmappings $(MKDIR) -p $(@D) @@ -233,7 +244,7 @@ COPY_FILES += $(ICCPROFILE_TARGET_FILES) #TODO: rework this to avoid hardcoding library name in the makefile # ifdef OPENJDK - ifeq ($(PLATFORM), windows) + ifeq ($(OPENJDK_TARGET_OS), windows) FREETYPE_LIB = $(JDK_OUTPUTDIR)/bin/$(call SHARED_LIBRARY,freetype) else ifeq ($(USING_SYSTEM_FT_LIB), false) @@ -243,7 +254,7 @@ ifdef OPENJDK $(FREETYPE_LIB): $(FREETYPE2_LIB_PATH)/$(call SHARED_LIBRARY,freetype) $(CP) $(FREETYPE2_LIB_PATH)/$(call SHARED_LIBRARY,freetype) $@ - ifeq ($(BUILD_OS), windows) + ifeq ($(OPENJDK_BUILD_OS), windows) $(CHMOD) +rx $@ endif @@ -254,7 +265,7 @@ endif # Copy msvcr100.dll on windows -ifeq ($(PLATFORM),windows) +ifeq ($(OPENJDK_TARGET_OS),windows) MSVCRNN_TARGET := $(JDK_OUTPUTDIR)/bin/$(notdir $(MSVCRNN_DLL)) $(MSVCRNN_TARGET): $(MSVCRNN_DLL) $(MKDIR) -p $(@D) @@ -286,14 +297,14 @@ else JVMCFG_ARCH := $(ARCH) endif -ifeq ($(PLATFORM),macosx) +ifeq ($(OPENJDK_TARGET_OS),macosx) ifeq ($(JVMCFG_ARCH),amd64) JVMCFG_ARCH := x86_64 endif JVMCFG_SRC := $(JDK_TOPDIR)/src/macosx/bin/$(JVMCFG_ARCH)/jvm.cfg JVMCFG_DIR := $(JDK_OUTPUTDIR)/lib else - JVMCFG_SRC := $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/bin/$(JVMCFG_ARCH)/jvm.cfg + JVMCFG_SRC := $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/bin/$(JVMCFG_ARCH)/jvm.cfg JVMCFG_DIR := $(JDK_OUTPUTDIR)/lib/$(LIBARCH) endif @@ -353,15 +364,15 @@ COPY_FILES += $(JVMCFG) PROPS_SRC := $(JDK_TOPDIR)/src/share/lib/security/java.security PROPS_DST := $(JDK_OUTPUTDIR)/lib/security/java.security -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) PROPS_SRC := $(JDK_TOPDIR)/src/share/lib/security/java.security-solaris endif -ifeq ($(PLATFORM), windows) +ifeq ($(OPENJDK_TARGET_OS), windows) PROPS_SRC := $(JDK_TOPDIR)/src/share/lib/security/java.security-windows endif -ifeq ($(PLATFORM), macosx) +ifeq ($(OPENJDK_TARGET_OS), macosx) PROPS_SRC := $(JDK_TOPDIR)/src/share/lib/security/java.security-macosx endif @@ -453,7 +464,7 @@ $(SHARED_FONTS_DST_DIR)/fonts.dir : $(JDK_TOPDIR)/src/solaris/classes/sun/awt/mo COPY_FILES += $(SHARED_FONTS_DST) $(SHARED_FONTS_DST_DIR)/fonts.dir -ifeq ($(PLATFORM), linux) +ifeq ($(OPENJDK_TARGET_OS), linux) # The oblique fonts are only needed/wanted on Linux. @@ -532,11 +543,13 @@ $(JDK_OUTPUTDIR)/lib/$(LIBARCH)/libxinerama.so: $(JDK_TOPDIR)/src/closed/solaris $(MKDIR) -p $(@D) $(RM) $@ $(CP) $< $@ + $(CHMOD) 755 $@ $(JDK_OUTPUTDIR)/lib/$(LIBARCH)/libjdgaSUNW%.so: $(JDK_TOPDIR)/src/closed/solaris/lib/$(ARCH)/libjdgaSUNW%.so $(MKDIR) -p $(@D) $(RM) $@ $(CP) $< $@ + $(CHMOD) 755 $@ $(JDK_OUTPUTDIR)/lib/$(LIBARCH)/libjdgaSUNWafb.so: $(JDK_OUTPUTDIR)/lib/$(LIBARCH)/libjdgaSUNWffb.so $(MKDIR) -p $(@D) @@ -549,7 +562,7 @@ endif ########################################################################################## -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) SUNPKCS11_CFG_SRC := $(JDK_TOPDIR)/src/share/lib/security/sunpkcs11-solaris.cfg SUNPKCS11_CFG_DST := $(JDK_OUTPUTDIR)/lib/security/sunpkcs11-solaris.cfg @@ -566,7 +579,7 @@ endif ########################################################################################## ifndef OPENJDK -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) UCRYPTO_CFG_SRC := $(JDK_TOPDIR)/src/closed/share/lib/security/ucrypto-solaris.cfg UCRYPTO_CFG_DST := $(JDK_OUTPUTDIR)/lib/security/ucrypto-solaris.cfg diff --git a/jdk/makefiles/CopyIntoClasses.gmk b/jdk/makefiles/CopyIntoClasses.gmk index 92f9330616d..4e9726e452b 100644 --- a/jdk/makefiles/CopyIntoClasses.gmk +++ b/jdk/makefiles/CopyIntoClasses.gmk @@ -133,7 +133,7 @@ COPY_FILES += \ $(wildcard $(SWING_PLAF_METAL_RESOURCES_DIR)/icons/ocean/*.png) \ $(wildcard $(SWING_PLAF_METAL_RESOURCES_DIR)/sounds/*.wav) -ifneq ($(PLATFORM), windows) +ifneq ($(OPENJDK_TARGET_OS), windows) # Only copy GTK resources on Solaris/Linux SWING_PLAF_GTK_RESOURCES_DIR = $(JDK_TOPDIR)/src/share/classes/com/sun/java/swing/plaf/gtk COPY_FILES += \ @@ -174,11 +174,11 @@ COPY_FILES += \ $(shell $(MKDIR) -p $(JDK_OUTPUTDIR)/classes/META-INF/services) # Find all META-INF/services/* files ALL_META-INF_DIRS_share:=$(shell $(FIND) $(JDK_TOPDIR)/src/share/classes -type d -a -name META-INF) -ALL_META-INF_DIRS_hostapi:=$(shell $(FIND) $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes -type d -a -name META-INF) +ALL_META-INF_DIRS_targetapi:=$(shell $(FIND) $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes -type d -a -name META-INF) # Platform specific overrides shared -ifneq ($(ALL_META-INF_DIRS_hostapi),) - ALL_META-INF_DIRS:=$(ALL_META-INF_DIRS_hostapi) \ - $(filter-out %$(patsubst $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes%,%,$(ALL_META-INF_DIRS_hostapi)),\ +ifneq ($(ALL_META-INF_DIRS_targetapi),) + ALL_META-INF_DIRS:=$(ALL_META-INF_DIRS_targetapi) \ + $(filter-out %$(patsubst $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes%,%,$(ALL_META-INF_DIRS_targetapi)),\ $(ALL_META-INF_DIRS_share)) else ALL_META-INF_DIRS:=$(ALL_META-INF_DIRS_share) @@ -189,7 +189,7 @@ ifdef OPENJDK endif ifndef OPENJDK -ifneq ($(PLATFORM), macosx) +ifneq ($(OPENJDK_TARGET_OS), macosx) ALL_META-INF_DIRS += $(JDK_TOPDIR)/src/closed/share/classes/sun/jdbc/odbc/META-INF endif endif @@ -216,9 +216,9 @@ OUT_SERVICES_FILES:=$(addprefix $(JDK_OUTPUTDIR)/classes/META-INF/services/,\ $(shell $(PRINTF) "$(SRC_SERVICES_FILES)\n" | $(SED) -e 's|/[^ ]*/META-INF/services/||g')) OUT_SERVICES_FILES_COLON:=$(addsuffix :,$(OUT_SERVICES_FILES)) # Exception handling for print services with no META-INF directory -SRC_SERVICES_FILES_PRINT = $(wildcard $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes/sun/print/services/*) +SRC_SERVICES_FILES_PRINT = $(wildcard $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes/sun/print/services/*) OUT_SERVICES_FILES_PRINT = $(addprefix $(JDK_OUTPUTDIR)/classes/META-INF/services/,\ - $(patsubst $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes/sun/print/services/%,%,\ + $(patsubst $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes/sun/print/services/%,%,\ $(SRC_SERVICES_FILES_PRINT))) OUT_SERVICES_FILES_PRINT_COLON = $(addsuffix :,$(OUT_SERVICES_FILES_PRINT)) RULES_SERVICES_PRINT = $(join $(OUT_SERVICES_FILES_PRINT_COLON),$(SRC_SERVICES_FILES_PRINT)) @@ -229,7 +229,7 @@ META-INF_RULES_SERVICES:=$(RULES_SERVICES_PRINT) $(join $(OUT_SERVICES_FILES_COL define addto_meta-inf_services $1 echo Installing META-INF/services/$$(@F) - $(CAT) $$< | $(SED) -e "s/^#\[$(PLATFORM)\]//" > $$@ + $(CAT) $$< | $(SED) -e "s/^#\[$(OPENJDK_TARGET_OS)\]//" > $$@ endef $(foreach i,$(META-INF_RULES_SERVICES),$(eval $(call addto_meta-inf_services,$i))) # Here is the generic rule, whose receipt the above rules will trigger. @@ -261,13 +261,13 @@ JAVAX_SOUND_SRC_FILES := \ COPY_EXTRA += $(foreach F,$(notdir $(JAVAX_SOUND_SRC_FILES)),$(JDK_OUTPUTDIR)/classes/META-INF/services/${F}) -ifeq ($(PLATFORM)-$(ARCH),windows-ia64) +ifeq ($(OPENJDK_TARGET_OS)-$(ARCH),windows-ia64) JAVAX_SOUND_SRC_FILES += windows-ia64/javax.sound.sampled.spi.MixerProvider COPY_EXTRA += $(JDK_OUTPUTDIR)/classes/META-INF/services/javax.sound.sampled.spi.MixerProvider -else ifeq ($(PLATFORM),windows) +else ifeq ($(OPENJDK_TARGET_OS),windows) JAVAX_SOUND_SRC_FILES += windows-i586/javax.sound.sampled.spi.MixerProvider COPY_EXTRA += $(JDK_OUTPUTDIR)/classes/META-INF/services/javax.sound.sampled.spi.MixerProvider -else ifeq ($(PLATFORM)-$(ARCH),linux-i586) +else ifeq ($(OPENJDK_TARGET_OS)-$(ARCH),linux-i586) JAVAX_SOUND_SRC_FILES += linux-i586/javax.sound.sampled.spi.MixerProvider COPY_EXTRA += $(JDK_OUTPUTDIR)/classes/META-INF/services/javax.sound.sampled.spi.MixerProvider else diff --git a/jdk/makefiles/CopySamples.gmk b/jdk/makefiles/CopySamples.gmk index f373b26d341..bb18a07491c 100644 --- a/jdk/makefiles/CopySamples.gmk +++ b/jdk/makefiles/CopySamples.gmk @@ -46,7 +46,7 @@ ifndef OPENJDK SAMPLE_TARGET += $(SAMPLE_CLOSED_TARGET) endif -ifneq (, $(filter $(PLATFORM), solaris macosx)) +ifneq (, $(filter $(OPENJDK_TARGET_OS), solaris macosx)) SAMPLE_SOLARIS_SOURCE := $(shell $(FIND) $(SAMPLE_SOLARIS_SOURCE_DIR) -type f -print) SAMPLE_SOLARIS_TARGET := $(subst $(SAMPLE_SOLARIS_SOURCE_DIR),$(SAMPLE_TARGET_DIR),$(SAMPLE_SOLARIS_SOURCE)) SAMPLE_TARGET += $(SAMPLE_SOLARIS_TARGET) @@ -72,4 +72,3 @@ COPY_FILES += $(SAMPLE_TARGET) all: $(COPY_FILES) .PHONY: all - diff --git a/jdk/makefiles/CreateJars.gmk b/jdk/makefiles/CreateJars.gmk index 681fdb70201..698885df08a 100644 --- a/jdk/makefiles/CreateJars.gmk +++ b/jdk/makefiles/CreateJars.gmk @@ -32,6 +32,10 @@ default: all include Tools.gmk +# +# This makefile...so that altering will trigger rebuilding include/exclude-lists => jars +# +MAKEFILE=$(JDK_TOPDIR)/makefiles/CreateJars.gmk MAINMANIFEST := $(JDK_TOPDIR)/make/tools/manifest.mf BEANMANIFEST := $(JDK_TOPDIR)/make/javax/swing/beaninfo/manifest @@ -46,7 +50,7 @@ JCONSOLE_JAR_DEPS := \ $(eval $(call SetupArchive,BUILD_JCONSOLE_JAR,$(JCONSOLE_JAR_DEPS),\ SRCS:=$(JDK_OUTPUTDIR)/classes,\ - SUFFIXES:=.class .gif .png,\ + SUFFIXES:=.class .gif .png .properties,\ INCLUDES:=sun/tools/jconsole com/sun/tools/jconsole,\ JARMAIN:=sun.tools.jconsole.JConsole,\ JAR:=$(JDK_OUTPUTDIR)/lib/jconsole.jar,\ @@ -242,12 +246,35 @@ RT_JAR_EXCLUDES := \ sun/swing/BeanInfoUtils.class \ $(LOCALEDATA_INCLUDES) -ifndef OPENJDK -ifndef JAVASE_EMBEDDED +# These files should never be put into rt.jar +# but due to a misstake...some are put there if embedded +# +ifneq ($(JAVASE_EMBEDDED), true) +# normal (correct) case RT_JAR_EXCLUDES += \ com/oracle/jrockit/jfr \ oracle/jrockit/jfr +else +# embedded (broken) case +RT_JAR_EXCLUDES += \ + oracle/jrockit/jfr/parser \ + oracle/jrockit/jfr/tools \ + oracle/jrockit/jfr/NativeOptions.class \ + oracle/jrockit/jfr/RepositoryChunkHandler.class endif + +ifeq ($(OPENJDK_TARGET_OS), macosx) + RT_JAR_EXCLUDES += com/sun/nio/sctp \ + sun/nio/ch/sctp \ + sun/jdbc \ + sun/nio/ch/DevPollArrayWrapper\$$$$Updator.class \ + sun/nio/ch/DevPollArrayWrapper.class \ + sun/nio/ch/DevPollSelectorImpl.class \ + sun/nio/ch/DevPollSelectorProvider.class \ + sun/nio/ch/EPollArrayWrapper\$$$$Updator.class \ + sun/nio/ch/EPollArrayWrapper.class \ + sun/nio/ch/EPollSelectorImpl.class \ + sun/nio/ch/EPollSelectorProvider.class endif # Find all files in the classes dir to use as dependencies. This could be more fine granular. @@ -271,12 +298,19 @@ $(RESOURCE_JAR_MANIFEST_FILE): $(MAINMANIFEST) -e "s#@@COMPANY_NAME@@#$(COMPANY_NAME)#" \ $(MAINMANIFEST) >> $@ -$(JDK_OUTPUTDIR)/lib/_the.jars.exclude: +$(JDK_OUTPUTDIR)/lib/_the.jars.exclude: $(MAKEFILE) $(MKDIR) -p $(@D) $(call ListPathsSafely,RT_JAR_EXCLUDES,\n, >> $@) +$(JDK_OUTPUTDIR)/lib/classlist : $(JDK_TOPDIR)/make/tools/sharing/classlist.$(OPENJDK_TARGET_OS) \ + $(MAKEFILE) + $(MKDIR) -p $(@D) + $(RM) -f $@.temp + $(TOOL_ADDJSUM) $< $@.temp + $(MV) $@.temp $@ + $(JDK_OUTPUTDIR)/lib/_the.jars.contents: $(BUILD_TOOLS) $(JDK_OUTPUTDIR)/lib/_the.jars.exclude \ - $(ALL_FILES_IN_CLASSES) + $(ALL_FILES_IN_CLASSES) $(JDK_OUTPUTDIR)/lib/classlist $(MKDIR) -p $(@D) $(RM) $@.temp ($(CD) $(JDK_OUTPUTDIR)/classes && \ @@ -290,17 +324,22 @@ $(JDK_OUTPUTDIR)/lib/_the.rt.jar.contents: $(JDK_OUTPUTDIR)/lib/_the.jars.conten $(JDK_OUTPUTDIR)/lib/_the.resources.jar.contents: $(JDK_OUTPUTDIR)/lib/_the.jars.contents $(GREP) -v -e '\.class$$' -e '/_the\.*' -e '^_the\.*' $(JDK_OUTPUTDIR)/lib/_the.jars.contents > $@ +RT_JAR_CREATE_OPTIONS := c0fm +ifeq ($(COMPRESS_JARS), true) + RT_JAR_CREATE_OPTIONS := cfm +endif + $(JDK_OUTPUTDIR)/lib/rt.jar: $(JDK_OUTPUTDIR)/lib/_the.rt.jar.contents $(RT_JAR_MANIFEST_FILE) $(ECHO) Creating rt.jar $(CD) $(JDK_OUTPUTDIR)/classes && \ - $(JAR) cfm $@ $(RT_JAR_MANIFEST_FILE) \ + $(JAR) $(RT_JAR_CREATE_OPTIONS) $@ $(RT_JAR_MANIFEST_FILE) \ @$(JDK_OUTPUTDIR)/lib/_the.rt.jar.contents $(JDK_OUTPUTDIR)/lib/resources.jar: $(JDK_OUTPUTDIR)/lib/_the.resources.jar.contents \ $(RESOURCE_JAR_MANIFEST_FILE) $(ECHO) Creating resources.jar $(CD) $(JDK_OUTPUTDIR)/classes && \ - $(JAR) cfm $@ $(RESOURCE_JAR_MANIFEST_FILE) \ + $(JAR) $(RT_JAR_CREATE_OPTIONS) $@ $(RESOURCE_JAR_MANIFEST_FILE) \ @$(JDK_OUTPUTDIR)/lib/_the.resources.jar.contents JARS+=$(JDK_OUTPUTDIR)/lib/rt.jar $(JDK_OUTPUTDIR)/lib/resources.jar @@ -309,7 +348,7 @@ JARS+=$(JDK_OUTPUTDIR)/lib/rt.jar $(JDK_OUTPUTDIR)/lib/resources.jar CHARSETS_JAR_DEPS := -ifneq ($(HOST_OS), windows) +ifneq ($(OPENJDK_TARGET_OS), windows) CHARSETS_EXTRA_FILES:=sun/awt/motif/X11GBK.class \ sun/awt/motif/X11GB2312\$$$$Decoder.class \ sun/awt/motif/X11GB2312.class \ @@ -328,20 +367,22 @@ $(eval $(call SetupArchive,BUILD_CHARSETS_JAR,$(CHARSETS_JAR_DEPS),\ $(CHARSETS_EXTRA_FILES) \ META-INF/services/java.nio.charset.spi.CharsetProvider, \ JAR:=$(JDK_OUTPUTDIR)/lib/charsets.jar, \ - SKIP_METAINF := true)) + SKIP_METAINF := true, \ + CHECK_COMPRESS_JAR:=true)) JARS+=$(JDK_OUTPUTDIR)/lib/charsets.jar ########################################################################################## -ifndef OPENJDK +ifeq ($(ENABLE_JFR), true) $(eval $(call SetupArchive,BUILD_JFR_JAR,,\ SRCS:=$(JDK_OUTPUTDIR)/classes,\ INCLUDES:=com/oracle/jrockit/jfr \ oracle/jrockit/jfr,\ JAR:=$(JDK_OUTPUTDIR)/lib/jfr.jar,\ SKIP_METAINF:=true,\ - MANIFEST:=$(MAINMANIFEST))) + MANIFEST:=$(MAINMANIFEST), \ + CHECK_COMPRESS_JAR:=true)) JARS+=$(JDK_OUTPUTDIR)/lib/jfr.jar endif @@ -356,13 +397,14 @@ $(eval $(call SetupArchive,BUILD_JSSE_JAR,,\ com/sun/net/ssl/internal/ssl,\ JAR:=$(JDK_OUTPUTDIR)/lib/jsse.jar,\ SKIP_METAINF:=true,\ - MANIFEST:=$(MAINMANIFEST))) + MANIFEST:=$(MAINMANIFEST), \ + CHECK_COMPRESS_JAR:=true)) JARS+=$(JDK_OUTPUTDIR)/lib/jsse.jar ########################################################################################## -ifneq ($(PLATFORM)-$(ARCH_DATA_MODEL),windows-64) +ifneq ($(OPENJDK_TARGET_OS)-$(ARCH_DATA_MODEL),windows-64) SUNPKCS11_JAR_DST := $(JDK_OUTPUTDIR)/lib/ext/sunpkcs11.jar ifndef OPENJDK @@ -544,7 +586,7 @@ endif ########################################################################################## -ifeq ($(PLATFORM),windows) +ifeq ($(OPENJDK_TARGET_OS),windows) SUNMSCAPI_JAR_DST := $(JDK_OUTPUTDIR)/lib/ext/sunmscapi.jar @@ -574,7 +616,7 @@ endif ########################################################################################## -ifeq ($(PLATFORM),solaris) +ifeq ($(OPENJDK_TARGET_OS),solaris) ifndef OPENJDK UCRYPTO_JAR_DST := $(JDK_OUTPUTDIR)/lib/ext/ucrypto.jar @@ -661,7 +703,8 @@ $(eval $(call SetupArchive,BUILD_TOOLS_JAR,$(TOOLS_JAR_DEPS),\ META-INF/services/com.sun.tools.internal.ws.wscompile.Plugin \ META-INF/services/com.sun.tools.internal.xjc.Plugin,\ JAR:=$(JDK_OUTPUTDIR)/lib/tools.jar,\ - SKIP_METAINF:=true)) + SKIP_METAINF:=true, \ + CHECK_COMPRESS_JAR:=true)) JARS+=$(JDK_OUTPUTDIR)/lib/tools.jar @@ -696,6 +739,7 @@ EXPORTED_PRIVATE_PKGS = com.sun.servicetag \ com.oracle.nio $(IMAGES_OUTPUTDIR)/symbols/_the.symbols: $(JDK_OUTPUTDIR)/lib/rt.jar + $(RM) -rf $(IMAGES_OUTPUTDIR)/symbols/META-INF/sym $(MKDIR) -p $(IMAGES_OUTPUTDIR)/symbols/META-INF/sym $(JAVA) \ -Xbootclasspath/a:$(JDK_OUTPUTDIR)/classes \ @@ -711,7 +755,8 @@ MAKE_SURE_DIR_EXISTS_DUMMY := $(shell $(MKDIR) -p $(IMAGES_OUTPUTDIR)/symbols) $(eval $(call SetupArchive,BUILD_CT_SYM,$(IMAGES_OUTPUTDIR)/symbols/_the.symbols,\ SRCS:=$(IMAGES_OUTPUTDIR)/symbols,\ INCLUDES:=META-INF/sym,\ - JAR:=$(JDK_OUTPUTDIR)/lib/ct.sym)) + JAR:=$(JDK_OUTPUTDIR)/lib/ct.sym, \ + CHECK_COMPRESS_JAR:=true)) JARS+=$(JDK_OUTPUTDIR)/lib/ct.sym @@ -765,7 +810,7 @@ SRC_ZIP_INCLUDES = \ org/xml/sax \ sunw -SRC_ZIP_SRCS = $(JDK_TOPDIR)/src/share/classes $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes +SRC_ZIP_SRCS = $(JDK_TOPDIR)/src/share/classes $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes SRC_ZIP_SRCS += $(JDK_OUTPUTDIR)/gensrc SRC_ZIP_SRCS += $(JDK_OUTPUTDIR)/impsrc SRC_ZIP_SRCS += $(JDK_OUTPUTDIR)/gendocsrc_rmic @@ -776,16 +821,16 @@ endif # Need to copy launcher src files into desired directory structure # before zipping the sources. LAUNCHER_SRC_FILES := $(wildcard $(JDK_TOPDIR)/src/share/bin/*) \ - $(wildcard $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/bin/java_md*) + $(wildcard $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/bin/java_md*) LAUNCHER_ZIP_SRC := $(patsubst $(JDK_TOPDIR)/src/share/bin/%,$(IMAGES_OUTPUTDIR)/src/launcher/%,\ - $(patsubst $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/bin/%,$(IMAGES_OUTPUTDIR)/src/launcher/%,\ + $(patsubst $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/bin/%,$(IMAGES_OUTPUTDIR)/src/launcher/%,\ $(LAUNCHER_SRC_FILES))) $(IMAGES_OUTPUTDIR)/src/launcher/%: $(JDK_TOPDIR)/src/share/bin/% $(MKDIR) -p $(@D) $(CP) $< $@ -$(IMAGES_OUTPUTDIR)/src/launcher/%: $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/bin/% +$(IMAGES_OUTPUTDIR)/src/launcher/%: $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/bin/% $(MKDIR) -p $(@D) $(CP) $< $@ diff --git a/jdk/makefiles/GendataBreakIterator.gmk b/jdk/makefiles/GendataBreakIterator.gmk index 6321afbf7ad..9c12334b7d9 100644 --- a/jdk/makefiles/GendataBreakIterator.gmk +++ b/jdk/makefiles/GendataBreakIterator.gmk @@ -35,10 +35,10 @@ # TEXT_SRCDIR = $(JDK_TOPDIR)/src/share/classes TEXT_PKG = sun/text/resources -TEXT_SOURCES = %$(TEXT_PKG)/BreakIteratorRules.java \ - %$(TEXT_PKG)/BreakIteratorInfo.java \ - %$(TEXT_PKG)/BreakIteratorRules_th.java \ - %$(TEXT_PKG)/BreakIteratorInfo_th.java +TEXT_SOURCES = $(TEXT_PKG)/BreakIteratorRules.java \ + $(TEXT_PKG)/BreakIteratorInfo.java \ + $(TEXT_PKG)/BreakIteratorRules_th.java \ + $(TEXT_PKG)/BreakIteratorInfo_th.java # Generate BreakIteratorData BREAK_ITERATOR_DIR = $(JDK_OUTPUTDIR)/break_iterator diff --git a/jdk/makefiles/GendataFontConfig.gmk b/jdk/makefiles/GendataFontConfig.gmk index dec8b5bb0fc..860b233857f 100644 --- a/jdk/makefiles/GendataFontConfig.gmk +++ b/jdk/makefiles/GendataFontConfig.gmk @@ -25,13 +25,13 @@ GENDATA_FONT_CONFIG_DST := $(JDK_OUTPUTDIR)/lib -ifeq ($(PLATFORM), windows) +ifeq ($(OPENJDK_TARGET_OS), windows) GENDATA_FONT_CONFIG_SRC_DIR := $(JDK_TOPDIR)/src/windows/classes/sun/awt/windows GENDATA_FONT_CONFIG_SRC_FILES := fontconfig.properties GENDATA_FONT_CONFIG_SRC_PREFIX := endif -ifeq ($(PLATFORM), linux) +ifeq ($(OPENJDK_TARGET_OS), linux) GENDATA_FONT_CONFIG_SRC_PREFIX := linux. ifdef OPENJDK GENDATA_FONT_CONFIG_SRC_DIR := $(JDK_TOPDIR)/src/solaris/classes/sun/awt/fontconfigs @@ -52,27 +52,29 @@ GENDATA_FONT_CONFIG_SRC_FILES := \ endif endif -ifeq ($(PLATFORM), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) GENDATA_FONT_CONFIG_SRC_DIR := $(JDK_TOPDIR)/src/solaris/classes/sun/awt/fontconfigs GENDATA_FONT_CONFIG_SRC_FILES := fontconfig.properties GENDATA_FONT_CONFIG_SRC_PREFIX := solaris. endif -ifeq ($(PLATFORM), macosx) +ifeq ($(OPENJDK_TARGET_OS), macosx) GENDATA_FONT_CONFIG_SRC_DIR := $(JDK_TOPDIR)/src/macosx/classes/sun/awt/fontconfigs GENDATA_FONT_CONFIG_SRC_FILES := fontconfig.properties GENDATA_FONT_CONFIG_SRC_PREFIX := macosx. -endif # PLATFORM +endif # OPENJDK_TARGET_OS ### $(GENDATA_FONT_CONFIG_DST)/%.src : $(GENDATA_FONT_CONFIG_SRC_DIR)/$(GENDATA_FONT_CONFIG_SRC_PREFIX)% $(MKDIR) -p $(@D) $(CP) $< $@ + $(CHMOD) 644 $@ $(GENDATA_FONT_CONFIG_DST)/%.bfc : $(GENDATA_FONT_CONFIG_SRC_DIR)/$(GENDATA_FONT_CONFIG_SRC_PREFIX)%.properties $(MKDIR) -p $(@D) $(TOOL_COMPILEFONTCONFIG) $< $@ + $(CHMOD) 444 $@ ### diff --git a/jdk/makefiles/GendataHtml32dtd.gmk b/jdk/makefiles/GendataHtml32dtd.gmk index 29ae389bd0b..f1a2c95d55a 100644 --- a/jdk/makefiles/GendataHtml32dtd.gmk +++ b/jdk/makefiles/GendataHtml32dtd.gmk @@ -32,5 +32,4 @@ $(HTML32DTD): $(BUILD_TOOLS) $(RM) $@ ($(TOOL_DTDBUILDER) html32 > $@) || exit 1 -GENDATA_HTML32DTD += $(HTML32DTD) - +GENDATA_HTML32DTD += $(HTML32DTD) \ No newline at end of file diff --git a/jdk/makefiles/GenerateClasses.gmk b/jdk/makefiles/GenerateClasses.gmk index a5e68c8b77e..dda0558b0b9 100644 --- a/jdk/makefiles/GenerateClasses.gmk +++ b/jdk/makefiles/GenerateClasses.gmk @@ -27,7 +27,13 @@ default: all include $(SPEC) include MakeBase.gmk -include RMICompile.gmk +include RMICompilation.gmk + +# To ensure the latest stub generator files are picked up from corba repo +# when available, we need to run with latest rmic version available. +ifeq ($(CROSS_COMPILE_ARCH),) + RMIC := $(UNCYGDRIVE) $(JDK_OUTPUTDIR)/bin/rmic +endif CLASSES_DIR := $(JDK_OUTPUTDIR)/classes # NOTE: If the smart javac dependency management is reintroduced, these classes risk diff --git a/jdk/makefiles/GenerateData.gmk b/jdk/makefiles/GenerateData.gmk index d2eebf01097..54b367cb343 100644 --- a/jdk/makefiles/GenerateData.gmk +++ b/jdk/makefiles/GenerateData.gmk @@ -69,6 +69,7 @@ $(GENDATA_CURDATA): $(JDK_TOPDIR)/src/share/classes/java/util/CurrencyData.prope $(RM) $@ $(TOOL_GENERATECURRENCYDATA) -o $@.temp < $< $(MV) $@.temp $@ + $(CHMOD) 444 $@ GENDATA += $(GENDATA_CURDATA) diff --git a/jdk/makefiles/GenerateJavaSources.gmk b/jdk/makefiles/GenerateJavaSources.gmk index 70b464a2730..2474bf6586e 100644 --- a/jdk/makefiles/GenerateJavaSources.gmk +++ b/jdk/makefiles/GenerateJavaSources.gmk @@ -65,7 +65,7 @@ GENSRC += $(GENSRC_BUFFER) include GensrcExceptions.gmk GENSRC += $(GENSRC_EXCEPTIONS) -ifneq ($(HOST_OS),windows) +ifneq ($(OPENJDK_TARGET_OS),windows) include GensrcIcons.gmk GENSRC += $(GENSRC_ICONS) @@ -78,6 +78,11 @@ ifndef DISABLE_NIMBUS GENSRC += $(GENSRC_SWING_NIMBUS) endif +ifeq ($(OPENJDK_TARGET_OS), macosx) + include GensrcJObjC.gmk + GENSRC += $(GENSRC_JOBJC) +endif + $(GENSRC) : $(BUILD_TOOLS) # The exception handling of swing beaninfo @@ -100,7 +105,10 @@ all: $(GENSRC) $(GENSRC_SWING_BEANINFO) $(MKDIR) -p gensrc/javax/swing/plaf && \ $(CP) -rp gensrc_swing/javax/swing/plaf/* gensrc/javax/swing/plaf) \ fi -ifneq ($(HOST_OS),windows) + if [ -d $(JDK_OUTPUTDIR)/gensrc_jobjc ] ; then \ + (cd $(JDK_OUTPUTDIR) && cp -rp gensrc_jobjc/src/* gensrc) \ + fi +ifneq ($(OPENJDK_TARGET_OS),windows) (cd $(JDK_OUTPUTDIR) && \ $(CP) -rp gensrc_icons/* gensrc && \ $(CP) -rp gensrc_x11wrappers/classes/* gensrc) diff --git a/jdk/makefiles/GensrcBuffer.gmk b/jdk/makefiles/GensrcBuffer.gmk index bc9c150da6b..4ae466ebef7 100644 --- a/jdk/makefiles/GensrcBuffer.gmk +++ b/jdk/makefiles/GensrcBuffer.gmk @@ -198,6 +198,7 @@ define SetupGenBuffer $(if $(12),$1_$(strip $(12))) $(if $(13),$1_$(strip $(13))) $(if $(14),$1_$(strip $(14))) + $(if $(15),$(error Internal makefile error: Too many arguments to SetupGenBuffer, please update GensrcBuffer.gmk)) $(call fixRw,$1,$$($1_RW)) $(call typesAndBits,$1,$$($1_type),$$($1_BO)) diff --git a/jdk/makefiles/GensrcIcons.gmk b/jdk/makefiles/GensrcIcons.gmk index 3e9f07437ba..733f25461a9 100644 --- a/jdk/makefiles/GensrcIcons.gmk +++ b/jdk/makefiles/GensrcIcons.gmk @@ -29,7 +29,7 @@ GENSRC_ICONS_TMP := $(JDK_OUTPUTDIR)/gensrc_icons GENSRC_ICONS_DST := $(GENSRC_ICONS_TMP)/sun/awt/X11 ifdef OPENJDK - ICONS_PATH_PREFIX := $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API) + ICONS_PATH_PREFIX := $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API) else ICONS_PATH_PREFIX := $(JDK_TOPDIR)/src/closed/solaris endif @@ -41,7 +41,7 @@ GENSRC_ICONS_SRC += \ $(ICONS_PATH_PREFIX)/classes/sun/awt/X11/java-icon48.png -ICONPATH := $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes/sun/awt/X11 +ICONPATH := $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes/sun/awt/X11 GENSRC_ICONS_SRC += \ $(ICONPATH)/security-icon-bw16.png \ @@ -86,7 +86,7 @@ $$($1_TARGET32) : $2/$1 $(GENSRC_ICONS_TMP)/_the.dir $(ECHO) "public class $$($1_NAME32) {" >> $$@.tmp $(ECHO) "public static int[] $$($1_SHORTNAME) = { " >> $$@.tmp # TODO FIX FIX FIX -ifneq ($(PLATFORM),macosx) +ifneq ($(OPENJDK_TARGET_OS),macosx) $(CAT) $$< | $(TOOL_TOBIN) >> $$@.tmp endif $(ECHO) "}; }" >> $$@.tmp @@ -100,7 +100,7 @@ $$($1_TARGET64) : $2/$1 $(GENSRC_ICONS_TMP)/_the.dir $(ECHO) "public class $$($1_NAME64) {" >> $$@.tmp $(ECHO) "public static long[] $$($1_SHORTNAME) = { " >> $$@.tmp # TODO FIX FIX FIX -ifneq ($(PLATFORM),macosx) +ifneq ($(OPENJDK_TARGET_OS),macosx) $(CAT) $$< | $(TOOL_TOBIN) >> $$@.tmp endif $(ECHO) "}; }" >> $$@.tmp diff --git a/jdk/makefiles/GensrcJObjC.gmk b/jdk/makefiles/GensrcJObjC.gmk new file mode 100644 index 00000000000..d44df8193df --- /dev/null +++ b/jdk/makefiles/GensrcJObjC.gmk @@ -0,0 +1,80 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +GENSRC_JOBJC := + +JOBJC_FRAMEWORKS := Foundation CoreFoundation AppKit +FRAMEWORKS_DIR := /System/Library/Frameworks +GBM := /usr/bin/gen_bridge_metadata + +JOBJC_SRC := $(JDK_TOPDIR)/src/macosx/native/jobjc +JOBJC_TMP := $(JDK_OUTPUTDIR)/gensrc_jobjc +JOBJC_DST := $(JDK_OUTPUTDIR)/gensrc_jobjc/src + +# +# Build generator +# +$(eval $(call SetupJavaCompilation,BUILD_JOBJC_PRIMITIVE_CODER,\ + SETUP:=GENERATE_OLDBYTECODE,\ + INCLUDES:=core/java \ + com/apple,\ + HEADERS :=$(JOBJC_DST)/jni_headers/core ,\ + SRC:=$(JOBJC_SRC)/src \ + $(JOBJC_SRC)/src/generator/java, \ + BIN:=$(JOBJC_TMP)/bin)) + +GENSRC_JOBJC += $(JOBJC_TMP)/bin/_the.batch + +# +# Generate bridge support +# +BRIDGESUPPORT := $(addprefix $(JOBJC_TMP)/bridge/,$(addsuffix Full.bridgesupport,$(JOBJC_FRAMEWORKS))) + +$(JOBJC_TMP)/bridge/%Full.bridgesupport : $(FRAMEWORKS_DIR)/%.framework/Headers/*.h + $(MKDIR) -p $(@D) + if [ -f $(FRAMEWORKS_DIR)/$*.framework/Resources/BridgeSupport/$(@F) ]; then \ + cp $(FRAMEWORKS_DIR)/$*.framework/Resources/BridgeSupport/$(@F) $@ ;\ + else \ + $(GBM) -F complete --framework $* -o $@ ; \ + fi + +# +# Find Xbootclasspath +# +$(JOBJC_TMP)/_the.generator_bootclasspath : $(JOBJC_TMP)/bin/_the.batch + $(JAVA) -cp $(JOBJC_TMP)/bin com.apple.internal.jobjc.generator.BootClassPathMinus JObjC.jar > $@.tmp + $(MV) $@.tmp $@ + + +# +# Run generator +# +TOOL_JOBJC := $(JAVA) -cp $(JOBJC_TMP)/bin -ea com.apple.internal.jobjc.generator.Generator + +$(JOBJC_TMP)/_the.generator : $(JOBJC_TMP)/bin/_the.batch $(JOBJC_TMP)/_the.generator_bootclasspath $(BRIDGESUPPORT) + $(JAVA) -d64 -Xbootclasspath:`$(CAT) $(JOBJC_TMP)/_the.generator_bootclasspath` -cp $(JOBJC_TMP)/bin -ea com.apple.internal.jobjc.generator.Generator dst=$(JOBJC_DST) frameworks=$(JOBJC_TMP)/bridge + $(TOUCH) $@ + +GENSRC_JOBJC += $(JOBJC_TMP)/_the.generator diff --git a/jdk/makefiles/GensrcMisc.gmk b/jdk/makefiles/GensrcMisc.gmk index d2acd806e5c..08d64bbe8c0 100644 --- a/jdk/makefiles/GensrcMisc.gmk +++ b/jdk/makefiles/GensrcMisc.gmk @@ -53,9 +53,9 @@ GENSRC_MISC += $(JDK_OUTPUTDIR)/gensrc_misc/sun/tools/jconsole/Version.java ########################################################################################## -ifeq ($(HOST_OS_API),posix) - UPSUFFIX:=$(PLATFORM) - ifeq ($(PLATFORM),macosx) +ifeq ($(OPENJDK_TARGET_OS_API),posix) + UPSUFFIX:=$(OPENJDK_TARGET_OS) + ifeq ($(OPENJDK_TARGET_OS),macosx) UPSUFFIX:=bsd endif # UNIXProcess.java is different for solaris and linux. We need to copy @@ -64,7 +64,7 @@ ifeq ($(HOST_OS_API),posix) $(JDK_OUTPUTDIR)/gensrc_misc/java/lang/UNIXProcess.java : \ $(JDK_TOPDIR)/src/solaris/classes/java/lang/UNIXProcess.java.$(UPSUFFIX) $(MKDIR) -p $(@D) - $(ECHO) Copying UNIXProcess.java.$(PLATFORM) to java/lang/UNIXProcess.java + $(ECHO) Copying UNIXProcess.java.$(OPENJDK_TARGET_OS) to java/lang/UNIXProcess.java $(CP) $< $@ $(CHMOD) u+rw $@ @@ -74,8 +74,8 @@ endif ########################################################################################## ifndef OPENJDK -ifneq ($(PLATFORM), windows) -ifneq ($(PLATFORM), macosx) +ifneq ($(OPENJDK_TARGET_OS), windows) +ifneq ($(OPENJDK_TARGET_OS), macosx) # These file(s) are needed for building fake .so libs on !windows for jdbcodbc $(JDK_OUTPUTDIR)/gensrc_c/libjdbcodbc/dummyodbc1.c : @@ -101,85 +101,98 @@ GENSRC_MISC += $(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/ch/SocketOptionRegistry.java GENSRC_SOR_SRC := $(JDK_TOPDIR)/src/share/native/sun/nio/ch GENSRC_SOR_SRC_FILE := genSocketOptionRegistry.c -GENSRC_SOR_BIN := $(JDK_OUTPUTDIR)/objs/gensrc/genSocketOptionRegistry -GENSRC_SOR_EXE := $(GENSRC_SOR_BIN)/genSocketOptionRegistry$(EXE_SUFFIX) +GENSRC_SOR_BIN := $(JDK_OUTPUTDIR)/gensrc_misc/genSocketOptionRegistry SOR_COPYRIGHT_YEARS = $(shell $(CAT) $(GENSRC_SOR_SRC)/$(GENSRC_SOR_SRC_FILE) | \ $(NAWK) '/^.*Copyright.*Oracle/ { printf "%s %s",$$4,$$5 }') -$(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/ch/SocketOptionRegistry.java : $(GENSRC_SOR_EXE) - $(MKDIR) -p $(@D) - NAWK="$(NAWK)" SH="$(SH)" $(SH) -e $(JDK_TOPDIR)/makefiles/scripts/addNotices.sh "$(SOR_COPYRIGHT_YEARS)" > $@.tmp - $(GENSRC_SOR_EXE) >> $@.tmp - $(MV) $@.tmp $@ - - $(eval $(call SetupNativeCompilation,BUILD_GENSRC_SOR_EXE,\ SRC:=$(GENSRC_SOR_SRC),\ INCLUDE_FILES:=$(GENSRC_SOR_SRC_FILE),\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB),\ - BIN:=$(GENSRC_SOR_BIN),\ - EXE:=$(GENSRC_SOR_EXE))) + CC:=$(HOST_CC),\ + LDEXE:=$(HOST_LD),\ + OBJECT_DIR:=$(GENSRC_SOR_BIN),\ + OUTPUT_DIR:=$(GENSRC_SOR_BIN),\ + PROGRAM:=genSocketOptionRegistry)) + +ifneq ($(JAVASE_EMBEDDED), true) +$(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/ch/SocketOptionRegistry.java : $(BUILD_GENSRC_SOR_EXE) + $(MKDIR) -p $(@D) + NAWK="$(NAWK)" SH="$(SH)" $(SH) -e $(JDK_TOPDIR)/makefiles/scripts/addNotices.sh "$(SOR_COPYRIGHT_YEARS)" > $@.tmp + $(BUILD_GENSRC_SOR_EXE) >> $@.tmp + $(MV) $@.tmp $@ +else +$(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/ch/SocketOptionRegistry.java : $(JDK_TOPDIR)/src/closed/solaris/classes/sun/nio/ch/SocketOptionRegistry-$(OPENJDK_TARGET_OS)-$(OPENJDK_TARGET_CPU_ARCH).java + $(MKDIR) -p $(@D) + $(CP) $< $@ +endif ########################################################################################## -ifneq ($(PLATFORM),windows) +ifneq ($(OPENJDK_TARGET_OS),windows) GENSRC_MISC += $(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/fs/UnixConstants.java -GENSRC_UC_SRC := $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/nio/fs +GENSRC_UC_SRC := $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/nio/fs GENSRC_UC_SRC_FILE := genUnixConstants.c -GENSRC_UC_BIN := $(JDK_OUTPUTDIR)/objs/gensrc/genUnixConstants -GENSRC_UC_EXE := $(GENSRC_UC_BIN)/genUnixConstants$(EXE_SUFFIX) +GENSRC_UC_BIN := $(JDK_OUTPUTDIR)/gensrc_misc/genUnixConstants UC_COPYRIGHT_YEARS = $(shell $(CAT) $(GENSRC_UC_SRC)/$(GENSRC_UC_SRC_FILE) | \ $(NAWK) '/^.*Copyright.*Oracle/ { printf "%s %s",$$4,$$5 }') -$(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/fs/UnixConstants.java : $(GENSRC_UC_EXE) - $(MKDIR) -p $(@D) - NAWK="$(NAWK)" SH="$(SH)" $(SH) -e $(JDK_TOPDIR)/makefiles/scripts/addNotices.sh "$(UC_COPYRIGHT_YEARS)" > $@.tmp - $(GENSRC_UC_EXE) >> $@.tmp - $(MV) $@.tmp $@ - - $(eval $(call SetupNativeCompilation,BUILD_GENSRC_UC_EXE,\ SRC:=$(GENSRC_UC_SRC),\ INCLUDE_FILES:=$(GENSRC_UC_SRC_FILE),\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB),\ - BIN:=$(GENSRC_UC_BIN),\ - EXE:=$(GENSRC_UC_EXE))) + CC:=$(HOST_CC),\ + LDEXE:=$(HOST_CC),\ + OBJECT_DIR:=$(GENSRC_UC_BIN),\ + OUTPUT_DIR:=$(GENSRC_UC_BIN),\ + PROGRAM:=genUnixConstants)) + +ifneq ($(JAVASE_EMBEDDED), true) +$(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/fs/UnixConstants.java : $(BUILD_GENSRC_UC_EXE) + $(MKDIR) -p $(@D) + NAWK="$(NAWK)" SH="$(SH)" $(SH) -e $(JDK_TOPDIR)/makefiles/scripts/addNotices.sh "$(UC_COPYRIGHT_YEARS)" > $@.tmp + $(BUILD_GENSRC_UC_EXE) >> $@.tmp + $(MV) $@.tmp $@ +else +$(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/fs/UnixConstants.java : $(JDK_TOPDIR)/src/closed/solaris/classes/sun/nio/fs/UnixConstants-$(OPENJDK_TARGET_OS)-$(OPENJDK_TARGET_CPU_ARCH).java + $(MKDIR) -p $(@D) + $(CP) $< $@ +endif endif ########################################################################################## -ifeq ($(PLATFORM),solaris) +ifeq ($(OPENJDK_TARGET_OS),solaris) GENSRC_MISC += $(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/fs/SolarisConstants.java -GENSRC_SOL_SRC := $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/native/sun/nio/fs +GENSRC_SOL_SRC := $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/sun/nio/fs GENSRC_SOL_SRC_FILE := genSolarisConstants.c -GENSRC_SOL_BIN := $(JDK_OUTPUTDIR)/objs/gensrc/genSolarisConstants -GENSRC_SOL_EXE := $(GENSRC_SOL_BIN)/genSolarisConstants$(EXE_SUFFIX) +GENSRC_SOL_BIN := $(JDK_OUTPUTDIR)/gensrc_misc/genSolarisConstants SOL_COPYRIGHT_YEARS = $(shell $(CAT) $(GENSRC_SOL_SRC)/$(GENSRC_SOL_SRC_FILE) | \ $(NAWK) '/^.*Copyright.*Oracle/ { printf "%s %s",$$4,$$5 }') -$(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/fs/SolarisConstants.java : $(GENSRC_SOL_EXE) - $(MKDIR) -p $(@D) - NAWK="$(NAWK)" SH="$(SH)" $(SH) -e $(JDK_TOPDIR)/makefiles/scripts/addNotices.sh "$(SOL_COPYRIGHT_YEARS)" > $@.tmp - $(GENSRC_SOL_EXE) >> $@.tmp - $(MV) $@.tmp $@ - - $(eval $(call SetupNativeCompilation,BUILD_GENSRC_SOL_EXE,\ SRC:=$(GENSRC_SOL_SRC),\ INCLUDE_FILES:=$(GENSRC_SOL_SRC_FILE),\ LANG:=C,\ - CFLAGS:=$(CFLAGS_JDKLIB),\ - BIN:=$(GENSRC_SOL_BIN),\ - EXE:=$(GENSRC_SOL_EXE))) + CC:=$(HOST_CC),\ + LDEXE:=$(HOST_CC),\ + OBJECT_DIR:=$(GENSRC_SOL_BIN),\ + OUTPUT_DIR:=$(GENSRC_SOL_BIN),\ + PROGRAM:=genSolarisConstants)) + +$(JDK_OUTPUTDIR)/gensrc_misc/sun/nio/fs/SolarisConstants.java : $(BUILD_GENSRC_SOL_EXE) + $(MKDIR) -p $(@D) + NAWK="$(NAWK)" SH="$(SH)" $(SH) -e $(JDK_TOPDIR)/makefiles/scripts/addNotices.sh "$(SOL_COPYRIGHT_YEARS)" > $@.tmp + $(BUILD_GENSRC_SOL_EXE) >> $@.tmp + $(MV) $@.tmp $@ + endif diff --git a/jdk/makefiles/GensrcProperties.gmk b/jdk/makefiles/GensrcProperties.gmk index 4d663534b5a..f4eea941f33 100644 --- a/jdk/makefiles/GensrcProperties.gmk +++ b/jdk/makefiles/GensrcProperties.gmk @@ -46,7 +46,7 @@ define add_properties_to_compile # Strip away prefix and suffix, # leaving for example: sun/util/resources/CurrencyNames_sv - $1_PROPPATHS:=$$(patsubst $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes/%.properties,%,\ + $1_PROPPATHS:=$$(patsubst $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes/%.properties,%,\ $$(patsubst $(JDK_TOPDIR)/src/share/classes/%.properties,%,$2)) # Apply optional name transformation, example: hz_TW -> hz_HK @@ -75,7 +75,7 @@ define add_properties_to_clean # Strip away prefix and suffix, # leaving for example: sun/util/resources/CurrencyNames_sv - $1_PROPPATHS:=$$(patsubst $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes/%.properties,%,\ + $1_PROPPATHS:=$$(patsubst $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes/%.properties,%,\ $$(patsubst $(JDK_TOPDIR)/src/share/classes/%.properties,%,$2)) # Apply optional name transformation, example: hz_TW -> hz_HK @@ -124,7 +124,7 @@ $(eval $(call add_properties_to_compile,COM_SUN_ACCESSIBILITY_HK,\ $(eval $(call add_properties_to_clean,COM_SUN_IMAGEIO,\ $(shell find $(JDK_TOPDIR)/src/share/classes/com/sun/imageio -name "*.properties"))) #com/sun/java/swing/plaf/gtk/resources -ifneq ($(PLATFORM), windows) +ifneq ($(OPENJDK_TARGET_OS), windows) # Only compile GTK resource bundles on Solaris/Linux $(eval $(call add_properties_to_compile,COM_SUN_SWING_PLAF_GTK,\ $(shell find $(JDK_TOPDIR)/src/share/classes/com/sun/java/swing/plaf/gtk/resources -name "*.properties"),\ @@ -264,6 +264,10 @@ $(eval $(call add_properties_to_compile,SUN_TOOLS_JAR_HK,\ $(eval $(call add_properties_to_clean,SUN_TOOLS_SERIALVER,\ $(shell find $(JDK_TOPDIR)/src/share/classes/sun/tools/javac/resources -name "javac.properties"))) +#sun/tools/jconsole/resources +$(eval $(call add_properties_to_clean,SUN_TOOLS_JCONSOLE,\ + $(shell find $(JDK_TOPDIR)/src/share/classes/sun/tools/jconsole/resources -name "*.properties"))) + #sun/tools/serialver $(eval $(call add_properties_to_clean,SUN_TOOLS_SERIALVER,\ $(shell find $(JDK_TOPDIR)/src/share/classes/sun/tools/serialver -name "*.properties"),,,resources)) diff --git a/jdk/makefiles/GensrcX11Wrappers.gmk b/jdk/makefiles/GensrcX11Wrappers.gmk index 03938bbfc1b..9dca546d1f8 100644 --- a/jdk/makefiles/GensrcX11Wrappers.gmk +++ b/jdk/makefiles/GensrcX11Wrappers.gmk @@ -30,10 +30,10 @@ GENSRC_SIZER_SRC := $(JDK_TOPDIR)/src/solaris/classes/sun/awt/X11/generator GENSRC_SIZES := -ifeq ($(PLATFORM)-$(LIBARCH), solaris-i386) +ifeq ($(OPENJDK_TARGET_OS)-$(LIBARCH), solaris-i386) GENSRC_SIZES := sizes.32 sizes.64 -else ifeq ($(PLATFORM), solaris) -isalist:=$(shell $(ISAINFO)) +else ifeq ($(OPENJDK_TARGET_OS), solaris) +isalist:=$(shell isainfo) ifneq (,$(findstring sparcv9, $(isalist))) # On sparcv9 we generate both 32 and 64-bit sizers in spite of ARCH_DATA_MODEL. GENSRC_SIZES := sizes.32 sizes.64 @@ -46,7 +46,7 @@ GENSRC_SIZES := sizes.32 endif # amd64 endif # sparcv9 else # !solaris -ifeq ($(PLATFORM), macosx) +ifeq ($(OPENJDK_TARGET_OS), macosx) GENSRC_SIZES := sizes.32 sizes.64 else # !macosx GENSRC_SIZES := sizes.$(ARCH_DATA_MODEL) @@ -62,18 +62,23 @@ $(GENSRC_X11WRAPPERS_TMP)/sizer/sizer.%.c : $(GENSRC_SIZER_SRC)/xlibtypes.txt $(TOOL_WRAPPERGENERATOR) $(@D) $< "sizer" $* $(GENSRC_X11WRAPPERS_TMP)/sizer/sizer.%.exe : $(GENSRC_X11WRAPPERS_TMP)/sizer/sizer.%.c - (cd $(@D) && $(CC) -m$* -o $@ $< $(CFLAGS_JDKLIB) \ + (cd $(@D) && $(HOST_CC) -m$* -o $@ $< \ + -I$(JDK_OUTPUTDIR)/include \ + -I$(JDK_TOPDIR)/src/share/javavm/export \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/javavm/export \ + -I$(JDK_TOPDIR)//src/share/native/common \ + -I$(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/native/common \ -I$(JDK_TOPDIR)/src/solaris/native/sun/awt \ -I$(JDK_TOPDIR)/src/share/native/sun/awt/debug \ -I$(JDK_TOPDIR)/src/share/native/sun/awt/image/cvutils -lc) -ifeq ($(PLATFORM)-$(LIBARCH), solaris-i386) +ifeq ($(OPENJDK_TARGET_OS)-$(LIBARCH), solaris-i386) $(GENSRC_X11WRAPPERS_TMP)/sizer/sizes.32 : $(GENSRC_X11WRAPPERS_TMP)/sizer/sizer.32.exe $< > $@.tmp $(MV) $@.tmp $@ -$(GENSRC_X11WRAPPERS_TMP)/sizer/sizes.64 : $(JDK_TOPDIR)/src/$(LEGACY_HOST_OS_API)/classes/sun/awt/X11/generator/sizes.64-$(PLATFORM)-$(LIBARCH) +$(GENSRC_X11WRAPPERS_TMP)/sizer/sizes.64 : $(JDK_TOPDIR)/src/$(LEGACY_OPENJDK_TARGET_OS_API)/classes/sun/awt/X11/generator/sizes.64-$(OPENJDK_TARGET_OS)-$(LIBARCH) $(MKDIR) -p $(@D) $(CP) $< $@ else @@ -88,9 +93,9 @@ $(GENSRC_X11WRAPPERS_TMP)/classes/_the.classes : $(foreach S,$(GENSRC_SIZES),$(G $(MKDIR) -p $(@D)/sun/awt/X11 $(RM) $(@D)/sun/awt/X11/* $(TOOL_WRAPPERGENERATOR) $(@D)/sun/awt/X11 $(GENSRC_SIZER_SRC)/xlibtypes.txt "gen" $(GENSRC_X11WRAPPERS_TMP)/sizer/sizes -ifeq ($(PLATFORM)-$(LIBARCH), solaris-amd64) - $(ECHO) COMPARING $@ and $(GENSRC_SIZER_SRC)/sizes.64-$(PLATFORM)-i386 - $(DIFF) $(GENSRC_X11WRAPPERS_TMP)/sizes.64 $(GENSRC_SIZER_SRC)/sizes.64-$(PLATFORM)-i386 +ifeq ($(OPENJDK_TARGET_OS)-$(LIBARCH), solaris-amd64) + $(ECHO) COMPARING $(GENSRC_X11WRAPPERS_TMP)/sizer/sizes.64 and $(GENSRC_SIZER_SRC)/sizes.64-$(OPENJDK_TARGET_OS)-i386 + $(DIFF) $(GENSRC_X11WRAPPERS_TMP)/sizer/sizes.64 $(GENSRC_SIZER_SRC)/sizes.64-$(OPENJDK_TARGET_OS)-i386 endif $(TOUCH) $@ diff --git a/jdk/makefiles/Images.gmk b/jdk/makefiles/Images.gmk index 9315955117e..bda32366082 100644 --- a/jdk/makefiles/Images.gmk +++ b/jdk/makefiles/Images.gmk @@ -34,15 +34,20 @@ include Tools.gmk images: jre-image jdk-image -ifeq ($(HOST_OS),solaris) +ifeq ($(OPENJDK_TARGET_OS),solaris) define install-file $(MKDIR) -p $(@D) - $(CP) -r -P '$<' '$(@D)' + $(CP) -f -r -P '$<' '$(@D)' +endef +else ifeq ($(OPENJDK_TARGET_OS),macosx) +define install-file + $(MKDIR) -p $(@D) + $(CP) -fpRP '$<' '$@' endef else define install-file $(MKDIR) -p $(@D) - $(CP) -P '$<' '$@' + $(CP) -fP '$<' '$@' endef endif @@ -67,7 +72,7 @@ $(JDK_IMAGE_DIR)/jre/bin/%: $(JDK_OUTPUTDIR)/bin/% $(ECHO) Copying $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(install-file) -NOT_JRE_BIN_FILES = \ +NOT_JRE_BIN_FILES := \ appletviewer$(EXE_SUFFIX) \ extcheck$(EXE_SUFFIX) \ idlj$(EXE_SUFFIX) \ @@ -107,7 +112,12 @@ WINDOWS_JDK_BIN_FILES = \ # Find all files in bin dir ALL_BIN_LIST := $(shell $(FIND) $(JDK_OUTPUTDIR)/bin -type f) -ifeq ($(HOST_OS),windows) + +# For unknown reason the debuginfo files for binaries are not put into images +# e.g filter them out +ALL_BIN_LIST := $(filter-out %.debuginfo %.diz, $(ALL_BIN_LIST)) + +ifeq ($(OPENJDK_TARGET_OS),windows) JDK_BIN_LIST := $(filter $(addprefix %,$(WINDOWS_JDK_BIN_FILES)), $(ALL_BIN_LIST)) else JDK_BIN_LIST := $(ALL_BIN_LIST) @@ -147,7 +157,7 @@ NOT_JRE_LIB_FILES := \ ct.sym JDK_LIB_FILES := $(NOT_JRE_LIB_FILES) -ifeq ($(HOST_OS), linux) +ifeq ($(OPENJDK_TARGET_OS), linux) JDK_LIB_FILES += jexec endif @@ -236,14 +246,21 @@ JDK_MAN_PAGES = \ wsimport.1 \ xjc.1 -ifeq ($(HOST_OS), linux) +ifeq ($(OPENJDK_TARGET_OS), linux) MAN_SRC_DIR:=$(JDK_TOPDIR)/src/linux/doc MAN1_SUBDIR:=man endif -ifeq ($(HOST_OS), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) MAN_SRC_DIR:=$(JDK_TOPDIR)/src/solaris/doc MAN1_SUBDIR:=sun/man/man1 endif +ifeq ($(OPENJDK_TARGET_OS), macosx) + MAN_SRC_DIR:=$(JDK_TOPDIR)/src/bsd/doc + MAN1_SUBDIR:=man + JDK_MAN_PAGES := $(filter-out jcmd.1, $(JDK_MAN_PAGES)) + JDK_MAN_PAGES := $(filter-out jvisualvm.1, $(JDK_MAN_PAGES)) +endif + $(JRE_IMAGE_DIR)/man/man1/%: $(MAN_SRC_DIR)/$(MAN1_SUBDIR)/% $(ECHO) Copying $(patsubst $(OUTPUT_ROOT)/%,%,$@) @@ -286,7 +303,7 @@ $(JDK_IMAGE_DIR)/man/ja_JP.PCK/man1/%: $(MAN_SRC_DIR)/$(MAN1_SUBDIR)/ja/% $(ECHO) Converting $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(call install-ja-manpage,PCK) -ifeq ($(HOST_OS), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) $(JRE_IMAGE_DIR)/man/ja/man1/%: $(MAN_SRC_DIR)/$(MAN1_SUBDIR)/ja/% $(ECHO) Converting $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(install-file) @@ -302,7 +319,7 @@ $(JDK_IMAGE_DIR)/man/ja_JP.UTF-8/man1/jcmd.1 $(JDK_IMAGE_DIR)/man/ja_JP.PCK/man1 $(MKDIR) -p $(@D) $(TOUCH) $@ -ifeq ($(HOST_OS), linux) +ifeq ($(OPENJDK_TARGET_OS), linux) $(JRE_IMAGE_DIR)/man/ja: $(ECHO) Creating $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(CD) $(@D) && $(RM) ja && $(LN) -s ja_JP.UTF-8 ja @@ -312,7 +329,17 @@ ifeq ($(HOST_OS), linux) $(CD) $(@D) && $(RM) ja && $(LN) -s ja_JP.UTF-8 ja endif -ifeq ($(HOST_OS), linux) +ifeq ($(OPENJDK_TARGET_OS), macosx) + $(JRE_IMAGE_DIR)/man/ja: + $(ECHO) Creating $(patsubst $(OUTPUT_ROOT)/%,%,$@) + $(CD) $(@D) && $(RM) ja && $(LN) -s ja_JP.UTF-8 ja + + $(JDK_IMAGE_DIR)/man/ja: + $(ECHO) Creating $(patsubst $(OUTPUT_ROOT)/%,%,$@) + $(CD) $(@D) && $(RM) ja && $(LN) -s ja_JP.UTF-8 ja +endif + +ifeq ($(OPENJDK_TARGET_OS), linux) JRE_MAN_PAGE_LIST := $(addprefix $(JRE_IMAGE_DIR)/man/man1/,$(JRE_MAN_PAGES)) \ $(addprefix $(JRE_IMAGE_DIR)/man/ja_JP.UTF-8/man1/,$(JRE_MAN_PAGES)) \ $(JRE_IMAGE_DIR)/man/ja @@ -322,7 +349,7 @@ ifeq ($(HOST_OS), linux) $(JDK_IMAGE_DIR)/man/ja endif -ifeq ($(HOST_OS), solaris) +ifeq ($(OPENJDK_TARGET_OS), solaris) JRE_MAN_PAGE_LIST := $(addprefix $(JRE_IMAGE_DIR)/man/man1/,$(JRE_MAN_PAGES)) \ $(addprefix $(JRE_IMAGE_DIR)/man/ja/man1/,$(JRE_MAN_PAGES)) \ $(addprefix $(JRE_IMAGE_DIR)/man/ja_JP.UTF-8/man1/,$(JRE_MAN_PAGES)) \ @@ -334,6 +361,16 @@ ifeq ($(HOST_OS), solaris) $(addprefix $(JDK_IMAGE_DIR)/man/ja_JP.PCK/man1/,$(JDK_MAN_PAGES)) endif +ifeq ($(OPENJDK_TARGET_OS), macosx) + JRE_MAN_PAGE_LIST := $(addprefix $(JRE_IMAGE_DIR)/man/man1/,$(JRE_MAN_PAGES)) \ + $(addprefix $(JRE_IMAGE_DIR)/man/ja_JP.UTF-8/man1/,$(JRE_MAN_PAGES)) \ + $(JRE_IMAGE_DIR)/man/ja + + JDK_MAN_PAGE_LIST := $(addprefix $(JDK_IMAGE_DIR)/man/man1/,$(JDK_MAN_PAGES)) \ + $(addprefix $(JDK_IMAGE_DIR)/man/ja_JP.UTF-8/man1/,$(JDK_MAN_PAGES)) \ + $(JDK_IMAGE_DIR)/man/ja +endif + ################################################################################ # /demo dir @@ -383,6 +420,7 @@ ifndef OPENJDK $(JDK_IMAGE_DIR)/db/README-JDK.html: $(JDK_TOPDIR)/src/closed/share/db/README-JDK.html $(ECHO) Copying '$(patsubst $(OUTPUT_ROOT)/%,%,$@)' $(install-file) + $(CHMOD) 644 $(@) JDK_DB_TARGETS := $(patsubst $(JDK_TOPDIR)/src/closed/share/db/%,$(IMAGES_OUTPUTDIR)/_unzip/%.unzipped,\ $(shell $(FIND) $(JDK_TOPDIR)/src/closed/share/db -name "*.zip" ! -name "*demo*")) \ @@ -411,7 +449,7 @@ ifdef OPENJDK else JRE_DOC_FILES := COPYRIGHT Welcome.html LICENSE THIRDPARTYLICENSEREADME.txt JDK_DOC_FILES := COPYRIGHT README.html LICENSE THIRDPARTYLICENSEREADME.txt - ifeq ($(HOST_OS), windows) + ifeq ($(OPENJDK_TARGET_OS), windows) JRE_DOC_FILES += README.txt else JRE_DOC_FILES += README @@ -432,32 +470,39 @@ JDK_DOC_TARGETS := $(addprefix $(JDK_IMAGE_DIR)/,$(JDK_DOC_FILES)) $(JRE_IMAGE_DIR)/%: $(JRE_DOC_LOCATION)/% $(ECHO) Copying $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(install-file) + $(CHMOD) 444 $(@) $(JDK_IMAGE_DIR)/jre/%: $(JRE_DOC_LOCATION)/% $(ECHO) Copying $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(install-file) + $(CHMOD) 444 $(@) $(JRE_IMAGE_DIR)/README.txt: $(JRE_DOC_LOCATION)/README $(ECHO) Copying $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(MKDIR) -p $(@D) $(CP) $< $@ + $(CHMOD) 444 $(@) $(JDK_IMAGE_DIR)/jre/README.txt: $(JRE_DOC_LOCATION)/README $(ECHO) Copying $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(MKDIR) -p $(@D) $(CP) $< $@ + $(CHMOD) 444 $(@) $(JDK_IMAGE_DIR)/%: $(JDK_DOC_LOCATION)/% $(ECHO) Copying $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(install-file) + $(CHMOD) 444 $(@) $(JDK_IMAGE_DIR)/demo/%: $(JDK_DOC_LOCATION)/% $(ECHO) Copying $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(install-file) + $(CHMOD) 444 $(@) $(JDK_IMAGE_DIR)/sample/%: $(JDK_DOC_LOCATION)/% $(ECHO) Copying $(patsubst $(OUTPUT_ROOT)/%,%,$@) $(install-file) + $(CHMOD) 444 $(@) JRE_INFO_FILE := $(JRE_IMAGE_DIR)/release JDK_INFO_FILE := $(JDK_IMAGE_DIR)/release @@ -500,7 +545,7 @@ $(JDK_IMAGE_DIR)/src.zip: $(IMAGES_OUTPUTDIR)/src.zip # Post processing (strip etc) ifneq ($(POST_STRIP_CMD),) - ifeq ($(HOST_OS), windows) + ifeq ($(OPENJDK_TARGET_OS), windows) EXEC_LIST:=$(shell $(FIND) $(JDK_OUTPUTDIR)/bin -type f -name \*.exe \ -o -name \*.dll | $(EGREP) -v -i "$(MSVCRNN_DLL)") else @@ -510,17 +555,43 @@ ifneq ($(POST_STRIP_CMD),) | $(EGREP) 'ELF' | $(CUT) -d':' -f1) endif # Filter out non JRE files and convert to unique touch files to depend on - JRE_EXEC_TOUCH_LIST:=$(patsubst $(JDK_OUTPUTDIR)/%,$(IMAGES_OUTPUTDIR)/_strip/%.stripped,\ + JRE_EXEC_TOUCH_LIST:=$(patsubst $(JDK_OUTPUTDIR)/%,$(IMAGES_OUTPUTDIR)/_strip_jre/%.stripped,\ $(filter-out $(addprefix %,$(NOT_JRE_BIN_FILES) $(NOT_JRE_LIB_FILES)), $(EXEC_LIST))) + JDK_JRE_EXEC_TOUCH_LIST:=$(patsubst $(JDK_OUTPUTDIR)/%, \ + $(IMAGES_OUTPUTDIR)/_strip_jdk/jre/%.stripped, \ + $(filter-out $(addprefix %,$(NOT_JRE_BIN_FILES) $(NOT_JRE_LIB_FILES)), $(EXEC_LIST))) + + JDK_BIN_EXEC_TOUCH_LIST := $(patsubst $(JDK_OUTPUTDIR)/%, \ + $(IMAGES_OUTPUTDIR)/_strip_jdk/%.stripped, \ + $(filter-out $(JDK_OUTPUTDIR)/lib/%, $(EXEC_LIST))) + # Setup a rule for stripping files based on touch files - $(IMAGES_OUTPUTDIR)/_strip/%.stripped: $(JRE_IMAGE_DIR)/% + $(IMAGES_OUTPUTDIR)/_strip_jre/%.stripped: $(JRE_IMAGE_DIR)/% $(ECHO) Stripping $(patsubst $(OUTPUT_ROOT)/%,%,$<) $(CHMOD) u+w $< $(POST_STRIP_CMD) $< $(CHMOD) go-w $< $(MKDIR) -p $(@D) $(TOUCH) $@ + + $(IMAGES_OUTPUTDIR)/_strip_jdk/bin/%.stripped: $(JDK_IMAGE_DIR)/bin/% + $(ECHO) Stripping $(patsubst $(OUTPUT_ROOT)/%,%,$<) + $(CHMOD) u+w $< + $(POST_STRIP_CMD) $< + $(CHMOD) go-w $< + $(MKDIR) -p $(@D) + $(TOUCH) $@ + + # Setup a rule for stripping files based on touch files + $(IMAGES_OUTPUTDIR)/_strip_jdk/jre/%.stripped: $(JDK_IMAGE_DIR)/jre/% + $(ECHO) Stripping $(patsubst $(OUTPUT_ROOT)/%,%,$<) + $(CHMOD) u+w $< + $(POST_STRIP_CMD) $< + $(CHMOD) go-w $< + $(MKDIR) -p $(@D) + $(TOUCH) $@ + endif ################################################################################ @@ -538,7 +609,8 @@ jdk-image: $(JDK_BIN_TARGETS) $(JDKJRE_BIN_TARGETS) \ $(JDK_MAN_PAGE_LIST) $(JDK_SAMPLE_TARGETS) \ $(JDK_DB_TARGETS) $(JDK_INCLUDE_TARGETS) \ $(JDKJRE_DOC_TARGETS) $(JDK_DOC_TARGETS) \ - $(JDK_INFO_FILE) $(JDK_IMAGE_DIR)/src.zip + $(JDK_INFO_FILE) $(JDK_JRE_EXEC_TOUCH_LIST) $(JDK_BIN_EXEC_TOUCH_LIST) \ + $(JDK_IMAGE_DIR)/src.zip ################################################################################ diff --git a/jdk/makefiles/Import.gmk b/jdk/makefiles/Import.gmk new file mode 100644 index 00000000000..eee94e221d6 --- /dev/null +++ b/jdk/makefiles/Import.gmk @@ -0,0 +1,243 @@ +# +# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +default: all + +include $(SPEC) +include MakeBase.gmk + +####### + +IMPORT_TARGET_FILES := + +IMPORT_CLASSES := CORBA JAXP JAXWS LANGTOOLS +IMPORT_SOURCES := CORBA JAXP JAXWS LANGTOOLS +# Only Corba has binaries +IMPORT_BINARIES := CORBA + +####### + +# Put the libraries here. Different locations for different target apis. +ifeq ($(OPENJDK_TARGET_OS_API),posix) + ifneq ($(OPENJDK_TARGET_OS),macosx) + INSTALL_LIBRARIES_HERE:=$(JDK_OUTPUTDIR)/lib/$(LIBARCH) + else + INSTALL_LIBRARIES_HERE:=$(JDK_OUTPUTDIR)/lib + endif + HOTSPOT_LIB_DIR:=$(HOTSPOT_DIST)/jre/lib/$(LIBARCH) +else + INSTALL_LIBRARIES_HERE:=$(JDK_OUTPUTDIR)/bin + HOTSPOT_LIB_DIR:=$(HOTSPOT_DIST)/jre/bin +endif + +####### + +# +# jar xf/unzip fails when executing them all in parallel +# introduce artificial dependency (_DEP) buuhhh + +define ImportClasses +$1_CLASSES_DEP := $$(IMPORT_TARGET_CLASSES) +IMPORT_TARGET_CLASSES += $(JDK_OUTPUTDIR)/classes/_the.$1.classes.imported + +$(JDK_OUTPUTDIR)/classes/_the.$1.classes.imported : $$($1_DIST)/lib/classes.jar $$($1_CLASSES_DEP) + $(ECHO) Importing $1 classes.jar + $(MKDIR) -p $$(@D) + ($(CD) $$(@D) && $(JAR) xvf $$< > $$@.tmp) + $(MV) $$@.tmp $$@ +endef + +define ImportSources +$1_SOURCES_DEP := $$(IMPORT_TARGET_SOURCES) +IMPORT_TARGET_SOURCES += $(JDK_OUTPUTDIR)/impsrc/_the.$1.src.imported + +$(JDK_OUTPUTDIR)/impsrc/_the.$1.src.imported : $$($1_DIST)/lib/src.zip $$($1_SOURCES_DEP) + $(ECHO) Importing $1 src.zip + $(MKDIR) -p $$(@D) + ($(CD) $$(@D) && $(JAR) xvf $$< > $$@.tmp) + $(MV) $$@.tmp $$@ +endef + +define ImportBinaries +$1_BINARIES_DEP := $$(IMPORT_TARGET_BINARIES) +IMPORT_TARGET_BINARIES += $(JDK_OUTPUTDIR)/_the.$1.binaries.imported + +$(JDK_OUTPUTDIR)/_the.$1.binaries.imported : $$($1_DIST)/lib/bin.zip $$($1_BINARIES_DEP) + $(ECHO) Importing $1 bin.zip + $(MKDIR) -p $$(@D) + ($(CD) $$(@D) && $(JAR) xvf $$< > $$@.tmp) + $(MV) $$@.tmp $$@ +endef + +####### + +$(foreach I,$(IMPORT_CLASSES), $(eval $(call ImportClasses,$I))) +$(foreach I,$(IMPORT_SOURCES), $(eval $(call ImportSources,$I))) +$(foreach I,$(IMPORT_BINARIES), $(eval $(call ImportBinaries,$I))) + +IMPORT_TARGET_FILES += $(IMPORT_TARGET_CLASSES) $(IMPORT_TARGET_SOURCES) $(IMPORT_TARGET_BINARIES) + +####### + +ifeq ($(OPENJDK_TARGET_OS),solaris) +define do-install-file + $(MKDIR) -p $$(@D) + $(CP) -r -P '$$<' '$$(@D)' +endef +else ifeq ($(OPENJDK_TARGET_OS),macosx) +define do-install-file + $(MKDIR) -p $$(@D) + $(CP) -pRP '$$<' '$$@' +endef +else +define do-install-file + $(MKDIR) -p $$(@D) + $(CP) -P '$$<' '$$@' +endef +endif + +define CopyDir + $1_SRC_FILES := $(shell $(FIND) $2 -type f) + $1_DST_FILES := $$(patsubst $2/%,$3/%,$$($1_SRC_FILES)) + IMPORT_TARGET_FILES += $$($1_DST_FILES) +$3/% : $2/% + $(ECHO) Copying $$(@F) + $(do-install-file) +endef + +####### + +# +# Import hotspot +# + +$(eval $(call CopyDir,HOTSPOT0, $(HOTSPOT_LIB_DIR), $(INSTALL_LIBRARIES_HERE))) +$(eval $(call CopyDir,HOTSPOT1, $(HOTSPOT_DIST)/lib, $(JDK_OUTPUTDIR)/lib)) + +JSIG_DEBUGINFO := $(wildcard $(HOTSPOT_DIST)/jre/lib/$(LIBARCH)/libjsig.debuginfo) \ + $(wildcard $(HOTSPOT_DIST)/jre/lib/$(LIBARCH)/libjsig.diz) + +ifneq ($(OPENJDK_TARGET_OS), windows) + ifeq ($(JVM_VARIANT_SERVER), true) + IMPORT_TARGET_FILES += $(INSTALL_LIBRARIES_HERE)/server/$(LIBRARY_PREFIX)jsig$(SHARED_LIBRARY_SUFFIX) + ifneq (,$(JSIG_DEBUGINFO)) + IMPORT_TARGET_FILES += $(INSTALL_LIBRARIES_HERE)/server/$(foreach I,$(JSIG_DEBUGINFO),$(notdir $I)) + endif + endif + ifeq ($(JVM_VARIANT_CLIENT), true) + IMPORT_TARGET_FILES += $(INSTALL_LIBRARIES_HERE)/client/$(LIBRARY_PREFIX)jsig$(SHARED_LIBRARY_SUFFIX) + ifneq (,$(JSIG_DEBUGINFO)) + IMPORT_TARGET_FILES += $(INSTALL_LIBRARIES_HERE)/client/$(foreach I,$(JSIG_DEBUGINFO),$(notdir $I)) + endif + endif +endif + +$(INSTALL_LIBRARIES_HERE)/server/%$(SHARED_LIBRARY_SUFFIX) : $(INSTALL_LIBRARIES_HERE)/%$(SHARED_LIBRARY_SUFFIX) + $(RM) -f $@ + $(LN) -s ../$(@F) $@ + +$(INSTALL_LIBRARIES_HERE)/server/%.debuginfo : $(INSTALL_LIBRARIES_HERE)/%.debuginfo + $(RM) -f $@ + $(LN) -s ../$(@F) $@ + +$(INSTALL_LIBRARIES_HERE)/server/%.diz : $(INSTALL_LIBRARIES_HERE)/%.diz + $(RM) -f $@ +ifeq (REALLY_WEIRD,1) + $(LN) -s ../$(@F) $@ +else +# +# TODO: Check if this is what they really want...a zip containing a symlink +# + $(RM) -f $(basename $@).debuginfo + $(LN) -s ../$(basename $(@F)).debuginfo $(basename $@).debuginfo + $(ZIP) -q -y $@ $(basename $@).debuginfo + $(RM) -f $(basename $@).debuginfo +endif + +$(INSTALL_LIBRARIES_HERE)/client/%$(SHARED_LIBRARY_SUFFIX) : $(INSTALL_LIBRARIES_HERE)/%$(SHARED_LIBRARY_SUFFIX) + $(RM) -f $@ + $(LN) -s ../$(@F) $@ + +$(INSTALL_LIBRARIES_HERE)/client/%.debuginfo : $(INSTALL_LIBRARIES_HERE)/%.debuginfo + $(RM) -f $@ + $(LN) -s ../$(@F) $@ + +$(INSTALL_LIBRARIES_HERE)/client/%.diz : $(INSTALL_LIBRARIES_HERE)/%.diz + $(RM) -f $@ +ifeq (REALLY_WEIRD,1) + $(LN) -s ../$(@F) $@ +else +# +# TODO: Check if this is what they really want...a zip containing a symlink +# + $(RM) -f $(basename $@).debuginfo + $(LN) -s ../$(basename $(@F)).debuginfo $(basename $@).debuginfo + $(ZIP) -q -y $@ $(basename $@).debuginfo + $(RM) -f $(basename $@).debuginfo +endif + +####### + +ifeq ($(OPENJDK_TARGET_OS),solaris) +define install-file + $(MKDIR) -p $(@D) + $(CP) -r -P '$<' '$(@D)' +endef +else ifeq ($(OPENJDK_TARGET_OS),macosx) +define install-file + $(MKDIR) -p $(@D) + $(CP) -pRP '$<' '$@' +endef +else +define install-file + $(MKDIR) -p $(@D) + $(CP) -P '$<' '$@' +endef +endif + +ifndef OPENJDK + +IMPORT_TARGET_FILES += \ + $(JDK_OUTPUTDIR)/lib/security/US_export_policy.jar \ + $(JDK_OUTPUTDIR)/lib/security/local_policy.jar \ + $(JDK_OUTPUTDIR)/lib/jce.jar + +$(JDK_OUTPUTDIR)/lib/jce.jar : $(JDK_TOPDIR)/make/closed/tools/crypto/jce/jce.jar + $(ECHO) Copying $(@F) + $(install-file) + +$(JDK_OUTPUTDIR)/lib/security/local_policy.jar: $(JDK_TOPDIR)/make/closed/tools/crypto/jce/local_policy.jar + $(ECHO) Copying $(@F) + $(install-file) + +$(JDK_OUTPUTDIR)/lib/security/US_export_policy.jar: $(JDK_TOPDIR)/make/closed/tools/crypto/jce/US_export_policy.jar + $(ECHO) Copying $(@F) + $(install-file) + +endif # OPENJDK + +####### + +all: $(IMPORT_TARGET_FILES) diff --git a/jdk/makefiles/LegacyMakefiles.gmk b/jdk/makefiles/LegacyMakefiles.gmk deleted file mode 100644 index e2fe44a4c02..00000000000 --- a/jdk/makefiles/LegacyMakefiles.gmk +++ /dev/null @@ -1,42 +0,0 @@ -# -# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -include $(SPEC) -include MakeBase.gmk - -all: $(JDK_OUTPUTDIR)/_the.legacy_make - -DEPS:= $(shell $(FIND) $(JDK_TOPDIR)/makefiles/java -type f) \ - $(shell $(FIND) $(JDK_TOPDIR)/makefiles/javax -type f) \ - $(shell $(FIND) $(JDK_TOPDIR)/makefiles/sun -type f) \ - $(shell $(FIND) $(JDK_TOPDIR)/makefiles/com -type f) - -$(JDK_OUTPUTDIR)/_the.legacy_make: $(DEPS) - (echo Building single threaded Java subdir && \ - $(MAKE) -j1 -C java all && \ - touch $@) - -.PHONY: all - diff --git a/jdk/makefiles/Makefile b/jdk/makefiles/Makefile index 6feba0efe4a..d7381dc9317 100644 --- a/jdk/makefiles/Makefile +++ b/jdk/makefiles/Makefile @@ -38,21 +38,21 @@ include Setup.gmk include Tools.gmk all: $(BUILD_TOOLS) +# Import (corba jaxp jaxws langtools hotspot) + +$(MAKE) -f Import.gmk +# +$(MAKE) -f GenerateJavaSources.gmk -# Drop back to the old makefiles for -# packages/libs that have not yet been converted. - +$(MAKE) -f LegacyMakefiles.gmk # Ok, now gensrc is fully populated. +$(MAKE) -f GenerateData.gmk +$(MAKE) -f CompileJavaClasses.gmk -# The classes have been built, now generate -# classes that have other sources. - +$(MAKE) -f GenerateClasses.gmk # The classes are now built and # any javah files have now been generated. +$(MAKE) -f CompileNativeLibraries.gmk # Finally compile the launchers. +$(MAKE) -f CompileLaunchers.gmk +# Generate classes that have other sources. Needs +# to execute launchers. + +$(MAKE) -f GenerateClasses.gmk # Now we have a complete jdk, which you can run. # It is not yet wrapped up as an installed image. # The demos are compiled against this jdk. @@ -64,16 +64,11 @@ ifndef NO_SAMPLES +$(MAKE) -f CopySamples.gmk endif -# Create the final jdk and jre images in the old way. Kept for reference -# until conversion is fully done. -old-images: - +$(MAKE) $(IMAGES_MAKE_ARGS) -f OldImages.gmk - # Create the final jdk and jre images, to be wrapped up # into packages, or installed. images: +$(MAKE) -f CreateJars.gmk - +$(MAKE) $(IMAGES_MAKE_ARGS) -f Images.gmk + +$(MAKE) -f Images.gmk BINARIES:=$(shell if test -d $(IMAGES_OUTPUTDIR)/j2sdk-image/bin; then cd $(IMAGES_OUTPUTDIR)/j2sdk-image/bin && $(LS) ; fi) @@ -90,9 +85,4 @@ install: images $(RM) $(addprefix $(INSTALL_PREFIX)/bin/,$(BINARIES)) $(foreach b,$(BINARIES),$(LN) -s $(INSTALL_PREFIX)/jvm/$(INSTALLDIR)/bin/$b $(INSTALL_PREFIX)/bin/$b &&) true -# Create the deb,rpm,tgz,zip, packages. -packages: images - echo Creating packages...well, in the future. - $(MKDIR) -p $(OUTPUT_ROOT)/packages - .PHONY: all install images diff --git a/jdk/makefiles/OldImages.gmk b/jdk/makefiles/OldImages.gmk deleted file mode 100644 index 1db1c174db8..00000000000 --- a/jdk/makefiles/OldImages.gmk +++ /dev/null @@ -1,175 +0,0 @@ -# -# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -include $(SPEC) -include MakeBase.gmk -include JavaCompilation.gmk -include Setup.gmk - -default: $(IMAGES_OUTPUTDIR)/_the.images - -include Tools.gmk - -JARS:= - -########################################################################################## - -JCONSOLE_JAR_DEPS := \ - $(shell $(FIND) $(JDK_OUTPUTDIR)/newclasses/sun/tools/jconsole/ -name "_the.package") \ - $(shell $(FIND) $(JDK_OUTPUTDIR)/newclasses/com/sun/tools/jconsole/ -name "_the.package") - -$(eval $(call SetupArchive,BUILD_JCONSOLE_JAR,$(JCONSOLE_JAR_DEPS),\ - SRCS:=$(JDK_OUTPUTDIR)/newclasses,\ - SUFFIXES:=.class .gif .png,\ - INCLUDES:=sun/tools/jconsole com/sun/tools/jconsole,\ - JARMAIN:=sun.tools.jconsole.JConsole,\ - JAR:=$(JDK_OUTPUTDIR)/lib/jconsole.jar,\ - SKIP_METAINF:=true)) - -JARS+=$(JDK_OUTPUTDIR)/lib/jconsole.jar - -########################################################################################## - -CHARSETS_JAR_DEPS := - -$(eval $(call SetupArchive,BUILD_CHARSETS_JAR,$(CHARSETS_JAR_DEPS),\ - SRCS:=$(JDK_OUTPUTDIR)/newclasses, \ - SUFFIXES:=.class .dat,\ - INCLUDES:=sun/nio/cs/ext,\ - EXTRA_FILES := sun/awt/HKSCS.class \ - sun/awt/motif/X11GBK.class \ - 'sun/awt/motif/X11GB2312$$$$Decoder.class' \ - sun/awt/motif/X11GB2312.class \ - 'sun/awt/motif/X11KSC5601$$$$Decoder.class' \ - 'sun/awt/motif/X11KSC5601$$$$Encoder.class' \ - 'sun/awt/motif/X11GB2312$$$$Encoder.class' \ - 'sun/awt/motif/X11GBK$$$$Encoder.class' \ - sun/awt/motif/X11KSC5601.class \ - META-INF/services/java.nio.charset.spi.CharsetProvider, \ - JAR:=$(JDK_OUTPUTDIR)/lib/charsets.jar, \ - JARMAIN := NONE, \ - SKIP_METAINF := true)) - -JARS+=$(JDK_OUTPUTDIR)/lib/charsets.jar - -########################################################################################## - -SUNPKCS11_JAR_DST := $(JDK_OUTPUTDIR)/lib/ext/sunpkcs11.jar - -ifndef OPENJDK - -SUNPKCS11_JAR_SRC := $(JDK_TOPDIR)/make/closed/tools/crypto/pkcs11/sunpkcs11.jar - -$(SUNPKCS11_JAR_DST) : $(SUNPKCS11_JAR_SRC) - @$(ECHO) "\n>>>Installing prebuilt SunPKCS11 provider..." - $(RM) $@ - $(CP) $< $@ - -else - -$(eval $(call SetupArchive,BUILD_SUNPKCS11_JAR,$(SUNPKCS11_JAR_DEPS),\ - SRCS:=$(JDK_OUTPUTDIR)/newclasses, \ - SUFFIXES:=.class,\ - INCLUDES:=sun/security/pkcs11,\ - JAR:=$(SUNPKCS11_JAR_DST), \ - JARMAIN := NONE, \ - SKIP_METAINF := true)) - -endif - -JARS += $(SUNPKCS11_JAR_DST) - -########################################################################################## - -SUNEC_JAR_DST := $(JDK_OUTPUTDIR)/lib/ext/sunec.jar - -ifndef OPENJDK - -SUNEC_JAR_SRC := $(JDK_TOPDIR)/make/closed/tools/crypto/ec/sunec.jar - -$(SUNEC_JAR_DST) : $(SUNEC_JAR_SRC) - @$(ECHO) "\n>>>Installing prebuilt SunEC provider..." - $(RM) $@ - $(CP) $< $@ - -else - -$(eval $(call SetupArchive,BUILD_SUNEC_JAR,$(SUNEC_JAR_DEPS),\ - SRCS:=$(JDK_OUTPUTDIR)/newclasses, \ - SUFFIXES:=.class,\ - INCLUDES:=sun/security/ec,\ - EXCLUDE_FILES := \ - sun/security/ec/ECKeyFactory.class \ - sun/security/ec/ECParameters.class \ - sun/security/ec/ECPrivateKeyImpl.class \ - sun/security/ec/ECPublicKeyImpl.class \ - sun/security/ec/NamedCurve.class \ - 'sun/security/ec/ECKeyFactory$$$$1.class' \ - 'sun/security/ec/ECKeyFactory$$$$2.class' ,\ - JAR:=$(SUNEC_JAR_DST), \ - JARMAIN := NONE, \ - SKIP_METAINF := true)) - -endif - -JARS += $(SUNEC_JAR_DST) - -########################################################################################## - -# TODO: deps? -$(eval $(call SetupArchive,BUILD_SWINGBEANS_JAR,$(SWINGBEANS_JAR_DEPS),\ - SRCS:=$(JDK_OUTPUTDIR)/newclasses,\ - SUFFIXES:=BeanInfo.class .gif,\ - INCLUDES:=javax/swing sun/swing,\ - EXCLUDES:=javax/swing/plaf,\ - EXTRA_FILES:=javax/swing/SwingBeanInfoBase.class sun/swing/BeanInfoUtils.class,\ - JAR:=$(JDK_OUTPUTDIR)/lib/dt.jar,\ - JARMAIN:=NONE,\ - SKIP_METAINF:=true)) - -JARS+=$(JDK_OUTPUTDIR)/lib/dt.jar - -########################################################################################## - -# Need to define BUILDDIR for Release.gmk to work -BUILDDIR=$(JDK_TOPDIR)/makefiles -include common/Defs.gmk -include common/Release.gmk - -# A rudimentary attempt at band-aiding the dependency tracking. -DEPS:= $(shell $(FIND) $(JDK_OUTPUTDIR)/newclasses -name "*.class" -type f) \ - $(shell $(FIND) $(JDK_OUTPUTDIR)/bin -type f) \ - $(shell $(FIND) $(JDK_OUTPUTDIR)/lib -type f) - -$(IMAGES_OUTPUTDIR)/_the.images : $(DEPS) $(JARS) - $(MKDIR) -p $(@D) -# Restart this makefile, ugly, but since double colon (::) rules -# have been used in Release.gmk, it is impossible to craft on -# dependencies on these. I.e. -do-not-use- :: rules!!!!! -# Repeat after me: -do-not-use- :: rules!!!!! - $(MAKE) -j1 -f OldImages.gmk $(IMAGES_MAKE_ARGS) images - $(TOUCH) $@ - -.PHONY: default diff --git a/jdk/makefiles/Tools.gmk b/jdk/makefiles/Tools.gmk index 71ffde7e397..3f0a8dd02ab 100644 --- a/jdk/makefiles/Tools.gmk +++ b/jdk/makefiles/Tools.gmk @@ -123,3 +123,27 @@ TOOL_WRAPPERGENERATOR=$(JAVA) -cp $(JDK_OUTPUTDIR)/btclasses \ TOOL_TOBIN=$(JAVA) -Djava.awt.headless=true -cp $(JDK_OUTPUTDIR)/btclasses \ sun.awt.X11.ToBin + +########################################################################################## + +# Tools needed on solaris because OBJCOPY is broken. + +$(eval $(call SetupNativeCompilation,ADD_GNU_DEBUGLINK,\ + SRC:=$(JDK_TOPDIR)/make/tools/add_gnu_debuglink,\ + LANG:=C,\ + CC:=$(HOST_CC),\ + LDEXE:=$(HOST_LD),\ + LDFLAGS:=-lelf,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/add_gnu_debuglink,\ + OUTPUT_DIR:=$(JDK_OUTPUTDIR)/btbin,\ + PROGRAM:=add_gnu_debuglink)) + +$(eval $(call SetupNativeCompilation,FIX_EMPTY_SEC_HDR_FLAGS,\ + SRC:=$(JDK_TOPDIR)/make/tools/fix_empty_sec_hdr_flags,\ + LANG:=C,\ + CC:=$(HOST_CC),\ + LDEXE:=$(HOST_LD),\ + LDFLAGS:=-lelf,\ + OBJECT_DIR:=$(JDK_OUTPUTDIR)/objs/fix_empty_sec_hdr_flags,\ + OUTPUT_DIR:=$(JDK_OUTPUTDIR)/btbin,\ + PROGRAM:=fix_empty_sec_hdr_flags)) diff --git a/jdk/makefiles/com/sun/crypto/provider/Makefile b/jdk/makefiles/com/sun/crypto/provider/Makefile deleted file mode 100644 index 93a0b1308c7..00000000000 --- a/jdk/makefiles/com/sun/crypto/provider/Makefile +++ /dev/null @@ -1,275 +0,0 @@ -# -# Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile for building sunjce_provider.jar. -# -# This file was derived from make/javax/crypto/Makefile. -# - -# -# (The terms "OpenJDK" and "JDK" below refer to OpenJDK and Sun JDK builds -# respectively.) -# -# JCE builds are very different between OpenJDK and JDK. The OpenJDK JCE -# jar files do not require signing, but those for JDK do. If an unsigned -# jar file is installed into JDK, things will break when the crypto -# routines are called. -# -# This Makefile does the "real" build of the JCE files. There are some -# javac options currently specific to JCE, so we recompile now to make -# sure any implicit compilations didn't use any incorrect flags. -# -# For OpenJDK, the jar files built here are installed directly into the -# OpenJDK. -# -# For JDK, the binaries use pre-built/pre-signed binary files stored in -# the closed workspace that are not shipped in the OpenJDK workspaces. -# We still build the JDK files here to verify the files compile, and in -# preparation for possible signing. Developers working on JCE in JDK -# must sign the JCE files before testing. The JCE signing key is kept -# separate from the JDK workspace to prevent its disclosure. -# -# SPECIAL NOTE TO JCE/JDK developers: The source files must eventually -# be built and signed, and the resulting jar files MUST BE CHECKED INTO -# THE CLOSED PART OF THE WORKSPACE*. This separate step *MUST NOT BE -# FORGOTTEN*, otherwise a bug fixed in the source code will not be -# reflected in the shipped binaries. The "release" target should be -# used to generate the required files. -# -# There are a number of targets to help both JDK/OpenJDK developers. -# -# Main Targets (JDK/OPENJDK): -# -# all/clobber/clean The usual. -# If OpenJDK, installs sunjce_provider.jar. -# If JDK, installs prebuilt -# sunjce_provider.jar. -# -# jar Builds/installs sunjce_provider.jar -# If OpenJDK, does not sign. -# If JDK, tries to sign. -# -# Other lesser-used Targets (JDK/OPENJDK): -# -# build-jar Builds sunjce_provider.jar -# (does not sign/install) -# -# install-jar Alias for "jar" above. -# -# Other targets (JDK only): -# -# sign Alias for sign-jar -# sign-jar Builds/signs sunjce_provider.jar (no install) -# -# release Builds all targets in preparation -# for workspace integration. -# -# install-prebuilt Installs the pre-built jar files -# -# This makefile was written to support parallel target execution. -# - -BUILDDIR = ../../../.. -PACKAGE = com.sun.crypto.provider -PRODUCT = sun - -# -# The following is for when we need to do postprocessing -# (signing) against a read-only build. If the OUTPUTDIR -# isn't writable, the build currently crashes out. -# -ifndef OPENJDK - ifdef ALT_JCE_BUILD_DIR - # ===================================================== - # Where to place the output, in case we're building from a read-only - # build area. (e.g. a release engineering build.) - JCE_BUILD_DIR=${ALT_JCE_BUILD_DIR} - IGNORE_WRITABLE_OUTPUTDIR_TEST=true - else - JCE_BUILD_DIR=${TEMPDIR} - endif -endif - -JAVAC_MAX_WARNINGS = false -JAVAC_LINT_OPTIONS = -Xlint:all,-deprecation -JAVAC_WARNINGS_FATAL = true -include $(BUILDDIR)/common/Defs.gmk - -# -# Location for the newly built classfiles. -# -CLASSDESTDIR = $(TEMPDIR)/classes - -# -# Subdirectories of these are automatically included. -# -AUTO_FILES_JAVA_DIRS = \ - com/sun/crypto/provider - -include $(BUILDDIR)/common/Classes.gmk - -# -# Rules -# - -# -# Some licensees do not get the security sources, but we still need to -# be able to build "all" for them. Check here to see if the sources were -# available. If not, then we don't need to continue this rule. -# - -ifdef OPENJDK -all: build-jar install-jar -else # OPENJDK -ifeq ($(strip $(FILES_java)),) -all: install-prebuilt - $(no-source-warning) -else # FILES_java available -all: build-jar install-prebuilt - $(build-warning) -endif # $(FILES_java) available -endif # OPENJDK - -# -# We use a variety of subdirectories in the $(TEMPDIR) depending on what -# part of the build we're doing. Both OPENJDK/JDK builds are initially -# done in the unsigned area. When files are signed in JDK, they will be -# placed in the appropriate areas. -# -UNSIGNED_DIR = $(TEMPDIR)/unsigned - -include $(BUILDDIR)/javax/crypto/Defs-jce.gmk - - -# ===================================================== -# Build the unsigned sunjce_provider.jar file. -# - -JAR_DESTFILE = $(EXTDIR)/sunjce_provider.jar - -# -# The sunjce_provider.jar needs to be in the extension class directory, -# therefore none of its classes should appear in $(CLASSBINDIR). -# Currently no one is using any of the SunJCE internals, so these files -# should not have been built. -# - -# -# Since the -C option to jar is used below, each directory entry must be -# preceded with the appropriate directory to "cd" into. -# -JAR_DIRS = $(patsubst %, -C $(CLASSDESTDIR) %, $(AUTO_FILES_JAVA_DIRS)) - -build-jar: $(UNSIGNED_DIR)/sunjce_provider.jar - -# -# Build sunjce_provider.jar. -# -$(UNSIGNED_DIR)/sunjce_provider.jar: build $(JCE_MANIFEST_FILE) - $(prep-target) - $(BOOT_JAR_CMD) cmf $(JCE_MANIFEST_FILE) $@ $(JAR_DIRS) \ - $(BOOT_JAR_JFLAGS) - @$(java-vm-cleanup) - - -ifndef OPENJDK -# ===================================================== -# Sign the provider jar file. Not needed for OpenJDK. -# - -SIGNED_DIR = $(JCE_BUILD_DIR)/signed - -sign: sign-jar - -sign-jar: $(SIGNED_DIR)/sunjce_provider.jar - -ifndef ALT_JCE_BUILD_DIR -$(SIGNED_DIR)/sunjce_provider.jar: $(UNSIGNED_DIR)/sunjce_provider.jar -else -# -# We have to remove the build dependency, otherwise, we'll try to rebuild it -# which we can't do on a read-only filesystem. -# -$(SIGNED_DIR)/sunjce_provider.jar: - @if [ ! -r $(UNSIGNED_DIR)/sunjce_provider.jar ] ; then \ - $(ECHO) "Couldn't find $(UNSIGNED_DIR)/sunjce_provider.jar"; \ - exit 1; \ - fi -endif - $(call sign-file, $(UNSIGNED_DIR)/sunjce_provider.jar) - - -# ===================================================== -# Create the Release Engineering files. Signed builds, etc. -# - -release: $(SIGNED_DIR)/sunjce_provider.jar - $(RM) $(JCE_BUILD_DIR)/release/sunjce_provider.jar - $(MKDIR) -p $(JCE_BUILD_DIR)/release - $(CP) $(SIGNED_DIR)/sunjce_provider.jar $(JCE_BUILD_DIR)/release - $(release-warning) - -endif # OPENJDK - - -# ===================================================== -# Install routines. -# - -# -# Install sunjce_provider.jar, depending on which type is requested. -# -install-jar jar: $(JAR_DESTFILE) -ifndef OPENJDK - $(release-warning) -endif - -ifdef OPENJDK -$(JAR_DESTFILE): $(UNSIGNED_DIR)/sunjce_provider.jar -else -$(JAR_DESTFILE): $(SIGNED_DIR)/sunjce_provider.jar -endif - $(install-file) - -ifndef OPENJDK -install-prebuilt: - @$(ECHO) "\n>>>Installing prebuilt SunJCE provider..." - $(RM) $(JAR_DESTFILE) - $(CP) $(PREBUILT_DIR)/jce/sunjce_provider.jar $(JAR_DESTFILE) -endif - - -# ===================================================== -# Support routines. -# - -clobber clean:: - $(RM) -r $(JAR_DESTFILE) $(TEMPDIR) $(JCE_BUILD_DIR) - -.PHONY: build-jar jar install-jar -ifndef OPENJDK -.PHONY: sign sign-jar release install-prebuilt -endif diff --git a/jdk/makefiles/common/Classes.gmk b/jdk/makefiles/common/Classes.gmk deleted file mode 100644 index 07acf6c0106..00000000000 --- a/jdk/makefiles/common/Classes.gmk +++ /dev/null @@ -1,67 +0,0 @@ -# -# Copyright (c) 1995, 2005, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. -# - -include $(JDK_TOPDIR)/makefiles/common/Rules.gmk - -# -# Say you built classes into $(ALT_CLASSBINDIR) and then at the end of -# the build you might want to copy them over to $(ALT_CLASSDESTDIR); -# this rule takes care of that. No one should really set these -# variables except the bootstrap/recompile stage of the java compiler. -# -ifdef ALT_CLASSBINDIR - -# By default post-processing is copying. Suppose you want to build -# a jar file then set ALT_CLASSES_DISPOSITION to '../../dest/nameof.jar' -# before including this file. -ifndef ALT_CLASSES_DISPOSITION -ALT_CLASSES_DISPOSITION = copy-classes -endif - -build : $(ALT_CLASSES_DISPOSITION) - -copy-classes: -ifneq ($(ALT_CLASSBINDIR), $(ALT_CLASSDESTDIR)) - @if [ -s $(TEMPDIR)/.classes.list ]; then \ - mkdir -p $(ALT_CLASSDESTDIR); \ - echo "Copying $(ALT_CLASSBINDIR)..."; \ - echo "(cd $(ALT_CLASSBINDIR); tar cf - .) | \ - (cd $(ALT_CLASSDESTDIR); tar xf -)"; \ - (cd $(ALT_CLASSBINDIR); tar cf - .) | \ - (cd $(ALT_CLASSDESTDIR); tar xf -); \ - fi -else # ALT_CLASSBINDIR - @if [ -s $(TEMPDIR)/.classes.list ]; then \ - echo "Copy source and destination are the same: $(ALT_CLASSBINDIR) -- Copy skipped..."; \ - fi -endif # ALT_CLASSBINDIR - -.PHONY: copy-classes -endif # ALT_CLASSBINDIR - diff --git a/jdk/makefiles/common/Cscope.gmk b/jdk/makefiles/common/Cscope.gmk deleted file mode 100644 index 812fd5f0d12..00000000000 --- a/jdk/makefiles/common/Cscope.gmk +++ /dev/null @@ -1,100 +0,0 @@ -# -# Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# The cscope.out file is made in the current directory and spans the entire -# source tree. -# -# Things to note: -# 1. We use relative names for cscope. -# 2. We *don't* remove the old cscope.out file, because cscope is smart -# enough to only build what has changed. It can be confused, however, -# if files are renamed or removed, so it may be necessary to manually -# remove cscope.out if a lot of reorganization has occurred. -# -CSDIRS = $(JDK_TOPDIR)/src $(JDK_TOPDIR)/build -CSINCS = $(CSDIRS:%=-I%) - -# -# Set CSFLAGS env variable to -b when using fast cscope to build the fast -# (but large) cscope data bases. -# -CSCOPE = cscope-fast -ifeq ($(CSCOPE), cscope-fast) -CSFLAGS = -b -endif - -# -# Adding .java files pushes the file count of a full workspace up about 2500 -# files, which slows database lookup. Thus allow these files to be added from -# the environment (CSCLASSES=yes). -# -ifdef CSCLASSES -ADDCLASSES= -o -name '*.java' -endif - -# -# Adding CClassHeaders also pushes the file count of a full workspace up about -# 200 files (these files also don't exist in a new workspace, and thus will -# cause the recreation of the database as they get created, which might seem -# A little confusing). Thus allow these files to be added from the environment -# (CSHEADERS=yes). -# -ifndef CSHEADERS -RMCCHEADERS= -o -name CClassHeaders -endif - - -.PRECIOUS: cscope.out - -cscope.out: cscope.files FRC - $(CSCOPE) $(CSFLAGS) - -# -# What files should we include? A simple rule might be just those files under -# SCM control, however this would miss files we create like the opcodes and -# CClassHeaders. The following attempts to find everything that is *useful*. -# (demo directories contain many .java files -# that probably aren't useful for development, and the pkgarchive may contain -# duplicates of files within the source hierarchy). The ordering of the .raw -# file is an attempt to make cscope display the most relevant files first. -# -cscope.files: FRC - @-$(RM) cscope.files cscope.files.raw - echo "$(CSINCS)" > cscope.files - -find $(CSDIRS) $(SCM_DIRS_prune) -o -type d \( -name '.del-*' -o \ - -name '*demo' -o -name pkgarchive $(RMCCHEADERS) \) -prune -o \ - -type f \( -name '*.[Ccshlxy]' -o -name '*.il' -o -name '*.cc' -o \ - -name 'Makefile*' -o -name GNUmakefile -o -name '*.gmk' -o \ - -name '*.cpp' $(ADDCLASSES) \) -print > cscope.files.raw - -egrep -v "\.java|\/build\/" cscope.files.raw >> cscope.files - -fgrep ".java" cscope.files.raw >> cscope.files - -fgrep "/build/" cscope.files.raw >> cscope.files - @-$(RM) cscope.files.raw - -cscope.clean: - -$(RM) cscope.files cscope.files.raw cscope.out - -FRC: diff --git a/jdk/makefiles/common/Defs-embedded.gmk b/jdk/makefiles/common/Defs-embedded.gmk deleted file mode 100644 index 089fae9d586..00000000000 --- a/jdk/makefiles/common/Defs-embedded.gmk +++ /dev/null @@ -1,76 +0,0 @@ -# -# Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Variable definitions for SE Embedded builds. This file should -# not contain rules. -# -ifdef JAVASE_EMBEDDED - -# Compress jar files -COMPRESS_JARS = true - -# Don't mmap zip files -LIBZIP_CAN_USE_MMAP = false - -# Disable ALSA version check -REQUIRED_ALSA_VERSION = - -# Compilation settings -OTHER_CPPFLAGS += -DJAVASE_EMBEDDED - -# Product naming -PRODUCT_SUFFIX = SE Runtime Environment for Embedded -RUNTIME_NAME = $(PRODUCT_NAME) $(PRODUCT_SUFFIX) - -# Reduced JRE locations -JRE_REDUCED_HEADLESS_IMAGE_DIR = $(ABS_OUTPUTDIR)/j2re-reduced-headless-image -JRE_REDUCED_IMAGE_DIR = $(ABS_OUTPUTDIR)/j2re-reduced-image - -# Override on linux to further reduce binary/lib sizes in product build -ifeq ($(PLATFORM), linux) - ifeq ($(VARIANT), OPT) - ifneq ($(NO_STRIP), true) - ifneq ($(DEBUG_BINARIES), true) - POST_STRIP_PROCESS = $(STRIP) --strip-unneeded - endif - endif - endif -endif - -# NIO Platform specific source file location -ifdef CROSS_COMPILE_ARCH - NIO_PLATFORM_CLASSES_ROOT_DIR = $(CLOSED_PLATFORM_SRC)/classes/ -endif - -# For ARM sflt we need to link to a library with improved FP accuracy -# and it must be linked after fdlibm - this places it at the end after libc -# -z muldefs avoids linker errors for duplicate symbols. -ifeq ($(CROSS_COMPILE_ARCH), arm) - EXTRA_LIBS += $(EXT_LIBS_PATH)/sflt_glibc_jdk.a -Xlinker -z -Xlinker muldefs -endif - -endif # JAVASE_EMBEDDED - diff --git a/jdk/makefiles/common/Defs-linux.gmk b/jdk/makefiles/common/Defs-linux.gmk deleted file mode 100644 index 03ff72a27b2..00000000000 --- a/jdk/makefiles/common/Defs-linux.gmk +++ /dev/null @@ -1,430 +0,0 @@ -# -# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile to specify compiler flags for programs and libraries -# targeted to Linux. Should not contain any rules. -# -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. -# - -# Warning: the following variables are overriden by Defs.gmk. Set -# values will be silently ignored: -# CFLAGS (set $(OTHER_CFLAGS) instead) -# CPPFLAGS (set $(OTHER_CPPFLAGS) instead) -# CXXFLAGS (set $(OTHER_CXXFLAGS) instead) -# LDFLAGS (set $(OTHER_LDFAGS) instead) -# LDLIBS (set $(EXTRA_LIBS) instead) -# LDLIBS_COMMON (set $(EXTRA_LIBS) instead) - -# Get shared JDK settings -include $(JDK_MAKE_SHARED_DIR)/Defs.gmk - -# Part of INCREMENTAL_BUILD mechanism. -# Compiler emits things like: path/file.o: file.h -# We want something like: relative_path/file.o relative_path/file.d: file.h -CC_DEPEND = -MM -CC_DEPEND_FILTER = $(SED) -e 's!$*\.$(OBJECT_SUFFIX)!$(dir $@)& $(dir $@)$*.$(DEPEND_SUFFIX)!g' - -ifndef PLATFORM_SRC - PLATFORM_SRC = $(BUILDDIR)/../src/solaris -endif # PLATFORM_SRC - -# Platform specific closed sources -ifndef OPENJDK - ifndef CLOSED_PLATFORM_SRC - CLOSED_PLATFORM_SRC = $(BUILDDIR)/../src/closed/solaris - endif -endif - -# platform specific include files -PLATFORM_INCLUDE_NAME = $(PLATFORM) -PLATFORM_INCLUDE = $(INCLUDEDIR)/$(PLATFORM_INCLUDE_NAME) - -# suffix used for make dependencies files. -DEPEND_SUFFIX = d -# The suffix applied to the library name for FDLIBM -FDDLIBM_SUFFIX = a -# The suffix applied to scripts (.bat for windows, nothing for unix) -SCRIPT_SUFFIX = -# CC compiler object code output directive flag value -CC_OBJECT_OUTPUT_FLAG = -o #trailing blank required! - -# Default OBJCOPY comes from GNU Binutils on Linux: -DEF_OBJCOPY=/usr/bin/objcopy -ifdef CROSS_COMPILE_ARCH - # don't try to generate .debuginfo files when cross compiling - _JUNK_ := $(shell \ - echo >&2 "INFO: cross compiling for ARCH $(CROSS_COMPILE_ARCH)," \ - "skipping .debuginfo generation.") - OBJCOPY= -else - OBJCOPY=$(shell test -x $(DEF_OBJCOPY) && echo $(DEF_OBJCOPY)) - ifneq ($(ALT_OBJCOPY),) - _JUNK_ := $(shell echo >&2 "INFO: ALT_OBJCOPY=$(ALT_OBJCOPY)") - # disable .debuginfo support by setting ALT_OBJCOPY to a non-existent path - OBJCOPY=$(shell test -x $(ALT_OBJCOPY) && echo $(ALT_OBJCOPY)) - endif -endif - -ifdef LIBRARY_SUPPORTS_FULL_DEBUG_SYMBOLS -# The setting of OBJCOPY above enables the JDK build to import -# .debuginfo files from the HotSpot build. However, adding FDS -# support to the JDK build will occur in phases so a different -# make variable is used to indicate that a particular library -# supports FDS. - -ifeq ($(OBJCOPY),) - _JUNK_ := $(shell \ - echo >&2 "INFO: no objcopy cmd found so cannot create .debuginfo files.") -else - _JUNK_ := $(shell \ - echo >&2 "INFO: $(OBJCOPY) cmd found so will create .debuginfo files.") - - # Library stripping policies for .debuginfo configs: - # all_strip - strips everything from the library - # min_strip - strips most stuff from the library; leaves minimum symbols - # no_strip - does not strip the library at all - # - # Oracle security policy requires "all_strip". A waiver was granted on - # 2011.09.01 that permits using "min_strip" in the Java JDK and Java JRE. - # - DEF_STRIP_POLICY="min_strip" - ifeq ($(ALT_STRIP_POLICY),) - STRIP_POLICY=$(DEF_STRIP_POLICY) - else - STRIP_POLICY=$(ALT_STRIP_POLICY) - endif - - _JUNK_ := $(shell \ - echo >&2 "INFO: STRIP_POLICY=$(STRIP_POLICY)") -endif -endif - -# -# Default optimization -# - -ifndef OPTIMIZATION_LEVEL - ifeq ($(PRODUCT), java) - OPTIMIZATION_LEVEL = HIGHER - else - OPTIMIZATION_LEVEL = LOWER - endif -endif -ifndef FASTDEBUG_OPTIMIZATION_LEVEL - FASTDEBUG_OPTIMIZATION_LEVEL = LOWER -endif - -CC_OPT/NONE = -CC_OPT/LOWER = -O2 -CC_OPT/HIGHER = -O3 -CC_OPT/HIGHEST = -O3 - -CC_OPT = $(CC_OPT/$(OPTIMIZATION_LEVEL)) - -# For all platforms, do not omit the frame pointer register usage. -# We need this frame pointer to make it easy to walk the stacks. -# This should be the default on X86, but ia64 and amd64 may not have this -# as the default. -CFLAGS_REQUIRED_amd64 += -fno-omit-frame-pointer -D_LITTLE_ENDIAN -CFLAGS_REQUIRED_i586 += -fno-omit-frame-pointer -D_LITTLE_ENDIAN -CFLAGS_REQUIRED_ia64 += -fno-omit-frame-pointer -D_LITTLE_ENDIAN -CFLAGS_REQUIRED_sparcv9 += -m64 -mcpu=v9 -LDFLAGS_COMMON_sparcv9 += -m64 -mcpu=v9 -CFLAGS_REQUIRED_sparc += -m32 -mcpu=v9 -LDFLAGS_COMMON_sparc += -m32 -mcpu=v9 -CFLAGS_REQUIRED_arm += -fsigned-char -D_LITTLE_ENDIAN -CFLAGS_REQUIRED_ppc += -fsigned-char -D_BIG_ENDIAN -ifeq ($(ZERO_BUILD), true) - CFLAGS_REQUIRED = $(ZERO_ARCHFLAG) - ifeq ($(ZERO_ENDIANNESS), little) - CFLAGS_REQUIRED += -D_LITTLE_ENDIAN - endif - LDFLAGS_COMMON += $(ZERO_ARCHFLAG) -else - CFLAGS_REQUIRED = $(CFLAGS_REQUIRED_$(ARCH)) - LDFLAGS_COMMON += $(LDFLAGS_COMMON_$(ARCH)) -endif - -# If this is a --hash-style=gnu system, use --hash-style=both -# The gnu .hash section won't work on some Linux systems like SuSE 10. -_HAS_HASH_STYLE_GNU:=$(shell $(CC) -dumpspecs | $(GREP) -- '--hash-style=gnu') -ifneq ($(_HAS_HASH_STYLE_GNU),) - LDFLAGS_HASH_STYLE = -Wl,--hash-style=both -endif -LDFLAGS_COMMON += $(LDFLAGS_HASH_STYLE) - -# -# Selection of warning messages -# -GCC_INHIBIT = -Wno-unused -Wno-parentheses -GCC_STYLE = -GCC_WARNINGS = -W -Wall $(GCC_STYLE) $(GCC_INHIBIT) - -# -# Treat compiler warnings as errors, if warnings not allowed -# -ifeq ($(COMPILER_WARNINGS_FATAL),true) - GCC_WARNINGS += -Werror -endif - -# -# Misc compiler options -# -ifneq ($(ARCH),ppc) - CFLAGS_COMMON = -fno-strict-aliasing -endif -PIC_CODE_LARGE = -fPIC -PIC_CODE_SMALL = -fpic -GLOBAL_KPIC = $(PIC_CODE_LARGE) -CFLAGS_COMMON += $(GLOBAL_KPIC) $(GCC_WARNINGS) -ifeq ($(ARCH), amd64) - CFLAGS_COMMON += -pipe -endif - -# Linux 64bit machines use Dwarf2, which can be HUGE, have fastdebug use -g1 -DEBUG_FLAG = -g -ifeq ($(FASTDEBUG), true) - ifeq ($(ARCH_DATA_MODEL), 64) - DEBUG_FLAG = -g1 - endif -endif - -# DEBUG_BINARIES overrides everything, use full -g debug information -ifeq ($(DEBUG_BINARIES), true) - DEBUG_FLAG = -g - CFLAGS_REQUIRED += $(DEBUG_FLAG) -endif - -CFLAGS_OPT = $(CC_OPT) -CFLAGS_DBG = $(DEBUG_FLAG) -CFLAGS_COMMON += $(CFLAGS_REQUIRED) - -CXXFLAGS_COMMON = $(GLOBAL_KPIC) -DCC_NOEX $(GCC_WARNINGS) -CXXFLAGS_OPT = $(CC_OPT) -CXXFLAGS_DBG = $(DEBUG_FLAG) -CXXFLAGS_COMMON += $(CFLAGS_REQUIRED) - -# FASTDEBUG: Optimize the code in the -g versions, gives us a faster debug java -ifeq ($(FASTDEBUG), true) - CFLAGS_DBG += $(CC_OPT/$(FASTDEBUG_OPTIMIZATION_LEVEL)) - CXXFLAGS_DBG += $(CC_OPT/$(FASTDEBUG_OPTIMIZATION_LEVEL)) -endif - -CPP_ARCH_FLAGS = -DARCH='"$(ARCH)"' - -# Alpha arch does not like "alpha" defined (potential general arch cleanup issue here) -ifneq ($(ARCH),alpha) - CPP_ARCH_FLAGS += -D$(ARCH) -else - CPP_ARCH_FLAGS += -D_$(ARCH)_ -endif - -CPPFLAGS_COMMON = $(CPP_ARCH_FLAGS) -DLINUX $(VERSION_DEFINES) \ - -D_LARGEFILE64_SOURCE -D_GNU_SOURCE -D_REENTRANT - -ifeq ($(ARCH_DATA_MODEL), 64) -CPPFLAGS_COMMON += -D_LP64=1 -endif - -CPPFLAGS_OPT = -DNDEBUG -CPPFLAGS_DBG = -DDEBUG -ifneq ($(PRODUCT), java) - CPPFLAGS_DBG += -DLOGGING -endif - -ifdef LIBRARY - # Libraries need to locate other libraries at runtime, and you can tell - # a library where to look by way of the dynamic runpaths (RPATH or RUNPATH) - # buried inside the .so. The $ORIGIN says to look relative to where - # the library itself is and it can be followed with relative paths from - # that. By default we always look in $ORIGIN, optionally we add relative - # paths if the Makefile sets LD_RUNPATH_EXTRAS to those relative paths. - # On Linux we add a flag -z origin, not sure if this is necessary, but - # doesn't seem to hurt. - # The environment variable LD_LIBRARY_PATH will over-ride these runpaths. - # Try: 'readelf -d lib*.so' to see these settings in a library. - # - Z_ORIGIN_FLAG/sparc = -Xlinker -z -Xlinker origin - Z_ORIGIN_FLAG/i586 = -Xlinker -z -Xlinker origin - Z_ORIGIN_FLAG/amd64 = -Xlinker -z -Xlinker origin - Z_ORIGIN_FLAG/ia64 = -Xlinker -z -Xlinker origin - Z_ORIGIN_FLAG/arm = - Z_ORIGIN_FLAG/ppc = - Z_ORIGIN_FLAG/zero = -Xlinker -z -Xlinker origin - - LDFLAG_Z_ORIGIN = $(Z_ORIGIN_FLAG/$(ARCH_FAMILY)) - - LDFLAGS_COMMON += $(LDFLAG_Z_ORIGIN) -Xlinker -rpath -Xlinker \$$ORIGIN - LDFLAGS_COMMON += $(LD_RUNPATH_EXTRAS:%=$(LDFLAG_Z_ORIGIN) -Xlinker -rpath -Xlinker \$$ORIGIN/%) - -endif - -EXTRA_LIBS += -lc - -LDFLAGS_DEFS_OPTION = -Xlinker -z -Xlinker defs -#LDFLAGS_COMMON += $(LDFLAGS_DEFS_OPTION) - -# -# -L paths for finding and -ljava -# -LDFLAGS_OPT = -Xlinker -O1 -LDFLAGS_COMMON += -L$(LIBDIR)/$(LIBARCH) -LDFLAGS_COMMON += -Wl,-soname=$(LIB_PREFIX)$(LIBRARY).$(LIBRARY_SUFFIX) - -# -# -static-libgcc is a gcc-3 flag to statically link libgcc, gcc-2.9x always -# statically link libgcc but will print a warning with the flag. We don't -# want the warning, so check gcc version first. -# -ifeq ($(CC_MAJORVER),3) - OTHER_LDFLAGS += -static-libgcc -endif - -# Automatic precompiled header option to use (if COMPILE_APPROACH=batch) -# (See Rules.gmk) The gcc 5 compiler might have an option for this? -AUTOMATIC_PCH_OPTION = - -# -# Post Processing of libraries/executables -# -ifeq ($(VARIANT), OPT) - ifneq ($(NO_STRIP), true) - ifneq ($(DEBUG_BINARIES), true) - # Debug 'strip -g' leaves local function Elf symbols (better stack - # traces) - POST_STRIP_PROCESS = $(STRIP) -g - endif - endif -endif - -# -# Use: ld $(LD_MAPFILE_FLAG) mapfile *.o -# -LD_MAPFILE_FLAG = -Xlinker --version-script -Xlinker - -# -# Support for Quantify. -# -ifdef QUANTIFY -QUANTIFY_CMD = quantify -QUANTIFY_OPTIONS = -cache-dir=/tmp/quantify -always-use-cache-dir=yes -LINK_PRE_CMD = $(QUANTIFY_CMD) $(QUANTIFY_OPTIONS) -endif - -# -# Path and option to link against the VM, if you have to. Note that -# there are libraries that link against only -ljava, but they do get -# -L to the -ljvm, this is because -ljava depends on -ljvm, whereas -# the library itself should not. -# -VM_NAME = server -# First try to link against server, if that does not exist link against client. -JVMLIB = -L$(LIBDIR)/$(LIBARCH)/server -L$(LIBDIR)/$(LIBARCH)/client -ljvm -JAVALIB = -ljava $(JVMLIB) - -# -# We want to privatize JVM symbols on Solaris. This is so the user can -# write a function called FindClass and this should not override the -# FindClass that is inside the JVM. At this point in time we are not -# concerned with other JNI libraries because we hope that there will -# not be as many clashes there. -# -PRIVATIZE_JVM_SYMBOLS = false - -USE_PTHREADS = true -override ALT_CODESET_KEY = _NL_CTYPE_CODESET_NAME -override AWT_RUNPATH = -override HAVE_ALTZONE = false -override HAVE_FILIOH = false -override HAVE_GETHRTIME = false -override HAVE_GETHRVTIME = false -override HAVE_SIGIGNORE = true -override LEX_LIBRARY = -lfl -ifeq ($(STATIC_CXX),true) -override LIBCXX = -Wl,-Bstatic -lstdc++ -lgcc -Wl,-Bdynamic -else -override LIBCXX = -lstdc++ -endif -override LIBPOSIX4 = -override LIBSOCKET = -override LIBNSL = -override LIBSCF = -override LIBTHREAD = -override LIBDL = -ldl -override MOOT_PRIORITIES = true -override NO_INTERRUPTIBLE_IO = true -ifeq ($(ARCH), amd64) -override OPENWIN_LIB = $(OPENWIN_HOME)/lib64 -else -override OPENWIN_LIB = $(OPENWIN_HOME)/lib -endif -override OTHER_M4FLAGS = -D__GLIBC__ -DGNU_ASSEMBLER -override SUN_CMM_SUBDIR = -override THREADS_FLAG = native -override USE_GNU_M4 = true -override USING_GNU_TAR = true -override WRITE_LIBVERSION = false - -# USE_EXECNAME forces the launcher to look up argv[0] on $PATH, and put the -# resulting resolved absolute name of the executable in the environment -# variable EXECNAME. That executable name is then used that to locate the -# installation area. -override USE_EXECNAME = true - -# If your platform has DPS, it will have Type1 fonts too, in which case -# it is best to enable DPS support until such time as 2D's rasteriser -# can fully handle Type1 fonts in all cases. Default is "yes". -# HAVE_DPS should only be "no" if the platform has no DPS headers or libs -# DPS (Displayable PostScript) is available on Solaris machines -HAVE_DPS = no - -# -# Japanese manpages -# -JA_SOURCE_ENCODING = eucJP -JA_TARGET_ENCODINGS = UTF-8 - -# Settings for the JDI - Serviceability Agent binding. -HOTSPOT_SALIB_PATH = $(HOTSPOT_IMPORT_PATH)/jre/lib/$(LIBARCH) -SALIB_NAME = $(LIB_PREFIX)saproc.$(LIBRARY_SUFFIX) -SA_DEBUGINFO_NAME = $(LIB_PREFIX)saproc.debuginfo - -# The JDI - Serviceability Agent binding is not currently supported -# on Linux-ia64. -ifeq ($(ARCH), ia64) - INCLUDE_SA = false -else - INCLUDE_SA = true -endif - -ifdef CROSS_COMPILE_ARCH - # X11 headers are not under /usr/include - OTHER_CFLAGS += -I$(OPENWIN_HOME)/include - OTHER_CXXFLAGS += -I$(OPENWIN_HOME)/include - OTHER_CPPFLAGS += -I$(OPENWIN_HOME)/include -endif diff --git a/jdk/makefiles/common/Defs-macosx.gmk b/jdk/makefiles/common/Defs-macosx.gmk deleted file mode 100644 index e1e8e252e7c..00000000000 --- a/jdk/makefiles/common/Defs-macosx.gmk +++ /dev/null @@ -1,402 +0,0 @@ -# -# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile to specify compiler flags for programs and libraries -# targeted to MACOSX. Should not contain any rules. -# -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. -# - -# Warning: the following variables are overriden by Defs.gmk. Set -# values will be silently ignored: -# CFLAGS (set $(OTHER_CFLAGS) instead) -# CPPFLAGS (set $(OTHER_CPPFLAGS) instead) -# CXXFLAGS (set $(OTHER_CXXFLAGS) instead) -# LDFLAGS (set $(OTHER_LDFAGS) instead) -# LDLIBS (set $(EXTRA_LIBS) instead) -# LDLIBS_COMMON (set $(EXTRA_LIBS) instead) - -# Get shared JDK settings -include $(JDK_MAKE_SHARED_DIR)/Defs.gmk - -# Part of INCREMENTAL_BUILD mechanism. -# Compiler emits things like: path/file.o: file.h -# We want something like: relative_path/file.o relative_path/file.d: file.h -CC_DEPEND = -MM -CC_DEPEND_FILTER = $(SED) -e 's!$*\.$(OBJECT_SUFFIX)!$(dir $@)& $(dir $@)$*.$(DEPEND_SUFFIX)!g' - -ifndef PLATFORM_SRC - PLATFORM_SRC = $(BUILDDIR)/../src/solaris -endif # PLATFORM_SRC - -PLATFORM_SRC_MACOS = $(BUILDDIR)/../src/macosx - -# BSD build pulls its platform sources from the solaris tree. -JAVA_SRCDIR_LIST = src/$(PLATFORM) src/solaris src/share -NATIVE_SRCDIR_LIST = src/$(PLATFORM) src/solaris src/share - -# Platform specific closed sources -ifndef OPENJDK - ifndef CLOSED_PLATFORM_SRC - CLOSED_PLATFORM_SRC = $(BUILDDIR)/../src/closed/solaris - endif -endif - -# platform specific include files -PLATFORM_INCLUDE_NAME = $(OS_NAME) -PLATFORM_INCLUDE = $(INCLUDEDIR)/$(PLATFORM_INCLUDE_NAME) - -# suffix used for make dependencies files. -DEPEND_SUFFIX = d -# The suffix applied to the library name for FDLIBM -FDDLIBM_SUFFIX = a -# The suffix applied to scripts (.bat for windows, nothing for unix) -SCRIPT_SUFFIX = -# CC compiler object code output directive flag value -CC_OBJECT_OUTPUT_FLAG = -o #trailing blank required! -CC_PROGRAM_OUTPUT_FLAG = -o #trailing blank required! - -# -# Default optimization -# - -ifndef OPTIMIZATION_LEVEL - ifeq ($(PRODUCT), java) - OPTIMIZATION_LEVEL = HIGHER - else - OPTIMIZATION_LEVEL = LOWER - endif -endif -ifndef FASTDEBUG_OPTIMIZATION_LEVEL - FASTDEBUG_OPTIMIZATION_LEVEL = LOWER -endif - -# For macosx use -Os by default, unless -O3 can be proved to be worth the cost, as per policy -# -CC_OPT/NONE = -CC_OPT/LOWER = -Os -CC_OPT/HIGHER = -Os -CC_OPT/HIGHEST = -Os - -CC_OPT = $(CC_OPT/$(OPTIMIZATION_LEVEL)) - -# For all platforms, do not omit the frame pointer register usage. -# We need this frame pointer to make it easy to walk the stacks. -# This should be the default on X86, but ia64, and x86_64 -# may not have this as the default. -CFLAGS_REQUIRED_x86_64 += -m64 -fno-omit-frame-pointer -D_LITTLE_ENDIAN -LDFLAGS_COMMON_x86_64 += -m64 -CFLAGS_REQUIRED_i586 += -m32 -fno-omit-frame-pointer -D_LITTLE_ENDIAN -LDFLAGS_COMMON_i586 += -m32 -CFLAGS_REQUIRED_ia64 += -m64 -fno-omit-frame-pointer -D_LITTLE_ENDIAN -CFLAGS_REQUIRED_sparcv9 += -m64 -mcpu=v9 -LDFLAGS_COMMON_sparcv9 += -m64 -mcpu=v9 -CFLAGS_REQUIRED_sparc += -m32 -mcpu=v9 -LDFLAGS_COMMON_sparc += -m32 -mcpu=v9 -CFLAGS_REQUIRED_arm += -fsigned-char -D_LITTLE_ENDIAN -CFLAGS_REQUIRED_ppc += -fsigned-char -D_BIG_ENDIAN -ifeq ($(ZERO_BUILD), true) - CFLAGS_REQUIRED = $(ZERO_ARCHFLAG) - ifeq ($(ZERO_ENDIANNESS), little) - CFLAGS_REQUIRED += -D_LITTLE_ENDIAN - endif - LDFLAGS_COMMON += $(ZERO_ARCHFLAG) -else ifeq ($(ARCH), universal) - CFLAGS_REQUIRED += -arch i386 -arch x86_64 -D_LITTLE_ENDIAN - LDFLAGS_COMMON += -arch i386 -arch x86_64 -else - CFLAGS_REQUIRED = $(CFLAGS_REQUIRED_$(ARCH)) - LDFLAGS_COMMON += $(LDFLAGS_COMMON_$(ARCH)) -endif -# 16-byte stack re-alignment on 32-bit Darwin -CFLAGS_REQUIRED_i586 += -mstackrealign - -OTHER_CFLAGS = \ - -F/System/Library/Frameworks/JavaVM.framework/Frameworks \ - -F/System/Library/Frameworks/ApplicationServices.framework/Frameworks - -# -# Selection of warning messages -# -GCC_INHIBIT = -Wno-unused -Wno-parentheses -GCC_STYLE = -GCC_WARNINGS = -W -Wall $(GCC_STYLE) $(GCC_INHIBIT) - -# -# Treat compiler warnings as errors, if warnings not allowed -# -ifeq ($(COMPILER_WARNINGS_FATAL),true) - GCC_WARNINGS += -Werror -endif - -# -# Misc compiler options -# -ifneq ($(ARCH),ppc) - CFLAGS_COMMON = -fno-strict-aliasing -endif -PIC_CODE_LARGE = -fPIC -PIC_CODE_SMALL = -fpic -GLOBAL_KPIC = $(PIC_CODE_LARGE) -CFLAGS_COMMON += $(GLOBAL_KPIC) $(GCC_WARNINGS) -ifeq ($(ARCH), x86_64) - CFLAGS_COMMON += -pipe -endif - -# BSD 64bit machines use Dwarf2, which can be HUGE, have fastdebug use -g1 -DEBUG_FLAG = -g -ifeq ($(FASTDEBUG), true) - ifeq ($(ARCH_DATA_MODEL), 64) - DEBUG_FLAG = -g1 - endif -endif - -# DEBUG_BINARIES overrides everything, use full -g debug information -ifeq ($(DEBUG_BINARIES), true) - DEBUG_FLAG = -g - CFLAGS_REQUIRED += $(DEBUG_FLAG) -endif - -CFLAGS_OPT = $(CC_OPT) -CFLAGS_DBG = $(DEBUG_FLAG) -CFLAGS_COMMON += $(CFLAGS_REQUIRED) - -CXXFLAGS_COMMON = $(GLOBAL_KPIC) -DCC_NOEX $(GCC_WARNINGS) -CXXFLAGS_OPT = $(CC_OPT) -CXXFLAGS_DBG = $(DEBUG_FLAG) -CXXFLAGS_COMMON += $(CFLAGS_REQUIRED) - -# FASTDEBUG: Optimize the code in the -g versions, gives us a faster debug java -ifeq ($(FASTDEBUG), true) - CFLAGS_DBG += $(CC_OPT/$(FASTDEBUG_OPTIMIZATION_LEVEL)) - CXXFLAGS_DBG += $(CC_OPT/$(FASTDEBUG_OPTIMIZATION_LEVEL)) -endif - -CPP_ARCH_FLAGS = -DARCH='"$(ARCH)"' - -# Alpha arch does not like "alpha" defined (potential general arch cleanup issue here) -ifneq ($(ARCH),alpha) - CPP_ARCH_FLAGS += -D$(ARCH) -else - CPP_ARCH_FLAGS += -D_$(ARCH)_ -endif -CPPFLAGS_COMMON = $(CPP_ARCH_FLAGS) -D_ALLBSD_SOURCE $(VERSION_DEFINES) \ - -D_LARGEFILE64_SOURCE -D_GNU_SOURCE -D_REENTRANT - -CPPFLAGS_COMMON += -DMACOSX - -ifeq ($(ARCH_DATA_MODEL), 64) -CPPFLAGS_COMMON += -D_LP64=1 -endif - -CPPFLAGS_OPT = -DNDEBUG -CPPFLAGS_DBG = -DDEBUG -ifneq ($(PRODUCT), java) - CPPFLAGS_DBG += -DLOGGING -endif - -# Libraries need to locate other libraries at runtime, and you can tell -# a library where to look by way of the dynamic runpaths (RPATH or RUNPATH) -# buried inside the .{so,dylib}. The {$ORIGIN,@loader_path/} says to look -# relative to where the library itself is and it can be followed -# with relative paths from that. By default we always look in -# {$ORIGIN,@loader_path/}, optionally we add relative paths if the Makefile -# sets LD_RUNPATH_EXTRAS to those relative paths. -# Except on MacOS X we add a flag -z origin, not sure if this is necessary, -# but doesn't seem to hurt. -# The environment variable LD_LIBRARY_PATH will over-ride these runpaths. -# See 'man {dyld,rtld}' for more information. -# Try: 'readelf -d lib*.so' to see these settings in a library. -# -LDFLAGS_COMMON += -Xlinker -rpath -Xlinker @loader_path/. -LDFLAGS_COMMON += $(LD_RUNPATH_EXTRAS:%=-Xlinker -rpath -Xlinker @loader_path/%) -LDFLAGS_COMMON += -Xlinker -install_name -Xlinker @rpath/$(@F) - -# -# -L paths for finding and -ljava -# -LDFLAGS_COMMON += -L$(LIBDIR) - -# -# -static-libgcc is a gcc-3 flag to statically link libgcc, gcc-2.9x always -# statically link libgcc but will print a warning with the flag. We don't -# want the warning, so check gcc version first. -# -ifeq ($(CC_MAJORVER),3) - OTHER_LDFLAGS += -static-libgcc -endif - -# Automatic precompiled header option to use (if COMPILE_APPROACH=batch) -# (See Rules.gmk) The gcc 5 compiler might have an option for this? -AUTOMATIC_PCH_OPTION = - -# -# Post Processing of libraries/executables -# -ifeq ($(VARIANT), OPT) - ifneq ($(NO_STRIP), true) - ifneq ($(DEBUG_BINARIES), true) - # Debug 'strip -S' leaves local function Elf symbols (better stack - # traces) - POST_STRIP_PROCESS = $(STRIP) -S - endif - endif -endif - -# -# Use: ld $(LD_MAPFILE_FLAG) mapfile *.o -# -LD_MAPFILE_FLAG = -Xlinker --version-script -Xlinker - -# -# Support for Quantify. -# -ifdef QUANTIFY -QUANTIFY_CMD = quantify -QUANTIFY_OPTIONS = -cache-dir=/tmp/quantify -always-use-cache-dir=yes -LINK_PRE_CMD = $(QUANTIFY_CMD) $(QUANTIFY_OPTIONS) -endif - -# Darwin does not support linker map files. -LDNOMAP=true - -# -# Path and option to link against the VM, if you have to. Note that -# there are libraries that link against only -ljava, but they do get -# -L to the -ljvm, this is because -ljava depends on -ljvm, whereas -# the library itself should not. -# -VM_NAME = server -JVMLIB = -L$(LIBDIR)/server -L$(LIBDIR)/client -ljvm -JAVALIB = -ljava $(JVMLIB) - -# -# We want to privatize JVM symbols on Solaris. This is so the user can -# write a function called FindClass and this should not override the -# FindClass that is inside the JVM. At this point in time we are not -# concerned with other JNI libraries because we hope that there will -# not be as many clashes there. -# -PRIVATIZE_JVM_SYMBOLS = false - -USE_PTHREADS = true -override ALT_CODESET_KEY = _NL_CTYPE_CODESET_NAME -override AWT_RUNPATH = -override HAVE_ALTZONE = false -override HAVE_FILIOH = false -override HAVE_GETHRTIME = false -override HAVE_GETHRVTIME = false -override HAVE_SIGIGNORE = true -override LEX_LIBRARY = -lfl -ifeq ($(STATIC_CXX),true) -override LIBCXX = -Wl,-Bstatic -lstdc++ -lgcc -Wl,-Bdynamic -else -override LIBCXX = -lstdc++ -endif -override LIBPOSIX4 = -override LIBSOCKET = -override LIBNSL = -override LIBTHREAD = -override LIBDL = -override MOOT_PRIORITIES = true -override NO_INTERRUPTIBLE_IO = true -override OPENWIN_HOME = $(X11_PATH) -override OPENWIN_LIB = $(OPENWIN_HOME)/lib -override OTHER_M4FLAGS = -D__GLIBC__ -DGNU_ASSEMBLER -override SUN_CMM_SUBDIR = -override THREADS_FLAG = native -override USE_GNU_M4 = true -override USING_GNU_TAR = true -override WRITE_LIBVERSION = false - -ifdef ALT_X11_PATH - X11_PATH = $(ALT_X11_PATH) -else - X11_PATH = /usr/X11R6 -endif - -ifdef ALT_PACKAGE_PATH - PACKAGE_PATH = $(ALT_PACKAGE_PATH) -else - PACKAGE_PATH = /opt/local -endif - -# ALSA -ifdef ALT_ALSA_LIB_PATH - ALSA_LIB_PATH = $(ALT_ALSA_LIB_PATH) -else - ALSA_LIB_PATH = $(PACKAGE_PATH)/lib -endif - -ifdef ALT_ALSA_HEADERS_PATH - ALSA_HEADERS_PATH = $(ALT_ALSA_HEADERS_PATH) -else - ALSA_HEADERS_PATH = $(PACKAGE_PATH)/include -endif - -# USE_EXECNAME forces the launcher to look up argv[0] on $PATH, and put the -# resulting resolved absolute name of the executable in the environment -# variable EXECNAME. That executable name is then used that to locate the -# installation area. -override USE_EXECNAME = true - -# If your platform has DPS, it will have Type1 fonts too, in which case -# it is best to enable DPS support until such time as 2D's rasteriser -# can fully handle Type1 fonts in all cases. Default is "yes". -# HAVE_DPS should only be "no" if the platform has no DPS headers or libs -# DPS (Displayable PostScript) is available on Solaris machines -HAVE_DPS = no - -SYSTEM_ZLIB = true - -# -# Japanese manpages -# -JA_SOURCE_ENCODING = eucJP -JA_TARGET_ENCODINGS = UTF-8 - -# Settings for the JDI - Serviceability Agent binding. - -HOTSPOT_SALIB_PATH = $(HOTSPOT_IMPORT_PATH)/jre/lib/$(LIBARCH) -SALIB_NAME = $(LIB_PREFIX)saproc.$(LIBRARY_SUFFIX) - -# The JDI - Serviceability Agent binding is not currently supported -# on ia64. -ifeq ($(ARCH), ia64) - INCLUDE_SA = false -else - INCLUDE_SA = true -endif - -ifdef CROSS_COMPILE_ARCH - # X11 headers are not under /usr/include - OTHER_CFLAGS += -I$(OPENWIN_HOME)/include - OTHER_CXXFLAGS += -I$(OPENWIN_HOME)/include - OTHER_CPPFLAGS += -I$(OPENWIN_HOME)/include -endif - -LIB_LOCATION ?= $(LIBDIR) diff --git a/jdk/makefiles/common/Defs-solaris.gmk b/jdk/makefiles/common/Defs-solaris.gmk deleted file mode 100644 index 7632e6767f1..00000000000 --- a/jdk/makefiles/common/Defs-solaris.gmk +++ /dev/null @@ -1,757 +0,0 @@ -# -# Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile to specify compiler flags for programs and libraries -# targeted to Solaris. Should not contain any rules. -# -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. -# - -# Warning: the following variables are overridden by Defs.gmk. Set -# values will be silently ignored: -# CFLAGS (set $(OTHER_CFLAGS) instead) -# CPPFLAGS (set $(OTHER_CPPFLAGS) instead) -# CXXFLAGS (set $(OTHER_CXXFLAGS) instead) -# LDFLAGS (set $(OTHER_LDFAGS) instead) -# LDLIBS (set $(EXTRA_LIBS) instead) -# LDLIBS_COMMON (set $(EXTRA_LIBS) instead) -# LINTFLAGS (set $(OTHER_LINTFLAGS) instead) -# -# Note: CPPFLAGS are used in C and C++ compiles. -# - -# Get shared JDK settings -include $(JDK_MAKE_SHARED_DIR)/Defs.gmk - -ifndef PLATFORM_SRC -PLATFORM_SRC = $(BUILDDIR)/../src/solaris -endif # PLATFORM_SRC - -# Platform specific closed sources -ifndef OPENJDK - ifndef CLOSED_PLATFORM_SRC - CLOSED_PLATFORM_SRC = $(BUILDDIR)/../src/closed/solaris - endif -endif - -# platform specific include files -PLATFORM_INCLUDE_NAME = $(PLATFORM) -PLATFORM_INCLUDE = $(INCLUDEDIR)/$(PLATFORM_INCLUDE_NAME) - -# suffix used for make dependencies files -DEPEND_SUFFIX = d -# suffix used for lint files -LINT_SUFFIX = ln -# The suffix applied to the library name for FDLIBM -FDDLIBM_SUFFIX = a -# The suffix applied to scripts (.bat for windows, nothing for unix) -SCRIPT_SUFFIX = -# CC compiler object code output directive flag value -CC_OBJECT_OUTPUT_FLAG = -o #trailing blank required! - -ifdef ENABLE_FULL_DEBUG_SYMBOLS -# Only check for Full Debug Symbols support on Solaris if it is -# specifically enabled. Hopefully, it can be enabled by default -# once the .debuginfo size issues are worked out. - -# Default OBJCOPY comes from the SUNWbinutils package: -DEF_OBJCOPY=/usr/sfw/bin/gobjcopy -ifeq ($(PLATFORM)-$(LIBARCH), solaris-amd64) - # On Solaris AMD64/X64, gobjcopy is not happy and fails: - # - # usr/sfw/bin/gobjcopy --add-gnu-debuglink=.debuginfo .so - # BFD: stKPaiop: Not enough room for program headers, try linking with -N - # /usr/sfw/bin/gobjcopy: stKPaiop: Bad value - # BFD: stKPaiop: Not enough room for program headers, try linking with -N - # /usr/sfw/bin/gobjcopy: libsaproc.debuginfo: Bad value - # BFD: stKPaiop: Not enough room for program headers, try linking with -N - # /usr/sfw/bin/gobjcopy: stKPaiop: Bad value - _JUNK_ := $(shell \ - echo >&2 "INFO: $(DEF_OBJCOPY) is not working on Solaris AMD64/X64") - OBJCOPY= -else - OBJCOPY=$(shell test -x $(DEF_OBJCOPY) && echo $(DEF_OBJCOPY)) - ifneq ($(ALT_OBJCOPY),) - _JUNK_ := $(shell echo >&2 "INFO: ALT_OBJCOPY=$(ALT_OBJCOPY)") - # disable .debuginfo support by setting ALT_OBJCOPY to a non-existent path - OBJCOPY=$(shell test -x $(ALT_OBJCOPY) && echo $(ALT_OBJCOPY)) - endif -endif - -ifdef LIBRARY_SUPPORTS_FULL_DEBUG_SYMBOLS -# The setting of OBJCOPY above enables the JDK build to import -# .debuginfo files from the HotSpot build. However, adding FDS -# support to the JDK build will occur in phases so a different -# make variable is used to indicate that a particular library -# supports FDS. - -ifeq ($(OBJCOPY),) - _JUNK_ := $(shell \ - echo >&2 "INFO: no objcopy cmd found so cannot create .debuginfo files.") -else - _JUNK_ := $(shell \ - echo >&2 "INFO: $(OBJCOPY) cmd found so will create .debuginfo files.") - - # Library stripping policies for .debuginfo configs: - # all_strip - strips everything from the library - # min_strip - strips most stuff from the library; leaves minimum symbols - # no_strip - does not strip the library at all - # - # Oracle security policy requires "all_strip". A waiver was granted on - # 2011.09.01 that permits using "min_strip" in the Java JDK and Java JRE. - # - DEF_STRIP_POLICY="min_strip" - ifeq ($(ALT_STRIP_POLICY),) - STRIP_POLICY=$(DEF_STRIP_POLICY) - else - STRIP_POLICY=$(ALT_STRIP_POLICY) - endif - _JUNK_ := $(shell \ - echo >&2 "INFO: STRIP_POLICY=$(STRIP_POLICY)") -endif -endif -endif - -# -# Java default optimization (-x04/-O2) etc. Applies to the VM. -# -ifndef OPTIMIZATION_LEVEL - ifeq ($(PRODUCT), java) - OPTIMIZATION_LEVEL = HIGHER - else - OPTIMIZATION_LEVEL = LOWER - endif -endif -ifndef FASTDEBUG_OPTIMIZATION_LEVEL - FASTDEBUG_OPTIMIZATION_LEVEL = LOWER -endif - -# -# If -Xa is in CFLAGS_COMMON it will end up ahead of $(CC_OPT) for the -# optimized build, and that ordering of the flags completely freaks -# out cc. Hence, -Xa is instead in each CFLAGS variant. -# -# The more unusual options to the Sun C compiler: -# -v Stricter type checking, more error checking -# (To turn ALL warnings into fatals, use -errwarn=%all) -# -xstrconst Place string literals and constants in read-only area -# (means you can't write on your string literals) -# -xs Force debug information (stabs) into the .so or a.out -# (makes the library/executable debuggable without the -# .o files needing to be around, but at a space cost) -# -g & -O If you add the -g option to the optimized compiles -# you will get better stack retraces, the code is -# still optimized. This includes a space cost too. -# -xc99=%none Do NOT allow for c99 extensions to be used. -# e.g. declarations must precede statements -# -xCC Allow the C++ style of comments in C: // -# Required with many of the source files. -# -mt Assume multi-threaded (important) -# -# The more unusual options to the Sun C compiler: -# +w Print more warnings -# +w2 Maximum warnings -# - -# -# Debug flag for C and C++ compiler -# -CFLAGS_DEBUG_OPTION = -g $(CC_OPT/NONE) -CXXFLAGS_DEBUG_OPTION = -g $(CXX_OPT/NONE) - -# Turn off -g if we are doing tcov build -ifdef TCOV_BUILD - CFLAGS_DEBUG_OPTION= - CXXFLAGS_DEBUG_OPTION= -endif - -# FASTDEBUG: Optimize the -g builds, gives us a faster debug java -# If true adds -O to the debug compiles. This allows for any assert -# tests to remain and debug checking. The resulting code is faster -# but less debuggable. Stack traces are still valid, although only -# approximate line numbers are given. Printing of local variables -# during a debugging session is not possible, but stepping and -# printing of global or static variables should be possible. -# Performance/size of files should be about the same, maybe smaller. -# -ifeq ($(FASTDEBUG), true) - CFLAGS_DEBUG_OPTION = -g $(CC_OPT/$(FASTDEBUG_OPTIMIZATION_LEVEL)) - CXXFLAGS_DEBUG_OPTION = -g0 $(CXX_OPT/$(FASTDEBUG_OPTIMIZATION_LEVEL)) -endif - -CFLAGS_COMMON = -L$(OBJDIR) - -# Do not allow C99 language features like declarations in code etc. -CFLAGS_COMMON += -xc99=%none - -# Allow C++ comments in C code -CFLAGS_COMMON += -xCC - -# Show error message tags on errors -CFLAGS_COMMON += -errshort=tags -CXXFLAGS_COMMON += -errtags=yes - -# Optimization flags -CFLAGS_OPT = $(CC_OPT) - -# Debug version flags -CFLAGS_DBG = $(CFLAGS_DEBUG_OPTION) - -# Required C compiler flags -CFLAGS_COMMON += -Xa $(CFLAGS_REQUIRED) - -# Maximum warnings all the time -CXXFLAGS_COMMON += +w -CFLAGS_COMMON += -v - -# Assume MT behavior all the time (important) -CXXFLAGS_COMMON += -mt -CFLAGS_COMMON += -mt - -# Assume no C++ exceptions are used -CXXFLAGS_COMMON += -features=no%except -DCC_NOEX - -# For C++, these options tell it to assume nothing about locating libraries -# either at compile time, or at runtime. Use of these options will likely -# require the use of -L and -R options to indicate where libraries will -# be found at compile time (-L) and at runtime (-R). -# The /usr/lib location comes for free, so no need to specify that one. -# Note: C is much simplier and there is no need for these options. This -# is mostly needed to avoid dependencies on libraries in the -# Compiler install area, also see LIBCXX and LIBM. -CXXFLAGS_COMMON += -norunpath -xnolib - -# -# Treat compiler warnings as errors, if requested -# -ifeq ($(COMPILER_WARNINGS_FATAL),true) - CFLAGS_COMMON += -errwarn=%all - CXXFLAGS_COMMON += -errwarn=%all -endif - -CXXFLAGS_OPT = $(CXX_OPT) -CXXFLAGS_DBG = $(CXXFLAGS_DEBUG_OPTION) -CXXFLAGS_COMMON += $(CFLAGS_REQUIRED) - -# Add -xstrconst to the library compiles. This forces all string -# literals into the read-only data section, which prevents them from -# being written to and increases the runtime pages shared on the system. -# -ifdef LIBRARY - CFLAGS_COMMON +=-xstrconst -endif - -# Source browser database -# -# COMPILE_WITH_SB -# If defined adds -xsb to compiles and creates a -# source browsing database during compilation. -# -ifdef COMPILE_WITH_SB - ifeq ($(LIBRARY), java) - CFLAGS_DBG += -xsb - endif -endif - -# Lint Flags: -# -Xa ANSI C plus K&R, favor ANSI rules -# -fd report on old style func defs -# -errchk=structarg report on 64bit struct args by value -# -errchk=longptr64 report on 64bit to 32bit issues (ignores casts) -# -errchk=parentheses report on suggested use of extra parens -# -v suppress unused args -# -x suppress unused externs -# -u suppress extern func/vars used/defined -# -errfmt=simple use one line errors with position info -# $(LINT_XARCH_OPTION) See Compiler-sun.gwk - -LINTFLAGS_COMMON = -Xa -LINTFLAGS_COMMON += -fd -LINTFLAGS_COMMON += -errchk=structarg,longptr64,parentheses -LINTFLAGS_COMMON += -v -LINTFLAGS_COMMON += -x -LINTFLAGS_COMMON += -u -LINTFLAGS_COMMON += -errfmt=simple -LINTFLAGS_OPT = -LINTFLAGS_DBG = - -# The -W0,-noglobal tells the compiler to NOT generate mangled global -# ELF data symbols for file local static data. -# This can break fix&continue, but we'd rather do the same compilations -# for deliverable bits as we do for non-deliverable bits -# Tell the compilers to never generate globalized names, all the time. -CFLAGS_COMMON += -W0,-noglobal - -# If we have a specific arch value to use, add it -CFLAGS_COMMON += $(XARCH_OPTION) -CXXFLAGS_COMMON += $(XARCH_OPTION) -ASFLAGS_COMMON += $(AS_XARCH_OPTION) -EXTRA_LIBS += $(XARCH_OPTION) -LINTFLAGS_COMMON += $(LINT_XARCH_OPTION) - -# -# uncomment the following to build with PERTURBALOT set -# -# OTHER_CFLAGS += -DPERTURBALOT -# - -CPPFLAGS_COMMON = -D__solaris__ -D$(ARCH_FAMILY) -CPPFLAGS_OPT = -DNDEBUG -CPPFLAGS_DBG = -DDEBUG - -ifneq ($(PRODUCT), java) - CPPFLAGS_DBG += -DLOGGING -DDBINFO -endif - -ifeq ($(ARCH_FAMILY), i586) - # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the - # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN - # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h). - # Note: -Dmacro is the same as #define macro 1 - # -Dmacro= is the same as #define macro - # - CPPFLAGS_COMMON += -DcpuIntel -D_LITTLE_ENDIAN= -D$(LIBARCH) - # Turn off a superfluous compiler error message on Intel - CFLAGS_COMMON += -erroff=E_BAD_PRAGMA_PACK_VALUE -endif - -# Java memory management is based on memory mapping by default, but a -# system only assuming malloc/free can be built by adding -DUSE_MALLOC - -CPPFLAGS_COMMON += -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS -CPPFLAGS_OPT += -DTRIMMED - -LDFLAGS_DEFS_OPTION = -z defs -LDFLAGS_COMMON += $(LDFLAGS_DEFS_OPTION) - -# -# -L paths for finding and -ljava -# -LDFLAGS_COMMON += -L$(LIBDIR)/$(LIBARCH) -LDFLAGS_OPT = -LDFLAGS_DBG = - -# -# We never really want the incremental linker, ever -# The -xildoff option tells Sun's compilers to NOT use incremental linker -# -LDFLAGS_COMMON += -xildoff - -ifdef LIBRARY - # Libraries need to locate other libraries at runtime, and you can tell - # a library where to look by way of the dynamic runpaths (RPATH or RUNPATH) - # buried inside the .so. The $ORIGIN says to look relative to where - # the library itself is and it can be followed with relative paths from - # that. By default we always look in $ORIGIN, optionally we add relative - # paths if the Makefile sets LD_RUNPATH_EXTRAS to those relative paths. - # The environment variable LD_LIBRARY_PATH will over-ride these runpaths. - # Try: 'dump -Lv lib*.so' to see these settings in a library. - # - LDFLAGS_COMMON += -R\$$ORIGIN - LDFLAGS_COMMON += $(LD_RUNPATH_EXTRAS:%=-R\$$ORIGIN/%) -endif - -EXTRA_LIBS += -lc - -# Postprocessing is done on the images directories only -# -ifeq ($(VARIANT), OPT) - ifeq ($(PARTIAL_GPROF), true) - NO_STRIP = true - endif - ifeq ($(GPROF), true) - NO_STRIP = true - endif - ifneq ($(NO_STRIP), true) - # Debug 'strip -x' leaves local function Elf symbols (better stack traces) - POST_STRIP_PROCESS = $(STRIP) -x - endif -endif -POST_MCS_PROCESS=$(MCS) -d -a "JDK $(FULL_VERSION)" - -# -# Sun C compiler will take -M and pass it on to ld. -# Usage: ld $(LD_MAPFILE_FLAG) mapfile *.o -# -ifeq ($(CC_VERSION),gcc) -LD_MAPFILE_FLAG = -Xlinker -M -Xlinker -else -LD_MAPFILE_FLAG = -M -endif - -# -# Variables globally settable from the make command line (default -# values in brackets): -# GPROF (false) -# Eg: % gnumake GPROF=true -GPROF = false -ifeq ($(GPROF), true) - CFLAGS_COMMON += -DGPROF -xpg - EXTRA_LIBS += -xpg -endif - -# PARTIAL_GPROF is to be used ONLY during compilation - it should not -# appear during linking of libraries or programs. It also should -# prevent linking with -z defs to allow a symbol to remain undefined. -# -PARTIAL_GPROF = false -ifeq ($(PARTIAL_GPROF), true) - CFLAGS_GPROF += -xpg - LDFLAGS_DEFS_OPTION = -z nodefs -endif - -# -# For a TCOV build we add in the TCOV_OPTION -# -ifdef TCOV_BUILD - TCOV_OPTION = -xprofile=tcov - LDFLAGS_COMMON += $(TCOV_OPTION) -Kpic - CFLAGS_COMMON += $(TCOV_OPTION) - CXXFLAGS_COMMON += $(TCOV_OPTION) - EXTRA_LIBS += $(TCOV_OPTION) - LDNOMAP=true -endif - -# -# Solaris only uses native threads. -# -THREADS_FLAG= native -THREADS_DIR= threads - -# -# Support for Quantify. -# -ifdef QUANTIFY - QUANTIFY_CMD = quantify - QUANTIFY_OPTIONS = -cache-dir=/tmp/quantify -always-use-cache-dir=yes - LINK_PRE_CMD = $(QUANTIFY_CMD) $(QUANTIFY_OPTIONS) - ifdef LIBRARY - CFLAGS_COMMON += -K PIC - endif -endif - -# -# Support for Purify. -# -ifdef PURIFY - PURIFY_CMD = /net/suntools.eng/export/tools/sparc/bin/purify - PURIFY_OPTIONS = -cache-dir=/tmp/quantify -always-use-cache-dir=yes - LINK_PRE_CMD = $(PURIFY_CMD) $(PURIFY_OPTIONS) - ifdef LIBRARY - CFLAGS_COMMON += -K PIC - endif -endif - -# -# Different "levels" of optimization. -# -ifeq ($(CC_VERSION),gcc) - - CC_OPT/NONE = - CC_OPT/LOWER = -O2 - CC_OPT/HIGHER = -O3 - CC_OPT/HIGHEST = -O3 - - CXX_OPT/NONE = - CXX_OPT/LOWER = -O2 - CXX_OPT/HIGHER = -O3 - CXX_OPT/HIGHEST = -O3 - - CFLAGS_REQUIRED_i586 += -fno-omit-frame-pointer - CFLAGS_REQUIRED_amd64 += -fno-omit-frame-pointer - - # Automatic precompiled header option to use (if COMPILE_APPROACH=batch) - # (See Rules.gmk) May need to wait for gcc 5? - AUTOMATIC_PCH_OPTION = - -else - - # Highest could be -xO5, but indications are that -xO5 should be reserved - # for a per-file use, on sources with known performance impacts. - OPT_LEVEL/LOWER = 2 - OPT_LEVEL/HIGHER = 4 - OPT_LEVEL/HIGHEST = 4 - - CC_OPT/NONE = - CC_OPT/LOWER = $(OPT_LEVEL/LOWER:%=-xO%) - CC_OPT/HIGHER = $(OPT_LEVEL/HIGHER:%=-xO%) - CC_OPT/HIGHEST = $(OPT_LEVEL/HIGHEST:%=-xO%) - - CXX_OPT/NONE = - CXX_OPT/LOWER = $(OPT_LEVEL/LOWER:%=-xO%) - CXX_OPT/HIGHER = $(OPT_LEVEL/HIGHER:%=-xO%) - CXX_OPT/HIGHEST = $(OPT_LEVEL/HIGHEST:%=-xO%) - - # We need stack frames at all times - USE_XKEEPFRAME_OPTION = false - ifeq ($(USE_XKEEPFRAME_OPTION),true) - - # Unknown spelling on this option at this time (Maybe in SS13?) - CC_XKEEPFRAME_OPTIONS = -xkeepframe - CXX_XKEEPFRAME_OPTIONS = -xkeepframe - - else - - # On X86, make sure tail call optimization is off - # The z and y are the tail call optimizations. - ifeq ($(ARCH_FAMILY), i586) - CC_NEWER_THAN_58 := \ - $(shell $(EXPR) $(CC_MAJORVER) \> 5 \| \ - \( $(CC_MAJORVER) = 5 \& $(CC_MINORVER) \> 8 \) ) - ifeq ($(CC_NEWER_THAN_58),1) - # Somehow, tail call optimization is creeping in. - # Make sure it is off. - # WARNING: These may cause compiler warnings about duplicate -O options - CC_XKEEPFRAME_OPTIONS += -Wu,-O$(OPT_LEVEL/$(OPTIMIZATION_LEVEL))~yz - CXX_XKEEPFRAME_OPTIONS += -Qoption ube -O$(OPT_LEVEL/$(OPTIMIZATION_LEVEL))~yz - endif - endif - - # On i586 we need to tell the code generator to ALWAYS use a - # frame pointer. - ifeq ($(ARCH_FAMILY), i586) - # Note that in 5.7, this is done with -xregs=no%frameptr - ifeq ($(CC_VER), 5.5) - # It's not exactly clear when this optimization kicks in, the - # current assumption is -xO4 or greater and for C++ with - # the -features=no%except option and -xO4 and greater. - # Bottom line is, we ALWAYS want a frame pointer! - CC_XKEEPFRAME_OPTIONS += -Wu,-Z~B - CXX_XKEEPFRAME_OPTIONS += -Qoption ube -Z~B - endif - - CC_NEWER_THAN_56 := \ - $(shell $(EXPR) $(CC_MAJORVER) \> 5 \| \ - \( $(CC_MAJORVER) = 5 \& $(CC_MINORVER) \> 6 \) ) - ifeq ($(CC_NEWER_THAN_56),1) - # Do NOT use frame pointer register as a general purpose opt register - CC_OPT/NONE += -xregs=no%frameptr - CXX_OPT/NONE += -xregs=no%frameptr - CC_XKEEPFRAME_OPTIONS += -xregs=no%frameptr - CXX_XKEEPFRAME_OPTIONS += -xregs=no%frameptr - endif - endif - - # Optimizer for sparc needs to be told not to do certain things - # related to frames or save instructions. - ifeq ($(ARCH_FAMILY), sparc) - # Do not use save instructions instead of add instructions - # This was an optimization starting in SC5.0 that made it hard for us to - # find the "save" instruction (which got turned into an "add") - CC_XKEEPFRAME_OPTIONS += -Wc,-Qrm-s - CXX_XKEEPFRAME_OPTIONS += -Qoption cg -Qrm-s - # Don't allow tail call code optimization. Started in SC5.0. - # We don't like code of this form: - # save - # - # call foo - # restore - # because we can't tell if the method will have a stack frame - # and register windows or not. - CC_XKEEPFRAME_OPTIONS += -Wc,-Qiselect-T0 - CXX_XKEEPFRAME_OPTIONS += -Qoption cg -Qiselect-T0 - endif - - endif - - # Extra options used with HIGHEST - # - # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be - # done with care, there are some assumptions below that need to - # be understood about the use of pointers, and IEEE behavior. - # - # Use non-standard floating point mode (not IEEE 754) - CC_HIGHEST_EXTRAS += -fns - # Do some simplification of floating point arithmetic (not IEEE 754) - CC_HIGHEST_EXTRAS += -fsimple - # Use single precision floating point with 'float' - CC_HIGHEST_EXTRAS += -fsingle - # Assume memory references via basic pointer types do not alias - # (Source with excessing pointer casting and data access with mixed - # pointer types are not recommended) - CC_HIGHEST_EXTRAS += -xalias_level=basic - # Use intrinsic or inline versions for math/std functions - # (If you expect perfect errno behavior, do not use this) - CC_HIGHEST_EXTRAS += -xbuiltin=%all - # Loop data dependency optimizations (need -xO3 or higher) - CC_HIGHEST_EXTRAS += -xdepend - # Pointer parameters to functions do not overlap - # (Similar to -xalias_level=basic usage, but less obvious sometimes. - # If you pass in multiple pointers to the same data, do not use this) - CC_HIGHEST_EXTRAS += -xrestrict - # Inline some library routines - # (If you expect perfect errno behavior, do not use this) - CC_HIGHEST_EXTRAS += -xlibmil - # Use optimized math routines - # (If you expect perfect errno behavior, do not use this) - # Can cause undefined external on Solaris 8 X86 on __sincos, removing for now - # CC_HIGHEST_EXTRAS += -xlibmopt - ifeq ($(ARCH_FAMILY), sparc) - # Assume at most 8byte alignment, raise SIGBUS on error - ### Presents an ABI issue with customer JNI libs? - ####CC_HIGHEST_EXTRAS += -xmemalign=8s - # Automatic prefetch instructions, explicit prefetch macros - CC_HIGHEST_EXTRAS += -xprefetch=auto,explicit - # Pick ultra as the chip to optimize to - CC_HIGHEST_EXTRAS += -xchip=ultra - endif - ifeq ($(ARCH), i586) - # Pick pentium as the chip to optimize to - CC_HIGHEST_EXTRAS += -xchip=pentium - endif - ifdef LIBRARY - # The Solaris CBE (Common Build Environment) requires that the use - # of appl registers be disabled when compiling a public library (or - # a library that's loaded by a public library) on sparc. - CFLAGS_REQUIRED_sparc += -xregs=no%appl - CFLAGS_REQUIRED_sparcv9 += -xregs=no%appl - endif - CC_NEWER_THAN_56 := \ - $(shell $(EXPR) $(CC_MAJORVER) \> 5 \| \ - \( $(CC_MAJORVER) = 5 \& $(CC_MINORVER) \> 6 \) ) - ifeq ($(CC_NEWER_THAN_56),1) - # Presents an ABI issue with customer JNI libs? We must be able to - # to handle 4byte aligned objects? (rare occurance, but possible?) - CFLAGS_REQUIRED_sparc += -xmemalign=4s - endif - # Just incase someone trys to use the SOS9 compilers - ifeq ($(CC_VER), 5.6) - # We MUST allow data alignment of 4 for sparc (sparcv9 is ok at 8s) - CFLAGS_REQUIRED_sparc += -xmemalign=4s - endif - # Automatic precompiled header option to use (if COMPILE_APPROACH=batch) - # (See Rules.gmk) The SS11 -xpch=auto* options appear to be broken. - AUTOMATIC_PCH_OPTION = - - # Add in keep frame options - CC_OPT/LOWER += $(CC_XKEEPFRAME_OPTIONS) - CC_OPT/HIGHER += $(CC_XKEEPFRAME_OPTIONS) - CC_OPT/HIGHEST += $(CC_XKEEPFRAME_OPTIONS) - CXX_OPT/LOWER += $(CXX_XKEEPFRAME_OPTIONS) - CXX_OPT/HIGHER += $(CXX_XKEEPFRAME_OPTIONS) - CXX_OPT/HIGHEST += $(CXX_XKEEPFRAME_OPTIONS) - - # Add in highest optimization settings - CC_OPT/HIGHEST += $(CC_HIGHEST_EXTRAS) - CXX_OPT/HIGHEST += $(CC_HIGHEST_EXTRAS) - -endif - -# Default optimization settings based on level. -CC_OPT = $(CC_OPT/$(OPTIMIZATION_LEVEL)) -CXX_OPT = $(CXX_OPT/$(OPTIMIZATION_LEVEL)) - -# Flags required all the time -CFLAGS_REQUIRED = $(CFLAGS_REQUIRED_$(ARCH)) - -# -# Path and option to link against the VM, if you have to. Note that -# there are libraries that link against only -ljava, but they do get -# -L to the -ljvm, this is because -ljava depends on -ljvm, whereas -# the library itself should not. -# -VM_NAME = server -JVMLIB = -L$(LIBDIR)/$(LIBARCH)/server -L$(LIBDIR)/$(LIBARCH)/client -ljvm -JAVALIB = -ljava $(JVMLIB) - -# Part of INCREMENTAL_BUILD mechanism. -# Compiler emits things like: path/file.o: file.h -# We want something like: relative_path/file.o relative_path/file.d: file.h -# In addition on Solaris, any include file starting with / is deleted, -# this gets rid of things like /usr/include files, which never change. -CC_DEPEND = -xM1 -CC_DEPEND_FILTER = $(SED) -e '/:[ ]*[/]/d' -e 's!$*\.$(OBJECT_SUFFIX)!$(dir $@)& $(dir $@)$*.$(DEPEND_SUFFIX)!g' | $(SORT) -u - -# Location of openwin libraries (do we really need this anymore?) -OPENWIN_HOME = /usr/openwin -OPENWIN_LIB = $(OPENWIN_HOME)/lib$(ISA_DIR) - -# Runtime graphics library search paths... -OPENWIN_RUNTIME_LIB = /usr/openwin/lib$(ISA_DIR) -AWT_RUNPATH = -R/usr/dt/lib$(ISA_DIR) -R$(OPENWIN_RUNTIME_LIB) - -# C++ Runtime library (libCrun.so), use instead of -lCrun. -# Originally used instead of -lCrun to guarantee use of the system -# .so version and not the .a or .so that came with the compilers. -# With the newer compilers this could probably change back to -lCrun but -# in general this is ok to continue to do. -LIBCXX = /usr/lib$(ISA_DIR)/libCrun.so.1 - -# JDK now requires Solaris 10, so pick up libm.so.2 -LIBM = /usr/lib$(ISA_DIR)/libm.so.2 - -# Socket library -LIBSOCKET = -lsocket - -# Network Services library -LIBNSL = -lnsl - -# service configuration facility library -LIBSCF = -lscf - -# Dynamic Loading library -LIBDL = -ldl - -# GLOBAL_KPIC: If set means all libraries are PIC, position independent code -# EXCEPT for select compiles -# If a .o file is compiled non-PIC then it should be forced -# into the RW data segment with a mapfile option. This is done -# with object files which generated from .s files. -# The -ztext enforces that no relocations remain in the text segment -# so that it remains purely read-only for optimum system performance. -# Some libraries may use a smaller size (13bit -Kpic) on sparc instead of -# (32 bit -KPIC) and will override GLOBAL_KPIC appropriately. -# -PIC_CODE_LARGE = -KPIC -PIC_CODE_SMALL = -Kpic -ifndef TCOV_BUILD - GLOBAL_KPIC = $(PIC_CODE_LARGE) - CXXFLAGS_COMMON += $(GLOBAL_KPIC) - CFLAGS_COMMON += $(GLOBAL_KPIC) - LDFLAGS_COMMON += -ztext -endif # TCOV_BUILD - -# If your platform has DPS, it will have Type1 fonts too, in which case -# it is best to enable DPS support until such time as 2D's rasteriser -# can fully handle Type1 fonts in all cases. Default is "yes". -# HAVE_DPS should only be "no" if the platform has no DPS headers or libs -# DPS (Displayable PostScript) is available on Solaris machines - -HAVE_DPS = yes - -# -# Japanese manpages -# -JA_SOURCE_ENCODING = eucJP -JA_TARGET_ENCODINGS = eucJP UTF-8 PCK - -# Settings for the JDI - Serviceability Agent binding. -HOTSPOT_SALIB_PATH = $(HOTSPOT_IMPORT_PATH)/jre/lib/$(LIBARCH) -SALIB_NAME = $(LIB_PREFIX)saproc.$(LIBRARY_SUFFIX) -SA_DEBUGINFO_NAME = $(LIB_PREFIX)saproc.debuginfo -INCLUDE_SA=true - diff --git a/jdk/makefiles/common/Defs-windows.gmk b/jdk/makefiles/common/Defs-windows.gmk deleted file mode 100644 index 54c9879adf5..00000000000 --- a/jdk/makefiles/common/Defs-windows.gmk +++ /dev/null @@ -1,418 +0,0 @@ -# -# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile to specify compiler flags for programs and libraries -# targeted to Windows builds. Should not contain any rules. -# -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. -# - -# Get shared JDK settings -include $(JDK_MAKE_SHARED_DIR)/Defs.gmk - -# CC compiler object code output directive flag value -CC_OBJECT_OUTPUT_FLAG = -Fo - -# The suffix applied to the library name for FDLIBM -FDDLIBM_SUFFIX = lib -# The suffix applied to scripts (.bat for windows, nothing for unix) -SCRIPT_SUFFIX = .bat - -# LIB_LOCATION, which for windows identifies where .exe files go, may be -# set by each GNUmakefile. The default is BINDIR. -ifndef LIB_LOCATION - LIB_LOCATION = $(BINDIR) -endif # LIB_LOCATION - -ifndef PLATFORM_SRC - PLATFORM_SRC = $(BUILDDIR)/../src/windows -endif # PLATFORM_SRC - -# Platform specific closed sources -ifndef OPENJDK - ifndef CLOSED_PLATFORM_SRC - CLOSED_PLATFORM_SRC = $(BUILDDIR)/../src/closed/windows - endif -endif - -# for backwards compatability, the old "win32" is used here instead of -# the more proper "windows" -PLATFORM_INCLUDE_NAME = win32 -PLATFORM_INCLUDE = $(INCLUDEDIR)/$(PLATFORM_INCLUDE_NAME) - -# The following DLL's are considered MS runtime libraries and should -# not to be REBASEd, see deploy/make/common/Release.gmk. -# msvcr*.dll: Microsoft runtimes -ifeq ($(COMPILER_VERSION), VS2010) - MSVCRNN_DLL = msvcr100.dll - MSVCPNN_DLL = msvcp100.dll -endif - -EXTRA_LFLAGS += /LIBPATH:$(DXSDK_LIB_PATH) - -# C Compiler flag definitions - -# -# Default optimization -# - -ifndef OPTIMIZATION_LEVEL - ifeq ($(PRODUCT), java) - OPTIMIZATION_LEVEL = HIGHER - else - OPTIMIZATION_LEVEL = LOWER - endif -endif -ifndef FASTDEBUG_OPTIMIZATION_LEVEL - FASTDEBUG_OPTIMIZATION_LEVEL = LOWER -endif - -ifeq ($(CC_VERSION),msvc) - # Visual Studio compiler option definitions: - # -O1 Favors reduced size over speed (-Og -Os -Oy -Ob2 -Gs -GF -Gy) - # -O2 Favors speed over reduced size (-Og -Oi -Ot -Oy -Ob2 -Gs -GF -Gy) - # -Ob2 More aggressive inlining - # -Og Global optimizations - # -Oi Replace some functions with intrinsic or special forms - # -fp:precise (should be the default) - # Improve floating point calculations (disables some optimizations) - # -Os Favor small code - # -Ot Favor faster code - # -Oy Frame pointer omission - # -G6 Used to be -GB? - # -GF Pool strings in read-only memory - # -Gf Pool strings in read-write memory (the default) - # -Gs Controls stack probess - # -GS Adds buffer overflow checks on stacks (the default) - # -EHsc Enables exception handling - # -Gy Function level linking only - # - - CC_OPT/NONE = -Od - CC_OPT/LOWER = -O2 - CC_OPT/HIGHER = -O3 - CC_OPT/HIGHEST = -O3 - - ifeq ($(COMPILER_VERSION), VS2010) - # Automatic precompiled header option to use (if COMPILE_APPROACH=batch) - AUTOMATIC_PCH_OPTION = - GX_OPTION = -EHsc - GZ_OPTION = -RTC1 - ifeq ($(ARCH_DATA_MODEL), 32) - CC_OPT/HIGHEST = -O2 - CC_OPT/HIGHER = -O1 - CC_OPT/LOWER = -O1 - else - CC_OPT/HIGHEST = -O2 - CC_OPT/HIGHER = -O1 - CC_OPT/LOWER = -O1 - endif - endif - -else # CC_VERSION - # GCC not supported, but left for historical reference... - CC_OPT/NONE = - CC_OPT/LOWER = -O2 - CC_OPT/HIGHER = -O2 - CC_OPT/HIGHEST = -O3 - -endif - -CC_OPT = $(CC_OPT/$(OPTIMIZATION_LEVEL)) - -# Select the runtime support library carefully, need to be consistent -# -# Visual Studio Runtime compiler option definitions: -# -MD Use dynamic multi-threaded runtime library -# -MDd Use debug version (don't use, doesn't mix with -MD DLL's) -# -MT Use static multi-threaded runtime library (-ML is going away) -# -MTd Use static debug version (better than -MDd, no runtime issues) -# -D_DEBUG Change use of malloc/free/etc to use special debug ones (-MTd) -# -# NOTE: We also will use /D _STATIC_CPPLIB so we don't need msvcpnn.dll -# -# If MS_RUNTIME_STATIC is requested we may have a problem, it is no longer -# supported by VS2010 -ifneq ($(MS_RUNTIME_STATIC),true) - MS_RUNTIME_OPTION=-MD -endif -# The _DEBUG macro option (changes things like malloc to use debug version) -MS_RUNTIME_DEBUG_OPTION= -MS_RC_DEBUG_OPTION= -# Externally set environment variable can force any build to use the debug vers -ifeq ($(MFC_DEBUG), true) - ifeq ($(MS_RUNTIME_STATIC),true) - MS_RUNTIME_OPTION=-MTd - else - # This MS debugging flag forces a dependence on the debug - # version of the runtime library (MSVCR*D.DLL), as does -MDd. - # We cannot re-distribute this debug runtime. - MS_RUNTIME_OPTION=-MDd - endif - MS_RUNTIME_DEBUG_OPTION= -D_DEBUG - MS_RC_DEBUG_OPTION= -d _DEBUG -endif - -# Always add _STATIC_CPPLIB definition -STATIC_CPPLIB_OPTION = /D _STATIC_CPPLIB - -# Silence the warning about using _STATIC_CPPLIB -ifneq ($(SHOW_ALL_WARNINGS),true) - # Needed with VS2010 to turn off the deprecated warning. - STATIC_CPPLIB_OPTION += /D _DISABLE_DEPRECATE_STATIC_CPPLIB -endif - -MS_RUNTIME_OPTION += $(STATIC_CPPLIB_OPTION) - -ifeq ($(CC_VERSION),msvc) - # Visual Studio compiler option definitions: - # -Zi Cause *.pdb file to be created, full debug information - # -Z7 Full debug inside the .obj, no .pdb - # -Zd Basic debug, no local variables? In the .obj - # -Zl Don't add runtime library name to obj file? - # -Od Turns off optimization and speeds compilation - # -YX -Fp/.../foobar.pch Use precompiled headers (try someday?) - # -nologo Don't print out startup message - # /D _STATIC_CPPLIB - # Use static link for the C++ runtime (so msvcpnn.dll not needed) - # - CFLAGS_COMMON += -Zi -nologo - CFLAGS_OPT = $(CC_OPT) - CFLAGS_DBG = -Od $(MS_RUNTIME_DEBUG_OPTION) - - CFLAGS_VS2010 += -Zc:wchar_t- - - # All builds get the same runtime setting - CFLAGS_COMMON += $(MS_RUNTIME_OPTION) $(CFLAGS_$(COMPILER_VERSION)) - - LDEBUG = /debug - - ifeq ($(VTUNE_SUPPORT), true) - OTHER_CFLAGS = -Z7 -Ox - LDEBUG += /pdb:NONE - endif - - # VS2010, always need safe exception handlers, not needed on 64bit - ifeq ($(ARCH_DATA_MODEL), 32) - LFLAGS_VS2010 += -SAFESEH - endif - - # LFLAGS are the flags given to $(LINK) and used to build the actual DLL file - BASELFLAGS = -nologo /opt:REF /incremental:no - - LFLAGS = $(BASELFLAGS) $(LDEBUG) $(EXTRA_LFLAGS) $(LFLAGS_$(COMPILER_VERSION)) - LDDFLAGS += $(LFLAGS_$(COMPILER_VERSION)) - -endif - -# -# Preprocessor macro definitions -# -CPPFLAGS_COMMON = -DWIN32 -DIAL -D_LITTLE_ENDIAN -ifeq ($(ARCH), amd64) - CPPFLAGS_COMMON += -D_AMD64_ -Damd64 -else - CPPFLAGS_COMMON += -D_X86_ -Dx86 -endif -CPPFLAGS_COMMON += -DWIN32_LEAN_AND_MEAN - -# -# Output options (use specific filenames to avoid parallel compile errors) -# -CFLAGS_COMMON += -Fd$(OBJDIR)/$(basename $(@F)).pdb -Fm$(OBJDIR)/$(basename $(@F)).map - -# -# Use -wdNNNN to disable warning NNNN. -# C4800 is a warning about bool performance casts (can't make go away) -# -COMPILER_WARNINGS_TO_IGNORE = 4800 -CFLAGS_COMMON += $(COMPILER_WARNINGS_TO_IGNORE:%=-wd%) - -# -# Treat compiler warnings as errors, if requested -# -CFLAGS_COMMON += -W$(COMPILER_WARNING_LEVEL) -ifeq ($(COMPILER_WARNINGS_FATAL),true) - CFLAGS_COMMON += -WX -endif - -# Turn off some warnings by default, enable them all if asked. -ifneq ($(SHOW_ALL_WARNINGS),true) - # The -D _CRT_SECURE_NO_DEPRECATE turns off security/deprecated warnings on - # the standard C library functions like strcpy. - CFLAGS_COMMON += -D _CRT_SECURE_NO_DEPRECATE - # The -D _CRT_NONSTDC_NO_DEPRECATE turns off deprecation warnings about using - # non-standard C POSIX functions. - CFLAGS_COMMON += -D _CRT_NONSTDC_NO_DEPRECATE -endif - -CPPFLAGS_OPT = -DNDEBUG -CPPFLAGS_DBG = -DDEBUG -DLOGGING - -CXXFLAGS_COMMON = $(CFLAGS_COMMON) -CXXFLAGS_OPT = $(CFLAGS_OPT) -CXXFLAGS_DBG = $(CFLAGS_DBG) - -ifneq ($(LIBRARY),fdlibm) - EXTRA_LIBS += advapi32.lib -endif - -# -# Path and option to link against the VM, if you have to. -# -JVMLIB = $(LIBDIR)/jvm.lib -JAVALIB = $(LIBDIR)/java.lib - -ifeq ($(CC_VERSION), msvc) - CC_DEPEND = -FD - CC_DEPEND_FILTER = -else # CC_VERSION -# not supported, but left for historical reference... - CC_DEPEND = -MM - CC_DEPEND_FILTER = $(SED) -e 's!$*\.$(OBJECT_SUFFIX)!$(dir $@)&!g' -endif # CC_VERSION - -LIBRARY_SUFFIX = dll -LIB_SUFFIX = lib - -# Settings for the JDI - Serviceability Agent binding. -HOTSPOT_SALIB_PATH = $(HOTSPOT_IMPORT_PATH)/jre/bin -SALIB_NAME = $(LIB_PREFIX)sawindbg.$(LIBRARY_SUFFIX) -SAMAP_NAME = $(LIB_PREFIX)sawindbg.map -SAPDB_NAME = $(LIB_PREFIX)sawindbg.pdb - -ifeq ($(ARCH), ia64) - # SA will never be supported here. - INCLUDE_SA = false -else - INCLUDE_SA = true -endif - -# Settings for the VERSIONINFO tap on windows. -VERSIONINFO_RESOURCE = $(BUILDDIR)/../src/windows/resource/version.rc - -ifneq ($(JDK_BUILD_NUMBER),) - COOKED_BUILD_NUMBER = $(shell $(ECHO) $(JDK_BUILD_NUMBER) | $(SED) -e 's/^b//' -e 's/^0//') -else - COOKED_BUILD_NUMBER = 0 -endif - -# If the update version contains non-numeric characters, we need -# to massage it into a numeric format. -# We use the following formula: -# JDK_UPDATE_VER = JDK_UPDATE_VERSION * 10 + EXCEPTION_VERSION -# -# Here are some examples: -# 1.5.0 b01 -> 5,0,0,1 -# 1.5.0_10 b01 -> 5,0,100,1 -# 1.4.2 b01 -> 4,2,0,1 -# 1.4.2_02 b01 -> 4,2,20,1 -# 1.4.2_02a b01 -> 4,2,21,1 -# 1.4.2_02b b01 -> 4,2,22,1 -ifdef JDK_UPDATE_VERSION - VTMP := $(shell $(ECHO) $(JDK_UPDATE_VERSION) | $(TR) "abcde" "12345") - CAB_CHAR1 := $(shell $(ECHO) $(VTMP) | $(NAWK) '{print substr($$1, 1, 1);}') - CAB_CHAR2 := $(shell $(ECHO) $(VTMP) | $(NAWK) '{print substr($$1, 2, 1);}') - CAB_CHAR3 := $(shell $(ECHO) $(VTMP) | $(NAWK) '{print substr($$1, 3, 1);}') - JDK_UPDATE_META_TAG := U$(MARKETING_NUMBER) - ifeq ($(CAB_CHAR3),) - CAB_CHAR3 := 0 - endif - ifeq ($(CAB_CHAR1), 0) - JDK_UPDATE_VER := $(CAB_CHAR2)$(CAB_CHAR3) - else - JDK_UPDATE_VER := $(CAB_CHAR1)$(CAB_CHAR2)$(CAB_CHAR3) - endif -else - JDK_UPDATE_VER := 0 -endif - -#RC_FLAGS = /l 0x409 /r - -#ifeq ($(VARIANT), OPT) -# RC_FLAGS += -d NDEBUG -#else -# RC_FLAGS += $(MS_RC_DEBUG_OPTION) -#endif - -# Values for the RC variables defined in RC_FLAGS -#JDK_RC_BUILD_ID = $(FULL_VERSION) -#JDK_RC_COMPANY = $(COMPANY_NAME) -#JDK_RC_COMPONENT = $(PRODUCT_NAME) $(JDK_RC_PLATFORM_NAME) binary -#JDK_RC_VER = \ -# $(JDK_MINOR_VERSION).$(JDK_MICRO_VERSION).$(JDK_UPDATE_VER).$(COOKED_BUILD_NUMBER) -#JDK_RC_COPYRIGHT = Copyright \xA9 $(COPYRIGHT_YEAR) -#JDK_RC_NAME = \ -# $(PRODUCT_NAME) $(JDK_RC_PLATFORM_NAME) $(JDK_MINOR_VERSION) $(JDK_UPDATE_META_TAG) -#JDK_RC_FVER = \ -# $(JDK_MINOR_VERSION),$(JDK_MICRO_VERSION),$(JDK_UPDATE_VER),$(COOKED_BUILD_NUMBER) - -# JDK name required here -#RC_FLAGS += -d "JDK_BUILD_ID=$(JDK_RC_BUILD_ID)" \ -# -d "JDK_COMPANY=$(JDK_RC_COMPANY)" \ -# -d "JDK_COMPONENT=$(JDK_RC_COMPONENT)" \ -# -d "JDK_VER=$(JDK_RC_VER)" \ -# -d "JDK_COPYRIGHT=$(JDK_RC_COPYRIGHT)" \ -# -d "JDK_NAME=$(JDK_RC_NAME)" \ -# -d "JDK_FVER=$(JDK_RC_FVER)" - -# Enable 7-Zip LZMA file (de)compression for Java Kernel if it is available -ifeq ($(ARCH_DATA_MODEL), 32) - ifneq ($(KERNEL), off) - # This is a hack to use until 7-Zip (and UPX) bundles can be put - # under /java/devtools. - ifndef DEPLOY_TOPDIR - DEPLOY_TOPDIR=$(JDK_TOPDIR)/../deploy - endif - # Uncomment this block to cause build failure if above assumption false - #DCHK = $(shell if [ ! -d $(DEPLOY_TOPDIR) ] ; then \ - # $(ECHO) deploy_not_a_peer_of_j2se ; \ - #fi ) - #ifeq ($(DCHK), deploy_not_a_peer_of_j2se) - # If a build failure points to control coming here it means - # it means deploy is not in the same directory - # as j2se. Java Kernel can't tolerate that for the time being. - #endif - EC_TMP = $(shell if [ -d $(DEPLOY_TOPDIR)/make/lzma ] ; then \ - $(ECHO) true ; \ - else \ - $(ECHO) false ; \ - fi ) - ifeq ($(EC_TMP), true) - EXTRA_COMP_INSTALL_PATH = lib\\\\deploy\\\\lzma.dll - # Crazy but true: deploy/make/plugin/jinstall/Makefile.jkernel does - # not include deploy/make/common/Defs-windows.gmk, either directly - # or indirectly. But it does include this file, so redundantly declare - # these variables that are in deploy/make/common/Defs-windows.gmk for - # the sake of the Java Kernel part of the deploy build. Whew! - EXTRA_COMP_LIB_NAME = lzma.dll - EXTRA_COMP_PATH = $(OUTPUTDIR)/tmp/deploy/lzma/win32/obj - EXTRA_COMP_CMD_PATH = $(EXTRA_COMP_PATH)/lzma.exe - EXTRA_COMP_LIB_PATH = $(EXTRA_COMP_PATH)/$(EXTRA_COMP_LIB_NAME) - endif - endif -endif diff --git a/jdk/makefiles/common/Defs.gmk b/jdk/makefiles/common/Defs.gmk deleted file mode 100644 index be43455b5fd..00000000000 --- a/jdk/makefiles/common/Defs.gmk +++ /dev/null @@ -1,577 +0,0 @@ -# -# Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Common variables used by all the Java makefiles. This file should -# not contain rules. -# - -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. -# - -# Check for strange explicit settings (change to empty or true) -ifdef OPENJDK - ifneq ($(OPENJDK),true) - x:=$(error "OPENJDK (if defined) can only be set to true") - endif -endif - -# -# On Solaris, the 'make' utility from Sun will not work with these makefiles. -# This little rule is only understood by Sun's make, and is harmless -# when seen by the GNU make tool. If using Sun's make, this causes the -# make command to fail. -# -SUN_MAKE_TEST:sh = echo "ERROR: PLEASE USE GNU VERSION OF MAKE"; exit 33 - -include $(SPEC) -include $(JDK_MAKE_SHARED_DIR)/Platform.gmk - -# Historically PLATFORM_SRC used to be src/$(PLATFORM), but we switched it to -# src/solaris so if you want to build on Linux you didn't need a src/linux -# directory. In an ideal world it would be called src/genunix but we are not -# there yet. -# -ifndef SHARE_SRC - SHARE_SRC = $(BUILDDIR)/../src/share -endif - -# Files that cannot be included in the OpenJDK distribution are -# collected under a parent directory which contains just those files. -ifndef CLOSED_SRC - CLOSED_SRC = $(BUILDDIR)/../src/closed -endif - -# If CLOSE_SRC_INCLUDED isn't set to true, check if there's any -# closed directory. -ifneq ($(CLOSED_SRC_INCLUDED), true) - CLOSED_SRC_INCLUDED := $(shell \ - if [ -d $(CLOSED_SRC) ] ; then \ - echo true; \ - else \ - echo false; \ - fi) -endif - -# Set OPENJDK based on CLOSED_SRC_INCLUDED -ifeq ($(CLOSED_SRC_INCLUDED), false) - OPENJDK = true -endif - -# Define where closed directories are -ifdef OPENJDK - CLOSED_SRC = - CLOSED_SHARE_SRC = -else - ifndef CLOSED_SHARE_SRC - CLOSED_SHARE_SRC = $(CLOSED_SRC)/share - endif -endif - -# -# Get platform definitions -# - -include $(JDK_TOPDIR)/makefiles/common/Defs-$(PLATFORM).gmk - -# -# SE-Embedded support, if enabled -# - -include $(JDK_TOPDIR)/makefiles/common/Defs-embedded.gmk - -# -# Cross-compilation Settings -# -ifdef CROSS_COMPILE_ARCH - # Can't run the tools we just built - USE_ONLY_BOOTDIR_TOOLS = true - - # When cross-compiling CC generates code for the target, but - # some parts of the build generate C code that has to be compiled - # and executed on the build host - HOST_CC is the 'local' compiler. - # For linux the default is /usr/bin/gcc; other platforms need to - # set it explicitly - ifeq ($(PLATFORM), linux) - ifndef HOST_CC - HOST_CC = $(USRBIN_PATH)gcc - endif - endif -else - # Must set HOST_CC if not already set - ifndef HOST_CC - HOST_CC = $(CC) - endif -endif - -# Reset the VM name for client-only builds -ifeq ($(JVM_VARIANT),client) - VM_NAME = client -endif - -# -# Freetype logic is applicable to OpenJDK only -# -ifdef OPENJDK - -ifeq ($(PLATFORM), windows) - DEVTOOLS_FT_DIR=$(JDK_DEVTOOLS_DIR)/win32/freetype-$(ARCH) -endif -ifeq ($(PLATFORM), linux) - DEVTOOLS_FT_DIR=$(JDK_DEVTOOLS_DIR)/$(PLATFORM)/freetype-$(ARCH) -endif -ifeq ($(PLATFORM), solaris) - # historically for Solaris we have slightly different devtools - # naming conventions - DEVTOOLS_FT_DIR=$(JDK_DEVTOOLS_DIR)/$(ARCH_FAMILY)/freetype-$(ARCH) -endif - -DEVTOOLS_FT_DIR_EXISTS = $(shell \ - if [ -f $(DEVTOOLS_FT_DIR)/include/ft2build.h ] ; then \ - echo true; \ - else \ - echo false; \ - fi) - - ifdef ALT_FREETYPE_LIB_PATH - FREETYPE_LIB_PATH = $(ALT_FREETYPE_LIB_PATH) - ifeq ($(PLATFORM), macosx) - USING_SYSTEM_FT_LIB=true - endif - else - ifeq ($(DEVTOOLS_FT_DIR_EXISTS), true) - FREETYPE_LIB_PATH = $(DEVTOOLS_FT_DIR)/lib - else - ifeq ($(PLATFORM), macosx) - FREETYPE_LIB_PATH = /usr/X11R6/lib - else - FREETYPE_LIB_PATH = /usr/lib - endif - USING_SYSTEM_FT_LIB=true - endif - endif - - ifdef ALT_FREETYPE_HEADERS_PATH - FREETYPE_HEADERS_PATH = $(ALT_FREETYPE_HEADERS_PATH) - else - ifeq ($(DEVTOOLS_FT_DIR_EXISTS), true) - FREETYPE_HEADERS_PATH = $(DEVTOOLS_FT_DIR)/include - else - ifeq ($(PLATFORM), macosx) - FREETYPE_HEADERS_PATH = /usr/X11R6/include - else - FREETYPE_HEADERS_PATH = /usr/include - endif - endif - endif -endif - -# -# zlib version -# -ZLIB_VERSION = 1.2.5 - - -# -# Localizations for the different parts of the product beyond English -# - -JRE_LOCALES = de es fr it ja ko pt_BR sv zh_CN zh_TW zh_HK -PLUGIN_LOCALES = de es fr it ja ko pt_BR sv zh_CN zh_TW zh_HK -JDK_LOCALES = ja zh_CN - -# -# A list of locales we support but don't have resource files. -# This is defined to optimize the search of resource bundles. -# -JRE_NONEXIST_LOCALES = en en_US de_DE es_ES fr_FR it_IT ja_JP ko_KR sv_SE zh - -# -# For now, most libraries except libjava and libjvm itself link against libjvm -# and libjava, the latter for its exported common utilities. libjava only -# links against libjvm. Programs' makefiles take their own responsibility for -# adding other libs. -# -# The makefiles for these packages do not link against libjvm and libjava. -# This list will eventually go away and each Programs' makefiles -# will have to explicitly declare that they want to link to libjava/libjvm -# -NO_JAVALIB_PKGS = \ - sun.security.mscapi \ - sun.security.krb5 \ - sun.security.pkcs11 \ - sun.security.jgss \ - sun.security.jgss.wrapper \ - sun.security.ec \ - sun.security.smartcardio \ - com.sun.security.auth.module - -ifdef PACKAGE -# put JAVALIB first, but do not lose any platform specific values.... - ifeq (,$(findstring $(PACKAGE),$(NO_JAVALIB_PKGS))) - LDLIBS_COMMON = $(JAVALIB) - endif -endif # PACKAGE - -# -# Libraries that must appear ahead of libc.so on the link command line -# -ifdef PROGRAM - - ifeq ($(PLATFORM), solaris) - LDLIBS_COMMON = -lthread -ldl - endif - - ifeq ($(PLATFORM), linux) - LDLIBS_COMMON = -ldl - endif - - ifeq ($(PLATFORM), macosx) - LDLIBS_COMMON = -pthread - endif - -endif # PROGRAM - -LDLIBS_COMMON += $(EXTRA_LIBS) - -# for generated binaries -BINDIR = $(OUTPUTDIR)/bin$(ISA_DIR) -# for generated libraries -LIBDIR = $(OUTPUTDIR)/lib -ABS_LIBDIR = $(ABS_OUTPUTDIR)/lib -# Optional place to save the windows .lib files -LIBFILES_DIR = $(OUTPUTDIR)/libfiles -# for ext jre files -EXTDIR = $(LIBDIR)/ext -# for generated include files -INCLUDEDIR = $(OUTPUTDIR)/include -# for generated class files -CLASSBINDIR = $(OUTPUTDIR)/classes -DEMOCLASSDIR = $(OUTPUTDIR)/democlasses -# for generated tool class files -BUILDTOOLCLASSDIR = $(OUTPUTDIR)/btclasses -# for build tool jar files -BUILDTOOLJARDIR = $(OUTPUTDIR)/btjars -ABS_BUILDTOOLJARDIR = $(ABS_OUTPUTDIR)/btjars -# for generated tool class files -BUILDTOOLBINDIR = $(OUTPUTDIR)/btbins -# for generated java source files -GENSRCDIR = $(OUTPUTDIR)/gensrc -# for generated C source files (not javah) -GENNATIVESRCDIR = $(OUTPUTDIR)/gennativesrc -# for imported source files -IMPORTSRCDIR = $(OUTPUTDIR)/impsrc -# for imported documents -IMPORTDOCDIR = $(OUTPUTDIR)/impdoc -# for generated demo -DEMODIR = $(OUTPUTDIR)/demo -NEWDEMODIR = $(OUTPUTDIR)/newdemo -# for sample code -SAMPLEDIR = $(OUTPUTDIR)/sample -# for generated documentation -DOCSDIR = $(OUTPUTDIR)/docs$(DOCSDIRSUFFIX) -DOCSDIRSUFFIX = - -# The MESSAGE, WARNING and ERROR files are used to store sanityck and -# warnings and errors. -ifndef ERROR_FILE - ERROR_FILE = $(OUTPUTDIR)/sanityCheckErrors.txt -endif -ifndef WARNING_FILE - WARNING_FILE = $(OUTPUTDIR)/sanityCheckWarnings.txt -endif -ifndef MESSAGE_FILE - MESSAGE_FILE = $(OUTPUTDIR)/sanityCheckMessages.txt -endif - -#where the demo source can be found -DEMOSRCDIR = $(SHARE_SRC)/demo - -#where the sample source can be found -SAMPLESRCDIR = $(SHARE_SRC)/sample - -# An attempt is made to generate unique enough directories for the -# generated files to not have name collisisons. Most build units -# defines PRODUCT (except Release.gmk), but then they may or may -# not define PACKAGE, PROGRAM, and LIBRARY. This code attempts to -# generate a unique OBJDIR/CLASSHDRDIR for each build unit based -# on which of those values are set within each build unit. - -UNIQUE_LOCATION_STRING = tmp - -ifneq ($(PRODUCT),) - UNIQUE_LOCATION_STRING += /$(PRODUCT) -endif - -ifneq ($(PACKAGE),) - UNIQUE_LOCATION_STRING += /$(PACKAGE) -endif - -ifneq ($(PROGRAM),) - UNIQUE_LOCATION_STRING += /$(PROGRAM) -endif - -ifneq ($(LIBRARY),) - ifneq ($(LIBRARY_OUTPUT),) - UNIQUE_LOCATION_STRING += /$(LIBRARY_OUTPUT) - else - UNIQUE_LOCATION_STRING += /$(LIBRARY) - endif -endif - -# the use of += above makes a space separated list which we need to -# remove for filespecs. -# -NULLSTRING := -ONESPACE := $(NULLSTRING) # space before this comment is required. -UNIQUE_PATH = $(subst $(ONESPACE),,$(UNIQUE_LOCATION_STRING)) - -# TEMPDIR is a unique general purpose directory -# need to use 'override' because GNU Make on Linux exports the wrong -# value. -TEMPDIR ?= $(OUTPUTDIR)/$(UNIQUE_PATH) -ABS_TEMPDIR ?= $(ABS_OUTPUTDIR)/$(UNIQUE_PATH) - -# This must be created right away for pattern rules in Sanity.gmk to work. -dummy1:=$(shell $(MKDIR) -p $(TEMPDIR)) -dummy2:=$(shell $(MKDIR) -p $(TEMP_DISK)) - -# OBJDIRNAME is the name of the directory where the object code is to -# be placed. It's name depends on whether the data model architecture -# is 32-bit or not. -ifneq ($(ARCH_DATA_MODEL), 32) - OBJDIRNAME = obj$(ARCH_DATA_MODEL)$(OBJDIRNAME_SUFFIX) -else - OBJDIRNAME = obj$(OBJDIRNAME_SUFFIX) -endif -OBJDIR = $(TEMPDIR)/$(OBJDIRNAME) - -# CLASSHDRDIR is where the generated C Class Header files go. -CLASSHDRDIR = $(TEMPDIR)/CClassHeaders - -# -# CLASSDESTDIR can be used to specify the directory where generated classes -# are to be placed. The default is CLASSBINDIR. -# -ifndef CLASSDESTDIR -CLASSDESTDIR = $(CLASSBINDIR) -endif - -INCLUDES = -I. -I$(CLASSHDRDIR) \ - $(patsubst %,-I%,$(subst $(CLASSPATH_SEPARATOR), ,$(VPATH.h))) $(OTHER_INCLUDES) -OTHER_CPPFLAGS += $(INCLUDES) - -# -# vpaths. These are the default locations searched for source files. -# GNUmakefiles of individual areas often override the default settings. -# There are no longer default vpath entries for C and assembler files -# so we can ensure that libraries don't get their hands on JVM files. -# -# We define an intermediate variable for Java files because -# we use its value later to help define $SOURCEPATH - -ifeq ($(PLATFORM), macosx) - VPATH0.java = $(subst $(ONESPACE),:,$(GENSRCDIR) $(call JavaSrcDirList,,classes)) -else - VPATH0.java = $(GENSRCDIR)$(CLASSPATH_SEPARATOR)$(PLATFORM_SRC)/classes$(CLASSPATH_SEPARATOR)$(SHARE_SRC)/classes -endif - -ifdef OPENJDK - VPATH.java = $(VPATH0.java) -else - # - # If filenames are duplicated between open/closed workspaces, prefer - # the closed files. - # - # Source ordering is important: some targets depend on closed files - # replacing open ones, and thus the closed file sources must be found - # before the open ones. - # - # Don't reorder without consulting the teams that depend on this behavior. - # - VPATH.java = $(CLOSED_PLATFORM_SRC)/classes$(CLASSPATH_SEPARATOR)$(CLOSED_SHARE_SRC)/classes$(CLASSPATH_SEPARATOR)$(VPATH0.java) -endif -vpath %.java $(VPATH.java) -vpath %.class $(CLASSBINDIR) -vpath %.$(OBJECT_SUFFIX) $(OBJDIR) - -# -# VPATH.h is used elsewhere to generate include flags. By default, -# anyone has access to the include files that the JVM area exports, -# namely jni.h, jvm.h, and jni_utils.h, plus their platform-specific -# relatives. -# -VPATH0.h = $(PLATFORM_SRC)/javavm/export$(CLASSPATH_SEPARATOR)$(SHARE_SRC)/javavm/export -ifdef OPENJDK - VPATH.h = $(VPATH0.h) -else - VPATH.h = $(CLOSED_SHARE_SRC)/javavm/export$(CLASSPATH_SEPARATOR)$(VPATH0.h) -endif -vpath %.h $(VPATH.h) - -# -# Used in two ways: helps link against libjava.so. Also if overridden -# determines where your shared library is installed. -# -ifndef LIB_LOCATION - LIB_LOCATION = $(LIBDIR)/$(LIBARCH) -endif - -# -# Java header and stub variables -# -CLASSHDRS = $(patsubst %,$(CLASSHDRDIR)/%.h,$(subst .,_,$(CLASSES.export))) -CLASSSTUBOBJS = classstubs.$(OBJECT_SUFFIX) -STUBPREAMBLE = $(INCLUDEDIR)/StubPreamble.h - -# -# Classpath seen by javac (different from the one seen by the VM -# running javac), and useful variables. -# -SOURCEPATH = $(VPATH.java) -PKG = $(shell $(EXPR) $(PACKAGE) : '\([a-z]*\)') -PKGDIR = $(subst .,/,$(PACKAGE)) - -# -# The java/javac/jdk variables (JAVAC_CMD, JAVA_CMD, etc.) -# -include $(JDK_MAKE_SHARED_DIR)/Defs-java.gmk - -UNIQUE_PATH_PATTERN = $(subst /,.,$(UNIQUE_PATH)) - -# Run MAKE $@ for a launcher: -# $(call make-launcher, name, mainclass, java-args, main-args) -define make-launcher -$(CD) $(BUILDDIR)/launchers && \ -$(MAKE) -f Makefile.launcher \ - PROGRAM=$(strip $1) \ - MAIN_CLASS=$(strip $2) \ - MAIN_JAVA_ARGS="$(strip $3)" \ - MAIN_ARGS="$(strip $4)" -endef - -# -# Convenient macros -# - -# Prepare $@ target, remove old one and making sure directory exists -define prep-target -mkdir -p $(@D) -rm -f $@ -endef - -# Simple install of $< file to $@ -define install-file -$(prep-target) -$(CP) $< $@ -endef - -define chmod-file -$(CHMOD) $1 $@ -endef - -define install-sym-link -$(LN) -s $1 $@ -endef - -define install-manifest-file -$(install-file) -endef - -# Cleanup rule for after debug java run (hotspot.log file is left around) -# (This could be an old leftover file in a read-only area, use the @- prefix) -HOTSPOT_LOG_NAME = hotspot.log -define java-vm-cleanup -if [ -w $(HOTSPOT_LOG_NAME) ] ; then rm -f $(HOTSPOT_LOG_NAME); fi -endef - -# Current directory -CURRENT_DIRECTORY := $(shell $(PWD)) - -# -# Create BYFILE OPT and DBG settings, if CFLAGS_OPT/foobar.o is set then it is -# used for this file, otherwise the default settings are used. -# -CFLAGS_$(VARIANT)/BYFILE = $(CFLAGS_$(VARIANT)/$(@F)) \ - $(CFLAGS_$(VARIANT)$(CFLAGS_$(VARIANT)/$(@F))) -CXXFLAGS_$(VARIANT)/BYFILE = $(CXXFLAGS_$(VARIANT)/$(@F)) \ - $(CXXFLAGS_$(VARIANT)$(CXXFLAGS_$(VARIANT)/$(@F))) - -# -# Tool flags -# -# EXTRA_CFLAGS are used to define cross-compilation options -# -ASFLAGS = $(ASFLAGS_$(VARIANT)) $(ASFLAGS_COMMON) $(OTHER_ASFLAGS) -CFLAGS = $(CFLAGS_$(VARIANT)/BYFILE) $(CFLAGS_COMMON) $(OTHER_CFLAGS) $(EXTRA_CFLAGS) -CXXFLAGS = $(CXXFLAGS_$(VARIANT)/BYFILE) $(CXXFLAGS_COMMON) $(OTHER_CXXFLAGS) $(EXTRA_CFLAGS) -CPPFLAGS = $(CPPFLAGS_$(VARIANT)) $(CPPFLAGS_COMMON) $(OTHER_CPPFLAGS) \ - $(DEFINES) $(OPTIONS:%=-D%) -LDFLAGS = $(LDFLAGS_$(VARIANT)) $(LDFLAGS_COMMON) $(OTHER_LDFLAGS) -LDLIBS = $(OTHER_LDLIBS) $(LDLIBS_$(VARIANT)) $(LDLIBS_COMMON) -LINTFLAGS = $(LINTFLAGS_$(VARIANT)) $(LINTFLAGS_COMMON) \ - $(OTHER_LINTFLAGS) - -VERSION_DEFINES = -DRELEASE='"$(RELEASE)"' - -ifdef INSANE - export INSANE -endif - -ifdef ALT_COPYRIGHT_YEAR - COPYRIGHT_YEAR = $(ALT_COPYRIGHT_YEAR) -else - COPYRIGHT_YEAR := $(shell $(DATE) '+%Y') -endif - -ifndef OPENJDK -include $(JDK_TOPDIR)/make/closed/common/Defs.gmk -endif - -# Install of imported file (JDK_IMPORT_PATH, or some other external location) -define install-importonly-file -@$(ECHO) "ASSEMBLY_IMPORT: $@" -$(prep-target) -$(CP) $< $@ -@if [ "$(PLATFORM)" = "linux" -a "$(@F)" = "libjvm.so" ] ; then \ - if [ -x /usr/sbin/selinuxenabled ] ; then \ - /usr/sbin/selinuxenabled; \ - if [ $$? = 0 ] ; then \ - $(ECHO) "/usr/bin/chcon -t textrel_shlib_t $@"; \ - /usr/bin/chcon -t textrel_shlib_t $@; \ - if [ $$? != 0 ]; then \ - echo "ERROR: Cannot chcon $@"; \ - fi; \ - fi; \ - fi; \ -fi -endef - -define install-import-file -$(install-importonly-file) -endef - -.PHONY: all build clean clobber diff --git a/jdk/makefiles/common/Demo.gmk b/jdk/makefiles/common/Demo.gmk deleted file mode 100644 index 25e1bd0905c..00000000000 --- a/jdk/makefiles/common/Demo.gmk +++ /dev/null @@ -1,415 +0,0 @@ -# -# Copyright (c) 2004, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) -c -COMPILE.cc = $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -LINK.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) -LINK.cc = $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) - -# JDK Demo building jar file. - -# Some names are defined with LIBRARY inside the Defs.gmk file -LIBRARY=$(DEMONAME) -OBJDIR=$(TEMPDIR)/$(DEMONAME) - -# Input: -# DEMONAME - name of the demo -# DEMO_ROOT - path to root of all demo files -# DEMO_DESTDIR - path to final demo destination directory -# -# Optional Input: -# DEMO_SRCDIR - path to source if different from DEMO_ROOT -# DEMO_PSRCDIR - path to additional platform specific source -# DEMO_PKGDIR - sub directory of sources we want -# DEMO_TOPFILES - names of top-level files relative to DEMO_ROOT -# DEMO_MAINCLASS - name of the main class for the jar manifest -# DEMO_NATIVECLASS - name of the class with native methods -# DEMO_DESCRIPTOR - name of service file for jar (relative to DEMO_SRCDIR) -# DEMO_EXTRA_SRCDIR - path to directory that holds extra sources to add -# DEMO_EXTRA_FILES - extra sources relative to DEMO_EXTRA_SRCDIR -# DEMO_OBJECTS - extra native object files needed -# DEMO_MANIFEST_ATTR - extra line to add to the jar manifest file - -# Assume the source directory is the root directory if not set -ifndef DEMO_SRCDIR - DEMO_SRCDIR = $(DEMO_ROOT) -endif -ifndef DEMO_PKGDIR - DEMO_PKGDIR = . -endif - -# Some demos have special needs -ifneq ($(DEMONAME),agent_util) - DEMO_NEEDS_AGENT_UTIL = $(findstring agent_util,$(DEMO_OBJECTS)) -endif -ifneq ($(DEMONAME),java_crw_demo) - DEMO_NEEDS_JAVA_CRW_DEMO = $(findstring java_crw_demo,$(DEMO_OBJECTS)) -endif -ifeq ($(DEMONAME),hprof) - DEMO_NEEDS_NPT = true -endif - -# Place to hold the build area (kind of a temp area) -DEMO_BUILD_AREA = $(DEMOCLASSDIR)/$(PRODUCT)/$(DEMONAME) - -# Destination "src" directory -DEMO_BUILD_SRCDIR = $(DEMO_BUILD_AREA)/src - -ifndef DEMO_SKIP_SRCZIP - DEMO_BUILD_SRCZIP = $(DEMO_BUILD_AREA)/src.zip - DEMO_SOURCE_ZIP = $(DEMO_DESTDIR)/src.zip -endif - -# Place to hold the jar image we are creating -DEMO_JAR_IMAGE = $(DEMO_BUILD_AREA)/jar_image - -# The jar manifest file we will create and use -DEMO_MANIFEST = $(DEMO_BUILD_AREA)/manifest.mf - -# The list of source files or options we will supply to javac -DEMO_JAVAC_INPUT = $(DEMO_BUILD_AREA)/javac_input.txt - -# Any name of javah file -DEMO_JAVAH_FILE = $(DEMO_NATIVECLASS:%=$(DEMO_BUILD_SRCDIR)/%.h) - -# Get complete list of files for this demo -ifdef DEMO_PSRCDIR - DEMO_ALL_FILES2 := $(shell ( $(CD) $(DEMO_PSRCDIR) \ - && $(FIND) $(DEMO_PKGDIR) $(SCM_DIRS_prune) -o -type f -print ) \ - | $(SED) 's@^\./@@' ) - DEMO_ALL_FILES += $(DEMO_ALL_FILES2) -endif -ifdef DEMO_EXTRA_SRCDIR - DEMO_ALL_FILES += $(DEMO_EXTRA_FILES) -endif -DEMO_ALL_FILES1 := $(shell ( $(CD) $(DEMO_SRCDIR) \ - && $(FIND) $(DEMO_PKGDIR) $(SCM_DIRS_prune) -o -type f -print ) \ - | $(SED) 's@^\./@@' ) -DEMO_ALL_FILES += $(DEMO_ALL_FILES1) - -# Just the java sources -DEMO_JAVA_SOURCES = $(filter %.java,$(DEMO_ALL_FILES)) - -# Just the C and C++ sources -DEMO_C_SRC_FILES = $(filter %.c,$(DEMO_ALL_FILES)) -DEMO_CPP_SRC_FILES = $(filter %.cpp,$(DEMO_ALL_FILES)) - -# All the native source files -DEMO_ALL_NATIVE_SOURCES = $(DEMO_C_SRC_FILES) -DEMO_ALL_NATIVE_SOURCES += $(DEMO_CPP_SRC_FILES) -DEMO_ALL_NATIVE_SOURCES += $(filter %.h,$(DEMO_ALL_FILES)) -DEMO_ALL_NATIVE_SOURCES += $(filter %.hpp,$(DEMO_ALL_FILES)) - -# If we have java sources, then define the jar file we will create -ifndef DEMO_JAR_NAME - DEMO_JAR_NAME = $(DEMONAME).jar -endif -ifneq ($(strip $(DEMO_JAVA_SOURCES)),) - DEMO_JAR = $(DEMO_DESTDIR)/$(DEMO_JAR_NAME) -endif - -# If we have native sources, define the native library we will create -ifneq ($(strip $(DEMO_ALL_NATIVE_SOURCES)),) - # Path to native library we will create - DEMO_LIBRARY = \ - $(DEMO_DESTDIR)/lib$(ISA_DIR)/$(LIB_PREFIX)$(DEMONAME).$(LIBRARY_SUFFIX) - # C and C++ compiler flags we need to add to standard flags - DEMO_CPPFLAGS += -I$(DEMO_BUILD_SRCDIR) - # If the npt library is used we need to find the npt.h file - ifneq ($(DEMO_NEEDS_NPT),) - # The npt library is delivered as part of the JRE - DEMO_CPPFLAGS += -I$(SHARE_SRC)/npt -I$(PLATFORM_SRC)/npt - endif - # Is the shared agent_util code needed - ifneq ($(DEMO_NEEDS_AGENT_UTIL),) - DEMO_FULL_SOURCES += $(DEMO_BUILD_SRCDIR)/agent_util.c - DEMO_FULL_SOURCES += $(DEMO_BUILD_SRCDIR)/agent_util.h - endif - # Is the shared java_crw_demo code needed - ifneq ($(DEMO_NEEDS_JAVA_CRW_DEMO),) - DEMO_FULL_SOURCES += $(DEMO_BUILD_SRCDIR)/java_crw_demo.c - DEMO_FULL_SOURCES += $(DEMO_BUILD_SRCDIR)/java_crw_demo.h - endif - # All the native object files we need to build the library - DEMO_OBJECTS += $(DEMO_C_SRC_FILES:%.c=%.$(OBJECT_SUFFIX)) \ - $(DEMO_CPP_SRC_FILES:%.cpp=%.$(OBJECT_SUFFIX)) - # Linking is special depending on whether we had C++ code or on windows - DEMO_NEEDS_CPP = $(strip $(DEMO_CPP_SRC_FILES)) - CPPFLAGS += $(DEMO_CPPFLAGS) - ifeq ($(PLATFORM),windows) - # Note: This is a link with cl.exe, not link.exe, options differ quite - # bit between them. - LINK.demo = $(LINK.c) - LDLIBS.demo = $(EXTRA_LIBS) $(LFLAGS_$(COMPILER_VERSION)) - DEMO_VERSION_INFO = $(OBJDIR)/$(LIBRARY).res - LDLIBS.demo += $(DEMO_VERSION_INFO) - else - ifneq ($(DEMO_NEEDS_CPP),) - LINK.demo = $(LINK.cpp) - LDLIBS.demo = $(LIBCXX) - ifeq ($(PLATFORM),solaris) - LDLIBS.demo += -lc - endif - else - LINK.demo = $(LINK.c) - LDLIBS.demo = $(LDLIBS) - endif - endif -endif - -# Files that are considered resources (need to be in the jar file) -DEMO_RESOURCES += $(filter-out %.java,$(DEMO_ALL_FILES)) - -# All destination files (top level readme files and all sources) -# Note: We exclude the topfiles from the src tree. -DEMO_DEST_TOPFILES = $(DEMO_TOPFILES:%=$(DEMO_DESTDIR)/%) -DEMO_FILTERED_SOURCES = $(filter-out $(DEMO_TOPFILES),$(DEMO_ALL_FILES)) -DEMO_FULL_SOURCES += $(DEMO_FILTERED_SOURCES:%=$(DEMO_BUILD_SRCDIR)/%) - -# Default rule -all: build demo_info - -# Used to populate the destination directories -$(DEMO_DESTDIR)/%: $(DEMO_ROOT)/% - $(install-file) -ifneq ($(DEMO_SRCDIR),$(DEMO_ROOT)) -$(DEMO_DESTDIR)/%: $(DEMO_SRCDIR)/% - $(install-file) -endif -$(DEMO_BUILD_SRCDIR)/%: $(DEMO_SRCDIR)/% - $(install-file) -ifdef DEMO_PSRCDIR -$(DEMO_BUILD_SRCDIR)/%: $(DEMO_PSRCDIR)/% - $(install-file) -endif -ifdef DEMO_EXTRA_SRCDIR -$(DEMO_BUILD_SRCDIR)/%: $(DEMO_EXTRA_SRCDIR)/% - $(install-file) -endif -ifneq ($(DEMO_NEEDS_AGENT_UTIL),) -$(DEMO_BUILD_SRCDIR)/%: $(DEMO_SRCDIR)/../agent_util/% - $(install-file) -endif -ifneq ($(DEMO_NEEDS_JAVA_CRW_DEMO),) -$(DEMO_BUILD_SRCDIR)/%: $(DEMO_SRCDIR)/../java_crw_demo/% - $(install-file) -endif - -# Jar manifest file -MAINMANIFEST = $(JDK_TOPDIR)/make/tools/manifest.mf -$(DEMO_MANIFEST): $(MAINMANIFEST) - @$(prep-target) - $(SED) -e "s#@@RELEASE@@#$(RELEASE)#" \ - -e "s#@@COMPANY_NAME@@#$(COMPANY_NAME)#" \ - $(MAINMANIFEST) >> $@ - $(ECHO) "Main-Class: $(DEMO_MAINCLASS)" >> $@ -ifdef DEMO_MANIFEST_ATTR - $(ECHO) "$(DEMO_MANIFEST_ATTR)" >> $@ -endif - -# Populating the jar image directory -$(DEMO_JAR_IMAGE)/%: $(DEMO_SRCDIR)/% - $(install-file) -ifdef DEMO_PSRCDIR -$(DEMO_JAR_IMAGE)/%: $(DEMO_PSRCDIR)/% - $(install-file) -endif -ifdef DEMO_EXTRA_SRCDIR -$(DEMO_JAR_IMAGE)/%: $(DEMO_EXTRA_SRCDIR)/% - $(install-file) -endif -ifdef DEMO_DESCRIPTOR -$(DEMO_JAR_IMAGE)/META-INF/services/$(DEMO_DESCRIPTOR): \ - $(DEMO_SRCDIR)/$(DEMO_DESCRIPTOR) - $(install-file) -endif - -# If we are creating a jar file (we have java code) -ifdef DEMO_JAR - -# Input file for javac -$(DEMO_JAVAC_INPUT): $(DEMO_JAVA_SOURCES:%=$(DEMO_BUILD_SRCDIR)/%) - @$(prep-target) - @for i in $(DEMO_JAVA_SOURCES) ; do \ - $(ECHO) "$(DEMO_BUILD_SRCDIR)/$$i" >> $@ ; \ - done - -# Jar file creation -$(DEMO_JAR): \ - $(DEMO_JAVAC_INPUT) \ - $(DEMO_MANIFEST) \ - $(DEMO_DESCRIPTOR:%=$(DEMO_JAR_IMAGE)/META-INF/services/%) \ - $(DEMO_RESOURCES:%=$(DEMO_JAR_IMAGE)/%) - @$(prep-target) - $(MKDIR) -p $(DEMO_JAR_IMAGE) - $(JAVAC_CMD) -d $(DEMO_JAR_IMAGE) -sourcepath $(DEMO_BUILD_SRCDIR) \ - @$(DEMO_JAVAC_INPUT) - ifeq ($(DEMO_INCL_SRC),true) - $(CP) $(DEMO_JAVA_SOURCES:%=$(DEMO_BUILD_SRCDIR)/%) $(DEMO_JAR_IMAGE) - endif - ifeq ($(DEMO_ONLY_SRC),true) - $(RM) -r $(DEMO_JAR_IMAGE) - $(MKDIR) -p $(DEMO_JAR_IMAGE) - $(CP) -r $(DEMO_BUILD_SRCDIR)/* $(DEMO_JAR_IMAGE) - ifneq ($(DEMO_TOPFILES),) - $(CP) $(DEMO_ROOT)/$(DEMO_TOPFILES) $(DEMO_JAR_IMAGE) - endif - endif - $(BOOT_JAR_CMD) -cfm $@ $(DEMO_MANIFEST) \ - -C $(DEMO_JAR_IMAGE) . \ - $(BOOT_JAR_JFLAGS) - @$(java-vm-cleanup) - -endif - -ifndef DEMO_SKIP_SRCZIP - # Create a src.zip file - $(DEMO_BUILD_SRCZIP): $(DEMO_FULL_SOURCES) - @$(prep-target) - $(CD) $(DEMO_BUILD_AREA)/src && $(ZIPEXE) -q -r ../$(@F) . - - # Install the destination src.zip file and create the src tree - $(DEMO_SOURCE_ZIP): $(DEMO_BUILD_SRCZIP) - $(install-file) -endif - -ifeq ($(PLATFORM),windows) -# JDK name required here -RC_FLAGS += /D "JDK_FNAME=$(LIBRARY).dll" \ - /D "JDK_INTERNAL_NAME=$(LIBRARY)" \ - /D "JDK_FTYPE=0x2L" -endif - -# Native library building -ifdef DEMO_LIBRARY - - # Full paths to object files - DEMO_FULL_OBJECTS = $(DEMO_OBJECTS:%=$(OBJDIR)/%) - VPATH= - -# Native compile rules -$(OBJDIR)/%.$(OBJECT_SUFFIX): $(DEMO_BUILD_SRCDIR)/%.c - @$(prep-target) - $(COMPILE.c) $(CC_OBJECT_OUTPUT_FLAG)$@ $< - ifneq ($(DEMO_NEEDS_CPP),) -$(OBJDIR)/%.$(OBJECT_SUFFIX): $(DEMO_BUILD_SRCDIR)/%.cpp - @$(prep-target) - $(COMPILE.cpp) $(CC_OBJECT_OUTPUT_FLAG)$@ $< - endif - - # Actual creation of the native shared library (C++ and C are different) -$(DEMO_LIBRARY): $(DEMO_FULL_OBJECTS) - @$(prep-target) - ifeq ($(PLATFORM),windows) - $(RC) $(RC_FLAGS) $(CC_OBJECT_OUTPUT_FLAG)$(DEMO_VERSION_INFO) $(VERSIONINFO_RESOURCE) - $(LINK.demo) $(SHARED_LIBRARY_FLAG) -Fe$@ \ - $(DEMO_FULL_OBJECTS) $(LDLIBS.demo) - else - $(LINK.demo) $(SHARED_LIBRARY_FLAG) -o $@ \ - $(DEMO_FULL_OBJECTS) $(LDLIBS.demo) - endif - @$(call binary_file_verification,$@) - - # Generation of any javah include file, make sure objects are dependent on it - ifdef DEMO_NATIVECLASS -$(DEMO_JAVAH_FILE): $(DEMO_JAR) - @$(prep-target) - $(JAVAH_CMD) -d $(DEMO_BUILD_SRCDIR) -classpath $(DEMO_JAR) \ - $(DEMO_NATIVECLASS) - @$(java-vm-cleanup) -$(DEMO_FULL_OBJECTS): $(DEMO_JAVAH_FILE) - endif - -endif - -# Build involves populating the destination "src" tree, building the jar and -# native library, and creating a source bundle - -sources: $(DEMO_FULL_SOURCES) - @$(ECHO) "Created $@" - -objects: - @$(ECHO) "Created $@" - -# Why the nested make here? It only works this way, don't know why. -bundles: $(DEMO_BUILD_SRCZIP) - $(RM) -r $(DEMO_DESTDIR) - $(MKDIR) -p $(DEMO_DESTDIR) - $(MAKE) $(DEMO_LIBRARY) $(DEMO_JAR) $(DEMO_SOURCE_ZIP) $(DEMO_DEST_TOPFILES) -# Applets are special, no jar file, no src.zip, everything expanded. -ifdef DEMO_IS_APPLET - @$(ECHO) "Expanding jar file into demos area at $(DEMO_DESTDIR)" - ( $(CD) $(DEMO_DESTDIR) && \ - $(BOOT_JAR_CMD) -xfv $(DEMO_JAR_NAME) \ - $(BOOT_JAR_JFLAGS) && \ - $(RM) -r META-INF $(DEMO_JAR_NAME) && \ - $(java-vm-cleanup) ) - @( $(CD) $(DEMO_DESTDIR) && $(java-vm-cleanup) ) - @$(ECHO) "Expanding source into demos area at $(DEMO_DESTDIR)" - ( $(CD) $(DEMO_DESTDIR) && $(UNZIP) -o src.zip && $(RM) src.zip ) -endif - -build: sources bundles - -# Printing out a demo information line -define printDemoSetting -if [ "$2" != "" ] ; then $(PRINTF) "%-20s %s\n" "$1:" "$2"; fi -endef - -# Print out the demo information -demo_info: - @$(ECHO) "=========================================================" - @$(call printDemoSetting,DEMONAME,$(DEMONAME)) - @$(call printDemoSetting,DEMO_ROOT,$(DEMO_ROOT)) - @$(call printDemoSetting,DEMO_SRCDIR,$(DEMO_SRCDIR)) - @$(call printDemoSetting,DEMO_DESTDIR,$(DEMO_DESTDIR)) - @$(call printDemoSetting,DEMO_JAR,$(DEMO_JAR)) - @$(call printDemoSetting,DEMO_MANIFEST_ATTR,$(DEMO_MANIFEST_ATTR)) - @$(call printDemoSetting,DEMO_PSRCDIR,$(DEMO_PSRCDIR)) - @$(call printDemoSetting,DEMO_EXTRA_SRCDIR,$(DEMO_EXTRA_SRCDIR)) - @$(call printDemoSetting,DEMO_EXTRA_FILES,$(DEMO_EXTRA_FILES)) - @$(call printDemoSetting,DEMO_TOPFILES,$(DEMO_TOPFILES)) - @$(call printDemoSetting,DEMO_MAINCLASS,$(DEMO_MAINCLASS)) - @$(call printDemoSetting,DEMO_DESCRIPTOR,$(DEMO_DESCRIPTOR)) - @$(call printDemoSetting,DEMO_NATIVECLASS,$(DEMO_NATIVECLASS)) - @$(call printDemoSetting,DEMO_LIBRARY,$(DEMO_LIBRARY)) - @$(call printDemoSetting,DEMO_OBJECTS,$(DEMO_OBJECTS)) - @$(call printDemoSetting,DEMO_SOURCE_ZIP,$(DEMO_SOURCE_ZIP)) - @$(ECHO) "=========================================================" - -# Clean rule -clean clobber: - $(RM) -r $(DEMO_BUILD_AREA) - $(RM) -r $(DEMO_DESTDIR) - -# This should not be needed, but some versions of GNU make have a bug that -# sometimes deleted these files for some strange and unknown reason -# (GNU make version 3.78.1 has the problem, GNU make version 3.80 doesn't?) -.PRECIOUS: $(DEMO_FULL_SOURCES) $(DEMO_BUILD_SRCZIP) $(DEMO_SOURCE_ZIP) - -# List phony targets -.PHONY: all build clean clobber demo_info \ - sources bundles - diff --git a/jdk/makefiles/common/Library.gmk b/jdk/makefiles/common/Library.gmk deleted file mode 100644 index 03b76ae22b0..00000000000 --- a/jdk/makefiles/common/Library.gmk +++ /dev/null @@ -1,326 +0,0 @@ -# -# Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Generic makefile for building shared libraries. -# - -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. -# - -include $(JDK_TOPDIR)/makefiles/common/Classes.gmk - -# -# It is important to define these *after* including Classes.gmk -# in order to override the values defined inthat makefile. -# - -ifeq ($(LIBRARY), fdlibm) -ifeq ($(PLATFORM),windows) -ACTUAL_LIBRARY_NAME = $(LIB_PREFIX)$(LIBRARY).$(FDDLIBM_SUFFIX) -ACTUAL_LIBRARY_DIR = $(OBJDIR) -else # PLATFORM -ACTUAL_LIBRARY_NAME = $(LIB_PREFIX)$(LIBRARY).$(ARCH).$(FDDLIBM_SUFFIX) -ACTUAL_LIBRARY_DIR = $(OBJDIR) -endif #PLATFORM -else # LIBRARY -ACTUAL_LIBRARY_NAME = $(LIB_PREFIX)$(LIBRARY).$(LIBRARY_SUFFIX) -ACTUAL_LIBRARY_DIR = $(LIB_LOCATION) -endif -ACTUAL_LIBRARY = $(ACTUAL_LIBRARY_DIR)/$(ACTUAL_LIBRARY_NAME) - -library:: $(ACTUAL_LIBRARY) - -FILES_o = $(patsubst %.c, %.$(OBJECT_SUFFIX), $(addprefix $(OBJDIR)/, $(notdir $(FILES_c)))) -FILES_o += $(patsubst %.s, %.$(OBJECT_SUFFIX), $(addprefix $(OBJDIR)/, $(notdir $(FILES_s)))) -FILES_o += $(patsubst %.cpp, %.$(OBJECT_SUFFIX), $(addprefix $(OBJDIR)/, $(notdir $(FILES_cpp)))) - -ifeq ($(PLATFORM), macosx) -FILES_o += $(patsubst %.m, %.$(OBJECT_SUFFIX), $(addprefix $(OBJDIR)/, $(notdir $(FILES_objc)))) -FILES_o += $(patsubst %.mm, %.$(OBJECT_SUFFIX), $(addprefix $(OBJDIR)/, $(notdir $(FILES_objcpp)))) - -INCREMENTAL_BUILD=false - -endif # PLATFORM - -ifeq ($(INCREMENTAL_BUILD),true) -FILES_d = $(patsubst %.c, %.$(DEPEND_SUFFIX), $(addprefix $(OBJDIR)/, $(notdir $(FILES_c)))) -FILES_d += $(patsubst %.cpp, %.$(DEPEND_SUFFIX), $(addprefix $(OBJDIR)/, $(notdir $(FILES_cpp)))) -endif # INCREMENTAL_BUILD - -ifeq ($(PLATFORM),solaris) -# List of all lint files, one for each .c file (only for C) -FILES_ln = $(patsubst %.c, %.$(LINT_SUFFIX), $(addprefix $(OBJDIR)/, $(notdir $(FILES_c)))) -endif - -LINK.cc = $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) -LINK.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) - -# -# C++ libraries must be linked with CC. -# -ifdef CPLUSPLUSLIBRARY -LINKER=$(LINK.cc) -else -LINKER=$(LINK.c) -endif - -$(ACTUAL_LIBRARY):: $(INIT) $(TEMPDIR) $(LIBDIR) $(BINDIR) $(EXTDIR) classheaders - @$(ECHO) Building lib:$(ACTUAL_LIBRARY) -# -# COMPILE_APPROACH: Different approaches to compile up the native object -# files as quickly as possible. -# The setting of parallel works best on Unix, batch on Windows. -# - -COMPILE_FILES_o = $(OBJDIR)/.files_compiled -$(COMPILE_FILES_o): $(FILES_d) $(FILES_o) - @$(ECHO) "$<" >> $@ -clean:: - $(RM) $(COMPILE_FILES_o) - -# -# COMPILE_APPROACH=parallel: Will trigger compilations (just compilations) to -# happen in parallel. Greatly decreases Unix build time, even on single CPU -# machines, more so on multiple CPU machines. Default is 2 compiles -# at a time, but can be adjusted with ALT_PARALLEL_COMPILE_JOBS. -# Note that each .d file will also be dependent on it's .o file, see -# Rules.gmk. -# Note this does not depend on Rules.gmk to work like batch (below) -# and this technique doesn't seem to help Windows build time nor does -# it work very well, it's possible the Windows Visual Studio compilers -# don't work well in a parallel situation, this needs investigation. -# - -ifeq ($(COMPILE_APPROACH),parallel) - -.PHONY: library_parallel_compile - -library_parallel_compile: - @$(ECHO) "Begin parallel compiles: $(shell $(PWD))" - $(MAKE) -j $(PARALLEL_COMPILE_JOBS) $(COMPILE_FILES_o) - @$(ECHO) "Done with parallel compiles: $(shell $(PWD))" - -$(ACTUAL_LIBRARY):: library_parallel_compile - -endif - -# -# COMPILE_APPROACH=batch: Will trigger compilations (just compilations) to -# happen in batch mode. Greatly decreases Windows build time. -# See logic in Rules.gmk for how compiles happen, the $(MAKE) in -# library_batch_compile below triggers the actions in Rules.gmk. -# Note that each .d file will also be dependent on it's .o file, see -# Rules.gmk. -# -ifeq ($(COMPILE_APPROACH),batch) - -.PHONY: library_batch_compile - -library_batch_compile: - @$(ECHO) "Begin BATCH compiles: $(shell $(PWD))" - $(MAKE) $(COMPILE_FILES_o) - $(MAKE) batch_compile - @$(ECHO) "Done with BATCH compiles: $(shell $(PWD))" - $(MAKE) COMPILE_APPROACH=normal $(COMPILE_FILES_o) - -$(ACTUAL_LIBRARY):: library_batch_compile - -endif - -ifeq ($(PLATFORM), windows) - -# -# Library building rules. -# - -$(LIBRARY).lib:: $(OBJDIR) - -ifeq ($(LIBRARY), fdlibm) -$(ACTUAL_LIBRARY):: $(OBJDIR)/$(LIBRARY).lib - -$(OBJDIR)/$(LIBRARY).lib:: $(OBJDIR)/$(LIBRARY).lcf - @$(prep-target) - $(AR) -NODEFAULTLIB:MSVCRT -out:$@ -nologo \ - @$(OBJDIR)/$(LIBRARY).lcf $(OTHER_LCF) $(LDLIBS_COMMON) -else # LIBRARY -# build it into $(OBJDIR) so that the other generated files get put -# there, then copy just the DLL (and MAP file) to the requested directory. -# -$(ACTUAL_LIBRARY):: $(OBJDIR)/$(LIBRARY).lcf - @$(prep-target) - @$(MKDIR) -p $(OBJDIR) - $(LD) -dll -out:$(OBJDIR)/$(@F) \ - -map:$(OBJDIR)/$(LIBRARY).map \ - $(LFLAGS) @$(OBJDIR)/$(LIBRARY).lcf \ - $(OTHER_LCF) $(LDLIBS) - $(CP) $(OBJDIR)/$(@F) $@ - @$(call binary_file_verification,$@) - $(CP) $(OBJDIR)/$(LIBRARY).map $(@D) - $(CP) $(OBJDIR)/$(LIBRARY).pdb $(@D) - -endif # LIBRARY - -$(OBJDIR)/$(LIBRARY).lcf: $(OBJDIR)/$(LIBRARY).res $(COMPILE_FILES_o) $(FILES_m) - @$(prep-target) - @$(MKDIR) -p $(TEMPDIR) - @$(ECHO) $(FILES_o) > $@ -ifndef LOCAL_RESOURCE_FILE - @$(ECHO) $(OBJDIR)/$(LIBRARY).res >> $@ -endif - @$(ECHO) Created $@ - -# JDK name required here -RC_FLAGS += /D "JDK_FNAME=$(LIBRARY).dll" \ - /D "JDK_INTERNAL_NAME=$(LIBRARY)" \ - /D "JDK_FTYPE=0x2L" - -$(OBJDIR)/$(LIBRARY).res: $(VERSIONINFO_RESOURCE) -ifndef LOCAL_RESOURCE_FILE - @$(prep-target) - $(RC) $(RC_FLAGS) $(CC_OBJECT_OUTPUT_FLAG)$(@) $(VERSIONINFO_RESOURCE) -endif - -# -# Install a .lib file if required. -# -ifeq ($(INSTALL_DOT_LIB), true) -$(ACTUAL_LIBRARY):: $(LIBDIR)/$(LIBRARY).lib - -clean:: - -$(RM) $(LIBDIR)/$(LIBRARY).lib - -$(LIBDIR)/$(LIBRARY).lib:: $(OBJDIR)/$(LIBRARY).lib - $(install-file) - -$(LIBDIR)/$(LIBRARY).dll:: $(OBJDIR)/$(LIBRARY).dll - $(install-file) - -endif # INSTALL_DOT_LIB - -else # PLATFORM - -# -# On Solaris, use mcs to write the version into the comment section of -# the shared library. On other platforms set this to false at the -# make command line. -# - -ifneq ($(PLATFORM), macosx) - ARFLAGS = -r -endif - -$(ACTUAL_LIBRARY):: $(COMPILE_FILES_o) $(FILES_m) $(FILES_reorder) - @$(prep-target) - @$(ECHO) "STATS: LIBRARY=$(LIBRARY), PRODUCT=$(PRODUCT), OPTIMIZATION_LEVEL=$(OPTIMIZATION_LEVEL)" - @$(ECHO) "Rebuilding $@ because of $?" -ifeq ($(LIBRARY), fdlibm) - $(AR) $(ARFLAGS) $@ $(FILES_o) -else # LIBRARY - $(LINKER) $(SHARED_LIBRARY_FLAG) -o $@ $(FILES_o) $(LDLIBS) - @$(call binary_file_verification,$@) -ifeq ($(WRITE_LIBVERSION),true) - $(MCS) -d -a "$(FULL_VERSION)" $@ -endif # WRITE_LIBVERSION -endif # LIBRARY - -endif # PLATFORM - -# -# Cross check all linted files against each other -# -ifeq ($(PLATFORM),solaris) -lint.errors : $(FILES_ln) - $(LINT.c) $(FILES_ln) $(LDLIBS) -endif - -# -# Class libraries with JNI native methods get a include to the package. -# -ifdef PACKAGE -vpath %.c $(PLATFORM_SRC)/native/$(PKGDIR) -vpath %.c $(SHARE_SRC)/native/$(PKGDIR) -OTHER_INCLUDES += -I$(SHARE_SRC)/native/common -I$(PLATFORM_SRC)/native/common -OTHER_INCLUDES += -I$(SHARE_SRC)/native/$(PKGDIR) \ - -I$(PLATFORM_SRC)/native/$(PKGDIR) -endif - -# -# Clean/clobber rules -# -clean:: - $(RM) -r $(ACTUAL_LIBRARY) - -clobber:: clean - -# -# INCREMENTAL_BUILD means that this workspace will be built over and over -# possibly incrementally. This means tracking the object file dependencies -# on include files so that sources get re-compiled when the include files -# change. When building from scratch and doing a one time build (like -# release engineering or nightly builds) set INCREMENTAL_BUILD=false. -# - -ifeq ($(INCREMENTAL_BUILD),true) - -# -# Workaround: gnumake sometimes says files is empty when it shouldn't -# was: files := $(foreach file, $(wildcard $(OBJDIR)/*.$(DEPEND_SUFFIX)), $(file)) -# -files := $(shell $(LS) $(OBJDIR)/*.$(DEPEND_SUFFIX) 2>/dev/null) - -# -# Only include these files if we have any. -# -ifneq ($(strip $(files)),) - -include $(files) - -endif # files - -endif # INCREMENTAL_BUILD - -# -# Default dependencies -# - -all: build - -build: library - -debug: - $(MAKE) VARIANT=DBG build - -fastdebug: - $(MAKE) VARIANT=DBG FASTDEBUG=true build - -openjdk: - $(MAKE) OPENJDK=true build - -FORCE: - -.PHONY: all build debug fastdebug - diff --git a/jdk/makefiles/common/Mapfile-vers.gmk b/jdk/makefiles/common/Mapfile-vers.gmk deleted file mode 100644 index 15c8ccd519a..00000000000 --- a/jdk/makefiles/common/Mapfile-vers.gmk +++ /dev/null @@ -1,97 +0,0 @@ -# -# Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile for linking with mapfiles. -# -# NOTE: Not using a mapfile will expose all your extern functions and -# extern data symbols as part of your interface, so unless your -# extern names are safe from being mistaken as names from other -# libraries, you better use a mapfile, or use a unique naming -# convention on all your extern symbols. -# -# The mapfile will establish versioning by defining the exported interface. -# -# The mapfile can also force certain .o files or elf sections into the -# the different segments of the resulting library/program image. -# -# The macro FILES_m can contain any number of mapfiles. -# - -# Always make sure 'all' is the default rule -mapfile_default_rule: all - -ifeq ($(PLATFORM), solaris) - -ifeq ($(VARIANT), OPT) - # OPT build MUST have a mapfile? - ifndef FILES_m - FILES_m = mapfile-vers - endif - - # If we are re-ordering functions in this solaris library, we need to make - # sure that -xF is added to the compile lines. This option is critical and - # enables the functions to be reordered. - ifdef FILES_reorder - CFLAGS_OPT += -xF - CXXFLAGS_OPT += -xF - endif - -INIT += $(TEMPDIR)/mapfile-vers - -$(TEMPDIR)/mapfile-vers : $(FILES_m) $(FILES_reorder) - $(prep-target) - $(CAT) $(FILES_m) > $@ - ifdef FILES_reorder - $(SED) -e 's=OUTPUTDIR=$(OUTPUTDIR)=' $(FILES_reorder) >> $@ - endif -endif # VARIANT - -ifndef LDNOMAP - LDMAPFLAGS_OPT = -M$(TEMPDIR)/mapfile-vers - LDMAPFLAGS_DBG = $(FILES_m:%=-M%) -endif - -endif # PLATFORM - -ifeq ($(PLATFORM), linux) - -ifeq ($(VARIANT), OPT) - # OPT build MUST have a mapfile? - ifndef FILES_m - FILES_m = mapfile-vers - endif -endif # VARIANT - -ifndef LDNOMAP - LDMAPFLAGS_OPT = $(FILES_m:%=-Xlinker -version-script=%) - LDMAPFLAGS_DBG = $(FILES_m:%=-Xlinker -version-script=%) -endif - -endif # PLATFORM - -LDFLAGS_OPT += $(LDMAPFLAGS_OPT) -LDFLAGS_DBG += $(LDMAPFLAGS_DBG) - diff --git a/jdk/makefiles/common/Modules.gmk b/jdk/makefiles/common/Modules.gmk deleted file mode 100644 index 7c6ccfda5f8..00000000000 --- a/jdk/makefiles/common/Modules.gmk +++ /dev/null @@ -1,479 +0,0 @@ -# -# Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -JDK_MODULE_IMAGE_DIR = $(ABS_OUTPUTDIR)/jdk-module-image -JRE_MODULE_IMAGE_DIR = $(ABS_OUTPUTDIR)/jre-module-image - -# -# modules Target to build jdk and jre module image -# -# There is one jar file per module containing classes only. -# All module jars are currently placed under jre/lib directory. -# -# Open issues that need further investigation: -# 1. Classes in jre/lib/ext/dnsns.jar are currently put in jre/lib/jndi-dns -# module. META-INF/services file is not installed. -# 2. Signed jars -# For JDK build, signed jars are copied to the build. -# All jars in the module image are unsigned. - -MODULE_IMAGEBINDIR = bin - -# -# Targets. -# -INITIAL_MODULE_IMAGE_JRE=initial-module-image-jre -INITIAL_MODULE_IMAGE_JDK=initial-module-image-jdk -ifeq ($(PLATFORM), solaris) - ifeq ($(ARCH_DATA_MODEL), 64) - INITIAL_MODULE_IMAGE_JRE=initial-module-image-jre-sol64 - INITIAL_MODULE_IMAGE_JDK=initial-module-image-jdk-sol64 - endif -endif - -modules modules-clobber \ -initial-module-image-jre initial-module-image-jdk \ -initial-module-image-jre-sol64 initial-module-image-jdk-sol64 \ -trim-module-image-jre trim-module-image-jdk \ -process-module-image-jre process-module-image-jdk :: - @$(ECHO) ">>>Making "$@" @ `$(DATE)` ..." - -# Order is important here, trim jre after jdk image is created -modules:: gen-modules \ - $(INITIAL_MODULE_IMAGE_JRE) $(INITIAL_MODULE_IMAGE_JDK) \ - trim-module-image-jre trim-module-image-jdk \ - process-module-image-jre process-module-image-jdk - -# Don't use these -module-image-jre:: initial-module-image-jre trim-module-image-jre process-module-image-jre -module-image-jdk:: initial-module-image-jdk trim-module-image-jdk process-module-image-jdk - -# -# Paths to these files we need -JDK_MODULE_LICENSES = $(LICENSE_DOCLIST_JDK:%=$(JDK_MODULE_IMAGE_DIR)/%) -JDK_MODULE_64_LICENSES = $(LICENSE_DOCLIST_JDK:%=$(JDK_MODULE_IMAGE_DIR)/%64) -JDK_MODULE_DOCFILES = $(OTHER_DOCLIST_JDK:%=$(JDK_MODULE_IMAGE_DIR)/%) - -JRE_MODULE_LICENSES = $(LICENSE_DOCLIST_JRE:%=$(JRE_MODULE_IMAGE_DIR)/%) -JRE_MODULE_64_LICENSES = $(LICENSE_DOCLIST_JRE:%=$(JRE_MODULE_IMAGE_DIR)/%64) -JRE_MODULE_DOCFILES = $(OTHER_DOCLIST_JRE:%=$(JRE_MODULE_IMAGE_DIR)/%) -JRE_MODULE_DOCFILES += $(JRE_NAMECHANGE_DOCLIST:%=$(JRE_MODULE_IMAGE_DIR)/%$(TEXT_SUFFIX)) - -###### RULES - -# JDK files -$(JDK_MODULE_IMAGE_DIR)/%: $(SHARE_JDK_DOC_SRC)/% - $(process-doc-file) -# Removes LICENSE_VERSION or not -ifdef LICENSE_VERSION -$(JDK_MODULE_IMAGE_DIR)/%: $(SHARE_JDK_DOC_SRC)/%$(LICENSE_VERSION) - $(process-doc-file) -$(JDK_MODULE_IMAGE_DIR)/%64: $(SHARE_JDK_DOC_SRC)/%$(LICENSE_VERSION) - $(process-doc-file) -else -$(JDK_MODULE_IMAGE_DIR)/%64: $(SHARE_JDK_DOC_SRC)/% - $(process-doc-file) -endif - -# JRE files -$(JRE_MODULE_IMAGE_DIR)/%: $(SHARE_JRE_DOC_SRC)/% - $(process-doc-file) -# Add $(TEXT_SUFFIX) suffix -ifdef TEXT_SUFFIX -$(JRE_MODULE_IMAGE_DIR)/%$(TEXT_SUFFIX): $(SHARE_JRE_DOC_SRC)/% - $(process-doc-file) -endif -# Removes LICENSE_VERSION or not -ifdef LICENSE_VERSION -$(JRE_MODULE_IMAGE_DIR)/%: $(SHARE_JRE_DOC_SRC)/%$(LICENSE_VERSION) - $(process-doc-file) -$(JRE_MODULE_IMAGE_DIR)/%64: $(SHARE_JRE_DOC_SRC)/%$(LICENSE_VERSION) - $(process-doc-file) -else -$(JRE_MODULE_IMAGE_DIR)/%64: $(SHARE_JRE_DOC_SRC)/% - $(process-doc-file) -endif - -###################################################### -# JRE Image -###################################################### - -MODULES_LIST = $(MODULES_TEMPDIR)/classlist/modules.list - -# Modules in the jre/lib/security directory -POLICY_MODULES = US_export_policy local_policy - -# Modules in the modules/ext directory -EXT_MODULES = localedata security-sunec security-sunjce - -# Build PKCS#11 on all platforms except 64-bit Windows. -PKCS11 = security-sunpkcs11 -ifeq ($(ARCH_DATA_MODEL), 64) - ifeq ($(PLATFORM), windows) - PKCS11 = - endif -endif - -EXT_MODULES += $(PKCS11) - -# Build Microsoft CryptoAPI provider only on (non-64-bit) Windows platform. -ifeq ($(PLATFORM), windows) - ifneq ($(ARCH_DATA_MODEL), 64) - EXT_MODULES += security-sunmscapi - endif -endif - -# Modules for JDK only -JDK_MODULES = tools - -gen-modules: - $(CD) modules; $(MAKE) all - -initial-module-image-jre-setup: - $(RM) -r $(JRE_MODULE_IMAGE_DIR) - $(MKDIR) -p $(JRE_MODULE_IMAGE_DIR) - -# 64-bit solaris jre image contains only the 64-bit add-on files. -initial-module-image-jre-sol64:: initial-module-image-jre-setup \ - $(JRE_MODULE_LICENSES) $(JRE_MODULE_64_LICENSES) - @# Use tar instead of cp to preserve the symbolic links - for dir in bin lib ; do \ - ( $(CD) $(OUTPUTDIR) && \ - $(TAR) cf - `$(FIND) $$dir -name '$(ARCH)' -print` | \ - ($(CD) $(JRE_MODULE_IMAGE_DIR) && $(TAR) xf -) ) ; \ - done - @# Remove some files from the jre area - for t in $(NOTJRETOOLS) ; do \ - $(RM) $(JRE_MODULE_IMAGE_DIR)/bin$(ISA_DIR)/$$t ; \ - done - $(RM) `$(FIND) $(JRE_MODULE_IMAGE_DIR)/lib -name 'orb.idl'` - $(RM) `$(FIND) $(JRE_MODULE_IMAGE_DIR)/lib -name 'ir.idl'` - -# Construct an initial jre image (initial jdk jre) no trimming or stripping -initial-module-image-jre:: initial-module-image-jre-setup \ - $(JRE_LICENSES) $(JRE_MODULE_DOCFILES) \ - $(BUILDMETAINDEX_JARFILE) - @# Copy in bin directory - $(CD) $(OUTPUTDIR) && $(FIND) bin -depth | $(CPIO) -pdum $(JRE_MODULE_IMAGE_DIR) - @# CTE plugin security change require new empty directory lib/applet - $(MKDIR) -p $(JRE_MODULE_IMAGE_DIR)/lib/applet - @# Copy files but not .jar in lib directory - $(CD) $(OUTPUTDIR) && $(FIND) lib -depth | $(EGREP) -v ".jar$$" | $(CPIO) -pdum $(JRE_MODULE_IMAGE_DIR) - @# - @# copy modules to jre/lib - @# - for m in `$(NAWK) '{print $$1}' $(MODULES_LIST)` ; do \ - $(CP) $(MODULES_DIR)/$$m/lib/$$m.jar $(JRE_MODULE_IMAGE_DIR)/lib ; \ - done - $(MKDIR) -p $(JRE_MODULE_IMAGE_DIR)/lib/ext - for m in $(EXT_MODULES) ; do \ - $(MV) $(JRE_MODULE_IMAGE_DIR)/lib/$$m.jar $(JRE_MODULE_IMAGE_DIR)/lib/ext ; \ - done - for m in $(POLICY_MODULES) ; do \ - $(MV) $(JRE_MODULE_IMAGE_DIR)/lib/$$m.jar $(JRE_MODULE_IMAGE_DIR)/lib/security; \ - done - @# Remove jdk modules - for m in $(JDK_MODULES) ; do \ - $(RM) $(JRE_MODULE_IMAGE_DIR)/lib/$$m.jar ; \ - done - - @# Make sure all directories are read/execute for everyone - $(CHMOD) a+rx `$(FIND) $(JRE_MODULE_IMAGE_DIR) -type d` - @# Remove some files from the jre area - for t in $(NOTJRETOOLS) ; do \ - $(RM) $(JRE_MODULE_IMAGE_DIR)/bin$(ISA_DIR)/$$t ; \ - done - @# Remove orb.idl and ir.idl from jre - $(FIND) $(JRE_MODULE_IMAGE_DIR)/lib -name 'orb.idl' -exec $(RM) \{} \; - $(FIND) $(JRE_MODULE_IMAGE_DIR)/lib -name 'ir.idl' -exec $(RM) \{} \; - @# Generate meta-index to make boot and extension class loaders lazier - $(CD) $(JRE_MODULE_IMAGE_DIR)/lib && \ - $(BOOT_JAVA_CMD) -jar $(BUILDMETAINDEX_JARFILE) \ - -o meta-index *.jar - @$(CD) $(JRE_MODULE_IMAGE_DIR)/lib && $(java-vm-cleanup) - $(CD) $(JRE_MODULE_IMAGE_DIR)/lib/ext && \ - $(BOOT_JAVA_CMD) -jar $(BUILDMETAINDEX_JARFILE) \ - -o meta-index *.jar - @$(CD) $(JRE_MODULE_IMAGE_DIR)/lib/ext && $(java-vm-cleanup) -ifeq ($(PLATFORM), windows) - @# Remove certain *.lib files - $(CD) $(JRE_MODULE_IMAGE_DIR)/lib && \ - $(RM) java.$(LIB_SUFFIX) jvm.$(LIB_SUFFIX) \ - hpi.$(LIB_SUFFIX) awt.$(LIB_SUFFIX) jawt.$(LIB_SUFFIX) - ifeq ($(ARCH_DATA_MODEL), 32) - @# The Java Kernel JRE image ships with a special VM. It is not included - @# in the full JRE image, so remove it. Also, is it only for 32-bit windows. - $(CD) $(JRE_MODULE_IMAGE_DIR)/bin && $(RM) -r kernel - endif -endif # Windows -ifneq ($(PLATFORM), windows) - $(call copy-man-pages,$(JRE_MODULE_IMAGE_DIR),$(JRE_MAN_PAGES)) -endif # !windows - -# Trim out any extra files not for the jre shipment but wanted in the jdk jre. -# (Note the jdk WILL want the jre image before this trimming) -# Removes server VM on Windows 32bit. -# Remove certain shared libraries that should not be in the jre image -# but should be in the jdk jre image. -trim-module-image-jre:: -ifeq ($(PLATFORM), windows) - ifeq ($(ARCH_DATA_MODEL), 32) - $(RM) -r $(JRE_MODULE_IMAGE_DIR)/bin/server - endif - ifdef NOTJRE_SHARED_LIBS - for l in $(NOTJRE_SHARED_LIBS) ; do \ - $(RM) $(JRE_MODULE_IMAGE_DIR)/bin/$$l ; \ - done ; - endif -else # PLATFORM - ifdef NOTJRE_SHARED_LIBS - for l in $(NOTJRE_SHARED_LIBS) ; do \ - $(RM) $(JRE_MODULE_IMAGE_DIR)/lib/$(LIBARCH)/$$l ; \ - done ; - endif -endif # PLATFORM - -# Get list of all Elf files in the jre -JRE_MODULE_ELF_LIST=$(MODULES_TEMPDIR)/jre-elf-files.list -$(JRE_MODULE_ELF_LIST): - @$(prep-target) -ifneq ($(PLATFORM), windows) - $(RM) $@ - $(FIND) $(JRE_MODULE_IMAGE_DIR)/lib -type f -name \*.$(LIB_SUFFIX) >> $@ - $(FILE) `$(FIND) $(JRE_MODULE_IMAGE_DIR)/bin -type f -name \*$(EXE_SUFFIX)` \ - | $(EGREP) 'ELF' | $(CUT) -d':' -f1 >> $@ -endif - -# Post process the image (strips and mcs on Elf files we are shipping) -# (Note the jdk WILL want the jre image before this processing) -process-module-image-jre:: $(JRE_MODULE_ELF_LIST) -ifneq ($(POST_STRIP_PROCESS), ) - for f in `$(CAT) $(JRE_MODULE_ELF_LIST)`; do \ - $(CHMOD) u+w $${f}; \ - $(ECHO) $(POST_STRIP_PROCESS) $${f}; \ - $(POST_STRIP_PROCESS) $${f}; \ - $(CHMOD) go-w $${f}; \ - done -endif -ifneq ($(POST_MCS_PROCESS), ) - for f in `$(CAT) $(JRE_MODULE_ELF_LIST)`; do \ - $(CHMOD) u+w $${f}; \ - $(ECHO) $(POST_MCS_PROCESS) $${f}; \ - $(POST_MCS_PROCESS) $${f}; \ - $(CHMOD) go-w $${f}; \ - done -endif - $(RM) $(JRE_MODULE_ELF_LIST) - -###################################################### -# JDK Image -###################################################### -# Note: cpio ($(CPIO)) sometimes leaves directories without rx access. - -initial-module-image-jdk-setup: - $(RM) -r $(JDK_MODULE_IMAGE_DIR) - $(MKDIR) -p $(JDK_MODULE_IMAGE_DIR)/jre - ($(CD) $(JRE_MODULE_IMAGE_DIR) && $(FIND) . -depth -print \ - | $(CPIO) -pdum $(JDK_MODULE_IMAGE_DIR)/jre ) - $(RM) -rf $(JDK_MODULE_IMAGE_DIR)/jre/man - $(CHMOD) a+rx `$(FIND) $(JDK_MODULE_IMAGE_DIR) -type d` - -initial-module-image-jdk64-bindemos: - for dir in bin demo ; do \ - ( $(CD) $(OUTPUTDIR) && \ - $(TAR) cf - `$(FIND) $$dir -name '$(LIBARCH)' -print` | \ - ($(CD) $(JDK_MODULE_IMAGE_DIR) && $(TAR) xf -) ) ; \ - done - -# Solaris 64 bit image is special -initial-module-image-jdk-sol64:: initial-module-image-jdk-setup \ - initial-module-image-jdk64-bindemos \ - $(JDK_MODULE_LICENSES) $(JDK_MODULARLIZED_64_LICENSES) - -# DB files to add -ifeq ($(OPENJDK),true) - -initial-module-image-jdk-db: - -else - -# Create the list of db *.zip files to bundle with jdk -ABS_DB_PATH :=$(call FullPath,$(CLOSED_SHARE_SRC)/db) -DB_ZIP_LIST = $(shell $(LS) $(ABS_DB_PATH)/*.zip 2>/dev/null) - -initial-module-image-jdk-db: $(DB_ZIP_LIST) - $(MKDIR) -p $(JDK_MODULE_IMAGE_DIR)/db - for d in $(DB_ZIP_LIST); do \ - ($(CD) $(JDK_MODULE_IMAGE_DIR)/db && $(UNZIP) -o $$d); \ - done - -endif - -# Standard jdk image -initial-module-image-jdk:: initial-module-image-jdk-setup \ - initial-module-image-jdk-db \ - $(JDK_MODULE_LICENSES) $(JDK_MODULE_DOCFILES) - $(MKDIR) $(JDK_MODULE_IMAGE_DIR)/lib - @# - @# copy jdk modules to jdk/lib - @# - $(MKDIR) -p $(JDK_MODULE_IMAGE_DIR)/lib - for m in $(JDK_MODULES) ; do \ - $(CP) $(MODULES_DIR)/$$m/lib/$$m.jar $(JDK_MODULE_IMAGE_DIR)/lib ; \ - done - ifeq ($(PLATFORM), windows) - @# - @# lib/ - @# - $(CP) $(LIBDIR)/$(LIB_PREFIX)jvm.$(LIB_SUFFIX) $(JDK_MODULE_IMAGE_DIR)/lib - $(CP) $(LIBDIR)/$(LIB_PREFIX)jawt.$(LIB_SUFFIX) $(JDK_MODULE_IMAGE_DIR)/lib - @# - @# bin/ - @# - @# copy all EXE files and only certain DLL files from BINDIR - $(MKDIR) -p $(JDK_MODULE_IMAGE_DIR)/bin - $(CP) $(BINDIR)/*$(EXE_SUFFIX) $(JDK_MODULE_IMAGE_DIR)/bin - $(CP) $(BINDIR)/jli.$(LIBRARY_SUFFIX) $(JDK_MODULE_IMAGE_DIR)/bin - ifeq ($(COMPILER_VERSION), VS2010) - $(CP) $(BINDIR)/msvc*100.$(LIBRARY_SUFFIX) $(JDK_MODULE_IMAGE_DIR)/bin - endif - ifeq ($(ARCH_DATA_MODEL), 32) - ifeq ($(COMPILER_VERSION), VS2003) - $(CP) $(BINDIR)/msvc*71.$(LIBRARY_SUFFIX) $(JDK_MODULE_IMAGE_DIR)/bin - endif - endif - else # PLATFORM - @# - @# bin/ - @# - ($(CD) $(BINDIR)/.. && $(TAR) cf - \ - `$(FIND) bin \( -type f -o -type l \) -print `) | \ - ($(CD) $(JDK_MODULE_IMAGE_DIR) && $(TAR) xf -) - endif # PLATFORM - @# - @# lib/ct.sym - @# - $(MKDIR) -p $(OUTPUTDIR)/symbols/META-INF/sym - $(JAVAC_CMD) -XDprocess.packages -proc:only \ - -processor com.sun.tools.javac.sym.CreateSymbols \ - -Acom.sun.tools.javac.sym.Jar=$(RT_JAR) \ - -Acom.sun.tools.javac.sym.Dest=$(OUTPUTDIR)/symbols/META-INF/sym/rt.jar \ - $(CORE_PKGS) $(NON_CORE_PKGS) $(EXCLUDE_PROPWARN_PKGS) - $(BOOT_JAR_CMD) c0f $(LIBDIR)/ct.sym \ - -C $(OUTPUTDIR)/symbols META-INF $(BOOT_JAR_JFLAGS) - @$(java-vm-cleanup) - $(CP) $(LIBDIR)/ct.sym $(JDK_MODULE_IMAGE_DIR)/lib/ct.sym - @# - @# CORBA supported orb.idl and ir.idl should be copied to lib - @# - $(CP) $(LIBDIR)/orb.idl $(JDK_MODULE_IMAGE_DIR)/lib/orb.idl - $(CP) $(LIBDIR)/ir.idl $(JDK_MODULE_IMAGE_DIR)/lib/ir.idl - ifeq ($(PLATFORM), linux) - @# - @# on Linux copy jexec from jre/lib to /lib - @# - $(CP) $(LIBDIR)/jexec $(JDK_MODULE_IMAGE_DIR)/lib/jexec - endif # PLATFORM - @# - @# demo, include - @# - $(CP) -r -f $(DEMODIR) $(JDK_MODULE_IMAGE_DIR) - $(CP) -r -f $(SAMPLEDIR) $(JDK_MODULE_IMAGE_DIR) - $(CP) -r $(INCLUDEDIR) $(JDK_MODULE_IMAGE_DIR) - @# - @# Swing BeanInfo generation - @# - $(CD) javax/swing/beaninfo && $(MAKE) JDK_IMAGE_DIR=$(JDK_MODULE_IMAGE_DIR) swing-1.2-beans -ifneq ($(PLATFORM), windows) - $(call copy-man-pages,$(JDK_MODULE_IMAGE_DIR),$(JDK_MAN_PAGES)) -endif # !windows - -# Trim out files we don't want to ship -trim-module-image-jdk:: - @# Remove tools that should not be part of SDK. - for t in $(NOTJDKTOOLS); do \ - $(RM) $(JDK_MODULE_IMAGE_DIR)/bin/$${t}$(EXE_SUFFIX) \ - $(JDK_MODULE_IMAGE_DIR)/bin/*/native_threads/$${t}$(EXE_SUFFIX); \ - done - -# Get list of Elf files in the jdk -JDK_MODULE_ELF_LIST=$(MODULES_TEMPDIR)/jdk-elf-files.list -$(JDK_MODULE_ELF_LIST): - @$(prep-target) -ifneq ($(PLATFORM), windows) - $(RM) $@ - $(FIND) $(JDK_MODULE_IMAGE_DIR)/jre/lib -type f -name \*.$(LIB_SUFFIX) >> $@ - $(FILE) `$(FIND) $(JDK_MODULE_IMAGE_DIR)/jre/bin -type f -name \*$(EXE_SUFFIX)` \ - | $(EGREP) 'ELF' | $(CUT) -d':' -f1 >> $@ - file `$(FIND) $(JDK_MODULE_IMAGE_DIR)/bin -type f -name \*$(EXE_SUFFIX)` \ - | $(EGREP) 'ELF' | $(CUT) -d':' -f1 >> $@ -endif - -# Post process the image (strips and mcs on files we are shipping) -process-module-image-jdk:: $(JDK_MODULE_ELF_LIST) -ifneq ($(POST_STRIP_PROCESS), ) - for f in `$(CAT) $(JDK_MODULE_ELF_LIST)`; do \ - $(CHMOD) u+w $${f}; \ - $(ECHO) $(POST_STRIP_PROCESS) $${f}; \ - $(POST_STRIP_PROCESS) $${f}; \ - $(CHMOD) go-w $${f}; \ - done -endif -ifneq ($(POST_MCS_PROCESS), ) - for f in `$(CAT) $(JDK_MODULE_ELF_LIST)`; do \ - $(CHMOD) u+w $${f}; \ - $(ECHO) $(POST_MCS_PROCESS) $${f}; \ - $(POST_MCS_PROCESS) $${f}; \ - $(CHMOD) go-w $${f}; \ - done -endif - $(RM) $(JDK_MODULE_ELF_LIST) - -###################################################### -# clobber -###################################################### -modules-clobber:: - $(RM) -r $(JDK_MODULE_IMAGE_DIR) - $(RM) -r $(JRE_MODULE_IMAGE_DIR) - -modules modules-clobber:: - @$(ECHO) ">>>Finished making "$@" @ `$(DATE)` ..." - @$(java-vm-cleanup) - -.PHONY: modules module-image-jre module-image-jdk \ - initial-module-image-jre initial-module-image-jdk \ - initial-module-image-jre-sol64 initial-module-image-jdk-sol64 \ - initial-module-image-jdk-setup \ - initial-module-image-jdk-db \ - initial-module-image-jdk64-bindemos \ - initial-module-image-jre-setup \ - trim-module-image-jre trim-module-image-jdk \ - process-module-image-jre process-module-image-jdk \ - install-previous-jre install-previous-jdk \ - modules-clobber - -# Force rule -FRC: - diff --git a/jdk/makefiles/common/Program.gmk b/jdk/makefiles/common/Program.gmk deleted file mode 100644 index 5ace9dc8eda..00000000000 --- a/jdk/makefiles/common/Program.gmk +++ /dev/null @@ -1,319 +0,0 @@ -# -# Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Generic makefile for building executables. -# - -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. -# - -# -# If building programs, use a normal compile approach -# -ifeq ($(COMPILE_APPROACH),batch) - override COMPILE_APPROACH = normal -endif - -# set the platform specific directory for macosx, also this platform shares -# substantial family ties with its siblings (solaris and linux), thus we add -# solaris src path to its compilation dependencies. -ifeq ($(PLATFORM), macosx) - LAUNCHER_PLATFORM_SRC = $(BUILDDIR)/../src/macosx - LAUNCHER_SOLARIS_PLATFORM_SRC = $(BUILDDIR)/../src/solaris -else - LAUNCHER_PLATFORM_SRC = $(PLATFORM_SRC) -endif - -ifndef LAUNCHER_SHARE_SRC - LAUNCHER_SHARE_SRC = $(SHARE_SRC) -endif - -ACTUAL_PROGRAM_NAME = $(PROGRAM)$(EXE_SUFFIX) -ACTUAL_PROGRAM_DIR = $(BINDIR) -ACTUAL_PROGRAM = $(ACTUAL_PROGRAM_DIR)/$(ACTUAL_PROGRAM_NAME) - -# Make sure the default rule is all -program_default_rule: all - -program: $(ACTUAL_PROGRAM) - -# Work-around for missing processor specific mapfiles -ifndef CROSS_COMPILE_ARCH - # reuse the mapfiles in the launcher's directory, the same should - # be applicable to the tool launchers as well. - FILES_m = $(BUILDDIR)/java/main/java/mapfile-$(ARCH) - include $(BUILDDIR)/common/Mapfile-vers.gmk -endif - -include $(JDK_TOPDIR)/makefiles/common/Rules.gmk - -ifdef NEVER_ACT_AS_SERVER_CLASS_MACHINE - OTHER_CPPFLAGS += -DNEVER_ACT_AS_SERVER_CLASS_MACHINE -endif - -# -# Create a dependency on libjli (Java Launcher Infrastructure) -# -# On UNIX, this is a relative dependency using $ORIGIN. Unfortunately, to -# do this reliably on Linux takes a different syntax than Solaris. -# -# On Windows, this is done by using the same directory as the executable -# itself, as with all the Windows libraries. -# -ifeq ($(PLATFORM), macosx) - ifneq ($(ARCH), universal) - LDFLAGS += -Wl,-all_load - endif - LDFLAGS += $(OUTPUTDIR)/tmp/java/jli/$(OBJDIRNAME)/static/libjli.a - - ifeq ($(SYSTEM_ZLIB),true) - OTHER_LDLIBS += -lz - endif -endif - -ifneq (,$(findstring $(PLATFORM), linux solaris)) # UNIX systems - LDFLAGS += -L $(LIBDIR)/$(LIBARCH)/jli - OTHER_LDLIBS += -ljli - ifeq ($(PLATFORM), solaris) - ifeq ($(ARCH_DATA_MODEL), 32) - LDFLAGS += -R \$$ORIGIN/../lib/$(LIBARCH)/jli - LDFLAGS += -R \$$ORIGIN/../jre/lib/$(LIBARCH)/jli - else - LDFLAGS += -R \$$ORIGIN/../../lib/$(LIBARCH)/jli - LDFLAGS += -R \$$ORIGIN/../../jre/lib/$(LIBARCH)/jli - endif - endif - ifeq ($(PLATFORM), linux) - LDFLAGS += $(LDFLAG_Z_ORIGIN) - LDFLAGS += -Wl,--allow-shlib-undefined - LDFLAGS += -Wl,-rpath -Wl,\$$ORIGIN/../lib/$(LIBARCH)/jli - LDFLAGS += -Wl,-rpath -Wl,\$$ORIGIN/../jre/lib/$(LIBARCH)/jli - endif -endif - -ifeq ($(PLATFORM), windows) - JLI_LCF = $(OUTPUTDIR)/tmp/java/jli/$(OBJDIRNAME)/jli.lcf - ifdef STATIC_JLI - LDFLAGS += -libpath:$(OUTPUTDIR)/tmp/java/jli/$(OBJDIRNAME)/static - else - LDFLAGS += -libpath:$(OUTPUTDIR)/tmp/java/jli/$(OBJDIRNAME) - endif - OTHER_LDLIBS += jli.lib -endif - -# -# Launcher specific files. -# -FILES_o = $(OBJDIR)/main.$(OBJECT_SUFFIX) - -$(ACTUAL_PROGRAM):: classes $(INIT) - -# -# Windows only -# -ifeq ($(PLATFORM), windows) - # JDK name required here - RC_FLAGS += /D "JDK_FNAME=$(PROGRAM)$(EXE_SUFFIX)" \ - /D "JDK_INTERNAL_NAME=$(PROGRAM)" \ - /D "JDK_FTYPE=0x1L" - - $(OBJDIR)/$(PROGRAM).res: $(VERSIONINFO_RESOURCE) - @$(prep-target) - ifndef LOCAL_RESOURCE_FILE - $(RC) $(RC_FLAGS) $(CC_OBJECT_OUTPUT_FLAG)$(@) $(VERSIONINFO_RESOURCE) - endif - - $(OBJDIR)/$(PROGRAM).lcf: $(OBJDIR)/$(PROGRAM).res $(FILES_o) - @$(prep-target) - @$(ECHO) $(FILES_o) > $@ - ifndef LOCAL_RESOURCE_FILE - @$(ECHO) $(OBJDIR)/$(PROGRAM).res >> $@ - endif - @$(ECHO) setargv.obj >> $@ - @$(ECHO) Created $@ - - $(ACTUAL_PROGRAM):: $(OBJDIR)/$(PROGRAM)$(EXE_SUFFIX) - @$(install-file) - - ifeq ($(ARCH_DATA_MODEL), 32) - STACK_SIZE=327680 - else - # We need more Stack for Windows 64bit - STACK_SIZE=1048576 - endif - - IMVERSION=$(JDK_MINOR_VERSION).$(JDK_MICRO_VERSION).$(JDK_UPDATE_VER).$(COOKED_BUILD_NUMBER) - $(OBJDIR)/$(PROGRAM).exe.manifest: $(JDK_TOPDIR)/src/windows/resource/java.manifest - @$(prep-target) - $(SED) 's%IMVERSION%$(IMVERSION)%g;s%PROGRAM%$(PROGRAM)%g' $< > $@ - - # We used a hand-crafted manifest file for all executables. - # It is tweaked to embed the build number and executable name. - # Use ";#2" for .dll and ";#1" for .exe in the MT command below: - $(OBJDIR)/$(PROGRAM)$(EXE_SUFFIX):: $(OBJDIR)/$(PROGRAM).lcf $(FILES_o) $(JLI_LCF) $(OBJDIR)/$(PROGRAM).exe.manifest - @$(prep-target) - @set -- $?; \ - $(ECHO) Rebuilding $@ because of $$1 $$2 $$3 $$4 $$5 $$6 $${7:+...}; - $(LD) -out:$@ /STACK:$(STACK_SIZE) \ - -map:$(OBJDIR)/$(PROGRAM).map $(LFLAGS) $(LDFLAGS) \ - @$(OBJDIR)/$(PROGRAM).lcf $(LDLIBS) - ifdef MT - $(MT) /manifest $(OBJDIR)/$(PROGRAM).exe.manifest /outputresource:$@;#1 - endif - @$(call binary_file_verification,$@) -else - # - # Note that we have to link -lthread even when USE_PTHREADS is true. - # This is becuase checkForCorrectLibthread() croaks otherwise. - # - LIBTHREAD = -lthread - ifeq ($(USE_PTHREADS),true) - THREADLIBS = -lpthread $(LIBTHREAD) - else - THREADLIBS = $(LIBTHREAD) - endif - - ifeq ($(PLATFORM), macosx) - THREADLIBS = -pthread - # Needed for linking the various launchers - LDFLAGS += -framework Cocoa -framework Security \ - -framework ApplicationServices - OTHER_CPPFLAGS += -DPACKAGE_PATH='"$(PACKAGE_PATH)"' - - # Default Info.plist file for the command line tools. This gets overridden by - # some of the jvmstat tools so that they have task_for_pid() privileges - ifndef INFO_PLIST_FILE - INFO_PLIST_FILE = Info-cmdline.plist - endif - LDFLAGS += -sectcreate __TEXT __info_plist $(LAUNCHER_PLATFORM_SRC)/lib/$(INFO_PLIST_FILE) - else - INFO_PLIST_FILE= - endif - - # - # This rule only applies on unix. It supports quantify and its ilk. - # - $(ACTUAL_PROGRAM):: $(FILES_o) - @$(prep-target) - @set -- $?; \ - $(ECHO) Rebuilding $@ because of $$1 $$2 $$3 $$4 $$5 $$6 $${7:+...}; - @$(MKDIR) -p $(TEMPDIR) - $(LINK_PRE_CMD) $(CC) $(CC_OBJECT_OUTPUT_FLAG)$@ $(LDFLAGS) \ - $(FILES_o) $(THREADLIBS) $(LDLIBS) - ifeq ($(findstring privileged, $(INFO_PLIST_FILE)), privileged) - -codesign -s openjdk_codesign $@ - endif - @$(call binary_file_verification,$@) -endif # PLATFORM - -clean:: -ifeq ($(PLATFORM), windows) - $(RM) $(OBJDIR)/$(PROGRAM).rc - $(RM) $(OBJDIR)/$(PROGRAM).ico - $(RM) $(OBJDIR)/$(PROGRAM).lcf - $(RM) $(OBJDIR)/$(PROGRAM).map - $(RM) $(OBJDIR)/$(PROGRAM).exp - $(RM) $(OBJDIR)/$(PROGRAM).lib - $(RM) $(OBJDIR)/$(PROGRAM)$(EXE_SUFFIX) - $(RM) $(OBJDIR)/$(PROGRAM).ilk - $(RM) *.pdb -endif - - -clobber:: - $(RM) $(ACTUAL_PROGRAM) - -# -# Now include make dependencies (created during compilation, see Rules.gmk) -# -ifeq ($(INCREMENTAL_BUILD),true) - # Workaround: gnumake sometimes says files is empty when it shouldn't - # was: files := $(foreach file, $(wildcard */$(ARCH)/*.$(DEPEND_SUFFIX)), $(file)) - files := $(shell $(LS) $(OBJDIR)/*.$(DEPEND_SUFFIX) 2>/dev/null) - ifneq ($(strip $(files)),) - include $(files) - endif -endif - -ifdef JAVA_ARGS - OTHER_CPPFLAGS += -DJAVA_ARGS='$(JAVA_ARGS)' - OTHER_CPPFLAGS += -DLAUNCHER_NAME='"$(LAUNCHER_NAME)"' -endif - -ifeq ($(PLATFORM), windows) - ifdef RELEASE - OTHER_CPPFLAGS += -DVERSION='"$(RELEASE)"' - endif -endif - - -ifneq ($(PLATFORM), windows) - HAVE_GETHRTIME=true -endif - -ifeq ($(HAVE_GETHRTIME),true) - OTHER_CPPFLAGS += -DHAVE_GETHRTIME -endif - -OTHER_INCLUDES += -I$(LAUNCHER_SHARE_SRC)/bin -I$(LAUNCHER_PLATFORM_SRC)/bin -ifeq ($(PLATFORM), macosx) - OTHER_INCLUDES += -I$(LAUNCHER_SOLARIS_PLATFORM_SRC)/bin - ifneq ($(SYSTEM_ZLIB), true) - OTHER_INCLUDES += -I$(SHARE_SRC)/native/java/util/zip/zlib-1.1.3 - endif -else - OTHER_INCLUDES += -I$(SHARE_SRC)/native/java/util/zip/zlib-1.1.3 -endif - -OTHER_CPPFLAGS += -DPROGNAME='"$(PROGRAM)"' -VERSION_DEFINES += -DFULL_VERSION='"$(FULL_VERSION)"' - -VERSION_DEFINES += -DJDK_MAJOR_VERSION='"$(JDK_MAJOR_VERSION)"' \ - -DJDK_MINOR_VERSION='"$(JDK_MINOR_VERSION)"' - - - -$(OBJDIR)/main.$(OBJECT_SUFFIX): $(LAUNCHER_SHARE_SRC)/bin/main.c - @$(prep-target) - $(COMPILE.c) $(CC_OBJECT_OUTPUT_FLAG)$(OBJDIR)/main.$(OBJECT_SUFFIX) \ - $(VERSION_DEFINES) $< - -# -# Default dependencies -# - -all: build - -build: program - -debug: - $(MAKE) VARIANT=DBG build - -fastdebug: - $(MAKE) VARIANT=DBG FASTDEBUG=true build - -.PHONY: all build program clean clobber debug fastdebug diff --git a/jdk/makefiles/common/Release-embedded.gmk b/jdk/makefiles/common/Release-embedded.gmk deleted file mode 100644 index d5d709fd3b4..00000000000 --- a/jdk/makefiles/common/Release-embedded.gmk +++ /dev/null @@ -1,230 +0,0 @@ -# -# Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# SE-Embedded Reduced JRE targets -# -ifdef JAVASE_EMBEDDED - -reduced-image-jre reduced-headless-image-jre :: - @$(ECHO) ">>>Making "$@" @ `$(DATE)` ..." - -# Add the reduced-jre images as pre-reqs. These will be processed last -images:: reduced-image-jre reduced-headless-image-jre - - -###################################################### -# Create the headless rt.jar -###################################################### - -NOT_HEADLESS_RT_JAR_LIST = $(ABS_TEMPDIR)/not_hl_rt_jar.list -HEADLESS_RT_JAR_FILELIST=$(JARFILELISTS_TEMPDIR)/hl_rt_jar_list -TOTAL_HEADLESS_JAR_FILELIST=$(REORDER_TEMPDIR)/hl_file_list -HEADLESS_CLASSLIST=$(ABS_TEMPDIR)/headless_classlist - -# Add the jar file directories that we don't want in the -# headless JRE. If you want to remove most classes in a -# directory, put the directory in the NOT_HEADLESS_RT_JAR_LIST -# and put the individual classes you want to keep in the -# HEADLESS_CLASSLIST file. -$(NOT_HEADLESS_RT_JAR_LIST): $(NOT_RT_JAR_LIST) - $(RM) $(HEADLESS_CLASSLIST) - $(RM) $(NOT_HEADLESS_RT_JAR_LIST) - $(CP) $(NOT_RT_JAR_LIST) $(NOT_HEADLESS_RT_JAR_LIST) -# List all the packages to be excluded - $(ECHO) "sun/awt/motif/" >> $@ - $(ECHO) "sun/awt/X11/" >> $@ - $(ECHO) "sun/applet/" >> $@ - $(ECHO) "sun/java2d/opengl/" >> $@ - $(ECHO) "com/sun/java/swing/plaf/" >> $@ -# List all the individual classes to be included - $(ECHO) "sun/awt/motif/MFontConfiguration.class" >$(HEADLESS_CLASSLIST) - $(ECHO) "sun/applet/AppContextCreator.class" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/applet/AppletAudioClip.class" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/java2d/opengl/GLXSurfaceData.class" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/java2d/opengl/GLXSurfaceData"\$$"GLXOffScreenSurfaceData.class" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/java2d/opengl/GLXVolatileSurfaceManager.class" >>$(HEADLESS_CLASSLIST) - $(ECHO) "sun/java2d/opengl/OGLSurfaceData.class" >>$(HEADLESS_CLASSLIST) - - -$(TOTAL_HEADLESS_JAR_FILELIST): $(JARREORDER_JARFILE) $(NOT_HEADLESS_RT_JAR_LIST) - $(prep-target) - $(RM) $@.temp - $(CD) $(CLASSBINDIR) ; \ - $(BOOT_JAVA_CMD) -jar $(JARREORDER_JARFILE) \ - -o $@.temp - $(NOT_HEADLESS_RT_JAR_LIST) . -# Add on the explicitly included class files from the otherwise excluded packages - $(CAT) $(HEADLESS_CLASSLIST) >> $@.temp - $(MV) $@.temp $@ - @$(CD) $(CLASSBINDIR); $(java-vm-cleanup) - -# Create the headless rt.jar file list & non-class files list -MakeHeadlessJarFileList: $(TOTAL_HEADLESS_JAR_FILELIST) $(JARSPLIT_JARFILE) - @$(RM) $(HEADLESS_RT_JAR_FILELIST) $(RES_JAR_FILELIST) - $(BOOT_JAVA_CMD) -jar $(JARSPLIT_JARFILE) $(TOTAL_HEADLESS_JAR_FILELIST) \ - -o $(HEADLESS_RT_JAR_FILELIST) $(RES_JAR_FILELIST) - @$(java-vm-cleanup) - -# Create headless rt.jar -HL_RT_JAR=$(ABS_TEMPDIR)/rt-hl-orig.jar -$(HL_RT_JAR): MakeHeadlessJarFileList $(RT_JAR_MANIFEST_FILE) - $(prep-target) - $(CD) $(CLASSBINDIR) ; \ - $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS) $(RT_JAR_MANIFEST_FILE) $@ @$(HEADLESS_RT_JAR_FILELIST) \ - $(JAR_JFLAGS) - @$(CD) $(CLASSBINDIR); $(java-vm-cleanup) - - -# -# Produce a reduced Headful JRE for Embedded Devices -# -# The deployment binaries are added during the deployment build process -# - -# Binaries that don't get included in reduced jre image bin directory -NOT_REDUCEDJRE_BIN = \ - java_vm \ - kinit \ - klist \ - ktab \ - orbd \ - policytool \ - rmid \ - rmiregistry \ - servertool \ - tnameserv \ - pack200 \ - unpack200 - -# jars/resources/libs that don't get included in reduced jre image lib directory -NOT_REDUCEDJRE_LIB = \ - charsets.jar \ - ext/dnsns.jar \ - ext/localedata.jar \ - $(LIBARCH)/client/classes.jsa \ - $(LIBARCH)/libjavaplugin_jni.so \ - $(LIBARCH)/libjavaplugin_nscp_gcc29.so \ - $(LIBARCH)/libjavaplugin_nscp.so \ - $(LIBARCH)/libjavaplugin_oji.so - -# JRE docs that don't get included in reduced jre image top directory -NOT_REDUCEDJRE_DOC = \ - Welcome.html - -reduced-image-jre:: - @$(ECHO) Starting to Produce Reduced JRE - @# - @# First make a copy of the full JRE - @# - $(RM) -r $(JRE_REDUCED_IMAGE_DIR) - $(MKDIR) -p $(JRE_REDUCED_IMAGE_DIR) - $(CD) $(JRE_IMAGE_DIR); \ - $(TAR) cf - . | ($(CD) $(JRE_REDUCED_IMAGE_DIR); $(TAR) xf - ); - - @# - @# Remove all of the files that are not needed for the - @# reduced JRE - @# - for l in $(NOT_REDUCEDJRE_BIN) ; do \ - $(RM) $(JRE_REDUCED_IMAGE_DIR)/bin/$$l ; \ - done - for l in $(NOT_REDUCEDJRE_LIB) ; do \ - $(RM) $(JRE_REDUCED_IMAGE_DIR)/lib/$$l ; \ - done - for l in $(NOT_REDUCEDJRE_DOC) ; do \ - $(RM) $(JRE_REDUCED_IMAGE_DIR)/$$l ; \ - done - - @# Remove misc. other files - $(RM) -r $(JRE_REDUCED_IMAGE_DIR)/man - $(RM) -f $(JRE_REDUCED_IMAGE_DIR)/CHANGES - - @$(ECHO) Done Creating Reduced JRE - -# -# Produce a reduced Headless JRE -# -reduced-headless-image-jre:: $(RT_JAR) $(RESOURCES_JAR) $(BUILD_META_INDEX) $(HL_RT_JAR) - @$(ECHO) Starting to Produce Reduced Headless JRE - @# - @# First make a copy of the reduced JRE we just built - @# - $(RM) -r $(JRE_REDUCED_HEADLESS_IMAGE_DIR) - $(MKDIR) -p $(JRE_REDUCED_HEADLESS_IMAGE_DIR) - $(CD) $(JRE_REDUCED_IMAGE_DIR); \ - $(TAR) cf - . | ($(CD) $(JRE_REDUCED_HEADLESS_IMAGE_DIR); $(TAR) xf - ); - - @# Replace the full rt.jar with the headless rt.jar - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/rt.jar - $(CP) $(HL_RT_JAR) $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/rt.jar - - @# - @# Remove all of the files that are not needed for the - @# reduced Headless JRE - @# - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/$(LIBARCH)/gtkhelper - $(RM) $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/$(LIBARCH)/libjsoundalsa.so - $(RM) -r $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/audio - $(RM) -fr $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/applet - $(RM) $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/$(LIBARCH)/awt_robot - $(RM) $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/$(LIBARCH)/libawt_xawt.so - $(RM) -r $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/$(LIBARCH)/libsplashscreen.so - @# Remove oblique fonts and reduce font support to LucidaSansRegular only - $(RM) -fr $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/oblique-fonts - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/LucidaBrightDemiBold.ttf - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/LucidaBrightDemiItalic.ttf - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/LucidaBrightItalic.ttf - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/LucidaBrightRegular.ttf - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/LucidaSansDemiBold.ttf - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/LucidaTypewriterBold.ttf - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/LucidaTypewriterRegular.ttf - -ifeq ($(PLATFORM), linux) -# put out minimal fonts.dir file for the remaining font - $(RM) -f $(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/fonts.dir - $(ECHO) 6>$(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/fonts.dir - $(ECHO) "LucidaSansRegular.ttf -b&h-lucidasans-medium-r-normal-sans-0-0-0-0-p-0-iso8859-1">>$(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/fonts.dir - $(ECHO) "LucidaSansRegular.ttf -b&h-lucidasans-medium-r-normal-sans-0-0-0-0-p-0-iso8859-2">>$(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/fonts.dir - $(ECHO) "LucidaSansRegular.ttf -b&h-lucidasans-medium-r-normal-sans-0-0-0-0-p-0-iso8859-4">>$(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/fonts.dir - $(ECHO) "LucidaSansRegular.ttf -b&h-lucidasans-medium-r-normal-sans-0-0-0-0-p-0-iso8859-5">>$(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/fonts.dir - $(ECHO) "LucidaSansRegular.ttf -b&h-lucidasans-medium-r-normal-sans-0-0-0-0-p-0-iso8859-7">>$(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/fonts.dir - $(ECHO) "LucidaSansRegular.ttf -b&h-lucidasans-medium-r-normal-sans-0-0-0-0-p-0-iso8859-9">>$(JRE_REDUCED_HEADLESS_IMAGE_DIR)/lib/fonts/fonts.dir - -endif # Linux - - @# - @# all done with JRE reduced headless image - @# - - @$(ECHO) Done Creating Reduced Headless JRE - -images-clobber:: - $(RM) -r $(JRE_REDUCED_IMAGE_DIR) - $(RM) -r $(JRE_REDUCED_HEADLESS_IMAGE_DIR) - -.PHONY: reduced-image-jre reduced-headless-image-jre - -endif # JAVASE_EMBEDDED - diff --git a/jdk/makefiles/common/Release-macosx.gmk b/jdk/makefiles/common/Release-macosx.gmk deleted file mode 100644 index f56370f3ca1..00000000000 --- a/jdk/makefiles/common/Release-macosx.gmk +++ /dev/null @@ -1,75 +0,0 @@ -# -# Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -MANBASEDIRS=$(JDK_TOPDIR)/src/bsd/doc $(IMPORTDOCDIR) -MAN1SUBDIR = man -JA_DIRNAME=ja_JP.UTF-8 - -# Defines the release targets for Mac OS X build products - -JDK_BUNDLE_DIR = $(ABS_OUTPUTDIR)/j2sdk-bundle/jdk$(JDK_VERSION).jdk/Contents -JRE_BUNDLE_DIR = $(ABS_OUTPUTDIR)/j2re-bundle/jre$(JDK_VERSION).jre/Contents - -MACOSX_SRC = $(JDK_TOPDIR)/src/macosx - -BUNDLE_ID ?= net.java.openjdk -BUNDLE_ID_JRE ?= $(BUNDLE_ID).jre -BUNDLE_ID_JDK ?= $(BUNDLE_ID).jdk - -BUNDLE_NAME ?= OpenJDK $(JDK_MINOR_VERSION) -BUNDLE_NAME_JRE ?= $(BUNDLE_NAME) -BUNDLE_NAME_JDK ?= $(BUNDLE_NAME) - -BUNDLE_INFO ?= OpenJDK ($(JDK_VERSION)) -BUNDLE_INFO_JRE ?= $(BUNDLE_INFO) -BUNDLE_INFO_JDK ?= $(BUNDLE_INFO) - -BUNDLE_PLATFORM_VERSION ?= $(JDK_MAJOR_VERSION).$(JDK_MINOR_VERSION) -BUNDLE_VERSION ?= $(JDK_VERSION) -BUNDLE_VENDOR ?= UNDEFINED - -jre-bundle-setup: - $(RM) -r $(JRE_BUNDLE_DIR) - -jdk-bundle-setup: - $(RM) -r $(JDK_BUNDLE_DIR) - -jre-bundle-files: - $(MKDIR) -p $(JRE_BUNDLE_DIR)/MacOS - ln -s ../Home/lib/jli/libjli.dylib $(JRE_BUNDLE_DIR)/MacOS/ - $(CP) -r $(JRE_IMAGE_DIR) $(JRE_BUNDLE_DIR)/Home - $(SED) -e "s/@@ID@@/$(BUNDLE_ID_JRE)/g" -e "s/@@NAME@@/$(BUNDLE_NAME_JRE)/g" -e "s/@@INFO@@/$(BUNDLE_INFO_JRE)/g" -e "s/@@PLATFORM_VERSION@@/$(BUNDLE_PLATFORM_VERSION)/g" -e "s/@@VERSION@@/$(BUNDLE_VERSION)/g" -e "s/@@VENDOR@@/$(BUNDLE_VENDOR)/g" < $(MACOSX_SRC)/bundle/JRE-Info.plist > $(JRE_BUNDLE_DIR)/Info.plist - /usr/bin/SetFile -a B $(JRE_BUNDLE_DIR)/../ - -jdk-bundle-files: - $(MKDIR) -p $(JDK_BUNDLE_DIR)/MacOS - ln -s ../Home/jre/lib/jli/libjli.dylib $(JDK_BUNDLE_DIR)/MacOS/ - $(CP) -r $(JDK_IMAGE_DIR) $(JDK_BUNDLE_DIR)/Home - $(SED) -e "s/@@ID@@/$(BUNDLE_ID_JDK)/g" -e "s/@@NAME@@/$(BUNDLE_NAME_JDK)/g" -e "s/@@INFO@@/$(BUNDLE_INFO_JDK)/g" -e "s/@@PLATFORM_VERSION@@/$(BUNDLE_PLATFORM_VERSION)/g" -e "s/@@VERSION@@/$(BUNDLE_VERSION)/g" -e "s/@@VENDOR@@/$(BUNDLE_VENDOR)/g" < $(MACOSX_SRC)/bundle/JDK-Info.plist > $(JDK_BUNDLE_DIR)/Info.plist - /usr/bin/SetFile -a B $(JDK_BUNDLE_DIR)/../ - -EXTRA_IMAGE_TARGETS += jre-bundle-setup jdk-bundle-setup jre-bundle-files jdk-bundle-files - -.PHONY: $(EXTRA_JRE_TARGETS) $(EXTRA_IMAGE_TARGETS) diff --git a/jdk/makefiles/common/Release.gmk b/jdk/makefiles/common/Release.gmk deleted file mode 100644 index 74c84cb4712..00000000000 --- a/jdk/makefiles/common/Release.gmk +++ /dev/null @@ -1,1401 +0,0 @@ -# -# Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -include $(JDK_TOPDIR)/makefiles/docs/CORE_PKGS.gmk -include $(JDK_TOPDIR)/makefiles/docs/NON_CORE_PKGS.gmk -include $(JDK_TOPDIR)/makefiles/Tools.gmk - -# What jdk version are we building -THIS_JDK_VERSION := $(JDK_MAJOR_VERSION).$(JDK_MINOR_VERSION).$(JDK_MICRO_VERSION) - -# -# Perform release engineering tasks. -# -# images An image is what the product looks like when it is -# installed. -# - -IMAGE_BINDIR = bin - -# The compiler should not issue a "Proprietary" warning when compiling -# classes in the com.sun.java.swing.plaf packages, since we've always -# allowed, and even advocated, extending them (see bug 6476749). -# -# This approach is NOT to be used as a general purpose way to avoid such -# compiler warnings for non-core packages. The correct way is to document -# the packages in NON_CORE_PKGS.gmk, and include them in the NON_CORE_PKGS -# definition. -# -# Swing has taken this approach only as a temporary measure to avoid -# the compiler warnings until we can properly document these packages. -# This is covered under 6491853. -EXCLUDE_PROPWARN_PKGS = com.sun.java.swing.plaf.windows \ - com.sun.java.swing.plaf.motif \ - com.sun.java.swing.plaf.gtk - -# -# Include the exported private packages in ct.sym. -# This is an interim solution until the ct.sym is replaced -# with a new module system (being discussed for JDK 8). -# -EXPORTED_PRIVATE_PKGS = com.sun.servicetag \ - com.oracle.net \ - com.oracle.nio - -# 64-bit solaris has a few special cases. We define the variable -# SOLARIS64 for use in this Makefile to easily test those cases -ifeq ($(PLATFORM), solaris) - ifeq ($(ARCH_DATA_MODEL), 64) - SOLARIS64 = true - IMAGE_BINDIR = bin/$(ARCH) - endif -endif - -JTG_DOCS = $(JDK_TOPDIR)/src/solaris/doc - -ifeq ($(PLATFORM), macosx) - include $(JDK_TOPDIR)/make/common/Release-$(PLATFORM).gmk -endif - -# The base names of all the license and document files for the jdk and jre -# (These files get placed in the jdk and jre install images) -ifdef OPENJDK - # Where to find these files - SHARE_JDK_DOC_SRC = $(JDK_TOPDIR) - SHARE_JRE_DOC_SRC = $(JDK_TOPDIR) - # Same files for jdk and jre, no name changes - IMAGE_DOCLIST_JDK = LICENSE ASSEMBLY_EXCEPTION THIRD_PARTY_README - IMAGE_DOCLIST_JDK_DEMOS_AND_SAMPLES = - IMAGE_DOCLIST_JRE = LICENSE ASSEMBLY_EXCEPTION THIRD_PARTY_README -else - # make/closed/common/Defs.gmk for closed location of SHARE_JDK_DOC_SRC - - IMAGE_DOCLIST_JDK = COPYRIGHT README.html LICENSE THIRDPARTYLICENSEREADME.txt - IMAGE_DOCLIST_JDK_DEMOS_AND_SAMPLES = demo/DEMOS_LICENSE sample/SAMPLES_LICENSE - IMAGE_DOCLIST_JRE = COPYRIGHT Welcome.html LICENSE THIRDPARTYLICENSEREADME.txt - ifeq ($(PLATFORM), windows) - IMAGE_DOCLIST_JRE += README.txt - else - IMAGE_DOCLIST_JRE += README - endif -endif - -# Paths to these files we need -JDK_DOCFILES = $(IMAGE_DOCLIST_JDK:%=$(JDK_IMAGE_DIR)/%) -JRE_DOCFILES = $(IMAGE_DOCLIST_JRE:%=$(JRE_IMAGE_DIR)/%) -JDK_DEMOS_AND_SAMPLES_DOCFILES = $(IMAGE_DOCLIST_JDK_DEMOS_AND_SAMPLES:%=$(JDK_IMAGE_DIR)/%) - -# absolute directory names: note, these must exist prior to build -# time - they are created in the main Makefile. -JRE_IMAGE_BINDIR = $(JRE_IMAGE_DIR)/bin - -MAINMANIFEST = $(JDK_TOPDIR)/make/tools/manifest.mf -BEANMANIFEST = $(JDK_TOPDIR)/make/javax/swing/beaninfo/manifest - -# -# Man pages -# - -JRE_MAN_PAGES = \ - java.1 \ - keytool.1 \ - orbd.1 \ - pack200.1 \ - policytool.1 \ - rmid.1 \ - rmiregistry.1 \ - servertool.1 \ - tnameserv.1 \ - unpack200.1 - -ifndef OPENJDK - JRE_MAN_PAGES += javaws.1 -endif - -JDK_MAN_PAGES = \ - $(JRE_MAN_PAGES) \ - appletviewer.1 \ - extcheck.1 \ - idlj.1 \ - jar.1 \ - jarsigner.1 \ - javac.1 \ - javadoc.1 \ - javah.1 \ - javap.1 \ - jconsole.1 \ - jdb.1 \ - jhat.1 \ - jinfo.1 \ - jmap.1 \ - jps.1 \ - jrunscript.1 \ - jsadebugd.1 \ - jstack.1 \ - jstat.1 \ - jstatd.1 \ - native2ascii.1 \ - rmic.1 \ - schemagen.1 \ - serialver.1 \ - wsgen.1 \ - wsimport.1 \ - xjc.1 - -ifeq ($(PLATFORM), solaris) - MANBASEDIRS=$(JDK_TOPDIR)/src/solaris/doc $(IMPORTDOCDIR) - MAN1SUBDIR=sun/man/man1 -endif # solaris - -ifeq ($(PLATFORM), linux) - MANBASEDIRS=$(JDK_TOPDIR)/src/linux/doc $(IMPORTDOCDIR) - MAN1SUBDIR=man - JA_DIRNAME=ja_JP.UTF-8 -endif # linux - -define copy-man-pages -$(MKDIR) -p $1/man/man1 -for manbase in $(MANBASEDIRS:%=%/$(MAN1SUBDIR)) ; do \ - for manpage in $2; do \ - if [ -f $${manbase}/$${manpage} ] ; then \ - $(CP) $${manbase}/$${manpage} $1/man/man1 ; \ - for ja_encoding in $(JA_TARGET_ENCODINGS); do \ - ja_dir="ja"; \ - if [ "$${ja_encoding}" != "$(JA_SOURCE_ENCODING)" ]; then \ - ja_dir="ja_JP.$${ja_encoding}"; \ - fi; \ - $(MKDIR) -p $1/man/$${ja_dir}/man1; \ - $(CAT) $${manbase}/ja/$${manpage} \ - | $(NATIVE2ASCII) -encoding $(JA_SOURCE_ENCODING) \ - | $(SED) 's/@@VERSION@@/$(THIS_JDK_VERSION)/g' \ - | $(NATIVE2ASCII) -reverse -encoding $${ja_encoding} \ - > $1/man/$${ja_dir}/man1/$${manpage}; \ - done; \ - fi; \ - done; \ -done -$(java-vm-cleanup) -if [ "$(JA_DIRNAME)" != "" ] ; then \ - $(CD) $1/man && $(RM) ja && $(LN) -s $(JA_DIRNAME) ja; \ -fi -endef - - -# no compression unless requested -ifndef COMPRESS_JARS - CREATE_JAR_OPTS = c0mf - CREATE_JAR_OPTS_NOMANIFEST = c0f -else - CREATE_JAR_OPTS = cmf - CREATE_JAR_OPTS_NOMANIFEST = cf -endif - -# -# Targets. -# -INITIAL_IMAGE_JRE=initial-image-jre -INITIAL_IMAGE_JDK=initial-image-jdk -ifeq ($(PLATFORM), solaris) - ifeq ($(ARCH_DATA_MODEL), 64) - INITIAL_IMAGE_JRE=initial-image-jre-sol64 - INITIAL_IMAGE_JDK=initial-image-jdk-sol64 - endif -endif - -images images-clobber \ -initial-image-jre initial-image-jdk \ -initial-image-jre-sol64 initial-image-jdk-sol64 \ -trim-image-jre trim-image-jdk \ -identify-image-jre identify-image-jdk \ -process-image-jre process-image-jdk \ -sec-files sec-files-win jgss-files :: - $(ECHO) ">>>Making "$@" @ `$(DATE)` ..." - -install: images - -# Order is important here, trim jre after jdk image is created -ifeq ($(PLATFORM), macosx) - -images:: $(INITIAL_IMAGE_JRE) $(EXTRA_JRE_TARGETS) $(INITIAL_IMAGE_JDK) \ - trim-image-jre trim-image-jdk \ - identify-image-jre identify-image-jdk \ - process-image-jre process-image-jdk sec-files sec-files-win jgss-files \ - $(EXTRA_IMAGE_TARGETS) -else - -images:: $(INITIAL_IMAGE_JRE) $(INITIAL_IMAGE_JDK) \ - trim-image-jre trim-image-jdk \ - identify-image-jre identify-image-jdk \ - process-image-jre process-image-jdk sec-files sec-files-win jgss-files -endif - -# Don't use these -image-jre:: initial-image-jre trim-image-jre identify-image-jre process-image-jre -image-jdk:: initial-image-jdk trim-image-jdk identify-image-jdk process-image-jdk - -# -# Sources we ship in the SDK. -# -SOURCES = \ - java/applet \ - java/awt \ - java/beans \ - java/io \ - java/lang \ - java/math \ - java/net \ - java/nio \ - java/rmi \ - java/security \ - java/sql \ - java/text \ - java/util \ - com/sun/corba \ - com/sun/image/codec/jpeg \ - com/sun/imageio \ - com/sun/java/swing \ - com/sun/javadoc \ - com/sun/jmx \ - com/sun/source \ - com/sun/naming \ - com/sun/security/auth \ - com/sun/security/jgss \ - javax/accessibility \ - javax/annotation \ - javax/script \ - javax/imageio \ - javax/lang \ - javax/management \ - javax/naming \ - javax/print \ - javax/rmi \ - javax/security \ - javax/sound \ - javax/sql \ - javax/swing \ - javax/tools \ - javax/xml \ - com/sun/org/apache \ - com/sun/java_cup \ - com/sun/jlex \ - org/ietf \ - org/omg \ - org/w3c/dom \ - org/xml/sax \ - sunw -# -# Directories where sources may be found. If a file with the same path -# name exists in more than one of these places, the one found last on this -# list wins. -# -SOURCE_DIRS = $(SHARE_SRC)/classes $(PLATFORM_SRC)/classes -SOURCE_DIRS += $(GENSRCDIR) -SOURCE_DIRS += $(IMPORTSRCDIR) -SOURCE_DIRS += $(JDK_OUTPUTDIR)/gendocsrc_rmic -ifndef OPENJDK - SOURCE_DIRS += $(CLOSED_SRC)/share/classes -endif - - -# -# Specific files and directories that will be filtered out from above areas. -# -SOURCE_FILTERs = $(SCM_DIRs) ',*' -SOURCE_FILES_filter = $(SOURCE_FILTERs:%=-name % -prune -o) - -# -# Bug 4249883 - excluding some unnecessary packages from com.sun.tools -# -# Bug 5008685 - exclude jconsole from sun/tools -# -TOOLS = \ - META-INF/services/com.sun.jdi.connect.Connector \ - META-INF/services/com.sun.jdi.connect.spi.TransportService \ - sun/tools/asm \ - sun/tools/jar \ - sun/tools/java \ - sun/tools/javac \ - sun/tools/jcmd \ - sun/tools/jps \ - sun/tools/jstat \ - sun/tools/jstatd \ - sun/tools/native2ascii \ - sun/tools/serialver \ - sun/tools/tree \ - sun/tools/util \ - sun/security/tools/JarBASE64Encoder.class \ - sun/security/tools/JarSigner.class \ - sun/security/tools/JarSignerParameters.class \ - sun/security/tools/JarSignerResources.class \ - sun/security/tools/JarSignerResources_ja.class \ - sun/security/tools/JarSignerResources_zh_CN.class \ - sun/security/tools/SignatureFile\$$Block.class \ - sun/security/tools/SignatureFile.class \ - sun/security/tools/TimestampedSigner.class \ - sun/rmi/rmic \ - sun/applet \ - sun/jvmstat \ - com/sun/javadoc \ - com/sun/jdi \ - com/sun/jarsigner \ - com/sun/source \ - com/sun/tools/classfile \ - com/sun/tools/doclets \ - com/sun/tools/example/debug/expr \ - com/sun/tools/example/debug/tty \ - com/sun/tools/extcheck \ - com/sun/tools/hat \ - com/sun/tools/javac \ - com/sun/tools/javadoc \ - com/sun/tools/javah \ - com/sun/tools/javap \ - com/sun/tools/corba \ - com/sun/tools/internal/xjc \ - com/sun/tools/internal/ws \ - META-INF/services/com.sun.tools.internal.ws.wscompile.Plugin \ - META-INF/services/com.sun.tools.internal.xjc.Plugin \ - com/sun/istack/internal/tools \ - com/sun/tools/internal/jxc/ap \ - com/sun/tools/internal/ws/wscompile/plugin/at_generated \ - com/sun/codemodel \ - com/sun/tools/internal/jxc \ - com/sun/xml/internal/rngom \ - com/sun/xml/internal/xsom \ - org/relaxng/datatype \ - com/sun/xml/internal/dtdparser \ - com/sun/tools/jdi \ - com/sun/tools/script/shell \ - META-INF/services/com.sun.tools.attach.spi.AttachProvider \ - com/sun/tools/attach \ - sun/tools/attach \ - sun/tools/jstack \ - sun/tools/jinfo \ - sun/tools/jmap - -# classes that go into jfr.jar -JFR_CLASSES_DIRS= \ - com/oracle/jrockit/jfr \ - oracle/jrockit/jfr - -# classes that go into jsse.jar -JSSE_CLASSES_DIRS = \ - sun/security/provider/Sun.class \ - sun/security/rsa/SunRsaSign.class \ - sun/security/ssl \ - com/sun/net/ssl/internal/ssl - -# classes that go into dnsns.jar -DNS_CLASSES_DIRS = \ - sun/net/spi/nameservice/dns \ - META-INF/services/sun.net.spi.nameservice.NameServiceDescriptor - -# classes and files that go into localedata.jar -LOCALEDATA_JAR_DIRS = \ - sun/text/resources/*_ar* \ - sun/text/resources/*_hi* \ - sun/text/resources/*_iw* \ - sun/text/resources/*_iw* \ - sun/text/resources/*_ja* \ - sun/text/resources/*_ko* \ - sun/text/resources/*_th.* \ - sun/text/resources/*_th_* \ - sun/text/resources/*_vi* \ - sun/text/resources/*_zh* \ - sun/text/resources/*Data_th \ - sun/text/resources/thai_dict \ - sun/util/resources/*_ar* \ - sun/util/resources/*_hi* \ - sun/util/resources/*_iw* \ - sun/util/resources/*_iw* \ - sun/util/resources/*_ja* \ - sun/util/resources/*_ko* \ - sun/util/resources/*_th_* \ - sun/util/resources/*_th.* \ - sun/util/resources/*_vi* \ - sun/util/resources/*_zh* - -LOCALEDATA_JAR_FILES = $(foreach i,$(LOCALEDATA_JAR_DIRS), $(wildcard $(CLASSBINDIR)/$i)) - -# files under $(OUTPUTDIR) that need to go into sec-bin.zip for builds -# where the corresponding sources are not available -SEC_FILES_DIRS = \ - classes/javax/net \ - classes/javax/security/cert \ - classes/com/sun/net/ssl \ - classes/com/sun/security/cert \ - classes/sun/net/www/protocol/https \ - classes/sun/security/pkcs12 \ - classes/sun/security/ssl \ - classes/sun/security/krb5/*.class \ - classes/sun/security/krb5/internal/*.class \ - classes/sun/security/krb5/internal/ccache \ - classes/sun/security/krb5/internal/crypto \ - classes/sun/security/krb5/internal/ktab \ - classes/sun/security/krb5/internal/rcache \ - classes/sun/security/krb5/internal/util \ - classes/sun/security/jgss/spi/GSSContextSpi.class - -# files under $(OUTPUTDIR) that need to go into sec-windows-win.zip for builds -# where the corresponding sources are not available -SEC_FILES_WIN_DIRS = \ - classes/sun/security/krb5/internal/tools - -# files under $(BINDIR) that need to go into jgss_files.zip for builds -# where the corresponding sources are not available -JGSS_FILES_DIRS = \ - bin/w2k_lsa_auth.dll \ - bin/w2k_lsa_auth.map \ - bin/w2k_lsa_auth.pdb - -# The following get removed from the SDK image. -NOTJDKTOOLS = \ - java_vm - -# The following get removed from the JRE after the bulk-copy of BINDIR... -NOTJRETOOLS = \ - appletviewer$(EXE_SUFFIX) \ - extcheck$(EXE_SUFFIX) \ - idlj$(EXE_SUFFIX) \ - jar$(EXE_SUFFIX) \ - jarsigner$(EXE_SUFFIX) \ - java-rmi.cgi \ - javac$(EXE_SUFFIX) \ - javadoc$(EXE_SUFFIX) \ - javah$(EXE_SUFFIX) \ - javap$(EXE_SUFFIX) \ - jcmd$(EXE_SUFFIX) \ - jdb$(EXE_SUFFIX) \ - jps$(EXE_SUFFIX) \ - jrunscript$(EXE_SUFFIX) \ - jstat$(EXE_SUFFIX) \ - jstatd$(EXE_SUFFIX) \ - jstack$(EXE_SUFFIX) \ - packagebean$(SCRIPT_SUFFIX) \ - rmic$(EXE_SUFFIX) \ - serialver$(EXE_SUFFIX) \ - unregbean$(EXE_SUFFIX) \ - jconsole$(EXE_SUFFIX) \ - jinfo$(EXE_SUFFIX) \ - jmap$(EXE_SUFFIX) \ - native2ascii$(EXE_SUFFIX) \ - xjc$(EXE_SUFFIX) \ - wsgen$(EXE_SUFFIX) \ - wsimport$(EXE_SUFFIX) \ - schemagen$(EXE_SUFFIX) \ - jsadebugd$(EXE_SUFFIX) \ - jhat$(EXE_SUFFIX) - -# The following get removed from the JRE after the bulk-copy of LIBDIR... -NOTJRELIBS = tools.jar \ - jconsole.jar \ - dt.jar - -ifeq ($(INCLUDE_SA), true) - NOTJRELIBS += sa-jdi.jar - - # The following get removed from the JRE after the bulk-copy of LIBDIR... - NOTJRE_SHARED_LIBS = $(SALIB_NAME) -else - NOTJRE_SHARED_LIBS = -endif - -# Attach library is JDK only -NOTJRE_SHARED_LIBS += $(LIB_PREFIX)attach.$(LIBRARY_SUFFIX) - -# -###### RULES - -# Processing license files from source area to image area -# These will be modified to have the platform specific EOL chars. -define process-doc-file -$(prep-target) -$(SED) 's/$$//g' $< > $@ -$(CHMOD) 444 $@ -endef - -# JDK files -$(JDK_IMAGE_DIR)/%: $(SHARE_JDK_DOC_SRC)/% - $(process-doc-file) - -$(JDK_IMAGE_DIR)/demo/DEMOS_LICENSE: $(SHARE_JDK_DOC_SRC)/DEMOS_LICENSE - $(process-doc-file) - -$(JDK_IMAGE_DIR)/sample/SAMPLES_LICENSE: $(SHARE_JDK_DOC_SRC)/SAMPLES_LICENSE - $(process-doc-file) - -# JRE files -$(JRE_IMAGE_DIR)/%: $(SHARE_JRE_DOC_SRC)/% - $(process-doc-file) -ifeq ($(PLATFORM), windows) -$(JRE_IMAGE_DIR)/README.txt: $(SHARE_JRE_DOC_SRC)/README - $(process-doc-file) -endif - - -###################################################### -# List of directories in classes directory that should NOT be in rt.jar -###################################################### - -NOT_RT_JAR_LIST = $(IMAGES_OUTPUTDIR)/tmp/not_rt_jar.list - -$(NOT_RT_JAR_LIST): FRC - $(prep-target) - $(ECHO) "#\n" >> $@ - $(ECHO) "# List of subdirectories not in include in rt.jar" >> $@ - $(ECHO) "# Directories must contain trailing '/'." >> $@ - $(ECHO) "com/sun/javadoc/" >> $@ - $(ECHO) "com/sun/jdi/" >> $@ - $(ECHO) "com/sun/jarsigner/" >> $@ - $(ECHO) "com/sun/source/" >> $@ - $(ECHO) "com/sun/istack/internal/tools/" >> $@ - $(ECHO) "META-INF/services/com.sun.jdi.connect.Connector" >> $@ - $(ECHO) "META-INF/services/com.sun.jdi.connect.spi.TransportService" >> $@ - $(ECHO) "META-INF/services/com.sun.tools.xjc.Plugin" >> $@ - $(ECHO) "com/sun/tools/" >> $@ - $(ECHO) "sun/jvmstat/" >> $@ - $(ECHO) "sun/nio/cs/ext/" >> $@ - $(ECHO) "sun/awt/HKSCS.class" >> $@ - $(ECHO) "sun/awt/motif/X11GB2312\$$Decoder.class" >> $@ - $(ECHO) "sun/awt/motif/X11GB2312\$$Encoder.class" >> $@ - $(ECHO) "sun/awt/motif/X11GB2312.class" >> $@ - $(ECHO) "sun/awt/motif/X11GBK\$$Encoder.class" >> $@ - $(ECHO) "sun/awt/motif/X11GBK.class" >> $@ - $(ECHO) "sun/awt/motif/X11KSC5601\$$Decoder.class" >> $@ - $(ECHO) "sun/awt/motif/X11KSC5601\$$Encoder.class" >> $@ - $(ECHO) "sun/awt/motif/X11KSC5601.class" >> $@ - $(ECHO) "META-INF/services/java.nio.charset.spi.CharsetProvider" >> $@ - $(ECHO) "sun/rmi/rmic/" >> $@ - $(ECHO) "sun/tools/asm/" >> $@ - $(ECHO) "sun/tools/java/" >> $@ - $(ECHO) "sun/tools/javac/" >> $@ - $(ECHO) "com/sun/tools/classfile/" >> $@ - $(ECHO) "com/sun/tools/javap/" >> $@ - $(ECHO) "sun/tools/jcmd/" >> $@ - $(ECHO) "sun/tools/jconsole/" >> $@ - $(ECHO) "sun/tools/jps/" >> $@ - $(ECHO) "sun/tools/jstat/" >> $@ - $(ECHO) "sun/tools/jstatd/" >> $@ - $(ECHO) "sun/tools/native2ascii/" >> $@ - $(ECHO) "sun/tools/serialver/" >> $@ - $(ECHO) "sun/tools/tree/" >> $@ - $(ECHO) "sun/tools/util/" >> $@ - $(ECHO) "sun/security/tools/JarBASE64Encoder.class" >> $@ - $(ECHO) "sun/security/tools/JarSigner.class" >> $@ - $(ECHO) "sun/security/tools/JarSignerParameters.class" >> $@ - $(ECHO) "sun/security/tools/JarSignerResources.class" >> $@ - $(ECHO) "sun/security/tools/JarSignerResources_ja.class" >> $@ - $(ECHO) "sun/security/tools/JarSignerResources_zh_CN.class" >> $@ - $(ECHO) "sun/security/tools/SignatureFile\$$Block.class" >> $@ - $(ECHO) "sun/security/tools/SignatureFile.class" >> $@ - $(ECHO) "sun/security/tools/TimestampedSigner.class" >> $@ - $(ECHO) "sun/security/provider/Sun.class" >> $@ - $(ECHO) "sun/security/rsa/SunRsaSign.class" >> $@ - $(ECHO) "sun/security/ssl/" >> $@ - $(ECHO) "sun/security/pkcs11/" >> $@ - $(ECHO) "sun/security/ec/ECDHKeyAgreement.class" >> $@ - $(ECHO) "sun/security/ec/ECDSASignature.class" >> $@ - $(ECHO) "sun/security/ec/ECKeyPairGenerator.class" >> $@ - $(ECHO) "sun/security/ec/SunEC\$$1.class" >> $@ - $(ECHO) "sun/security/ec/SunEC.class" >> $@ - $(ECHO) "sun/security/ec/SunECEntries.class" >> $@ - $(ECHO) "sun/security/ec/ECDSASignature\$$Raw.class" >> $@ - $(ECHO) "sun/security/ec/ECDSASignature\$$SHA1.class" >> $@ - $(ECHO) "sun/security/ec/ECDSASignature\$$SHA256.class" >> $@ - $(ECHO) "sun/security/ec/ECDSASignature\$$SHA384.class" >> $@ - $(ECHO) "sun/security/ec/ECDSASignature\$$SHA512.class" >> $@ - $(ECHO) "com/sun/net/ssl/internal/ssl/" >> $@ - $(ECHO) "javax/crypto/" >> $@ - $(ECHO) "sun/security/internal/" >> $@ - $(ECHO) "com/sun/crypto/provider/" >> $@ - $(ECHO) "META-INF/services/com.sun.tools.attach.spi.AttachProvider" >> $@ - $(ECHO) "com/sun/tools/attach/" >> $@ - $(ECHO) "org/relaxng/datatype/" >> $@ - $(ECHO) "com/sun/codemodel/" >> $@ - $(ECHO) "com/sun/xml/internal/dtdparser/" >> $@ - $(ECHO) "com/sun/xml/internal/rngom/" >> $@ - $(ECHO) "com/sun/xml/internal/xsom/" >> $@ - $(ECHO) "com/sun/tools/script/shell/" >> $@ - $(ECHO) "sun/tools/attach/" >> $@ - $(ECHO) "sun/tools/jstack/" >> $@ - $(ECHO) "sun/tools/jinfo/" >> $@ - $(ECHO) "sun/tools/jmap/" >> $@ - $(ECHO) "sun/net/spi/nameservice/dns/" >> $@ - $(ECHO) "META-INF/services/sun.net.spi.nameservice.NameServiceDescriptor" >> $@ - $(ECHO) "javax/swing/AbstractButtonBeanInfo.class" >> $@ - $(ECHO) "javax/swing/BoxBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JAppletBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JButtonBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JCheckBoxBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JCheckBoxMenuItemBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JColorChooserBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JComboBoxBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JComponentBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JDesktopPaneBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JDialogBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JEditorPaneBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JFileChooserBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JFormattedTextFieldBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JFrameBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JInternalFrameBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JLabelBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JLayeredPaneBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JListBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JMenuBarBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JMenuBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JMenuItemBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JOptionPaneBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JPanelBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JPasswordFieldBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JPopupMenuBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JProgressBarBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JRadioButtonBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JRadioButtonMenuItemBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JScrollBarBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JScrollPaneBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JSeparatorBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JSliderBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JSpinnerBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JSplitPaneBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JTabbedPaneBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JTableBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JTextAreaBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JTextFieldBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JTextPaneBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JToggleButtonBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JToolBarBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JTreeBeanInfo.class" >> $@ - $(ECHO) "javax/swing/JWindowBeanInfo.class" >> $@ - $(ECHO) "javax/swing/SwingBeanInfoBase.class" >> $@ - $(ECHO) "javax/swing/text/JTextComponentBeanInfo.class" >> $@ - $(ECHO) "sun/swing/BeanInfoUtils.class" >> $@ - $(ECHO) $(patsubst $(CLASSBINDIR)/%,%,$(LOCALEDATA_JAR_FILES)) | $(TR) " " "\n" >> $@ -ifndef OPENJDK -ifndef JAVASE_EMBEDDED - $(ECHO) "com/oracle/jrockit/jfr/" >> $@ - $(ECHO) "com/oracle/jrockit/jfr/client/" >> $@ - $(ECHO) "com/oracle/jrockit/jfr/management/" >> $@ - $(ECHO) "oracle/jrockit/jfr/" >> $@ - $(ECHO) "oracle/jrockit/jfr/events/" >> $@ - $(ECHO) "oracle/jrockit/jfr/openmbean/" >> $@ - $(ECHO) "oracle/jrockit/jfr/parser/" >> $@ - $(ECHO) "oracle/jrockit/jfr/settings/" >> $@ - $(ECHO) "oracle/jrockit/jfr/tools/" >> $@ - $(ECHO) "oracle/jrockit/jfr/util/" >> $@ - $(ECHO) "oracle/jrockit/jfr/util/log/" >> $@ - $(ECHO) "oracle/jrockit/jfr/util/os/" >> $@ - $(ECHO) "oracle/jrockit/jfr/util/text/" >> $@ -endif -endif - (cd $(JDK_OUTPUTDIR)/classes && $(FIND) . -name "_the.*") >> $@ -ifeq ($(PLATFORM), macosx) - $(ECHO) "com/sun/nio/sctp/" >> $@ - $(ECHO) "sun/nio/ch/sctp/" >> $@ - $(ECHO) "sun/jdbc/" >> $@ - $(ECHO) "sun/nio/ch/DevPollArrayWrapper\$$Updator.class" >> $@ - $(ECHO) "sun/nio/ch/DevPollArrayWrapper.class" >> $@ - $(ECHO) "sun/nio/ch/DevPollSelectorImpl.class" >> $@ - $(ECHO) "sun/nio/ch/DevPollSelectorProvider.class" >> $@ - $(ECHO) "sun/nio/ch/EPollArrayWrapper\$$Updator.class" >> $@ - $(ECHO) "sun/nio/ch/EPollArrayWrapper.class" >> $@ - $(ECHO) "sun/nio/ch/EPollSelectorImpl.class" >> $@ - $(ECHO) "sun/nio/ch/EPollSelectorProvider.class" >> $@ -endif - -###################################################### -# List of directories in classes directory that should NOT be in resources.jar -###################################################### - -NOT_RESOURCES_JAR_LIST = $(IMAGES_OUTPUTDIR)/tmp/not_resources_jar.list - -$(NOT_RESOURCES_JAR_LIST): FRC - $(prep-target) - $(ECHO) "#\n" >> $@ - $(ECHO) "# List of subdirectories not in include in resources.jar" >> $@ - $(ECHO) "# Directories must contain trailing '/'." >> $@ - $(ECHO) "javax/swing/beaninfo/" >> $@ - -TOTAL_JAR_EXCLUDE_LIST = $(IMAGES_OUTPUTDIR)/tmp/total_jar_exclude.list - -###################################################### -# Total exclude list -###################################################### - -$(TOTAL_JAR_EXCLUDE_LIST): $(NOT_RT_JAR_LIST) $(NOT_RESOURCES_JAR_LIST) - $(prep-target) - $(ECHO) "#\n" >> $@ - $(ECHO) "# List of subdirectories not in include in resources.jar" >> $@ - $(CAT) $(NOT_RT_JAR_LIST) >>$@ - $(CAT) $(NOT_RESOURCES_JAR_LIST) >>$@ - -# File order list for rt.jar -# - sun.applet is included, till hotjava stops relying on it. -# - sun.tools.jar is included, needs cleanup. -# -REORDER_TEMPDIR=$(IMAGES_OUTPUTDIR)/tmp/reorder -TOTAL_JAR_FILELIST=$(REORDER_TEMPDIR)/file_list - -JARFILELISTS_TEMPDIR=$(IMAGES_OUTPUTDIR)/tmp/jarfilelists -RT_JAR_FILELIST=$(JARFILELISTS_TEMPDIR)/rt_jar_list -RES_JAR_FILELIST=$(JARFILELISTS_TEMPDIR)/resources_jar_list - -$(TOTAL_JAR_FILELIST): $(BUILD_TOOLS) $(TOTAL_JAR_EXCLUDE_LIST) - $(prep-target) - $(RM) $@.temp - ($(CD) $(CLASSBINDIR) && \ - $(TOOL_JARREORDER) \ - -o $@.temp $(ABS_LIBDIR)/classlist $(TOTAL_JAR_EXCLUDE_LIST) . ) - $(MV) $@.temp $@ - ($(CD) $(CLASSBINDIR) && $(java-vm-cleanup)) - -# Create the jfr.jar containing Java Flight Recorder implementation -JFR_JAR= -ifndef OPENJDK -ifndef JAVASE_EMBEDDED -JFR_JAR=$(ABS_TEMPDIR)/jfr-orig.jar -$(JFR_JAR): $(OTHER_JAR_MANIFEST_FILE) - $(prep-target) - $(CD) $(CLASSBINDIR) && \ - $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS) $(OTHER_JAR_MANIFEST_FILE) $@ \ - $(JFR_CLASSES_DIRS) $(BOOT_JAR_JFLAGS) - @$(CD) $(CLASSBINDIR) && $(java-vm-cleanup) -endif -endif - -# Create the rt.jar file list & non-class files list - -$(RT_JAR_FILELIST) + $(RES_JAR_FILELIST): \ - $(TOTAL_JAR_FILELIST) $(BUILD_TOOLS) - $(RM) $(RT_JAR_FILELIST) $(RES_JAR_FILELIST) - $(MKDIR) -p $(JARFILELISTS_TEMPDIR) - $(TOOL_JARSPLIT) \ - $(TOTAL_JAR_FILELIST) \ - -o $(RT_JAR_FILELIST) $(RES_JAR_FILELIST) - $(java-vm-cleanup) - -# Create the manifest file. -RT_JAR_MANIFEST_FILE=$(IMAGES_OUTPUTDIR)/tmp/rt_manifest.tmp -$(RT_JAR_MANIFEST_FILE): $(MAINMANIFEST) $(BEANMANIFEST) - $(prep-target) - $(SED) -e "s#@@RELEASE@@#$(RELEASE)#" \ - -e "s#@@COMPANY_NAME@@#$(COMPANY_NAME)#" \ - $(MAINMANIFEST) >> $@ - $(ECHO) >> $@ - $(CAT) $(BEANMANIFEST) >> $@ - -OTHER_JAR_MANIFEST_FILE=$(IMAGES_OUTPUTDIR)/tmp/other_manifest.tmp -$(OTHER_JAR_MANIFEST_FILE): $(MAINMANIFEST) - $(prep-target) - $(SED) -e "s#@@RELEASE@@#$(RELEASE)#" \ - -e "s#@@COMPANY_NAME@@#$(COMPANY_NAME)#" \ - $(MAINMANIFEST) >> $@ - -# Create resources.jar containing non-class files -RESOURCES_JAR=$(IMAGES_OUTPUTDIR)/tmp/resources-orig.jar -$(RESOURCES_JAR): $(RES_JAR_FILELIST) $(OTHER_JAR_MANIFEST_FILE) - $(prep-target) - $(CD) $(CLASSBINDIR) && \ - $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS) $(OTHER_JAR_MANIFEST_FILE) $@ \ - @$(RES_JAR_FILELIST) $(BOOT_JAR_JFLAGS) - $(CD) $(CLASSBINDIR) && $(java-vm-cleanup) - -# Create jsse.jar containing SunJSSE implementation classes -JSSE_JAR=$(IMAGES_OUTPUTDIR)/tmp/jsse-orig.jar -$(JSSE_JAR): $(OTHER_JAR_MANIFEST_FILE) - $(prep-target) - $(CD) $(CLASSBINDIR) && \ - $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS) $(OTHER_JAR_MANIFEST_FILE) $@ \ - $(JSSE_CLASSES_DIRS) $(BOOT_JAR_JFLAGS) - @$(CD) $(CLASSBINDIR) && $(java-vm-cleanup) - -# Create dnsns.jar -# Create without manifest for now to not differ with old buildsystem. -DNS_JAR=$(IMAGES_OUTPUTDIR)/tmp/dns-orig.jar -$(DNS_JAR): $(OTHER_JAR_MANIFEST_FILE) - $(prep-target) - $(CD) $(CLASSBINDIR) && \ - $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS_NOMANIFEST) $@ \ - $(DNS_CLASSES_DIRS) $(BOOT_JAR_JFLAGS) - @$(CD) $(CLASSBINDIR) && $(java-vm-cleanup) - -# Create localedata.jar containing localedata for non european languages -LOCALEDATA_JAR=$(IMAGES_OUTPUTDIR)/localedata-orig.jar -$(LOCALEDATA_JAR): $(LOCALEDATA_JAR_FILES) - $(prep-target) -# Create without manifest for now to not differ with old buildsystem. -# $(CD) $(CLASSBINDIR) && \ -# $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS) $(OTHER_JAR_MANIFEST_FILE) $@ \ -# $(LOCALEDATA_JAR_DIRS) $(BOOT_JAR_JFLAGS) - $(CD) $(CLASSBINDIR) && \ - $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS_NOMANIFEST) $@ \ - $(LOCALEDATA_JAR_DIRS) $(BOOT_JAR_JFLAGS) - $(CD) $(CLASSBINDIR) && $(java-vm-cleanup) - -# Create sec-bin.zip -SEC_FILES_ZIP=$(IMAGES_OUTPUTDIR)/tmp/sec-bin.zip -sec-files:: - $(prep-target) - $(RM) $(SEC_FILES_ZIP) - $(CD) $(OUTPUTDIR) && \ - $(ZIPEXE) -rq9 $(SEC_FILES_ZIP) $(SEC_FILES_DIRS) - $(java-vm-cleanup) - -# Create sec-windows-bin.zip -SEC_FILES_WIN_ZIP=$(IMAGES_OUTPUTDIR)/tmp/sec-windows-bin.zip -sec-files-win:: -ifeq ($(PLATFORM), windows) - $(prep-target) - $(RM) $(SEC_FILES_WIN_ZIP) - $(CD) $(OUTPUTDIR) && \ - $(ZIPEXE) -rq9 $(SEC_FILES_WIN_ZIP) $(SEC_FILES_WIN_DIRS) - $(java-vm-cleanup) -endif - -# Create JGSS files that contains the native Kerberos library -JGSS_WIN32_FILES_ZIP=$(IMAGES_OUTPUTDIR)/tmp/jgss-windows-i586-bin.zip -JGSS_WIN64_FILES_ZIP=$(IMAGES_OUTPUTDIR)/tmp/jgss-windows-x64-bin.zip -jgss-files:: -ifeq ($(PLATFORM), windows) - $(prep-target) - ifeq ($(ARCH_DATA_MODEL), 32) - $(RM) $(JGSS_WIN32_FILES_ZIP) - $(CD) $(OUTPUTDIR) && \ - $(ZIPEXE) -rq9 $(JGSS_WIN32_FILES_ZIP) $(JGSS_FILES_DIRS) - else - $(RM) $(JGSS_WIN64_FILES_ZIP) - $(CD) $(OUTPUTDIR) && \ - $(ZIPEXE) -rq9 $(JGSS_WIN64_FILES_ZIP) $(JGSS_FILES_DIRS) - endif - $(java-vm-cleanup) -endif - -# Create rt.jar -RT_JAR=$(IMAGES_OUTPUTDIR)/tmp/rt-orig.jar -$(RT_JAR): $(RT_JAR_FILELIST) $(RT_JAR_MANIFEST_FILE) - $(prep-target) - $(CD) $(CLASSBINDIR) && \ - $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS) $(RT_JAR_MANIFEST_FILE) $@ \ - @$(RT_JAR_FILELIST) $(BOOT_JAR_JFLAGS) - $(CD) $(CLASSBINDIR) && $(java-vm-cleanup) - -# SE-Embedded targets if enabled -include $(JDK_TOPDIR)/makefiles/common/Release-embedded.gmk - - -###################################################### -# JRE Image -###################################################### - -initial-image-jre-setup: - $(RM) -r $(JRE_IMAGE_DIR) - $(MKDIR) -p $(JRE_IMAGE_DIR) - -# 64-bit solaris jre image contains only the 64-bit add-on files. -initial-image-jre-sol64:: initial-image-jre-setup - @# Use tar instead of cp to preserve the symbolic links - for dir in bin lib ; do \ - ( $(CD) $(OUTPUTDIR) && \ - $(TAR) cf - `$(FIND) $$dir -name '$(ARCH)' -print` | \ - ($(CD) $(JRE_IMAGE_DIR) && $(TAR) xf -) ) ; \ - done - @# Remove some files from the jre area - for t in $(NOTJRETOOLS) ; do \ - $(RM) $(JRE_IMAGE_DIR)/bin$(ISA_DIR)/$$t ; \ - done - for l in $(NOTJRELIBS) ; do \ - $(RM) $(JRE_IMAGE_DIR)/lib/$$l ; \ - done - $(RM) `$(FIND) $(JRE_IMAGE_DIR)/lib -name 'orb.idl'` - $(RM) `$(FIND) $(JRE_IMAGE_DIR)/lib -name 'ir.idl'` - -# Construct an initial jre image (initial jdk jre) no trimming or stripping -# See "initial-image-jdk-setup" for an explanation of the rm of -# drive names like C: -initial-image-jre:: initial-image-jre-setup \ - $(JRE_DOCFILES) \ - $(RT_JAR) $(RESOURCES_JAR) $(JSSE_JAR) $(JFR_JAR) $(DNS_JAR) $(LOCALEDATA_JAR) \ - $(BUILD_TOOLS) - @# Copy in bin directory - $(CD) $(OUTPUTDIR) && $(FIND) bin -depth | $(CPIO) -pdum $(JRE_IMAGE_DIR) - @# CTE plugin security change require new empty directory lib/applet - $(MKDIR) -p $(JRE_IMAGE_DIR)/lib/applet - @# Copy in lib directory - $(CD) $(OUTPUTDIR) && $(FIND) lib -depth | $(CPIO) -pdum $(JRE_IMAGE_DIR) - ifeq ($(USING_CYGWIN),true) - $(RM) -rf $(JRE_IMAGE_DIR)/[A-Za-z]: - $(RM) -rf $(OUTPUTDIR)/[A-Za-z]: - endif - @# Make sure all directories are read/execute for everyone - $(CHMOD) a+rx `$(FIND) $(JRE_IMAGE_DIR) -type d` - @# Remove some files from the jre area - for t in $(NOTJRETOOLS) ; do \ - $(RM) $(JRE_IMAGE_DIR)/bin$(ISA_DIR)/$$t ; \ - done - for l in $(NOTJRELIBS) ; do \ - $(RM) $(JRE_IMAGE_DIR)/lib/$$l ; \ - done - @# Remove orb.idl and ir.idl from jre - $(FIND) $(JRE_IMAGE_DIR)/lib -name 'orb.idl' -exec $(RM) \{} \; - $(FIND) $(JRE_IMAGE_DIR)/lib -name 'ir.idl' -exec $(RM) \{} \; - @# Copy in rt.jar & resources.jar file - $(CP) $(RT_JAR) $(JRE_IMAGE_DIR)/lib/rt.jar - $(CP) $(RESOURCES_JAR) $(JRE_IMAGE_DIR)/lib/resources.jar - $(CP) $(JSSE_JAR) $(JRE_IMAGE_DIR)/lib/jsse.jar -ifneq ($(JFR_JAR),) - $(CP) $(JFR_JAR) $(JRE_IMAGE_DIR)/lib/jfr.jar -endif - $(CP) $(DNS_JAR) $(JRE_IMAGE_DIR)/lib/ext/dnsns.jar - $(CP) $(LOCALEDATA_JAR) $(JRE_IMAGE_DIR)/lib/ext/localedata.jar - @# Generate meta-index to make boot and extension class loaders lazier - $(CD) $(JRE_IMAGE_DIR)/lib && \ - $(TOOL_BUILDMETAINDEX) \ - -o meta-index *.jar - $(CD) $(JRE_IMAGE_DIR)/lib && $(java-vm-cleanup) - $(CD) $(JRE_IMAGE_DIR)/lib/ext && \ - $(TOOL_BUILDMETAINDEX) \ - -o meta-index *.jar - $(CD) $(JRE_IMAGE_DIR)/lib/ext && $(java-vm-cleanup) -ifeq ($(PLATFORM), macosx) - @#install jobjc, apple mac only - $(CP) $(OUTPUTDIR)/JObjC.build/JObjC.jar $(JRE_IMAGE_DIR)/lib/JObjC.jar -endif -ifeq ($(PLATFORM), windows) - @# Remove certain *.lib files - $(CD) $(JRE_IMAGE_DIR)/lib && \ - $(RM) java.$(LIB_SUFFIX) jvm.$(LIB_SUFFIX) \ - awt.$(LIB_SUFFIX) jawt.$(LIB_SUFFIX) - ifeq ($(ARCH_DATA_MODEL), 32) - @# The Java Kernel JRE image ships with a special VM. It is not included - @# in the full JRE image, so remove it. Also, is it only for 32-bit windows. - $(CD) $(JRE_IMAGE_DIR)/bin && $(RM) -r kernel - endif -endif # Windows -ifneq ($(PLATFORM), windows) - $(call copy-man-pages,$(JRE_IMAGE_DIR),$(JRE_MAN_PAGES)) -endif # !windows - -# Trim out any extra files not for the jre shipment but wanted in the jdk jre. -# (Note the jdk WILL want the jre image before this trimming) -# Removes server VM on Windows 32bit. -# Remove certain shared libraries that should not be in the jre image -# but should be in the jdk jre image. -trim-image-jre:: - @# Clean out all _the. files. - $(FIND) $(JRE_IMAGE_DIR) -name "_the.*" $(FIND_DELETE) -ifeq ($(PLATFORM), windows) - ifeq ($(ARCH_DATA_MODEL), 32) - $(RM) -r $(JRE_IMAGE_DIR)/bin/server - endif - ifdef NOTJRE_SHARED_LIBS - for l in $(NOTJRE_SHARED_LIBS) ; do \ - $(RM) $(JRE_IMAGE_DIR)/bin/$$l ; \ - done ; - endif -else # PLATFORM - ifdef NOTJRE_SHARED_LIBS - for l in $(NOTJRE_SHARED_LIBS) ; do \ - $(RM) $(JRE_IMAGE_DIR)/lib/$(LIBARCH)/$$l ; \ - done ; - endif -endif # PLATFORM - -# Get list of all binary (COFF or Elf) files in the jre -JRE_BIN_LIST=$(TEMPDIR)/jre-bin-files.list -$(JRE_BIN_LIST): - $(RM) $@ -ifeq ($(PLATFORM), windows) - $(FIND) $(JRE_IMAGE_DIR)/bin -type f -name \*.exe \ - -o -name \*.dll | $(EGREP) -v -i "$(MSVCRNN_DLL)" > $@ -else - $(FIND) $(JRE_IMAGE_DIR)/lib -type f -name \*.$(LIB_SUFFIX) >> $@ - $(FILE) `$(FIND) $(JRE_IMAGE_DIR)/bin -type f -name \*$(EXE_SUFFIX)` \ - | $(EGREP) 'ELF' | $(CUT) -d':' -f1 >> $@ -endif - -# Post process the image (strips and mcs on Elf files we are shipping) -# (Note the jdk WILL want the jre image before this processing) -process-image-jre:: $(JRE_BIN_LIST) -ifneq ($(POST_STRIP_PROCESS), ) - @for f in `$(CAT) $(JRE_BIN_LIST)`; do \ - $(CHMOD) u+w $${f}; \ - $(ECHO) $(POST_STRIP_PROCESS) $${f}; \ - $(POST_STRIP_PROCESS) $${f}; \ - $(CHMOD) go-w $${f}; \ - done -endif -ifneq ($(POST_MCS_PROCESS), ) - @for f in `$(CAT) $(JRE_BIN_LIST)`; do \ - $(CHMOD) u+w $${f}; \ - $(ECHO) $(POST_MCS_PROCESS) $${f}; \ - $(POST_MCS_PROCESS) $${f}; \ - $(CHMOD) go-w $${f}; \ - done -endif - @for f in `$(CAT) $(JRE_BIN_LIST)`; do \ - $(call binary_file_verification,$${f}); \ - done - $(RM) $(JRE_BIN_LIST) - -###################################################### -# JDK Image -###################################################### -# Note: cpio ($(CPIO)) sometimes leaves directories without rx access. - -# REMIND: the $(RM) calls for patterns like c:, d: following $(CPIO) -# are because the 1.7.x versions of cygwin's cpio command drops these -# in the working directory if the output path begins with that pattern -# The one for the output jre subdirectory gets there because cpio sees its -# own dropping in the input jre subdirectory. Need to remove both of these. -# We can remove these RM's if someone figures out how to stop cpio from -# leaving these there. -# Note that its a real problem not because this directory can end up in the -# bundle (I think it won't since it not in bin or lib and those are the -# only places from which we copy everything), but because the presence -# of this file causes cygwin's find to bomb out, thus breaking the build -# in "install". -initial-image-jdk-setup: - $(RM) -r $(JDK_IMAGE_DIR) - $(MKDIR) -p $(JDK_IMAGE_DIR)/jre - ($(CD) $(JRE_IMAGE_DIR) && $(FIND) . -depth -print \ - | $(CPIO) -pdum $(JDK_IMAGE_DIR)/jre ) - ifeq ($(USING_CYGWIN),true) - $(RM) -rf $(JRE_IMAGE_DIR)/[A-Za-z]: - $(RM) -rf $(JDK_IMAGE_DIR)/jre/[A-Za-z]: - endif - $(RM) -rf $(JDK_IMAGE_DIR)/jre/man - $(CHMOD) a+rx `$(FIND) $(JDK_IMAGE_DIR) -type d` - -initial-image-jdk64-bindemos: - for dir in bin demo ; do \ - ( $(CD) $(OUTPUTDIR) && \ - $(TAR) cf - `$(FIND) $$dir -name '$(LIBARCH)' -print` | \ - ($(CD) $(JDK_IMAGE_DIR) && $(TAR) xf -) ) ; \ - done - -# Solaris 64 bit image is special -initial-image-jdk-sol64:: initial-image-jdk-setup \ - initial-image-jdk64-bindemos - -# DB files to add -ifdef OPENJDK - -initial-image-jdk-db: - -else - -# Create the list of db *.zip files to bundle with jdk -ABS_DB_PATH :=$(call FullPath,$(CLOSED_SHARE_SRC)/db) -DB_ZIP_LIST := $(shell $(LS) $(ABS_DB_PATH)/*.zip 2>/dev/null) -# Can't have : in these file names as they are used in a rule -# below. -ifdef USING_CYGWIN - DB_ZIP_LIST:=$(shell $(CYGPATH) -a -u $(DB_ZIP_LIST)) -endif - -# Java DB image. Move the Java DB demo directory into the JDK's demo -# dir and in the process, rename it to db. Also remove index.html, -# since it presumes docs are co-located. Also remove register.html (no -# longer relevant). -initial-image-jdk-db: $(DB_ZIP_LIST) - $(MKDIR) -p $(JDK_IMAGE_DIR)/db - for d in $(DB_ZIP_LIST); do \ - ($(CD) $(JDK_IMAGE_DIR)/db && $(UNZIP) -o $$d); \ - done - $(CP) $(ABS_DB_PATH)/README-JDK.html $(JDK_IMAGE_DIR)/db -ifndef NO_DEMOS - $(RM) -rf $(NEWDEMODIR)/db - $(MV) $(JDK_IMAGE_DIR)/db/demo $(NEWDEMODIR)/db - $(CP) $(ABS_DB_PATH)/README-JDK-DEMOS.html $(NEWDEMODIR)/db/ -else - $(RM) -rf $(JDK_IMAGE_DIR)/db/demo -endif - $(RM) $(JDK_IMAGE_DIR)/db/index.html $(JDK_IMAGE_DIR)/db/register.html -endif - -# The launcher source files we need for src.zip -FILES_launcher = $(wildcard $(SHARE_SRC)/bin/*) \ - $(wildcard $(PLATFORM_SRC)/bin/java_md*) - -# Standard jdk image -initial-image-jdk:: initial-image-jdk-setup \ - initial-image-jdk-db \ - $(JDK_DOCFILES) \ - $(JDK_DEMOS_AND_SAMPLES_DOCFILES) - $(MKDIR) $(JDK_IMAGE_DIR)/lib - @# - @# Copy in the jars in lib that only belong in the JDK - @# - for l in $(NOTJRELIBS); do \ - if [ -r $(LIBDIR)/$$l ]; then \ - $(CP) $(LIBDIR)/$$l $(JDK_IMAGE_DIR)/lib; \ - fi; \ - done - ifeq ($(PLATFORM), windows) - @# - @# lib/ - @# - $(CP) $(LIBDIR)/$(LIB_PREFIX)jvm.$(LIB_SUFFIX) $(JDK_IMAGE_DIR)/lib - $(CP) $(LIBDIR)/$(LIB_PREFIX)jawt.$(LIB_SUFFIX) $(JDK_IMAGE_DIR)/lib - @# - @# bin/ - @# - @# copy all EXE files and only certain DLL files from BINDIR - $(MKDIR) -p $(JDK_IMAGE_DIR)/bin - $(CP) $(BINDIR)/*$(EXE_SUFFIX) $(JDK_IMAGE_DIR)/bin - $(CP) $(BINDIR)/jli.$(LIBRARY_SUFFIX) $(JDK_IMAGE_DIR)/bin - ifeq ($(COMPILER_VERSION), VS2010) - $(CP) $(BINDIR)/msvc*100.$(LIBRARY_SUFFIX) $(JDK_IMAGE_DIR)/bin - endif - else # PLATFORM - @# - @# bin/ - @# - ($(CD) $(BINDIR)/.. && $(TAR) cf - \ - `$(FIND) bin \( -type f -o -type l \) -print `) | \ - ($(CD) $(JDK_IMAGE_DIR) && $(TAR) xf -) - endif # PLATFORM - @# - @# lib/tools.jar - @# - $(MKDIR) -p $(IMAGES_OUTPUTDIR)/lib - $(CD) $(CLASSBINDIR) && \ - $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS_NOMANIFEST) $(IMAGES_OUTPUTDIR)/lib/tools.jar \ - $(TOOLS) $(BOOT_JAR_JFLAGS) - $(CD) $(CLASSBINDIR) && $(java-vm-cleanup) - $(CP) $(IMAGES_OUTPUTDIR)/lib/tools.jar $(JDK_IMAGE_DIR)/lib/tools.jar - @# - @# lib/ct.sym - @# - $(MKDIR) -p $(IMAGES_OUTPUTDIR)/symbols/META-INF/sym - $(BOOT_JAVA_CMD) \ - -Xbootclasspath/p:$(JAVAC_JAR) \ - -Xbootclasspath/a:$(JDK_OUTPUTDIR)/classes \ - -jar $(JAVAC_JAR) $(JAVACFLAGS) \ - -XDprocess.packages -proc:only \ - -processor com.sun.tools.javac.sym.CreateSymbols \ - -Acom.sun.tools.javac.sym.Jar=$(RT_JAR) \ - -Acom.sun.tools.javac.sym.Dest=$(IMAGES_OUTPUTDIR)/symbols/META-INF/sym/rt.jar \ - $(CORE_PKGS) $(NON_CORE_PKGS) $(EXCLUDE_PROPWARN_PKGS) $(EXPORTED_PRIVATE_PKGS) - $(BOOT_JAR_CMD) $(CREATE_JAR_OPTS_NOMANIFEST) $(IMAGES_OUTPUTDIR)/lib/ct.sym \ - -C $(IMAGES_OUTPUTDIR)/symbols META-INF $(BOOT_JAR_JFLAGS) - $(java-vm-cleanup) - $(CP) $(IMAGES_OUTPUTDIR)/lib/ct.sym $(JDK_IMAGE_DIR)/lib/ct.sym - @# - @# CORBA supported orb.idl and ir.idl should be copied to lib - @# - $(CP) $(LIBDIR)/orb.idl $(JDK_IMAGE_DIR)/lib/orb.idl - $(CP) $(LIBDIR)/ir.idl $(JDK_IMAGE_DIR)/lib/ir.idl - ifeq ($(PLATFORM), linux) - @# - @# on Linux copy jexec from jre/lib to /lib - @# - $(CP) $(LIBDIR)/jexec $(JDK_IMAGE_DIR)/lib/jexec - endif # PLATFORM - @# - @# src.zip - @# - $(MKDIR) -p $(JDK_IMAGE_DIR)/src - @# - @# The '*-*' pattern in the find command excludes files named with dashes, - @# such as the java.nio templates for generated classes - @# - @# The Linux 'tar' command cannot handle the huge command line argument - @# generated by the more efficient solaris/windows method of copying files. - @# So for Linux, make use of the -T option (like Solaris' -I option) of - @# obtaining the list of files from a file. MKS tar has no such option. - - ifneq (,$(findstring $(PLATFORM), linux macosx)) - for d in $(SOURCE_DIRS); do \ - $(RM) $(IMAGES_OUTPUTDIR)/tmp/src-files.list; \ - ($(CD) $$d && \ - for sd in $(SOURCES) ; do \ - if [ -d $$sd ] ; then \ - $(FIND) $$sd $(SOURCE_FILES_filter) \ - -name '*.java' -print \ - >> $(IMAGES_OUTPUTDIR)/tmp/src-files.list ; \ - fi; \ - done ; \ - ) ; \ - if [ -f $(IMAGES_OUTPUTDIR)/tmp/src-files.list ] ; then \ - ($(CD) $$d && $(TAR) cf - -T $(IMAGES_OUTPUTDIR)/tmp/src-files.list ) \ - | ($(CD) $(JDK_IMAGE_DIR)/src && $(TAR) xf -); \ - fi; \ - done - else - for d in $(SOURCE_DIRS); do \ - $(RM) $(IMAGES_OUTPUTDIR)/tmp/src-files.list; \ - ($(CD) $$d && \ - for sd in $(SOURCES) ; do \ - if [ -d $$sd ] ; then \ - $(FIND) $$sd $(SOURCE_FILES_filter) \ - -name '*.java' -print \ - >> $(IMAGES_OUTPUTDIR)/tmp/src-files.list ; \ - fi; \ - done ; \ - ) ; \ - if [ -f $(IMAGES_OUTPUTDIR)/tmp/src-files.list ] ; then \ - ($(CD) $$d && $(TAR) cf - `$(CAT) $(IMAGES_OUTPUTDIR)/tmp/src-files.list`) \ - | ($(CD) $(JDK_IMAGE_DIR)/src && $(TAR) xf -); \ - fi; \ - done - endif - $(RM) $(IMAGES_OUTPUTDIR)/tmp/src-files.list - $(CHMOD) -R +w $(JDK_IMAGE_DIR)/src - $(MKDIR) -p $(JDK_IMAGE_DIR)/src/launcher - $(CP) $(FILES_launcher) $(JDK_IMAGE_DIR)/src/launcher - $(CD) $(JDK_IMAGE_DIR)/src && $(ZIPEXE) -qr ../src.zip * - $(RM) -r $(JDK_IMAGE_DIR)/src - @# - @# demo, include - @# -ifndef NO_DEMOS - mkdir -p $(JDK_IMAGE_DIR)/demo - $(CP) -r -f $(NEWDEMODIR)/* $(JDK_IMAGE_DIR)/demo - $(FIND) $(JDK_IMAGE_DIR)/demo -name "_the.*" $(FIND_DELETE) -endif -ifndef NO_SAMPLES - $(CP) -r -f $(SAMPLEDIR) $(JDK_IMAGE_DIR) -endif - $(CP) -r $(INCLUDEDIR) $(JDK_IMAGE_DIR) - @# - @# Swing BeanInfo generation - @# - $(CP) $(JDK_OUTPUTDIR)/lib/dt.jar $(JDK_IMAGE_DIR)/lib/dt.jar -ifneq ($(PLATFORM), windows) - $(call copy-man-pages,$(JDK_IMAGE_DIR),$(JDK_MAN_PAGES)) -endif # !windows - -# Trim out files we don't want to ship -trim-image-jdk:: - @# Clean out all _the. files. - $(FIND) $(JDK_IMAGE_DIR) -name "_the.*" $(FIND_DELETE) - @# Remove tools that should not be part of SDK. - for t in $(NOTJDKTOOLS); do \ - $(RM) $(JDK_IMAGE_DIR)/bin/$${t}$(EXE_SUFFIX); \ - done - -# Get list of binary (COFF or Elf) files in the jdk -JDK_BIN_LIST=$(TEMPDIR)/jdk-bin-files.list -$(JDK_BIN_LIST): -ifeq ($(PLATFORM), windows) - $(FIND) $(JDK_IMAGE_DIR)/jre/bin -type f -name \*.exe \ - -o -name \*.dll | $(EGREP) -v -i "$(MSVCRNN_DLL)" > $@ - $(FIND) $(JDK_IMAGE_DIR)/bin -type f -name \*.exe \ - -o -name \*.dll | $(EGREP) -v -i "$(MSVCRNN_DLL)" >> $@ -else - $(RM) $@ - $(FIND) $(JDK_IMAGE_DIR)/jre/lib -type f -name \*.$(LIB_SUFFIX) >> $@ - $(FILE) `$(FIND) $(JDK_IMAGE_DIR)/jre/bin -type f -name \*$(EXE_SUFFIX)` \ - | $(EGREP) 'ELF' | $(CUT) -d':' -f1 >> $@ - $(FILE) `$(FIND) $(JDK_IMAGE_DIR)/bin -type f -name \*$(EXE_SUFFIX)` \ - | $(EGREP) 'ELF' | $(CUT) -d':' -f1 >> $@ -endif - -# Post process the image (strips and mcs on files we are shipping) -process-image-jdk:: $(JDK_BIN_LIST) -ifneq ($(POST_STRIP_PROCESS), ) - @for f in `$(CAT) $(JDK_BIN_LIST)`; do \ - $(CHMOD) u+w $${f}; \ - $(ECHO) $(POST_STRIP_PROCESS) $${f}; \ - $(POST_STRIP_PROCESS) $${f}; \ - $(CHMOD) go-w $${f}; \ - done -endif -ifneq ($(POST_MCS_PROCESS), ) - @for f in `$(CAT) $(JDK_BIN_LIST)`; do \ - $(CHMOD) u+w $${f}; \ - $(ECHO) $(POST_MCS_PROCESS) $${f}; \ - $(POST_MCS_PROCESS) $${f}; \ - $(CHMOD) go-w $${f}; \ - done -endif - @for f in `$(CAT) $(JDK_BIN_LIST)`; do \ - $(call binary_file_verification,$${f}); \ - done - $(RM) $(JDK_BIN_LIST) - -################################################################### -# What did we build -################################################################### - -# The jdk text info file that lives at the root of the install image. - -JDK_INFO_FILE = $(JDK_IMAGE_DIR)/release -JRE_INFO_FILE = $(JRE_IMAGE_DIR)/release - -# Common way to emit a line into the release or info file -define info-file-item # name value -$(PRINTF) '%s="%s"\n' $1 $2 >> $@ -endef - -# Values to emit -MINIMUM_OS_NAME := $(REQUIRED_OS_NAME) -MINIMUM_OS_VERSION := $(REQUIRED_OS_VERSION) -MINIMUM_OS_ARCH := $(ARCH) -ALL_SOURCE_TIPS = $(shell \ - if [ -f $(SOURCE_TIPS) ] ; then \ - $(CAT) $(SOURCE_TIPS) ; \ - fi) - -$(JDK_INFO_FILE): FRC - $(prep-target) - $(call info-file-item, "JAVA_VERSION", "$(THIS_JDK_VERSION)") - $(call info-file-item, "OS_NAME", "$(MINIMUM_OS_NAME)") - $(call info-file-item, "OS_VERSION", "$(MINIMUM_OS_VERSION)") - $(call info-file-item, "OS_ARCH", "$(MINIMUM_OS_ARCH)") - $(call info-file-item, "SOURCE", "$(ALL_SOURCE_TIPS)") - -# Create release file to identify this image -identify-image-jdk:: $(JDK_INFO_FILE) - -$(JRE_INFO_FILE): FRC - $(prep-target) - $(call info-file-item, "JAVA_VERSION", "$(THIS_JDK_VERSION)") - $(call info-file-item, "OS_NAME", "$(MINIMUM_OS_NAME)") - $(call info-file-item, "OS_VERSION", "$(MINIMUM_OS_VERSION)") - $(call info-file-item, "OS_ARCH", "$(MINIMUM_OS_ARCH)") - $(call info-file-item, "SOURCE", "$(ALL_SOURCE_TIPS)") - -# Create release file to identify this image -identify-image-jre:: $(JRE_INFO_FILE) - -images images-clobber:: - $(ECHO) ">>>Finished making "$@" @ `$(DATE)` ..." - $(java-vm-cleanup) - -.PHONY: images image-jre image-jdk \ - initial-image-jre initial-image-jdk \ - initial-image-jre-sol64 initial-image-jdk-sol64 \ - initial-image-jdk-setup \ - initial-image-jdk-db \ - initial-image-jdk64-bindemos \ - initial-image-jre-setup \ - trim-image-jre trim-image-jdk \ - process-image-jre process-image-jdk \ - identify-image-jre identify-image-jdk \ - images-clobber - -# Force rule -FRC: - diff --git a/jdk/makefiles/common/Rules.gmk b/jdk/makefiles/common/Rules.gmk deleted file mode 100644 index 9e9163a887b..00000000000 --- a/jdk/makefiles/common/Rules.gmk +++ /dev/null @@ -1,357 +0,0 @@ -# -# Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# -# Rules shared by all Java makefiles. -# -# Used to apply to source file $<, checks code conventions, issues warnings. -define check-conventions - if [ "$(CONVENTION_WATCH)" = "true" ] ; then \ - if [ "`$(CAT) -n -v -t $< | $(EGREP) -v '\@\(\#\)' | $(EGREP) '\^[MLI]'`" != "" ] ; then \ - $(ECHO) "WARNING: File contains tabs, ^M, or ^L characters: $<"; \ - if [ "$(CONVENTION_DETAILS)" = "true" ] ; then \ - $(CAT) -n -v -t $< | $(EGREP) -v '\@\(\#\)' | $(EGREP) '\^[MLI]' ; \ - fi; \ - fi; \ - fi -endef - -# Make sure the default rule is all -rules_default_rule: all - -# -# Directory set up. (Needed by deploy workspace) -# -$(CLASSDESTDIR) $(CLASSHDRDIR) $(OBJDIR) $(OUTPUTDIR) $(BINDIR) $(LIBDIR) $(LIBDIR)/$(LIBARCH) $(TEMPDIR) $(EXTDIR): - $(MKDIR) -p $@ - -# -# All source tree areas for java/properties files (a few may be closed) -# -ifeq ($(PLATFORM), macosx) - ifdef OPENJDK - ALL_CLASSES_SRC = $(call JavaSrcDirList,,classes) - else - ALL_CLASSES_SRC = \ - $(CLOSED_SHARE_SRC)/classes $(CLOSED_PLATFORM_SRC)/classes \ - $(call JavaSrcDirList,,classes) - endif -else - ifdef OPENJDK - ALL_CLASSES_SRC = $(SHARE_SRC)/classes $(PLATFORM_SRC)/classes - else - ALL_CLASSES_SRC = \ - $(CLOSED_SHARE_SRC)/classes $(CLOSED_PLATFORM_SRC)/classes \ - $(SHARE_SRC)/classes $(PLATFORM_SRC)/classes - endif -endif - -# -# If AUTO_FILES_PROPERTIES_DIRS used, automatically find properties files -# -ifdef AUTO_FILES_PROPERTIES_DIRS - AUTO_FILES_PROPERTIES_FILTERS1 = $(SCM_DIRs) ',*' - AUTO_FILES_PROPERTIES_FILTERS1 += $(AUTO_PROPERTIES_PRUNE) - FILES_properties_find_filters1 = $(AUTO_FILES_PROPERTIES_FILTERS1:%=-name % -prune -o) - FILES_properties_auto1 := \ - $(shell \ - for dir in $(ALL_CLASSES_SRC) ; do \ - if [ -d $$dir ] ; then \ - ( $(CD) $$dir; \ - for sdir in $(AUTO_FILES_PROPERTIES_DIRS); do \ - if [ -d $$sdir ] ; then \ - $(FIND) $$sdir $(FILES_properties_find_filters1) \ - -name '*.properties' -print ; \ - fi ; \ - done \ - ); \ - fi; \ - done \ - ) -else - FILES_properties_auto1 = -endif # AUTO_FILES_PROPERTIES_DIRS - -# Add any automatically found properties files to the properties file list -FILES_properties += $(FILES_properties_auto1) - -# -# Get Resources help -# -include $(JDK_TOPDIR)/makefiles/common/internal/Resources.gmk - -# -# Compiling .java files. -# - -# -# Automatically add to FILES_java if AUTO_FILES_JAVA_DIRS is defined -# -# There are two basic types of sources, normal source files and the -# generated ones. The Normal sources will be located in: -# $(ALL_CLASSES_SRC) -# The generated sources, which might show up late to dinner, are at: -# $(GENSRCDIR) -# and since they could be generated late, we need to be careful that -# we look for these sources late and not use the ':=' assignment which -# might miss their generation. - -ifdef AUTO_FILES_JAVA_DIRS - # Filter out these files or directories - AUTO_FILES_JAVA_SOURCE_FILTERS1 = $(SCM_DIRs) ',*' - AUTO_FILES_JAVA_SOURCE_FILTERS2 = - AUTO_FILES_JAVA_SOURCE_FILTERS1 += $(AUTO_JAVA_PRUNE) - AUTO_FILES_JAVA_SOURCE_FILTERS2 += $(AUTO_JAVA_PRUNE) - - # First list is the normal sources that should always be there, - # by using the ':=', which means we do this processing once. - FILES_java_find_filters1 = $(AUTO_FILES_JAVA_SOURCE_FILTERS1:%=-name % -prune -o) - FILES_java_auto1 := \ - $(shell \ - for dir in $(ALL_CLASSES_SRC) ; do \ - if [ -d $$dir ] ; then \ - ( $(CD) $$dir; \ - for sdir in $(AUTO_FILES_JAVA_DIRS); do \ - if [ -d $$sdir ] ; then \ - $(FIND) $$sdir $(FILES_java_find_filters1) \ - -name '*.java' -print ; \ - fi ; \ - done \ - ); \ - fi; \ - done \ - ) - # Second list is the generated sources that should be rare, but will likely - # show up late and we need to look for them at the last minute, so we - # cannot use the ':=' assigment here. But if this gets expanded multiple - # times, the if tests should make them relatively cheap. - FILES_java_find_filters2 = $(AUTO_FILES_JAVA_SOURCE_FILTERS2:%=-name % -prune -o) - FILES_java_auto2 = \ - $(shell \ - for dir in $(GENSRCDIR); do \ - if [ -d $$dir ] ; then \ - ( $(CD) $$dir; \ - for sdir in $(AUTO_FILES_JAVA_DIRS); do \ - if [ -d $$sdir ] ; then \ - $(FIND) $$sdir $(FILES_java_find_filters2) \ - -name '*.java' -print ; \ - fi ; \ - done \ - ); \ - fi; \ - done \ - ) -else - FILES_java_auto1 = - FILES_java_auto2 = -endif - -# Add all found java sources to FILES_java macro (if AUTO_FILES_JAVA_DIRS used) -FILES_java += $(FILES_java_auto1) $(FILES_java_auto2) - -# File that will hold java source names that need compiling -JAVA_SOURCE_LIST=$(TEMPDIR)/.classes.list - -# Add a java source to the list -define add-java-file -$(ECHO) "$?" >> $(JAVA_SOURCE_LIST) -$(check-conventions) -endef - -ifdef DEMOS -$(CLASSDESTDIR)/%.class: $(SOURCEPATH)/%.java - $(add-java-file) -#Redirect zh_HK java files to tmp directory which created from zh_TW -#$(CLASSDESTDIR)/%_zh_HK.class: $(JDK_L10N_TMP_OUTPUTDIR)/%_zh_HK.java -# $(add-java-file) -else - -# -# Rules for closed files -# -# If filenames are duplicated between open/closed workspaces, prefer -# the closed files. -# -# Rule ordering in this Makefile is important: some targets depend -# on closed files replacing open ones, and thus the closed file rules -# must be found before the open ones. -# -# Don't reorder without consulting teams that depend on this behavior. -# -ifndef OPENJDK -$(CLASSDESTDIR)/%.class: $(CLOSED_PLATFORM_SRC)/classes/%.java - $(add-java-file) -$(CLASSDESTDIR)/%.class: $(CLOSED_SHARE_SRC)/classes/%.java - $(add-java-file) -endif - -$(CLASSDESTDIR)/%.class: $(GENSRCDIR)/%.java - $(add-java-file) - -ifeq ($(PLATFORM), macosx) -$(CLASSDESTDIR)/%.class: $(JDK_TOPDIR)/src/macosx/classes/%.java - $(add-java-file) -endif -$(CLASSDESTDIR)/%.class: $(PLATFORM_SRC)/classes/%.java - $(add-java-file) - -$(CLASSDESTDIR)/%.class: $(SHARE_SRC)/classes/%.java - $(add-java-file) - -#Redirect zh_HK java files to tmp directory which created from zh_TW -$(CLASSDESTDIR)/%_zh_HK.class: $(JDK_L10N_TMP_OUTPUTDIR)/%_zh_HK.java - $(add-java-file) -endif - -# List of class files needed -FILES_class = $(FILES_java:%.java=$(CLASSDESTDIR)/%.class) - -# Got to include exported files. -FILES_class += $(FILES_export:%.java=$(CLASSDESTDIR)/%.class) - -# Construct list of java sources we need to compile -source_list_prime: - mkdir -p $(TEMPDIR) -# Note that we slip resources in so that compiled properties files get created: -$(JAVA_SOURCE_LIST) : source_list_prime resources $(FILES_class) - touch $@ - -.delete.classlist: - rm -f $(JAVA_SOURCE_LIST) - -# Make sure all newer sources are compiled (in a batch) -classes : $(CLASSES_INIT) .delete.classlist .compile.classlist - -.compile.classlist : $(JAVA_SOURCE_LIST) - $(MKDIR) -p $(CLASSDESTDIR) - $(RM) $<.filtered - $(CAT) $< | $(NAWK) 'length>0' | $(SORT) -u > $<.filtered - numfiles=`$(WC) -l < $<.filtered` ; \ - if [ $$numfiles -ge 1 ] ; then \ - $(ECHO) "# Java sources to be compiled: (listed in file $<)"; \ - $(CAT) $<.filtered; \ - $(ECHO) "# Running javac: $$numfiles files; in $(CURDIR)"; \ - $(ECHO) $(JAVAC_CMD) -sourcepath "$(SOURCEPATH)" -d $(CLASSDESTDIR) @$<.filtered; \ - $(JAVAC_CMD) -sourcepath "$(SOURCEPATH)" -d $(CLASSDESTDIR) @$<.filtered && \ - $(ECHO) "# javac finished"; \ - fi - $(java-vm-cleanup) - -clobber clean:: - rm -f $(JAVA_SOURCE_LIST) - -ifndef DONT_CLOBBER_CLASSES - ifndef PACKAGE - DONT_CLOBBER_CLASSES = true - else - DONT_CLOBBER_CLASSES = false - endif -endif - -packages.clean: -ifeq ($(DONT_CLOBBER_CLASSES),false) - ifdef AUTO_FILES_JAVA_DIRS - for sdir in $(AUTO_FILES_JAVA_DIRS); do \ - echo "rm -f -r $(CLASSDESTDIR)/$$sdir"; \ - rm -f -r $(CLASSDESTDIR)/$$sdir; \ - done - else - rm -f -r $(CLASSDESTDIR)/$(PKGDIR) - endif -endif - -ifdef DEMOS -classes.clean: - rm -f -r $(DEMODST) $(CLASSDESTDIR) -else -classes.clean: packages.clean - rm -f $(JAVA_SOURCE_LIST) -endif - -# -# C and C++ make dependencies -# -include $(JDK_TOPDIR)/makefiles/common/internal/NativeCompileRules.gmk - -# -# Running Javah to generate stuff into CClassHeaders. -# - -ifdef FILES_export - -CLASSES.export = $(subst /,.,$(FILES_export:%.java=%)) -CLASSES.export += $(subst /,.,$(FILES_export2:%.java=%)) -CLASSES.export += $(subst /,.,$(FILES_export3:%.java=%)) -CLASSES_export = $(FILES_export:%.java=$(CLASSDESTDIR)/%.class) -CLASSES_export += $(FILES_export2:%.java=$(CLASSDESTDIR)/%.class) -CLASSES_export += $(FILES_export3:%.java=$(CLASSDESTDIR)/%.class) - -# Fix when deploy workspace makefiles don't depend on this name -#CLASSHDR_DOTFILE=$(CLASSHDRDIR)/.classheaders - -CLASSHDR_DOTFILE=$(OBJDIR)/.class.headers.$(ARCH) - -classheaders: classes $(CLASSHDR_DOTFILE) - -$(CLASSHDR_DOTFILE): $(CLASSES_export) - $(prep-target) - echo "# Running javah:" - echo $(UNCYGDRIVE) $(JAVAH_CMD) -d $(CLASSHDRDIR)/ \ - $(CLASSES.export) $(subst $$,\$$,$(EXPORTED_inner)) - $(UNCYGDRIVE) $(JAVAH_CMD) -d $(CLASSHDRDIR)/ \ - $(CLASSES.export) $(subst $$,\$$,$(EXPORTED_inner)) - $(java-vm-cleanup) - touch $@ - -classheaders.clean: - rm -f $(CLASSHDR_DOTFILE) - rm -f -r $(CLASSHDRDIR) - -else # FILES_export - -classheaders: classes - -classheaders.clean: - -endif # FILES_export - -clean clobber:: classheaders.clean classes.clean .delete.classlist - -# -# Default dependencies -# - -all: build - -build: classheaders - -default: all - -.PHONY: all build clean clobber \ - .delete.classlist classes .compile.classlist classes.clean \ - classheaders classheaders.clean \ - batch_compile - diff --git a/jdk/makefiles/common/Subdirs.gmk b/jdk/makefiles/common/Subdirs.gmk deleted file mode 100644 index b8c5405d160..00000000000 --- a/jdk/makefiles/common/Subdirs.gmk +++ /dev/null @@ -1,148 +0,0 @@ -# Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Generic makefile for building subdirectories. -# -# SUBDIRS variables to specify the subdirectories to build recursively. -# Makefile has to include Subdirs.gmk AFTER all SUBDIRS variables are -# defined. -# -# This file does not contain any rule. -# -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. - -# -# SUBDIRS subdirs for the base module always get built -# SUBDIRS_ subdirs for the named group -# -# By default, subdirs specified in the SUBDIRS and all SUBDIRS_* -# variables will be built. -# -# Variables of the currently supported groups are: -# SUBDIRS_desktop -# SUBDIRS_management -# SUBDIRS_enterprise -# SUBDIRS_misc -# SUBDIRS_tools -# -# Change to the above list also need to update -# make/common/shared/Sanity.gmk. NOTE: this list is subject -# to change. -# -# Eventually we want to restructure the make directory -# according to these grouping (e.g. make/desktop/...) and -# the SUBDIRS_ variables would not be needed. -# - -# Iterate the subdirectories specified in $1. -# - cd into each subdir and make them - -# Given a SUBDIRS* list (first argument), cd into them and make them -# SUBDIRS_MAKEFLAGS Make settings for a subdir make -# SUBDIRS_MAKEFLAGS-$@ Make settings specific to this target -# -define subdirs-group-loop -$(ECHO) "Begin Processing SUBDIRS: $($1)" -for i in DUMMY $($1) ; do \ - if [ "$$i" != "DUMMY" ] ; then \ - $(MAKE) -C $$i $@ $(SUBDIRS_MAKEFLAGS) $(SUBDIRS_MAKEFLAGS-$@) \ - FULL_VERSION=$(FULL_VERSION) RELEASE=$(RELEASE) || exit 1; \ - fi ; \ -done -$(ECHO) "Done Processing SUBDIRS: $($1)" -endef - -# Given a OTHERSUBDIRS list, cd into them and make them (extra loop define) -# OTHERSUBDIRS_MAKEFLAGS Make settings for a subdir make -define OTHERSUBDIRS-loop -$(ECHO) "Begin Processing OTHERSUBDIRS: $(OTHERSUBDIRS)" -for i in DUMMY $(OTHERSUBDIRS) ; do \ - if [ "$$i" != "DUMMY" ] ; then \ - $(MAKE) -C $$i $@ $(OTHERSUBDIRS_MAKEFLAGS) \ - FULL_VERSION=$(FULL_VERSION) RELEASE=$(RELEASE) || exit 1; \ - fi ; \ -done -$(ECHO) "Done Processing OTHERSUBDIRS: $(OTHERSUBDIRS)" -endef - -# -# Iterate the list specified in SUBDIRS_ only if -# SUBDIRS_ is set. -# -ifdef SUBDIRS_desktop - define subdirs-desktop-loop - $(call subdirs-group-loop,SUBDIRS_desktop) - endef -else - define subdirs-desktop-loop - endef -endif # SUBDIRS_desktop - -ifdef SUBDIRS_enterprise - define subdirs-enterprise-loop - $(call subdirs-group-loop,SUBDIRS_enterprise) - endef -else -define subdirs-enterprise-loop -endef -endif # SUBDIRS_enterprise - -ifdef SUBDIRS_management - define subdirs-management-loop - $(call subdirs-group-loop,SUBDIRS_management) - endef -else - define subdirs-management-loop - endef -endif # SUBDIRS_management - -ifdef SUBDIRS_misc - define subdirs-misc-loop - $(call subdirs-group-loop,SUBDIRS_misc) - endef -else - define subdirs-misc-loop - endef -endif # SUBDIRS_misc - -ifdef SUBDIRS_tools - define subdirs-tools-loop - $(call subdirs-group-loop,SUBDIRS_tools) - endef -else - define subdirs-tools-loop - endef -endif # SUBDIRS_tools - -# -# If BUILD_MODULES is not set or it's set to "all", -# iterate all groups. -SUBDIRS_all = $(SUBDIRS) $(SUBDIRS_desktop) $(SUBDIRS_enterprise) \ - $(SUBDIRS_management) $(SUBDIRS_misc) $(SUBDIRS_tools) - -define SUBDIRS-loop - $(call subdirs-group-loop,SUBDIRS_all) -endef diff --git a/jdk/makefiles/common/internal/Defs-corba.gmk b/jdk/makefiles/common/internal/Defs-corba.gmk deleted file mode 100644 index 20468696196..00000000000 --- a/jdk/makefiles/common/internal/Defs-corba.gmk +++ /dev/null @@ -1,63 +0,0 @@ -# -# Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# The specific packages that come from or go to rt.jar and tools.jar -IMPORT_RT_PACKAGES += \ - org/omg/CORBA \ - org/omg/CORBA_2_3 \ - org/omg/CosNaming \ - org/omg/Dynamic \ - org/omg/DynamicAny \ - org/omg/IOP \ - org/omg/Messaging \ - org/omg/PortableInterceptor \ - org/omg/PortableServer \ - org/omg/SendingContext \ - org/omg/stub/java/rmi \ - javax/rmi \ - javax/rmi/CORBA \ - javax/activity \ - javax/transaction \ - com/sun/corba/se/GiopIDL \ - com/sun/corba/se/PortableActivationIDL \ - com/sun/corba/se/impl \ - com/sun/corba/se/internal \ - com/sun/corba/se/org/omg/CORBA \ - com/sun/corba/se/pept \ - com/sun/corba/se/spi \ - com/sun/org/omg/CORBA \ - com/sun/org/omg/SendingContext \ - com/sun/tools/corba/se/logutil \ - sun/corba \ - sun/rmi/rmic/iiop - -IMPORT_TOOLS_PACKAGES += \ - com/sun/tools/corba/se/idl \ - sun/rmi/rmic/iiop - -IMPORT_CORBA_BINARIES += \ - lib/orb.idl \ - lib/ir.idl - diff --git a/jdk/makefiles/common/internal/Defs-jaxp.gmk b/jdk/makefiles/common/internal/Defs-jaxp.gmk deleted file mode 100644 index eb5813c970e..00000000000 --- a/jdk/makefiles/common/internal/Defs-jaxp.gmk +++ /dev/null @@ -1,53 +0,0 @@ -# -# Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# The specific packages that come from or go to rt.jar and tools.jar -IMPORT_RT_PACKAGES += \ - org/w3c/dom \ - org/xml/sax \ - javax/xml/XMLConstants.class \ - javax/xml/datatype \ - javax/xml/namespace \ - javax/xml/parsers \ - javax/xml/stream \ - javax/xml/transform \ - javax/xml/validation \ - javax/xml/xpath \ - com/sun/java_cup \ - com/sun/org/apache/bcel \ - com/sun/org/apache/regexp \ - com/sun/org/apache/xalan \ - com/sun/org/apache/xerces \ - com/sun/org/apache/xml/internal/dtm \ - com/sun/org/apache/xml/internal/res \ - com/sun/org/apache/xml/internal/resolver \ - com/sun/org/apache/xml/internal/serialize \ - com/sun/org/apache/xml/internal/serializer \ - com/sun/org/apache/xml/internal/utils \ - com/sun/org/apache/xpath \ - com/sun/xml/internal/stream - -IMPORT_TOOLS_PACKAGES += - diff --git a/jdk/makefiles/common/internal/Defs-jaxws.gmk b/jdk/makefiles/common/internal/Defs-jaxws.gmk deleted file mode 100644 index f0ba12b292a..00000000000 --- a/jdk/makefiles/common/internal/Defs-jaxws.gmk +++ /dev/null @@ -1,63 +0,0 @@ -# -# Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# The specific packages that come from or go to rt.jar and tools.jar -IMPORT_RT_PACKAGES += \ - META-INF/mailcap.default \ - META-INF/mimetypes.default \ - javax/activation \ - com/sun/activation \ - javax/xml/bind \ - javax/xml/soap \ - javax/xml/ws \ - javax/jws \ - javax/annotation \ - com/sun/xml/internal/bind \ - com/sun/xml/internal/fastinfoset \ - com/sun/xml/internal/messaging \ - com/sun/xml/internal/org/jvnet \ - com/sun/xml/internal/txw2 \ - com/sun/xml/internal/ws \ - com/sun/xml/internal/stream/buffer - -NOT_USED_PACKAGES += \ - com/sun/tools/internal/txw2 - -IMPORT_TOOLS_PACKAGES += \ - com/sun/codemodel \ - com/sun/istack/internal/tools \ - com/sun/xml/internal/rngom \ - com/sun/xml/internal/xsom \ - com/sun/xml/internal/dtdparser \ - com/sun/tools/internal/xjc \ - com/sun/tools/internal/ws \ - com/sun/tools/internal/jxc \ - org/relaxng \ - META-INF/services/com.sun.tools.internal.ws.wscompile.Plugin \ - META-INF/services/com.sun.tools.internal.xjc.Plugin \ - com/sun/tools/internal/jxc/ap \ - com/sun/tools/internal/ws/wscompile/plugin/at_generated - - diff --git a/jdk/makefiles/common/internal/Defs-langtools.gmk b/jdk/makefiles/common/internal/Defs-langtools.gmk deleted file mode 100644 index eebbfd0cbcb..00000000000 --- a/jdk/makefiles/common/internal/Defs-langtools.gmk +++ /dev/null @@ -1,42 +0,0 @@ -# -# Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# The specific packages that come from or go to rt.jar and tools.jar - -IMPORT_RT_PACKAGES += \ - javax/annotation/processing \ - javax/lang/model \ - javax/tools - -IMPORT_TOOLS_PACKAGES += \ - com/sun/javadoc \ - com/sun/source \ - com/sun/tools/classfile \ - com/sun/tools/doclets \ - com/sun/tools/javac \ - com/sun/tools/javadoc \ - com/sun/tools/javah \ - com/sun/tools/javap - diff --git a/jdk/makefiles/common/internal/ImportComponents.gmk b/jdk/makefiles/common/internal/ImportComponents.gmk deleted file mode 100644 index 995de5b6e9a..00000000000 --- a/jdk/makefiles/common/internal/ImportComponents.gmk +++ /dev/null @@ -1,173 +0,0 @@ -# -# Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - --include $(SPEC) - -# JDK jars where component classes come from as second choice -JDK_RT_JAR = $(JDK_IMPORT_PATH)/jre/lib/rt.jar -JDK_TOOLS_JAR = $(JDK_IMPORT_PATH)/lib/tools.jar -JDK_RESOURCES_JAR = $(JDK_IMPORT_PATH)/jre/lib/resources.jar - -# The specific packages that come from or go to rt.jar and tools.jar -# IF the component deliverables are not available. -IMPORT_TOOLS_PACKAGES = -IMPORT_RT_PACKAGES = - -# The following will add to IMPORT_TOOLS_PACKAGES and/or IMPORT_RT_PACKAGES -ifndef LANGTOOLS_DIST - include $(BUILDDIR)/common/internal/Defs-langtools.gmk -endif -ifndef CORBA_DIST - include $(BUILDDIR)/common/internal/Defs-corba.gmk -endif -ifndef JAXP_DIST - include $(BUILDDIR)/common/internal/Defs-jaxp.gmk -endif -ifndef JAXWS_DIST - include $(BUILDDIR)/common/internal/Defs-jaxws.gmk -endif - -# Clean up these lists so empty lists are empty -IMPORT_TOOLS_PACKAGES := $(strip $(IMPORT_TOOLS_PACKAGES)) -IMPORT_RT_PACKAGES := $(strip $(IMPORT_RT_PACKAGES)) - -# Relative paths to import component deliverables -CLASSES_JAR_FILE=lib/classes.jar -SRC_ZIP_FILE=lib/src.zip -BIN_ZIP_FILE=lib/bin.zip -DOC_ZIP_FILE=lib/doc.zip - -################################################################# -# Macros: - -# Importing component class files -define import-one-classes -if [ "$($1)" != "" ] ; then \ - $(ECHO) "Importing classes from component $1"; \ - $(call Unjar,$2,$($1)/$(CLASSES_JAR_FILE),); \ -fi -endef - -# Importing optional component doc files (for man pages?) -define import-one-docs -if [ "$($1)" != "" -a -f $($1)/$(DOC_ZIP_FILE) ] ; then \ - $(ECHO) "Importing docs from component $1"; \ - $(call Unzipper,$2,$($1)/$(DOC_ZIP_FILE)); \ -fi -endef - -# Importing optional component src files (for jdk src.zip and javadoc) -define import-one-sources -if [ "$($1)" != "" ] ; then \ - $(ECHO) "Importing sources from component $1"; \ - $(call Unzipper,$2,$($1)/$(SRC_ZIP_FILE)); \ -fi -endef - -# Importing optional component bin files (for install image) -define import-one-binaries -if [ "$($1)" != "" -a -f $($1)/$(BIN_ZIP_FILE) ] ; then \ - $(ECHO) "Importing binaries from component $1"; \ - $(call Unzipper,$2,$($1)/$(BIN_ZIP_FILE)); \ -fi -endef - -# Unzip zip file $2 into directory $1 (if $2 exists) -# Warning: $2 must be absolute path not relative -define Unzipper -( \ - $(MKDIR) -p $1; \ - ( $(CD) $1 && $(UNZIP) -o $2 > /dev/null ) \ -) -endef - -# Unjar directories $3 from jar file $2 into directory $1 (if $2 exists) -# Warning: $2 must be absolute path not relative -define Unjar -( \ - $(MKDIR) -p $1; \ - ( $(CD) $1 && $(BOOT_JAR_CMD) xf $2 $3 $(BOOT_JAR_JFLAGS) ) && \ - ( $(CD) $1 && $(java-vm-cleanup) ) \ -) -endef - -# Import all component sources into directory $1 -define import-component-sources -$(call import-one-sources,LANGTOOLS_DIST,$1) -$(call import-one-sources,CORBA_DIST,$1) -$(call import-one-sources,JAXP_DIST,$1) -$(call import-one-sources,JAXWS_DIST,$1) -endef - -# Import all component docs into directory $1 (optional) -define import-component-docs -$(call import-one-docs,LANGTOOLS_DIST,$1) -$(call import-one-docs,CORBA_DIST,$1) -$(call import-one-docs,JAXP_DIST,$1) -$(call import-one-docs,JAXWS_DIST,$1) -endef - -# Import all component bins into directory $1 (optional) -define import-component-binaries -$(call import-one-binaries,LANGTOOLS_DIST,$1) -$(call import-one-binaries,CORBA_DIST,$1) -$(call import-one-binaries,JAXP_DIST,$1) -$(call import-one-binaries,JAXWS_DIST,$1) -if [ "$(CORBA_DIST)" = "" ] ; then \ - $(MKDIR) -p $(OUTPUTDIR)/lib ; \ - ( $(CD) $(JDK_IMPORT_PATH) && $(CP) $(IMPORT_CORBA_BINARIES) $(ABS_OUTPUTDIR)/lib ) ; \ -fi -endef - -# Import all component classes into directory $1 -# Here we special case classes coming from JDK when component not supplied -define import-component-classes -$(ECHO) "Import classes from $(JDK_IMPORT_PATH)" -if [ "$(IMPORT_TOOLS_PACKAGES)" != "" ] ; then \ - $(call Unjar,$1,$(JDK_RESOURCES_JAR),$(IMPORT_TOOLS_PACKAGES)); \ - $(call Unjar,$1,$(JDK_TOOLS_JAR),$(IMPORT_TOOLS_PACKAGES)); \ -fi -if [ "$(IMPORT_RT_PACKAGES)" != "" ] ; then \ - $(call Unjar,$1,$(JDK_RESOURCES_JAR),$(IMPORT_RT_PACKAGES)); \ - $(call Unjar,$1,$(JDK_RT_JAR),$(IMPORT_RT_PACKAGES)); \ -fi -$(call import-one-classes,LANGTOOLS_DIST,$1) -$(call import-one-classes,CORBA_DIST,$1) -$(call import-one-classes,JAXP_DIST,$1) -$(call import-one-classes,JAXWS_DIST,$1) -endef - -# Clean up import files -define import-component-sources-clean -$(RM) -r $1 -endef -define import-component-docs-clean -$(RM) -r $1 -endef -define import-component-classes-clean -$(RM) -r $(IMPORT_TOOLS_PACKAGES:%=$1/%) -$(RM) -r $(IMPORT_RT_PACKAGES:%=$1/%) -endef - diff --git a/jdk/makefiles/common/internal/NativeCompileRules.gmk b/jdk/makefiles/common/internal/NativeCompileRules.gmk deleted file mode 100644 index 68d5eca4d69..00000000000 --- a/jdk/makefiles/common/internal/NativeCompileRules.gmk +++ /dev/null @@ -1,238 +0,0 @@ -# -# Copyright (c) 1995, 2007, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Native C/C++ Compile Rules -# - --include $(SPEC) --include $(VARS) - -COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) -c -COMPILE.cc = $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c - -# -# INCREMENTAL_BUILD: Record the #include file dependencies. -# -# NOTE: We build make include files with the suffix -# $(DEPEND_SUFFIX) on every compilation. These are initially -# created as temp files just in case a ^C kills it in the middle. -# Compiler is smart enough to handle ^C and not create the .o file, or -# is supposed to be that smart, but the .$(DEPEND_SUFFIX) file -# creation here isn't. -# These .$(DEPEND_SUFFIX) files are included by Library.gmk and -# Program.gmk, when they exist (Search for 'make dependencies'). -# - -ifeq ($(INCREMENTAL_BUILD),true) - -$(OBJDIR)/%.$(DEPEND_SUFFIX): %.c - @$(prep-target) - @$(ECHO) "Creating $@" - @$(RM) $@.temp - @$(CC) $(CC_DEPEND) $(CPPFLAGS) $< 2> $(DEV_NULL) | \ - $(CC_DEPEND_FILTER) > $@.temp - @$(MV) $@.temp $@ - -$(OBJDIR)/%.$(DEPEND_SUFFIX): %.cpp - @$(prep-target) - @$(ECHO) "Creating $@" - @$(RM) $@.temp - @$(CXX) $(CC_DEPEND) $(CPPFLAGS) $(CXXFLAGS) $< 2> $(DEV_NULL) | \ - $(CC_DEPEND_FILTER) > $@.temp - @$(MV) $@.temp $@ - -endif # INCREMENTAL_BUILD - -# -# C, C++, asm files. -# -# Normal or parallel compile rule is the same, but batch compiles require -# we save up the sources files that use the same compile line so that we -# can do one compile line. -# - -ifneq ($(COMPILE_APPROACH), batch) - -$(OBJDIR)/%.$(OBJECT_SUFFIX): %.c - @$(prep-target) - $(COMPILE.c) $(CC_OBJECT_OUTPUT_FLAG)$@ $(CFLAGS_GPROF) $< - @$(check-conventions) - -$(OBJDIR)/%.$(OBJECT_SUFFIX): %.cpp - @$(prep-target) - $(COMPILE.cc) $(CC_OBJECT_OUTPUT_FLAG)$@ $(CFLAGS_GPROF) $< - @$(check-conventions) - -else - - # - # Batch compiling might be faster if the compiler was smart about recognizing - # optimization opportunities available when all files are being compiled - # the same way. Unfortunately this is rare. - # Automatic pre-compiled headers (pch) might be a possibility so we - # add any auto pch options here. - # So we save all the source files that have the same compile line as the - # first file. A normal compile pass is made after the batch compile - # to catch anything missed. - # If the compilers had a -o option that allowed us to direct where to - # write the object files to, then we would not need to save the object - # file list or move them from the make directory to the build directory. - # - - # Source names - COMPILE_LIST.c = $(OBJDIR)/.source_names_c - COMPILE_LIST.cpp = $(OBJDIR)/.source_names_cpp - - # Object file list - COMPILE_OBJ_LIST.c = $(OBJDIR)/.obj_names_c - COMPILE_OBJ_LIST.cpp = $(OBJDIR)/.obj_names_cpp - - # The compile line - COMPILE_BATCH.c = $(OBJDIR)/.compile_c - COMPILE_BATCH.cpp = $(OBJDIR)/.compile_cpp - - # The compile line for the current target - THIS_COMPILE_BATCH.c = $(COMPILE_BATCH.c)-$(@F) - THIS_COMPILE_BATCH.cpp = $(COMPILE_BATCH.cpp)-$(@F) - -$(OBJDIR)/%.$(OBJECT_SUFFIX): %.c - @$(prep-target) - @$(ECHO) "$(COMPILE.c) $(CFLAGS_GPROF)" > $(THIS_COMPILE_BATCH.c) - @if [ ! -s $(COMPILE_BATCH.c) ] ; then \ - $(CP) $(THIS_COMPILE_BATCH.c) $(COMPILE_BATCH.c) ; \ - $(ECHO) $< > $(COMPILE_LIST.c); \ - $(ECHO) $(@F) > $(COMPILE_OBJ_LIST.c); \ - elif [ "`$(DIFF) -w -b $(THIS_COMPILE_BATCH.c) $(COMPILE_BATCH.c)`" \ - = "" ] ; then \ - $(ECHO) $< >> $(COMPILE_LIST.c); \ - $(ECHO) $(@F) >> $(COMPILE_OBJ_LIST.c); \ - fi - @$(RM) $(THIS_COMPILE_BATCH.c) - @$(check-conventions) - -$(OBJDIR)/%.$(OBJECT_SUFFIX): %.cpp - @$(prep-target) - @$(ECHO) "$(COMPILE.cc) $(CFLAGS_GPROF)" > $(THIS_COMPILE_BATCH.cpp) - @if [ ! -s $(COMPILE_BATCH.cpp) ] ; then \ - $(CP) $(THIS_COMPILE_BATCH.cpp) $(COMPILE_BATCH.cpp) ; \ - $(ECHO) $< > $(COMPILE_LIST.cpp); \ - $(ECHO) $(@F) > $(COMPILE_OBJ_LIST.cpp); \ - elif [ "`$(DIFF) -w -b $(THIS_COMPILE_BATCH.cpp) $(COMPILE_BATCH.cpp)`"\ - = "" ] ; then \ - $(ECHO) $< >> $(COMPILE_LIST.cpp); \ - $(ECHO) $(@F) >> $(COMPILE_OBJ_LIST.cpp); \ - fi - @$(RM) $(THIS_COMPILE_BATCH.cpp) - @$(check-conventions) - -batch_compile: $(FILES_o) - @$(ECHO) "Doing batch compilations" - @if [ -s $(COMPILE_LIST.c) ] ; then \ - $(ECHO) "$(COMPILE.c) $(CFLAGS_GPROF) $(AUTOMATIC_PCH_OPTION) \ - `$(CAT) $(COMPILE_LIST.c)`" ; \ - ( $(COMPILE.c) $(CFLAGS_GPROF) $(AUTOMATIC_PCH_OPTION) \ - `$(CAT) $(COMPILE_LIST.c)` && \ - $(ECHO) "$(MV) `$(CAT) $(COMPILE_OBJ_LIST.c)` $(OBJDIR)" && \ - $(MV) `$(CAT) $(COMPILE_OBJ_LIST.c)` $(OBJDIR) ) || exit 1 ; \ - fi - @if [ -s $(COMPILE_LIST.cpp) ] ; then \ - $(ECHO) "$(COMPILE.cc) $(CFLAGS_GPROF) $(AUTOMATIC_PCH_OPTION) \ - `$(CAT) $(COMPILE_LIST.cpp)`" ; \ - ( $(COMPILE.cc) $(CFLAGS_GPROF) $(AUTOMATIC_PCH_OPTION) \ - `$(CAT) $(COMPILE_LIST.cpp)` && \ - $(ECHO) "$(MV) `$(CAT) $(COMPILE_OBJ_LIST.cpp)` $(OBJDIR)" && \ - $(MV) `$(CAT) $(COMPILE_OBJ_LIST.cpp)` $(OBJDIR) ) || exit 1 ; \ - fi - @$(RM) $(COMPILE_BATCH.c) $(COMPILE_LIST.c) $(COMPILE_OBJ_LIST.c) - @$(RM) $(COMPILE_BATCH.cpp) $(COMPILE_LIST.cpp) $(COMPILE_OBJ_LIST.cpp) - -endif - -# newer as does not handle c++ style comments -$(OBJDIR)/%.$(OBJECT_SUFFIX): %.s - ifneq ($(CC_VERSION), gcc) - @$(prep-target) - $(COMPILE.s) $(CC_OBJECT_OUTPUT_FLAG)$@ $< - else - @$(prep-target) - $(CPP) -x assembler-with-cpp $< | $(COMPILE.s) -o $@ - endif - @$(check-conventions) - -# Obj-C files (Mac OS X only). -ifeq ($(PLATFORM), macosx) -$(OBJDIR)/%.$(OBJECT_SUFFIX): %.m - @$(prep-target) - $(COMPILE.c) $(CC_OBJECT_OUTPUT_FLAG)$@ $(CFLAGS_GPROF) $< - @$(check-conventions) - -$(OBJDIR)/%.$(OBJECT_SUFFIX): %.mm - @$(prep-target) - $(COMPILE.cc) $(CC_OBJECT_OUTPUT_FLAG)$@ $(CFLAGS_GPROF) $< - @$(check-conventions) - -$(OBJDIR)/%.$(OBJECT_SUFFIX): %.c - @$(prep-target) - $(COMPILE.c) $(CC_OBJECT_OUTPUT_FLAG)$@ $(CFLAGS_GPROF) $< - @$(check-conventions) -endif # PLATFORM - -# -# Quick hack for making the compiler generate just the assembly file. -# $ gnumake obj/sparc/myfile.s -# -$(OBJDIR)/%.s: %.c - @$(prep-target) - $(COMPILE.c) $(CC_OBJECT_OUTPUT_FLAG)$@ -S $< - @$(check-conventions) - -# remove the intermediate files from the directories. -# (If VARIANT=OPT, this removes all debug and fastdebug files too) -clobber clean:: - $(RM) -r $(OBJDIR) - $(RM) -r $(OBJDIR)_* - -# -# Lint support -# (The 'lint' rule below is an older rule not using the .$(LINT_SUFFIX) files) -# - -ifeq ($(PLATFORM), solaris) -$(OBJDIR)/%.$(LINT_SUFFIX): %.c - @$(prep-target) - $(LINT.c) -dirout=$(OBJDIR) -c $< -lint.clean: - $(RM) $(OBJDIR)/*.$(LINT_SUFFIX) -# Old rule -lint: $(FILES_c) - ifneq ($(FILES_c),) - $(LINT.c) -Ncheck -Nlevel=3 $? $(LDLIBS) > lint.$(ARCH) 2>&1 - endif -endif - -.PHONY: batch_compile - - diff --git a/jdk/makefiles/common/internal/Resources.gmk b/jdk/makefiles/common/internal/Resources.gmk deleted file mode 100644 index 2b5c1e7bd16..00000000000 --- a/jdk/makefiles/common/internal/Resources.gmk +++ /dev/null @@ -1,262 +0,0 @@ -# -# Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Generic mechanism for installing properties files, resource bundles, -# and other resource files. -# -# FILES_properties should be defined. -# FILES_compiled_properties should be defined. -# -# If COMPILED_PROPERTIES_SUPERCLASS is defined, ALL the FILES_properties -# files will be compiled into java with this super class. -# -# You can add locales to LOCALE_SUFFIXES explicitly, or use the -# LOCALE_SET_DEFINITION variable to add some pre-defined locale lists. -# The LOCALE_SET_DEFINITION can have the value: jre, plugin, or jdk. -# -# Resource bundles to be installed are identified using the following variables. -# Note that only the file name of the base bundle is given; localized versions -# are added automatically. For Java files, use a format suitable for inclusion -# in the FILES_java list; dito for properties, all relative paths. -# -# NEW_RESOURCE_BUNDLES_JAVA - new resource bundles implemented in -# Java, not localized -# RESOURCE_BUNDLES_JAVA - resource bundles implemented in -# Java, localized -# -# The following variable is now used for most .properties files in the JDK. -# These properties files are converted into java and compiled with javac. -# The resulting .class files are usually smaller and are always faster to load. -# The relative path to the properties file becomes a relative path to a -# java source file. -# -# RESOURCE_BUNDLES_COMPILED_PROPERTIES - resource bundles implemented as -# properties files, localized -# NEW_RESOURCE_BUNDLES_COMPILED_PROPERTIES - same as above, not localized -# -# For non-compiled properties files, use the following variables: -# -# NEW_RESOURCE_BUNDLES_UNCOMPILED_PROPERTIES - new resource bundles implemented as -# properties files, not localized -# RESOURCE_BUNDLES_UNCOMPILED_PROPERTIES - resource bundles implemented as -# properties files, localized -# -# Other properties files to be installed are identified using the variable: -# -# OTHER_PROPERTIES -# - -include $(SPEC) -include $(SRC_ROOT)/jdk/makefiles/Tools.gmk - -# Compile properties files into java source? -ifdef COMPILED_PROPERTIES_SUPERCLASS - # Add all properties files to the compiled properties list (all or nothing) - COMPILED_PROPERTIES += $(FILES_compiled_properties) $(FILES_properties) -else - COMPILED_PROPERTIES_SUPERCLASS = ListResourceBundle - COMPILED_PROPERTIES += $(FILES_compiled_properties) -endif - -# Determine the locale suffixes needed beyond the base bundle - -ifeq ($(LOCALE_SET_DEFINITION), plugin) - LOCALE_SUFFIXES += $(PLUGIN_LOCALES) -endif -ifeq ($(LOCALE_SET_DEFINITION), jdk) - LOCALE_SUFFIXES += $(JDK_LOCALES) -endif -ifeq ($(LOCALE_SET_DEFINITION), jre) - LOCALE_SUFFIXES += $(JRE_LOCALES) -endif - -# Java files get tacked onto the standard list of files to compile -RESOURCE_BUNDLE_FILES_java += $(NEW_RESOURCE_BUNDLES_JAVA) -RESOURCE_BUNDLE_FILES_java += $(RESOURCE_BUNDLES_JAVA) \ - $(foreach file,$(RESOURCE_BUNDLES_JAVA), \ - $(foreach locale,$(LOCALE_SUFFIXES), \ - $(basename $(file))_$(locale).java)) - -# Add to java sources list -FILES_java += $(RESOURCE_BUNDLE_FILES_java) - -# Compiled properties files are translated to .java. -# The .java files are generated into GENSRCDIR. -COMPILED_PROPERTIES += $(NEW_RESOURCE_BUNDLES_COMPILED_PROPERTIES) -COMPILED_PROPERTIES += $(RESOURCE_BUNDLES_COMPILED_PROPERTIES) \ - $(foreach file,$(RESOURCE_BUNDLES_COMPILED_PROPERTIES),\ - $(foreach locale,$(LOCALE_SUFFIXES),\ - $(basename $(file))_$(locale)$(suffix $(file)))) - -# Add to java sources list -FILES_java += $(COMPILED_PROPERTIES:%.properties=%.java) - -# Non-compiled files -PROPERTIES_FILES += $(NEW_RESOURCE_BUNDLES_UNCOMPILED_PROPERTIES) -PROPERTIES_FILES += $(RESOURCE_BUNDLES_UNCOMPILED_PROPERTIES) \ - $(foreach file,$(RESOURCE_BUNDLES_UNCOMPILED_PROPERTIES), \ - $(foreach locale,$(LOCALE_SUFFIXES), \ - $(basename $(file))_$(locale)$(suffix $(file)))) -# other properties -PROPERTIES_FILES += $(OTHER_PROPERTIES) - -# -# Process and strip all non-compiled properties files (in a batch mode) -# -STRIP_PROP_FILES = $(PROPERTIES_FILES:%=$(CLASSDESTDIR)/%) -# To efficiently strip properties we use one run of StripProperties. -# This macro gathers an option for use later. -STRIP_PROP_options=$(TEMPDIR)/strip_prop_options -define install-properties-file -$(install-file) -$(call chmod-file, a+rw) -@$(ECHO) "# Adding to strip properties list: $@" -$(ECHO) "$@" >> $(STRIP_PROP_options) -endef - -# Constructs command line options file -$(STRIP_PROP_options): $(STRIP_PROP_FILES) - @$(TOUCH) $@ -strip_prop_options_clean: - @$(RM) $(STRIP_PROP_options) - -# Strip the properties files -strip_all_props: $(BUILD_TOOLS) $(STRIP_PROP_options) - @if [ -s $(STRIP_PROP_options) ] ; then \ - $(ECHO) "$(TOOL_STRIPPROPERTIES) @$(STRIP_PROP_options)" ; \ - $(TOOL_STRIPPROPERTIES) @$(STRIP_PROP_options) ; \ - fi - @$(java-vm-cleanup) - -# -# Creates files in CLASSDESTDIR -# - -# In some cases, we move files from package to resources subdir -$(CLASSDESTDIR)/$(PKGDIR)/resources/%.properties: \ - $(SHARE_SRC)/classes/$(PKGDIR)/%.properties - $(install-properties-file) -$(CLASSDESTDIR)/%.properties: $(SHARE_SRC)/classes/%.properties - $(install-properties-file) -$(CLASSDESTDIR)/%.res: $(SHARE_SRC)/classes/%.res - $(install-file) -$(CLASSDESTDIR)/%.dtd: $(SHARE_SRC)/classes/%.dtd - $(install-file) -$(CLASSDESTDIR)/%.xml: $(SHARE_SRC)/classes/%.xml - $(install-file) -$(CLASSDESTDIR)/%.prp: $(SHARE_SRC)/classes/%.prp - $(install-file) - -# -# To efficiently compile properties into java sources we use one run -# of compileproperties. This macro gathers an option for use later. -# Note: The properties file and java source name can be different -# locales, e.g. zh_TW and zh_HK. The java source filename -# determines the name of the class. -COMPILE_PROP_options=$(TEMPDIR)/compile_prop_options -define add-property-java-file -@$(prep-target) -@$(ECHO) "# Adding to compile properties list: $? -> $@" -$(ECHO) "-compile $? $@ $(COMPILED_PROPERTIES_SUPERCLASS)" \ - >> $(COMPILE_PROP_options) -endef - -$(GENSRCDIR)/%.java: $(PLATFORM_SRC)/classes/%.properties - $(add-property-java-file) -$(GENSRCDIR)/%.java: $(SHARE_SRC)/classes/%.properties - $(add-property-java-file) -$(GENSRCDIR)/%.java: $(GENSRCDIR)/%.properties - $(add-property-java-file) -ifndef OPENJDK -$(GENSRCDIR)/%.java: $(CLOSED_PLATFORM_SRC)/classes/%.properties - $(add-property-java-file) -$(GENSRCDIR)/%.java: $(CLOSED_SHARE_SRC)/classes/%.properties - $(add-property-java-file) -endif - -# Create HK java file from zh_TW (explicit resource bundles only) -define create-hk-java-file -@$(prep-target) -$(CAT) $< | $(SED) -e '/class/s/_zh_TW/_zh_HK/' > $@ -endef - -# Explicit resource bundles -$(GENSRCDIR)/%_zh_HK.java: $(PLATFORM_SRC)/classes/%_zh_TW.java - $(create-hk-java-file) -$(GENSRCDIR)/%_zh_HK.java: $(SHARE_SRC)/classes/%_zh_TW.java - $(create-hk-java-file) - -# Compile of zh_HK properties just uses the zh_TW properties files -$(GENSRCDIR)/%_zh_HK.java: $(PLATFORM_SRC)/classes/%_zh_TW.properties - $(add-property-java-file) -$(GENSRCDIR)/%_zh_HK.java: $(SHARE_SRC)/classes/%_zh_TW.properties - $(add-property-java-file) - -# Simple delivery of zh_HK properties files just copies zh_TW properties files -$(CLASSDESTDIR)/%_zh_HK.properties: \ - $(PLATFORM_SRC)/classes/%_zh_TW.properties - $(install-properties-file) -$(CLASSDESTDIR)/%_zh_HK.properties: \ - $(SHARE_SRC)/classes/%_zh_TW.properties - $(install-properties-file) - -# List of java files converted from properties files needed -COMPILE_PROP_JAVA_FILES = $(COMPILED_PROPERTIES:%.properties=$(GENSRCDIR)/%.java) - -# Constructs command line options file -$(COMPILE_PROP_options): $(COMPILE_PROP_JAVA_FILES) - @$(TOUCH) $@ -compile_prop_options_clean: - @$(RM) $(COMPILE_PROP_options) - -# Make sure all are compiled, one compiler run -compile_all_props: $(BUILD_TOOLS) $(COMPILE_PROP_options) - @if [ `$(CAT) $(COMPILE_PROP_options) | $(WC) -l` -ge 1 ] ; then \ - $(MKDIR) -p $(GENSRCDIR); \ - $(ECHO) "$(TOOL_COMPILEPROPERTIES) @$(COMPILE_PROP_options)";\ - $(TOOL_COMPILEPROPERTIES) @$(COMPILE_PROP_options) ; \ - $(java-vm-cleanup); \ - fi - -# Make sure the build rule creates all the properties -resources: - -ifneq ($(strip $(PROPERTIES_FILES)),) - resources: strip_prop_options_clean strip_all_props - clobber clean:: - $(RM) $(STRIP_PROP_FILES) $(STRIP_PROP_options) -endif - -ifneq ($(strip $(COMPILED_PROPERTIES)),) - resources: compile_prop_options_clean compile_all_props - clobber clean:: - $(RM) $(COMPILE_PROP_JAVA_FILES) $(COMPILE_PROP_options) -endif - -.PHONY: resources \ - compile_prop_options_clean compile_all_props \ - strip_prop_options_clean strip_all_props - diff --git a/jdk/makefiles/common/shared/Compiler-gcc.gmk b/jdk/makefiles/common/shared/Compiler-gcc.gmk deleted file mode 100644 index 3b6923eac06..00000000000 --- a/jdk/makefiles/common/shared/Compiler-gcc.gmk +++ /dev/null @@ -1,98 +0,0 @@ -# -# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# GCC Compiler settings -# - -ifeq ($(PLATFORM), windows) - - # Settings specific to Windows, pretty stale, hasn't been used - CC ?= $(COMPILER_PATH)gcc - CPP ?= $(COMPILER_PATH)gcc -E - CXX ?= $(COMPILER_PATH)g++ - CCC ?= $(COMPILER_PATH)g++ - AR ?= $(COMPILER_PATH)lib - LINK ?= $(COMPILER_PATH)link - RC ?= $(COMPILER_PATH)rc - LINK32 = $(LINK) - RSC = $(RC) - # unset any GNU Make settings of MFLAGS and MAKEFLAGS which may mess up nmake - NMAKE = MFLAGS= MAKEFLAGS= $(COMPILER_PATH)nmake -nologo - ifeq ($(ARCH_DATA_MODEL), 32) - CC_VER = UNKNOWN - else - CC_VER = UNKNOWN - endif - _LINK_VER :=$(shell $(LINK) 2>&1 | $(HEAD) -n 1) - LINK_VER :=$(call GetVersion,"$(_LINK_VER)") - -endif - -ifeq ($(PLATFORM), linux) - -# Settings specific to Linux - CC ?= $(COMPILER_PATH)gcc - CPP ?= $(COMPILER_PATH)gcc -E -# Acquire the paths to the compilers and tools - # statically link libstdc++ before C++ ABI is stablized on Linux - STATIC_CXX = true - ifeq ($(STATIC_CXX),true) - # g++ always dynamically links libstdc++, even we use "-Wl,-Bstatic -lstdc++" - # We need to use gcc to statically link the C++ runtime. gcc and g++ use - # the same subprocess to compile C++ files, so it is OK to build using gcc. - CXX ?= $(CC) - #$(COMPILER_PATH)gcc - else -# CXX = $(COMPILER_PATH)g++ - endif - # Option used to create a shared library - SHARED_LIBRARY_FLAG = -shared - SUN_COMP_VER := $(shell $(CC) --verbose 2>&1 ) - -endif - -ifeq ($(PLATFORM), solaris) - - # Settings specific to Solaris - CC ?= $(COMPILER_PATH)gcc - CPP ?= $(COMPILER_PATH)gcc -E - CXX ?= $(COMPILER_PATH)g++ - - # Option used to create a shared library - SHARED_LIBRARY_FLAG = -G - -endif - -# Get gcc version -_CC_VER :=$(shell $(CC) -dumpversion 2>&1 ) -CC_VER :=$(call GetVersion,"$(_CC_VER)") -CC_MAJORVER :=$(call MajorVersion,$(CC_VER)) -CC_MINORVER :=$(call MinorVersion,$(CC_VER)) - -# Name of compiler -COMPILER_NAME = GCC$(call MajorVersion,$(CC_VER)) -COMPILER_VERSION = $(COMPILER_NAME) - diff --git a/jdk/makefiles/common/shared/Compiler-llvm.gmk b/jdk/makefiles/common/shared/Compiler-llvm.gmk deleted file mode 100644 index 0b26a08cd24..00000000000 --- a/jdk/makefiles/common/shared/Compiler-llvm.gmk +++ /dev/null @@ -1,59 +0,0 @@ -# -# Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# LLVM Compiler settings -# - -ifeq ($(PLATFORM), macosx) - - # Settings specific to Mac OS X - ifeq ($(origin CC), default) - CC = $(COMPILER_PATH)llvm-gcc - endif - CPP = $(COMPILER_PATH)llvm-gcc -E - ifeq ($(origin CXX), default) - CXX = $(COMPILER_PATH)llvm-g++ - endif - - REQUIRED_CC_VER = 4.2.1 - - # Option used to create a shared library - SHARED_LIBRARY_FLAG = -Wl,-install_name,@rpath/$(@F) -dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 - SUN_COMP_VER := $(shell $(CC) --verbose 2>&1 ) - - AR = $(CC) - ARFLAGS = -nostdlib -r -arch i386 -arch x86_64 -o - -endif - -# Get llvm version -_CC_VER :=$(shell $(CC) -dumpversion 2>&1 ) -CC_VER :=$(call GetVersion,"$(_CC_VER)") - -# Name of compiler -COMPILER_NAME = LLVM-GCC$(call MajorVersion,$(CC_VER)) -COMPILER_VERSION = $(COMPILER_NAME) - diff --git a/jdk/makefiles/common/shared/Compiler-msvc.gmk b/jdk/makefiles/common/shared/Compiler-msvc.gmk deleted file mode 100644 index b5007022664..00000000000 --- a/jdk/makefiles/common/shared/Compiler-msvc.gmk +++ /dev/null @@ -1,93 +0,0 @@ -# -# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# MSVC Compiler settings -# - -ifeq ($(PLATFORM), windows) - CC ?= $(COMPILER_PATH)cl - CPP ?= $(COMPILER_PATH)cl - CXX ?= $(COMPILER_PATH)cl - CCC ?= $(COMPILER_PATH)cl - AR ?= $(COMPILER_PATH)lib - LINK ?= $(COMPILER_PATH)link - LINK32 ?= $(LINK) -# TODO Add dumpbin.exe to configure - DUMPBIN ?= $(COMPILER_PATH)dumpbin.exe - - # Fill in unknown values - COMPILER_NAME=Unknown MSVC Compiler - COMPILER_VERSION= - - # unset any GNU Make settings of MFLAGS and MAKEFLAGS which may mess up nmake - NMAKE = MFLAGS= MAKEFLAGS= $(COMPILER_PATH)nmake -nologo - - # Compiler version and type (Always get word after "Version") - CC_VER := $(shell $(CC) 2>&1 | $(HEAD) -n 1 | $(SED) 's/.*\(Version.*\)/\1/' | $(NAWK) '{print $$2}') - - LINK_VER := $(shell $(LINK) | $(HEAD) -n 1 | $(NAWK) '{print $$6}') - CC_MAJORVER :=$(call MajorVersion,$(CC_VER)) - - # The VS2010 compiler is the same one used on both 32bit and 64bit - ifeq ($(CC_MAJORVER), 16) - COMPILER_NAME=Microsoft Visual Studio 10 (16.00.30319.01) - COMPILER_VERSION=VS2010 - ifeq ($(WINDOWSSDKDIR),) - WINDOWSSDKDIR := $(error WINDOWSSDKDIR cannot be empty here) - endif - ifeq ($(ARCH_DATA_MODEL), 32) - _OTHER_TOOLS_BIN = $(WINDOWSSDKDIR)/Bin - else - ifeq ($(ARCH), ia64) - _OTHER_TOOLS_BIN = $(WINDOWSSDKDIR)/Bin/ia64 - else - _OTHER_TOOLS_BIN = $(WINDOWSSDKDIR)/Bin/x64 - endif - endif - RC = $(_OTHER_TOOLS_BIN)/RC.Exe - REBASE = $(_OTHER_TOOLS_BIN)/ReBase.Exe - MT = $(_OTHER_TOOLS_BIN)/mt.exe - MTL = $(_OTHER_TOOLS_BIN)/midl.exe - endif - - # These variables can never be empty - ifndef COMPILER_PATH - COMPILER_PATH := $(error COMPILER_PATH cannot be empty here) - endif - ifndef COMPILER_VERSION - COMPILER_VERSION := $(error COMPILER_VERSION cannot be empty here) - endif - ifneq ($(COMPILER_VERSION),VS2010) - COMPILER_VERSION := $(error COMPILER_VERSION must be VS2010) - endif - - # Shared library generation flag - SHARED_LIBRARY_FLAG = -LD - # RSC is always same as RC (Not sure who uses this RSC variable) - RSC = $(RC) - -endif - diff --git a/jdk/makefiles/common/shared/Compiler-sun.gmk b/jdk/makefiles/common/shared/Compiler-sun.gmk deleted file mode 100644 index 539ba98f22a..00000000000 --- a/jdk/makefiles/common/shared/Compiler-sun.gmk +++ /dev/null @@ -1,138 +0,0 @@ -# -# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Sun Studio Compiler settings -# - -# Sun Studio Compiler settings specific to Solaris -ifeq ($(PLATFORM), solaris) - CC ?= $(COMPILER_PATH)cc - CPP ?= $(COMPILER_PATH)cc -E - CXX ?= $(COMPILER_PATH)CC - LINT ?= $(COMPILER_PATH)lint - # Option used to create a shared library - SHARED_LIBRARY_FLAG = -G - GCC =$(GCC_COMPILER_PATH)gcc -endif - -# Sun Studio Compiler settings specific to Linux -ifeq ($(PLATFORM), linux) - # This has not been tested - CC ?= $(COMPILER_PATH)cc - CPP ?= $(COMPILER_PATH)cc -E - CXX ?= $(COMPILER_PATH)CC - LINT ?= $(COMPILER_PATH)lint - # statically link libstdc++ before C++ ABI is stablized on Linux - STATIC_CXX = true - ifeq ($(STATIC_CXX),true) - # CC always dynamically links libstdc++, even we use "-Wl,-Bstatic -lstdc++" - # We need to use cc to statically link the C++ runtime. - CXX ?= $(COMPILER_PATH)cc - else - CXX ?= $(COMPILER_PATH)CC - endif - # Option used to create a shared library - SHARED_LIBRARY_FLAG = -G -endif - -# Get compiler version -_CC_VER :=$(shell $(CC) -V 2>&1 | $(HEAD) -n 1) -CC_VER :=$(call GetVersion,"$(_CC_VER)") -CC_MAJORVER :=$(call MajorVersion,$(CC_VER)) -CC_MINORVER :=$(call MinorVersion,$(CC_VER)) - -# Name of compilers being used -COMPILER_VERSION-5.7 = SS10 -COMPILER_NAME-5.7 = Sun Studio 10 -COMPILER_VERSION-5.8 = SS11 -COMPILER_NAME-5.8 = Sun Studio 11 -COMPILER_VERSION-5.9 = SS12 -COMPILER_NAME-5.9 = Sun Studio 12 -COMPILER_VERSION-5.10 = SS12u1 -COMPILER_NAME-5.10 = Sun Studio 12 Update 1 -COMPILER_VERSION-5.11 = OSS12u2 -COMPILER_NAME-5.11 = Oracle Solaris Studio 12 Update 2 -COMPILER_VERSION = $(COMPILER_VERSION-$(CC_VER)) -COMPILER_NAME = $(COMPILER_NAME-$(CC_VER)) - -# Arch specific settings (determines type of .o files and instruction set) -# Starting in SS12 (5.9), the arch options changed. -# The assembler /usr/ccs/bin/as wants older SS11 (5.8) style options. -# Note: We need to have both 32 and 64 values at all times for awt Makefiles. -# -XARCH_OPTION_OLD/32 = -XARCH_OPTION_OLD/64 = -XARCH_OPTION_NEW/32 = -m32 -XARCH_OPTION_NEW/64 = -m64 -# Lint options are slightly different -LINT_XARCH_OPTION_OLD/32 = -LINT_XARCH_OPTION_OLD/64 = -LINT_XARCH_OPTION_NEW/32 = -m32 -LINT_XARCH_OPTION_NEW/64 = -m64 -ifeq ($(ARCH_FAMILY), sparc) - ifdef VIS_NEEDED - XARCH_OPTION_OLD/32 += -xarch=v8plusa - XARCH_OPTION_OLD/64 += -xarch=v9a - XARCH_OPTION_NEW/32 += -xarch=sparcvis - XARCH_OPTION_NEW/64 += -xarch=sparcvis - else - # Someday this should change to improve optimization on UltraSPARC - # and abandon v8, even change to sparcvis or sparcvis2, this - # abandons machines like the SPARCstation 10. - # Indications with jdk6 is that alacrity runs do not show a - # big improvement using v8plus over v8, but other benchmarks might. - XARCH_OPTION_OLD/32 += -xarch=v8 - XARCH_OPTION_OLD/64 += -xarch=v9 - # Note that this new option (SS12+) effectively means v8plus - XARCH_OPTION_NEW/32 += -xarch=sparc - XARCH_OPTION_NEW/64 += -xarch=sparc - endif - LINT_XARCH_OPTION_OLD/64 += -Xarch=v9 -endif -ifeq ($(ARCH_FAMILY), i586) - XARCH_OPTION_OLD/64 += -xarch=amd64 - LINT_XARCH_OPTION_OLD/64 += -Xarch=amd64 -endif -# Pick the options we want based on the compiler being used. (5.9 or newer) -CC_59_OR_NEWER := \ - $(shell expr $(CC_MAJORVER) \> 5 \| \ - \( $(CC_MAJORVER) = 5 \& $(CC_MINORVER) \>= 9 \) ) -ifeq ($(CC_59_OR_NEWER), 1) - XARCH_OPTION/32 = $(XARCH_OPTION_NEW/32) - XARCH_OPTION/64 = $(XARCH_OPTION_NEW/64) - LINT_XARCH_OPTION/32 = $(LINT_XARCH_OPTION_NEW/32) - LINT_XARCH_OPTION/64 = $(LINT_XARCH_OPTION_NEW/64) -else - XARCH_OPTION/32 = $(XARCH_OPTION_OLD/32) - XARCH_OPTION/64 = $(XARCH_OPTION_OLD/64) - LINT_XARCH_OPTION/32 = $(LINT_XARCH_OPTION_OLD/32) - LINT_XARCH_OPTION/64 = $(LINT_XARCH_OPTION_OLD/64) -endif -XARCH_OPTION = $(XARCH_OPTION/$(ARCH_DATA_MODEL)) -LINT_XARCH_OPTION = $(LINT_XARCH_OPTION/$(ARCH_DATA_MODEL)) -# The /usr/ccs/bin/as assembler always wants the older SS11 (5.8) options. -AS_XARCH_OPTION = $(XARCH_OPTION_OLD/$(ARCH_DATA_MODEL)) - diff --git a/jdk/makefiles/common/shared/Defs-control.gmk b/jdk/makefiles/common/shared/Defs-control.gmk deleted file mode 100644 index 3a5dc1686d2..00000000000 --- a/jdk/makefiles/common/shared/Defs-control.gmk +++ /dev/null @@ -1,143 +0,0 @@ -# -# Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Common variables used by all the Java makefiles. This file should -# not contain rules. -# - -# WARNING: This file is shared with other components. -# - -ifndef JDK_MAKE_SHARED_DIR - JDK_MAKE_SHARED_DIR = $(JDK_TOPDIR)/makefiles/common/shared -endif - -ifndef HOTSPOT_TOPDIR - HOTSPOT_TOPDIR=$(TOPDIR)/hotspot -endif -ifndef LANGTOOLS_TOPDIR - LANGTOOLS_TOPDIR=$(TOPDIR)/langtools -endif -ifndef CORBA_TOPDIR - CORBA_TOPDIR=$(TOPDIR)/corba -endif -ifndef JAXP_TOPDIR - JAXP_TOPDIR=$(TOPDIR)/jaxp -endif -ifndef JAXWS_TOPDIR - JAXWS_TOPDIR=$(TOPDIR)/jaxws -endif -ifndef JDK_TOPDIR - JDK_TOPDIR=$(TOPDIR)/jdk -endif -ifndef INSTALL_TOPDIR - INSTALL_TOPDIR=$(TOPDIR)/install -endif -ifndef SPONSORS_TOPDIR - SPONSORS_TOPDIR=$(TOPDIR)/sponsors -endif -ifndef DEPLOY_TOPDIR - DEPLOY_TOPDIR=$(TOPDIR)/deploy -endif - -# Get shared platform settings -include $(JDK_MAKE_SHARED_DIR)/Platform.gmk - -# Default directory immediately above the "build" output directory (OUTPUTDIR) -BUILD_PARENT_DIRECTORY=$(TOPDIR) - -# Get platform specific settings -include $(JDK_MAKE_SHARED_DIR)/Defs.gmk - -SRC_BUNDLEDIR = $(OUTPUTDIR)/source-bundles -ABS_SRC_BUNDLEDIR = $(ABS_OUTPUTDIR)/source-bundles -BIN_BUNDLEDIR = $(OUTPUTDIR)/bundles -BIN_DEMOS_BUNDLEDIR = $(OUTPUTDIR)/demos-bundles -ABS_BIN_BUNDLEDIR = $(ABS_OUTPUTDIR)/bundles - -dummy := $(shell $(MKDIR) -p $(BIN_BUNDLEDIR)) -dummy := $(shell $(MKDIR) -p $(BIN_DEMOS_BUNDLEDIR) ) -dummy := $(shell $(MKDIR) -p $(SRC_BUNDLEDIR) ) - -TEMP_DIR = $(OUTPUTDIR)/tmp -ABS_TEMP_DIR = $(ABS_OUTPUTDIR)/tmp - -dummy := $(shell $(MKDIR) -p $(TEMP_DIR)) - -# The language version we want for this jdk build -SOURCE_LANGUAGE_VERSION=7 -# The class version we want for this jdk build -TARGET_CLASS_VERSION=7 - -# The MESSAGE, WARNING and ERROR files are used to store sanity check and -# source check messages, warnings and errors. -export ERROR_FILE := $(ABS_OUTPUTDIR)/sanityCheckErrors.txt -export WARNING_FILE := $(ABS_OUTPUTDIR)/sanityCheckWarnings.txt -export MESSAGE_FILE := $(ABS_OUTPUTDIR)/sanityCheckMessages.txt - -# source bundle generation definitions -BUNDLE_DATE := $(shell $(DATE) '+%d_%b_%Y' | $(TR) "[A-Z]" "[a-z]") -ifdef ALT_BUNDLE_DATE - BUNDLE_DATE := $(ALT_BUNDLE_DATE) -endif - -# If the update version contains non-numeric characters, we need -# to massage it into a numeric format. Unfortunately, the -# Windows VERSIONINFO resource that we stick in jvm.dll cannot -# handle non-numeric characters. We have to do this here because -# Hotspot (nmake) cannot handle calculations. So we use the -# following formula: -# COOKED_JDK_UPDATE_VERSION = JDK_UPDATE_VERSION * 10 + EXCEPTION_VERSION -# -# Here are some examples: -# 1.5.0 b01 -> 5,0,0,1 -# 1.5.0_10 b01 -> 5,0,100,1 -# 1.4.2 b01 -> 4,2,0,1 -# 1.4.2_02 b01 -> 4,2,20,1 -# 1.4.2_02a b01 -> 4,2,21,1 -# 1.4.2_02b b01 -> 4,2,22,1 -ifdef JDK_UPDATE_VERSION - VTMP := $(shell $(ECHO) $(JDK_UPDATE_VERSION) | $(TR) "abcde" "12345") - CHAR1 := $(shell $(ECHO) $(VTMP) | $(NAWK) '{print substr($$1, 1, 1);}') - CHAR2 := $(shell $(ECHO) $(VTMP) | $(NAWK) '{print substr($$1, 2, 1);}') - CHAR3 := $(shell $(ECHO) $(VTMP) | $(NAWK) '{print substr($$1, 3, 1);}') - ifeq ($(CHAR3),) - CHAR3 := 0 - endif - ifeq ($(CHAR1), 0) - COOKED_JDK_UPDATE_VERSION := $(CHAR2)$(CHAR3) - else - COOKED_JDK_UPDATE_VERSION := $(CHAR1)$(CHAR2)$(CHAR3) - endif -endif - -ifneq ($(JDK_BUILD_NUMBER),) - COOKED_BUILD_NUMBER = $(shell $(ECHO) $(JDK_BUILD_NUMBER) \ - | $(SED) -e 's/^b//' | $(SED) -e 's/^0//') -else - COOKED_BUILD_NUMBER = 0 -endif - diff --git a/jdk/makefiles/common/shared/Defs-java.gmk b/jdk/makefiles/common/shared/Defs-java.gmk deleted file mode 100644 index 897b24d77a3..00000000000 --- a/jdk/makefiles/common/shared/Defs-java.gmk +++ /dev/null @@ -1,249 +0,0 @@ -# -# Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Common java/javac/jdk variables used by all the Java makefiles. -# This file should not contain rules. -# - -# WARNING: This file is shared with other workspaces. -# So when it includes other files, it must use JDK_TOPDIR. -# - --include $(SPEC) - -# -# Memory related -J flags that all uses of java tools should use. -# -#JAVA_MEM_FLAGS = -Xmx$(MAX_VM_MEMORY)m -#ifeq ($(ARCH), ia64) - # Special flags for javac on ia64 to work around a VM problem with - # bad code generation during inlining (what version had this problem?): - # Suspect this may not be needed anymore. -# JAVA_MEM_FLAGS += -Xms$(MAX_VM_MEMORY)m -XX:-Inline -#else -# JAVA_MEM_FLAGS += -Xms$(MIN_VM_MEMORY)m -XX:PermSize=32m -XX:MaxPermSize=160m -#endif - -# -# All java tools (javac, javah, and javadoc) run faster with certain java -# options, this macro should be used with all these tools. -# In particular, the client VM makes these tools run faster when -# it's available. -# -ADD_CLIENT_VM_OPTION = false -ifeq ($(PLATFORM), solaris) - ADD_CLIENT_VM_OPTION = true -else - ifeq ($(ARCH_DATA_MODEL), 32) - ADD_CLIENT_VM_OPTION = true - endif -endif - -# Options for hotspot to turn off printing of options with fastdebug version -# and creating the hotspot.log file. -#JAVA_HOTSPOT_DISABLE_PRINT_VMOPTIONS = \ -# -XX:-PrintVMOptions -XX:+UnlockDiagnosticVMOptions -XX:-LogVMOutput - -# JVM options -ifeq ($(PLATFORM), macosx) - JAVA_JVM_FLAGS = $(JAVA_HOTSPOT_DISABLE_PRINT_VMOPTIONS) -Djava.awt.headless=true -else - JAVA_JVM_FLAGS = $(JAVA_HOTSPOT_DISABLE_PRINT_VMOPTIONS) -endif - -#ifeq ($(ADD_CLIENT_VM_OPTION), true) -# JAVA_JVM_FLAGS += -client -#endif -#ifdef USE_HOTSPOT_INTERPRETER_MODE -# JAVA_JVM_FLAGS += -Xint -#endif - -# Various VM flags -JAVA_TOOLS_FLAGS = $(JAVA_JVM_FLAGS) $(JAVA_MEM_FLAGS) - -# The VM flags for javac -JAVAC_JVM_FLAGS = - -# 64-bit builds require a larger thread stack size. -#ifeq ($(ARCH_DATA_MODEL), 32) -# JAVAC_JVM_FLAGS += -J-XX:ThreadStackSize=768 -#else -# JAVAC_JVM_FLAGS += -J-XX:ThreadStackSize=1536 -#endif -JAVAC_JVM_FLAGS += $(JAVA_TOOLS_FLAGS:%=-J%) - -# The jar -J options are special, must be added at the end of the command line -JAR_JFLAGS = $(JAVA_TOOLS_FLAGS:%=-J%) - -# JAVA_TOOLS_DIR is the default location to find Java tools to run, if -# langtools is not available. -# This should be the latest promoted JDK javac. -ifndef JAVA_TOOLS_DIR - JAVA_TOOLS_DIR = $(JDK_IMPORT_PATH)/bin -endif - -# -# Invoking the Java compiler. In leaf makefiles, choose as follows: -# -- Use JAVAC if you want to take full control of what options get -# passed to javac. -# -- Use JAVAC_CMD if you want to take the defaults given to you. -# - -ifndef DEBUG_CLASSFILES - ifeq ($(VARIANT), DBG) - DEBUG_CLASSFILES = true - endif -endif -JAVACFLAGS = -ifeq ($(DEBUG_CLASSFILES),true) - JAVACFLAGS += -g -endif -ifeq ($(JAVAC_MAX_WARNINGS), true) - JAVAC_LINT_OPTIONS += -Xlint:all -endif -ifeq ($(JAVAC_WARNINGS_FATAL), true) - JAVACFLAGS += -Werror -endif - -# TODO: Workaround for CR 7063027. Remove -path eventually. -JAVAC_LINT_OPTIONS += -Xlint:-path - -JAVACFLAGS += $(JAVAC_LINT_OPTIONS) - -# -# Some licensees do not get the Security Source bundles. We will -# fall back on the prebuilt jce.jar so that we can do a best -# attempt at building. If sources exist, we always want to -# build/use the most recent source instead of an older jce.jar, whether -# built implicitly/explicitly. -# -ifeq ($(wildcard $(SHARE_SRC)/classes/javax/crypto/Cipher.java),) - JCE_PATH = $(CLASSPATH_SEPARATOR)$(LIBDIR)/jce.jar -endif - -# Add the source level -SOURCE_LANGUAGE_VERSION = 7 -LANGUAGE_VERSION = -source $(SOURCE_LANGUAGE_VERSION) -JAVACFLAGS += $(LANGUAGE_VERSION) - -# Add the class version we want -TARGET_CLASS_VERSION = 7 -CLASS_VERSION = -target $(TARGET_CLASS_VERSION) -JAVACFLAGS += $(CLASS_VERSION) -JAVACFLAGS += -encoding ascii -JAVACFLAGS += "-Xbootclasspath:$(CLASSBINDIR)$(JCE_PATH)" -JAVACFLAGS += $(OTHER_JAVACFLAGS) - -# Needed for javah -JAVAHFLAGS += -bootclasspath "$(CLASSBINDIR)$(JCE_PATH)" - -# Needed for javadoc to ensure it builds documentation -# against the newly built classes -JAVADOCFLAGS += -bootclasspath $(CLASSBINDIR) - -# Needed for JAVADOC and BOOT_JAVACFLAGS -NO_PROPRIETARY_API_WARNINGS = -XDignore.symbol.file=true - -# Langtools -LANGTOOLS_DIST ?= $(ALT_LANGTOOLS_DIST) - -ifdef LANGTOOLS_DIST - JAVAC_JAR = $(LANGTOOLS_DIST)/bootstrap/lib/javac.jar - JAVAH_JAR = $(LANGTOOLS_DIST)/bootstrap/lib/javah.jar - JAVADOC_JAR = $(LANGTOOLS_DIST)/bootstrap/lib/javadoc.jar - DOCLETS_JAR = $(LANGTOOLS_DIST)/bootstrap/lib/doclets.jar - JAVAC_CMD = $(BOOT_JAVA_CMD) \ - "-Xbootclasspath/p:$(JAVAC_JAR)" \ - -jar $(JAVAC_JAR) $(JAVACFLAGS) - JAVAH_CMD = $(BOOT_JAVA_CMD) \ - "-Xbootclasspath/p:$(JAVAH_JAR)$(CLASSPATH_SEPARATOR)$(JAVAC_JAR)" \ - -jar $(JAVAH_JAR) $(JAVAHFLAGS) - JAVADOC_CMD = $(BOOT_JAVA_CMD) \ - "-Xbootclasspath/p:$(JAVADOC_JAR)$(CLASSPATH_SEPARATOR)$(JAVAC_JAR)$(CLASSPATH_SEPARATOR)$(DOCLETS_JAR)" \ - -jar $(JAVADOC_JAR) $(JAVADOCFLAGS) -else - # If no explicit tools, use boot tools (add VM flags in this case) - JAVAC_CMD = $(UNCYGDRIVE) $(JAVA_TOOLS_DIR)/javac $(JAVAC_JVM_FLAGS) \ - $(JAVACFLAGS) - JAVAH_CMD = $(UNCYGDRIVE) $(JAVA_TOOLS_DIR)/javah \ - $(JAVAHFLAGS) - JAVADOC_CMD = $(UNCYGDRIVE) $(JAVA_TOOLS_DIR)/javadoc $(JAVA_TOOLS_FLAGS:%=-J%) \ - $(JAVADOCFLAGS) -endif - -# Override of what javac to use (see deploy workspace) -#ifdef JAVAC -# JAVAC_CMD = $(JAVAC) -#endif - -# -# The bootstrap java compiler (defined as the javac in the ALT_BOOTDIR jdk). -# Will be used to compile java code used to build the jdk, e.g. class files -# created by this compiler will NOT become part of this built jdk, but just -# used to build this jdk, e.g. run with the java in the ALT_BOOTDIR jdk. -# -# The javac supplied with the LANGTOOLS_DIST should be used to build the -# classes that will be put into the built jdk. But note that this javac -# will use the ALT_BOOTDIR java runtime. Any classes created by the -# LANGTOOLS_DIST javac should not be run during this jdk build and indeed -# may not even run with the ALT_BOOTDIR jdk because they may be a newer -# class file version that the ALT_BOOTDIR jdk doesn't understand. -# -# The important observation here is that the built jdk is NOT run during -# the build. If the built jdk needs to be verified that it can build this -# same jdk, then it should be supplied to the build process as the ALT_BOOTDIR -# jdk, and this resulting built jdk should be compared to the first one. -# (They should be the same). Re-using this built jdk as the ALT_BOOTDIR -# jdk will be the only way and the recommeneded way to verify the built jdk -# can bootstrap itself. -# - -# The javac options supplied to the boot javac is limited. This compiler -# should only be used to build the 'make/tools' sources, which are not -# class files that end up in the classes directory. -BOOT_JAVACFLAGS += $(JAVAC_LINT_OPTIONS) -ifeq ($(JAVAC_WARNINGS_FATAL), true) - BOOT_JAVACFLAGS += -Werror -endif - -BOOT_JAVACFLAGS += -encoding ascii -BOOT_JAR_JFLAGS += $(JAR_JFLAGS) - -BOOT_JAVACFLAGS += $(NO_PROPRIETARY_API_WARNINGS) - -BOOT_JAVA_CMD = $(UNCYGDRIVE) $(BOOTDIR)/bin/java $(JAVA_TOOLS_FLAGS) -BOOT_JAVAC_CMD = $(UNCYGDRIVE) $(BOOTDIR)/bin/javac $(JAVAC_JVM_FLAGS) $(BOOT_JAVACFLAGS) -BOOT_JAR_CMD = $(UNCYGDRIVE) $(BOOTDIR)/bin/jar -BOOT_JARSIGNER_CMD = $(UNCYGDRIVE) $(BOOTDIR)/bin/jarsigner - -# Various tools we need to run (FIXUP: Are these the right ones?) -NATIVE2ASCII = $(UNCYGDRIVE) $(BOOTDIR)/bin/native2ascii $(JAVA_TOOLS_FLAGS:%=-J%) -RMIC = $(UNCYGDRIVE) $(BOOTDIR)/bin/rmic $(JAVA_TOOLS_FLAGS:%=-J%) -IDLJ = $(UNCYGDRIVE) $(BOOTDIR)/bin/idlj $(JAVA_TOOLS_FLAGS:%=-J%) - -# Should not be used -#JAVA = /should/not/be/used - diff --git a/jdk/makefiles/common/shared/Defs-javadoc.gmk b/jdk/makefiles/common/shared/Defs-javadoc.gmk deleted file mode 100644 index c222ad10fa4..00000000000 --- a/jdk/makefiles/common/shared/Defs-javadoc.gmk +++ /dev/null @@ -1,71 +0,0 @@ -# -# Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# Copyright year for beginning of Java and some of the apis -# (Needed when creating the javadocs) -FIRST_COPYRIGHT_YEAR = 1993 -DOMAPI_FIRST_COPYRIGHT_YEAR = 2005 -MIRROR_FIRST_COPYRIGHT_YEAR = 2004 -DOCLETAPI_FIRST_COPYRIGHT_YEAR = 1993 -TAGLETAPI_FIRST_COPYRIGHT_YEAR = 1993 -JDI_FIRST_COPYRIGHT_YEAR = 1999 -JAAS_FIRST_COPYRIGHT_YEAR = 1998 -JGSS_FIRST_COPYRIGHT_YEAR = 2000 -SMARTCARDIO_FIRST_COPYRIGHT_YEAR = 2005 -HTTPSERVER_FIRST_COPYRIGHT_YEAR = 2005 -MGMT_FIRST_COPYRIGHT_YEAR = 2003 -ATTACH_FIRST_COPYRIGHT_YEAR = 2005 -JCONSOLE_FIRST_COPYRIGHT_YEAR = 2006 -SCTPAPI_FIRST_COPYRIGHT_YEAR = 2009 -TRACING_FIRST_COPYRIGHT_YEAR = 2008 -TREEAPI_FIRST_COPYRIGHT_YEAR = 2005 -JNLP_FIRST_COPYRIGHT_YEAR = 1998 -PLUGIN2_FIRST_COPYRIGHT_YEAR = 2007 - -# Oracle name -FULL_COMPANY_NAME = Oracle and/or its affiliates - -# Copyright address -COMPANY_ADDRESS = 500 Oracle Parkway
Redwood Shores, CA 94065 USA. - -# The trademark symbol -TRADEMARK = ™ - -# Common copyright lines used -# The word "Copyright" might optionally be a link to the file cpyr.html. -# The first year of copyright may vary or not be available. -# The address to the company might be optional. -COMMA:= , -EMPTY:= -SPACE:=$(EMPTY) $(EMPTY) -COPYRIGHT_SYMBOL = &\#x00a9; -# Macro to construct the copyright line -# (The GNU make 3.78.1 "if" conditional is broken, fixed in GNU make 3.81) -define CopyrightLine # optionalurl optionalfirstyear optionaladdress -$(if $(strip $1),Copyright,Copyright) \ -$(COPYRIGHT_SYMBOL) $(if $2,$2${COMMA},) $(COPYRIGHT_YEAR),\ -$(FULL_COMPANY_NAME). $3 All rights reserved. -endef - diff --git a/jdk/makefiles/common/shared/Defs-linux.gmk b/jdk/makefiles/common/shared/Defs-linux.gmk deleted file mode 100644 index 1e0559dbf4a..00000000000 --- a/jdk/makefiles/common/shared/Defs-linux.gmk +++ /dev/null @@ -1,213 +0,0 @@ -# -# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Definitions for Linux. -# - -# Default for COMPILER_WARNINGS_FATAL on Linux (C & C++ compiler warnings) -ifndef COMPILER_WARNINGS_FATAL - COMPILER_WARNINGS_FATAL=false -endif - -# Linux should use parallel compilation for best build times -ifndef COMPILE_APPROACH - COMPILE_APPROACH = parallel -endif - -# Indication that we are doing an incremental build. -# This may trigger the creation of make depend files. -ifndef INCREMENTAL_BUILD - INCREMENTAL_BUILD = false -endif - -# FullPath just makes sure it never ends with a / and no duplicates -define FullPath -$(shell cd $1 2> $(DEV_NULL) && pwd) -endef - -# OptFullPath: Absolute path name of a dir that might not initially exist. -define OptFullPath -$(shell if [ "$1" != "" -a -d "$1" ]; then (cd $1 && pwd); else echo "$1"; fi) -endef - -# Location on system where jdk installs might be -USRJDKINSTANCES_PATH =/opt/java - -# UNIXCOMMAND_PATH: path to where the most common Unix commands are. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_UNIXCOMMAND_PATH)" "undefined" - UNIXCOMMAND_PATH :=$(call PrefixPath,$(ALT_UNIXCOMMAND_PATH)) -else - UNIXCOMMAND_PATH = /bin/ -endif - -# USRBIN_PATH: path to where the most common Unix commands are. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_USRBIN_PATH)" "undefined" - USRBIN_PATH :=$(call PrefixPath,$(ALT_USRBIN_PATH)) -else - USRBIN_PATH = /usr/bin/ -endif - -# UNIXCCS_PATH: path to where the Solaris ported UNIX commands can be found -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_UNIXCCS_PATH)" "undefined" - UNIXCCS_PATH :=$(call PrefixPath,$(ALT_UNIXCCS_PATH)) -else - UNIXCCS_PATH = /usr/ccs/bin/ -endif - -# SLASH_JAVA: location of all network accessable files -ifdef ALT_SLASH_JAVA - SLASH_JAVA :=$(ALT_SLASH_JAVA) -else - SLASH_JAVA := $(call DirExists,/java,/java,/NOT-SET) -endif - -# JDK_DEVTOOLS_DIR: common path for all the java devtools -ifdef ALT_JDK_DEVTOOLS_DIR - JDK_DEVTOOLS_DIR =$(ALT_JDK_DEVTOOLS_DIR) -else - JDK_DEVTOOLS_DIR =$(SLASH_JAVA)/devtools -endif - -# COMPILER_PATH: path to where the compiler and tools are installed. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_COMPILER_PATH)" "undefined" - COMPILER_PATH :=$(call PrefixPath,$(ALT_COMPILER_PATH)) -else - COMPILER_PATH =/usr/bin/ -endif - -# OPENWIN_HOME: path to where the X11 environment is installed. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq ($(ALT_OPENWIN_HOME),) - OPENWIN_HOME :=$(call PrefixPath,$(ALT_OPENWIN_HOME)) -else - OPENWIN_HOME ?=$(SYS_ROOT)/usr/X11R6/ -endif - -# DEVTOOLS_PATH: for other tools required for building (such as zip, etc.) -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_DEVTOOLS_PATH)" "undefined" - DEVTOOLS_PATH :=$(call PrefixPath,$(ALT_DEVTOOLS_PATH)) -else - DEVTOOLS_PATH =/usr/bin/ -endif - -# _BOOTDIR1: First choice for a Bootstrap JDK, previous released JDK. -# _BOOTDIR2: Second choice -ifndef ALT_BOOTDIR - _BOOTDIR1 =$(SLASH_JAVA)/re/jdk/$(PREVIOUS_JDK_VERSION)/archive/fcs/binaries/$(PLATFORM)-$(ARCH) - _BOOTDIR2 =$(USRJDKINSTANCES_PATH)/jdk$(PREVIOUS_JDK_VERSION) -endif - -# Always build headless on Linux -BUILD_HEADLESS = true -LIBM=-lm - -# GCC29_COMPILER_PATH: is the path to where the gcc 2.9 compiler is installed -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifdef ALT_GCC29_COMPILER_PATH - GCC29_COMPILER_PATH :=$(call PrefixPath,$(ALT_GCC29_COMPILER_PATH)) -else - GCC29_COMPILER_PATH = $(JDK_DEVTOOLS_DIR)/$(PLATFORM)/gcc29/usr/ -endif - -_CUPS_HEADERS_PATH=/usr/include - -# Import JDK images allow for partial builds, components not built are -# imported (or copied from) these import areas when needed. - -# BUILD_JDK_IMPORT_PATH: location of JDK install trees to import for -# multiple platforms, e.g. windows-i586, solaris-sparc, linux-586, etc. -ifdef ALT_BUILD_JDK_IMPORT_PATH - BUILD_JDK_IMPORT_PATH :=$(call FullPath,$(ALT_BUILD_JDK_IMPORT_PATH)) -else - BUILD_JDK_IMPORT_PATH = $(PROMOTED_BUILD_BINARIES) -endif - -# JDK_IMPORT_PATH: location of JDK install tree (this version) to import -ifdef ALT_JDK_IMPORT_PATH - JDK_IMPORT_PATH :=$(call FullPath,$(ALT_JDK_IMPORT_PATH)) -else - JDK_IMPORT_PATH = $(BUILD_JDK_IMPORT_PATH)/$(PLATFORM)-$(ARCH)$(_JDK_IMPORT_VARIANT) -endif - -# HOTSPOT_IMPORT_PATH: location of hotspot pre-built files -ifdef ALT_HOTSPOT_IMPORT_PATH - HOTSPOT_IMPORT_PATH :=$(call FullPath,$(ALT_HOTSPOT_IMPORT_PATH)) -else - HOTSPOT_IMPORT_PATH ?=$(JDK_IMPORT_PATH) -endif - -# HOTSPOT_CLIENT_PATH: location of client jvm library file. -ifeq ($(ARCH_DATA_MODEL), 32) - ifdef ALT_HOTSPOT_CLIENT_PATH - HOTSPOT_CLIENT_PATH :=$(call FullPath,$(ALT_HOTSPOT_CLIENT_PATH)) - else - HOTSPOT_CLIENT_PATH =$(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/client - endif -endif - -# HOTSPOT_SERVER_PATH: location of server jvm library file. -ifdef ALT_HOTSPOT_SERVER_PATH - HOTSPOT_SERVER_PATH :=$(call FullPath,$(ALT_HOTSPOT_SERVER_PATH)) -else - HOTSPOT_SERVER_PATH =$(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/server -endif - -# Special define for checking the binaries - -# Debug builds should downgrade warnings to just info -MAPFILE_WARNING-DBG=INFO -MAPFILE_WARNING-OPT=WARNING -MAPFILE_WARNING-=WARNING -MAPFILE_WARNING=$(MAPFILE_WARNING-$(VARIANT)) - -# Macro to check it's input file for banned dependencies and verify the -# binary built properly. Relies on process exit code. -ifndef CROSS_COMPILE_ARCH -define binary_file_verification # binary_file -( \ - $(ECHO) "Checking for mapfile use in: $1" && \ - if [ "`$(NM) -D -g --defined-only $1 | $(EGREP) 'SUNWprivate'`" = "" ] ; then \ - $(ECHO) "$(MAPFILE_WARNING): File was not built with a mapfile: $1"; \ - fi && \ - $(ECHO) "Library loads for: $1" && \ - $(LDD) $1 && \ - $(ECHO) "RUNPATH for: $1" && \ - ( $(READELF) -d $1 | $(EGREP) 'NEEDED|RUNPATH|RPATH' ) \ -) -endef -else -define binary_file_verification -( \ - $(ECHO) "Skipping binary file verification for cross-compile build" \ -) -endef -endif - diff --git a/jdk/makefiles/common/shared/Defs-macosx.gmk b/jdk/makefiles/common/shared/Defs-macosx.gmk deleted file mode 100644 index a847d8ae9f3..00000000000 --- a/jdk/makefiles/common/shared/Defs-macosx.gmk +++ /dev/null @@ -1,252 +0,0 @@ -# -# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Definitions for Bsd. -# - -# Default for COMPILER_WARNINGS_FATAL on Bsd (C & C++ compiler warnings) -ifndef COMPILER_WARNINGS_FATAL - COMPILER_WARNINGS_FATAL=false -endif - -# Bsd should use parallel compilation for best build times -ifndef COMPILE_APPROACH - COMPILE_APPROACH = parallel -endif - -# Indication that we are doing an incremental build. -# This may trigger the creation of make depend files. -ifndef INCREMENTAL_BUILD - INCREMENTAL_BUILD = false -endif - -# FullPath just makes sure it never ends with a / and no duplicates -define FullPath -$(shell cd $1 2> $(DEV_NULL) && pwd) -endef - -# OptFullPath: Absolute path name of a dir that might not initially exist. -define OptFullPath -$(shell if [ "$1" != "" -a -d "$1" ]; then (cd $1 && pwd); else echo "$1"; fi) -endef - -# Location on system where jdk installs might be -USRJDKINSTANCES_PATH = $(PACKAGE_PATH) - -# UNIXCOMMAND_PATH: path to where the most common Unix commands are. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_UNIXCOMMAND_PATH)" "undefined" - UNIXCOMMAND_PATH :=$(call PrefixPath,$(ALT_UNIXCOMMAND_PATH)) -else - UNIXCOMMAND_PATH = /bin/ -endif - -# USRBIN_PATH: path to where the most common Unix commands are. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_USRBIN_PATH)" "undefined" - USRBIN_PATH :=$(call PrefixPath,$(ALT_USRBIN_PATH)) -else - USRBIN_PATH = /usr/bin/ -endif - -# UNIXCCS_PATH: path to where the Solaris ported UNIX commands can be found -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_UNIXCCS_PATH)" "undefined" - UNIXCCS_PATH :=$(call PrefixPath,$(ALT_UNIXCCS_PATH)) -else - UNIXCCS_PATH = /usr/ccs/bin/ -endif - -# SLASH_JAVA: location of all network accessable files -ifdef ALT_SLASH_JAVA - SLASH_JAVA :=$(ALT_SLASH_JAVA) -else - SLASH_JAVA := $(call DirExists,/java,/java,/NOT-SET) -endif - -# JDK_DEVTOOLS_DIR: common path for all the java devtools -ifdef ALT_JDK_DEVTOOLS_DIR - JDK_DEVTOOLS_DIR =$(ALT_JDK_DEVTOOLS_DIR) -else - JDK_DEVTOOLS_DIR =$(SLASH_JAVA)/devtools -endif - -# COMPILER_PATH: path to where the compiler and tools are installed. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_COMPILER_PATH)" "undefined" - COMPILER_PATH :=$(call PrefixPath,$(ALT_COMPILER_PATH)) -else - ifeq ($(OS_VENDOR), Apple) - ifndef DEVELOPER_DIR - DEVELOPER_DIR = $(shell /usr/bin/xcode-select -print-path)/usr/bin/ - endif - - COMPILER_PATH := $(call DirExists,$(DEVELOPER_DIR),/usr/bin/,/NOT-SET) - else - COMPILER_PATH =/usr/bin/ - endif -endif - -# OPENWIN_HOME: path to where the X11 environment is installed. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq ($(ALT_OPENWIN_HOME),) - OPENWIN_HOME :=$(call PrefixPath,$(ALT_OPENWIN_HOME)) -else - OPENWIN_HOME ?=$(X11_PATH) -endif - -# DEVTOOLS_PATH: for other tools required for building (such as zip, etc.) -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_DEVTOOLS_PATH)" "undefined" - DEVTOOLS_PATH :=$(call PrefixPath,$(ALT_DEVTOOLS_PATH)) -else - DEVTOOLS_PATH =$(PACKAGE_PATH)/bin/ -endif - -# _BOOTDIR1: First choice for a Bootstrap JDK, previous released JDK. -# _BOOTDIR2: Second choice -ifndef ALT_BOOTDIR - _BOOTDIR1 =$(SLASH_JAVA)/re/jdk/$(PREVIOUS_JDK_VERSION)/archive/fcs/binaries/$(PLATFORM)-$(ARCH) - _BOOTDIR2 =$(USRJDKINSTANCES_PATH)/jdk$(PREVIOUS_JDK_VERSION) -endif - -# Always build headless on Bsd -BUILD_HEADLESS = true -LIBM=-lm - -ifeq ($(OS_VENDOR), Apple) - _CUPS_HEADERS_PATH=/usr/include -else - _CUPS_HEADERS_PATH=$(PACKAGE_PATH)/include -endif - -# Import JDK images allow for partial builds, components not built are -# imported (or copied from) these import areas when needed. - -# BUILD_JDK_IMPORT_PATH: location of JDK install trees to import for -# multiple platforms, e.g. windows-i586, solaris-sparc, bsd-586, etc. -ifdef ALT_BUILD_JDK_IMPORT_PATH - BUILD_JDK_IMPORT_PATH :=$(call FullPath,$(ALT_BUILD_JDK_IMPORT_PATH)) -else - BUILD_JDK_IMPORT_PATH = $(PROMOTED_BUILD_BINARIES) -endif -BUILD_JDK_IMPORT_PATH:=$(call AltCheckValue,BUILD_JDK_IMPORT_PATH) - -# JDK_IMPORT_PATH: location of JDK install tree (this version) to import -ifdef ALT_JDK_IMPORT_PATH - JDK_IMPORT_PATH :=$(call FullPath,$(ALT_JDK_IMPORT_PATH)) -else - JDK_IMPORT_PATH = $(BUILD_JDK_IMPORT_PATH)/$(PLATFORM)-$(ARCH)$(_JDK_IMPORT_VARIANT) -endif -JDK_IMPORT_PATH:=$(call AltCheckValue,JDK_IMPORT_PATH) - -# HOTSPOT_IMPORT_PATH: location of hotspot pre-built files -ifdef ALT_HOTSPOT_IMPORT_PATH - HOTSPOT_IMPORT_PATH :=$(call FullPath,$(ALT_HOTSPOT_IMPORT_PATH)) -else - HOTSPOT_IMPORT_PATH ?=$(JDK_IMPORT_PATH) -endif -HOTSPOT_IMPORT_PATH:=$(call AltCheckValue,HOTSPOT_IMPORT_PATH) - -# HOTSPOT_CLIENT_PATH: location of client jvm library file. -ifeq ($(ARCH_DATA_MODEL), 32) - ifdef ALT_HOTSPOT_CLIENT_PATH - HOTSPOT_CLIENT_PATH :=$(call FullPath,$(ALT_HOTSPOT_CLIENT_PATH)) - else - HOTSPOT_CLIENT_PATH =$(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/client - endif - HOTSPOT_CLIENT_PATH:=$(call AltCheckValue,HOTSPOT_CLIENT_PATH) -endif - -# HOTSPOT_SERVER_PATH: location of server jvm library file. -ifdef ALT_HOTSPOT_SERVER_PATH - HOTSPOT_SERVER_PATH :=$(call FullPath,$(ALT_HOTSPOT_SERVER_PATH)) -else - HOTSPOT_SERVER_PATH =$(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/server -endif -HOTSPOT_SERVER_PATH:=$(call AltCheckValue,HOTSPOT_SERVER_PATH) - -# Special define for checking the binaries - -# Debug builds should downgrade warnings to just info -MAPFILE_WARNING-DBG=INFO -MAPFILE_WARNING-OPT=WARNING -MAPFILE_WARNING-=WARNING -MAPFILE_WARNING=$(MAPFILE_WARNING-$(VARIANT)) - -# Macro to check it's input file for banned dependencies and verify the -# binary built properly. Relies on process exit code. -ifndef CROSS_COMPILE_ARCH -ifeq ($(OS_VENDOR), Apple) -define binary_file_verification # binary_file -( \ - $(ECHO) "Checking for mapfile use in: $1" && \ - if [ "`$(NM) -g $1 | $(EGREP) 'SUNWprivate'`" = "" ] ; then \ - $(ECHO) "WARNING: File was not built with a mapfile: $1"; \ - fi && \ - $(ECHO) "Library loads for: $1" && \ - $(OTOOL) -L $1 && \ - $(ECHO) "RUNPATH for: $1" && \ - ( $(OTOOL) -l $1 | $(EGREP) 'path ' ) \ -) || true -endef -else -ifeq ($(OS_VENDOR), OpenBSD) -define binary_file_verification # binary_file -( \ - $(ECHO) "Checking for mapfile use in: $1" && \ - if [ "`$(OBJDUMP) -T $1 | $(EGREP) '[0-9a-f]* g *DF \.text.*SUNWprivate'`" = "" ] ; then \ - $(ECHO) "$(MAPFILE_WARNING): File was not built with a mapfile: $1"; \ - fi && \ - $(ECHO) "Library loads for: $1" && \ - $(LDD) $1 && \ - $(ECHO) "RUNPATH for: $1" && \ - ( $(READELF) -d $1 | $(EGREP) 'NEEDED|RUNPATH|RPATH' ) \ -) || true -endef -else -define binary_file_verification # binary_file -( \ - $(ECHO) "Checking for mapfile use in: $1" && \ - if [ "`$(NM) -D -g --defined-only $1 | $(EGREP) 'SUNWprivate'`" = "" ] ; then \ - $(ECHO) "$(MAPFILE_WARNING): File was not built with a mapfile: $1"; \ - fi && \ - $(ECHO) "Library loads for: $1" && \ - $(LDD) $1 && \ - $(ECHO) "RUNPATH for: $1" && \ - ( $(READELF) -d $1 | $(EGREP) 'NEEDED|RUNPATH|RPATH' ) \ -) -endef -endif # OS_VENDOR == OpenBSD -endif # OS_VENDOR == Apple -else -define binary_file_verification -( \ - $(ECHO) "Skipping binary file verification for cross-compile build" \ -) -endef -endif - diff --git a/jdk/makefiles/common/shared/Defs-solaris.gmk b/jdk/makefiles/common/shared/Defs-solaris.gmk deleted file mode 100644 index cd7fa15d27c..00000000000 --- a/jdk/makefiles/common/shared/Defs-solaris.gmk +++ /dev/null @@ -1,239 +0,0 @@ -# -# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Definitions for Solaris. -# - -# Default for COMPILER_WARNINGS_FATAL on Solaris (C & C++ compiler warnings) -ifndef COMPILER_WARNINGS_FATAL - COMPILER_WARNINGS_FATAL=false -endif - -# Solaris should use parallel compilation for best build times -ifndef COMPILE_APPROACH - COMPILE_APPROACH = parallel -endif - -# Indication that we are doing an incremental build. -# This may trigger the creation of make depend files. -ifndef INCREMENTAL_BUILD - INCREMENTAL_BUILD = false -endif - -# FullPath just makes sure it never ends with a / and no duplicates -define FullPath -$(shell cd $1 2> $(DEV_NULL) && pwd) -endef - -# OptFullPath: Absolute path name of a dir that might not initially exist. -define OptFullPath -$(shell if [ "$1" != "" -a -d "$1" ]; then (cd $1 && pwd); else echo "$1"; fi) -endef - -# Location on system where jdk installs might be -USRJDKINSTANCES_PATH =/usr/jdk/instances - -# UNIXCOMMAND_PATH: path to where the most common Unix commands are. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_UNIXCOMMAND_PATH)" "undefined" - UNIXCOMMAND_PATH :=$(call PrefixPath,$(ALT_UNIXCOMMAND_PATH)) -else - UNIXCOMMAND_PATH = /usr/bin/ -endif - -# UNIXCCS_PATH: path to where the less common UNIX commands can be found -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_UNIXCCS_PATH)" "undefined" - UNIXCCS_PATH :=$(call PrefixPath,$(ALT_UNIXCCS_PATH)) -else - UNIXCCS_PATH = /usr/ccs/bin/ -endif - -# SLASH_JAVA: location of all network accessable files -ifdef ALT_SLASH_JAVA - SLASH_JAVA :=$(ALT_SLASH_JAVA) -else - SLASH_JAVA := $(call DirExists,/java,/java,/NOT-SET) -endif - -# JDK_DEVTOOLS_DIR: common path for all the java devtools -ifdef ALT_JDK_DEVTOOLS_DIR - JDK_DEVTOOLS_DIR =$(ALT_JDK_DEVTOOLS_DIR) -else - JDK_DEVTOOLS_DIR =$(SLASH_JAVA)/devtools -endif - -# COMPILER_PATH: path to where the compiler and tools are installed. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_COMPILER_PATH)" "undefined" - COMPILER_PATH :=$(call PrefixPath,$(ALT_COMPILER_PATH)) -else - # If the place where we keep a set of Sun Studio compilers doesn't exist, - # try and use /opt/SUNWspro, the default location for the SS compilers. - # (DirExists checks for this path twice, an automount double check) - _SUNSTUDIO_SET_ROOT=$(JDK_DEVTOOLS_DIR)/$(ARCH_FAMILY)/SUNWspro - SUNSTUDIO_SET_ROOT:=$(call DirExists,$(_SUNSTUDIO_SET_ROOT),$(_SUNSTUDIO_SET_ROOT),) - ifneq ($(SUNSTUDIO_SET_ROOT),) - COMPILER_PATH =$(SUNSTUDIO_SET_ROOT)/$(REQUIRED_COMPILER_VERSION)/bin/ - else - COMPILER_PATH =/opt/SUNWspro/bin/ - endif -endif - -# DEVTOOLS_PATH: for other tools required for building (such as zip, etc.) -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_DEVTOOLS_PATH)" "undefined" - DEVTOOLS_PATH :=$(call PrefixPath,$(ALT_DEVTOOLS_PATH)) -else - ifdef ALT_JDK_DEVTOOLS_DIR - DEVTOOLS_PATH =$(JDK_DEVTOOLS_DIR)/$(ARCH_FAMILY)/bin/ - else - ifdef OPENJDK - DEVTOOLS_PATH = /usr/bin/ - else - DEVTOOLS_PATH =$(JDK_DEVTOOLS_DIR)/$(ARCH_FAMILY)/bin/ - endif - endif -endif - -# _BOOTDIR1: First choice for a Bootstrap JDK, previous released JDK. -# _BOOTDIR2: Second choice -ifndef ALT_BOOTDIR - _BOOTDIR1 =$(SLASH_JAVA)/re/jdk/$(PREVIOUS_JDK_VERSION)/archive/fcs/binaries/$(PLATFORM)-$(ARCH) - _BOOTDIR2 =$(USRJDKINSTANCES_PATH)/jdk$(PREVIOUS_JDK_VERSION) -endif - -# GCC_COMPILER_PATH: path to where the gcc/g++ compiler and tools are installed -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifneq "$(origin ALT_GCC_COMPILER_PATH)" "undefined" - GCC_COMPILER_PATH :=$(call PrefixPath,$(ALT_GCC_COMPILER_PATH)) -else - GCC_COMPILER_PATH = $(JDK_DEVTOOLS_DIR)/$(ARCH_FAMILY)/gnucc/bin/ -endif - - -# Always build headless on Solaris -BUILD_HEADLESS = true - -_CUPS_HEADERS_PATH=/opt/sfw/cups/include - -# Import JDK images allow for partial builds, components not built are -# imported (or copied from) these import areas when needed. - -# BUILD_JDK_IMPORT_PATH: location of JDK install trees to import for -# multiple platforms, e.g. windows-i586, solaris-sparc, linux-586, etc. -ifdef ALT_BUILD_JDK_IMPORT_PATH - BUILD_JDK_IMPORT_PATH :=$(call FullPath,$(ALT_BUILD_JDK_IMPORT_PATH)) -else - BUILD_JDK_IMPORT_PATH = $(PROMOTED_BUILD_BINARIES) -endif - -# JDK_IMPORT_PATH: location of previously built JDK (this version) to import -ifdef ALT_JDK_IMPORT_PATH - JDK_IMPORT_PATH :=$(call FullPath,$(ALT_JDK_IMPORT_PATH)) -else - JDK_IMPORT_PATH = $(BUILD_JDK_IMPORT_PATH)/$(PLATFORM)-$(ARCH)$(_JDK_IMPORT_VARIANT) -endif - -# HOTSPOT_IMPORT_PATH: location of hotspot pre-built files -ifdef ALT_HOTSPOT_IMPORT_PATH - HOTSPOT_IMPORT_PATH :=$(call FullPath,$(ALT_HOTSPOT_IMPORT_PATH)) -else - HOTSPOT_IMPORT_PATH ?=$(JDK_IMPORT_PATH) -endif - -# HOTSPOT_CLIENT_PATH: location of client jvm library file. -ifeq ($(ARCH_DATA_MODEL), 32) - ifdef ALT_HOTSPOT_CLIENT_PATH - HOTSPOT_CLIENT_PATH :=$(call FullPath,$(ALT_HOTSPOT_CLIENT_PATH)) - else - HOTSPOT_CLIENT_PATH =$(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/client - endif -endif - -# HOTSPOT_SERVER_PATH: location of server jvm library file. -ifdef ALT_HOTSPOT_SERVER_PATH - HOTSPOT_SERVER_PATH :=$(call FullPath,$(ALT_HOTSPOT_SERVER_PATH)) -else - HOTSPOT_SERVER_PATH =$(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/server -endif - -# Special define for checking the binaries - -# Debug builds should downgrade warnings to just info -MAPFILE_WARNING-DBG=INFO -MAPFILE_WARNING-OPT=WARNING -MAPFILE_WARNING-=WARNING -MAPFILE_WARNING=$(MAPFILE_WARNING-$(VARIANT)) - -# Some libraries do not have mapfiles for multiple reasons. -# These libraries for sparc and sparcv9 are exceptions to the mapfile rule: -# libjdgaSUNWafb.so -# libjdgaSUNWcg6.so -# libjdgaSUNWffb.so -# libjdgaSUNWm64.so -# libxinerama.so -# The library libJdbcOdbc.so has also been given an exception. -# The JNI/JVMTI demo libraries are also missing mapfiles, no exceptions yet. -ifeq ($(ARCH_FAMILY),sparc) - MAPFILE_EXCEPTIONS = \ - (libJdbcOdbc|libjdgaSUNWafb|libjdgaSUNWcg6|libjdgaSUNWffb|libjdgaSUNWm64|libxinerama) -else - MAPFILE_EXCEPTIONS = (libJdbcOdbc) -endif - -# Macro to check it's input file for banned dependencies and verify the -# binary built properly. Relies on process exit code. -ifndef CROSS_COMPILE_ARCH -ifneq (,$(DUMP)) -define binary_file_verification # binary_file -( \ - $(ECHO) "Checking for mapfile use in: $1" && \ - if [ "`$(ECHO) $(basename $(notdir $1)) | $(EGREP) '$(MAPFILE_EXCEPTIONS)'`" = "" \ - -a "`$(NM) -g -D $1 | $(EGREP) -v 'UNDEF' | $(EGREP) 'SUNWprivate'`" = "" ] ; then \ - $(ECHO) "$(MAPFILE_WARNING): File was not built with a mapfile: $1"; \ - fi && \ - $(ECHO) "Library loads for: $1" && \ - $(LDD) $1 && \ - $(ECHO) "RUNPATH for: $1" && \ - ( $(DUMP) -L -v $1 | $(EGREP) 'NEEDED|RUNPATH|RPATH' ) \ -) -endef -else -define binary_file_verification -( \ - $(ECHO) "Skipping binary file verification since no dump command found" \ -) -endef -endif -else -define binary_file_verification -( \ - $(ECHO) "Skipping binary file verification for cross-compile build" \ -) -endef -endif - diff --git a/jdk/makefiles/common/shared/Defs-versions.gmk b/jdk/makefiles/common/shared/Defs-versions.gmk deleted file mode 100644 index fba70370ba2..00000000000 --- a/jdk/makefiles/common/shared/Defs-versions.gmk +++ /dev/null @@ -1,215 +0,0 @@ -# -# Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# WARNING: This file is shared with other workspaces. -# - -# This file needs these set: PLATFORM, ARCH_FAMILY, and ARCH_DATA_MODEL. - -# Windows uses Microsoft compilers by default -ifeq ($(PLATFORM), windows) - override CC_VERSION = msvc -endif - -# Solaris uses Sun Studio compilers by default -ifeq ($(PLATFORM), solaris) - override CC_VERSION = sun -endif - -# Linux uses GNU compilers by default -ifeq ($(PLATFORM), linux) - override CC_VERSION = gcc -endif - -# Mac OS X uses LLVM by default -ifeq ($(PLATFORM), macosx) - override CC_VERSION = llvm -endif - -########################################################################## -# -# List of JDK official minimum, expected, or required versions: -# -# REQUIRED_ALSA_VERSION -# Linux only: The ALSA sound library version expected. -# -# REQUIRED_ANT_VER -# The minimum 'ant' version. -# -# REQUIRED_BOOT_VER -# The minimum boot jdk version. -# -# REQUIRED_CC_VER -# The primary C compiler version expected. -# -# REQUIRED_COMPILER_NAME -# The long descriptive name of the compiler we should use -# -# REQUIRED_COMPILER_VERSION -# The one word name that identifies the compilers being used. -# -# REQUIRED_CYGWIN_VER -# Windows only: If CYGWIN is used, the minimum CYGWIN version. -# -# REQUIRED_DXSDK_VER -# Windows only: The version of DirectX SDK expected. -# -# REQUIRED_FREETYPE_VERSION -# If we are using freetype, the freetype version expected. -# -# REQUIRED_GCC_VER -# Solaris and Linux only. The required version of gcc/g++ for the legacy OJI plugin. -# -# REQUIRED_LINK_VER -# Windows only: The version of link.exe expected. -# -# REQUIRED_MAKE_VER -# The minimum version of GNU make. -# -# REQUIRED_MKS_VER -# Windows only: If MKS used instead of CYGWIN, the minimum version of MKS. -# -# REQUIRED_OS_VARIANT_NAME -# The OS variation name required. -# Solaris: Solaris or OpenSolaris -# Windows: Windows2000, WindowsXP, Windows2003, etc. -# Linux: Fedora, RedHat, SuSE, Ubuntu, etc. -# -# REQUIRED_OS_VARIANT_VERSION -# The version number associated with the above OS variant name. -# Solaris: output of uname -r -# Windows: 5.0 for Windows2000, 5.1 for WindowsXP, 5.2 for Windows2003, etc. -# Linux: number for the variant, e.g. 9 for Fedora 9 -# -# REQUIRED_OS_VERSION -# The formal OS version number. -# Solaris & Windows: same as REQUIRED_OS_VARIANT_VERSION -# Linux: the kernel version, or output of uname -r -# -# REQUIRED_UNZIP_VER -# The minimum version of unzip. -# -# REQUIRED_ZIP_VER -# The minimum version of unzip. -# -########### -# -# Differences in the build platform from these versions may trigger warnings -# messages during the sanity checking when building the JDK. -# -# When building the OpenJDK most of these required or expected versions are -# ignored or allowed to vary widely to accomodate the many build situations -# of the OpenJDK. -# -########################################################################## - -# Solaris specific -ifeq ($(PLATFORM), solaris) - REQUIRED_OS_NAME = SunOS - REQUIRED_OS_VERSION = 5.10 - REQUIRED_OS_VARIANT_NAME = Solaris - REQUIRED_OS_VARIANT_VERSION = $(REQUIRED_OS_VERSION) - REQUIRED_COMPILER_NAME = Sun Studio 12 Update 1 - REQUIRED_COMPILER_VERSION = SS12u1 - # Cross-compilation compiler versions are target specific - # so don't set a required version if cross-compiling - ifndef CROSS_COMPILE_ARCH - ifeq ($(CC_VERSION),sun) - REQUIRED_CC_VER = 5.10 - endif - ifeq ($(CC_VERSION),gcc) - REQUIRED_CC_VER = 3.4.3 - endif - endif - REQUIRED_GCC_VER = 2.95.2 -endif - -# Linux specific -ifeq ($(PLATFORM), linux) - REQUIRED_OS_NAME = Linux - REQUIRED_OS_VERSION = 2.6 - REQUIRED_OS_VARIANT_NAME = Fedora - REQUIRED_OS_VARIANT_VERSION = 9 - REQUIRED_ALSA_VERSION = 0.9.1 - REQUIRED_COMPILER_NAME = GCC4 - REQUIRED_COMPILER_VERSION = GCC4 - REQUIRED_GCC_VER = 2.95 - # Cross-compilation compiler versions are target specific - # so don't set a required version if cross-compiling - ifndef CROSS_COMPILE_ARCH - ifeq ($(CC_VERSION),gcc) - REQUIRED_CC_VER = 4.3.0 - endif - ifeq ($(CC_VERSION),sun) - REQUIRED_CC_VER = 5.10 - endif - endif -endif - -# Mac specific -ifeq ($(PLATFORM), macosx) - REQUIRED_OS_NAME = Darwin - REQUIRED_OS_VERSION = 11.2 - REQUIRED_OS_VARIANT_NAME = MacOSX - REQUIRED_OS_VARIANT_VERSION = 10.7.2 - REQUIRED_COMPILER_NAME = GCC4 - REQUIRED_COMPILER_VERSION = GCC4 - REQUIRED_CC_VER = 4.2.1 -endif - -# Windows specific -ifeq ($(PLATFORM), windows) - REQUIRED_OS_NAME = Windows - ifeq ($(ARCH_DATA_MODEL),64) - REQUIRED_OS_VERSION = 5.2 - REQUIRED_OS_VARIANT_NAME = Windows2003 - else - REQUIRED_OS_VERSION = 5.1 - REQUIRED_OS_VARIANT_NAME = WindowsXP - endif - REQUIRED_OS_VARIANT_VERSION = $(REQUIRED_OS_VERSION) - REQUIRED_CYGWIN_VER = 4.0 - REQUIRED_MKS_VER = 6.1 - REQUIRED_DXSDK_VER = 0x0900 - ifeq ($(CC_VERSION),msvc) - REQUIRED_COMPILER_NAME = Visual Studio 10 - REQUIRED_COMPILER_VERSION = VS2010 - REQUIRED_CC_VER = 16.00.30319.01 - REQUIRED_LINK_VER = 10.00.30319.01 - endif - ifeq ($(CC_VERSION),gcc) - REQUIRED_CC_VER = 3.4.3 - endif -endif - -# Generic -REQUIRED_ANT_VER = 1.7.1 -REQUIRED_BOOT_VER = 1.7 -REQUIRED_FREETYPE_VERSION = 2.3.0 -REQUIRED_MAKE_VER = 3.81 -REQUIRED_UNZIP_VER = 5.12 -REQUIRED_ZIP_VER = 2.2 - diff --git a/jdk/makefiles/common/shared/Defs-windows.gmk b/jdk/makefiles/common/shared/Defs-windows.gmk deleted file mode 100644 index da796ee3f9f..00000000000 --- a/jdk/makefiles/common/shared/Defs-windows.gmk +++ /dev/null @@ -1,696 +0,0 @@ -# -# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Definitions for Windows. -# - -# Default for COMPILER_WARNINGS_FATAL on Windows (C++ compiler warnings) -# Level: Default is 3, 0 means none, 4 is the most but may be unreliable -# Some makefiles may have set this to 0 to turn off warnings completely, -# which also effectively creates a COMPILER_WARNINGS_FATAL=false situation. -# Program.gmk may turn this down to 2 (building .exe's). -# Windows 64bit platforms are less likely to be warning free. -# Historically, Windows 32bit builds should be mostly warning free. -# VS2010 introduced a large number of security warnings that are off by -# default but will be turned back on with SHOW_ALL_WARNINGS=true. -ifndef COMPILER_WARNING_LEVEL - COMPILER_WARNING_LEVEL=3 -endif -ifndef COMPILER_WARNINGS_FATAL - COMPILER_WARNINGS_FATAL=false -endif -ifndef SHOW_ALL_WARNINGS - SHOW_ALL_WARNINGS = false -endif - -# Windows should use parallel compilation for best build times -ifndef COMPILE_APPROACH - COMPILE_APPROACH = normal -endif - -# Indication that we are doing an incremental build. -# This may trigger the creation of make depend files. -# (This may not be working on windows yet, always force to false.) -override INCREMENTAL_BUILD = false - -# WARNING: This is extremely touch stuff, between CYGWIN vs. MKS and all -# variations of MKS and CYGWIN releases, and 32bit vs 64bit, -# this file can give you nightmares. -# -# Notes: -# Keep all paths in the windows "mixed" style except CYGWIN UNXIXCOMMAND_PATH. -# Use of PrefixPath is critical, some variables must end with / (see NOTE). -# Use of quotes is critical due to possible spaces in paths coming from -# the environment variables, be careful. -# First convert \ to / with subst, keep it quoted due to blanks, then -# use cygpath -s or dosname -s to get the short non-blank name. -# If the MKS is old and doesn't have a dosname -s, you will be forced -# to set ALT variables with the short non-space directory names. -# If dosname doesn't appear to work, we won't use it. -# The dosname utility also wants to accept stdin if it is not supplied -# any path on the command line, this is really dangerous when using -# make variables that can easily become empty, so I use: -# echo $1 | dosname -s instead of dosname -s $1 -# to prevent dosname from hanging up the make process when $1 is empty. -# The cygpath utility does not have this problem. -# The ALT values should never really have spaces or use \. -# Suspect these environment variables to have spaces and/or \ characters: -# SYSTEMROOT, SystemRoot, WINDIR, windir, PROGRAMFILES, ProgramFiles, -# DXSDK_DIR, MSTOOLS, Mstools, MSSDK, MSSdk, VCnnCOMNTOOLS, -# MSVCDIR, MSVCDir. -# So use $(subst \,/,) on them first adding quotes and placing them in -# their own variable assigned with :=, then use FullPath. -# - -ifdef USING_CYGWIN -# Macro to effectively do a toupper without an exec -define ToUpper -$(subst a,A,$(subst b,B,$(subst c,C,$(subst d,D,$(subst e,E,$(subst f,F,\ -$(subst g,G,$(subst h,H,$(subst i,I,$(subst j,J,$(subst k,K,$(subst l,L,\ -$(subst m,M,$(subst n,N,$(subst o,O,$(subst p,P,$(subst q,Q,$(subst r,R,\ -$(subst s,S,$(subst t,T,$(subst u,U,$(subst v,V,$(subst w,W,$(subst x,X,\ -$(subst y,Y,$(subst z,Z,$1)))))))))))))))))))))))))) -endef -# All possible drive letters -drives=a b c d e f g h i j k l m n o p q r s t v u w x y z -# Convert /cygdrive/ paths to the mixed style without an exec of cygpath -# Must be a path with no spaces. /cygdrive/letter is always lowercase -# and letter:/ is always uppercase coming from cygpath. -define MixedPath -$(patsubst /%,$(CYGWIN_HOME)/%,$(sort $(filter-out /cygdrive/%,$(foreach drive,$(drives),$(patsubst /cygdrive/$(drive)/%,$(call ToUpper,$(drive)):/%,$1))))) -endef -# Use FullPath to get C:/ style non-spaces path. Never ends with a /! -# We assume cygpath is available in the search path -# NOTE: Use of 'pwd' with CYGWIN will not get you a mixed style path! -define FullPath -$(if $(word 2,$1),$(shell $(CYGPATH_CMD) $1 2> $(DEV_NULL)),$(call MixedPath,$(realpath $(subst ",,$1)))) -endef -define OptFullPath -$(shell if [ "$1" != "" -a -d "$1" ]; then $(CYGPATH_CMD) "$1" 2> $(DEV_NULL); else echo "$1"; fi) -endef -else -# Temporary until we upgrade to MKS 8.7, MKS pwd returns mixed mode path -define FullPath -$(shell cd $1 2> $(DEV_NULL) && pwd) -endef -define OptFullPath -$(shell if [ "$1" != "" -a -d "$1" ]; then (cd $1 && pwd); else echo "$1"; fi) -endef -endif - -# System drive -ifdef SYSTEMDRIVE - _system_drive =$(SYSTEMDRIVE) -else - ifdef SystemDrive - _system_drive =$(SystemDrive) - endif -endif -_system_drive:=$(call CheckValue,_system_drive,C:) - -# UNIXCOMMAND_PATH: path to where the most common Unix commands are. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -# With cygwin, just use this as is don't use FullPath on it. -ifdef ALT_UNIXCOMMAND_PATH - ifdef USING_CYGWIN - UNIXCOMMAND_PATH :=$(call PrefixPath,$(ALT_UNIXCOMMAND_PATH)) - else - xALT_UNIXCOMMAND_PATH :="$(subst \,/,$(ALT_UNIXCOMMAND_PATH))" - fxALT_UNIXCOMMAND_PATH :=$(call FullPath,$(xALT_UNIXCOMMAND_PATH)) - UNIXCOMMAND_PATH :=$(call PrefixPath,$(fxALT_UNIXCOMMAND_PATH)) - endif -else - ifdef USING_CYGWIN - UNIXCOMMAND_PATH :=$(call PrefixPath,/usr/bin) - else - ifdef ROOTDIR - xROOTDIR :="$(subst \,/,$(ROOTDIR))" - _rootdir :=$(call FullPath,$(xROOTDIR)) - else - xROOTDIR :="$(_system_drive)/mksnt" - _rootdir :=$(call FullPath,$(xROOTDIR)) - endif - ifneq ($(_rootdir),) - UNIXCOMMAND_PATH :=$(call PrefixPath,$(_rootdir)/mksnt) - endif - endif -endif -UNIXCOMMAND_PATH:=$(call AltCheckSpaces,UNIXCOMMAND_PATH) - -# Get version of MKS or CYGWIN -ifndef USING_CYGWIN -_MKS_VER :=$(shell $(MKSINFO) 2>&1 | $(GREP) Release | $(TAIL) -1 | $(SED) -e 's@.*\(Release.*\)@\1@') -MKS_VER :=$(call GetVersion,$(_MKS_VER)) -# At this point, we can re-define FullPath to use DOSNAME_CMD -CHECK_MKS87:=$(call CheckVersions,$(MKS_VER),8.7) -TRY_DOSNAME:=false -ifeq ($(CHECK_MKS87),same) -TRY_DOSNAME:=true -endif -# Newer should be ok -ifeq ($(CHECK_MKS87),newer) -TRY_DOSNAME:=true -endif -ifeq ($(TRY_DOSNAME),true) -ifeq ($(shell $(UNIXCOMMAND_PATH)dosname -s $(_system_drive)/ 2> $(DEV_NULL)),$(_system_drive)/) -_DOSNAME=$(UNIXCOMMAND_PATH)dosname -DOSNAME_CMD:=$(_DOSNAME) -s -define FullPath -$(subst //,/,$(shell echo $1 | $(DOSNAME_CMD) 2> $(DEV_NULL))) -endef -endif # test dosname -s -endif # TRY_DOSNAME -endif # MKS - -# We try to get references to what we need via the default component -# environment variables, or what was used historically. - -# Process Windows values into FullPath values, these paths may have \ chars - -# System root -ifdef SYSTEMROOT - xSYSTEMROOT :="$(subst \,/,$(SYSTEMROOT))" - _system_root :=$(call FullPath,$(xSYSTEMROOT)) -else - ifdef SystemRoot - xSYSTEMROOT :="$(subst \,/,$(SystemRoot))" - _system_root :=$(call FullPath,$(xSYSTEMROOT)) - else - ifdef WINDIR - xWINDIR :="$(subst \,/,$(WINDIR))" - _system_root :=$(call FullPath,$(xWINDIR)) - else - ifdef windir - xWINDIR :="$(subst \,/,$(windir))" - _system_root :=$(call FullPath,$(xWINDIR)) - endif - endif - endif -endif -_system_root:=$(call CheckValue,_system_root,$(_system_drive)/WINNT) - -# Program Files directory -ifdef PROGRAMFILES - xPROGRAMFILES :="$(subst \,/,$(PROGRAMFILES))" -else - ifeq ($(ARCH_DATA_MODEL), 32) - xPROGRAMFILES :="$(_system_drive)/Program Files" - else - xPROGRAMFILES :="$(_system_drive)/Program Files (x86)" - endif -endif -ifeq ($(ARCH_DATA_MODEL), 32) - _program_files :=$(call FullPath,$(xPROGRAMFILES)) - _program_files32 :=$(_program_files) -else - ifdef PROGRAMW6432 - xPROGRAMW6432 :="$(subst \,/,$(PROGRAMW6432))" - else - xPROGRAMW6432 :="$(_system_drive)/Program Files" - endif - _program_files :=$(call FullPath,$(xPROGRAMW6432)) - _program_files32 :=$(call FullPath,$(xPROGRAMFILES)) - ifneq ($(word 1,$(_program_files32)),$(_program_files32)) - _program_files32:= - endif -endif -ifneq ($(word 1,$(_program_files)),$(_program_files)) - _program_files:= -endif - -# DirectX SDK -ifdef ALT_DXSDK_DRIVE - _dx_sdk_dir =$(ALT_DXSDK_DRIVE):/DXSDK -else - ifdef DXSDK_DIR - xDXSDK_DIR :="$(subst \,/,$(DXSDK_DIR))" - else - xDXSDK_DIR :="$(_system_drive)/DXSDK" - endif - _dx_sdk_dir :=$(call FullPath,$(xDXSDK_DIR)) -endif - -# Use of the Visual Studio compilers requires certain env variables be set: -# PATH should include the path to cl.exe -# INCLUDE should be defined -# LIB should be defined -# LIBPATH should be defined -# VS100COMNTOOLS should be defined -# WINDOWSSDKDIR should be defined -# The 7.0a path is from VS2010 Pro, the 7.1 path is the standalone SDK. -# For 64bit either will work for us. -# If a developer chooses to install the standalone SDK in some other -# location, then they need to set WINDOWSSDKDIR. -# -# Compilers for 64bit may be from the free SDK, or Visual Studio Professional. -# The free Express compilers don't contain 64 bit compilers, which is why -# you instead need the SDK. -# Release enginering will use VS2010 Pro, so the frequency of testing of -# SDK based builds will depend entirely on individual usage. - -# We only need to do this once -ifndef VS2010_EXISTS - # The 2 key paths we need are WINDOWSSDKDIR and VS100COMNTOOLS. - # If not defined try to see if default location exists. - # If defined make sure that the path has no spaces. - # Finally, export path with no spaces so logic minimizes FullPath calls. - ifndef WINDOWSSDKDIR - # The 7.0a SDK is the second choice. - xWINDOWSSDKDIR :="$(_program_files32)/Microsoft SDKs/Windows/v7.0a/" - fWINDOWSSDKDIR :=$(call FullPath,$(xWINDOWSSDKDIR)) - # The 7.1 SDK is the second choice. - ifeq ($(fWINDOWSSDKDIR),) - xWINDOWSSDKDIR :="$(_program_files32)/Microsoft SDKs/Windows/v7.1/" - fWINDOWSSDKDIR :=$(call FullPath,$(xWINDOWSSDKDIR)) - endif - else - ifneq ($(word 2,$(WINDOWSSDKDIR)),) - xWINDOWSSDKDIR :="$(subst \,/,$(WINDOWSSDKDIR))" - fWINDOWSSDKDIR :=$(call FullPath,$(xWINDOWSSDKDIR)) - else - fWINDOWSSDKDIR :=$(WINDOWSSDKDIR) - endif - endif - ifneq ($(fWINDOWSSDKDIR),) - WINDOWSSDKDIR :=$(fWINDOWSSDKDIR)/ - endif - ifndef VS100COMNTOOLS - xVS100COMNTOOLS :="$(_program_files32)/Microsoft Visual Studio 10.0/Common7/Tools/" - fVS100COMNTOOLS :=$(call FullPath,$(xVS100COMNTOOLS)) - else - xVS100COMNTOOLS :="$(subst \,/,$(VS100COMNTOOLS))" - ifneq ($(word 2,$(VS100COMNTOOLS)),) - fVS100COMNTOOLS :=$(call FullPath,$(xVS100COMNTOOLS)) - else - fVS100COMNTOOLS :=$(xVS100COMNTOOLS) - endif - endif - ifneq ($(fVS100COMNTOOLS),) - VS100COMNTOOLS :=$(fVS100COMNTOOLS)/ - endif - # Check to see that both exist - ifeq ($(WINDOWSSDKDIR),) - _vs2010_message := No WINDOWSSDKDIR found on system. $(_vs2010_message) - VS2010_EXISTS := false - endif - ifeq ($(VS100COMNTOOLS),) - _vs2010_message := No VS100COMNTOOLS found on system. $(_vs2010_message) - VS2010_EXISTS := false - endif - ifeq ($(VS2010_EXISTS),false) - x:=$(warning WARNING: No VS2010 available. $(_vs2010_message)) - VS100COMNTOOLS := - WINDOWSSDKDIR := - else - VS2010_EXISTS := true - _msvc_dir :=$(VS100COMNTOOLS)/../../Vc - endif - export VS2010_EXISTS - export VS100COMNTOOLS - export WINDOWSSDKDIR -endif - -ifneq ($(VS2010_EXISTS),true) - x:=$(error ERROR: No VS2010 found on system.) -endif - -# VS2010 Compiler root directory -_msvc_dir :=$(VS100COMNTOOLS)/../../Vc -# SDK root directory -_ms_sdk :=$(WINDOWSSDKDIR) -# Compiler bin directory and redist directory -ifeq ($(ARCH_DATA_MODEL), 32) - _compiler_bin :=$(_msvc_dir)/Bin - _redist_sdk :=$(call FullPath,$(_msvc_dir)/redist/x86/Microsoft.VC100.CRT) -endif -ifeq ($(ARCH_DATA_MODEL), 64) - _compiler_bin :=$(_msvc_dir)/bin/amd64 - _redist_sdk :=$(call FullPath,$(_msvc_dir)/redist/x64/Microsoft.VC100.CRT) -endif -ifeq ($(_redist_sdk),) - _redist_sdk :=$(_system_root)/system32 -endif - -# Location on system where jdk installs might be -ifneq ($(_program_files),) - USRJDKINSTANCES_PATH =$(_program_files)/Java -else - USRJDKINSTANCES_PATH =$(_system_drive)/ -endif - -# SLASH_JAVA: location of all network accessable files -# NOTE: Do not use FullPath on this because it's often a drive letter and -# plain drive letters are ambiguous, so just use this 'as is'. -ifdef ALT_SLASH_JAVA - xALT_SLASH_JAVA :="$(subst \,/,$(ALT_SLASH_JAVA))" - SLASH_JAVA :=$(xALT_SLASH_JAVA) -else - ifdef ALT_JDK_JAVA_DRIVE - SLASH_JAVA =$(JDK_JAVA_DRIVE) - else - SLASH_JAVA =J: - endif -endif -#SLASH_JAVA:=$(call AltCheckSpaces,SLASH_JAVA) - -# JDK_DEVTOOLS_DIR: common path for all the java devtools -ifdef ALT_JDK_DEVTOOLS_DIR - xALT_JDK_DEVTOOLS_DIR :="$(subst \,/,$(ALT_JDK_DEVTOOLS_DIR))" - JDK_DEVTOOLS_DIR :=$(call FullPath,$(xALT_JDK_DEVTOOLS_DIR)) -else - JDK_DEVTOOLS_DIR =$(SLASH_JAVA)/devtools -endif -JDK_DEVTOOLS_DIR:=$(call AltCheckSpaces,JDK_DEVTOOLS_DIR) - -# COMPILER_PATH: path to where the compiler and tools are installed. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifdef ALT_COMPILER_PATH - xALT_COMPILER_PATH :="$(subst \,/,$(ALT_COMPILER_PATH))" - fxALT_COMPILER_PATH :=$(call FullPath,$(xALT_COMPILER_PATH)) - COMPILER_PATH :=$(call PrefixPath,$(fxALT_COMPILER_PATH)) -else - COMPILER_PATH :=$(call PrefixPath,$(_compiler_bin)) -endif -COMPILER_PATH :=$(call AltCheckSpaces,COMPILER_PATH) - -# MSDEVTOOLS_PATH: path to where the additional MS Compiler tools are. -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifdef ALT_MSDEVTOOLS_PATH - xALT_MSDEVTOOLS_PATH :="$(subst \,/,$(ALT_MSDEVTOOLS_PATH))" - fxALT_MSDEVTOOLS_PATH :=$(call FullPath,$(xALT_MSDEVTOOLS_PATH)) - MSDEVTOOLS_PATH :=$(call PrefixPath,$(fxALT_MSDEVTOOLS_PATH)) -else - ifeq ($(ARCH_DATA_MODEL), 64) - ifdef MSTOOLS - xMSTOOLS :="$(subst \,/,$(MSTOOLS))" - _ms_tools :=$(call FullPath,$(xMSTOOLS)) - else - ifdef Mstools - xMSTOOLS :="$(subst \,/,$(Mstools))" - _ms_tools :=$(call FullPath,$(xMSTOOLS)) - else - _ms_tools := - endif - endif - ifneq ($(_ms_tools),) - _ms_tools_bin :=$(_ms_tools)/Bin - else - # Assumes compiler bin is .../Bin/win64/x86/AMD64, rc.exe is 3 levels up - _ms_tools_bin :=$(_compiler_bin)/../../.. - endif - else - _ms_tools_bin :=$(_compiler_bin) - endif - MSDEVTOOLS_PATH :=$(call PrefixPath,$(_ms_tools_bin)) -endif -MSDEVTOOLS_PATH:=$(call AltCheckSpaces,MSDEVTOOLS_PATH) - -# DEVTOOLS_PATH: for other tools required for building (such as zip, etc.) -# NOTE: Must end with / so that it could be empty, allowing PATH usage. -ifdef ALT_DEVTOOLS_PATH - xALT_DEVTOOLS_PATH :="$(subst \,/,$(ALT_DEVTOOLS_PATH))" - fxALT_DEVTOOLS_PATH :=$(call FullPath,$(xALT_DEVTOOLS_PATH)) - DEVTOOLS_PATH :=$(call PrefixPath,$(fxALT_DEVTOOLS_PATH)) -else - ifdef USING_CYGWIN - DEVTOOLS_PATH :=$(UNIXCOMMAND_PATH) - else - xDEVTOOLS_PATH :="$(_system_drive)/utils" - fxDEVTOOLS_PATH :=$(call FullPath,$(xDEVTOOLS_PATH)) - DEVTOOLS_PATH :=$(call PrefixPath,$(fxDEVTOOLS_PATH)) - endif -endif -DEVTOOLS_PATH:=$(call AltCheckSpaces,DEVTOOLS_PATH) - -# _BOOTDIR1: First choice for a Bootstrap JDK, previous released JDK. -# _BOOTDIR2: Second choice -# The _BOOTDIR3 is defind optionally. -ifndef ALT_BOOTDIR - _BOOTDIR1 =$(_system_drive)/jdk$(PREVIOUS_JDK_VERSION) - _BOOTDIR2 =$(USRJDKINSTANCES_PATH)/jdk$(PREVIOUS_JDK_VERSION) - _BOOTDIR3 =$(SLASH_JAVA)/re/jdk/$(PREVIOUS_JDK_VERSION)/archive/fcs/binaries/$(PLATFORM)-$(ARCH) -endif - -# Everybody needs the MSVCRNN runtime starting with VS2010 -_NEEDS_MSVCRNN = true - -ifeq ($(_NEEDS_MSVCRNN), true) - # MSVCRNN_DLL_PATH: location of msvcrnn.dll that will be re-distributed - ifdef ALT_MSVCRNN_DLL_PATH - xALT_MSVCRNN_DLL_PATH :="$(subst \,/,$(ALT_MSVCRNN_DLL_PATH))" - MSVCRNN_DLL_PATH :=$(call FullPath,$(xALT_MSVCRNN_DLL_PATH)) - else - MSVCRNN_DLL_PATH :=$(_redist_sdk) - endif - MSVCRNN_DLL_PATH :=$(call AltCheckSpaces,MSVCRNN_DLL_PATH) -endif - -# DXSDK_PATH: path to Microsoft DirectX SDK Include and Lib -ifdef ALT_DXSDK_PATH - xALT_DXSDK_PATH :="$(subst \,/,$(ALT_DXSDK_PATH))" - DXSDK_PATH :=$(call FullPath,$(xALT_DXSDK_PATH)) -else - _DXSDK_PATH1 :=$(_dx_sdk_dir) - _DXSDK_PATH2 :=$(JDK_DEVTOOLS_DIR)/windows/dxsdk - DXSDK_PATH :=$(call DirExists,$(_DXSDK_PATH1),$(_DXSDK_PATH2),$(_dx_sdk_dir)) -endif -DXSDK_PATH :=$(call AltCheckSpaces,DXSDK_PATH) - -# DXSDK_INCLUDE_PATH: path to Microsoft DirectX SDK Include -ifdef ALT_DXSDK_INCLUDE_PATH - xALT_DXSDK_INCLUDE_PATH :="$(subst \,/,$(ALT_DXSDK_INCLUDE_PATH))" - DXSDK_INCLUDE_PATH :=$(call FullPath,$(xALT_DXSDK_INCLUDE_PATH)) -else - DXSDK_INCLUDE_PATH =$(subst //,/,$(DXSDK_PATH)/Include) -endif - -# DXSDK_LIB_PATH: path to Microsoft DirectX SDK Lib -ifdef ALT_DXSDK_LIB_PATH - xALT_DXSDK_LIB_PATH :="$(subst \,/,$(ALT_DXSDK_LIB_PATH))" - DXSDK_LIB_PATH :=$(call FullPath,$(xALT_DXSDK_LIB_PATH)) -else - ifeq ($(ARCH_DATA_MODEL), 64) - # 64bit libs are located in "Lib/x64" subdir - DXSDK_LIB_PATH =$(subst //,/,$(DXSDK_PATH)/Lib/x64) - else - DXSDK_LIB_PATH =$(subst //,/,$(DXSDK_PATH)/Lib) - endif -endif - -# DEPLOY_MSSDK: Microsoft SDK for this platform (for deploy) -ifdef ALT_DEPLOY_MSSDK - xALT_DEPLOY_MSSDK :="$(subst \,/,$(ALT_DEPLOY_MSSDK))" - DEPLOY_MSSDK :=$(call FullPath,$(xALT_DEPLOY_MSSDK)) -else - DEPLOY_MSSDK :=$(_ms_sdk) -endif -DEPLOY_MSSDK:=$(call AltCheckSpaces,DEPLOY_MSSDK) - -# INSTALL_MSSDK: Microsoft Installer SDK for this platform (for install) -ifdef ALT_INSTALL_MSSDK - xALT_INSTALL_MSSDK :="$(subst \,/,$(ALT_INSTALL_MSSDK))" - INSTALL_MSSDK :=$(call FullPath,$(xALT_INSTALL_MSSDK)) -else - INSTALL_MSSDK :=$(_ms_sdk) -endif -INSTALL_MSSDK:=$(call AltCheckSpaces,INSTALL_MSSDK) - -# WSCRIPT: path to wscript.exe (used in creating install bundles) -ifdef ALT_WSCRIPT - xALT_WSCRIPT :="$(subst \,/,$(ALT_WSCRIPT))" - WSCRIPT =$(xALT_WSCRIPT) -else - _WSCRIPT1 :=$(_system_root)/system32/wscript.exe - _WSCRIPT2 :=$(DEVTOOLS_PATH)wscript.exe - WSCRIPT :=$(call FileExists,$(_WSCRIPT1),$(_WSCRIPT2)) -endif -WSCRIPT:=$(call AltCheckSpaces,WSCRIPT) -# batch mode no modal dialogs on errors, please. -WSCRIPT += -B - -# CSCRIPT: path to cscript.exe (used in creating install bundles) -ifdef ALT_CSCRIPT - xALT_CSCRIPT :="$(subst \,/,$(ALT_CSCRIPT))" - CSCRIPT =$(xALT_CSCRIPT) -else - _CSCRIPT1 :=$(_system_root)/system32/cscript.exe - _CSCRIPT2 :=$(DEVTOOLS_PATH)cscript.exe - CSCRIPT :=$(call FileExists,$(_CSCRIPT1),$(_CSCRIPT2)) -endif -CSCRIPT:=$(call AltCheckSpaces,CSCRIPT) - -# CABARC: path to cabarc.exe (used in creating install bundles) -ifdef ALT_CABARC - xALT_CABARC :="$(subst \,/,$(ALT_CABARC))" - CABARC =$(xALT_CABARC) -else - _CABARC1 :=$(_system_root)/system32/cabarc.exe - _CABARC2 :=$(DEVTOOLS_PATH)cabarc.exe - CABARC :=$(call FileExists,$(_CABARC1),$(_CABARC2)) -endif -CABARC:=$(call AltCheckSpaces,CABARC) - -# MSICERT: path to msicert.exe (used in creating install bundles) -ifdef ALT_MSICERT - xALT_MSICERT :="$(subst \,/,$(ALT_MSICERT))" - MSICERT =$(xALT_MSICERT) -else - _MSICERT1 :=$(INSTALL_MSSDK)/Bin/msicert.exe - _MSICERT2 :=$(DEVTOOLS_PATH)msicert.exe - MSICERT :=$(call FileExists,$(_MSICERT1),$(_MSICERT2)) -endif -MSICERT:=$(call AltCheckSpaces,MSICERT) - -# Import JDK images allow for partial builds, components not built are -# imported (or copied from) these import areas when needed. - -# BUILD_JDK_IMPORT_PATH: location of JDK install trees to import for -# multiple platforms, e.g. windows-i586, solaris-sparc, linux-586, etc. -ifdef ALT_BUILD_JDK_IMPORT_PATH - BUILD_JDK_IMPORT_PATH :=$(call FullPath,$(ALT_BUILD_JDK_IMPORT_PATH)) -else - BUILD_JDK_IMPORT_PATH = $(PROMOTED_BUILD_BINARIES) -endif -BUILD_JDK_IMPORT_PATH:=$(call AltCheckSpaces,BUILD_JDK_IMPORT_PATH) - -# JDK_IMPORT_PATH: location of previously built JDK (this version) to import -ifdef ALT_JDK_IMPORT_PATH - JDK_IMPORT_PATH :=$(call FullPath,$(ALT_JDK_IMPORT_PATH)) -else - JDK_IMPORT_PATH = $(BUILD_JDK_IMPORT_PATH)/$(PLATFORM)-$(ARCH)$(_JDK_IMPORT_VARIANT) -endif -JDK_IMPORT_PATH:=$(call AltCheckSpaces,JDK_IMPORT_PATH) - -# HOTSPOT_CLIENT_PATH: location of client jvm library file. -ifeq ($(ARCH_DATA_MODEL), 32) - ifdef ALT_HOTSPOT_CLIENT_PATH - HOTSPOT_CLIENT_PATH :=$(call FullPath,$(ALT_HOTSPOT_CLIENT_PATH)) - else - HOTSPOT_CLIENT_PATH =$(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/client - endif - HOTSPOT_CLIENT_PATH:=$(call AltCheckSpaces,HOTSPOT_CLIENT_PATH) -endif - -# HOTSPOT_SERVER_PATH: location of server jvm library file. -ifdef ALT_HOTSPOT_SERVER_PATH - HOTSPOT_SERVER_PATH :=$(call FullPath,$(ALT_HOTSPOT_SERVER_PATH)) -else - HOTSPOT_SERVER_PATH =$(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/server -endif -HOTSPOT_SERVER_PATH:=$(call AltCheckSpaces,HOTSPOT_SERVER_PATH) - -# HOTSPOT_LIB_PATH: location of jvm.lib file. -ifdef ALT_HOTSPOT_LIB_PATH - xALT_HOTSPOT_LIB_PATH :="$(subst \,/,$(ALT_HOTSPOT_LIB_PATH))" - HOTSPOT_LIB_PATH :=$(call FullPath,$(xALT_HOTSPOT_LIB_PATH)) -else - HOTSPOT_LIB_PATH =$(HOTSPOT_IMPORT_PATH)/lib -endif -HOTSPOT_LIB_PATH:=$(call AltCheckSpaces,HOTSPOT_LIB_PATH) - -# Special define for checking the binaries - -# All windows dll and exe files should have been built with /NXCOMPAT -# and be setup for dynamic base addresses. -# In addition, we should not be dependent on certain dll files that -# we do not or cannot redistribute. - -# List of filenames we should NOT be dependent on -ifeq ($(MFC_DEBUG),true) - BANNED_DLLS=msvcp100[.]dll -else - BANNED_DLLS=msvcp100[.]dll|msvcr100d[.]dll|msvcrtd[.]dll -endif - -# Check for /safeseh (only used on 32bit) -define binary_file_safeseh_verification # binary_file -( \ - $(ECHO) "Checking for /SAFESEH usage in: $1" && \ - if [ "`$(DUMPBIN) /loadconfig $1 | $(EGREP) -i 'Safe Exception Handler Table'`" = "" ] ; then \ - $(ECHO) "ERROR: Did not find 'Safe Exception Handler Table' in loadconfig: $1" ; \ - $(DUMPBIN) /loadconfig $1 ; \ - exit 6 ; \ - fi ; \ -) -endef - -# Check for /NXCOMPAT usage -define binary_file_nxcompat_verification # binary_file -( \ - $(ECHO) "Checking for /NXCOMPAT usage in: $1" && \ - if [ "`$(DUMPBIN) /headers $1 | $(EGREP) -i 'NX compatible'`" = "" ] ; then \ - $(ECHO) "ERROR: Did not find 'NX compatible' in headers: $1" ; \ - $(DUMPBIN) /headers $1 ; \ - exit 7 ; \ - fi ; \ -) -endef - -# Check for /DYNAMICBASE usage -define binary_file_dynamicbase_verification # binary_file -( \ - $(ECHO) "Checking for /DYNAMICBASE usage in: $1" && \ - if [ "`$(DUMPBIN) /headers $1 | $(EGREP) -i 'Dynamic base'`" = "" ] ; then \ - $(ECHO) "ERROR: Did not find 'Dynamic base' in headers: $1" ; \ - $(DUMPBIN) /headers $1 ; \ - exit 8 ; \ - fi ; \ -) -endef - -# Check for banned dll usage -define binary_file_dll_verification # binary_file -( \ - $(ECHO) "Checking for banned dependencies in: $1" && \ - if [ "`$(DUMPBIN) /dependents $1 | $(EGREP) -i '$(BANNED_DLLS)'`" != "" ] ; then \ - $(ECHO) "ERROR: Found use of $(BANNED_DLLS)"; \ - $(DUMPBIN) /dependents $1 ; \ - exit 9 ; \ - fi ; \ -) -endef - -# Macro to check it's input file for properly built executables. -# Relies on process exit code. Different for 32bit vs 64bit. -ifeq ($(ARCH_DATA_MODEL),32) -define binary_file_verification # binary_file -( \ - $(call binary_file_safeseh_verification,$1); \ - $(call binary_file_nxcompat_verification,$1); \ - $(call binary_file_dynamicbase_verification,$1); \ - $(call binary_file_dll_verification,$1); \ -) -endef -else -define binary_file_verification # binary_file -( \ - $(call binary_file_nxcompat_verification,$1); \ - $(call binary_file_dynamicbase_verification,$1); \ - $(call binary_file_dll_verification,$1); \ -) -endef -endif - diff --git a/jdk/makefiles/common/shared/Defs.gmk b/jdk/makefiles/common/shared/Defs.gmk deleted file mode 100644 index 89af038a7cb..00000000000 --- a/jdk/makefiles/common/shared/Defs.gmk +++ /dev/null @@ -1,662 +0,0 @@ -# -# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Definitions for all platforms. -# -# Normally the convention is that these alternate definitions of -# primary make variables are never defined inside the Makefiles anywhere -# but are defined via environment variables or set on the make command -# line. So you should never see an ALT_* variable defined in any -# makefiles, just used. This is the convention and there are some -# exceptions, either mistakes or unusual circumstances. -# -# The naming convention for the default value of one of these variables -# that has an ALT_* override capability is to name the default value with a -# leading underscore (_). So for XXX you would have: -# _XXX default value -# ALT_XXX any override the user is providing if any -# XXX the final value, either the default _XXX or the ALT_XXX value. -# - -# On Directory names. In very rare cases should the Windows directory -# names use the backslash, please use the C:/ style of windows paths. -# Avoid duplicating the // characters in paths, this has known to cause -# strange problems with jar and other utilities, e.g. /a//b/ != /a/b/. -# Some of these variables have an explicit trailing / character, but in -# general, they should NOT have the trailing / character. - --include $(SPEC) --include $(VARS) - -# Assumes ARCH, PLATFORM, ARCH_VM_SUBDIR, JDK_TOPDIR, etc. have been defined. - -# Simple pwd path -# NOTE: Just use the shell's cd and pwd here, more reliable at sanity time. -define PwdPath -$(shell cd $1 2> $(DEV_NULL) && pwd) -endef -define AbsPwdPathCheck -$(shell cd .. 2> $(DEV_NULL) && cd $1 2> $(DEV_NULL) && pwd) -endef - -# Checks an ALT value for spaces (should be one word), -# warns and returns Check_ALT_$1 if spaces -define AltCheckSpaces -$(if $(word 2,$($1)),$(warning "WARNING: Value of $1 contains a space: '$($1)', check or set ALT_$1")Check_ALT_$1,$($1)) -endef - -# Checks an ALT value for empty, warns and returns Check_ALT_$1 if empty -define AltCheckValue -$(if $($1),$($1),$(warning "WARNING: Value of $1 cannot be empty, check or set ALT_$1")Check_ALT_$1) -endef - -# Checks any value for empty, warns and returns $2 if empty -define CheckValue -$(if $($1),$($1),$(warning "WARNING: Value of $1 cannot be empty, will use '$2'")$2) -endef - -# Prefix for a utility prefix path, if empty leave alone, otherwise end with a / -define PrefixPath -$(if $1,$(subst //,/,$1/),) -endef - -# Select a directory if it exists, or the alternate 2 or the alternate 3 -define DirExists -$(shell \ - if [ -d "$1" ]; then \ - echo "$1"; \ - elif [ -d "$2" ]; then \ - echo "$2"; \ - else \ - echo "$3"; \ - fi) -endef - -# Select a directory if it exists, or the alternate 2, or the alternate 3, or the alternate 4 -define DirExists4 -$(shell \ - if [ -d "$1" ]; then \ - echo "$1"; \ - elif [ -d "$2" ]; then \ - echo "$2"; \ - elif [ -d "$3" ]; then \ - echo "$3"; \ - else \ - echo "$4"; \ - fi) -endef - - -# Select a writable directory if it exists and is writable, or the alternate -define WriteDirExists -$(shell \ - if [ -d "$1" -a -w "$1" ]; then \ - echo "$1"; \ - else \ - echo "$2"; \ - fi) -endef - -# Select a file if it exists, or the alternate 1, or the alternate 2 -define FileExists -$(shell \ - if [ -r "$1" ]; then \ - echo "$1"; \ - elif [ -r "$2" ]; then \ - echo "$2"; \ - else \ - echo "NO_FILE_EXISTS"; \ - fi) -endef - -# Given a line of text, get the version number from it -define GetVersion -$(shell echo $1 | sed -e 's@[^0-9]*\([0-9][0-9]*\.[0-9][.0-9]*\).*@\1@' ) -endef - -# Return one part of the version numbers, watch out for non digits. -define VersionWord # Number Version -$(word $1,$(subst ., ,$(subst -, ,$2))) -endef - -# Given a major.minor.micro version, return the major, minor, or micro number -define MajorVersion -$(if $(call VersionWord,1,$1),$(call VersionWord,1,$1),0) -endef -define MinorVersion -$(if $(call VersionWord,2,$1),$(call VersionWord,2,$1),0) -endef -define MicroVersion -$(if $(call VersionWord,3,$1),$(call VersionWord,3,$1),0) -endef - -# Macro that returns missing, same, newer, or older $1=version $2=required -define CheckVersions -$(shell \ - if [ "$1" = "" -o "$2" = "" ]; then \ - echo missing; \ - elif [ "$1" = "$2" ]; then \ - echo same; \ - elif [ $(call MajorVersion,$1) -lt $(call MajorVersion,$2) ] ; then \ - echo older; \ - elif [ $(call MajorVersion,$1) -gt $(call MajorVersion,$2) ] ; then \ - echo newer; \ - elif [ $(call MinorVersion,$1) -lt $(call MinorVersion,$2) ]; then \ - echo older; \ - elif [ $(call MinorVersion,$1) -gt $(call MinorVersion,$2) ]; then \ - echo newer; \ - elif [ $(call MicroVersion,$1) -lt $(call MicroVersion,$2) ]; then \ - echo older; \ - elif [ $(call MicroVersion,$1) -gt $(call MicroVersion,$2) ]; then \ - echo newer; \ - else \ - echo same; \ - fi) -endef - -# Expand SRCDIR_LIST, which is used to automatically include various -# platform and shared sources/headers. This is mainly useful for the -# Mac OS X build, which pulls its platform sources from the solaris and/or -# macosx trees, depending on the component. -ifeq ($(PLATFORM), macosx) - define JavaSrcDirList - $(JAVA_SRCDIR_LIST:%=$1$(JDK_TOPDIR)/%/$2) - endef - define NativeSrcDirList - $(NATIVE_SRCDIR_LIST:%=$1$(JDK_TOPDIR)/%/$2) - endef -endif - -# Make sure certain variables are non-empty at this point -_check_values:=\ -$(call CheckValue,ARCH,),\ -$(call CheckValue,ARCH_DATA_MODEL,),\ -$(call CheckValue,ARCH_VM_SUBDIR,),\ -$(call CheckValue,JDK_TOPDIR,),\ -$(call CheckValue,JDK_MAKE_SHARED_DIR,),\ -$(call CheckValue,VARIANT,),\ -$(call CheckValue,PLATFORM,) - -# Misc common settings for all workspaces -# This determines the version of the product, and the previous version or boot -ifndef JDK_MAJOR_VERSION - JDK_MAJOR_VERSION = 1 - PREVIOUS_MAJOR_VERSION = 1 -endif - -ifndef JDK_MINOR_VERSION - JDK_MINOR_VERSION = 8 - PREVIOUS_MINOR_VERSION = 7 -endif - -ifndef JDK_MICRO_VERSION - JDK_MICRO_VERSION = 0 - PREVIOUS_MICRO_VERSION = 0 -endif - -ifndef MILESTONE - MILESTONE = internal -endif - -# Default names -ifdef OPENJDK - LAUNCHER_NAME = openjdk - PRODUCT_NAME = OpenJDK - PRODUCT_SUFFIX = Runtime Environment - JDK_RC_PLATFORM_NAME = Platform - COMPANY_NAME = N/A -else - LAUNCHER_NAME = java - PRODUCT_NAME = Java(TM) - PRODUCT_SUFFIX = SE Runtime Environment - JDK_RC_PLATFORM_NAME = Platform SE - COMPANY_NAME = Oracle Corporation -endif - -RUNTIME_NAME = $(PRODUCT_NAME) $(PRODUCT_SUFFIX) - -ifndef BUILD_NUMBER - JDK_BUILD_NUMBER = b00 -else - ifndef JDK_BUILD_NUMBER - JDK_BUILD_NUMBER = $(BUILD_NUMBER) - endif -endif - -# Default variant is the optimized version of everything -# can be OPT or DBG, default is OPT -# Determine the extra pattern to add to the release name for debug/fastdebug. -# Determine the JDK_IMPORT_VARIANT, so we get the right VM files copied over. -# Determine suffix for obj directory or OBJDIR, for .o files. -# (by keeping .o files separate, just .o files, they don't clobber each -# other, however, the library files will clobber each other). -# -ifeq ($(VARIANT), DBG) - BUILD_VARIANT_RELEASE=-debug - OBJDIRNAME_SUFFIX=_g -else - BUILD_VARIANT_RELEASE= - OBJDIRNAME_SUFFIX= -endif -ifeq ($(FASTDEBUG), true) - VARIANT=DBG - BUILD_VARIANT_RELEASE=-fastdebug - OBJDIRNAME_SUFFIX=_gO - _JDK_IMPORT_VARIANT=/fastdebug -endif - -# Depending on the flavor of the build, add a -debug or -fastdebug to the name -ifdef DEBUG_NAME - BUILD_VARIANT_RELEASE=-$(DEBUG_NAME) -endif - -# These default values are redefined during a release build. -# CTE can set JDK_UPDATE_VERSION during the update release -ifdef JDK_UPDATE_VERSION - JDK_VERSION = $(JDK_MAJOR_VERSION).$(JDK_MINOR_VERSION).$(JDK_MICRO_VERSION)_$(JDK_UPDATE_VERSION) - MARKETING_NUMBER := $(shell \ - $(ECHO) $(JDK_UPDATE_VERSION) | $(NAWK) '{if (substr($$0,1,1)=="0") print substr($$0, 2); else print $$0;}') - MARKET_NAME= $(shell $(ECHO) " Update $(MARKETING_NUMBER)") - JDK_MKTG_VERSION = $(JDK_MINOR_VERSION)u$(MARKETING_NUMBER) -else - JDK_VERSION = $(JDK_MAJOR_VERSION).$(JDK_MINOR_VERSION).$(JDK_MICRO_VERSION) - JDK_MKTG_VERSION = $(JDK_MINOR_VERSION) - MARKET_NAME= -endif -JDK_UNDERSCORE_VERSION = $(subst .,_,$(JDK_VERSION)) -JDK_MKTG_UNDERSCORE_VERSION = $(subst .,_,$(JDK_MKTG_VERSION)) - -# RELEASE is JDK_VERSION and -MILESTONE if MILESTONE is set -ifneq ($(MILESTONE),fcs) - RELEASE = $(JDK_VERSION)-$(MILESTONE)$(BUILD_VARIANT_RELEASE) -else - RELEASE = $(JDK_VERSION)$(BUILD_VARIANT_RELEASE) -endif - -# FULL_VERSION is RELEASE and -BUILD_NUMBER if BUILD_NUMBER is set -ifdef BUILD_NUMBER - FULL_VERSION = $(RELEASE)-$(BUILD_NUMBER) -else - BUILD_NUMBER = b00 - ifndef USER_RELEASE_SUFFIX - BUILD_DATE := $(shell $(DATE) '+%Y_%m_%d_%H_%M') - # Avoid [:alnum:] since it depends on the locale. - CLEAN_USERNAME := $(shell $(ECHO) "$(USER)" | $(TR) -d -c 'abcdefghijklmnopqrstuvqxyz0123456789') - USER_RELEASE_SUFFIX := $(shell $(ECHO) "$(CLEAN_USERNAME)_$(BUILD_DATE)" | $(TR) 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvqxyz') - endif - export USER_RELEASE_SUFFIX - FULL_VERSION = $(RELEASE)-$(USER_RELEASE_SUFFIX)-$(BUILD_NUMBER) -endif - -# Promoted build location -PROMOTED_RE_AREA = $(SLASH_JAVA)/re/jdk/$(JDK_VERSION)/promoted -PROMOTED_BUILD_LATEST = latest -PROMOTED_BUILD_BASEDIR = $(PROMOTED_RE_AREA)/$(PROMOTED_BUILD_LATEST) -PROMOTED_BUILD_DISTDIR = $(PROMOTED_BUILD_BASEDIR)/dist/$(PLATFORM)-$(ARCH) -PROMOTED_BUILD_BINARIES = $(PROMOTED_BUILD_BASEDIR)/binaries - -# PARALLEL_COMPILE_JOBS: is the number of compiles done in parallel. -# If the user sets ALT_PARALLEL_COMPILE_JOBS, then COMPILE_APPROACH is set -# to parallel. -# -# Recommended setting: 2 seems to be ideal for single cpu machines, -# 2 times the number of CPU's is a basic formula, -# but probably not more than 4 if the machine is -# being shared by others, or the machine is limited -# in RAM or swap. -# -ifdef ALT_PARALLEL_COMPILE_JOBS - PARALLEL_COMPILE_JOBS=$(ALT_PARALLEL_COMPILE_JOBS) -else - PARALLEL_COMPILE_JOBS=2 -endif - -# Previous JDK release (version of BOOTDIR version) -ifdef ALT_PREVIOUS_JDK_VERSION - PREVIOUS_JDK_VERSION = $(ALT_PREVIOUS_JDK_VERSION) -else - PREVIOUS_JDK_VERSION = $(PREVIOUS_MAJOR_VERSION).$(PREVIOUS_MINOR_VERSION).$(PREVIOUS_MICRO_VERSION) -endif -export PREVIOUS_JDK_VERSION -PREVIOUS_JDK_VERSION:=$(call AltCheckSpaces,PREVIOUS_JDK_VERSION) - -# Version with _ instead of . in number -ifeq ($(PREVIOUS_MINOR_VERSION),5) - PREVIOUS_JDK_UNDERSCORE_VERSION = $(subst .,_,$(PREVIOUS_JDK_VERSION)) -else - PREVIOUS_JDK_UNDERSCORE_VERSION = $(PREVIOUS_MINOR_VERSION) -endif - -# Include any private definitions for this set of workspaces -_PRIVATE_DEFS_FILE=$(JDK_MAKE_SHARED_DIR)/PrivateDefs.gmk -ifeq ($(USING_PRIVATE_DEFS),) - USING_PRIVATE_DEFS:=$(shell if [ -f $(_PRIVATE_DEFS_FILE) ]; then echo true; else echo false; fi) -endif -ifeq ($(USING_PRIVATE_DEFS),true) -dummy:=$(warning "WARNING: Using definitions from $(_PRIVATE_DEFS_FILE)") -include $(_PRIVATE_DEFS_FILE) -endif - -# OUTPUTDIR: Location of all output for the build -ifdef ALT_OUTPUTDIR - OUTPUTDIR:=$(subst \,/,$(ALT_OUTPUTDIR)) - # Assumes this is absolute (checks later) - ABS_OUTPUTDIR:=$(OUTPUTDIR) -else - ifndef _OUTPUTDIR - # Default: Get "build" parent directory, which should always exist - ifndef BUILD_PARENT_DIRECTORY - BUILD_PARENT_DIRECTORY=$(BUILDDIR)/.. - endif - ifdef OPENJDK - _OUTPUTDIRNAME=$(PLATFORM)-$(ARCH)$(OPENJDK_SUFFIX) - else - _OUTPUTDIRNAME=$(PLATFORM)-$(ARCH) - endif - _OUTPUTDIR=$(BUILD_PARENT_DIRECTORY)/build/$(_OUTPUTDIRNAME) - endif - OUTPUTDIR:=$(_OUTPUTDIR) -endif -# Check for spaces and null value -OUTPUTDIR:=$(call AltCheckSpaces,OUTPUTDIR) - -# Get platform specific settings -# NB: OUTPUTDIR must be defined. Otherwise hotspot import detection will not work correctly -# On other hand this must be included early as it provides platform specific defines such as FullPath -include $(JDK_MAKE_SHARED_DIR)/Defs-versions.gmk - -# Get platform specific settings (defines COMPILER_PATH) -include $(JDK_MAKE_SHARED_DIR)/Defs-$(PLATFORM).gmk - -# Components -ifdef ALT_LANGTOOLS_DIST - LANGTOOLS_DIST :=$(call FullPath,$(ALT_LANGTOOLS_DIST)) -else - LANGTOOLS_DIST = -endif -ifdef ALT_CORBA_DIST - CORBA_DIST :=$(call FullPath,$(ALT_CORBA_DIST)) -else - CORBA_DIST = -endif -ifdef ALT_JAXP_DIST - JAXP_DIST :=$(call FullPath,$(ALT_JAXP_DIST)) -else - JAXP_DIST = -endif -ifdef ALT_JAXWS_DIST - JAXWS_DIST :=$(call FullPath,$(ALT_JAXWS_DIST)) -else - JAXWS_DIST = -endif - -# HOTSPOT_DOCS_IMPORT_PATH: Path to hotspot docs files to import into the docs generation -ifdef ALT_HOTSPOT_DOCS_IMPORT_PATH - HOTSPOT_DOCS_IMPORT_PATH :=$(call FullPath,$(ALT_HOTSPOT_DOCS_IMPORT_PATH)) -else - HOTSPOT_DOCS_IMPORT_PATH :=$(call DirExists,$(HOTSPOT_IMPORT_PATH)/docs,$(PROMOTED_BUILD_BASEDIR)/docs,/NO_DOCS_DIR) -endif - -# These are the same on all platforms but require the above platform include 1st - -# BOOTDIR: Bootstrap JDK, previous released JDK. -# _BOOTDIR1 and _BOOTDIR2 picked by platform -# Platform may optionally define _BOOTDIR3 as well. -ifdef ALT_BOOTDIR - BOOTDIR =$(ALT_BOOTDIR) -else - ifdef _BOOTDIR3 - BOOTDIR :=$(call DirExists4,$(_BOOTDIR1),$(_BOOTDIR2),$(_BOOTDIR3),/NO_BOOTDIR) - else - BOOTDIR :=$(call DirExists,$(_BOOTDIR1),$(_BOOTDIR2),/NO_BOOTDIR) - endif -endif -export BOOTDIR -BOOTDIR:=$(call AltCheckSpaces,BOOTDIR) - -# PREVIOUS_FCS_RE_AREA: re path to where previous release binaries/bundles are -PREVIOUS_FCS_RE_AREA = $(SLASH_JAVA)/re/jdk/$(PREVIOUS_JDK_VERSION)/archive/fcs - -# PREVIOUS_RELEASE_IMAGE: Previous install image to compare against -ifdef ALT_PREVIOUS_RELEASE_IMAGE - - # Explicit image provided, no bundle access needed - PREVIOUS_RELEASE_IMAGE :=$(call FullPath,$(ALT_PREVIOUS_RELEASE_IMAGE)) - -else - - # PREVIOUS_RELEASE_PATH: path to where previous release bundles are - ifdef ALT_PREVIOUS_RELEASE_PATH - PREVIOUS_RELEASE_PATH :=$(call OptFullPath,$(ALT_PREVIOUS_RELEASE_PATH)) - else - PREVIOUS_RELEASE_PATH := \ - $(call DirExists,$(PREVIOUS_FCS_RE_AREA)/bundles/$(PLATFORM)-$(ARCH),,) - endif - - # Depending on if we have access to these bundles - ifeq ($(PREVIOUS_RELEASE_PATH),) - # Use images in re area or BOOTDIR (which is normally the previous release) - PREVIOUS_RELEASE_IMAGE := \ - $(call DirExists,$(PREVIOUS_FCS_RE_AREA)/binaries/$(PLATFORM)-$(ARCH),$(BOOTDIR),) - else - # Get names of and paths to bundles - PREVIOUS_RELEASE_PATH:=$(call AltCheckSpaces,PREVIOUS_RELEASE_PATH) - export PREVIOUS_RELEASE_PATH - - # PREVIOUS_JDK_FILE: filename of install bundle for previous JDK - ifdef ALT_PREVIOUS_JDK_FILE - PREVIOUS_JDK_FILE =$(ALT_PREVIOUS_JDK_FILE) - else - PREVIOUS_JDK_FILE = \ - jdk-$(PREVIOUS_JDK_UNDERSCORE_VERSION)-$(PLATFORM)-$(ARCH)$(BUNDLE_FILE_SUFFIX) - endif - export PREVIOUS_JDK_FILE - PREVIOUS_JDK_FILE:=$(call AltCheckSpaces,PREVIOUS_JDK_FILE) - - # PREVIOUS_JRE_FILE: filename of install bundle for previous JRE - ifdef ALT_PREVIOUS_JRE_FILE - PREVIOUS_JRE_FILE =$(ALT_PREVIOUS_JRE_FILE) - else - PREVIOUS_JRE_FILE = \ - jre-$(PREVIOUS_JDK_UNDERSCORE_VERSION)-$(PLATFORM)-$(ARCH)$(BUNDLE_FILE_SUFFIX) - endif - export PREVIOUS_JRE_FILE - PREVIOUS_JRE_FILE:=$(call AltCheckSpaces,PREVIOUS_JRE_FILE) - - # Paths to these bundles - PREVIOUS_JRE_BUNDLE = $(PREVIOUS_RELEASE_PATH)/$(PREVIOUS_JRE_FILE) - PREVIOUS_JDK_BUNDLE = $(PREVIOUS_RELEASE_PATH)/$(PREVIOUS_JDK_FILE) - endif - -endif - -# Indicate we are using an image comparison -ifneq ($(PREVIOUS_RELEASE_IMAGE),) - PREVIOUS_RELEASE_PATH = USING-PREVIOUS_RELEASE_IMAGE - PREVIOUS_JRE_BUNDLE = USING-PREVIOUS_RELEASE_IMAGE - PREVIOUS_JDK_BUNDLE = USING-PREVIOUS_RELEASE_IMAGE -endif - -# CACERTS_FILE: if OPENJDK is false and the internal version of the file -# (that is, non-empty) is available, use it, otherwise use an -# empty keystore. -# -# We put this variable here for sanity checks and in case another -# components will need to know which cacerts file is being used. -# -ifdef ALT_CACERTS_FILE - CACERTS_FILE = $(ALT_CACERTS_FILE) -else - CACERTS_EXT = $(SHARE_SRC)/lib/security/cacerts - ifdef OPENJDK - CACERTS_FILE :=$(CACERTS_EXT) - else # (!OPENJDK) - CACERTS_INT = $(CLOSED_SHARE_SRC)/lib/security/cacerts.internal - CACERTS_FILE :=$(call FileExists,$(CACERTS_INT),$(CACERTS_EXT)) - endif # (OPENJDK) -endif -CACERTS_FILE:=$(call AltCheckSpaces,CACERTS_FILE) - -# -# When signing the JCE framework and provider, we could be using built -# bits on a read-only filesystem. If so, this test will fail and crash -# the build. -# -ifndef IGNORE_WRITABLE_OUTPUTDIR_TEST -# Create the output directory and make sure it exists and is writable -_create_outputdir:=$(shell $(MKDIR) -p "$(OUTPUTDIR)" > $(DEV_NULL) 2>&1) -ifeq ($(call WriteDirExists,$(OUTPUTDIR),/dev/null),/dev/null) - _outputdir_error:=$(error "ERROR: OUTPUTDIR '$(OUTPUTDIR)' not created or not writable") -endif -endif - -# Define absolute path if needed and check for spaces and null value -ifndef ABS_OUTPUTDIR - ifdef _OUTPUTDIRNAME - #Could not define this at the same time as _OUTPUTDIRNAME as FullPath is not defined at that point - ABS_BUILD_PARENT_DIRECTORY:=$(call FullPath,$(BUILD_PARENT_DIRECTORY)) - ABS_OUTPUTDIR:=$(ABS_BUILD_PARENT_DIRECTORY)/build/$(_OUTPUTDIRNAME) - else - ABS_OUTPUTDIR:=$(call FullPath,$(OUTPUTDIR)) - endif -endif -ABS_OUTPUTDIR:=$(call AltCheckSpaces,ABS_OUTPUTDIR) -# Make doubly sure this is a full path -ifeq ($(call AbsPwdPathCheck,$(ABS_OUTPUTDIR)), ) - ifdef ALT_OUTPUTDIR - _outputdir_error:=$(error "ERROR: Trouble with the absolute path for OUTPUTDIR '$(OUTPUTDIR)', was ALT_OUTPUTDIR '$(ALT_OUTPUTDIR)' an absolute path?") - else - _outputdir_error:=$(error "ERROR: Trouble with the absolute path for OUTPUTDIR '$(OUTPUTDIR)'") - endif -endif -_dir1:=$(call FullPath,$(ABS_OUTPUTDIR)) -_dir2:=$(call FullPath,$(OUTPUTDIR)) -ifneq ($(_dir1),$(_dir2)) - _outputdir_error:=$(error "ERROR: ABS_OUTPUTDIR '$(ABS_OUTPUTDIR)' is not the same directory as OUTPUTDIR '$(OUTPUTDIR)', '$(_dir1)'!='$(_dir2)'") -endif - -# Bin directory -# NOTE: ISA_DIR is usually empty, on Solaris it might be /sparcv9 or /amd64 -BINDIR = $(OUTPUTDIR)/bin$(ISA_DIR) - -# MOZILLA_HEADERS_PATH: path to mozilla header files for plugin -ifdef ALT_MOZILLA_HEADERS_PATH - MOZILLA_HEADERS_PATH :=$(call FullPath,$(ALT_MOZILLA_HEADERS_PATH)) -else - MOZILLA_HEADERS_PATH =$(JDK_DEVTOOLS_DIR)/share/plugin -endif -MOZILLA_HEADERS_PATH:=$(call AltCheckSpaces,MOZILLA_HEADERS_PATH) - -# CUPS_HEADERS_PATH: path to Cups headers files for Unix printing -#ifneq ($(PLATFORM), windows) -#JDK_CUPS_HEADERS_PATH=$(JDK_DEVTOOLS_DIR)/share/cups/include -# ifdef ALT_CUPS_HEADERS_PATH -# CUPS_HEADERS_PATH:=$(call FullPath,$(ALT_CUPS_HEADERS_PATH)) -# CUPS_HEADERS_PATH:=$(call AltCheckValue,CUPS_HEADERS_PATH) -# else -# CUPS_HEADERS_PATH:= \ -# $(shell if [ -d "$(JDK_CUPS_HEADERS_PATH)" ]; then \ -# echo "$(JDK_CUPS_HEADERS_PATH)"; \ -# else \ -# echo "$(_CUPS_HEADERS_PATH)";\ -# fi) -# endif -#endif - -# Utilities ant -ifeq ($(PLATFORM), windows) - ifeq ($(ANT_HOME),) - ANT_HOME := $(call DirExists,$(JDK_DEVTOOLS_DIR)/share/ant/latest,,) - endif -endif - -# There are few problems with ant we need to workaround: -# 1) ant is using temporary directory java.io.tmpdir -# However, this directory is not unique enough and two separate ant processes -# can easily end up using the exact same temp directory. This may lead to weird build failures -# To workaround this we will define tmp dir explicitly -# 2) ant attempts to detect JDK location based on java.exe location -# This is fragile as developer may have JRE first on the PATH. -# To workaround this we will specify JAVA_HOME explicitly - -ANT_TMPDIR = $(ABS_OUTPUTDIR)/tmp -ANT_WORKAROUNDS = ANT_OPTS=-Djava.io.tmpdir='$(ANT_TMPDIR)' JAVA_HOME='$(BOOTDIR)' - -ifeq ($(ANT_HOME),) - ANT = $(ANT_WORKAROUNDS) ant -else - ANT = $(ANT_WORKAROUNDS) $(ANT_HOME)/bin/ant -endif - -ifdef ALT_COPYRIGHT_YEAR - COPYRIGHT_YEAR = $(ALT_COPYRIGHT_YEAR) -else - COPYRIGHT_YEAR = $(shell $(DATE) '+%Y') -endif - -# Create file with source information -SOURCE_TIPS=$(ABS_OUTPUTDIR)/source_tips - -# The source tips can come from the Mercurial repository, or in the files -# $(HGTIP_FILENAME) which contains the tip but is also positioned in the same -# directory as the original $(HGDIR) directory. -# These should not be := assignments, only used from the root Makefile. -HG_VERSION = $(shell $(HG) version 2> $(DEV_NULL)) -HG_DIRECTORY=.hg -HGTIP_FILENAME=.hgtip -HG_SEARCH = ./REPO ./*/REPO ./*/*/REPO ./*/*/*/REPO -REPO_LIST = $(patsubst ./%,%,$(patsubst %/,%,$(sort $(dir \ - $(shell ( $(LS) -d $(HG_SEARCH:%/REPO=%/$(HG_DIRECTORY)) ; \ - $(LS) $(HG_SEARCH:%/REPO=%/$(HGTIP_FILENAME)) ) \ - 2> $(DEV_NULL)))))) - -# Emit the repo:tip pairs to $@ -define GetSourceTips -for i in $(REPO_LIST) IGNORE ; do \ - if [ "$${i}" = "IGNORE" ] ; then \ - continue; \ - elif [ -d $${i}/$(HG_DIRECTORY) -a "$(HG_VERSION)" != "" ] ; then \ - $(PRINTF) " %s:%s" \ - "$${i}" `$(HG) tip --repository $${i} --template '{node|short}\n'` ; \ - elif [ -f $${i}/$(HGTIP_FILENAME) ] ; then \ - $(PRINTF) " %s:%s" \ - "$${i}" `$(CAT) $${i}/$(HGTIP_FILENAME)` ; \ - fi; \ -done >> $@ -$(PRINTF) "\n" >> $@ -endef - -# Create the HGTIP_FILENAME file -define CreateHgTip -$(HG) tip --repository $1 --template '{node|short}\n' > $1/$(HGTIP_FILENAME);\ -$(ECHO) $1/$(HGTIP_FILENAME) -endef - -# Get the compiler specific settings (will run the compiler to find out) -# NOTE: COMPILER_PATH must be set by this time. -# Up until we include this file, we don't know what specific compiler -# version is actually being used (i.e. what is in PATH or COMPILER_PATH). -include $(JDK_MAKE_SHARED_DIR)/Compiler-$(CC_VERSION).gmk diff --git a/jdk/makefiles/common/shared/Platform.gmk b/jdk/makefiles/common/shared/Platform.gmk deleted file mode 100644 index 56ee0195d14..00000000000 --- a/jdk/makefiles/common/shared/Platform.gmk +++ /dev/null @@ -1,526 +0,0 @@ -# -# Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Shared platform (OS/ARCH) variable settings for the JDK builds. -# -# Includes basic system requirements, versions of utilities required, -# suffixes on files, and basic defaults attributed to the build platform. -# - -# -# Assumes some basic unix system utilities (e.g. uname) are in the search path -# in order to figure out the system. -# - -ifndef PLATFORM_SHARED - -PLATFORM_SHARED=done - -# Possible Input variables: -# ARCH_DATA_MODEL 32 or 64, default to 32 -# USER, LOGNAME user name (runs logname, or id if not set) -# PROCESSOR_IDENTIFIER windows only: needed in environment -# -# (Also gets input by running the utilities uname, logname, isainfo, or id.) -# -# Variables set by this file: -# SYSTEM_UNAME what 'uname' says this system is -# USER login name of user (minus blanks) -# PLATFORM windows, solaris, or linux -# VARIANT OPT or DBG, OPT is the default -# TEMP_DISK /tmp or C:/temp -# ARCH_DATA_MODEL 32 or 64 -# ARCH sparc, sparcv9, i586, amd64, or ia64 -# ARCH_FAMILY sparc or i586 -# ARCHPROP sparc or x86 -# ARCH_VM_SUBDIR jre/bin, jre/lib/sparc, etc. -# LIBARCH sparc, sparcv9, i386, amd64, or ia64 -# DEV_NULL destination of /dev/null, NUL or /dev/NULL -# CLASSPATH_SEPARATOR separator in classpath, ; or : -# LIB_PREFIX dynamic or static library prefix, lib or empty -# LIB_SUFFIX static library file suffix, .lib or .a? -# LIBRARY_SUFFIX dynamic library file suffix, .dll or .so -# OBJECT_SUFFIX object file suffix, .o or .obj -# EXE_SUFFIX executable file suffix, .exe or empty -# BUNDLE_FILE_SUFFIX suffix for bundles: .tar or .tar.gz -# ISA_DIR solaris only: /sparcv9 or /amd64 -# LIBARCH32 solaris only: sparc or i386 -# LIBARCH64 solaris only: sparcv9 or amd64 -# USING_CYGWIN windows only: true or false -# ISHIELD_TEMP_MIN windows only: minimum disk space in temp area - -# Only run uname once in this make session. -ifndef SYSTEM_UNAME - SYSTEM_UNAME := $(shell uname) - export SYSTEM_UNAME -endif - -# -# Prune out all known SCM (Source Code Management) directories -# so they will not be included when copying directory trees -# or packaging up .jar files, etc. This applies to all workspaces. -# -SCM_DIRs = .hg .svn CVS RCS SCCS Codemgr_wsdata deleted_files .hgignore .hgtags -# When changing SCM_DIRs also change SCM_DIRS_rexp and SCM_DIRS_prune: -SCM_DIRS_rexp = ".hg|.svn|CVS|RCS|SCCS|Codemgr_wsdata|deleted_files|.hgignore|.hgtags" -SCM_DIRS_prune = \( -name .hg -o -name .svn -o -name CVS -o -name RCS -o -name SCCS -o -name Codemgr_wsdata -o -name deleted_files -o -name .hgignore -o -name .hgtags \) -prune - -# Don't define this unless it's not defined -ifndef VARIANT - VARIANT=OPT -endif - -# Platform settings specific to Solaris -ifeq ($(SYSTEM_UNAME), SunOS) - PLATFORM = solaris - # Solaris sparc build can be either 32-bit or 64-bit. - # Default to 32, but allow explicit setting to 32 or 64. - ifndef ARCH_DATA_MODEL - ARCH_DATA_MODEL=32 - endif - ifeq ($(ARCH_DATA_MODEL), 32) - processor := $(shell uname -p) - archExpr = case "$(processor)" in \ - i[3-9]86) \ - echo i586 \ - ;; \ - sparc*) \ - echo sparc \ - ;; \ - *) \ - echo $(processor) \ - ;; \ - esac - ARCH := $(shell $(archExpr)) - else - ARCH := $(shell isainfo -n) - # ISA_DIR is used to locate 64-bit specific libraries which are generally - # in the same general place as other libraries under the ./$(ARCH) directory - ISA_DIR = /$(ARCH) - endif - # Need to maintain the jre/lib/i386 location for 32-bit Intel - ifeq ($(ARCH), i586) - ARCH_FAMILY = $(ARCH) - LIBARCH = i386 - # Value of Java os.arch property - ARCHPROP = x86 - else - ifeq ($(ARCH), amd64) - ARCH_FAMILY = i586 - else - ARCH_FAMILY = sparc - endif - LIBARCH = $(ARCH) - # Value of Java os.arch property - ARCHPROP = $(LIBARCH) - endif - # The two LIBARCH names - ifeq ($(ARCH_FAMILY), sparc) - LIBARCH32 = sparc - LIBARCH64 = sparcv9 - else - LIBARCH32 = i386 - LIBARCH64 = amd64 - endif - # Suffix for file bundles used in previous release - BUNDLE_FILE_SUFFIX=.tar - # How much RAM does this machine have (zones send an error to stderr): - MB_OF_MEMORY:=$(shell /usr/sbin/prtconf 2>/dev/null | fgrep 'Memory size:' | expand | cut -d' ' -f3) -endif - -# Platform settings specific to Linux -ifeq ($(SYSTEM_UNAME), Linux) - PLATFORM = linux - # Arch and OS name/version - ifdef CROSS_COMPILE_ARCH - mach := $(CROSS_COMPILE_ARCH) - else - mach := $(shell uname -m) - endif - archExpr = case "$(mach)" in \ - i[3-9]86) \ - echo i586 \ - ;; \ - ia64) \ - echo ia64 \ - ;; \ - x86_64) \ - echo amd64 \ - ;; \ - sparc*) \ - echo sparc \ - ;; \ - arm*) \ - echo arm \ - ;; \ - *) \ - echo $(mach) \ - ;; \ - esac - ARCH := $(shell $(archExpr) ) - ARCH_FAMILY := $(ARCH) - - # Linux builds may be 32-bit or 64-bit data model. - ifeq ($(ARCH), sparc) - # Linux sparc build can be either 32-bit or 64-bit. - # Default to 32, but allow explicit setting to 32 or 64. - ifndef ARCH_DATA_MODEL - ARCH_DATA_MODEL=32 - endif - ifeq ($(ARCH_DATA_MODEL), 32) - ARCH=sparc - else - ARCH=sparcv9 - endif - else - # Most archs are 32-bit - ifndef ARCH_DATA_MODEL - ARCH_DATA_MODEL=32 - ifeq ($(ARCH), amd64) - ARCH_DATA_MODEL=64 - endif - ifeq ($(ARCH), ia64) - ARCH_DATA_MODEL=64 - endif - endif - endif - - # Need to maintain the jre/lib/i386 location for 32-bit Intel - ifeq ($(ARCH), i586) - LIBARCH = i386 - else - LIBARCH = $(ARCH) - endif - - # Value of Java os.arch property - ARCHPROP = $(LIBARCH) - - # Suffix for file bundles used in previous release - BUNDLE_FILE_SUFFIX=.tar.gz - # How much RAM does this machine have: - MB_OF_MEMORY := $(shell free -m | fgrep Mem: | awk '{print $$2;}' ) -endif - -ifeq ($(SYSTEM_UNAME), Darwin) - PLATFORM = macosx - OS_NAME = darwin - OS_VENDOR = Apple - GB_OF_MEMORY := $(shell system_profiler SPHardwareDataType | fgrep Memory: | awk '{print $$2}') - MB_OF_MEMORY := $(shell expr ${GB_OF_MEMORY} '*' 1024) -endif - -# Platform settings specific to BSD/Mac OS X -ifeq ($(PLATFORM), macosx) - OS_VERSION := $(shell uname -r) - - # Arch and OS name/version - # Darwin x86 builds are i386/amd64 universal by default. - # Allow arch to be set from the environment to avoid this. - ifeq ($(origin ARCH), undefined) - ifeq ($(PLATFORM), macosx) -# ifdef OPENJDK -- when universal 32/64 binaries available in Hotspot -# mach := universal -# else - mach := x86_64 -# endif - else - mach := $(shell uname -m) - endif - else - mach := $(ARCH) - endif - - archExpr = case "$(mach)" in \ - i[3-9]86) \ - echo i586 \ - ;; \ - sparc64) \ - echo sparcv9 \ - ;; \ - sparc*) \ - echo sparc \ - ;; \ - x86_64) \ - echo amd64 \ - ;; \ - universal) \ - echo universal \ - ;; \ - "Power Macintosh") \ - echo ppc \ - ;; \ - *) \ - echo $(mach) \ - ;; \ - esac - ARCH := $(shell $(archExpr) ) - ARCH_FAMILY := $(ARCH) - - # i586, sparc, and ppc are 32 bit, amd64 and sparc64 are 64 - # ARCH_DATA_MODEL does not exactly mean anything in universal - # but it has to be one or the other, so pick 32 - ifneq (,$(findstring $(ARCH), i586 sparc ppc universal)) - ARCH_DATA_MODEL=32 - else - ARCH_DATA_MODEL=64 - endif - - # Need to maintain the jre/lib/i386 location for 32-bit Intel - ifeq ($(ARCH), i586) - LIBARCH = i386 - else - LIBARCH = $(ARCH) - endif - - # Value of Java os.arch property - ARCHPROP = $(LIBARCH) - - # Suffix for file bundles used in previous release - BUNDLE_FILE_SUFFIX=.tar.gz - # How much RAM does this machine have: -endif - -# Windows with and without CYGWIN will be slightly different -ifeq ($(SYSTEM_UNAME), Windows_NT) - PLATFORM = windows -endif -ifneq (,$(findstring CYGWIN,$(SYSTEM_UNAME))) - PLATFORM = windows - USING_CYGWIN = true - export USING_CYGWIN - CYGPATH_CMD=cygpath -a -s -m - # Only run "cygpath /" once in this make session. - ifndef CYGWIN_HOME - CYGWIN_HOME := $(shell $(CYGPATH_CMD) /) - export CYGWIN_HOME - endif -endif - -# Platform settings specific to Windows -ifeq ($(PLATFORM), windows) - # Windows builds default to the appropriate for the underlaying - # architecture. - # Temporary disk area - TEMP_DISK=C:/temp - # GNU Make or MKS overrides $(PROCESSOR_ARCHITECTURE) to always - # return "x86". Use the first word of $(PROCESSOR_IDENTIFIER) instead. - # And sometimes PROCESSOR_IDENTIFIER is not defined at all - # (in some restricted shells), so we use uname if we have to. - ifeq ($(PROCESSOR_IDENTIFIER),) - # Only run uname -m once in this make session. - ifndef SYSTEM_UNAME_M - SYSTEM_UNAME_M := $(shell uname -m) - export SYSTEM_UNAME_M - endif - PROC_ARCH:=$(SYSTEM_UNAME_M) - else - PROC_ARCH:=$(word 1, $(PROCESSOR_IDENTIFIER)) - endif - # Cover all the possibilities, MKS uname, CYGWIN uname, PROCESSOR_IDENTIFIER - # Get: X86, X64, or IA64 - PROC_ARCH:=$(patsubst 386,X86,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst 486,X86,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst 586,X86,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst 686,X86,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst i386,X86,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst i486,X86,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst i586,X86,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst i686,X86,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst x86,X86,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst intel64,X64,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst Intel64,X64,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst INTEL64,X64,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst em64t,X64,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst EM64T,X64,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst amd64,X64,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst AMD64,X64,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst 8664,X64,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst x86_64,X64,$(PROC_ARCH)) - PROC_ARCH:=$(patsubst ia64,IA64,$(PROC_ARCH)) - ifndef ARCH_DATA_MODEL - ifeq ($(PROC_ARCH),IA64) - ARCH_DATA_MODEL=64 - else - ifeq ($(PROC_ARCH),X64) - ARCH_DATA_MODEL=64 - else - ARCH_DATA_MODEL=32 - endif - endif - endif - export ARCH_DATA_MODEL - ifeq ($(ARCH_DATA_MODEL), 64) - # If the user wants to perform a cross compile build then they must - # - set ARCH_DATA_MODEL=64 and either - # + set ARCH to ia64 or amd64, or - ifeq ($(PROC_ARCH),X64) - ARCH=amd64 - else - ifeq ($(PROC_ARCH),IA64) - ARCH=ia64 - endif - endif - LIBARCH=$(ARCH) - # Value of Java os.arch property - ARCHPROP=$(LIBARCH) - else - # LIBARCH is used to preserve the jre/lib/i386 directory name for 32-bit intel - ARCH=i586 - LIBARCH=i386 - # Value of Java os.arch property - ARCHPROP=x86 - endif - ARCH_FAMILY = $(ARCH) - # Where is unwanted output to be delivered? - # MKS uses the special file "NUL", cygwin uses the customary unix file. - ifeq ($(USING_CYGWIN),true) - DEV_NULL = /dev/null - else - DEV_NULL = NUL - endif - export DEV_NULL - # Classpath separator - CLASSPATH_SEPARATOR = ; - # The suffix used for object file (.o for unix .obj for windows) - OBJECT_SUFFIX = obj - # The suffix applied to executables (.exe for windows, nothing for solaris) - EXE_SUFFIX = .exe - # The prefix applied to library files (lib for solaris, nothing for windows) - LIB_PREFIX= - LIBRARY_SUFFIX = dll - LIB_SUFFIX = lib - # User name determination (set _USER) - ifndef USER - ifdef USERNAME - _USER := $(USERNAME) - else - ifdef LOGNAME - _USER := $(LOGNAME) - else - _USER := $(shell id -un) - endif - endif - else - _USER:=$(USER) - endif - # Location of client/server directories - ARCH_VM_SUBDIR=jre/bin - # Suffix for file bundles used in previous release - BUNDLE_FILE_SUFFIX=.tar - # ISHIELD_TEMP_MIN is the difference of an empty C:\TEMP vs. one after a - # bundles build on windows. - ISHIELD_TEMP_MIN=250000 - # How much RAM does this machine have: - ifeq ($(JDK_HAS_MEM_INFO),) - MB_OF_MEMORY := 1024 - endif -endif - -# Unix type settings (same for all unix platforms) -ifneq ($(PLATFORM), windows) - # Temporary disk area - TEMP_DISK=/tmp - # Where is unwanted output to be delivered? - DEV_NULL = /dev/null - export DEV_NULL - # Character used between entries in classpath - CLASSPATH_SEPARATOR = : - # suffix used for object file (.o for unix .obj for windows) - OBJECT_SUFFIX = o - # The suffix applied to runtime libraries - LIBRARY_SUFFIX = so - # The suffix applied to link libraries - LIB_SUFFIX = so - # The suffix applied to executables (.exe for windows, nothing for solaris) - EXE_SUFFIX = - # The prefix applied to library files (lib for solaris, nothing for windows) - LIB_PREFIX = lib - # User name determination (set _USER) - ifndef USER - ifdef LOGNAME - _USER := $(LOGNAME) - else - _USER := $(shell logname) - endif - else - _USER:=$(USER) - endif - # Location of client/server directories - ARCH_VM_SUBDIR=jre/lib/$(LIBARCH) -endif - -# Darwin-specific Overrides -ifeq ($(SYSTEM_UNAME),Darwin) - # The suffix applied to runtime libraries - LIBRARY_SUFFIX = dylib - # The suffix applied to link libraries - ifeq ($(ARCH), universal) - LIB_SUFFIX = o - else - LIB_SUFFIX = a - endif - - ifeq ($(PLATFORM), macosx) - ARCH_VM_SUBDIR=jre/lib/$(LIBARCH) - endif -endif - -# Machines with 512Mb or less of real memory are considered low memory -# build machines and adjustments will be made to prevent excessing -# system swapping during the build. -ifeq ($(JDK_HAS_MEM_INFO),) - JDK_HAS_MEM_INFO=true - export JDK_HAS_MEM_INFO - ifneq ($(MB_OF_MEMORY),) - LOW_MEMORY_MACHINE := $(shell \ - if [ $(MB_OF_MEMORY) -le 512 ] ; then \ - echo "true"; \ - else \ - echo "false"; \ - fi) - MAX_VM_MEMORY := 512 - MIN_VM_MEMORY := $(MAX_VM_MEMORY) - else - MB_OF_MEMORY := unknown - LOW_MEMORY_MACHINE := true - MAX_VM_MEMORY := 384 - MIN_VM_MEMORY := 128 - endif - export MB_OF_MEMORY - export LOW_MEMORY_MACHINE - export MAX_VM_MEMORY - export MIN_VM_MEMORY -endif - -# If blanks in the username, use the first 4 words and pack them together -_USER1:=$(subst ', ,$(_USER)) -_USER2:=$(subst ", ,$(_USER1)) -USER:=$(word 1,$(_USER2))$(word 2,$(_USER2))$(word 3,$(_USER2))$(word 4,$(_USER2)) -export USER - -export PLATFORM -endif - diff --git a/jdk/makefiles/common/shared/PrivateDefs.gmk-example b/jdk/makefiles/common/shared/PrivateDefs.gmk-example deleted file mode 100644 index 93f6a43fb47..00000000000 --- a/jdk/makefiles/common/shared/PrivateDefs.gmk-example +++ /dev/null @@ -1,19 +0,0 @@ - -# This file, when re-named to PrivateDefs.gmk will get included in the -# makefile definitions (before the ALT_ variables are read) so that you can -# override makefile settings permanently for a workspace. -# Use of this file will cause WARNING errors, repeatedly, for a reason. -# -# WARNING: Use with caution. -# - -# EXAMPLE: Testing a special build of hotspot -# (this is the build/solaris/export-solaris-sparc directory from doing -# a 'cd hotspot/make; gnumake' build) -# -ifeq ($(PLATFORM),solaris) - ifeq ($(ARCH),sparc) - ALT_HOTSPOT_IMPORT_PATH=$(JDK_TOPDIR)/../export-solaris-sparc - endif -endif - diff --git a/jdk/makefiles/common/shared/Sanity-Settings.gmk b/jdk/makefiles/common/shared/Sanity-Settings.gmk deleted file mode 100644 index e571b068f82..00000000000 --- a/jdk/makefiles/common/shared/Sanity-Settings.gmk +++ /dev/null @@ -1,267 +0,0 @@ -# -# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Shared sanity settings file. Fills in the variable ALL_SETTINGS. -# - -# On Windows in particular, it can happen that quotes get into the PATH -# variable. This is very bad, and must be caught early or you can -# see errors like: sh: -c: line 0: syntax error near unexpected token -# -ifneq ($(PATH), $(subst ",,$(PATH))) - dummy1:=$(error ERROR: PATH variable contains double quotes, fix your PATH.) -endif -ifneq ($(PATH), $(subst ',,$(PATH))) - dummy1:=$(error ERROR: PATH variable contains single quotes, fix your PATH.) -endif - -# Used to add a heading to ALL_SETTINGS -define addHeading -"\n$1:\n" -endef - -# Used to add a line to ALL_SETTINGS for an optional value -# (need if test for windows which has issues with ; characters in values) -define addOptionalSetting -$(if $($1)," $1 = $($1)\n"," $1 = $($1)\n") -endef - -# Used to add a line to ALL_SETTINGS for something that must have a value -define addRequiredSetting -$(if $($1)," $1 = $($1)\n",$(warning WARNING: $1 should not be empty [Sanity-Settings.gmk])) -endef - -# Used to add a line to ALL_SETTINGS for something that must have a value -define addRequiredVersionSetting -$(if $($1)," $1 = $($1) [requires at least $(REQUIRED_$1)]\n",$(warning WARNING: $1 should not be empty [Sanity-Settings.gmk])) -endef - -# Used to add a series of lines to ALL_SETTINGS -define addAltSetting -" $1 = $($1)\n ALT_$1 = $(ALT_$1)\n" -endef - -# Variable that contains a string of all information - -# Make sure this is a 'do it now' variable. -ALL_SETTINGS:=$(call addHeading,Bootstrap Settings) -ALL_SETTINGS+=$(call addAltSetting,BOOTDIR) -ALL_SETTINGS+=$(call addRequiredVersionSetting,BOOT_VER) -ALL_SETTINGS+=$(call addAltSetting,OUTPUTDIR) -ALL_SETTINGS+=$(call addRequiredSetting,ABS_OUTPUTDIR) - - -ALL_SETTINGS+=$(call addHeading,Build Tool Settings) -ALL_SETTINGS+=$(call addAltSetting,SLASH_JAVA) -ALL_SETTINGS+=$(call addRequiredSetting,VARIANT) -ALL_SETTINGS+=$(call addAltSetting,JDK_DEVTOOLS_DIR) -ALL_SETTINGS+=$(call addOptionalSetting,ANT_HOME) -ALL_SETTINGS+=$(call addAltSetting,UNIXCOMMAND_PATH) -ALL_SETTINGS+=$(call addAltSetting,COMPILER_PATH) -ALL_SETTINGS+=$(call addAltSetting,DEVTOOLS_PATH) -ifeq ($(PLATFORM),linux) - ALL_SETTINGS+=$(call addAltSetting,UNIXCCS_PATH) - ALL_SETTINGS+=$(call addAltSetting,USRBIN_PATH) - ifndef OPENJDK - ALL_SETTINGS+=$(call addAltSetting,GCC29_COMPILER_PATH) - endif -endif -ifeq ($(PLATFORM),solaris) - ALL_SETTINGS+=$(call addAltSetting,UNIXCCS_PATH) - ifndef OPENJDK - ALL_SETTINGS+=$(call addAltSetting,GCC_COMPILER_PATH) - endif -endif -ifeq ($(PLATFORM),windows) - ifneq ($(MSVCRNN_DLL),) - ALL_SETTINGS+=$(call addAltSetting,MSVCRNN_DLL_PATH) - endif - ALL_SETTINGS+=$(call addRequiredSetting,INCLUDE) - ALL_SETTINGS+=$(call addRequiredSetting,LIB) -endif -ALL_SETTINGS+=$(call addOptionalSetting,COMPILER_NAME) -ALL_SETTINGS+=$(call addOptionalSetting,COMPILER_VERSION) -ifdef REQUIRED_CC_VER - ALL_SETTINGS+=$(call addRequiredVersionSetting,CC_VER) -else - ALL_SETTINGS+=$(call addOptionalSetting,CC_VER) -endif -ifeq ($(PLATFORM),solaris) - ifeq ($(ARCH_DATA_MODEL), 32) - ifndef OPENJDK - ALL_SETTINGS+=$(call addRequiredVersionSetting,GCC_VER) - endif - endif -endif -ALL_SETTINGS+=$(call addRequiredVersionSetting,ZIP_VER) -ALL_SETTINGS+=$(call addRequiredVersionSetting,UNZIP_VER) -ifeq ($(PLATFORM),windows) - ALL_SETTINGS+=$(call addRequiredVersionSetting,LINK_VER) - ALL_SETTINGS+=$(call addRequiredSetting,CC) - ALL_SETTINGS+=$(call addRequiredSetting,LINK) - ALL_SETTINGS+=$(call addRequiredSetting,DUMPBIN) -endif -ALL_SETTINGS+=$(call addRequiredVersionSetting,ANT_VER) -ALL_SETTINGS+=$(call addRequiredSetting,TEMPDIR) - - -ALL_SETTINGS+=$(call addHeading,Build Directives) -ALL_SETTINGS+=$(call addOptionalSetting,OPENJDK) -ALL_SETTINGS+=$(call addOptionalSetting,USE_HOTSPOT_INTERPRETER_MODE) -ALL_SETTINGS+=$(call addOptionalSetting,PEDANTIC) -ALL_SETTINGS+=$(call addOptionalSetting,DEV_ONLY) -ALL_SETTINGS+=$(call addOptionalSetting,NO_DOCS) -ALL_SETTINGS+=$(call addOptionalSetting,NO_DEMOS) -ALL_SETTINGS+=$(call addOptionalSetting,NO_SAMPLES) -ALL_SETTINGS+=$(call addOptionalSetting,NO_IMAGES) -ALL_SETTINGS+=$(call addOptionalSetting,TOOLS_ONLY) -ALL_SETTINGS+=$(call addOptionalSetting,INSANE) -ALL_SETTINGS+=$(call addRequiredSetting,COMPILE_APPROACH) -ifeq ($(COMPILE_APPROACH), parallel) - ALL_SETTINGS+=$(call addAltSetting,PARALLEL_COMPILE_JOBS) -endif -ALL_SETTINGS+=$(call addOptionalSetting,FASTDEBUG) -ALL_SETTINGS+=$(call addRequiredSetting,COMPILER_WARNINGS_FATAL) -ALL_SETTINGS+=$(call addOptionalSetting,COMPILER_WARNING_LEVEL) -ALL_SETTINGS+=$(call addOptionalSetting,SHOW_ALL_WARNINGS) -ALL_SETTINGS+=$(call addRequiredSetting,INCREMENTAL_BUILD) -ALL_SETTINGS+=$(call addOptionalSetting,CC_HIGHEST_OPT) -ALL_SETTINGS+=$(call addOptionalSetting,CC_HIGHER_OPT) -ALL_SETTINGS+=$(call addOptionalSetting,CC_LOWER_OPT) -ALL_SETTINGS+=$(call addOptionalSetting,CXXFLAGS) -ALL_SETTINGS+=$(call addOptionalSetting,CFLAGS) - -ALL_SETTINGS+=$(call addOptionalSetting,BOOT_JAVA_CMD) -ALL_SETTINGS+=$(call addOptionalSetting,BOOT_JAVAC_CMD) -ALL_SETTINGS+=$(call addOptionalSetting,BOOT_JAR_CMD) -ALL_SETTINGS+=$(call addOptionalSetting,BOOT_JARSIGNER_CMD) - -# These don't print out well with windows due to the ';' characters -ifneq ($(PLATFORM),windows) - ALL_SETTINGS+=$(call addOptionalSetting,JAVAC_CMD) - ALL_SETTINGS+=$(call addOptionalSetting,JAVAH_CMD) - ALL_SETTINGS+=$(call addOptionalSetting,JAVADOC_CMD) -endif - -ALL_SETTINGS+=$(call addHeading,Build Platform Settings) -ALL_SETTINGS+=$(call addRequiredSetting,USER) -ALL_SETTINGS+=$(call addRequiredSetting,PLATFORM) -ALL_SETTINGS+=$(call addRequiredSetting,ARCH) -ALL_SETTINGS+=$(call addRequiredSetting,LIBARCH) -ALL_SETTINGS+=$(call addRequiredSetting,ARCH_FAMILY) -ALL_SETTINGS+=$(call addRequiredSetting,ARCH_DATA_MODEL) -ALL_SETTINGS+=$(call addRequiredSetting,ARCHPROP) -ifeq ($(PLATFORM),windows) - ALL_SETTINGS+=$(call addRequiredSetting,PROCESSOR_ARCHITECTURE) - ALL_SETTINGS+=$(call addRequiredSetting,PROCESSOR_IDENTIFIER) - ifdef USING_CYGWIN - ALL_SETTINGS+=$(call addRequiredSetting,USING_CYGWIN) - ALL_SETTINGS+=$(call addRequiredVersionSetting,CYGWIN_VER) - ALL_SETTINGS+=$(call addRequiredSetting,CYGPATH_CMD) - else - ALL_SETTINGS+=$(call addRequiredVersionSetting,MKS_VER) - ALL_SETTINGS+=$(call addOptionalSetting,DOSNAME_CMD) - endif -endif -ifeq ($(PLATFORM),linux) - ifdef REQUIRED_ALSA_VERSION - ALL_SETTINGS+=$(call addRequiredSetting,ALSA_VERSION) - endif -endif -ALL_SETTINGS+=$(call addRequiredVersionSetting,OS_VERSION) -ALL_SETTINGS+=$(call addOptionalSetting,OS_VARIANT_NAME) -ALL_SETTINGS+=$(call addOptionalSetting,OS_VARIANT_VERSION) -ALL_SETTINGS+=$(call addRequiredSetting,MB_OF_MEMORY) - - -ALL_SETTINGS+=$(call addHeading,GNU Make Settings) -ALL_SETTINGS+=$(call addRequiredSetting,MAKE) -ALL_SETTINGS+=$(call addRequiredVersionSetting,MAKE_VER) -ALL_SETTINGS+=$(call addOptionalSetting,MAKECMDGOALS) -ALL_SETTINGS+=$(call addOptionalSetting,MAKEFLAGS) -ALL_SETTINGS+=$(call addRequiredSetting,SHELL) - - -ALL_SETTINGS+=$(call addHeading,Target Build Versions) -ALL_SETTINGS+=$(call addRequiredSetting,JDK_VERSION) -ALL_SETTINGS+=$(call addOptionalSetting,MILESTONE) -ALL_SETTINGS+=$(call addOptionalSetting,RELEASE) -ALL_SETTINGS+=$(call addRequiredSetting,FULL_VERSION) -ALL_SETTINGS+=$(call addOptionalSetting,BUILD_NUMBER) - - -ALL_SETTINGS+=$(call addHeading,External File/Binary Locations) -ALL_SETTINGS+=$(call addRequiredSetting,USRJDKINSTANCES_PATH) -ALL_SETTINGS+=$(call addAltSetting,BUILD_JDK_IMPORT_PATH) -ALL_SETTINGS+=$(call addAltSetting,JDK_IMPORT_PATH) -ALL_SETTINGS+=$(call addAltSetting,LANGTOOLS_DIST) -ALL_SETTINGS+=$(call addAltSetting,CORBA_DIST) -ALL_SETTINGS+=$(call addAltSetting,JAXP_DIST) -ALL_SETTINGS+=$(call addAltSetting,JAXWS_DIST) -ALL_SETTINGS+=$(call addAltSetting,HOTSPOT_DOCS_IMPORT_PATH) -ALL_SETTINGS+=$(call addAltSetting,HOTSPOT_IMPORT_PATH) -ifeq ($(ARCH_DATA_MODEL), 32) - ALL_SETTINGS+=$(call addAltSetting,HOTSPOT_CLIENT_PATH) -endif -ALL_SETTINGS+=$(call addAltSetting,HOTSPOT_SERVER_PATH) -ifeq ($(PLATFORM),windows) - ALL_SETTINGS+=$(call addAltSetting,HOTSPOT_LIB_PATH) - ALL_SETTINGS+=$(call addRequiredSetting,DXSDK_VER) - ALL_SETTINGS+=$(call addAltSetting,DXSDK_PATH) - ALL_SETTINGS+=$(call addAltSetting,DXSDK_INCLUDE_PATH) - ALL_SETTINGS+=$(call addAltSetting,DXSDK_LIB_PATH) - ALL_SETTINGS+=$(call addAltSetting,WINDOWSSDKDIR) - ALL_SETTINGS+=$(call addRequiredSetting,RC) - ALL_SETTINGS+=$(call addRequiredSetting,REBASE) - ifndef OPENJDK - ALL_SETTINGS+=$(call addAltSetting,DEPLOY_MSSDK) - ALL_SETTINGS+=$(call addAltSetting,INSTALL_MSSDK) - ALL_SETTINGS+=$(call addAltSetting,WSCRIPT) - ALL_SETTINGS+=$(call addAltSetting,MSICERT) - endif -endif -ALL_SETTINGS+=$(call addAltSetting,CACERTS_FILE) -ifndef OPENJDK - ALL_SETTINGS+=$(call addAltSetting,MOZILLA_HEADERS_PATH) -endif -ifneq ($(PLATFORM),windows) - ALL_SETTINGS+=$(call addAltSetting,CUPS_HEADERS_PATH) -endif - -ifdef OPENJDK - ALL_SETTINGS+=$(call addHeading,OpenJDK-specific settings) - ALL_SETTINGS+=$(call addAltSetting,FREETYPE_HEADERS_PATH) - ALL_SETTINGS+=$(call addAltSetting,FREETYPE_LIB_PATH) -endif - -ifdef OPENJDK - ALL_SETTINGS+=$(call addHeading,Previous JDK Settings) - ALL_SETTINGS+=$(call addAltSetting,PREVIOUS_RELEASE_PATH) - ALL_SETTINGS+=$(call addAltSetting,PREVIOUS_JDK_VERSION) - ALL_SETTINGS+=$(call addAltSetting,PREVIOUS_JDK_FILE) - ALL_SETTINGS+=$(call addAltSetting,PREVIOUS_JRE_FILE) - ALL_SETTINGS+=$(call addAltSetting,PREVIOUS_RELEASE_IMAGE) -endif diff --git a/jdk/makefiles/java/Makefile b/jdk/makefiles/java/Makefile deleted file mode 100644 index 57399f5ac83..00000000000 --- a/jdk/makefiles/java/Makefile +++ /dev/null @@ -1,58 +0,0 @@ -# -# Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile for building all of java -# - -PRODUCT=java -BUILDDIR=.. -include $(BUILDDIR)/common/Defs.gmk - -# -# The order of subdirs here is important -# -SUBDIRS += redist - -# Others -# Note: java_crw_demo java_hprof_demo are demos but must be delivered built in sdk - -SUBDIRS += - -SUBDIRS_management = -SUBDIRS_misc = - -#TODO Check invoke -# logging instrument invoke sql rmi - -ifeq ($(PLATFORM), macosx) - SUBDIRS += jobjc -endif # PLATFORM - -include $(BUILDDIR)/common/Subdirs.gmk - -all build clean clobber:: - $(SUBDIRS-loop) - diff --git a/jdk/makefiles/java/invoke/Makefile b/jdk/makefiles/java/invoke/Makefile deleted file mode 100644 index 93b1f46f5d3..00000000000 --- a/jdk/makefiles/java/invoke/Makefile +++ /dev/null @@ -1,42 +0,0 @@ -# -# Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -BUILDDIR = ../.. - -PACKAGE = java.lang.invoke -PRODUCT = java -include $(BUILDDIR)/common/Defs.gmk - -AUTO_FILES_JAVA_DIRS = java/lang/invoke sun/invoke -FILES_java = \ - java/lang/ClassValue.java \ - java/lang/BootstrapMethodError.java - -# The sources built here use new language syntax to generate -# method handle calls. Let's be sure we are using that format. -LANGUAGE_VERSION = -source 7 -CLASS_VERSION = -target 7 - -include $(BUILDDIR)/common/Classes.gmk diff --git a/jdk/makefiles/java/redist/Makefile b/jdk/makefiles/java/redist/Makefile deleted file mode 100644 index 88420927a80..00000000000 --- a/jdk/makefiles/java/redist/Makefile +++ /dev/null @@ -1,497 +0,0 @@ -# -# Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Imports files exported by a hotspot build or provided from an external -# location into the OUTPUTDIR, and also primes the OUTPUTDIR with files -# that are provided inside this workspace. -# -# IMPORT_LIST contains the list of destination files that are copied -# from external places (outside this workspace). -# -# INTERNAL_IMPORT_LIST is the list of destination files from BUILDDIR. -# - -BUILDDIR = ../.. -PRODUCT = java -include $(BUILDDIR)/common/Defs.gmk -include $(BUILDDIR)/Tools.gmk - -$(info ENTERING redist) - -SERVER_LOCATION = server -CLIENT_LOCATION = client -KERNEL_LOCATION = kernel - -DB_SUFFIX = _db -DTRACE_SUFFIX = _dtrace - -ifeq ($(PLATFORM), windows) - LIB_LOCATION = $(BINDIR) -else ifeq ($(PLATFORM), macosx) - LIB_LOCATION = $(LIBDIR) -else - LIB_LOCATION = $(LIBDIR)/$(LIBARCH) -endif - -JVM_NAME = $(LIB_PREFIX)jvm.$(LIBRARY_SUFFIX) -JVMLIB_NAME = $(LIB_PREFIX)jvm.$(LIB_SUFFIX) -JVMMAP_NAME = $(LIB_PREFIX)jvm.map -JVMPDB_NAME = $(LIB_PREFIX)jvm.pdb -LIBJSIG_NAME = $(LIB_PREFIX)jsig.$(LIBRARY_SUFFIX) -JVMDB_NAME = $(LIB_PREFIX)jvm$(DB_SUFFIX).$(LIBRARY_SUFFIX) -JVMDTRACE_NAME = $(LIB_PREFIX)jvm$(DTRACE_SUFFIX).$(LIBRARY_SUFFIX) - -JVM_DEBUGINFO_NAME = $(LIB_PREFIX)jvm.debuginfo -LIBJSIG_DEBUGINFO_NAME = $(LIB_PREFIX)jsig.debuginfo -JVMDB_DEBUGINFO_NAME = $(LIB_PREFIX)jvm$(DB_SUFFIX).debuginfo -JVMDTRACE_DEBUGINFO_NAME = $(LIB_PREFIX)jvm$(DTRACE_SUFFIX).debuginfo - -CLASSSHARINGDATA_DIR = $(BUILDDIR)/../make/tools/sharing - -# Needed to do file copy -ABS_BUILDDIR :=$(call FullPath,$(BUILDDIR)) - -SUBDIRS_desktop = -SUBDIRS_tools = sajdi -include $(BUILDDIR)/common/Subdirs.gmk - -all clean clobber:: - $(SUBDIRS-loop) - -all:: build - -# List of files created here or coming from BUILDDIR area (this workspace) -INTERNAL_IMPORT_LIST = $(LIBDIR)/classlist - -# List of files coming from outside this workspace -ifeq ($(JVM_VARIANT_SERVER),true) - IMPORT_LIST = $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVM_NAME) \ - $(LIB_LOCATION)/$(SERVER_LOCATION)/Xusage.txt - ifneq ($(OBJCOPY),) - # the import JDK may not contain .debuginfo files - ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/$(JVM_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVM_DEBUGINFO_NAME) - endif - endif -endif -ifeq ($(JVM_VARIANT_CLIENT),true) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVM_NAME) \ - $(LIB_LOCATION)/$(CLIENT_LOCATION)/Xusage.txt - ifneq ($(OBJCOPY),) - # the import JDK may not contain .debuginfo files - ifneq ($(wildcard $(HOTSPOT_CLIENT_PATH)/$(JVM_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVM_DEBUGINFO_NAME) - endif - endif -endif - -$(info ENTERING redist 2) -ifeq ($(PLATFORM), windows) - IMPORT_LIST += $(BINDIR)/$(notdir $(MSVCR100DLL)) - - $(BINDIR)/$(notdir $(MSVCR100DLL)): $(MSVCR100DLL) - $(install-import-file) - $(call chmod-file, a+x) - - # Get the hotspot .map and .pdb files for client and server - ifeq ($(JVM_VARIANT_SERVER),true) - IMPORT_LIST += \ - $(LIBDIR)/$(JVMLIB_NAME) \ - $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMMAP_NAME) \ - $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMPDB_NAME) - endif - - # Add .map and .pdb files to the import path for client and kernel VMs. - ifeq ($(JVM_VARIANT_CLIENT),true) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMMAP_NAME) \ - $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMPDB_NAME) - endif - ifeq ($(JVM_VARIANT_KERNEL),true) - IMPORT_LIST += $(LIB_LOCATION)/$(KERNEL_LOCATION)/$(JVMMAP_NAME) \ - $(LIB_LOCATION)/$(KERNEL_LOCATION)/$(JVMPDB_NAME) - endif - - $(info XXXX $(LIBDIR)/$(JVMLIB_NAME): $(HOTSPOT_LIB_PATH)/$(JVMLIB_NAME)) - $(LIBDIR)/$(JVMLIB_NAME): $(HOTSPOT_LIB_PATH)/$(JVMLIB_NAME) - $(install-import-file) - - # it is OK for the .map and .pdb files to not exist, so do not force a - # dependency on them from the bootstrap location, and allow the copy to fail. - $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMMAP_NAME): - @$(prep-target) - -$(CP) $(HOTSPOT_CLIENT_PATH)/$(JVMMAP_NAME) $@ - - $(LIB_LOCATION)/$(KERNEL_LOCATION)/$(JVMMAP_NAME): - @$(prep-target) - -$(CP) $(HOTSPOT_KERNEL_PATH)/$(JVMMAP_NAME) $@ - - $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMMAP_NAME): - @$(prep-target) - -$(CP) $(HOTSPOT_SERVER_PATH)/$(JVMMAP_NAME) $@ - - $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMPDB_NAME): - @$(prep-target) - -$(CP) $(HOTSPOT_CLIENT_PATH)/$(JVMPDB_NAME) $@ - - $(LIB_LOCATION)/$(KERNEL_LOCATION)/$(JVMPDB_NAME): - @$(prep-target) - -$(CP) $(HOTSPOT_KERNEL_PATH)/$(JVMPDB_NAME) $@ - - $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMPDB_NAME): - @$(prep-target) - -$(CP) $(HOTSPOT_SERVER_PATH)/$(JVMPDB_NAME) $@ - -else - # Posix like systems - IMPORT_LIST += $(LIB_LOCATION)/$(LIBJSIG_NAME) - ifneq ($(OBJCOPY),) - # the import JDK may not contain .debuginfo files - ifneq ($(wildcard $(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/$(LIBJSIG_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(LIBJSIG_DEBUGINFO_NAME) - endif - endif - ifeq ($(JVM_VARIANT_CLIENT),true) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(LIBJSIG_NAME) - ifneq ($(OBJCOPY),) - # the import JDK may not contain the target of the symlink - ifneq ($(wildcard $(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/$(LIBJSIG_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(LIBJSIG_DEBUGINFO_NAME) - endif - endif - endif - ifeq ($(JVM_VARIANT_SERVER),true) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(LIBJSIG_NAME) - ifneq ($(OBJCOPY),) - # the import JDK may not contain the target of the symlink - ifneq ($(wildcard $(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/$(LIBJSIG_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(LIBJSIG_DEBUGINFO_NAME) - endif - endif - endif - - ifeq ($(PLATFORM), solaris) - - ifeq ($(JVM_VARIANT_CLIENT),true) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMDB_NAME) - - # The conditional can be removed when import JDKs contain these files. - ifneq ($(wildcard $(HOTSPOT_CLIENT_PATH)/$(JVMDTRACE_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMDTRACE_NAME) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/64/$(JVMDB_NAME) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/64/$(JVMDTRACE_NAME) - ifneq ($(OBJCOPY),) - # the import JDK may not contain .debuginfo files - ifneq ($(wildcard $(HOTSPOT_CLIENT_PATH)/$(JVMDTRACE_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMDTRACE_DEBUGINFO_NAME) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/64/$(JVMDB_DEBUGINFO_NAME) - IMPORT_LIST += $(LIB_LOCATION)/$(CLIENT_LOCATION)/64/$(JVMDTRACE_DEBUGINFO_NAME) - endif - endif - else - $(warning WARNING: $(HOTSPOT_CLIENT_PATH)/$(JVMDTRACE_NAME) not found!) - endif - - $(LIB_LOCATION)/$(JVM_NAME): $(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVM_NAME) - @$(prep-target) - endif - - ifeq ($(JVM_VARIANT_SERVER),true) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDB_NAME) - ifneq ($(OBJCOPY),) - # the import JDK may not contain .debuginfo files - ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/$(JVMDB_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDB_DEBUGINFO_NAME) - endif - endif - # The conditional can be removed when import JDKs contain these files. - ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/$(JVMDTRACE_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDTRACE_NAME) - ifneq ($(OBJCOPY),) - # the import JDK may not contain .debuginfo files - ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/$(JVMDTRACE_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDTRACE_DEBUGINFO_NAME) - endif - endif - else - $(warning WARNING: $(HOTSPOT_SERVER_PATH)/$(JVMDB_NAME) not found!) - endif - - # The conditional can be removed when import JDKs contain these files. - ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDB_NAME) - ifneq ($(OBJCOPY),) - # the import JDK may not contain .debuginfo files - ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDB_DEBUGINFO_NAME) - endif - endif - else - $(warning WARNING: $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_NAME) not found!) - endif - - # The conditional can be removed when import JDKs contain these files. - ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/64/$(JVMDTRACE_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDTRACE_NAME) - ifneq ($(OBJCOPY),) - # the import JDK may not contain .debuginfo files - ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/64/$(JVMDTRACE_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDTRACE_DEBUGINFO_NAME) - endif - endif - else - $(warning WARNING: $(HOTSPOT_SERVER_PATH)/64/$(JVMDTRACE_NAME) not found!) - endif - endif - endif -endif - -$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVM_NAME): $(HOTSPOT_CLIENT_PATH)/$(JVM_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -ifneq ($(OBJCOPY),) -$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVM_DEBUGINFO_NAME): $(HOTSPOT_CLIENT_PATH)/$(JVM_DEBUGINFO_NAME) - $(install-import-file) -endif - -$(LIB_LOCATION)/$(KERNEL_LOCATION)/$(JVM_NAME): $(HOTSPOT_KERNEL_PATH)/$(JVM_NAME) - $(install-file) - @$(call binary_file_verification,$@) - -$(LIB_LOCATION)/$(LIBJSIG_NAME): $(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/$(LIBJSIG_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -ifneq ($(OBJCOPY),) -$(LIB_LOCATION)/$(LIBJSIG_DEBUGINFO_NAME): $(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/$(LIBJSIG_DEBUGINFO_NAME) - $(install-import-file) -endif - -$(LIB_LOCATION)/$(SERVER_LOCATION)/$(LIBJSIG_NAME): - @$(prep-target) - $(call install-sym-link, ../$(LIBJSIG_NAME)) - -ifneq ($(OBJCOPY),) -$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(LIBJSIG_DEBUGINFO_NAME) \ -$(LIB_LOCATION)/$(SERVER_LOCATION)/$(LIBJSIG_DEBUGINFO_NAME): - @$(prep-target) - $(call install-sym-link, ../$(LIBJSIG_DEBUGINFO_NAME)) -endif -$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(LIBJSIG_NAME): - @$(prep-target) - $(call install-sym-link, ../$(LIBJSIG_NAME)) - -ifneq ($(OBJCOPY),) -$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(LIBJSIG_DEBUGINFO_NAME): - @$(prep-target) - $(call install-sym-link, ../$(LIBJSIG_DEBUGINFO_NAME)) -endif - -$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMDB_NAME): $(HOTSPOT_CLIENT_PATH)/$(JVMDB_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -$(LIB_LOCATION)/$(CLIENT_LOCATION)/64/$(JVMDB_NAME): $(HOTSPOT_CLIENT_PATH)/64/$(JVMDB_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -ifneq ($(OBJCOPY),) -$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMDB_DEBUGINFO_NAME): $(HOTSPOT_CLIENT_PATH)/$(JVMDB_DEBUGINFO_NAME) - $(install-import-file) - -$(LIB_LOCATION)/$(CLIENT_LOCATION)/64/$(JVMDB_DEBUGINFO_NAME): $(HOTSPOT_CLIENT_PATH)/64/$(JVMDB_DEBUGINFO_NAME) - $(install-import-file) -endif - -$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDB_NAME): $(HOTSPOT_SERVER_PATH)/$(JVMDB_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -$(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDB_NAME): $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -ifneq ($(OBJCOPY),) -$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDB_DEBUGINFO_NAME): $(HOTSPOT_SERVER_PATH)/$(JVMDB_DEBUGINFO_NAME) - $(install-import-file) - -$(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDB_DEBUGINFO_NAME): $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_DEBUGINFO_NAME) - $(install-import-file) -endif - -$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMDTRACE_NAME): $(HOTSPOT_CLIENT_PATH)/$(JVMDTRACE_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -$(LIB_LOCATION)/$(CLIENT_LOCATION)/64/$(JVMDTRACE_NAME): $(HOTSPOT_CLIENT_PATH)/64/$(JVMDTRACE_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -ifneq ($(OBJCOPY),) -$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMDTRACE_DEBUGINFO_NAME): $(HOTSPOT_CLIENT_PATH)/$(JVMDTRACE_DEBUGINFO_NAME) - $(install-import-file) - -$(LIB_LOCATION)/$(CLIENT_LOCATION)/64/$(JVMDTRACE_DEBUGINFO_NAME): $(HOTSPOT_CLIENT_PATH)/64/$(JVMDTRACE_DEBUGINFO_NAME) - $(install-import-file) -endif - -$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDTRACE_NAME): $(HOTSPOT_SERVER_PATH)/$(JVMDTRACE_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -$(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDTRACE_NAME): $(HOTSPOT_SERVER_PATH)/64/$(JVMDTRACE_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVM_NAME): $(HOTSPOT_SERVER_PATH)/$(JVM_NAME) - $(install-import-file) - @$(call binary_file_verification,$@) - -ifneq ($(OBJCOPY),) -$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDTRACE_DEBUGINFO_NAME): $(HOTSPOT_SERVER_PATH)/$(JVMDTRACE_DEBUGINFO_NAME) - $(install-import-file) - -$(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDTRACE_DEBUGINFO_NAME): $(HOTSPOT_SERVER_PATH)/64/$(JVMDTRACE_DEBUGINFO_NAME) - $(install-import-file) - -$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVM_DEBUGINFO_NAME): $(HOTSPOT_SERVER_PATH)/$(JVM_DEBUGINFO_NAME) - $(install-import-file) -endif - -$(LIB_LOCATION)/$(SERVER_LOCATION)/Xusage.txt : $(HOTSPOT_SERVER_PATH)/Xusage.txt - $(install-import-file) - - -$(LIB_LOCATION)/$(CLIENT_LOCATION)/Xusage.txt : $(HOTSPOT_CLIENT_PATH)/Xusage.txt - $(install-import-file) - -$(LIB_LOCATION)/$(KERNEL_LOCATION)/Xusage.txt : $(HOTSPOT_KERNEL_PATH)/Xusage.txt - $(install-file) - -# -# Specific to non-OpenJDK building -# -ifndef OPENJDK - -INTERNAL_IMPORT_LIST += \ - $(LIBDIR)/security/US_export_policy.jar \ - $(LIBDIR)/security/local_policy.jar \ - $(LIBDIR)/jce.jar - -$(LIBDIR)/jce.jar: \ - $(JDK_TOPDIR)/make/closed/tools/crypto/jce/jce.jar - $(install-file) -$(LIBDIR)/security/US_export_policy.jar: \ - $(JDK_TOPDIR)/make/closed/tools/crypto/jce/US_export_policy.jar - $(install-file) -$(LIBDIR)/security/local_policy.jar: \ - $(JDK_TOPDIR)/make/closed/tools/crypto/jce/local_policy.jar - $(install-file) - -endif # OPENJDK - -# Construct classlist file -$(LIBDIR)/classlist: \ - $(CLASSSHARINGDATA_DIR)/classlist.$(PLATFORM) \ - $(ADDJSUM_JARFILE) - @$(prep-target) - @$(RM) -f $@.temp - $(TOOL_ADDJSUM) \ - $(CLASSSHARINGDATA_DIR)/classlist.$(PLATFORM) $@.temp - $(MV) $@.temp $@ - -# Import internal files (ones that are stashed in this source tree) -import_internal_files : $(INTERNAL_IMPORT_LIST) - -# Import files from the JDK that we are not building -import_files: $(IMPORT_LIST) - -# Get component information variables and rules -include $(BUILDDIR)/common/internal/ImportComponents.gmk - -# Security files we need to import -SEC_FILES_ZIP=$(ABS_BUILDDIR)/tools/crypto/sec-bin.zip -SEC_FILES_WIN_ZIP=$(ABS_BUILDDIR)/tools/crypto/sec-windows-bin.zip -JGSS_WIN32_FILES_ZIP=$(ABS_BUILDDIR)/tools/crypto/jgss-windows-i586-bin.zip -JGSS_WIN64_FILES_ZIP=$(ABS_BUILDDIR)/tools/crypto/jgss-windows-x64-bin.zip - -# Unzip zip file $2 into directory $1 (if $2 exists) -# Warning: $2 must be absolute path not relative -define SecUnzipper -if [ -f $2 ] ; then \ - $(MKDIR) -p $1; \ - $(ECHO) "( $(CD) $1 && $(UNZIP) -o $2 )"; \ - ( $(CD) $1 && $(UNZIP) -o $2 ); \ -fi -endef - -# If sec-bin exists, unpack it into the build directory -# Also, the library recompile build indirectly depends on two SSL classes, -# so copy those as well FIXUP -# if sec-windows-bin exists, unpack it into the build directory -# if JGSS files exists, unpack it into the build directory -$(TEMPDIR)/security_imported: - @$(prep-target) - @$(call SecUnzipper,$(OUTPUTDIR),$(SEC_FILES_ZIP)) -ifeq ($(PLATFORM), windows) - @$(call SecUnzipper,$(OUTPUTDIR),$(SEC_FILES_WIN_ZIP)) -endif -ifeq ($(PLATFORM), windows) - ifeq ($(ARCH_DATA_MODEL), 32) - @$(call SecUnzipper,$(OUTPUTDIR),$(JGSS_WIN32_FILES_ZIP)) - else - @$(call SecUnzipper,$(OUTPUTDIR),$(JGSS_WIN64_FILES_ZIP)) - endif -endif - @$(ECHO) "Imported on `$(DATE)`" > $@ - -# Import all files from other components -$(TEMPDIR)/components_imported: - @$(prep-target) - $(call import-component-binaries,$(ABS_OUTPUTDIR)) - $(call import-component-sources,$(IMPORTSRCDIR)) - $(call import-component-docs,$(IMPORTDOCDIR)) - $(call import-component-classes,$(CLASSDESTDIR)) - @$(ECHO) "Imported on `$(DATE)`" > $@ - -# Do pretty much everything -build : import_files \ - import_internal_files \ - $(TEMPDIR)/components_imported \ - $(TEMPDIR)/security_imported - -# Clean up what we imported (except for component files) -clean clobber:: - $(RM) $(IMPORT_LIST) - $(RM) $(INTERNAL_IMPORT_LIST) - $(call import-component-sources-clean,$(IMPORTSRCDIR)) - $(call import-component-docs-clean,$(IMPORTDOCDIR)) - $(call import-component-classes-clean,$(CLASSDESTDIR)) - $(RM) $(TEMPDIR)/components_imported - $(RM) $(TEMPDIR)/security_imported - -.PHONY: import_files import_internal_files - diff --git a/jdk/makefiles/java/redist/sajdi/Makefile b/jdk/makefiles/java/redist/sajdi/Makefile deleted file mode 100644 index 6bec18ce9d0..00000000000 --- a/jdk/makefiles/java/redist/sajdi/Makefile +++ /dev/null @@ -1,116 +0,0 @@ -# -# Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -BUILDDIR = ../../.. -PRODUCT = java -include $(BUILDDIR)/common/Defs.gmk - -ifeq ($(PLATFORM), windows) - LIB_LOCATION = $(BINDIR) -else ifeq ($(PLATFORM), macosx) - LIB_LOCATION = $(LIBDIR) -else - LIB_LOCATION = $(LIBDIR)/$(LIBARCH) -endif - -# INCLUDE_SA is false on platforms where SA is not supported. -# On platforms where it is supported, we want to allow it to -# not be present, at least temporarily. So, -# if the SA files (well, just sa-jdi.jar) do not exist -# in the HOTSPOT_IMPORT_PATH, then we won't build SA. -SA_EXISTS := $(shell if [ -r $(HOTSPOT_IMPORT_PATH)/lib/sa-jdi.jar ] ; then \ - $(ECHO) true; \ - else \ - $(ECHO) false; \ - fi) - -ifeq ($(SA_EXISTS), false) - INCLUDE_SA := false -endif - -IMPORT_LIST = -ifeq ($(INCLUDE_SA), true) - IMPORT_LIST += $(LIBDIR)/sa-jdi.jar \ - $(LIB_LOCATION)/$(SALIB_NAME) - ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) - ifeq ($(ZIP_DEBUGINFO_FILES),1) - # the import JDK may not contain .diz files - ifneq ($(wildcard $(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/$(SA_DIZ_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SA_DIZ_NAME) - endif - else - ifeq ($(PLATFORM), windows) - # the import JDK may not contain .pdb files - ifneq ($(wildcard $(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/$(SAPDB_NAME)),) - # assume .map file is present if .pdb is present - IMPORT_LIST += $(LIB_LOCATION)/$(SAMAP_NAME) \ - $(LIB_LOCATION)/$(SAPDB_NAME) - endif - else - # the import JDK may not contain .debuginfo files - ifneq ($(wildcard $(HOTSPOT_IMPORT_PATH)/$(ARCH_VM_SUBDIR)/$(SA_DEBUGINFO_NAME)),) - IMPORT_LIST += $(LIB_LOCATION)/$(SA_DEBUGINFO_NAME) - endif - endif - endif - endif -endif # INCLUDE_SA - - -ifeq ($(INCLUDE_SA), true) -# The Serviceability Agent is built in the Hotspot workspace. -# It contains two files: -# - sa-jdi.jar: This goes into the same dir as tools.jar. -# - a shared library: sawindbg.dll on windows / libproc.sa on unix -# This goes into the same dir as the other -# shared libs, eg. libjdwp.so. -$(LIBDIR)/sa-jdi.jar: $(HOTSPOT_IMPORT_PATH)/lib/sa-jdi.jar - $(install-importonly-file) - -$(LIB_LOCATION)/$(SALIB_NAME): $(HOTSPOT_SALIB_PATH)/$(SALIB_NAME) - $(install-import-file) - - ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) - ifeq ($(ZIP_DEBUGINFO_FILES),1) -$(LIB_LOCATION)/$(SA_DIZ_NAME): $(HOTSPOT_SALIB_PATH)/$(SA_DIZ_NAME) - $(install-import-file) - else - ifeq ($(PLATFORM), windows) -$(LIB_LOCATION)/$(SAPDB_NAME): $(HOTSPOT_SALIB_PATH)/$(SAPDB_NAME) - $(install-import-file) - -$(LIB_LOCATION)/$(SAMAP_NAME): $(HOTSPOT_SALIB_PATH)/$(SAMAP_NAME) - $(install-import-file) - else -$(LIB_LOCATION)/$(SA_DEBUGINFO_NAME): $(HOTSPOT_SALIB_PATH)/$(SA_DEBUGINFO_NAME) - $(install-import-file) - endif - endif - endif -endif # INCLUDE_SA - -all: $(IMPORT_LIST) - -clean clobber:: diff --git a/jdk/makefiles/javax/crypto/Defs-jce.gmk b/jdk/makefiles/javax/crypto/Defs-jce.gmk deleted file mode 100644 index 0bfd00c8cf8..00000000000 --- a/jdk/makefiles/javax/crypto/Defs-jce.gmk +++ /dev/null @@ -1,105 +0,0 @@ -# -# Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -include $(BUILDDIR)/common/Release.gmk - -# -# Include these extra attributes for now, should probably take out. -# -JCE_MANIFEST_FILE = $(TEMPDIR)/manifest.mf -$(JCE_MANIFEST_FILE): $(MAINMANIFEST) - $(prep-target) - $(SED) -e "s#@@RELEASE@@#$(RELEASE)#" \ - -e "s#@@COMPANY_NAME@@#$(COMPANY_NAME)#" \ - $(MAINMANIFEST) >> $@ - $(ECHO) "Extension-Name: javax.crypto" >> $@ - $(ECHO) "Implementation-Vendor-Id: com.sun" >> $@ - -README-MAKEFILE_WARNING = \ - "\nPlease read make/javax/crypto/Makefile for further build instructions." - -define no-source-warning - @$(ECHO) "\n***JCE sources are not available, skipping build.***" \ - $(README-MAKEFILE_WARNING) -endef - -ifndef OPENJDK - -PREBUILT_DIR = $(JDK_TOPDIR)/make/closed/tools/crypto - -define build-warning - @$(ECHO) "\n***JCE in JDK builds require special tools/procedures.***" \ - $(README-MAKEFILE_WARNING) -endef - -# -# Location for JCE codesigning key. -# -SIGNING_KEY_DIR = /security/ws/JCE-signing/src -SIGNING_KEYSTORE = $(SIGNING_KEY_DIR)/KeyStore.jks -SIGNING_PASSPHRASE = $(SIGNING_KEY_DIR)/passphrase.txt -SIGNING_ALIAS = oracle_jce_rsa - -# -# Defines for signing the various jar files. -# - -define presign - @if [ ! -f $(SIGNING_KEYSTORE) -o ! -f $(SIGNING_PASSPHRASE) ]; then \ - $(ECHO) "\n$(SIGNING_KEYSTORE): Signing mechanism *NOT* available..." \ - $(README-MAKEFILE_WARNING); \ - exit 2; \ - fi -endef - -define sign-target - $(BOOT_JARSIGNER_CMD) -keystore $(SIGNING_KEYSTORE) \ - $@ $(SIGNING_ALIAS) < $(SIGNING_PASSPHRASE) - @$(java-vm-cleanup) - @$(ECHO) "\nJar codesigning finished." -endef - -RELEASE_DIR = $(OUTPUTDIR)/jce-release - -define release-warning - @$(ECHO) \ - "\n***The jar files built by the 'release' target must***" \ - "\n***still be checked into the closed workspace! ***" \ - $(README-MAKEFILE_WARNING) -endef - -# -# Convenience macros for signing a jar file. -# -# Call through $(call sign-file, target file) -# -define sign-file - $(presign) - $(prep-target) - $(CP) $1 $@ - $(sign-target) -endef - -endif # !OPENJDK diff --git a/jdk/makefiles/javax/crypto/Makefile b/jdk/makefiles/javax/crypto/Makefile deleted file mode 100644 index f9089f902d3..00000000000 --- a/jdk/makefiles/javax/crypto/Makefile +++ /dev/null @@ -1,484 +0,0 @@ -# -# Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile for building jce.jar and the various cryptographic strength -# policy jar files. -# - -# -# (The terms "OpenJDK" and "JDK" below refer to OpenJDK and Sun JDK builds -# respectively.) -# -# JCE builds are very different between OpenJDK and JDK. The OpenJDK JCE -# jar files do not require signing, but those for JDK do. If an unsigned -# jar file is installed into JDK, things will break when the crypto -# routines are called. -# -# This Makefile does the "real" build of the JCE files. There are some -# javac options currently specific to JCE, so we recompile now to make -# sure any implicit compilations didn't use any incorrect flags. -# -# For OpenJDK, the jar files built here are installed directly into the -# OpenJDK. -# -# For JDK, the binaries use pre-built/pre-signed binary files stored in -# the closed workspace that are not shipped in the OpenJDK workspaces. -# We still build the JDK files here to verify the files compile, and in -# preparation for possible signing. Developers working on JCE in JDK -# must sign the JCE files before testing. The JCE signing key is kept -# separate from the JDK workspace to prevent its disclosure. -# -# SPECIAL NOTE TO JCE/JDK developers: The source files must eventually -# be built and signed, and the resulting jar files *MUST BE CHECKED INTO -# THE CLOSED PART OF THE WORKSPACE*. This separate step *MUST NOT BE -# FORGOTTEN*, otherwise a bug fixed in the source code will not be -# reflected in the shipped binaries. The "release" target should be -# used to generate the required files. -# -# There are a number of targets to help both JDK/OpenJDK developers. -# -# Main Targets (JDK/OPENJDK): -# -# all/clobber/clean The usual. -# If OpenJDK: builds/installs the -# jce.jar/limited policy files. -# If JDK: builds but does not install. -# During full tops-down builds, -# prebuilt/presigned jce.jar & -# limited policy files are copied -# in by make/java/redist/Makefile. -# If you are working in this directory -# and want to install the prebuilts, -# use the "install-prebuilt" target. -# -# jar Builds/installs jce.jar -# If OpenJDK, does not sign -# If JDK, tries to sign -# -# Other lesser-used Targets (JDK/OPENJDK): -# -# build-jar Builds jce.jar (does not sign/install) -# -# build-policy Builds policy files (does not sign/install) -# -# install-jar Alias for "jar" above -# -# install-limited Builds/installs limited policy files -# If OpenJDK, does not sign -# If JDK, tries to sign -# install-unlimited Builds/nstalls unlimited policy files -# If OpenJDK, does not sign -# If JDK, tries to sign -# -# Other targets (JDK only): -# -# sign Alias for sign-jar and sign-policy -# sign-jar Builds/signs jce.jar file (no install) -# sign-policy Builds/signs policy files (no install) -# -# release Builds all targets in preparation -# for workspace integration. -# -# install-prebuilt Installs the pre-built jar files -# -# This makefile was written to support parallel target execution. -# - -BUILDDIR = ../.. -PACKAGE = javax.crypto -PRODUCT = sun - -# -# The following is for when we need to do postprocessing -# (signing) against a read-only build. If the OUTPUTDIR -# isn't writable, the build currently crashes out. -# -ifndef OPENJDK - ifdef ALT_JCE_BUILD_DIR - # ===================================================== - # Where to place the output, in case we're building from a read-only - # build area. (e.g. a release engineering build.) - JCE_BUILD_DIR=${ALT_JCE_BUILD_DIR} - IGNORE_WRITABLE_OUTPUTDIR_TEST=true - else - JCE_BUILD_DIR=${TEMPDIR} - endif -endif - -JAVAC_MAX_WARNINGS = true -JAVAC_WARNINGS_FATAL = true -include $(BUILDDIR)/common/Defs.gmk - -# -# Location for the newly built classfiles. -# -CLASSDESTDIR = $(TEMPDIR)/classes - -# -# Subdirectories of these are automatically included. -# -AUTO_FILES_JAVA_DIRS = \ - javax/crypto \ - sun/security/internal/interfaces \ - sun/security/internal/spec - -include $(BUILDDIR)/common/Classes.gmk - -# -# Rules -# - -# -# Some licensees do not get the security sources, but we still need to -# be able to build "all" for them. Check here to see if the sources were -# available. If not, then we don't need to continue this rule. -# - -ifdef OPENJDK -all: build-jar install-jar build-policy install-limited -else # OPENJDK -ifeq ($(strip $(FILES_java)),) -all: - $(no-source-warning) -else # FILES_java/policy files available -all: build-jar build-policy - $(build-warning) -endif # $(FILES_java)/policy files available -endif # OPENJDK - -# -# We use a variety of subdirectories in the $(TEMPDIR) depending on what -# part of the build we're doing. Both OPENJDK/JDK builds are initially -# done in the unsigned area. When files are signed in JDK, they will be -# placed in the appropriate areas. -# -UNSIGNED_DIR = $(TEMPDIR)/unsigned - -include Defs-jce.gmk - - -# ===================================================== -# Build the unsigned jce.jar file. Signing comes later. -# - -JAR_DESTFILE = $(LIBDIR)/jce.jar - -# -# JCE building is somewhat involved. -# -# OpenJDK: Since we do not ship prebuilt JCE files, previous compiles -# in the build may have needed JCE class signatures. There were then -# implicitly built by javac (likely using the boot javac). While using -# those class files was fine for signatures, we need to rebuild using -# the right compiler. -# -# JDK: Even through the jce.jar was previously installed, since the -# source files are accessible in the source directories, they will -# always be "newer" than the prebuilt files inside the jar, and thus -# make will always rebuild them. (We could "hide" the JCE source in a -# separate directory, but that would make the build logic for JDK and -# OpenJDK more complicated.) -# -# Thus in either situation, we shouldn't use these files. -# -# To make sure the classes were built with the right compiler options, -# delete the existing files in $(CLASSBINDIR), rebuild the right way in a -# directory under $(TEMPDIR), then copy the files back to -# $(CLASSBINDIR). Building in $(TEMPDIR) allows us to use our make -# infrastructure without modification: .classes.list, macros, etc. -# - -# -# The list of directories that will be remade from scratch, using the -# right compilers/options. -# -DELETE_DIRS = $(patsubst %, $(CLASSBINDIR)/%, $(AUTO_FILES_JAVA_DIRS)) - -# -# Since the -C option to jar is used below, each directory entry must be -# preceded with the appropriate directory to "cd" into. -# -JAR_DIRS = $(patsubst %, -C $(CLASSDESTDIR) %, $(AUTO_FILES_JAVA_DIRS)) - -build-jar: $(UNSIGNED_DIR)/jce.jar - -# -# Build jce.jar, then replace the previously built JCE files in the -# classes directory with these. This ensures we have consistently built -# files throughout the workspaces. -# -$(UNSIGNED_DIR)/jce.jar: prebuild build $(JCE_MANIFEST_FILE) - $(prep-target) - $(BOOT_JAR_CMD) cmf $(JCE_MANIFEST_FILE) $@ $(JAR_DIRS) \ - $(BOOT_JAR_JFLAGS) - $(CP) -r $(CLASSDESTDIR)/* $(CLASSBINDIR) - @$(java-vm-cleanup) - -build: prebuild - -prebuild: - $(RM) -r $(DELETE_DIRS) - - -# ===================================================== -# Build the unsigned policy files. -# -# Given the current state of world export/import policies, -# these settings work for Sun's situation. This note is not -# legal guidance, you must still resolve any export/import issues -# applicable for your situation. Contact your export/import -# counsel for more information. -# - -POLICY_DESTDIR = $(LIBDIR)/security -UNSIGNED_POLICY_BUILDDIR = $(UNSIGNED_DIR)/policy - -build-policy: unlimited limited - -# -# Build the unsigned unlimited policy files. -# -unlimited: \ - $(UNSIGNED_POLICY_BUILDDIR)/unlimited/US_export_policy.jar \ - $(UNSIGNED_POLICY_BUILDDIR)/unlimited/local_policy.jar - -$(UNSIGNED_POLICY_BUILDDIR)/unlimited/US_export_policy.jar: \ - policy/unlimited/default_US_export.policy \ - policy/unlimited/UNLIMITED - $(prep-target) - $(BOOT_JAR_CMD) cmf policy/unlimited/UNLIMITED $@ \ - -C policy/unlimited default_US_export.policy \ - $(BOOT_JAR_JFLAGS) - @$(java-vm-cleanup) - -$(UNSIGNED_POLICY_BUILDDIR)/unlimited/local_policy.jar: \ - policy/unlimited/default_local.policy \ - policy/unlimited/UNLIMITED - $(prep-target) - $(BOOT_JAR_CMD) cmf policy/unlimited/UNLIMITED $@ \ - -C policy/unlimited default_local.policy \ - $(BOOT_JAR_JFLAGS) - @$(java-vm-cleanup) - -# -# Build the unsigned limited policy files. -# -# NOTE: We currently do not place restrictions on our limited export -# policy. This was not a typo. -# -limited: \ - $(UNSIGNED_POLICY_BUILDDIR)/limited/US_export_policy.jar \ - $(UNSIGNED_POLICY_BUILDDIR)/limited/local_policy.jar - -$(UNSIGNED_POLICY_BUILDDIR)/limited/US_export_policy.jar: \ - $(UNSIGNED_POLICY_BUILDDIR)/unlimited/US_export_policy.jar - $(install-file) - -$(UNSIGNED_POLICY_BUILDDIR)/limited/local_policy.jar: \ - policy/limited/default_local.policy \ - policy/limited/exempt_local.policy \ - policy/limited/LIMITED - $(prep-target) - $(BOOT_JAR_CMD) cmf policy/limited/LIMITED $@ \ - -C policy/limited default_local.policy \ - -C policy/limited exempt_local.policy \ - $(BOOT_JAR_JFLAGS) - @$(java-vm-cleanup) - -UNSIGNED_POLICY_FILES = \ - $(UNSIGNED_POLICY_BUILDDIR)/unlimited/US_export_policy.jar \ - $(UNSIGNED_POLICY_BUILDDIR)/unlimited/local_policy.jar \ - $(UNSIGNED_POLICY_BUILDDIR)/limited/US_export_policy.jar \ - $(UNSIGNED_POLICY_BUILDDIR)/limited/local_policy.jar \ - - -ifndef OPENJDK -# ===================================================== -# Sign the various jar files. Not needed for OpenJDK. -# - -SIGNED_DIR = $(JCE_BUILD_DIR)/signed -SIGNED_POLICY_BUILDDIR = $(SIGNED_DIR)/policy - -SIGNED_POLICY_FILES = \ - $(patsubst $(UNSIGNED_POLICY_BUILDDIR)/%,$(SIGNED_POLICY_BUILDDIR)/%, \ - $(UNSIGNED_POLICY_FILES)) - -sign: sign-jar sign-policy - -sign-jar: $(SIGNED_DIR)/jce.jar - -sign-policy: $(SIGNED_POLICY_FILES) - -ifndef ALT_JCE_BUILD_DIR -$(SIGNED_DIR)/jce.jar: $(UNSIGNED_DIR)/jce.jar -else -# -# We have to remove the build dependency, otherwise, we'll try to rebuild it -# which we can't do on a read-only filesystem. -# -$(SIGNED_DIR)/jce.jar: - @if [ ! -r $(UNSIGNED_DIR)/jce.jar ] ; then \ - $(ECHO) "Couldn't find $(UNSIGNED_DIR)/jce.jar"; \ - exit 1; \ - fi -endif - $(call sign-file, $(UNSIGNED_DIR)/jce.jar) - -$(SIGNED_POLICY_BUILDDIR)/unlimited/US_export_policy.jar: \ - $(UNSIGNED_POLICY_BUILDDIR)/unlimited/US_export_policy.jar - $(call sign-file, $<) - -$(SIGNED_POLICY_BUILDDIR)/unlimited/local_policy.jar: \ - $(UNSIGNED_POLICY_BUILDDIR)/unlimited/local_policy.jar - $(call sign-file, $<) - -$(SIGNED_POLICY_BUILDDIR)/limited/US_export_policy.jar: \ - $(UNSIGNED_POLICY_BUILDDIR)/limited/US_export_policy.jar - $(call sign-file, $<) - -$(SIGNED_POLICY_BUILDDIR)/limited/local_policy.jar: \ - $(UNSIGNED_POLICY_BUILDDIR)/limited/local_policy.jar - $(call sign-file, $<) - - -# ===================================================== -# Create the Release Engineering files. Signed builds, -# unlimited policy file distribution, etc. -# - -CLOSED_DIR = $(BUILDDIR)/closed/javax/crypto - -release: $(SIGNED_DIR)/jce.jar sign-policy $(CLOSED_DIR)/doc/README.txt - $(RM) -r \ - $(JCE_BUILD_DIR)/release/UnlimitedJCEPolicy \ - $(JCE_BUILD_DIR)/release/jce.jar \ - $(JCE_BUILD_DIR)/release/US_export_policy.jar \ - $(JCE_BUILD_DIR)/release/local_policy.jar \ - $(JCE_BUILD_DIR)/release/UnlimitedJCEPolicy.zip - $(MKDIR) -p $(JCE_BUILD_DIR)/release/UnlimitedJCEPolicy - $(CP) $(SIGNED_DIR)/jce.jar $(JCE_BUILD_DIR)/release - $(CP) \ - $(SIGNED_POLICY_BUILDDIR)/limited/US_export_policy.jar \ - $(SIGNED_POLICY_BUILDDIR)/limited/local_policy.jar \ - $(JCE_BUILD_DIR)/release - $(CP) \ - $(SIGNED_POLICY_BUILDDIR)/unlimited/US_export_policy.jar \ - $(SIGNED_POLICY_BUILDDIR)/unlimited/local_policy.jar \ - $(CLOSED_DIR)/doc/README.txt \ - $(JCE_BUILD_DIR)/release/UnlimitedJCEPolicy - cd $(JCE_BUILD_DIR)/release ; \ - $(ZIPEXE) -qr UnlimitedJCEPolicy.zip UnlimitedJCEPolicy - $(release-warning) - -endif # OPENJDK - - -# ===================================================== -# Install routines. -# - -# -# Install jce.jar, depending on which type is requested. -# -install-jar jar: $(JAR_DESTFILE) -ifndef OPENJDK - $(release-warning) -endif - -ifdef OPENJDK -$(JAR_DESTFILE): $(UNSIGNED_DIR)/jce.jar -else -$(JAR_DESTFILE): $(SIGNED_DIR)/jce.jar -endif - $(install-file) - -# -# Install the appropriate policy file, depending on the type of build. -# -ifdef OPENJDK -INSTALL_POLICYDIR = $(UNSIGNED_POLICY_BUILDDIR) -else -INSTALL_POLICYDIR = $(SIGNED_POLICY_BUILDDIR) -endif - -install-limited-jars: \ - $(INSTALL_POLICYDIR)/limited/US_export_policy.jar \ - $(INSTALL_POLICYDIR)/limited/local_policy.jar - $(MKDIR) -p $(POLICY_DESTDIR) - $(RM) \ - $(POLICY_DESTDIR)/US_export_policy.jar \ - $(POLICY_DESTDIR)/local_policy.jar - $(CP) $^ $(POLICY_DESTDIR) - -install-limited: install-limited-jars -ifndef OPENJDK - $(release-warning) -endif - -install-unlimited-jars: \ - $(INSTALL_POLICYDIR)/unlimited/US_export_policy.jar \ - $(INSTALL_POLICYDIR)/unlimited/local_policy.jar - $(MKDIR) -p $(POLICY_DESTDIR) - $(RM) \ - $(POLICY_DESTDIR)/US_export_policy.jar \ - $(POLICY_DESTDIR)/local_policy.jar - $(CP) $^ $(POLICY_DESTDIR) - -install-unlimited: install-unlimited-jars -ifndef OPENJDK - $(release-warning) -endif - -ifndef OPENJDK -install-prebuilt-jars: - @$(ECHO) "\n>>>Installing prebuilt JCE framework..." - $(RM) $(JAR_DESTFILE) \ - $(POLICY_DESTDIR)/US_export_policy.jar \ - $(POLICY_DESTDIR)/local_policy.jar - $(CP) $(PREBUILT_DIR)/jce/jce.jar $(JAR_DESTFILE) - $(CP) \ - $(PREBUILT_DIR)/jce/US_export_policy.jar \ - $(PREBUILT_DIR)/jce/local_policy.jar \ - $(POLICY_DESTDIR) - -install-prebuilt: install-prebuilt-jars -endif - -# ===================================================== -# Support routines. -# - -clobber clean:: - $(RM) -r $(JAR_DESTFILE) $(POLICY_DESTDIR)/US_export_policy.jar \ - $(POLICY_DESTDIR)/local_policy.jar $(DELETE_DIRS) $(TEMPDIR) \ - $(JCE_BUILD_DIR) - -.PHONY: build-jar jar build-policy unlimited limited install-jar \ - install-limited install-unlimited -ifndef OPENJDK -.PHONY: sign sign-jar sign-policy release install-prebuilt -endif diff --git a/jdk/makefiles/javax/crypto/policy/limited/LIMITED b/jdk/makefiles/javax/crypto/policy/limited/LIMITED deleted file mode 100644 index b58f7acd930..00000000000 --- a/jdk/makefiles/javax/crypto/policy/limited/LIMITED +++ /dev/null @@ -1 +0,0 @@ -Crypto-Strength: limited diff --git a/jdk/makefiles/javax/crypto/policy/limited/default_local.policy b/jdk/makefiles/javax/crypto/policy/limited/default_local.policy deleted file mode 100644 index 2a6d5134047..00000000000 --- a/jdk/makefiles/javax/crypto/policy/limited/default_local.policy +++ /dev/null @@ -1,14 +0,0 @@ -// Some countries have import limits on crypto strength. This policy file -// is worldwide importable. - -grant { - permission javax.crypto.CryptoPermission "DES", 64; - permission javax.crypto.CryptoPermission "DESede", *; - permission javax.crypto.CryptoPermission "RC2", 128, - "javax.crypto.spec.RC2ParameterSpec", 128; - permission javax.crypto.CryptoPermission "RC4", 128; - permission javax.crypto.CryptoPermission "RC5", 128, - "javax.crypto.spec.RC5ParameterSpec", *, 12, *; - permission javax.crypto.CryptoPermission "RSA", *; - permission javax.crypto.CryptoPermission *, 128; -}; diff --git a/jdk/makefiles/javax/crypto/policy/limited/exempt_local.policy b/jdk/makefiles/javax/crypto/policy/limited/exempt_local.policy deleted file mode 100644 index f3255a2d970..00000000000 --- a/jdk/makefiles/javax/crypto/policy/limited/exempt_local.policy +++ /dev/null @@ -1,13 +0,0 @@ -// Some countries have import limits on crypto strength. So this file -// will be useful. - -grant { - // There is no restriction to any algorithms if KeyRecovery is enforced. - permission javax.crypto.CryptoPermission *, "KeyRecovery"; - - // There is no restriction to any algorithms if KeyEscrow is enforced. - permission javax.crypto.CryptoPermission *, "KeyEscrow"; - - // There is no restriction to any algorithms if KeyWeakening is enforced. - permission javax.crypto.CryptoPermission *, "KeyWeakening"; -}; diff --git a/jdk/makefiles/javax/crypto/policy/unlimited/UNLIMITED b/jdk/makefiles/javax/crypto/policy/unlimited/UNLIMITED deleted file mode 100644 index 7fc7743c416..00000000000 --- a/jdk/makefiles/javax/crypto/policy/unlimited/UNLIMITED +++ /dev/null @@ -1 +0,0 @@ -Crypto-Strength: unlimited diff --git a/jdk/makefiles/javax/crypto/policy/unlimited/default_US_export.policy b/jdk/makefiles/javax/crypto/policy/unlimited/default_US_export.policy deleted file mode 100644 index 67d0acc47a3..00000000000 --- a/jdk/makefiles/javax/crypto/policy/unlimited/default_US_export.policy +++ /dev/null @@ -1,5 +0,0 @@ -// Manufacturing policy file. -grant { - // There is no restriction to any algorithms. - permission javax.crypto.CryptoAllPermission; -}; diff --git a/jdk/makefiles/javax/crypto/policy/unlimited/default_local.policy b/jdk/makefiles/javax/crypto/policy/unlimited/default_local.policy deleted file mode 100644 index 8dc9702e9da..00000000000 --- a/jdk/makefiles/javax/crypto/policy/unlimited/default_local.policy +++ /dev/null @@ -1,5 +0,0 @@ -// Country-specific policy file for countries with no limits on crypto strength. -grant { - // There is no restriction to any algorithms. - permission javax.crypto.CryptoAllPermission; -}; diff --git a/jdk/makefiles/mapfiles/libjava/mapfile-vers b/jdk/makefiles/mapfiles/libjava/mapfile-vers index 8517e713dd9..23cca532fd7 100644 --- a/jdk/makefiles/mapfiles/libjava/mapfile-vers +++ b/jdk/makefiles/mapfiles/libjava/mapfile-vers @@ -232,7 +232,6 @@ SUNWprivate_1.1 { Java_java_security_AccessController_doPrivileged__Ljava_security_PrivilegedExceptionAction_2Ljava_security_AccessControlContext_2; Java_java_security_AccessController_getStackAccessControlContext; Java_java_security_AccessController_getInheritedAccessControlContext; - Java_java_sql_DriverManager_getCallerClassLoader; Java_java_util_ResourceBundle_getClassContext; Java_java_util_TimeZone_getSystemTimeZoneID; Java_java_util_TimeZone_getSystemGMTOffsetID; diff --git a/jdk/makefiles/mapfiles/libjfr/mapfile-vers b/jdk/makefiles/mapfiles/libjfr/mapfile-vers index aed19a75be3..5ed216eee9d 100644 --- a/jdk/makefiles/mapfiles/libjfr/mapfile-vers +++ b/jdk/makefiles/mapfiles/libjfr/mapfile-vers @@ -6,34 +6,34 @@ # Define library interface. SUNWprivate_1.1 { - global: - Java_oracle_jrockit_jfr_util_os_Process_getpid; - Java_oracle_jrockit_jfr_util_os_Timing_counterTime; - Java_oracle_jrockit_jfr_util_os_Timing_init; - Java_oracle_jrockit_jfr_util_log_NativeLogger_output0; - Java_oracle_jrockit_jfr_VMJFR_isEnabled; - Java_oracle_jrockit_jfr_VMJFR_options; - Java_oracle_jrockit_jfr_VMJFR_init; - Java_oracle_jrockit_jfr_VMJFR_addConstPool; - Java_oracle_jrockit_jfr_VMJFR_removeConstPool; - Java_oracle_jrockit_jfr_VMJFR_storeConstPool; - Java_oracle_jrockit_jfr_VMJFR_classID; - Java_oracle_jrockit_jfr_VMJFR_stackTraceID; - Java_oracle_jrockit_jfr_VMJFR_threadID; - Java_oracle_jrockit_jfr_VMJFR_rotate; - Java_oracle_jrockit_jfr_VMJFR_shutdown; - Java_oracle_jrockit_jfr_VMJFR_start; - Java_oracle_jrockit_jfr_VMJFR_stop; - Java_oracle_jrockit_jfr_VMJFR_buffer; - Java_oracle_jrockit_jfr_VMJFR_flush; - Java_oracle_jrockit_jfr_VMJFR_write; - Java_oracle_jrockit_jfr_VMJFR_add; - Java_oracle_jrockit_jfr_VMJFR_remove; - Java_oracle_jrockit_jfr_VMJFR_setThreshold; - Java_oracle_jrockit_jfr_VMJFR_setPeriod; - Java_oracle_jrockit_jfr_VMJFR_getPeriod; - Java_oracle_jrockit_jfr_VMJFR_descriptors; + global: + Java_oracle_jrockit_jfr_Process_getpid; + Java_oracle_jrockit_jfr_Timing_counterTime; + Java_oracle_jrockit_jfr_Timing_init; + Java_oracle_jrockit_jfr_NativeLogger_output0; + Java_oracle_jrockit_jfr_VMJFR_isEnabled; + Java_oracle_jrockit_jfr_VMJFR_options; + Java_oracle_jrockit_jfr_VMJFR_init; + Java_oracle_jrockit_jfr_VMJFR_addConstPool; + Java_oracle_jrockit_jfr_VMJFR_removeConstPool; + Java_oracle_jrockit_jfr_VMJFR_storeConstPool; + Java_oracle_jrockit_jfr_VMJFR_classID; + Java_oracle_jrockit_jfr_VMJFR_stackTraceID; + Java_oracle_jrockit_jfr_VMJFR_threadID; + Java_oracle_jrockit_jfr_VMJFR_rotate; + Java_oracle_jrockit_jfr_VMJFR_shutdown; + Java_oracle_jrockit_jfr_VMJFR_start; + Java_oracle_jrockit_jfr_VMJFR_stop; + Java_oracle_jrockit_jfr_VMJFR_buffer; + Java_oracle_jrockit_jfr_VMJFR_flush; + Java_oracle_jrockit_jfr_VMJFR_write; + Java_oracle_jrockit_jfr_VMJFR_add; + Java_oracle_jrockit_jfr_VMJFR_remove; + Java_oracle_jrockit_jfr_VMJFR_setThreshold; + Java_oracle_jrockit_jfr_VMJFR_setPeriod; + Java_oracle_jrockit_jfr_VMJFR_getPeriod; + Java_oracle_jrockit_jfr_VMJFR_descriptors; JNI_OnLoad; - local: - *; + local: + *; }; diff --git a/jdk/makefiles/mapfiles/libnio/mapfile-linux b/jdk/makefiles/mapfiles/libnio/mapfile-linux index d72244170b9..63c9cbf1443 100644 --- a/jdk/makefiles/mapfiles/libnio/mapfile-linux +++ b/jdk/makefiles/mapfiles/libnio/mapfile-linux @@ -39,7 +39,6 @@ SUNWprivate_1.1 { Java_sun_nio_ch_EPollArrayWrapper_epollCreate; Java_sun_nio_ch_EPollArrayWrapper_epollCtl; Java_sun_nio_ch_EPollArrayWrapper_epollWait; - Java_sun_nio_ch_EPollArrayWrapper_fdLimit; Java_sun_nio_ch_EPollArrayWrapper_init; Java_sun_nio_ch_EPollArrayWrapper_interrupt; Java_sun_nio_ch_EPollArrayWrapper_offsetofData; @@ -87,7 +86,9 @@ SUNWprivate_1.1 { Java_sun_nio_ch_IOUtil_configureBlocking; Java_sun_nio_ch_IOUtil_drain; Java_sun_nio_ch_IOUtil_fdVal; + Java_sun_nio_ch_IOUtil_fdLimit; Java_sun_nio_ch_IOUtil_initIDs; + Java_sun_nio_ch_IOUtil_iovMax; Java_sun_nio_ch_IOUtil_makePipe; Java_sun_nio_ch_IOUtil_randomBytes; Java_sun_nio_ch_IOUtil_setfdVal; diff --git a/jdk/makefiles/mapfiles/libnio/mapfile-solaris b/jdk/makefiles/mapfiles/libnio/mapfile-solaris index 4d86f28a566..5a4908e1f6d 100644 --- a/jdk/makefiles/mapfiles/libnio/mapfile-solaris +++ b/jdk/makefiles/mapfiles/libnio/mapfile-solaris @@ -36,7 +36,6 @@ SUNWprivate_1.1 { Java_sun_nio_ch_DatagramDispatcher_readv0; Java_sun_nio_ch_DatagramDispatcher_write0; Java_sun_nio_ch_DatagramDispatcher_writev0; - Java_sun_nio_ch_DevPollArrayWrapper_fdLimit; Java_sun_nio_ch_DevPollArrayWrapper_init; Java_sun_nio_ch_DevPollArrayWrapper_interrupt; Java_sun_nio_ch_DevPollArrayWrapper_poll0; @@ -74,8 +73,10 @@ SUNWprivate_1.1 { Java_sun_nio_ch_InheritedChannel_soType0; Java_sun_nio_ch_IOUtil_configureBlocking; Java_sun_nio_ch_IOUtil_drain; + Java_sun_nio_ch_IOUtil_fdLimit; Java_sun_nio_ch_IOUtil_fdVal; Java_sun_nio_ch_IOUtil_initIDs; + Java_sun_nio_ch_IOUtil_iovMax; Java_sun_nio_ch_IOUtil_makePipe; Java_sun_nio_ch_IOUtil_randomBytes; Java_sun_nio_ch_IOUtil_setfdVal; @@ -112,13 +113,13 @@ SUNWprivate_1.1 { Java_sun_nio_ch_UnixAsynchronousServerSocketChannelImpl_accept0; Java_sun_nio_ch_UnixAsynchronousServerSocketChannelImpl_initIDs; Java_sun_nio_ch_UnixAsynchronousSocketChannelImpl_checkConnect; - Java_sun_nio_ch_SolarisEventPort_init; - Java_sun_nio_ch_SolarisEventPort_portCreate; - Java_sun_nio_ch_SolarisEventPort_portClose; - Java_sun_nio_ch_SolarisEventPort_portAssociate; - Java_sun_nio_ch_SolarisEventPort_portGet; - Java_sun_nio_ch_SolarisEventPort_portGetn; - Java_sun_nio_ch_SolarisEventPort_portSend; + Java_sun_nio_ch_SolarisEventPort_port_1create; + Java_sun_nio_ch_SolarisEventPort_port_1close; + Java_sun_nio_ch_SolarisEventPort_port_1associate; + Java_sun_nio_ch_SolarisEventPort_port_1dissociate; + Java_sun_nio_ch_SolarisEventPort_port_1get; + Java_sun_nio_ch_SolarisEventPort_port_1getn; + Java_sun_nio_ch_SolarisEventPort_port_1send; Java_sun_nio_fs_GnomeFileTypeDetector_initializeGio; Java_sun_nio_fs_GnomeFileTypeDetector_probeUsingGio; Java_sun_nio_fs_GnomeFileTypeDetector_initializeGnomeVfs; diff --git a/jdk/makefiles/mkdemo/Makefile b/jdk/makefiles/mkdemo/Makefile deleted file mode 100644 index 4cbe431a884..00000000000 --- a/jdk/makefiles/mkdemo/Makefile +++ /dev/null @@ -1,68 +0,0 @@ -# -# Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile for building all the demos -# - -BUILDDIR = .. -PRODUCT = demos -include $(BUILDDIR)/common/Defs.gmk - -SUBDIRS = jni -SUBDIRS_desktop = -SUBDIRS_management = -SUBDIRS_misc = -SUBDIRS_tools = jvmti - -include $(BUILDDIR)/common/Subdirs.gmk - -TOPLEVEL_FILES = \ - $(DEMODIR)/README - -all build:: nbproject - $(SUBDIRS-loop) - -all build:: $(TOPLEVEL_FILES) - -nbproject: - $(RM) -r $(DEMODIR)/nbproject - $(MKDIR) -p $(DEMODIR) - ( $(CD) $(SHARE_SRC)/demo && $(TAR) -cf - \ - `$(FIND) nbproject $(SCM_DIRS_prune) -o -type f -print` ) | \ - ( $(CD) $(DEMODIR) && $(TAR) -xf - ) -ifndef OPENJDK - ( $(CD) $(CLOSED_SHARE_SRC)/demo && $(TAR) -cf - \ - `$(FIND) nbproject $(SCM_DIRS_prune) -o -type f -print` ) | \ - ( $(CD) $(DEMODIR) && $(TAR) -xf - ) -endif - -$(DEMODIR)/%: $(DEMOSRCDIR)/% - $(install-file) - -clean clobber:: - $(SUBDIRS-loop) - $(RM) -r $(DEMODIR) - $(RM) -r $(DEMOCLASSDIR) diff --git a/jdk/makefiles/mkdemo/jni/Makefile b/jdk/makefiles/mkdemo/jni/Makefile deleted file mode 100644 index b24a5f32ac6..00000000000 --- a/jdk/makefiles/mkdemo/jni/Makefile +++ /dev/null @@ -1,44 +0,0 @@ -# -# Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile for building the jni demo(s) -# - -BUILDDIR = ../.. -PRODUCT = demos -include $(BUILDDIR)/common/Defs.gmk - -SUBDIRS = - -ifeq ($(PLATFORM),solaris) - SUBDIRS += Poller -endif - -include $(BUILDDIR)/common/Subdirs.gmk - -all build clean clobber:: - $(SUBDIRS-loop) - diff --git a/jdk/makefiles/mkdemo/jni/Poller/Makefile b/jdk/makefiles/mkdemo/jni/Poller/Makefile deleted file mode 100644 index baf23e39c8d..00000000000 --- a/jdk/makefiles/mkdemo/jni/Poller/Makefile +++ /dev/null @@ -1,45 +0,0 @@ -# -# Copyright (c) 1999, 2006, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Build Poller class demo. -# - -BUILDDIR = ../../.. -PRODUCT = demo/jni -DEMONAME = Poller -include $(BUILDDIR)/common/Defs.gmk - -DEMO_ROOT = $(PLATFORM_SRC)/demo/jni/$(DEMONAME) -DEMO_TOPFILES = ./README.txt -DEMO_MAINCLASS = Client -DEMO_NATIVECLASS= $(DEMONAME) -DEMO_DESTDIR = $(DEMODIR)/jni/$(DEMONAME) - -# -# Demo jar building rules. -# -include $(BUILDDIR)/common/Demo.gmk - diff --git a/jdk/makefiles/mkdemo/jvmti/Makefile b/jdk/makefiles/mkdemo/jvmti/Makefile deleted file mode 100644 index 88434cf464e..00000000000 --- a/jdk/makefiles/mkdemo/jvmti/Makefile +++ /dev/null @@ -1,51 +0,0 @@ -# -# Copyright (c) 2004, 2011, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile for building the jvmti demo(s) -# - -BUILDDIR = ../.. -PRODUCT = demos -include $(BUILDDIR)/common/Defs.gmk - -# Can be built in any order, the JRE version of hprof and java_crw_demo are -# really built in make/java. -# The hprof target here just delivers the sources and README files. -# The java_crw_demo and agent_util files are copied into each demo that -# uses them. -SUBDIRS = \ - hprof - -include $(BUILDDIR)/common/Subdirs.gmk - -all build clean clobber:: - $(SUBDIRS-loop) - -all build :: $(DEMODIR)/jvmti/index.html - -$(DEMODIR)/jvmti/index.html: $(SHARE_SRC)/demo/jvmti/index.html - $(install-file) - diff --git a/jdk/makefiles/mkdemo/jvmti/README.txt b/jdk/makefiles/mkdemo/jvmti/README.txt deleted file mode 100644 index 99e2a8f021d..00000000000 --- a/jdk/makefiles/mkdemo/jvmti/README.txt +++ /dev/null @@ -1,58 +0,0 @@ -# -# Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -Instructions on adding a jvmti demo agent. - -Basically you want to mimic the jvmti demo agent "mtrace". - -* Create and populate a source directory at src/share/demo/jvmti - (Try and re-use code in agent_util area like src/share/demo/jvmti/mtrace) - (This should include a small README.txt document on what this demo is) - -* Make sure the appropriate "demo" copyright notice is added to all the - source files. - -* Edit src/share/demo/jvmti/index.html and add in reference to this demo. - -* Create make directory at make/mkdemo/jvmti - (Mimic make/mkdemo/jvmti/mtrace/Makefile) - -* Edit make/mkdemo/jvmti/Makefile and add in the new demo - -* Create test directory at test/demo/jvmti, create at least one test - (Use test/demo/jvmti/mtrace as a template) - -* Don't forget to check in all the new files - -* Build and create images (cd make && gnumake && gnumake images) - (Do this on Solaris, Linux, and at least one Windows platform) - -* Verify that browsing build/*/j2sdk-images/demo/jvmti looks right - -* Run the tests: cd test/demo/jvmti && runregress . - (Do this on Solaris, Linux, and at least one Windows platform) - -Contact: serviceability-dev@openjdk.java.net for more information or help. - diff --git a/jdk/makefiles/mkdemo/jvmti/hprof/Makefile b/jdk/makefiles/mkdemo/jvmti/hprof/Makefile deleted file mode 100644 index e2529192a8e..00000000000 --- a/jdk/makefiles/mkdemo/jvmti/hprof/Makefile +++ /dev/null @@ -1,52 +0,0 @@ -# -# Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -BUILDDIR = ../../.. -PRODUCT = demo/jvmti -DEMONAME = hprof -include $(BUILDDIR)/common/Defs.gmk - -DEMO_ROOT = $(SHARE_SRC)/demo/jvmti/$(DEMONAME) -DEMO_TOPFILES = ./README.txt -DEMO_PSRCDIR = $(PLATFORM_SRC)/demo/jvmti/$(DEMONAME) -DEMO_DESTDIR = $(DEMODIR)/jvmti/$(DEMONAME) - -DEMO_OBJECTS = java_crw_demo.$(OBJECT_SUFFIX) - -ifeq ($(PLATFORM), windows) - EXTRA_LIBS += wsock32.lib winmm.lib -endif -ifeq ($(PLATFORM), solaris) - OTHER_LDLIBS += $(LIBSOCKET) $(LIBNSL) -ldl -endif -ifeq ($(PLATFORM), linux) - OTHER_LDLIBS += $(LIBSOCKET) $(LIBNSL) -ldl -lpthread -endif - -# -# Demo jar building rules. -# -include $(BUILDDIR)/common/Demo.gmk - diff --git a/jdk/makefiles/mkdemo/jvmti/mapfile-vers b/jdk/makefiles/mkdemo/jvmti/mapfile-vers deleted file mode 100644 index 5d5740463bc..00000000000 --- a/jdk/makefiles/mkdemo/jvmti/mapfile-vers +++ /dev/null @@ -1,34 +0,0 @@ -# -# Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# Define public interface for a Java JVMTI agent library (Solaris & Linux). - -SUNWprivate_1.1 { - global: - Agent_OnLoad; - Agent_OnUnload; - local: - *; -}; diff --git a/jdk/makefiles/mkdemo/management/README.txt b/jdk/makefiles/mkdemo/management/README.txt deleted file mode 100644 index ab667a17078..00000000000 --- a/jdk/makefiles/mkdemo/management/README.txt +++ /dev/null @@ -1,57 +0,0 @@ -# -# Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -Instructions on adding a java.lang.management demo. - -Basically you want to mimic the java.lang.management demo "FullThreadDump". - -* Create and populate a source directory at src/demo/management - (This should include a small README.txt document on what this demo is) - -* Make sure the appropriate "demo" copyright notice is added to all the - source files. - -* Edit src/share/demo/management/index.html and add in reference to this demo. - -* Create make directory at make/mkdemo/management - (Mimic make/mkdemo/management/FullThreadDump/Makefile) - -* Edit make/mkdemo/management/Makefile and add in the new demo - -* Create test directory at test/demo/management, create at least one test - (Use test/demo/management/FullThreadDump as a template) - -* Don't forget to put all files under SCM control - -* Build and create images (cd make && gnumake && gnumake images) - (Do this on Solaris, Linux, and at least one Windows platform) - -* Verify that browsing build/*/j2sdk-images/demo/management looks right - -* Run the tests: cd test/demo/management && runregress . - (Do this on Solaris, Linux, and at least one Windows platform) - -Contact: jk-svc-group@sun.com for more information or help. - diff --git a/jdk/makefiles/sun/jkernel/Makefile b/jdk/makefiles/sun/jkernel/Makefile deleted file mode 100644 index 5abf87b57f5..00000000000 --- a/jdk/makefiles/sun/jkernel/Makefile +++ /dev/null @@ -1,94 +0,0 @@ -# -# Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -BUILDDIR = ../.. -MODULE = jkernel -PACKAGE = sun.jkernel -LIBRARY = jkernel -PRODUCT = sun - -include $(BUILDDIR)/common/Defs.gmk - -# -# Use highest optimization level -# -_OPT = $(CC_HIGHEST_OPT) - -# -# Java source files -# -include FILES_java.gmk -AUTO_FILES_JAVA_DIRS = sun/jkernel - -LOCALE_SUFFIXES = $(JDK_LOCALES) - -# -# Native source files -# - -ifeq ($(ARCH_DATA_MODEL), 32) - -ifeq ($(PLATFORM), windows) - -# If this is the VS Express compiler it will lack vc/atlmfc/ -ATL_MFC_DIR :=$(call DirExists,$(COMPILER_PATH)/../atlmfc,,) - -ifneq ($(ATL_MFC_DIR),) - -include FILES_c_windows.gmk - -vpath %.cpp $(PLATFORM_SRC)/native/sun/jkernel - - -VERSIONINFO_RESOURCE = $(PLATFORM_SRC)/native/sun/jkernel/kernel.rc - -LDLIBS += urlmon.lib wininet.lib shlwapi.lib version.lib comctl32.lib gdi32.lib -def:$(PLATFORM_SRC)/native/sun/jkernel/kernel.def - -include $(BUILDDIR)/common/Library.gmk - -endif - -endif - -endif - -# -# Resources -# -include $(JDK_TOPDIR)/makefiles/common/internal/Resources.gmk - -# -# Rules -# -include $(BUILDDIR)/common/Classes.gmk - -# If extra compression is going to be available in the deploy build enable -# its use here by defining the JRE-relative pathname of the shared library - -ifeq ($(PLATFORM), windows) - ifdef EXTRA_COMP_INSTALL_PATH - CPPFLAGS += -DEXTRA_COMP_INSTALL_PATH=$(EXTRA_COMP_INSTALL_PATH) - endif -endif diff --git a/jdk/makefiles/sun/security/ec/Makefile b/jdk/makefiles/sun/security/ec/Makefile deleted file mode 100644 index d09dbecf629..00000000000 --- a/jdk/makefiles/sun/security/ec/Makefile +++ /dev/null @@ -1,333 +0,0 @@ -# -# Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile for building sunec.jar and sunec native library. -# -# This file was derived from make/com/sun/crypto/provider/Makefile. -# - -# -# (The terms "OpenJDK" and "JDK" below refer to OpenJDK and Sun JDK builds -# respectively.) -# -# JCE builds are very different between OpenJDK and JDK. The OpenJDK JCE -# jar files do not require signing, but those for JDK do. If an unsigned -# jar file is installed into JDK, things will break when the crypto -# routines are called. -# -# This Makefile does the "real" build of the JCE files. For OpenJDK, -# the jar files built here are installed directly into the OpenJDK. -# -# For JDK, the binaries use pre-built/pre-signed binary files stored in -# the closed workspace that are not shipped in the OpenJDK workspaces. -# We still build the JDK files here to verify the files compile, and in -# preparation for possible signing. Developers working on JCE in JDK -# must sign the JCE files before testing. The JCE signing key is kept -# separate from the JDK workspace to prevent its disclosure. -# -# SPECIAL NOTE TO JCE/JDK developers: The source files must eventually -# be built, signed, and then the resulting jar files MUST BE CHECKED -# INTO THE CLOSED PART OF THE WORKSPACE*. This separate step *MUST NOT -# BE FORGOTTEN*, otherwise a bug fixed in the source code will not be -# reflected in the shipped binaries. The "release" target should be -# used to generate the required files. -# -# There are a number of targets to help both JDK/OpenJDK developers. -# -# Main Targets (JDK/OPENJDK): -# -# all/clobber/clean The usual, plus the native libraries. -# If OpenJDK, installs sunec.jar. -# If JDK, installs prebuilt -# sunec.jar. -# -# jar Builds/installs sunec.jar -# If OpenJDK, does not sign. -# If JDK, tries to sign. -# -# Other lesser-used Targets (JDK/OPENJDK): -# -# build-jar Builds sunec.jar -# (does not sign/install) -# -# install-jar Alias for "jar" above. -# -# Other targets (JDK only): -# -# sign Alias for sign-jar -# sign-jar Builds/signs sunec.jar (no install) -# -# release Builds all targets in preparation -# for workspace integration. -# -# install-prebuilt Installs the pre-built jar files -# -# This makefile was written to support parallel target execution. -# - -BUILDDIR = ../../.. -PACKAGE = sun.security.ec -PRODUCT = sun - -# -# The following is for when we need to do postprocessing -# (signing) against a read-only build. If the OUTPUTDIR -# isn't writable, the build currently crashes out. -# -ifndef OPENJDK - ifdef ALT_JCE_BUILD_DIR - # ===================================================== - # Where to place the output, in case we're building from a read-only - # build area. (e.g. a release engineering build.) - JCE_BUILD_DIR=${ALT_JCE_BUILD_DIR} - IGNORE_WRITABLE_OUTPUTDIR_TEST=true - else - JCE_BUILD_DIR=${TEMPDIR} - endif -endif - -JAVAC_MAX_WARNINGS=false -JAVAC_LINT_OPTIONS=-Xlint:all,-deprecation -JAVAC_WARNINGS_FATAL=true -include $(BUILDDIR)/common/Defs.gmk - -# -# Location for the newly built classfiles. -# -CLASSDESTDIR = $(TEMPDIR)/classes - -# -# Java files -# -AUTO_FILES_JAVA_DIRS = $(PKGDIR) - -# -# Exclude the sources that get built by ../other/Makefile -# -AUTO_JAVA_PRUNE = \ - ECKeyFactory.java \ - ECParameters.java \ - ECPrivateKeyImpl.java \ - ECPublicKeyImpl.java \ - NamedCurve.java - -# -# Some licensees do not get the native ECC sources, but we still need to -# be able to build "all" for them. Check here to see if the sources are -# available. If not, then skip them. -# - -NATIVE_ECC_AVAILABLE := $(shell \ - if [ -d $(SHARE_SRC)/native/$(PKGDIR)/impl ] ; then \ - $(ECHO) true; \ - else \ - $(ECHO) false; \ - fi) - -ifeq ($(NATIVE_ECC_AVAILABLE), true) - - LIBRARY = sunec - - # - # Java files that define native methods - # - FILES_export = \ - $(PKGDIR)/ECDHKeyAgreement.java \ - $(PKGDIR)/ECDSASignature.java \ - $(PKGDIR)/ECKeyPairGenerator.java - - JAVAHFLAGS = -bootclasspath \ - "$(CLASSDESTDIR)$(CLASSPATH_SEPARATOR)$(CLASSBINDIR)$(JCE_PATH)" - - # - # C and C++ files - # - include FILES_c.gmk - - FILES_cpp = ECC_JNI.cpp - - CPLUSPLUSLIBRARY=true - - FILES_m = mapfile-vers - - # - # Find native code - # - vpath %.cpp $(SHARE_SRC)/native/$(PKGDIR) - - vpath %.c $(SHARE_SRC)/native/$(PKGDIR)/impl - - # - # Find include files - # - OTHER_INCLUDES += -I$(SHARE_SRC)/native/$(PKGDIR)/impl - - # - # Compiler flags - # - OTHER_CFLAGS += -DMP_API_COMPATIBLE -DNSS_ECC_MORE_THAN_SUITE_B - - # - # Libraries to link - # - ifneq ($(PLATFORM), windows) - OTHER_LDLIBS = $(LIBCXX) - endif - - include $(BUILDDIR)/common/Mapfile-vers.gmk - - include $(BUILDDIR)/common/Library.gmk - -else # NATIVE_ECC_AVAILABLE - - include $(BUILDDIR)/common/Classes.gmk - -endif # NATIVE_ECC_AVAILABLE - -# -# We use a variety of subdirectories in the $(TEMPDIR) depending on what -# part of the build we're doing. Both OPENJDK/JDK builds are initially -# done in the unsigned area. When files are signed in JDK, -# they will be placed in the appropriate area. -# -UNSIGNED_DIR = $(TEMPDIR)/unsigned - -include $(BUILDDIR)/javax/crypto/Defs-jce.gmk - -# -# Rules -# - -ifdef OPENJDK -all: build-jar install-jar -else -all: build-jar install-prebuilt - $(build-warning) -endif - - -# ===================================================== -# Build the unsigned sunec.jar file. -# - -JAR_DESTFILE = $(EXTDIR)/sunec.jar - -# -# Since the -C option to jar is used below, each directory entry must be -# preceded with the appropriate directory to "cd" into. -# -JAR_DIRS = $(patsubst %, -C $(CLASSDESTDIR) %, $(AUTO_FILES_JAVA_DIRS)) - -build-jar: $(UNSIGNED_DIR)/sunec.jar - -# -# Build sunec.jar. -# -$(UNSIGNED_DIR)/sunec.jar: build - $(prep-target) - $(BOOT_JAR_CMD) cf $@ $(JAR_DIRS) \ - $(BOOT_JAR_JFLAGS) - @$(java-vm-cleanup) - - -ifndef OPENJDK -# ===================================================== -# Sign the provider jar file. Not needed for OpenJDK. -# - -SIGNED_DIR = $(JCE_BUILD_DIR)/signed - -sign: sign-jar - -sign-jar: $(SIGNED_DIR)/sunec.jar - -ifndef ALT_JCE_BUILD_DIR -$(SIGNED_DIR)/sunec.jar: $(UNSIGNED_DIR)/sunec.jar -else -# -# We have to remove the build dependency, otherwise, we'll try to rebuild it -# which we can't do on a read-only filesystem. -# -$(SIGNED_DIR)/sunec.jar: - @if [ ! -r $(UNSIGNED_DIR)/sunec.jar ] ; then \ - $(ECHO) "Couldn't find $(UNSIGNED_DIR)/sunec.jar"; \ - exit 1; \ - fi -endif - $(call sign-file, $(UNSIGNED_DIR)/sunec.jar) - - -# ===================================================== -# Create the Release Engineering files. Signed builds, etc. -# - -release: $(SIGNED_DIR)/sunec.jar - $(RM) $(JCE_BUILD_DIR)/release/sunec.jar - $(MKDIR) -p $(JCE_BUILD_DIR)/release - $(CP) $(SIGNED_DIR)/sunec.jar $(JCE_BUILD_DIR)/release - $(release-warning) - -endif # OPENJDK - - -# ===================================================== -# Install routines. -# - -# -# Install sunec.jar, depending on which type is requested. -# -install-jar jar: $(JAR_DESTFILE) -ifndef OPENJDK - $(release-warning) -endif - -ifdef OPENJDK -$(JAR_DESTFILE): $(UNSIGNED_DIR)/sunec.jar -else -$(JAR_DESTFILE): $(SIGNED_DIR)/sunec.jar -endif - $(install-file) - -ifndef OPENJDK -install-prebuilt: - @$(ECHO) "\n>>>Installing prebuilt SunEC provider..." - $(RM) $(JAR_DESTFILE) - $(CP) $(PREBUILT_DIR)/ec/sunec.jar $(JAR_DESTFILE) -endif - - -# ===================================================== -# Support routines. -# - -clobber clean:: - $(RM) -r $(JAR_DESTFILE) $(TEMPDIR) $(JCE_BUILD_DIR) - -.PHONY: build-jar jar install-jar -ifndef OPENJDK -.PHONY: sign sign-jar release install-prebuilt -endif diff --git a/jdk/makefiles/sun/security/pkcs11/FILES_c.gmk b/jdk/makefiles/sun/security/pkcs11/FILES_c.gmk deleted file mode 100644 index 328547a3f4a..00000000000 --- a/jdk/makefiles/sun/security/pkcs11/FILES_c.gmk +++ /dev/null @@ -1,41 +0,0 @@ -# -# Copyright (c) 2003, 2007, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -FILES_c = \ - j2secmod.c \ - j2secmod_md.c \ - p11_convert.c \ - p11_crypt.c \ - p11_digest.c \ - p11_dual.c \ - p11_general.c \ - p11_keymgmt.c \ - p11_mutex.c \ - p11_objmgmt.c \ - p11_sessmgmt.c \ - p11_sign.c \ - p11_util.c \ - p11_md.c - diff --git a/jdk/makefiles/sun/security/pkcs11/Makefile b/jdk/makefiles/sun/security/pkcs11/Makefile deleted file mode 100644 index b94a6dbc109..00000000000 --- a/jdk/makefiles/sun/security/pkcs11/Makefile +++ /dev/null @@ -1,313 +0,0 @@ -# -# Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# -# Makefile for building sunpkcs11.jar and native libraries. -# -# This file was derived from make/com/sun/crypto/provider/Makefile. -# - -# -# (The terms "OpenJDK" and "JDK" below refer to OpenJDK and Sun JDK builds -# respectively.) -# -# JCE builds are very different between OpenJDK and JDK. The OpenJDK JCE -# jar files do not require signing, but those for JDK do. If an unsigned -# jar file is installed into JDK, things will break when the crypto -# routines are called. -# -# This Makefile does the "real" build of the JCE files. For OpenJDK, -# the jar files built here are installed directly into the OpenJDK. -# -# For JDK, the binaries use pre-built/pre-signed binary files stored in -# the closed workspace that are not shipped in the OpenJDK workspaces. -# We still build the JDK files here to verify the files compile, and in -# preparation for possible signing. Developers working on JCE in JDK -# must sign the JCE files before testing. The JCE signing key is kept -# separate from the JDK workspace to prevent its disclosure. -# -# SPECIAL NOTE TO JCE/JDK developers: The source files must eventually -# be built, signed, and then the resulting jar files MUST BE CHECKED -# INTO THE CLOSED PART OF THE WORKSPACE*. This separate step *MUST NOT -# BE FORGOTTEN*, otherwise a bug fixed in the source code will not be -# reflected in the shipped binaries. The "release" target should be -# used to generate the required files. -# -# There are a number of targets to help both JDK/OpenJDK developers. -# -# Main Targets (JDK/OPENJDK): -# -# all/clobber/clean The usual, plus the native libraries. -# If OpenJDK, installs sunpkcs11.jar. -# If JDK, installs prebuilt -# sunpkcs11.jar. -# -# jar Builds/installs sunpkcs11.jar -# If OpenJDK, does not sign. -# If JDK, tries to sign. -# -# Other lesser-used Targets (JDK/OPENJDK): -# -# build-jar Builds sunpkcs11.jar -# (does not sign/install) -# -# install-jar Alias for "jar" above. -# -# Other targets (JDK only): -# -# sign Alias for sign-jar -# sign-jar Builds/signs sunpkcs11.jar (no install) -# -# release Builds all targets in preparation -# for workspace integration. -# -# install-prebuilt Installs the pre-built jar files -# -# This makefile was written to support parallel target execution. -# - -BUILDDIR = ../../.. -PACKAGE = sun.security.pkcs11 -LIBRARY = j2pkcs11 -PRODUCT = sun - -# -# The following is for when we need to do postprocessing -# (signing/obfuscation) against a read-only build. If the OUTPUTDIR -# isn't writable, the build currently crashes out. -# -ifndef OPENJDK - ifdef ALT_JCE_BUILD_DIR - # ===================================================== - # Where to place the output, in case we're building from a read-only - # build area. (e.g. a release engineering build.) - JCE_BUILD_DIR=${ALT_JCE_BUILD_DIR} - IGNORE_WRITABLE_OUTPUTDIR_TEST=true - else - JCE_BUILD_DIR=${TEMPDIR} - endif -endif - -JAVAC_MAX_WARNINGS=false -JAVAC_LINT_OPTIONS=-Xlint:all,-deprecation -JAVAC_WARNINGS_FATAL=true -include $(BUILDDIR)/common/Defs.gmk - -# -# C and Java Files -# -include FILES_c.gmk - -# -# Subdirectories of these are automatically included. -# -AUTO_FILES_JAVA_DIRS = sun/security/pkcs11 - -# -# Java files that define native methods -# -FILES_export = \ - sun/security/pkcs11/wrapper/PKCS11.java \ - sun/security/pkcs11/Secmod.java - -# -# Find native code -# -vpath %.c \ - $(SHARE_SRC)/native/sun/security/pkcs11/wrapper \ - $(PLATFORM_SRC)/native/sun/security/pkcs11/wrapper \ - -# -# Find include files -# -OTHER_INCLUDES += \ - -I$(SHARE_SRC)/native/sun/security/pkcs11/wrapper \ - -I$(PLATFORM_SRC)/native/sun/security/pkcs11/wrapper - -# -# Rules -# -CLASSDESTDIR = $(TEMPDIR)/classes -JAVAHFLAGS = -bootclasspath \ - "$(CLASSDESTDIR)$(CLASSPATH_SEPARATOR)$(CLASSBINDIR)$(JCE_PATH)" - -include $(BUILDDIR)/common/Mapfile-vers.gmk - -include $(BUILDDIR)/common/Library.gmk - -# -# Libraries to link -# -ifneq ($(PLATFORM), windows) - OTHER_LDLIBS = $(LIBDL) -endif - -# Other config files -SUNPKCS11_CFG = - -ifeq ($(PLATFORM), solaris) -#SUNPKCS11_CFG = sunpkcs11-cfg -endif # PLATFORM - -SUNPKCS11_CFG_SRC = $(TOPDIR)/src/share/lib/security/sunpkcs11-solaris.cfg -SUNPKCS11_CFG_BUILD = $(LIBDIR)/security/sunpkcs11-solaris.cfg - -# -# We use a variety of subdirectories in the $(TEMPDIR) depending on what -# part of the build we're doing. Both OPENJDK/JDK builds are initially -# done in the unsigned area. When files are signed in JDK, -# they will be placed in the appropriate area. -# -UNSIGNED_DIR = $(TEMPDIR)/unsigned - -# -# Rules -# - -ifdef OPENJDK -all: $(SUNPKCS11_CFG) build-jar install-jar -else -all: $(SUNPKCS11_CFG) build-jar install-prebuilt - $(build-warning) -endif - -sunpkcs11-cfg: $(SUNPKCS11_CFG_BUILD) - -$(SUNPKCS11_CFG_BUILD): $(SUNPKCS11_CFG_SRC) - $(install-file) - -include $(BUILDDIR)/javax/crypto/Defs-jce.gmk - - -# ===================================================== -# Build the unsigned sunpkcs11.jar file. -# - -JAR_DESTFILE = $(EXTDIR)/sunpkcs11.jar - -# -# The sunpkcs11.jar needs to be in the extension class directory, -# therefore none of its classes can appear in $(CLASSBINDIR). -# Currently no one is using any of the PKCS11 internals, so these files -# should not have been built. -# - -# -# Since the -C option to jar is used below, each directory entry must be -# preceded with the appropriate directory to "cd" into. -# -JAR_DIRS = $(patsubst %, -C $(CLASSDESTDIR) %, $(AUTO_FILES_JAVA_DIRS)) - -build-jar: $(UNSIGNED_DIR)/sunpkcs11.jar - -# -# Build sunpkcs11.jar. -# -$(UNSIGNED_DIR)/sunpkcs11.jar: build - $(prep-target) - $(BOOT_JAR_CMD) cf $@ $(JAR_DIRS) \ - $(BOOT_JAR_JFLAGS) - @$(java-vm-cleanup) - - -ifndef OPENJDK -# ===================================================== -# Sign the provider jar file. Not needed for OpenJDK. -# - -SIGNED_DIR = $(JCE_BUILD_DIR)/signed - -sign: sign-jar - -sign-jar: $(SIGNED_DIR)/sunpkcs11.jar - -ifndef ALT_JCE_BUILD_DIR -$(SIGNED_DIR)/sunpkcs11.jar: $(UNSIGNED_DIR)/sunpkcs11.jar -else -# -# We have to remove the build dependency, otherwise, we'll try to rebuild it -# which we can't do on a read-only filesystem. -# -$(SIGNED_DIR)/sunpkcs11.jar: - @if [ ! -r $(UNSIGNED_DIR)/sunpkcs11.jar ] ; then \ - $(ECHO) "Couldn't find $(UNSIGNED_DIR)/sunpkcs11.jar"; \ - exit 1; \ - fi -endif - $(call sign-file, $(UNSIGNED_DIR)/sunpkcs11.jar) - - -# ===================================================== -# Create the Release Engineering files. Signed builds, etc. -# - -release: $(SIGNED_DIR)/sunpkcs11.jar - $(RM) $(JCE_BUILD_DIR)/release/sunpkcs11.jar - $(MKDIR) -p $(JCE_BUILD_DIR)/release - $(CP) $(SIGNED_DIR)/sunpkcs11.jar $(JCE_BUILD_DIR)/release - $(release-warning) - -endif # OPENJDK - - -# ===================================================== -# Install routines. -# - -# -# Install sunpkcs11.jar, depending on which type is requested. -# -install-jar jar: $(JAR_DESTFILE) -ifndef OPENJDK - $(release-warning) -endif - -ifdef OPENJDK -$(JAR_DESTFILE): $(UNSIGNED_DIR)/sunpkcs11.jar -else -$(JAR_DESTFILE): $(SIGNED_DIR)/sunpkcs11.jar -endif - $(install-file) - -ifndef OPENJDK -install-prebuilt: - @$(ECHO) "\n>>>Installing prebuilt SunPKCS11 provider..." - $(RM) $(JAR_DESTFILE) - $(CP) $(PREBUILT_DIR)/pkcs11/sunpkcs11.jar $(JAR_DESTFILE) -endif - - -# ===================================================== -# Support routines. -# - -clobber clean:: - $(RM) -r $(JAR_DESTFILE) $(TEMPDIR) $(JCE_BUILD_DIR) - $(RM) $(SUNPKCS11_CFG_BUILD) - -.PHONY: build-jar jar install-jar -ifndef OPENJDK -.PHONY: sign sign-jar release install-prebuilt -endif diff --git a/jdk/makefiles/sun/security/pkcs11/mapfile-vers b/jdk/makefiles/sun/security/pkcs11/mapfile-vers deleted file mode 100644 index 7301c11417d..00000000000 --- a/jdk/makefiles/sun/security/pkcs11/mapfile-vers +++ /dev/null @@ -1,110 +0,0 @@ -# -# Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -# Define public interface. - -SUNWprivate_1.1 { - global: - JNI_OnLoad; - Java_sun_security_pkcs11_wrapper_PKCS11_initializeLibrary; - Java_sun_security_pkcs11_wrapper_PKCS11_finalizeLibrary; - Java_sun_security_pkcs11_wrapper_PKCS11_connect; - Java_sun_security_pkcs11_wrapper_PKCS11_disconnect; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1Initialize; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1Finalize; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetInfo; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetSlotList; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetSlotInfo; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetTokenInfo; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetMechanismList; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetMechanismInfo; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1InitToken; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1InitPIN; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1SetPIN; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1OpenSession; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1CloseSession; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1CloseAllSessions; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetSessionInfo; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetOperationState; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1SetOperationState; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1Login; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1Logout; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1CreateObject; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1CopyObject; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DestroyObject; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetObjectSize; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetAttributeValue; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1SetAttributeValue; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1FindObjectsInit; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1FindObjects; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1FindObjectsFinal; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1EncryptInit; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1Encrypt; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1EncryptUpdate; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1EncryptFinal; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DecryptInit; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1Decrypt; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DecryptUpdate; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DecryptFinal; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestInit; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestSingle; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestUpdate; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestKey; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestFinal; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1SignInit; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1Sign; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1SignUpdate; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1SignFinal; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1SignRecoverInit; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1SignRecover; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1VerifyInit; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1Verify; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1VerifyUpdate; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1VerifyFinal; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1VerifyRecoverInit; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1VerifyRecover; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestEncryptUpdate; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1DecryptDigestUpdate; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1SignEncryptUpdate; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1DecryptVerifyUpdate; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GenerateKey; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GenerateKeyPair; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1WrapKey; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1UnwrapKey; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1DeriveKey; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1SeedRandom; - Java_sun_security_pkcs11_wrapper_PKCS11_C_1GenerateRandom; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetFunctionStatus; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1CancelFunction; -# Java_sun_security_pkcs11_wrapper_PKCS11_C_1WaitForSlotEvent; - Java_sun_security_pkcs11_Secmod_nssGetLibraryHandle; - Java_sun_security_pkcs11_Secmod_nssLoadLibrary; - Java_sun_security_pkcs11_Secmod_nssVersionCheck; - Java_sun_security_pkcs11_Secmod_nssInit; - Java_sun_security_pkcs11_Secmod_nssGetModuleList; - - local: - *; -}; From f7b99ca7f6a2a305c855f458f13bd5e8399a6193 Mon Sep 17 00:00:00 2001 From: Erik Joelsson Date: Tue, 3 Jul 2012 16:11:12 -0700 Subject: [PATCH 056/160] 7181504: Update of latest build-infra Makefiles Reviewed-by: ohair --- common/autoconf/autogen.sh | 18 +- common/autoconf/build-aux/config.guess | 1553 +-- common/autoconf/builddeps.conf.example | 8 +- common/autoconf/builddeps.m4 | 62 +- common/autoconf/configure | 16836 +---------------------- common/autoconf/configure.ac | 2956 +--- common/autoconf/cores.m4 | 103 - common/autoconf/help.m4 | 105 +- common/autoconf/platform.m4 | 521 +- common/autoconf/spec.gmk.in | 150 +- common/bin/compareimage.sh | 60 +- common/bin/diffexec.sh | 17 +- common/bin/diffjarzip.sh | 6 +- common/bin/difflib.sh | 24 +- common/makefiles/IdlCompilation.gmk | 3 +- common/makefiles/JavaCompilation.gmk | 31 +- common/makefiles/MakeBase.gmk | 1 + common/makefiles/Makefile | 233 +- common/makefiles/NativeCompilation.gmk | 406 +- common/makefiles/RMICompile.gmk | 103 - 20 files changed, 1233 insertions(+), 21963 deletions(-) delete mode 100644 common/autoconf/cores.m4 delete mode 100644 common/makefiles/RMICompile.gmk diff --git a/common/autoconf/autogen.sh b/common/autoconf/autogen.sh index 5f6937c52f7..ce56d2719d6 100644 --- a/common/autoconf/autogen.sh +++ b/common/autoconf/autogen.sh @@ -22,5 +22,19 @@ # questions. # -autoconf -W all configure.ac > configure -rm -rf config.status config.log autom4te.cache +script_dir=`dirname $0` +closed_script_dir="$script_dir/../../jdk/make/closed/autoconf" + +# Create a timestamp as seconds since epoch +TIMESTAMP=`date +%s` + +cat $script_dir/configure.ac | sed -e "s|@DATE_WHEN_GENERATED@|$TIMESTAMP|" | autoconf -W all -I$script_dir - > $script_dir/generated-configure.sh +rm -rf autom4te.cache + +if test -e $closed_script_dir/closed-hook.m4; then + # We have closed sources available; also generate configure script + # with closed hooks compiled in. + cat $script_dir/configure.ac | sed -e "s|@DATE_WHEN_GENERATED@|$TIMESTAMP|" | \ + sed -e "s|AC_DEFUN_ONCE(\[CLOSED_HOOK\])|m4_include([$closed_script_dir/closed-hook.m4])|" | autoconf -W all -I$script_dir - > $closed_script_dir/generated-configure.sh + rm -rf autom4te.cache +fi diff --git a/common/autoconf/build-aux/config.guess b/common/autoconf/build-aux/config.guess index e69905d5201..389eedfc1d1 100644 --- a/common/autoconf/build-aux/config.guess +++ b/common/autoconf/build-aux/config.guess @@ -1,1531 +1,38 @@ -#! /bin/sh -# Attempt to guess a canonical system name. -# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, -# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 -# Free Software Foundation, Inc. - -timestamp='2008-01-23' - -# This file is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. +#!/bin/sh # -# This program 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 for more details. +# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA -# 02110-1301, USA. +# 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. # -# As a special exception to the GNU General Public License, if you -# distribute this file as part of a program that contains a -# configuration script generated by Autoconf, you may include it under -# the same distribution terms that you use for the rest of that program. - - -# Originally written by Per Bothner . -# Please send patches to . Submit a context -# diff and a properly formatted ChangeLog entry. +# 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). # -# This script attempts to guess a canonical system name similar to -# config.sub. If it succeeds, it prints the system name on stdout, and -# exits with 0. Otherwise, it exits with 1. +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. # -# The plan is that this can be called by configure scripts if you -# don't specify an explicit build system type. -me=`echo "$0" | sed -e 's,.*/,,'` +# This is a wrapper for the config.guess from autoconf. The latter does not properly +# detect amd64 systems, since that require isainfo instead of uname. Instead of patching +# the autoconf system (which might easily get lost in a future update), we wrap it and +# fix the broken property, if needed. -usage="\ -Usage: $0 [OPTION] - -Output the configuration name of the system \`$me' is run on. - -Operation modes: - -h, --help print this help, then exit - -t, --time-stamp print date of last modification, then exit - -v, --version print version number, then exit - -Report bugs and patches to ." - -version="\ -GNU config.guess ($timestamp) - -Originally written by Per Bothner. -Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, -2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. - -This is free software; see the source for copying conditions. There is NO -warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." - -help=" -Try \`$me --help' for more information." - -# Parse command line -while test $# -gt 0 ; do - case $1 in - --time-stamp | --time* | -t ) - echo "$timestamp" ; exit ;; - --version | -v ) - echo "$version" ; exit ;; - --help | --h* | -h ) - echo "$usage"; exit ;; - -- ) # Stop option processing - shift; break ;; - - ) # Use stdin as input. - break ;; - -* ) - echo "$me: invalid option $1$help" >&2 - exit 1 ;; - * ) - break ;; - esac -done - -if test $# != 0; then - echo "$me: too many arguments$help" >&2 - exit 1 +DIR=`dirname $0` +OUT=`. $DIR/autoconf-config.guess` +echo $OUT | grep i386-pc-solaris > /dev/null 2> /dev/null +if test $? = 0; then + # isainfo -n returns either i386 or amd64 on Intel systems + REAL_CPU=`isainfo -n` + OUT=$REAL_CPU`echo $OUT | sed -e 's/[^-]*//'` fi - -trap 'exit 1' 1 2 15 - -# CC_FOR_BUILD -- compiler used by this script. Note that the use of a -# compiler to aid in system detection is discouraged as it requires -# temporary files to be created and, as you can see below, it is a -# headache to deal with in a portable fashion. - -# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still -# use `HOST_CC' if defined, but it is deprecated. - -# Portable tmp directory creation inspired by the Autoconf team. - -set_cc_for_build=' -trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; -trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; -: ${TMPDIR=/tmp} ; - { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || - { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || - { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || - { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; -dummy=$tmp/dummy ; -tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; -case $CC_FOR_BUILD,$HOST_CC,$CC in - ,,) echo "int x;" > $dummy.c ; - for c in cc gcc c89 c99 ; do - if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then - CC_FOR_BUILD="$c"; break ; - fi ; - done ; - if test x"$CC_FOR_BUILD" = x ; then - CC_FOR_BUILD=no_compiler_found ; - fi - ;; - ,,*) CC_FOR_BUILD=$CC ;; - ,*,*) CC_FOR_BUILD=$HOST_CC ;; -esac ; set_cc_for_build= ;' - -# This is needed to find uname on a Pyramid OSx when run in the BSD universe. -# (ghazi@noc.rutgers.edu 1994-08-24) -if (test -f /.attbin/uname) >/dev/null 2>&1 ; then - PATH=$PATH:/.attbin ; export PATH -fi - -UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown -UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown -UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown -UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown - -# Note: order is significant - the case branches are not exclusive. - -case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in - *:NetBSD:*:*) - # NetBSD (nbsd) targets should (where applicable) match one or - # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, - # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently - # switched to ELF, *-*-netbsd* would select the old - # object file format. This provides both forward - # compatibility and a consistent mechanism for selecting the - # object file format. - # - # Note: NetBSD doesn't particularly care about the vendor - # portion of the name. We always set it to "unknown". - sysctl="sysctl -n hw.machine_arch" - UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ - /usr/sbin/$sysctl 2>/dev/null || echo unknown)` - case "${UNAME_MACHINE_ARCH}" in - armeb) machine=armeb-unknown ;; - arm*) machine=arm-unknown ;; - sh3el) machine=shl-unknown ;; - sh3eb) machine=sh-unknown ;; - sh5el) machine=sh5le-unknown ;; - *) machine=${UNAME_MACHINE_ARCH}-unknown ;; - esac - # The Operating System including object format, if it has switched - # to ELF recently, or will in the future. - case "${UNAME_MACHINE_ARCH}" in - arm*|i386|m68k|ns32k|sh3*|sparc|vax) - eval $set_cc_for_build - if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ - | grep __ELF__ >/dev/null - then - # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). - # Return netbsd for either. FIX? - os=netbsd - else - os=netbsdelf - fi - ;; - *) - os=netbsd - ;; - esac - # The OS release - # Debian GNU/NetBSD machines have a different userland, and - # thus, need a distinct triplet. However, they do not need - # kernel version information, so it can be replaced with a - # suitable tag, in the style of linux-gnu. - case "${UNAME_VERSION}" in - Debian*) - release='-gnu' - ;; - *) - release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` - ;; - esac - # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: - # contains redundant information, the shorter form: - # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. - echo "${machine}-${os}${release}" - exit ;; - *:OpenBSD:*:*) - UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` - echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} - exit ;; - *:ekkoBSD:*:*) - echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} - exit ;; - *:SolidBSD:*:*) - echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} - exit ;; - macppc:MirBSD:*:*) - echo powerpc-unknown-mirbsd${UNAME_RELEASE} - exit ;; - *:MirBSD:*:*) - echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} - exit ;; - alpha:OSF1:*:*) - case $UNAME_RELEASE in - *4.0) - UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` - ;; - *5.*) - UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` - ;; - esac - # According to Compaq, /usr/sbin/psrinfo has been available on - # OSF/1 and Tru64 systems produced since 1995. I hope that - # covers most systems running today. This code pipes the CPU - # types through head -n 1, so we only detect the type of CPU 0. - ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` - case "$ALPHA_CPU_TYPE" in - "EV4 (21064)") - UNAME_MACHINE="alpha" ;; - "EV4.5 (21064)") - UNAME_MACHINE="alpha" ;; - "LCA4 (21066/21068)") - UNAME_MACHINE="alpha" ;; - "EV5 (21164)") - UNAME_MACHINE="alphaev5" ;; - "EV5.6 (21164A)") - UNAME_MACHINE="alphaev56" ;; - "EV5.6 (21164PC)") - UNAME_MACHINE="alphapca56" ;; - "EV5.7 (21164PC)") - UNAME_MACHINE="alphapca57" ;; - "EV6 (21264)") - UNAME_MACHINE="alphaev6" ;; - "EV6.7 (21264A)") - UNAME_MACHINE="alphaev67" ;; - "EV6.8CB (21264C)") - UNAME_MACHINE="alphaev68" ;; - "EV6.8AL (21264B)") - UNAME_MACHINE="alphaev68" ;; - "EV6.8CX (21264D)") - UNAME_MACHINE="alphaev68" ;; - "EV6.9A (21264/EV69A)") - UNAME_MACHINE="alphaev69" ;; - "EV7 (21364)") - UNAME_MACHINE="alphaev7" ;; - "EV7.9 (21364A)") - UNAME_MACHINE="alphaev79" ;; - esac - # A Pn.n version is a patched version. - # A Vn.n version is a released version. - # A Tn.n version is a released field test version. - # A Xn.n version is an unreleased experimental baselevel. - # 1.2 uses "1.2" for uname -r. - echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` - exit ;; - Alpha\ *:Windows_NT*:*) - # How do we know it's Interix rather than the generic POSIX subsystem? - # Should we change UNAME_MACHINE based on the output of uname instead - # of the specific Alpha model? - echo alpha-pc-interix - exit ;; - 21064:Windows_NT:50:3) - echo alpha-dec-winnt3.5 - exit ;; - Amiga*:UNIX_System_V:4.0:*) - echo m68k-unknown-sysv4 - exit ;; - *:[Aa]miga[Oo][Ss]:*:*) - echo ${UNAME_MACHINE}-unknown-amigaos - exit ;; - *:[Mm]orph[Oo][Ss]:*:*) - echo ${UNAME_MACHINE}-unknown-morphos - exit ;; - *:OS/390:*:*) - echo i370-ibm-openedition - exit ;; - *:z/VM:*:*) - echo s390-ibm-zvmoe - exit ;; - *:OS400:*:*) - echo powerpc-ibm-os400 - exit ;; - arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) - echo arm-acorn-riscix${UNAME_RELEASE} - exit ;; - arm:riscos:*:*|arm:RISCOS:*:*) - echo arm-unknown-riscos - exit ;; - SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) - echo hppa1.1-hitachi-hiuxmpp - exit ;; - Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) - # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. - if test "`(/bin/universe) 2>/dev/null`" = att ; then - echo pyramid-pyramid-sysv3 - else - echo pyramid-pyramid-bsd - fi - exit ;; - NILE*:*:*:dcosx) - echo pyramid-pyramid-svr4 - exit ;; - DRS?6000:unix:4.0:6*) - echo sparc-icl-nx6 - exit ;; - DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) - case `/usr/bin/uname -p` in - sparc) echo sparc-icl-nx7; exit ;; - esac ;; - sun4H:SunOS:5.*:*) - echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` - exit ;; - sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) - echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` - exit ;; - i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) - echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` - exit ;; - sun4*:SunOS:6*:*) - # According to config.sub, this is the proper way to canonicalize - # SunOS6. Hard to guess exactly what SunOS6 will be like, but - # it's likely to be more like Solaris than SunOS4. - echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` - exit ;; - sun4*:SunOS:*:*) - case "`/usr/bin/arch -k`" in - Series*|S4*) - UNAME_RELEASE=`uname -v` - ;; - esac - # Japanese Language versions have a version number like `4.1.3-JL'. - echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` - exit ;; - sun3*:SunOS:*:*) - echo m68k-sun-sunos${UNAME_RELEASE} - exit ;; - sun*:*:4.2BSD:*) - UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` - test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 - case "`/bin/arch`" in - sun3) - echo m68k-sun-sunos${UNAME_RELEASE} - ;; - sun4) - echo sparc-sun-sunos${UNAME_RELEASE} - ;; - esac - exit ;; - aushp:SunOS:*:*) - echo sparc-auspex-sunos${UNAME_RELEASE} - exit ;; - # The situation for MiNT is a little confusing. The machine name - # can be virtually everything (everything which is not - # "atarist" or "atariste" at least should have a processor - # > m68000). The system name ranges from "MiNT" over "FreeMiNT" - # to the lowercase version "mint" (or "freemint"). Finally - # the system name "TOS" denotes a system which is actually not - # MiNT. But MiNT is downward compatible to TOS, so this should - # be no problem. - atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) - echo m68k-atari-mint${UNAME_RELEASE} - exit ;; - atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) - echo m68k-atari-mint${UNAME_RELEASE} - exit ;; - *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) - echo m68k-atari-mint${UNAME_RELEASE} - exit ;; - milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) - echo m68k-milan-mint${UNAME_RELEASE} - exit ;; - hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) - echo m68k-hades-mint${UNAME_RELEASE} - exit ;; - *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) - echo m68k-unknown-mint${UNAME_RELEASE} - exit ;; - m68k:machten:*:*) - echo m68k-apple-machten${UNAME_RELEASE} - exit ;; - powerpc:machten:*:*) - echo powerpc-apple-machten${UNAME_RELEASE} - exit ;; - RISC*:Mach:*:*) - echo mips-dec-mach_bsd4.3 - exit ;; - RISC*:ULTRIX:*:*) - echo mips-dec-ultrix${UNAME_RELEASE} - exit ;; - VAX*:ULTRIX*:*:*) - echo vax-dec-ultrix${UNAME_RELEASE} - exit ;; - 2020:CLIX:*:* | 2430:CLIX:*:*) - echo clipper-intergraph-clix${UNAME_RELEASE} - exit ;; - mips:*:*:UMIPS | mips:*:*:RISCos) - eval $set_cc_for_build - sed 's/^ //' << EOF >$dummy.c -#ifdef __cplusplus -#include /* for printf() prototype */ - int main (int argc, char *argv[]) { -#else - int main (argc, argv) int argc; char *argv[]; { -#endif - #if defined (host_mips) && defined (MIPSEB) - #if defined (SYSTYPE_SYSV) - printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); - #endif - #if defined (SYSTYPE_SVR4) - printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); - #endif - #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) - printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); - #endif - #endif - exit (-1); - } -EOF - $CC_FOR_BUILD -o $dummy $dummy.c && - dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && - SYSTEM_NAME=`$dummy $dummyarg` && - { echo "$SYSTEM_NAME"; exit; } - echo mips-mips-riscos${UNAME_RELEASE} - exit ;; - Motorola:PowerMAX_OS:*:*) - echo powerpc-motorola-powermax - exit ;; - Motorola:*:4.3:PL8-*) - echo powerpc-harris-powermax - exit ;; - Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) - echo powerpc-harris-powermax - exit ;; - Night_Hawk:Power_UNIX:*:*) - echo powerpc-harris-powerunix - exit ;; - m88k:CX/UX:7*:*) - echo m88k-harris-cxux7 - exit ;; - m88k:*:4*:R4*) - echo m88k-motorola-sysv4 - exit ;; - m88k:*:3*:R3*) - echo m88k-motorola-sysv3 - exit ;; - AViiON:dgux:*:*) - # DG/UX returns AViiON for all architectures - UNAME_PROCESSOR=`/usr/bin/uname -p` - if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] - then - if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ - [ ${TARGET_BINARY_INTERFACE}x = x ] - then - echo m88k-dg-dgux${UNAME_RELEASE} - else - echo m88k-dg-dguxbcs${UNAME_RELEASE} - fi - else - echo i586-dg-dgux${UNAME_RELEASE} - fi - exit ;; - M88*:DolphinOS:*:*) # DolphinOS (SVR3) - echo m88k-dolphin-sysv3 - exit ;; - M88*:*:R3*:*) - # Delta 88k system running SVR3 - echo m88k-motorola-sysv3 - exit ;; - XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) - echo m88k-tektronix-sysv3 - exit ;; - Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) - echo m68k-tektronix-bsd - exit ;; - *:IRIX*:*:*) - echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` - exit ;; - ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. - echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id - exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' - i*86:AIX:*:*) - echo i386-ibm-aix - exit ;; - ia64:AIX:*:*) - if [ -x /usr/bin/oslevel ] ; then - IBM_REV=`/usr/bin/oslevel` - else - IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} - fi - echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} - exit ;; - *:AIX:2:3) - if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then - eval $set_cc_for_build - sed 's/^ //' << EOF >$dummy.c - #include - - main() - { - if (!__power_pc()) - exit(1); - puts("powerpc-ibm-aix3.2.5"); - exit(0); - } -EOF - if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` - then - echo "$SYSTEM_NAME" - else - echo rs6000-ibm-aix3.2.5 - fi - elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then - echo rs6000-ibm-aix3.2.4 - else - echo rs6000-ibm-aix3.2 - fi - exit ;; - *:AIX:*:[456]) - IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` - if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then - IBM_ARCH=rs6000 - else - IBM_ARCH=powerpc - fi - if [ -x /usr/bin/oslevel ] ; then - IBM_REV=`/usr/bin/oslevel` - else - IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} - fi - echo ${IBM_ARCH}-ibm-aix${IBM_REV} - exit ;; - *:AIX:*:*) - echo rs6000-ibm-aix - exit ;; - ibmrt:4.4BSD:*|romp-ibm:BSD:*) - echo romp-ibm-bsd4.4 - exit ;; - ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and - echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to - exit ;; # report: romp-ibm BSD 4.3 - *:BOSX:*:*) - echo rs6000-bull-bosx - exit ;; - DPX/2?00:B.O.S.:*:*) - echo m68k-bull-sysv3 - exit ;; - 9000/[34]??:4.3bsd:1.*:*) - echo m68k-hp-bsd - exit ;; - hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) - echo m68k-hp-bsd4.4 - exit ;; - 9000/[34678]??:HP-UX:*:*) - HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` - case "${UNAME_MACHINE}" in - 9000/31? ) HP_ARCH=m68000 ;; - 9000/[34]?? ) HP_ARCH=m68k ;; - 9000/[678][0-9][0-9]) - if [ -x /usr/bin/getconf ]; then - sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` - sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` - case "${sc_cpu_version}" in - 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 - 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 - 532) # CPU_PA_RISC2_0 - case "${sc_kernel_bits}" in - 32) HP_ARCH="hppa2.0n" ;; - 64) HP_ARCH="hppa2.0w" ;; - '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 - esac ;; - esac - fi - if [ "${HP_ARCH}" = "" ]; then - eval $set_cc_for_build - sed 's/^ //' << EOF >$dummy.c - - #define _HPUX_SOURCE - #include - #include - - int main () - { - #if defined(_SC_KERNEL_BITS) - long bits = sysconf(_SC_KERNEL_BITS); - #endif - long cpu = sysconf (_SC_CPU_VERSION); - - switch (cpu) - { - case CPU_PA_RISC1_0: puts ("hppa1.0"); break; - case CPU_PA_RISC1_1: puts ("hppa1.1"); break; - case CPU_PA_RISC2_0: - #if defined(_SC_KERNEL_BITS) - switch (bits) - { - case 64: puts ("hppa2.0w"); break; - case 32: puts ("hppa2.0n"); break; - default: puts ("hppa2.0"); break; - } break; - #else /* !defined(_SC_KERNEL_BITS) */ - puts ("hppa2.0"); break; - #endif - default: puts ("hppa1.0"); break; - } - exit (0); - } -EOF - (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` - test -z "$HP_ARCH" && HP_ARCH=hppa - fi ;; - esac - if [ ${HP_ARCH} = "hppa2.0w" ] - then - eval $set_cc_for_build - - # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating - # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler - # generating 64-bit code. GNU and HP use different nomenclature: - # - # $ CC_FOR_BUILD=cc ./config.guess - # => hppa2.0w-hp-hpux11.23 - # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess - # => hppa64-hp-hpux11.23 - - if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | - grep __LP64__ >/dev/null - then - HP_ARCH="hppa2.0w" - else - HP_ARCH="hppa64" - fi - fi - echo ${HP_ARCH}-hp-hpux${HPUX_REV} - exit ;; - ia64:HP-UX:*:*) - HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` - echo ia64-hp-hpux${HPUX_REV} - exit ;; - 3050*:HI-UX:*:*) - eval $set_cc_for_build - sed 's/^ //' << EOF >$dummy.c - #include - int - main () - { - long cpu = sysconf (_SC_CPU_VERSION); - /* The order matters, because CPU_IS_HP_MC68K erroneously returns - true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct - results, however. */ - if (CPU_IS_PA_RISC (cpu)) - { - switch (cpu) - { - case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; - case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; - case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; - default: puts ("hppa-hitachi-hiuxwe2"); break; - } - } - else if (CPU_IS_HP_MC68K (cpu)) - puts ("m68k-hitachi-hiuxwe2"); - else puts ("unknown-hitachi-hiuxwe2"); - exit (0); - } -EOF - $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && - { echo "$SYSTEM_NAME"; exit; } - echo unknown-hitachi-hiuxwe2 - exit ;; - 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) - echo hppa1.1-hp-bsd - exit ;; - 9000/8??:4.3bsd:*:*) - echo hppa1.0-hp-bsd - exit ;; - *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) - echo hppa1.0-hp-mpeix - exit ;; - hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) - echo hppa1.1-hp-osf - exit ;; - hp8??:OSF1:*:*) - echo hppa1.0-hp-osf - exit ;; - i*86:OSF1:*:*) - if [ -x /usr/sbin/sysversion ] ; then - echo ${UNAME_MACHINE}-unknown-osf1mk - else - echo ${UNAME_MACHINE}-unknown-osf1 - fi - exit ;; - parisc*:Lites*:*:*) - echo hppa1.1-hp-lites - exit ;; - C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) - echo c1-convex-bsd - exit ;; - C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) - if getsysinfo -f scalar_acc - then echo c32-convex-bsd - else echo c2-convex-bsd - fi - exit ;; - C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) - echo c34-convex-bsd - exit ;; - C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) - echo c38-convex-bsd - exit ;; - C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) - echo c4-convex-bsd - exit ;; - CRAY*Y-MP:*:*:*) - echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' - exit ;; - CRAY*[A-Z]90:*:*:*) - echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ - | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ - -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ - -e 's/\.[^.]*$/.X/' - exit ;; - CRAY*TS:*:*:*) - echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' - exit ;; - CRAY*T3E:*:*:*) - echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' - exit ;; - CRAY*SV1:*:*:*) - echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' - exit ;; - *:UNICOS/mp:*:*) - echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' - exit ;; - F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) - FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` - FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` - FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` - echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" - exit ;; - 5000:UNIX_System_V:4.*:*) - FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` - FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` - echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" - exit ;; - i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) - echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} - exit ;; - sparc*:BSD/OS:*:*) - echo sparc-unknown-bsdi${UNAME_RELEASE} - exit ;; - *:BSD/OS:*:*) - echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} - exit ;; - *:FreeBSD:*:*) - case ${UNAME_MACHINE} in - pc98) - echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; - amd64) - echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; - *) - echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; - esac - exit ;; - i*:CYGWIN*:*) - echo ${UNAME_MACHINE}-pc-cygwin - exit ;; - *:MINGW*:*) - echo ${UNAME_MACHINE}-pc-mingw32 - exit ;; - i*:windows32*:*) - # uname -m includes "-pc" on this system. - echo ${UNAME_MACHINE}-mingw32 - exit ;; - i*:PW*:*) - echo ${UNAME_MACHINE}-pc-pw32 - exit ;; - *:Interix*:[3456]*) - case ${UNAME_MACHINE} in - x86) - echo i586-pc-interix${UNAME_RELEASE} - exit ;; - EM64T | authenticamd) - echo x86_64-unknown-interix${UNAME_RELEASE} - exit ;; - IA64) - echo ia64-unknown-interix${UNAME_RELEASE} - exit ;; - esac ;; - [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) - echo i${UNAME_MACHINE}-pc-mks - exit ;; - i*:Windows_NT*:* | Pentium*:Windows_NT*:*) - # How do we know it's Interix rather than the generic POSIX subsystem? - # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we - # UNAME_MACHINE based on the output of uname instead of i386? - echo i586-pc-interix - exit ;; - i*:UWIN*:*) - echo ${UNAME_MACHINE}-pc-uwin - exit ;; - amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) - echo x86_64-unknown-cygwin - exit ;; - p*:CYGWIN*:*) - echo powerpcle-unknown-cygwin - exit ;; - prep*:SunOS:5.*:*) - echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` - exit ;; - *:GNU:*:*) - # the GNU system - echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` - exit ;; - *:GNU/*:*:*) - # other systems with GNU libc and userland - echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu - exit ;; - i*86:Minix:*:*) - echo ${UNAME_MACHINE}-pc-minix - exit ;; - arm*:Linux:*:*) - eval $set_cc_for_build - if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ - | grep -q __ARM_EABI__ - then - echo ${UNAME_MACHINE}-unknown-linux-gnu - else - echo ${UNAME_MACHINE}-unknown-linux-gnueabi - fi - exit ;; - avr32*:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu - exit ;; - cris:Linux:*:*) - echo cris-axis-linux-gnu - exit ;; - crisv32:Linux:*:*) - echo crisv32-axis-linux-gnu - exit ;; - frv:Linux:*:*) - echo frv-unknown-linux-gnu - exit ;; - ia64:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu - exit ;; - m32r*:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu - exit ;; - m68*:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu - exit ;; - mips:Linux:*:*) - eval $set_cc_for_build - sed 's/^ //' << EOF >$dummy.c - #undef CPU - #undef mips - #undef mipsel - #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) - CPU=mipsel - #else - #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) - CPU=mips - #else - CPU= - #endif - #endif -EOF - eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' - /^CPU/{ - s: ::g - p - }'`" - test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } - ;; - mips64:Linux:*:*) - eval $set_cc_for_build - sed 's/^ //' << EOF >$dummy.c - #undef CPU - #undef mips64 - #undef mips64el - #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) - CPU=mips64el - #else - #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) - CPU=mips64 - #else - CPU= - #endif - #endif -EOF - eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' - /^CPU/{ - s: ::g - p - }'`" - test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } - ;; - or32:Linux:*:*) - echo or32-unknown-linux-gnu - exit ;; - ppc:Linux:*:*) - echo powerpc-unknown-linux-gnu - exit ;; - ppc64:Linux:*:*) - echo powerpc64-unknown-linux-gnu - exit ;; - alpha:Linux:*:*) - case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in - EV5) UNAME_MACHINE=alphaev5 ;; - EV56) UNAME_MACHINE=alphaev56 ;; - PCA56) UNAME_MACHINE=alphapca56 ;; - PCA57) UNAME_MACHINE=alphapca56 ;; - EV6) UNAME_MACHINE=alphaev6 ;; - EV67) UNAME_MACHINE=alphaev67 ;; - EV68*) UNAME_MACHINE=alphaev68 ;; - esac - objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null - if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi - echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} - exit ;; - parisc:Linux:*:* | hppa:Linux:*:*) - # Look for CPU level - case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in - PA7*) echo hppa1.1-unknown-linux-gnu ;; - PA8*) echo hppa2.0-unknown-linux-gnu ;; - *) echo hppa-unknown-linux-gnu ;; - esac - exit ;; - parisc64:Linux:*:* | hppa64:Linux:*:*) - echo hppa64-unknown-linux-gnu - exit ;; - s390:Linux:*:* | s390x:Linux:*:*) - echo ${UNAME_MACHINE}-ibm-linux - exit ;; - sh64*:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu - exit ;; - sh*:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu - exit ;; - sparc:Linux:*:* | sparc64:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu - exit ;; - vax:Linux:*:*) - echo ${UNAME_MACHINE}-dec-linux-gnu - exit ;; - x86_64:Linux:*:*) - echo x86_64-unknown-linux-gnu - exit ;; - xtensa*:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu - exit ;; - i*86:Linux:*:*) - # The BFD linker knows what the default object file format is, so - # first see if it will tell us. cd to the root directory to prevent - # problems with other programs or directories called `ld' in the path. - # Set LC_ALL=C to ensure ld outputs messages in English. - ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \ - | sed -ne '/supported targets:/!d - s/[ ][ ]*/ /g - s/.*supported targets: *// - s/ .*// - p'` - case "$ld_supported_targets" in - elf32-i386) - TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu" - ;; - a.out-i386-linux) - echo "${UNAME_MACHINE}-pc-linux-gnuaout" - exit ;; - coff-i386) - echo "${UNAME_MACHINE}-pc-linux-gnucoff" - exit ;; - "") - # Either a pre-BFD a.out linker (linux-gnuoldld) or - # one that does not give us useful --help. - echo "${UNAME_MACHINE}-pc-linux-gnuoldld" - exit ;; - esac - # Determine whether the default compiler is a.out or elf - eval $set_cc_for_build - sed 's/^ //' << EOF >$dummy.c - #include - #ifdef __ELF__ - # ifdef __GLIBC__ - # if __GLIBC__ >= 2 - LIBC=gnu - # else - LIBC=gnulibc1 - # endif - # else - LIBC=gnulibc1 - # endif - #else - #if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__SUNPRO_C) || defined(__SUNPRO_CC) - LIBC=gnu - #else - LIBC=gnuaout - #endif - #endif - #ifdef __dietlibc__ - LIBC=dietlibc - #endif -EOF - eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' - /^LIBC/{ - s: ::g - p - }'`" - test x"${LIBC}" != x && { - echo "${UNAME_MACHINE}-pc-linux-${LIBC}" - exit - } - test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; } - ;; - i*86:DYNIX/ptx:4*:*) - # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. - # earlier versions are messed up and put the nodename in both - # sysname and nodename. - echo i386-sequent-sysv4 - exit ;; - i*86:UNIX_SV:4.2MP:2.*) - # Unixware is an offshoot of SVR4, but it has its own version - # number series starting with 2... - # I am not positive that other SVR4 systems won't match this, - # I just have to hope. -- rms. - # Use sysv4.2uw... so that sysv4* matches it. - echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} - exit ;; - i*86:OS/2:*:*) - # If we were able to find `uname', then EMX Unix compatibility - # is probably installed. - echo ${UNAME_MACHINE}-pc-os2-emx - exit ;; - i*86:XTS-300:*:STOP) - echo ${UNAME_MACHINE}-unknown-stop - exit ;; - i*86:atheos:*:*) - echo ${UNAME_MACHINE}-unknown-atheos - exit ;; - i*86:syllable:*:*) - echo ${UNAME_MACHINE}-pc-syllable - exit ;; - i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*) - echo i386-unknown-lynxos${UNAME_RELEASE} - exit ;; - i*86:*DOS:*:*) - echo ${UNAME_MACHINE}-pc-msdosdjgpp - exit ;; - i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) - UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` - if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then - echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} - else - echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} - fi - exit ;; - i*86:*:5:[678]*) - # UnixWare 7.x, OpenUNIX and OpenServer 6. - case `/bin/uname -X | grep "^Machine"` in - *486*) UNAME_MACHINE=i486 ;; - *Pentium) UNAME_MACHINE=i586 ;; - *Pent*|*Celeron) UNAME_MACHINE=i686 ;; - esac - echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} - exit ;; - i*86:*:3.2:*) - if test -f /usr/options/cb.name; then - UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then - UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` - (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 - (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ - && UNAME_MACHINE=i586 - (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ - && UNAME_MACHINE=i686 - (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ - && UNAME_MACHINE=i686 - echo ${UNAME_MACHINE}-pc-sco$UNAME_REL - else - echo ${UNAME_MACHINE}-pc-sysv32 - fi - exit ;; - pc:*:*:*) - # Left here for compatibility: - # uname -m prints for DJGPP always 'pc', but it prints nothing about - # the processor, so we play safe by assuming i386. - echo i386-pc-msdosdjgpp - exit ;; - Intel:Mach:3*:*) - echo i386-pc-mach3 - exit ;; - paragon:*:*:*) - echo i860-intel-osf1 - exit ;; - i860:*:4.*:*) # i860-SVR4 - if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then - echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 - else # Add other i860-SVR4 vendors below as they are discovered. - echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 - fi - exit ;; - mini*:CTIX:SYS*5:*) - # "miniframe" - echo m68010-convergent-sysv - exit ;; - mc68k:UNIX:SYSTEM5:3.51m) - echo m68k-convergent-sysv - exit ;; - M680?0:D-NIX:5.3:*) - echo m68k-diab-dnix - exit ;; - M68*:*:R3V[5678]*:*) - test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; - 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) - OS_REL='' - test -r /etc/.relid \ - && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` - /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ - && { echo i486-ncr-sysv4.3${OS_REL}; exit; } - /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ - && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; - 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) - /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ - && { echo i486-ncr-sysv4; exit; } ;; - m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) - echo m68k-unknown-lynxos${UNAME_RELEASE} - exit ;; - mc68030:UNIX_System_V:4.*:*) - echo m68k-atari-sysv4 - exit ;; - TSUNAMI:LynxOS:2.*:*) - echo sparc-unknown-lynxos${UNAME_RELEASE} - exit ;; - rs6000:LynxOS:2.*:*) - echo rs6000-unknown-lynxos${UNAME_RELEASE} - exit ;; - PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*) - echo powerpc-unknown-lynxos${UNAME_RELEASE} - exit ;; - SM[BE]S:UNIX_SV:*:*) - echo mips-dde-sysv${UNAME_RELEASE} - exit ;; - RM*:ReliantUNIX-*:*:*) - echo mips-sni-sysv4 - exit ;; - RM*:SINIX-*:*:*) - echo mips-sni-sysv4 - exit ;; - *:SINIX-*:*:*) - if uname -p 2>/dev/null >/dev/null ; then - UNAME_MACHINE=`(uname -p) 2>/dev/null` - echo ${UNAME_MACHINE}-sni-sysv4 - else - echo ns32k-sni-sysv - fi - exit ;; - PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort - # says - echo i586-unisys-sysv4 - exit ;; - *:UNIX_System_V:4*:FTX*) - # From Gerald Hewes . - # How about differentiating between stratus architectures? -djm - echo hppa1.1-stratus-sysv4 - exit ;; - *:*:*:FTX*) - # From seanf@swdc.stratus.com. - echo i860-stratus-sysv4 - exit ;; - i*86:VOS:*:*) - # From Paul.Green@stratus.com. - echo ${UNAME_MACHINE}-stratus-vos - exit ;; - *:VOS:*:*) - # From Paul.Green@stratus.com. - echo hppa1.1-stratus-vos - exit ;; - mc68*:A/UX:*:*) - echo m68k-apple-aux${UNAME_RELEASE} - exit ;; - news*:NEWS-OS:6*:*) - echo mips-sony-newsos6 - exit ;; - R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) - if [ -d /usr/nec ]; then - echo mips-nec-sysv${UNAME_RELEASE} - else - echo mips-unknown-sysv${UNAME_RELEASE} - fi - exit ;; - BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. - echo powerpc-be-beos - exit ;; - BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. - echo powerpc-apple-beos - exit ;; - BePC:BeOS:*:*) # BeOS running on Intel PC compatible. - echo i586-pc-beos - exit ;; - SX-4:SUPER-UX:*:*) - echo sx4-nec-superux${UNAME_RELEASE} - exit ;; - SX-5:SUPER-UX:*:*) - echo sx5-nec-superux${UNAME_RELEASE} - exit ;; - SX-6:SUPER-UX:*:*) - echo sx6-nec-superux${UNAME_RELEASE} - exit ;; - SX-7:SUPER-UX:*:*) - echo sx7-nec-superux${UNAME_RELEASE} - exit ;; - SX-8:SUPER-UX:*:*) - echo sx8-nec-superux${UNAME_RELEASE} - exit ;; - SX-8R:SUPER-UX:*:*) - echo sx8r-nec-superux${UNAME_RELEASE} - exit ;; - Power*:Rhapsody:*:*) - echo powerpc-apple-rhapsody${UNAME_RELEASE} - exit ;; - *:Rhapsody:*:*) - echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} - exit ;; - *:Darwin:*:*) - UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown - eval $set_cc_for_build - echo "int main(){}" > $dummy.c - if test "`$CC_FOR_BUILD -o $dummy $dummy.c; file $dummy | grep -c x86_64`" = 1 ; then - UNAME_PROCESSOR=x86_64 - fi - case $UNAME_PROCESSOR in - unknown) UNAME_PROCESSOR=powerpc ;; - esac - echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} - exit ;; - *:procnto*:*:* | *:QNX:[0123456789]*:*) - UNAME_PROCESSOR=`uname -p` - if test "$UNAME_PROCESSOR" = "x86"; then - UNAME_PROCESSOR=i386 - UNAME_MACHINE=pc - fi - echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} - exit ;; - *:QNX:*:4*) - echo i386-pc-qnx - exit ;; - NSE-?:NONSTOP_KERNEL:*:*) - echo nse-tandem-nsk${UNAME_RELEASE} - exit ;; - NSR-?:NONSTOP_KERNEL:*:*) - echo nsr-tandem-nsk${UNAME_RELEASE} - exit ;; - *:NonStop-UX:*:*) - echo mips-compaq-nonstopux - exit ;; - BS2000:POSIX*:*:*) - echo bs2000-siemens-sysv - exit ;; - DS/*:UNIX_System_V:*:*) - echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} - exit ;; - *:Plan9:*:*) - # "uname -m" is not consistent, so use $cputype instead. 386 - # is converted to i386 for consistency with other x86 - # operating systems. - if test "$cputype" = "386"; then - UNAME_MACHINE=i386 - else - UNAME_MACHINE="$cputype" - fi - echo ${UNAME_MACHINE}-unknown-plan9 - exit ;; - *:TOPS-10:*:*) - echo pdp10-unknown-tops10 - exit ;; - *:TENEX:*:*) - echo pdp10-unknown-tenex - exit ;; - KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) - echo pdp10-dec-tops20 - exit ;; - XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) - echo pdp10-xkl-tops20 - exit ;; - *:TOPS-20:*:*) - echo pdp10-unknown-tops20 - exit ;; - *:ITS:*:*) - echo pdp10-unknown-its - exit ;; - SEI:*:*:SEIUX) - echo mips-sei-seiux${UNAME_RELEASE} - exit ;; - *:DragonFly:*:*) - echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` - exit ;; - *:*VMS:*:*) - UNAME_MACHINE=`(uname -p) 2>/dev/null` - case "${UNAME_MACHINE}" in - A*) echo alpha-dec-vms ; exit ;; - I*) echo ia64-dec-vms ; exit ;; - V*) echo vax-dec-vms ; exit ;; - esac ;; - *:XENIX:*:SysV) - echo i386-pc-xenix - exit ;; - i*86:skyos:*:*) - echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' - exit ;; - i*86:rdos:*:*) - echo ${UNAME_MACHINE}-pc-rdos - exit ;; -esac - -#echo '(No uname command or uname output not recognized.)' 1>&2 -#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 - -eval $set_cc_for_build -cat >$dummy.c < -# include -#endif -main () -{ -#if defined (sony) -#if defined (MIPSEB) - /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, - I don't know.... */ - printf ("mips-sony-bsd\n"); exit (0); -#else -#include - printf ("m68k-sony-newsos%s\n", -#ifdef NEWSOS4 - "4" -#else - "" -#endif - ); exit (0); -#endif -#endif - -#if defined (__arm) && defined (__acorn) && defined (__unix) - printf ("arm-acorn-riscix\n"); exit (0); -#endif - -#if defined (hp300) && !defined (hpux) - printf ("m68k-hp-bsd\n"); exit (0); -#endif - -#if defined (NeXT) -#if !defined (__ARCHITECTURE__) -#define __ARCHITECTURE__ "m68k" -#endif - int version; - version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; - if (version < 4) - printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); - else - printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); - exit (0); -#endif - -#if defined (MULTIMAX) || defined (n16) -#if defined (UMAXV) - printf ("ns32k-encore-sysv\n"); exit (0); -#else -#if defined (CMU) - printf ("ns32k-encore-mach\n"); exit (0); -#else - printf ("ns32k-encore-bsd\n"); exit (0); -#endif -#endif -#endif - -#if defined (__386BSD__) - printf ("i386-pc-bsd\n"); exit (0); -#endif - -#if defined (sequent) -#if defined (i386) - printf ("i386-sequent-dynix\n"); exit (0); -#endif -#if defined (ns32000) - printf ("ns32k-sequent-dynix\n"); exit (0); -#endif -#endif - -#if defined (_SEQUENT_) - struct utsname un; - - uname(&un); - - if (strncmp(un.version, "V2", 2) == 0) { - printf ("i386-sequent-ptx2\n"); exit (0); - } - if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ - printf ("i386-sequent-ptx1\n"); exit (0); - } - printf ("i386-sequent-ptx\n"); exit (0); - -#endif - -#if defined (vax) -# if !defined (ultrix) -# include -# if defined (BSD) -# if BSD == 43 - printf ("vax-dec-bsd4.3\n"); exit (0); -# else -# if BSD == 199006 - printf ("vax-dec-bsd4.3reno\n"); exit (0); -# else - printf ("vax-dec-bsd\n"); exit (0); -# endif -# endif -# else - printf ("vax-dec-bsd\n"); exit (0); -# endif -# else - printf ("vax-dec-ultrix\n"); exit (0); -# endif -#endif - -#if defined (alliant) && defined (i860) - printf ("i860-alliant-bsd\n"); exit (0); -#endif - - exit (1); -} -EOF - -$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && - { echo "$SYSTEM_NAME"; exit; } - -# Apollos put the system type in the environment. - -test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } - -# Convex versions that predate uname can use getsysinfo(1) - -if [ -x /usr/convex/getsysinfo ] -then - case `getsysinfo -f cpu_type` in - c1*) - echo c1-convex-bsd - exit ;; - c2*) - if getsysinfo -f scalar_acc - then echo c32-convex-bsd - else echo c2-convex-bsd - fi - exit ;; - c34*) - echo c34-convex-bsd - exit ;; - c38*) - echo c38-convex-bsd - exit ;; - c4*) - echo c4-convex-bsd - exit ;; - esac -fi - -cat >&2 < in order to provide the needed -information to handle your system. - -config.guess timestamp = $timestamp - -uname -m = `(uname -m) 2>/dev/null || echo unknown` -uname -r = `(uname -r) 2>/dev/null || echo unknown` -uname -s = `(uname -s) 2>/dev/null || echo unknown` -uname -v = `(uname -v) 2>/dev/null || echo unknown` - -/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` -/bin/uname -X = `(/bin/uname -X) 2>/dev/null` - -hostinfo = `(hostinfo) 2>/dev/null` -/bin/universe = `(/bin/universe) 2>/dev/null` -/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` -/bin/arch = `(/bin/arch) 2>/dev/null` -/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` -/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` - -UNAME_MACHINE = ${UNAME_MACHINE} -UNAME_RELEASE = ${UNAME_RELEASE} -UNAME_SYSTEM = ${UNAME_SYSTEM} -UNAME_VERSION = ${UNAME_VERSION} -EOF - -exit 1 - -# Local variables: -# eval: (add-hook 'write-file-hooks 'time-stamp) -# time-stamp-start: "timestamp='" -# time-stamp-format: "%:y-%02m-%02d" -# time-stamp-end: "'" -# End: +echo $OUT diff --git a/common/autoconf/builddeps.conf.example b/common/autoconf/builddeps.conf.example index f285ffb4a29..d97033611f7 100644 --- a/common/autoconf/builddeps.conf.example +++ b/common/autoconf/builddeps.conf.example @@ -31,11 +31,11 @@ # Translate a configuration triplet/quadruplet into something # known by this configuration file. -# If no rewrite was found, then rewritten_host=${host} +# If no rewrite was found, then rewritten_target=${OPENJDK_TARGET_SYSTEM} REWRITE_i686_pc_linux_gnu=i686-unknown-linux-gnu REWRITE_i386_pc_solaris2_10=i686-sun-solaris2_10 -# The needed cups builddeps are host independent header files. +# The needed cups builddeps are platform independent header files. # I.e. they need not be part of the devkit. builddep_cups=lib/cups_1_3_9.zip builddep_cups_CFLAGS=-I${depdir} @@ -44,10 +44,10 @@ builddep_cups_CFLAGS=-I${depdir} # for the build platform. builddep_devkit=sdk/sdk-${rewritten_build}-20110921.tar.gz -# The freetype dependency is partyl host dependent. +# The freetype dependency is partly platform dependent. # It is stored inside the sys-root. builddep_freetype2=sdk/sdk-${rewritten_build}-20110921.tar.gz -builddep_freetype2_CFLAGS=-I${depdir}/${rewritten_host}/sys-root/usr/include/freetype2 +builddep_freetype2_CFLAGS=-I${depdir}/${rewritten_target}/sys-root/usr/include/freetype2 builddep_freetype2_LIBS=-lfreetype # There are many other build dependencies, but they are implicitly diff --git a/common/autoconf/builddeps.m4 b/common/autoconf/builddeps.m4 index 1be92ecf870..31797070da1 100644 --- a/common/autoconf/builddeps.m4 +++ b/common/autoconf/builddeps.m4 @@ -23,7 +23,7 @@ # questions. # -AC_DEFUN([BDEPS_SCAN_FOR_BUILDDEPS], +AC_DEFUN_ONCE([BDEPS_SCAN_FOR_BUILDDEPS], [ define(LIST_OF_BUILD_DEPENDENCIES,) if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then @@ -50,27 +50,27 @@ AC_DEFUN([BDEPS_SCAN_FOR_BUILDDEPS], AC_MSG_ERROR([Could not find any builddeps.conf at all!]) fi fi - # Create build and host names that use _ instead of "-" and ".". + # Create build and target names that use _ instead of "-" and ".". # This is necessary to use them in variable names. - build_var=`echo ${build} | tr '-' '_' | tr '.' '_'` - host_var=`echo ${host} | tr '-' '_' | tr '.' '_'` - # Extract rewrite information for build and host + build_var=`echo ${OPENJDK_BUILD_SYSTEM} | tr '-' '_' | tr '.' '_'` + target_var=`echo ${OPENJDK_TARGET_SYSTEM} | tr '-' '_' | tr '.' '_'` + # Extract rewrite information for build and target eval rewritten_build=\${REWRITE_${build_var}} if test "x$rewritten_build" = x; then - rewritten_build=${build} + rewritten_build=${OPENJDK_BUILD_SYSTEM} echo Build stays the same $rewritten_build else echo Rewriting build for builddeps into $rewritten_build fi - eval rewritten_host=\${REWRITE_${host_var}} - if test "x$rewritten_host" = x; then - rewritten_host=${host} - echo Host stays the same $rewritten_host + eval rewritten_target=\${REWRITE_${target_var}} + if test "x$rewritten_target" = x; then + rewritten_target=${OPENJDK_TARGET_SYSTEM} + echo Target stays the same $rewritten_target else - echo Rewriting host for builddeps into $rewritten_host + echo Rewriting target for builddeps into $rewritten_target fi rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'` - rewritten_host_var=`echo ${rewritten_host} | tr '-' '_' | tr '.' '_'` + rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'` fi AC_CHECK_PROGS(BDEPS_UNZIP, [7z unzip]) if test "x$BDEPS_UNZIP" = x7z; then @@ -127,11 +127,11 @@ AC_DEFUN([BDEPS_CHECK_MODULE], if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then # Source the builddeps file again, to make sure it uses the latest variables! . $builddepsfile - # Look for a host and build machine specific resource! - eval resource=\${builddep_$2_BUILD_${rewritten_build_var}_HOST_${rewritten_host_var}} + # Look for a target and build machine specific resource! + eval resource=\${builddep_$2_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}} if test "x$resource" = x; then - # Ok, lets instead look for a host specific resource - eval resource=\${builddep_$2_HOST_${rewritten_host_var}} + # Ok, lets instead look for a target specific resource + eval resource=\${builddep_$2_TARGET_${rewritten_target_var}} fi if test "x$resource" = x; then # Ok, lets instead look for a build specific resource @@ -228,3 +228,33 @@ AC_DEFUN([BDEPS_FETCH], $5=$installdir fi ]) + +AC_DEFUN_ONCE([BDEPS_CONFIGURE_BUILDDEPS], +[ +AC_ARG_WITH(builddeps-conf, [AS_HELP_STRING([--with-builddeps-conf], + [use this configuration file for the builddeps])]) + +AC_ARG_WITH(builddeps-server, [AS_HELP_STRING([--with-builddeps-server], + [download and use build dependencies from this server url, e.g. --with-builddeps-server=ftp://example.com/dir])]) + +AC_ARG_WITH(builddeps-dir, [AS_HELP_STRING([--with-builddeps-dir], + [store downloaded build dependencies here @<:@d/localhome/builddeps@:>@])], + [], + [with_builddeps_dir=/localhome/builddeps]) + +AC_ARG_WITH(builddeps-group, [AS_HELP_STRING([--with-builddeps-group], + [chgrp the downloaded build dependencies to this group])]) + +AC_ARG_ENABLE([list-builddeps], [AS_HELP_STRING([--enable-list-builddeps], + [list all build dependencies known to the configure script])], + [LIST_BUILDDEPS="${enableval}"], [LIST_BUILDDEPS='no']) + +if test "x$LIST_BUILDDEPS" = xyes; then + echo + echo List of build dependencies known to the configure script, + echo that can be used in builddeps.conf files: + cat $AUTOCONF_DIR/*.ac $AUTOCONF_DIR/*.m4 | grep BDEPS_CHECK_MODUL[E]\( | cut -f 2 -d ',' | tr -d ' ' | sort + echo + exit 1 +fi +]) diff --git a/common/autoconf/configure b/common/autoconf/configure index 68f93765ea6..85861c9ce1b 100644 --- a/common/autoconf/configure +++ b/common/autoconf/configure @@ -1,16781 +1,121 @@ -#! /bin/sh -# Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.67 for openjdk version-0.1. -# -# Report bugs to . -# -# -# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, -# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software -# Foundation, Inc. -# -# -# This configure script is free software; the Free Software Foundation -# gives unlimited permission to copy, distribute and modify it. -## -------------------- ## -## M4sh Initialization. ## -## -------------------- ## +#!/bin/sh -# Be more Bourne compatible -DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : - emulate sh - NULLCMD=: - # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in #( - *posix*) : - set -o posix ;; #( - *) : - ;; -esac -fi - - -as_nl=' -' -export as_nl -# Printing a long string crashes Solaris 7 /usr/bin/printf. -as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo -# Prefer a ksh shell builtin over an external printf program on Solaris, -# but without wasting forks for bash or zsh. -if test -z "$BASH_VERSION$ZSH_VERSION" \ - && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='print -r --' - as_echo_n='print -rn --' -elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='printf %s\n' - as_echo_n='printf %s' -else - if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then - as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' - as_echo_n='/usr/ucb/echo -n' - else - as_echo_body='eval expr "X$1" : "X\\(.*\\)"' - as_echo_n_body='eval - arg=$1; - case $arg in #( - *"$as_nl"*) - expr "X$arg" : "X\\(.*\\)$as_nl"; - arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; - esac; - expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" - ' - export as_echo_n_body - as_echo_n='sh -c $as_echo_n_body as_echo' - fi - export as_echo_body - as_echo='sh -c $as_echo_body as_echo' -fi - -# The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then - PATH_SEPARATOR=: - (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { - (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || - PATH_SEPARATOR=';' - } -fi - - -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -IFS=" "" $as_nl" - -# Find who we are. Look in the path if we contain no directory separator. -case $0 in #(( - *[\\/]* ) as_myself=$0 ;; - *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break - done -IFS=$as_save_IFS - - ;; -esac -# We did not find ourselves, most probably we were run as `sh COMMAND' -# in which case we are not to be found in the path. -if test "x$as_myself" = x; then - as_myself=$0 -fi -if test ! -f "$as_myself"; then - $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 - exit 1 -fi - -# Unset variables that we do not need and which cause bugs (e.g. in -# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" -# suppresses any "Segmentation fault" message there. '((' could -# trigger a bug in pdksh 5.2.14. -for as_var in BASH_ENV ENV MAIL MAILPATH -do eval test x\${$as_var+set} = xset \ - && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -LC_ALL=C -export LC_ALL -LANGUAGE=C -export LANGUAGE - -# CDPATH. -(unset CDPATH) >/dev/null 2>&1 && unset CDPATH - -if test "x$CONFIG_SHELL" = x; then - as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : - emulate sh - NULLCMD=: - # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which - # is contrary to our usage. Disable this feature. - alias -g '\${1+\"\$@\"}'='\"\$@\"' - setopt NO_GLOB_SUBST -else - case \`(set -o) 2>/dev/null\` in #( - *posix*) : - set -o posix ;; #( - *) : - ;; -esac -fi -" - as_required="as_fn_return () { (exit \$1); } -as_fn_success () { as_fn_return 0; } -as_fn_failure () { as_fn_return 1; } -as_fn_ret_success () { return 0; } -as_fn_ret_failure () { return 1; } - -exitcode=0 -as_fn_success || { exitcode=1; echo as_fn_success failed.; } -as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } -as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } -as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } -if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : - -else - exitcode=1; echo positional parameters were not saved. -fi -test x\$exitcode = x0 || exit 1" - as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO - as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO - eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && - test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 -test \$(( 1 + 1 )) = 2 || exit 1" - if (eval "$as_required") 2>/dev/null; then : - as_have_required=yes -else - as_have_required=no -fi - if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : - -else - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -as_found=false -for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - as_found=: - case $as_dir in #( - /*) - for as_base in sh bash ksh sh5; do - # Try only shells that exist, to save several forks. - as_shell=$as_dir/$as_base - if { test -f "$as_shell" || test -f "$as_shell.exe"; } && - { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : - CONFIG_SHELL=$as_shell as_have_required=yes - if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : - break 2 -fi -fi - done;; - esac - as_found=false -done -$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && - { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : - CONFIG_SHELL=$SHELL as_have_required=yes -fi; } -IFS=$as_save_IFS - - - if test "x$CONFIG_SHELL" != x; then : - # We cannot yet assume a decent shell, so we have to provide a - # neutralization value for shells without unset; and this also - # works around shells that cannot unset nonexistent variables. - BASH_ENV=/dev/null - ENV=/dev/null - (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV - export CONFIG_SHELL - exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} -fi - - if test x$as_have_required = xno; then : - $as_echo "$0: This script requires a shell more modern than all" - $as_echo "$0: the shells that I found on your system." - if test x${ZSH_VERSION+set} = xset ; then - $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" - $as_echo "$0: be upgraded to zsh 4.3.4 or later." - else - $as_echo "$0: Please tell bug-autoconf@gnu.org and -$0: build-infra-dev@openjdk.java.net about your system, -$0: including any error possibly output before this -$0: message. Then install a modern shell, or manually run -$0: the script under such a shell if you do have one." - fi - exit 1 -fi -fi -fi -SHELL=${CONFIG_SHELL-/bin/sh} -export SHELL -# Unset more variables known to interfere with behavior of common tools. -CLICOLOR_FORCE= GREP_OPTIONS= -unset CLICOLOR_FORCE GREP_OPTIONS - -## --------------------- ## -## M4sh Shell Functions. ## -## --------------------- ## -# as_fn_unset VAR -# --------------- -# Portably unset VAR. -as_fn_unset () -{ - { eval $1=; unset $1;} -} -as_unset=as_fn_unset - -# as_fn_set_status STATUS -# ----------------------- -# Set $? to STATUS, without forking. -as_fn_set_status () -{ - return $1 -} # as_fn_set_status - -# as_fn_exit STATUS -# ----------------- -# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. -as_fn_exit () -{ - set +e - as_fn_set_status $1 - exit $1 -} # as_fn_exit - -# as_fn_mkdir_p -# ------------- -# Create "$as_dir" as a directory, including parents if necessary. -as_fn_mkdir_p () -{ - - case $as_dir in #( - -*) as_dir=./$as_dir;; - esac - test -d "$as_dir" || eval $as_mkdir_p || { - as_dirs= - while :; do - case $as_dir in #( - *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( - *) as_qdir=$as_dir;; - esac - as_dirs="'$as_qdir' $as_dirs" - as_dir=`$as_dirname -- "$as_dir" || -$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$as_dir" : 'X\(//\)[^/]' \| \ - X"$as_dir" : 'X\(//\)$' \| \ - X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_dir" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - test -d "$as_dir" && break - done - test -z "$as_dirs" || eval "mkdir $as_dirs" - } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" - - -} # as_fn_mkdir_p -# as_fn_append VAR VALUE -# ---------------------- -# Append the text in VALUE to the end of the definition contained in VAR. Take -# advantage of any shell optimizations that allow amortized linear growth over -# repeated appends, instead of the typical quadratic growth present in naive -# implementations. -if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : - eval 'as_fn_append () - { - eval $1+=\$2 - }' -else - as_fn_append () - { - eval $1=\$$1\$2 - } -fi # as_fn_append - -# as_fn_arith ARG... -# ------------------ -# Perform arithmetic evaluation on the ARGs, and store the result in the -# global $as_val. Take advantage of shells that can avoid forks. The arguments -# must be portable across $(()) and expr. -if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : - eval 'as_fn_arith () - { - as_val=$(( $* )) - }' -else - as_fn_arith () - { - as_val=`expr "$@" || test $? -eq 1` - } -fi # as_fn_arith - - -# as_fn_error STATUS ERROR [LINENO LOG_FD] -# ---------------------------------------- -# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are -# provided, also output the error to LOG_FD, referencing LINENO. Then exit the -# script with STATUS, using 1 if that was 0. -as_fn_error () -{ - as_status=$1; test $as_status -eq 0 && as_status=1 - if test "$4"; then - as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 - fi - $as_echo "$as_me: error: $2" >&2 - as_fn_exit $as_status -} # as_fn_error - -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then - as_basename=basename -else - as_basename=false -fi - -if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then - as_dirname=dirname -else - as_dirname=false -fi - -as_me=`$as_basename -- "$0" || -$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X/"$0" | - sed '/^.*\/\([^/][^/]*\)\/*$/{ - s//\1/ - q - } - /^X\/\(\/\/\)$/{ - s//\1/ - q - } - /^X\/\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - -# Avoid depending upon Character Ranges. -as_cr_letters='abcdefghijklmnopqrstuvwxyz' -as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' -as_cr_Letters=$as_cr_letters$as_cr_LETTERS -as_cr_digits='0123456789' -as_cr_alnum=$as_cr_Letters$as_cr_digits - - - as_lineno_1=$LINENO as_lineno_1a=$LINENO - as_lineno_2=$LINENO as_lineno_2a=$LINENO - eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && - test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { - # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) - sed -n ' - p - /[$]LINENO/= - ' <$as_myself | - sed ' - s/[$]LINENO.*/&-/ - t lineno - b - :lineno - N - :loop - s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ - t loop - s/-\n.*// - ' >$as_me.lineno && - chmod +x "$as_me.lineno" || - { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } - - # Don't try to exec as it changes $[0], causing all sort of problems - # (the dirname of $[0] is not the place where we might find the - # original and so on. Autoconf is especially sensitive to this). - . "./$as_me.lineno" - # Exit status is that of the last command. - exit -} - -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in #((((( --n*) - case `echo 'xy\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - xy) ECHO_C='\c';; - *) echo `echo ksh88 bug on AIX 6.1` > /dev/null - ECHO_T=' ';; - esac;; -*) - ECHO_N='-n';; -esac - -rm -f conf$$ conf$$.exe conf$$.file -if test -d conf$$.dir; then - rm -f conf$$.dir/conf$$.file -else - rm -f conf$$.dir - mkdir conf$$.dir 2>/dev/null -fi -if (echo >conf$$.file) 2>/dev/null; then - if ln -s conf$$.file conf$$ 2>/dev/null; then - as_ln_s='ln -s' - # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. - ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' - elif ln conf$$.file conf$$ 2>/dev/null; then - as_ln_s=ln - else - as_ln_s='cp -p' - fi -else - as_ln_s='cp -p' -fi -rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file -rmdir conf$$.dir 2>/dev/null - -if mkdir -p . 2>/dev/null; then - as_mkdir_p='mkdir -p "$as_dir"' -else - test -d ./-p && rmdir ./-p - as_mkdir_p=false -fi - -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in #( - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x - -# Sed expression to map a string onto a valid CPP name. -as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" - -# Sed expression to map a string onto a valid variable name. -as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" - - -test -n "$DJDIR" || exec 7<&0 &1 - -# Name of the host. -# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, -# so uname gets run too. -ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` - -# -# Initializations. -# -ac_default_prefix=/usr/local -ac_clean_files= -ac_config_libobj_dir=. -LIBOBJS= -cross_compiling=no -subdirs= -MFLAGS= -MAKEFLAGS= - -# Identity of this package. -PACKAGE_NAME='openjdk' -PACKAGE_TARNAME='openjdk' -PACKAGE_VERSION='version-0.1' -PACKAGE_STRING='openjdk version-0.1' -PACKAGE_BUGREPORT='build-infra-dev@openjdk.java.net' -PACKAGE_URL='' - -# Factoring default headers for most tests. -ac_includes_default="\ -#include -#ifdef HAVE_SYS_TYPES_H -# include -#endif -#ifdef HAVE_SYS_STAT_H -# include -#endif -#ifdef STDC_HEADERS -# include -# include -#else -# ifdef HAVE_STDLIB_H -# include -# endif -#endif -#ifdef HAVE_STRING_H -# if !defined STDC_HEADERS && defined HAVE_MEMORY_H -# include -# endif -# include -#endif -#ifdef HAVE_STRINGS_H -# include -#endif -#ifdef HAVE_INTTYPES_H -# include -#endif -#ifdef HAVE_STDINT_H -# include -#endif -#ifdef HAVE_UNISTD_H -# include -#endif" - -ac_subst_vars='LTLIBOBJS -LIBOBJS -CACERTS_FILE -TEST_IN_BUILD -SALIB_NAME -OS_VERSION_MICRO -OS_VERSION_MINOR -OS_VERSION_MAJOR -LIBCXX -LDFLAGS_JDKEXE_SUFFIX -LDFLAGS_JDKLIB_SUFFIX -LDFLAGS_JDKEXE -LDFLAGS_JDKLIB -CXXFLAGS_JDKEXE -CXXFLAGS_JDKLIB -CFLAGS_JDKEXE -CFLAGS_JDKLIB -PACKAGE_PATH -IMAGES_MAKE_ARGS -IMAGES_OUTPUTDIR -JDK_MAKE_ARGS -JDK_OUTPUTDIR -HOTSPOT_MAKE_ARGS -HOTSPOT_DIST -HOTSPOT_OUTPUTDIR -JAXWS_MAKE_ARGS -JAXWS_DIST -JAXWS_OUTPUTDIR -JAXP_MAKE_ARGS -JAXP_DIST -JAXP_OUTPUTDIR -CORBA_MAKE_ARGS -CORBA_DIST -CORBA_OUTPUTDIR -LANGTOOLS_MAKE_ARGS -LANGTOOLS_DIST -LANGTOOLS_OUTPUTDIR -CXX_FLAG_DEPS -C_FLAG_DEPS -CXX_O_FLAG_NONE -CXX_O_FLAG_NORM -CXX_O_FLAG_HI -CXX_O_FLAG_HIGHEST -C_O_FLAG_NONE -C_O_FLAG_NORM -C_O_FLAG_HI -C_O_FLAG_HIGHEST -DISABLE_NIMBUS -GENERATE_DOCS -ENABLE_DOCS -LIBDL -LIBM -USE_EXTERNAL_LIBZ -USE_EXTERNAL_LIBGIF -USE_EXTERNAL_LIBJPEG -PULSE_LIBS -PULSE_CFLAGS -LIBPULSE_LIBS -LIBPULSE_CFLAGS -ALSA_LIBS -ALSA_CFLAGS -FREETYPE2_LIB_PATH -USING_SYSTEM_FT_LIB -FREETYPE2_LIBS -FREETYPE2_CFLAGS -CUPS_LIBS -CUPS_CFLAGS -OPENWIN_HOME -X_EXTRA_LIBS -X_LIBS -X_PRE_LIBS -X_CFLAGS -XMKMF -JAVAC_USE_MODE -JAVAC_USE_DEPS -JAVAC_SERVER_CORES -JAVAC_SERVERS -JAVAC_USE_REMOTE -SERVER_JAVA -BOOT_JDK_JVMARGS -OVERRIDE_SRC_ROOT -ADD_SRC_ROOT -NATIVE2ASCII -RMIC -JAR -JAVAH -JAVAC_FLAGS -JAVAC -BOOT_JDK_SOURCETARGET -JAVA -BOOT_TOOLSJAR -BOOT_RTJAR -BOOT_JDK -JAVA_CHECK -JAVAC_CHECK -ENDIAN -POST_MCS_CMD -POST_STRIP_CMD -SET_SHARED_LIBRARY_ORIGIN -CXX_FLAG_REORDER -C_FLAG_REORDER -SET_SHARED_LIBRARY_MAPFILE -SET_SHARED_LIBRARY_NAME -SHARED_LIBRARY_FLAGS -EXE_SUFFIX -STATIC_LIBRARY_SUFFIX -SHARED_LIBRARY_SUFFIX -LIBRARY_PREFIX -STATIC_LIBRARY -SHARED_LIBRARY -OBJ_SUFFIX -USE_PRECOMPILED_HEADER -ARCH_DATA_MODEL -LP64 -BUILD_LOG_WRAPPER -BUILD_LOG -CCACHE -UNCYGDRIVE -MCS -STRIP -NM -ASFLAGS -AS -CXXCPP -CPP -COMPILER_TYPE -RC_FLAGS -DUMPBIN -WINAR -RC -MT -WINLD -ARFLAGS -AR -LDEXECXX -LDCXX -LDEXE -LD -ac_ct_OBJC -OBJCFLAGS -OBJC -ac_ct_CXX -CXXFLAGS -CXX -OBJEXT -EXEEXT -ac_ct_CC -CPPFLAGS -LDFLAGS -CFLAGS -CC -HOSTCXX -HOSTCC -HOST_CXX -HOST_CC -DEFINE_CROSS_COMPILE_ARCH -AR_OUT_OPTION -LD_OUT_OPTION -EXE_OUT_OPTION -CC_OUT_OPTION -SYS_ROOT -BDEPS_FTP -BDEPS_UNZIP -PKG_CONFIG -JDK_TOPDIR -HOTSPOT_TOPDIR -JAXWS_TOPDIR -JAXP_TOPDIR -CORBA_TOPDIR -LANGTOOLS_TOPDIR -OUTPUT_ROOT -CONF_NAME -SPEC -MSVCR100DLL -CHECK_FOR_VCINSTALLDIR -SETUPDEVENV -COOKED_BUILD_NUMBER -FULL_VERSION -RELEASE -JDK_VERSION -RUNTIME_NAME -COPYRIGHT_YEAR -COMPANY_NAME -JDK_RC_PLATFORM_NAME -PRODUCT_SUFFIX -PRODUCT_NAME -LAUNCHER_NAME -MILESTONE -JDK_BUILD_NUMBER -JDK_UPDATE_VERSION -JDK_MICRO_VERSION -JDK_MINOR_VERSION -JDK_MAJOR_VERSION -BUILD_VARIANT_RELEASE -DEBUG_CLASSFILES -FASTDEBUG -VARIANT -DEBUG_LEVEL -JVM_VARIANT_ZEROSHARK -JVM_VARIANT_ZERO -JVM_VARIANT_KERNEL -JVM_VARIANT_CLIENT -JVM_VARIANT_SERVER -JVM_VARIANTS -BUILD_HEADLESS_ONLY -BUILD_HEADLESS -SUPPORT_HEADFUL -SUPPORT_HEADLESS -JDK_VARIANT -MINIMIZE_RAM_USAGE -JAVASE_EMBEDDED -JIGSAW -SET_OPENJDK -PATH_SEP -CYGPATH -SRC_ROOT -MEMORY_SIZE -CONCURRENT_BUILD_JOBS -NUM_CORES -DATE_WHEN_CONFIGURED -REQUIRED_OS_VERSION -REQUIRED_OS_NAME -LEGACY_BUILD_CPU3 -LEGACY_BUILD_CPU2 -LEGACY_BUILD_CPU1 -BUILD_CPU_ENDIAN -BUILD_CPU_BITS -BUILD_CPU_ARCH -BUILD_CPU -LEGACY_BUILD_OS_API -BUILD_OS_API -BUILD_OS_FAMILY -BUILD_OS -LEGACY_HOST_CPU3 -LEGACY_HOST_CPU2 -LEGACY_HOST_CPU1 -HOST_CPU_ENDIAN -HOST_CPU_BITS -HOST_CPU_ARCH -HOST_CPU -LEGACY_HOST_OS_API -HOST_OS_API -HOST_OS_FAMILY -HOST_OS -BUILD -HOST -host_os -host_vendor -host_cpu -host -build_os -build_vendor -build_cpu -build -HG -FILE -EXPR -READELF -OTOOL -LDD -UNZIP -ZIP -XARGS -WC -TOUCH -TR -TEE -TAIL -TAR -SORT -SH -SED -RM -THEPWDCMD -PRINTF -NAWK -MV -MKDIR -MAKE -LS -LN -HEAD -FIND_DELETE -FIND -FGREP -EGREP -GREP -ECHO -DIFF -DF -DATE -CUT -CPIO -CP -CHMOD -CAT -AWK -READLINK -CONFIGURE_COMMAND_LINE -PKGHANDLER -target_alias -host_alias -build_alias -LIBS -ECHO_T -ECHO_N -ECHO_C -DEFS -mandir -localedir -libdir -psdir -pdfdir -dvidir -htmldir -infodir -docdir -oldincludedir -includedir -localstatedir -sharedstatedir -sysconfdir -datadir -datarootdir -libexecdir -sbindir -bindir -program_transform_name -prefix -exec_prefix -PACKAGE_URL -PACKAGE_BUGREPORT -PACKAGE_STRING -PACKAGE_VERSION -PACKAGE_TARNAME -PACKAGE_NAME -PATH_SEPARATOR -SHELL' -ac_subst_files='' -ac_user_opts=' -enable_option_checking -with_data_model -with_num_cores -with_memory_size -enable_openjdk_only -enable_jigsaw -with_jdk_variant -enable_headful -with_jvm_variants -enable_debug -with_debug_level -with_msvcr100dll -with_builddeps_conf -with_builddeps_server -with_builddeps_dir -with_builddeps_group -enable_list_builddeps -with_sys_root -enable_ccache -with_ccache_dir -enable_precompiled_headers -with_boot_jdk -with_add_source_root -with_override_source_root -with_adds_and_overrides -with_override_langtools -with_override_corba -with_override_jaxp -with_override_jaxws -with_override_hotspot -with_override_jdk -with_boot_jdk_jvmargs -with_server_java -enable_javac_server -with_javac_server_cores -enable_javac_deps -enable_javac_multi_core -enable_macosx_runtime_support -with_x -with_cups -with_cups_include -with_cups_lib -with_freetype -with_alsa -with_alsa_include -with_alsa_lib -with_pulse -with_pulse_include -with_pulse_lib -enable_docs -enable_nimbus -enable_static_link_stdc__ -enable_hotspot_test_in_build -with_cacerts_file -' - ac_precious_vars='build_alias -host_alias -target_alias -PKG_CONFIG -CC -CFLAGS -LDFLAGS -LIBS -CPPFLAGS -CXX -CXXFLAGS -CCC -OBJC -OBJCFLAGS -CPP -CXXCPP -XMKMF -FREETYPE2_CFLAGS -FREETYPE2_LIBS -ALSA_CFLAGS -ALSA_LIBS -LIBPULSE_CFLAGS -LIBPULSE_LIBS' - - -# Initialize some variables set by options. -ac_init_help= -ac_init_version=false -ac_unrecognized_opts= -ac_unrecognized_sep= -# The variables have the same names as the options, with -# dashes changed to underlines. -cache_file=/dev/null -exec_prefix=NONE -no_create= -no_recursion= -prefix=NONE -program_prefix=NONE -program_suffix=NONE -program_transform_name=s,x,x, -silent= -site= -srcdir= -verbose= -x_includes=NONE -x_libraries=NONE - -# Installation directory options. -# These are left unexpanded so users can "make install exec_prefix=/foo" -# and all the variables that are supposed to be based on exec_prefix -# by default will actually change. -# Use braces instead of parens because sh, perl, etc. also accept them. -# (The list follows the same order as the GNU Coding Standards.) -bindir='${exec_prefix}/bin' -sbindir='${exec_prefix}/sbin' -libexecdir='${exec_prefix}/libexec' -datarootdir='${prefix}/share' -datadir='${datarootdir}' -sysconfdir='${prefix}/etc' -sharedstatedir='${prefix}/com' -localstatedir='${prefix}/var' -includedir='${prefix}/include' -oldincludedir='/usr/include' -docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' -infodir='${datarootdir}/info' -htmldir='${docdir}' -dvidir='${docdir}' -pdfdir='${docdir}' -psdir='${docdir}' -libdir='${exec_prefix}/lib' -localedir='${datarootdir}/locale' -mandir='${datarootdir}/man' - -ac_prev= -ac_dashdash= -for ac_option -do - # If the previous option needs an argument, assign it. - if test -n "$ac_prev"; then - eval $ac_prev=\$ac_option - ac_prev= - continue - fi - - case $ac_option in - *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; - *=) ac_optarg= ;; - *) ac_optarg=yes ;; - esac - - # Accept the important Cygnus configure options, so we can diagnose typos. - - case $ac_dashdash$ac_option in - --) - ac_dashdash=yes ;; - - -bindir | --bindir | --bindi | --bind | --bin | --bi) - ac_prev=bindir ;; - -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) - bindir=$ac_optarg ;; - - -build | --build | --buil | --bui | --bu) - ac_prev=build_alias ;; - -build=* | --build=* | --buil=* | --bui=* | --bu=*) - build_alias=$ac_optarg ;; - - -cache-file | --cache-file | --cache-fil | --cache-fi \ - | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) - ac_prev=cache_file ;; - -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ - | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) - cache_file=$ac_optarg ;; - - --config-cache | -C) - cache_file=config.cache ;; - - -datadir | --datadir | --datadi | --datad) - ac_prev=datadir ;; - -datadir=* | --datadir=* | --datadi=* | --datad=*) - datadir=$ac_optarg ;; - - -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ - | --dataroo | --dataro | --datar) - ac_prev=datarootdir ;; - -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ - | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) - datarootdir=$ac_optarg ;; - - -disable-* | --disable-*) - ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid feature name: $ac_useropt" - ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` - case $ac_user_opts in - *" -"enable_$ac_useropt" -"*) ;; - *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" - ac_unrecognized_sep=', ';; - esac - eval enable_$ac_useropt=no ;; - - -docdir | --docdir | --docdi | --doc | --do) - ac_prev=docdir ;; - -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) - docdir=$ac_optarg ;; - - -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) - ac_prev=dvidir ;; - -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) - dvidir=$ac_optarg ;; - - -enable-* | --enable-*) - ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid feature name: $ac_useropt" - ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` - case $ac_user_opts in - *" -"enable_$ac_useropt" -"*) ;; - *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" - ac_unrecognized_sep=', ';; - esac - eval enable_$ac_useropt=\$ac_optarg ;; - - -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ - | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ - | --exec | --exe | --ex) - ac_prev=exec_prefix ;; - -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ - | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ - | --exec=* | --exe=* | --ex=*) - exec_prefix=$ac_optarg ;; - - -gas | --gas | --ga | --g) - # Obsolete; use --with-gas. - with_gas=yes ;; - - -help | --help | --hel | --he | -h) - ac_init_help=long ;; - -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) - ac_init_help=recursive ;; - -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) - ac_init_help=short ;; - - -host | --host | --hos | --ho) - ac_prev=host_alias ;; - -host=* | --host=* | --hos=* | --ho=*) - host_alias=$ac_optarg ;; - - -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) - ac_prev=htmldir ;; - -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ - | --ht=*) - htmldir=$ac_optarg ;; - - -includedir | --includedir | --includedi | --included | --include \ - | --includ | --inclu | --incl | --inc) - ac_prev=includedir ;; - -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ - | --includ=* | --inclu=* | --incl=* | --inc=*) - includedir=$ac_optarg ;; - - -infodir | --infodir | --infodi | --infod | --info | --inf) - ac_prev=infodir ;; - -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) - infodir=$ac_optarg ;; - - -libdir | --libdir | --libdi | --libd) - ac_prev=libdir ;; - -libdir=* | --libdir=* | --libdi=* | --libd=*) - libdir=$ac_optarg ;; - - -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ - | --libexe | --libex | --libe) - ac_prev=libexecdir ;; - -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ - | --libexe=* | --libex=* | --libe=*) - libexecdir=$ac_optarg ;; - - -localedir | --localedir | --localedi | --localed | --locale) - ac_prev=localedir ;; - -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) - localedir=$ac_optarg ;; - - -localstatedir | --localstatedir | --localstatedi | --localstated \ - | --localstate | --localstat | --localsta | --localst | --locals) - ac_prev=localstatedir ;; - -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ - | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) - localstatedir=$ac_optarg ;; - - -mandir | --mandir | --mandi | --mand | --man | --ma | --m) - ac_prev=mandir ;; - -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) - mandir=$ac_optarg ;; - - -nfp | --nfp | --nf) - # Obsolete; use --without-fp. - with_fp=no ;; - - -no-create | --no-create | --no-creat | --no-crea | --no-cre \ - | --no-cr | --no-c | -n) - no_create=yes ;; - - -no-recursion | --no-recursion | --no-recursio | --no-recursi \ - | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) - no_recursion=yes ;; - - -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ - | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ - | --oldin | --oldi | --old | --ol | --o) - ac_prev=oldincludedir ;; - -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ - | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ - | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) - oldincludedir=$ac_optarg ;; - - -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) - ac_prev=prefix ;; - -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) - prefix=$ac_optarg ;; - - -program-prefix | --program-prefix | --program-prefi | --program-pref \ - | --program-pre | --program-pr | --program-p) - ac_prev=program_prefix ;; - -program-prefix=* | --program-prefix=* | --program-prefi=* \ - | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) - program_prefix=$ac_optarg ;; - - -program-suffix | --program-suffix | --program-suffi | --program-suff \ - | --program-suf | --program-su | --program-s) - ac_prev=program_suffix ;; - -program-suffix=* | --program-suffix=* | --program-suffi=* \ - | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) - program_suffix=$ac_optarg ;; - - -program-transform-name | --program-transform-name \ - | --program-transform-nam | --program-transform-na \ - | --program-transform-n | --program-transform- \ - | --program-transform | --program-transfor \ - | --program-transfo | --program-transf \ - | --program-trans | --program-tran \ - | --progr-tra | --program-tr | --program-t) - ac_prev=program_transform_name ;; - -program-transform-name=* | --program-transform-name=* \ - | --program-transform-nam=* | --program-transform-na=* \ - | --program-transform-n=* | --program-transform-=* \ - | --program-transform=* | --program-transfor=* \ - | --program-transfo=* | --program-transf=* \ - | --program-trans=* | --program-tran=* \ - | --progr-tra=* | --program-tr=* | --program-t=*) - program_transform_name=$ac_optarg ;; - - -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) - ac_prev=pdfdir ;; - -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) - pdfdir=$ac_optarg ;; - - -psdir | --psdir | --psdi | --psd | --ps) - ac_prev=psdir ;; - -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) - psdir=$ac_optarg ;; - - -q | -quiet | --quiet | --quie | --qui | --qu | --q \ - | -silent | --silent | --silen | --sile | --sil) - silent=yes ;; - - -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) - ac_prev=sbindir ;; - -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ - | --sbi=* | --sb=*) - sbindir=$ac_optarg ;; - - -sharedstatedir | --sharedstatedir | --sharedstatedi \ - | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ - | --sharedst | --shareds | --shared | --share | --shar \ - | --sha | --sh) - ac_prev=sharedstatedir ;; - -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ - | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ - | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ - | --sha=* | --sh=*) - sharedstatedir=$ac_optarg ;; - - -site | --site | --sit) - ac_prev=site ;; - -site=* | --site=* | --sit=*) - site=$ac_optarg ;; - - -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) - ac_prev=srcdir ;; - -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) - srcdir=$ac_optarg ;; - - -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ - | --syscon | --sysco | --sysc | --sys | --sy) - ac_prev=sysconfdir ;; - -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ - | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) - sysconfdir=$ac_optarg ;; - - -target | --target | --targe | --targ | --tar | --ta | --t) - ac_prev=target_alias ;; - -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) - target_alias=$ac_optarg ;; - - -v | -verbose | --verbose | --verbos | --verbo | --verb) - verbose=yes ;; - - -version | --version | --versio | --versi | --vers | -V) - ac_init_version=: ;; - - -with-* | --with-*) - ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid package name: $ac_useropt" - ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` - case $ac_user_opts in - *" -"with_$ac_useropt" -"*) ;; - *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" - ac_unrecognized_sep=', ';; - esac - eval with_$ac_useropt=\$ac_optarg ;; - - -without-* | --without-*) - ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid package name: $ac_useropt" - ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` - case $ac_user_opts in - *" -"with_$ac_useropt" -"*) ;; - *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" - ac_unrecognized_sep=', ';; - esac - eval with_$ac_useropt=no ;; - - --x) - # Obsolete; use --with-x. - with_x=yes ;; - - -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ - | --x-incl | --x-inc | --x-in | --x-i) - ac_prev=x_includes ;; - -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ - | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) - x_includes=$ac_optarg ;; - - -x-libraries | --x-libraries | --x-librarie | --x-librari \ - | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) - ac_prev=x_libraries ;; - -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ - | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) - x_libraries=$ac_optarg ;; - - -*) as_fn_error $? "unrecognized option: \`$ac_option' -Try \`$0 --help' for more information" - ;; - - *=*) - ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` - # Reject names that are not valid shell variable names. - case $ac_envvar in #( - '' | [0-9]* | *[!_$as_cr_alnum]* ) - as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; - esac - eval $ac_envvar=\$ac_optarg - export $ac_envvar ;; - - *) - # FIXME: should be removed in autoconf 3.0. - $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 - expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && - $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 - : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} - ;; - - esac -done - -if test -n "$ac_prev"; then - ac_option=--`echo $ac_prev | sed 's/_/-/g'` - as_fn_error $? "missing argument to $ac_option" -fi - -if test -n "$ac_unrecognized_opts"; then - case $enable_option_checking in - no) ;; - fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; - *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; - esac -fi - -# Check all directory arguments for consistency. -for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ - datadir sysconfdir sharedstatedir localstatedir includedir \ - oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ - libdir localedir mandir -do - eval ac_val=\$$ac_var - # Remove trailing slashes. - case $ac_val in - */ ) - ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` - eval $ac_var=\$ac_val;; - esac - # Be sure to have absolute directory names. - case $ac_val in - [\\/$]* | ?:[\\/]* ) continue;; - NONE | '' ) case $ac_var in *prefix ) continue;; esac;; - esac - as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" -done - -# There might be people who depend on the old broken behavior: `$host' -# used to hold the argument of --host etc. -# FIXME: To remove some day. -build=$build_alias -host=$host_alias -target=$target_alias - -# FIXME: To remove some day. -if test "x$host_alias" != x; then - if test "x$build_alias" = x; then - cross_compiling=maybe - $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host. - If a cross compiler is detected then cross compile mode will be used" >&2 - elif test "x$build_alias" != "x$host_alias"; then - cross_compiling=yes - fi -fi - -ac_tool_prefix= -test -n "$host_alias" && ac_tool_prefix=$host_alias- - -test "$silent" = yes && exec 6>/dev/null - - -ac_pwd=`pwd` && test -n "$ac_pwd" && -ac_ls_di=`ls -di .` && -ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || - as_fn_error $? "working directory cannot be determined" -test "X$ac_ls_di" = "X$ac_pwd_ls_di" || - as_fn_error $? "pwd does not report name of working directory" - - -# Find the source files, if location was not specified. -if test -z "$srcdir"; then - ac_srcdir_defaulted=yes - # Try the directory containing this script, then the parent directory. - ac_confdir=`$as_dirname -- "$as_myself" || -$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$as_myself" : 'X\(//\)[^/]' \| \ - X"$as_myself" : 'X\(//\)$' \| \ - X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_myself" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - srcdir=$ac_confdir - if test ! -r "$srcdir/$ac_unique_file"; then - srcdir=.. - fi -else - ac_srcdir_defaulted=no -fi -if test ! -r "$srcdir/$ac_unique_file"; then - test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." - as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" -fi -ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" -ac_abs_confdir=`( - cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" - pwd)` -# When building in place, set srcdir=. -if test "$ac_abs_confdir" = "$ac_pwd"; then - srcdir=. -fi -# Remove unnecessary trailing slashes from srcdir. -# Double slashes in file names in object file debugging info -# mess up M-x gdb in Emacs. -case $srcdir in -*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; -esac -for ac_var in $ac_precious_vars; do - eval ac_env_${ac_var}_set=\${${ac_var}+set} - eval ac_env_${ac_var}_value=\$${ac_var} - eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} - eval ac_cv_env_${ac_var}_value=\$${ac_var} -done - -# -# Report the --help message. -# -if test "$ac_init_help" = "long"; then - # Omit some internal or obsolete options to make the list less imposing. - # This message is too long to be a string in the A/UX 3.1 sh. - cat <<_ACEOF -\`configure' configures openjdk version-0.1 to adapt to many kinds of systems. - -Usage: $0 [OPTION]... [VAR=VALUE]... - -To assign environment variables (e.g., CC, CFLAGS...), specify them as -VAR=VALUE. See below for descriptions of some of the useful variables. - -Defaults for the options are specified in brackets. - -Configuration: - -h, --help display this help and exit - --help=short display options specific to this package - --help=recursive display the short help of all the included packages - -V, --version display version information and exit - -q, --quiet, --silent do not print \`checking ...' messages - --cache-file=FILE cache test results in FILE [disabled] - -C, --config-cache alias for \`--cache-file=config.cache' - -n, --no-create do not create output files - --srcdir=DIR find the sources in DIR [configure dir or \`..'] - -Installation directories: - --prefix=PREFIX install architecture-independent files in PREFIX - [$ac_default_prefix] - --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX - [PREFIX] - -By default, \`make install' will install all the files in -\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify -an installation prefix other than \`$ac_default_prefix' using \`--prefix', -for instance \`--prefix=\$HOME'. - -For better control, use the options below. - -Fine tuning of the installation directories: - --bindir=DIR user executables [EPREFIX/bin] - --sbindir=DIR system admin executables [EPREFIX/sbin] - --libexecdir=DIR program executables [EPREFIX/libexec] - --sysconfdir=DIR read-only single-machine data [PREFIX/etc] - --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] - --localstatedir=DIR modifiable single-machine data [PREFIX/var] - --libdir=DIR object code libraries [EPREFIX/lib] - --includedir=DIR C header files [PREFIX/include] - --oldincludedir=DIR C header files for non-gcc [/usr/include] - --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] - --datadir=DIR read-only architecture-independent data [DATAROOTDIR] - --infodir=DIR info documentation [DATAROOTDIR/info] - --localedir=DIR locale-dependent data [DATAROOTDIR/locale] - --mandir=DIR man documentation [DATAROOTDIR/man] - --docdir=DIR documentation root [DATAROOTDIR/doc/openjdk] - --htmldir=DIR html documentation [DOCDIR] - --dvidir=DIR dvi documentation [DOCDIR] - --pdfdir=DIR pdf documentation [DOCDIR] - --psdir=DIR ps documentation [DOCDIR] -_ACEOF - - cat <<\_ACEOF - -X features: - --x-includes=DIR X include files are in DIR - --x-libraries=DIR X library files are in DIR - -System types: - --build=BUILD configure for building on BUILD [guessed] - --host=HOST cross-compile to build programs to run on HOST [BUILD] -_ACEOF -fi - -if test -n "$ac_init_help"; then - case $ac_init_help in - short | recursive ) echo "Configuration of openjdk version-0.1:";; - esac - cat <<\_ACEOF - -Optional Features: - --disable-option-checking ignore unrecognized --enable/--with options - --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) - --enable-FEATURE[=ARG] include FEATURE [ARG=yes] - --enable-openjdk-only build OpenJDK regardless of the presence of closed - repositories [disabled] - --enable-jigsaw build Jigsaw images (not yet available) [disabled] - --disable-headful build headful support (graphical UI support) - [enabled] - --enable-debug set the debug level to fastdebug (shorthand for - --with-debug-level=fastdebug) [disabled] - --enable-list-builddeps list all build dependencies known to the configure - script - --disable-ccache use ccache to speed up recompilations [enabled] - --disable-precompiled-headers - use precompiled headers when compiling C++ [enabled] - --enable-javac-server enable the shared javac server during the build - process [disabled] - --enable-javac-deps enable the dependency tracking between Java packages - [disabled] - --enable-javac-multi-core - compile Java packages concurrently [disabled] - --disable-macosx-runtime-support - disable the use of MacOSX Java runtime support - framework [enabled] - --enable-docs enable generation of Javadoc documentation - [disabled] - --disable-nimbus disable Nimbus L&F [enabled] - --disable-static-link-stdc++ - disable static linking of the C++ runtime on Linux - [enabled] - --enable-hotspot-test-in-build - enable running of Queens test after Hotspot build - (not yet available) [disabled] - -Optional Packages: - --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] - --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) - --with-data-model build 32-bit or 64-bit binaries (for platforms that - support it), e.g. --with-data-model=32 [guessed] - --with-num-cores number of cores in the build system, e.g. - --with-num-cores=8 [probed] - --with-memory-size memory (in MB) available in the build system, e.g. - --with-memory-size=1024 [probed] - --with-jdk-variant JDK variant to build (normal, embedded) [normal] - --with-jvm-variants JVM variants (separated by commas) to build (server, - client, kernel, zero, zeroshark) [server] - --with-debug-level set the debug level (release, fastdebug, slowdebug) - [release] - --with-msvcr100dll copy this msvcr100.dll into the built JDK - --with-builddeps-conf use this configuration file for the builddeps - --with-builddeps-server download and use build dependencies from this server - url, e.g. - --with-builddeps-server=ftp://example.com/dir - --with-builddeps-dir store downloaded build dependencies here - [d/localhome/builddeps] - --with-builddeps-group chgrp the downloaded build dependencies to this - group - --with-sys-root pass this sys-root to the compilers and linker - (useful if the sys-root encoded in the cross - compiler tools is incorrect) - --with-ccache-dir where to store ccache files [~/.ccache] - --with-boot-jdk path to Boot JDK (used to bootstrap build) [probed] - --with-add-source-root for each and every source directory, look in this - additional source root for the same directory; if it - exists and have files in it, include it in the build - --with-override-source-root - for each and every source directory, look in this - override source root for the same directory; if it - exists, use that directory instead and ignore the - directory in the original source root - --with-adds-and-overrides - use the subdirs 'adds' and 'overrides' in the - specified directory as add-source-root and - override-source-root - --with-override-langtools - use this langtools dir for the build - --with-override-corba use this corba dir for the build - --with-override-jaxp use this jaxp dir for the build - --with-override-jaxws use this jaxws dir for the build - --with-override-hotspot use this hotspot dir for the build - --with-override-jdk use this jdk dir for the build - --with-boot-jdk-jvmargs specify JVM arguments to be passed to all - invocations of the Boot JDK, overriding the default - values, e.g --with-boot-jdk-jvmargs="-Xmx8G - -enableassertions" - --with-server-java use this java binary for running the javac - background server and other long running java tasks - in the build process, e.g. - ---with-server-java="/opt/jrockit/bin/java -server" - --with-javac-server-cores - use at most this number of concurrent threads on the - javac server [probed] - --with-x use the X Window System - --with-cups specify prefix directory for the cups package - (expecting the libraries under PATH/lib and the - headers under PATH/include) - --with-cups-include specify directory for the cups include files - --with-cups-lib specify directory for the cups library - --with-freetype specify prefix directory for the freetype2 package - (expecting the libraries under PATH/lib and the - headers under PATH/include) - --with-alsa specify prefix directory for the alsa package - (expecting the libraries under PATH/lib and the - headers under PATH/include) - --with-alsa-include specify directory for the alsa include files - --with-alsa-lib specify directory for the alsa library - --with-pulse specify prefix directory for the pulseaudio package - (expecting the libraries under PATH/lib and the - headers under PATH/include) - --with-pulse-include specify directory for the pulseaudio include files - --with-pulse-lib specify directory for the pulseaudio library - --with-cacerts-file specify alternative cacerts file - -Some influential environment variables: - PKG_CONFIG path to pkg-config utility - CC C compiler command - CFLAGS C compiler flags - LDFLAGS linker flags, e.g. -L if you have libraries in a - nonstandard directory - LIBS libraries to pass to the linker, e.g. -l - CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if - you have headers in a nonstandard directory - CXX C++ compiler command - CXXFLAGS C++ compiler flags - OBJC Objective C compiler command - OBJCFLAGS Objective C compiler flags - CPP C preprocessor - CXXCPP C++ preprocessor - XMKMF Path to xmkmf, Makefile generator for X Window System - FREETYPE2_CFLAGS - C compiler flags for FREETYPE2, overriding pkg-config - FREETYPE2_LIBS - linker flags for FREETYPE2, overriding pkg-config - ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config - ALSA_LIBS linker flags for ALSA, overriding pkg-config - LIBPULSE_CFLAGS - C compiler flags for LIBPULSE, overriding pkg-config - LIBPULSE_LIBS - linker flags for LIBPULSE, overriding pkg-config - -Use these variables to override the choices made by `configure' or to help -it to find libraries and programs with nonstandard names/locations. - -Report bugs to . -_ACEOF -ac_status=$? -fi - -if test "$ac_init_help" = "recursive"; then - # If there are subdirs, report their specific --help. - for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue - test -d "$ac_dir" || - { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || - continue - ac_builddir=. - -case "$ac_dir" in -.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; -*) - ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` - # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` - case $ac_top_builddir_sub in - "") ac_top_builddir_sub=. ac_top_build_prefix= ;; - *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; - esac ;; -esac -ac_abs_top_builddir=$ac_pwd -ac_abs_builddir=$ac_pwd$ac_dir_suffix -# for backward compatibility: -ac_top_builddir=$ac_top_build_prefix - -case $srcdir in - .) # We are building in place. - ac_srcdir=. - ac_top_srcdir=$ac_top_builddir_sub - ac_abs_top_srcdir=$ac_pwd ;; - [\\/]* | ?:[\\/]* ) # Absolute name. - ac_srcdir=$srcdir$ac_dir_suffix; - ac_top_srcdir=$srcdir - ac_abs_top_srcdir=$srcdir ;; - *) # Relative name. - ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix - ac_top_srcdir=$ac_top_build_prefix$srcdir - ac_abs_top_srcdir=$ac_pwd/$srcdir ;; -esac -ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix - - cd "$ac_dir" || { ac_status=$?; continue; } - # Check for guested configure. - if test -f "$ac_srcdir/configure.gnu"; then - echo && - $SHELL "$ac_srcdir/configure.gnu" --help=recursive - elif test -f "$ac_srcdir/configure"; then - echo && - $SHELL "$ac_srcdir/configure" --help=recursive - else - $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 - fi || ac_status=$? - cd "$ac_pwd" || { ac_status=$?; break; } - done -fi - -test -n "$ac_init_help" && exit $ac_status -if $ac_init_version; then - cat <<\_ACEOF -openjdk configure version-0.1 -generated by GNU Autoconf 2.67 - -Copyright (C) 2010 Free Software Foundation, Inc. -This configure script is free software; the Free Software Foundation -gives unlimited permission to copy, distribute and modify it. -_ACEOF - exit -fi - -## ------------------------ ## -## Autoconf initialization. ## -## ------------------------ ## - -# ac_fn_c_try_compile LINENO -# -------------------------- -# Try to compile conftest.$ac_ext, and return whether this succeeded. -ac_fn_c_try_compile () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext - if { { ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_compile") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && { - test -z "$ac_c_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then : - ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 -fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - as_fn_set_status $ac_retval - -} # ac_fn_c_try_compile - -# ac_fn_cxx_try_compile LINENO -# ---------------------------- -# Try to compile conftest.$ac_ext, and return whether this succeeded. -ac_fn_cxx_try_compile () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext - if { { ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_compile") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then : - ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 -fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - as_fn_set_status $ac_retval - -} # ac_fn_cxx_try_compile - -# ac_fn_objc_try_compile LINENO -# ----------------------------- -# Try to compile conftest.$ac_ext, and return whether this succeeded. -ac_fn_objc_try_compile () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext - if { { ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_compile") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && { - test -z "$ac_objc_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then : - ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 -fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - as_fn_set_status $ac_retval - -} # ac_fn_objc_try_compile - -# ac_fn_c_try_cpp LINENO -# ---------------------- -# Try to preprocess conftest.$ac_ext, and return whether this succeeded. -ac_fn_c_try_cpp () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if { { ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } > conftest.i && { - test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || - test ! -s conftest.err - }; then : - ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 -fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - as_fn_set_status $ac_retval - -} # ac_fn_c_try_cpp - -# ac_fn_cxx_try_cpp LINENO -# ------------------------ -# Try to preprocess conftest.$ac_ext, and return whether this succeeded. -ac_fn_cxx_try_cpp () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if { { ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } > conftest.i && { - test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || - test ! -s conftest.err - }; then : - ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 -fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - as_fn_set_status $ac_retval - -} # ac_fn_cxx_try_cpp - -# ac_fn_cxx_try_link LINENO -# ------------------------- -# Try to link conftest.$ac_ext, and return whether this succeeded. -ac_fn_cxx_try_link () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext conftest$ac_exeext - if { { ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_link") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest$ac_exeext && { - test "$cross_compiling" = yes || - $as_test_x conftest$ac_exeext - }; then : - ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 -fi - # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information - # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would - # interfere with the next link command; also delete a directory that is - # left behind by Apple's compiler. We do this before executing the actions. - rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - as_fn_set_status $ac_retval - -} # ac_fn_cxx_try_link - -# ac_fn_cxx_try_run LINENO -# ------------------------ -# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes -# that executables *can* be run. -ac_fn_cxx_try_run () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if { { ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_link") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' - { { case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_try") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; }; then : - ac_retval=0 -else - $as_echo "$as_me: program exited with status $ac_status" >&5 - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=$ac_status -fi - rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - as_fn_set_status $ac_retval - -} # ac_fn_cxx_try_run - -# ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES -# ---------------------------------------------- -# Tries to find the compile-time value of EXPR in a program that includes -# INCLUDES, setting VAR accordingly. Returns whether the value could be -# computed -ac_fn_cxx_compute_int () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if test "$cross_compiling" = yes; then - # Depending upon the size, compute the lo and hi bounds. -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -int -main () -{ -static int test_array [1 - 2 * !(($2) >= 0)]; -test_array [0] = 0 - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_lo=0 ac_mid=0 - while :; do - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -int -main () -{ -static int test_array [1 - 2 * !(($2) <= $ac_mid)]; -test_array [0] = 0 - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_hi=$ac_mid; break -else - as_fn_arith $ac_mid + 1 && ac_lo=$as_val - if test $ac_lo -le $ac_mid; then - ac_lo= ac_hi= - break - fi - as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - done -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -int -main () -{ -static int test_array [1 - 2 * !(($2) < 0)]; -test_array [0] = 0 - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_hi=-1 ac_mid=-1 - while :; do - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -int -main () -{ -static int test_array [1 - 2 * !(($2) >= $ac_mid)]; -test_array [0] = 0 - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_lo=$ac_mid; break -else - as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val - if test $ac_mid -le $ac_hi; then - ac_lo= ac_hi= - break - fi - as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - done -else - ac_lo= ac_hi= -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -# Binary search between lo and hi bounds. -while test "x$ac_lo" != "x$ac_hi"; do - as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -int -main () -{ -static int test_array [1 - 2 * !(($2) <= $ac_mid)]; -test_array [0] = 0 - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_hi=$ac_mid -else - as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -done -case $ac_lo in #(( -?*) eval "$3=\$ac_lo"; ac_retval=0 ;; -'') ac_retval=1 ;; -esac - else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -static long int longval () { return $2; } -static unsigned long int ulongval () { return $2; } -#include -#include -int -main () -{ - - FILE *f = fopen ("conftest.val", "w"); - if (! f) - return 1; - if (($2) < 0) - { - long int i = longval (); - if (i != ($2)) - return 1; - fprintf (f, "%ld", i); - } - else - { - unsigned long int i = ulongval (); - if (i != ($2)) - return 1; - fprintf (f, "%lu", i); - } - /* Do not output a trailing newline, as this causes \r\n confusion - on some platforms. */ - return ferror (f) || fclose (f) != 0; - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_run "$LINENO"; then : - echo >>conftest.val; read $3 &5 -$as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -#include <$2> -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - eval "$3=yes" -else - eval "$3=no" -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - -} # ac_fn_cxx_check_header_compile - -# ac_fn_cxx_check_func LINENO FUNC VAR -# ------------------------------------ -# Tests whether FUNC exists, setting the cache variable VAR accordingly -ac_fn_cxx_check_func () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -/* Define $2 to an innocuous variant, in case declares $2. - For example, HP-UX 11i declares gettimeofday. */ -#define $2 innocuous_$2 - -/* System header to define __stub macros and hopefully few prototypes, - which can conflict with char $2 (); below. - Prefer to if __STDC__ is defined, since - exists even on freestanding compilers. */ - -#ifdef __STDC__ -# include -#else -# include -#endif - -#undef $2 - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char $2 (); -/* The GNU C library defines this for functions which it implements - to always fail with ENOSYS. Some functions are actually named - something starting with __ and the normal name is an alias. */ -#if defined __stub_$2 || defined __stub___$2 -choke me -#endif - -int -main () -{ -return $2 (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - eval "$3=yes" -else - eval "$3=no" -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - -} # ac_fn_cxx_check_func - -# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES -# ------------------------------------------------------- -# Tests whether HEADER exists, giving a warning if it cannot be compiled using -# the include files in INCLUDES and setting the cache variable VAR -# accordingly. -ac_fn_c_check_header_mongrel () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if eval "test \"\${$3+set}\"" = set; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : - $as_echo_n "(cached) " >&6 -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -else - # Is the header compilable? -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 -$as_echo_n "checking $2 usability... " >&6; } -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -#include <$2> -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_header_compiler=yes -else - ac_header_compiler=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 -$as_echo "$ac_header_compiler" >&6; } - -# Is the header present? -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 -$as_echo_n "checking $2 presence... " >&6; } -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include <$2> -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - ac_header_preproc=yes -else - ac_header_preproc=no -fi -rm -f conftest.err conftest.i conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 -$as_echo "$ac_header_preproc" >&6; } - -# So? What about this header? -case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( - yes:no: ) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 -$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 -$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} - ;; - no:yes:* ) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 -$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 -$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 -$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 -$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 -$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} -( $as_echo "## ----------------------------------------------- ## -## Report this to build-infra-dev@openjdk.java.net ## -## ----------------------------------------------- ##" - ) | sed "s/^/$as_me: WARNING: /" >&2 - ;; -esac - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : - $as_echo_n "(cached) " >&6 -else - eval "$3=\$ac_header_compiler" -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - -} # ac_fn_c_check_header_mongrel - -# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES -# --------------------------------------------------------- -# Tests whether HEADER exists, giving a warning if it cannot be compiled using -# the include files in INCLUDES and setting the cache variable VAR -# accordingly. -ac_fn_cxx_check_header_mongrel () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if eval "test \"\${$3+set}\"" = set; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : - $as_echo_n "(cached) " >&6 -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -else - # Is the header compilable? -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 -$as_echo_n "checking $2 usability... " >&6; } -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -#include <$2> -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_header_compiler=yes -else - ac_header_compiler=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 -$as_echo "$ac_header_compiler" >&6; } - -# Is the header present? -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 -$as_echo_n "checking $2 presence... " >&6; } -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include <$2> -_ACEOF -if ac_fn_cxx_try_cpp "$LINENO"; then : - ac_header_preproc=yes -else - ac_header_preproc=no -fi -rm -f conftest.err conftest.i conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 -$as_echo "$ac_header_preproc" >&6; } - -# So? What about this header? -case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #(( - yes:no: ) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 -$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 -$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} - ;; - no:yes:* ) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 -$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 -$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 -$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 -$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 -$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} -( $as_echo "## ----------------------------------------------- ## -## Report this to build-infra-dev@openjdk.java.net ## -## ----------------------------------------------- ##" - ) | sed "s/^/$as_me: WARNING: /" >&2 - ;; -esac - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : - $as_echo_n "(cached) " >&6 -else - eval "$3=\$ac_header_compiler" -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} - -} # ac_fn_cxx_check_header_mongrel -cat >config.log <<_ACEOF -This file contains any messages produced by compilers while -running configure, to aid debugging if configure makes a mistake. - -It was created by openjdk $as_me version-0.1, which was -generated by GNU Autoconf 2.67. Invocation command line was - - $ $0 $@ - -_ACEOF -exec 5>>config.log -{ -cat <<_ASUNAME -## --------- ## -## Platform. ## -## --------- ## - -hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` -uname -m = `(uname -m) 2>/dev/null || echo unknown` -uname -r = `(uname -r) 2>/dev/null || echo unknown` -uname -s = `(uname -s) 2>/dev/null || echo unknown` -uname -v = `(uname -v) 2>/dev/null || echo unknown` - -/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` -/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` - -/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` -/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` -/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` -/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` -/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` -/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` -/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` - -_ASUNAME - -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - $as_echo "PATH: $as_dir" - done -IFS=$as_save_IFS - -} >&5 - -cat >&5 <<_ACEOF - - -## ----------- ## -## Core tests. ## -## ----------- ## - -_ACEOF - - -# Keep a trace of the command line. -# Strip out --no-create and --no-recursion so they do not pile up. -# Strip out --silent because we don't want to record it for future runs. -# Also quote any args containing shell meta-characters. -# Make two passes to allow for proper duplicate-argument suppression. -ac_configure_args= -ac_configure_args0= -ac_configure_args1= -ac_must_keep_next=false -for ac_pass in 1 2 -do - for ac_arg - do - case $ac_arg in - -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; - -q | -quiet | --quiet | --quie | --qui | --qu | --q \ - | -silent | --silent | --silen | --sile | --sil) - continue ;; - *\'*) - ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; - esac - case $ac_pass in - 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; - 2) - as_fn_append ac_configure_args1 " '$ac_arg'" - if test $ac_must_keep_next = true; then - ac_must_keep_next=false # Got value, back to normal. - else - case $ac_arg in - *=* | --config-cache | -C | -disable-* | --disable-* \ - | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ - | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ - | -with-* | --with-* | -without-* | --without-* | --x) - case "$ac_configure_args0 " in - "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; - esac - ;; - -* ) ac_must_keep_next=true ;; - esac - fi - as_fn_append ac_configure_args " '$ac_arg'" - ;; - esac - done -done -{ ac_configure_args0=; unset ac_configure_args0;} -{ ac_configure_args1=; unset ac_configure_args1;} - -# When interrupted or exit'd, cleanup temporary files, and complete -# config.log. We remove comments because anyway the quotes in there -# would cause problems or look ugly. -# WARNING: Use '\'' to represent an apostrophe within the trap. -# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. -trap 'exit_status=$? - # Save into config.log some information that might help in debugging. - { - echo - - $as_echo "## ---------------- ## -## Cache variables. ## -## ---------------- ##" - echo - # The following way of writing the cache mishandles newlines in values, -( - for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do - eval ac_val=\$$ac_var - case $ac_val in #( - *${as_nl}*) - case $ac_var in #( - *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; - esac - case $ac_var in #( - _ | IFS | as_nl) ;; #( - BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( - *) { eval $ac_var=; unset $ac_var;} ;; - esac ;; - esac - done - (set) 2>&1 | - case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( - *${as_nl}ac_space=\ *) - sed -n \ - "s/'\''/'\''\\\\'\'''\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" - ;; #( - *) - sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" - ;; - esac | - sort -) - echo - - $as_echo "## ----------------- ## -## Output variables. ## -## ----------------- ##" - echo - for ac_var in $ac_subst_vars - do - eval ac_val=\$$ac_var - case $ac_val in - *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; - esac - $as_echo "$ac_var='\''$ac_val'\''" - done | sort - echo - - if test -n "$ac_subst_files"; then - $as_echo "## ------------------- ## -## File substitutions. ## -## ------------------- ##" - echo - for ac_var in $ac_subst_files - do - eval ac_val=\$$ac_var - case $ac_val in - *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; - esac - $as_echo "$ac_var='\''$ac_val'\''" - done | sort - echo - fi - - if test -s confdefs.h; then - $as_echo "## ----------- ## -## confdefs.h. ## -## ----------- ##" - echo - cat confdefs.h - echo - fi - test "$ac_signal" != 0 && - $as_echo "$as_me: caught signal $ac_signal" - $as_echo "$as_me: exit $exit_status" - } >&5 - rm -f core *.core core.conftest.* && - rm -f -r conftest* confdefs* conf$$* $ac_clean_files && - exit $exit_status -' 0 -for ac_signal in 1 2 13 15; do - trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal -done -ac_signal=0 - -# confdefs.h avoids OS command line length limits that DEFS can exceed. -rm -f -r conftest* confdefs.h - -$as_echo "/* confdefs.h */" > confdefs.h - -# Predefined preprocessor variables. - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_NAME "$PACKAGE_NAME" -_ACEOF - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_TARNAME "$PACKAGE_TARNAME" -_ACEOF - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_VERSION "$PACKAGE_VERSION" -_ACEOF - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_STRING "$PACKAGE_STRING" -_ACEOF - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" -_ACEOF - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_URL "$PACKAGE_URL" -_ACEOF - - -# Let the site file select an alternate cache file if it wants to. -# Prefer an explicitly selected file to automatically selected ones. -ac_site_file1=NONE -ac_site_file2=NONE -if test -n "$CONFIG_SITE"; then - # We do not want a PATH search for config.site. - case $CONFIG_SITE in #(( - -*) ac_site_file1=./$CONFIG_SITE;; - */*) ac_site_file1=$CONFIG_SITE;; - *) ac_site_file1=./$CONFIG_SITE;; - esac -elif test "x$prefix" != xNONE; then - ac_site_file1=$prefix/share/config.site - ac_site_file2=$prefix/etc/config.site -else - ac_site_file1=$ac_default_prefix/share/config.site - ac_site_file2=$ac_default_prefix/etc/config.site -fi -for ac_site_file in "$ac_site_file1" "$ac_site_file2" -do - test "x$ac_site_file" = xNONE && continue - if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 -$as_echo "$as_me: loading site script $ac_site_file" >&6;} - sed 's/^/| /' "$ac_site_file" >&5 - . "$ac_site_file" \ - || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "failed to load site script $ac_site_file -See \`config.log' for more details" "$LINENO" 5 ; } - fi -done - -if test -r "$cache_file"; then - # Some versions of bash will fail to source /dev/null (special files - # actually), so we avoid doing that. DJGPP emulates it as a regular file. - if test /dev/null != "$cache_file" && test -f "$cache_file"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 -$as_echo "$as_me: loading cache $cache_file" >&6;} - case $cache_file in - [\\/]* | ?:[\\/]* ) . "$cache_file";; - *) . "./$cache_file";; - esac - fi -else - { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 -$as_echo "$as_me: creating cache $cache_file" >&6;} - >$cache_file -fi - -# Check that the precious variables saved in the cache have kept the same -# value. -ac_cache_corrupted=false -for ac_var in $ac_precious_vars; do - eval ac_old_set=\$ac_cv_env_${ac_var}_set - eval ac_new_set=\$ac_env_${ac_var}_set - eval ac_old_val=\$ac_cv_env_${ac_var}_value - eval ac_new_val=\$ac_env_${ac_var}_value - case $ac_old_set,$ac_new_set in - set,) - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 -$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} - ac_cache_corrupted=: ;; - ,set) - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 -$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} - ac_cache_corrupted=: ;; - ,);; - *) - if test "x$ac_old_val" != "x$ac_new_val"; then - # differences in whitespace do not lead to failure. - ac_old_val_w=`echo x $ac_old_val` - ac_new_val_w=`echo x $ac_new_val` - if test "$ac_old_val_w" != "$ac_new_val_w"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 -$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} - ac_cache_corrupted=: - else - { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 -$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} - eval $ac_var=\$ac_old_val - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 -$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 -$as_echo "$as_me: current value: \`$ac_new_val'" >&2;} - fi;; - esac - # Pass precious variables to config.status. - if test "$ac_new_set" = set; then - case $ac_new_val in - *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; - *) ac_arg=$ac_var=$ac_new_val ;; - esac - case " $ac_configure_args " in - *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. - *) as_fn_append ac_configure_args " '$ac_arg'" ;; - esac - fi -done -if $ac_cache_corrupted; then - { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 -$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} - as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 -fi -## -------------------- ## -## Main body of script. ## -## -------------------- ## - -ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - - - -ac_aux_dir= -for ac_dir in build-aux "$srcdir"/build-aux; do - if test -f "$ac_dir/install-sh"; then - ac_aux_dir=$ac_dir - ac_install_sh="$ac_aux_dir/install-sh -c" - break - elif test -f "$ac_dir/install.sh"; then - ac_aux_dir=$ac_dir - ac_install_sh="$ac_aux_dir/install.sh -c" - break - elif test -f "$ac_dir/shtool"; then - ac_aux_dir=$ac_dir - ac_install_sh="$ac_aux_dir/shtool install -c" - break - fi -done -if test -z "$ac_aux_dir"; then - as_fn_error $? "cannot find install-sh, install.sh, or shtool in build-aux \"$srcdir\"/build-aux" "$LINENO" 5 -fi - -# These three variables are undocumented and unsupported, -# and are intended to be withdrawn in a future Autoconf release. -# They can cause serious problems if a builder's source tree is in a directory -# whose full name contains unusual characters. -ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. -ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. -ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. - - - -# pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- -# -# Copyright © 2004 Scott James Remnant . -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program 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 for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -# -# As a special exception to the GNU General Public License, if you -# distribute this file as part of a program that contains a -# configuration script generated by Autoconf, you may include it under -# the same distribution terms that you use for the rest of that program. - -# PKG_PROG_PKG_CONFIG([MIN-VERSION]) -# ---------------------------------- -# PKG_PROG_PKG_CONFIG - -# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) -# -# Check to see whether a particular set of modules exists. Similar -# to PKG_CHECK_MODULES(), but does not set variables or print errors. -# -# -# Similar to PKG_CHECK_MODULES, make sure that the first instance of -# this or PKG_CHECK_MODULES is called, or make sure to call -# PKG_CHECK_EXISTS manually -# -------------------------------------------------------------- - - - -# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES]) -# --------------------------------------------- -# _PKG_CONFIG - -# _PKG_SHORT_ERRORS_SUPPORTED -# ----------------------------- -# _PKG_SHORT_ERRORS_SUPPORTED - - -# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], -# [ACTION-IF-NOT-FOUND]) -# -# -# Note that if there is a possibility the first call to -# PKG_CHECK_MODULES might not happen, you should be sure to include an -# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac -# -# -# -------------------------------------------------------------- -# PKG_CHECK_MODULES - -# -# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - - - - - - - - - -# -# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -# Fixes paths on windows hosts to be mixed mode short. - - - - -# -# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - - - - - -# -# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -function prepare_help_system { - for ac_prog in apt-get yum port pkgutil pkgadd -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_PKGHANDLER+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$PKGHANDLER"; then - ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_PKGHANDLER="$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -PKGHANDLER=$ac_cv_prog_PKGHANDLER -if test -n "$PKGHANDLER"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5 -$as_echo "$PKGHANDLER" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$PKGHANDLER" && break -done - -} - -function help_on_build_dependency { - # Print a helpful message on how to acquire the necessary build dependency. - # $1 is the help tag: freetyp2, cups, pulse, alsa etc - MISSING_DEPENDENCY=$1 - PKGHANDLER_COMMAND= - - case $PKGHANDLER in - apt-get) - apt_help $MISSING_DEPENDENCY ;; - yum) - yum_help $MISSING_DEPENDENCY ;; - port) - port_help $MISSING_DEPENDENCY ;; - pkgutil) - pkgutil_help $MISSING_DEPENDENCY ;; - pkgadd) - pkgadd_help $MISSING_DEPENDENCY ;; - * ) - break ;; - esac - - if test "x$PKGHANDLER_COMMAND" != x; then - HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." - fi -} - -function apt_help { - case $1 in - devkit) - PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;; - openjdk) - PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;; - alsa) - PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;; - cups) - PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;; - freetype2) - PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;; - pulse) - PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;; - x11) - PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev" ;; - ccache) - PKGHANDLER_COMMAND="sudo apt-get install ccache" ;; - * ) - break ;; - esac -} - -function yum_help { - case $1 in - devkit) - PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;; - openjdk) - PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;; - alsa) - PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;; - cups) - PKGHANDLER_COMMAND="sudo yum install cups-devel" ;; - freetype2) - PKGHANDLER_COMMAND="sudo yum install freetype2-devel" ;; - pulse) - PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;; - x11) - PKGHANDLER_COMMAND="sudo yum install libXtst-devel" ;; - ccache) - PKGHANDLER_COMMAND="sudo yum install ccache" ;; - * ) - break ;; - esac -} - -function port_help { - PKGHANDLER_COMMAND="" -} - -function pkgutil_help { - PKGHANDLER_COMMAND="" -} - -function pkgadd_help { - PKGHANDLER_COMMAND="" -} - - -# Save the command line. Do this very early, before it is lost by calling autoconf macros. CONFIGURE_COMMAND_LINE="$@" +conf_script_dir=`dirname $0` +conf_closed_script_dir="$conf_script_dir/../../jdk/make/closed/autoconf" +### +### Test that the generated configure is up-to-date +### -# Locate the directory of this script. -SCRIPT="$0" +# On Solaris /bin/sh doesn't support test -nt but /usr/bin/test does. +TEST=`which test` - if test "x$BUILD_OS" != xwindows; then - # Follow a chain of symbolic links. Use readlink - # where it exists, else fall back to horribly - # complicated shell code. - # Extract the first word of "readlink", so it can be a program name with args. -set dummy readlink; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_READLINK+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $READLINK in - [\\/]* | ?:[\\/]*) - ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS +print_error_not_up_to_date() { + echo "Error: The configure source files is newer than the generated files." + echo "Please run 'sh autogen.sh' to update the generated files." +} - ;; -esac -fi -READLINK=$ac_cv_path_READLINK -if test -n "$READLINK"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5 -$as_echo "$READLINK" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - if test "x$READLINK_TESTED" != yes; then - # On MacOSX there is a readlink tool with a different - # purpose than the GNU readlink tool. Check the found readlink. - ISGNU=`$READLINK --help 2>&1 | grep GNU` - if test "x$ISGNU" = x; then - # A readlink that we do not know how to use. - # Are there other non-GNU readlinks out there? - READLINK_TESTED=yes - READLINK= - fi - fi - - if test "x$READLINK" != x; then - SCRIPT=`$READLINK -f $SCRIPT` - else - STARTDIR=$PWD - COUNTER=0 - DIR=`dirname $SCRIPT` - FIL=`basename $SCRIPT` - while test $COUNTER -lt 20; do - ISLINK=`ls -l $DIR/$FIL | grep '\->' | sed -e 's/.*-> \(.*\)/\1/'` - if test "x$ISLINK" == x; then - # This is not a symbolic link! We are done! - break - fi - # The link might be relative! We have to use cd to travel safely. - cd $DIR - cd `dirname $ISLINK` - DIR=`pwd` - FIL=`basename $ISLINK` - let COUNTER=COUNTER+1 - done - cd $STARTDIR - SCRIPT=$DIR/$FIL - fi - fi - -AUTOCONF_DIR=`dirname $0` - -# Start with tools that do not need have cross compilation support -# and can be expected to be found in the default PATH. These tools are -# used by configure. Nor are these tools expected to be found in the -# devkit from the builddeps server either, since they are -# needed to download the devkit. -for ac_prog in gawk mawk nawk awk -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_AWK+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$AWK"; then - ac_cv_prog_AWK="$AWK" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_AWK="$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -AWK=$ac_cv_prog_AWK -if test -n "$AWK"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 -$as_echo "$AWK" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$AWK" && break -done - - - # Test that variable AWK is not empty. - if test "" = "$AWK"; then as_fn_error $? "Could not find awk !" "$LINENO" 5 ; fi - -# Extract the first word of "cat", so it can be a program name with args. -set dummy cat; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CAT+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $CAT in - [\\/]* | ?:[\\/]*) - ac_cv_path_CAT="$CAT" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CAT=$ac_cv_path_CAT -if test -n "$CAT"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5 -$as_echo "$CAT" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable CAT is not empty. - if test "" = "$CAT"; then as_fn_error $? "Could not find cat !" "$LINENO" 5 ; fi - -# Extract the first word of "chmod", so it can be a program name with args. -set dummy chmod; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CHMOD+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $CHMOD in - [\\/]* | ?:[\\/]*) - ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CHMOD=$ac_cv_path_CHMOD -if test -n "$CHMOD"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5 -$as_echo "$CHMOD" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable CHMOD is not empty. - if test "" = "$CHMOD"; then as_fn_error $? "Could not find chmod !" "$LINENO" 5 ; fi - -# Extract the first word of "cp", so it can be a program name with args. -set dummy cp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $CP in - [\\/]* | ?:[\\/]*) - ac_cv_path_CP="$CP" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CP=$ac_cv_path_CP -if test -n "$CP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5 -$as_echo "$CP" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable CP is not empty. - if test "" = "$CP"; then as_fn_error $? "Could not find cp !" "$LINENO" 5 ; fi - -# Extract the first word of "cpio", so it can be a program name with args. -set dummy cpio; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CPIO+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $CPIO in - [\\/]* | ?:[\\/]*) - ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CPIO=$ac_cv_path_CPIO -if test -n "$CPIO"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5 -$as_echo "$CPIO" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable CPIO is not empty. - if test "" = "$CPIO"; then as_fn_error $? "Could not find cpio !" "$LINENO" 5 ; fi - -# Extract the first word of "cut", so it can be a program name with args. -set dummy cut; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CUT+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $CUT in - [\\/]* | ?:[\\/]*) - ac_cv_path_CUT="$CUT" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CUT=$ac_cv_path_CUT -if test -n "$CUT"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5 -$as_echo "$CUT" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable CUT is not empty. - if test "" = "$CUT"; then as_fn_error $? "Could not find cut !" "$LINENO" 5 ; fi - -# Extract the first word of "date", so it can be a program name with args. -set dummy date; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_DATE+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $DATE in - [\\/]* | ?:[\\/]*) - ac_cv_path_DATE="$DATE" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -DATE=$ac_cv_path_DATE -if test -n "$DATE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5 -$as_echo "$DATE" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable DATE is not empty. - if test "" = "$DATE"; then as_fn_error $? "Could not find date !" "$LINENO" 5 ; fi - -# Extract the first word of "df", so it can be a program name with args. -set dummy df; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_DF+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $DF in - [\\/]* | ?:[\\/]*) - ac_cv_path_DF="$DF" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -DF=$ac_cv_path_DF -if test -n "$DF"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5 -$as_echo "$DF" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable DF is not empty. - if test "" = "$DF"; then as_fn_error $? "Could not find df !" "$LINENO" 5 ; fi - -# Extract the first word of "diff", so it can be a program name with args. -set dummy diff; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_DIFF+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $DIFF in - [\\/]* | ?:[\\/]*) - ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -DIFF=$ac_cv_path_DIFF -if test -n "$DIFF"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5 -$as_echo "$DIFF" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable DIFF is not empty. - if test "" = "$DIFF"; then as_fn_error $? "Could not find diff !" "$LINENO" 5 ; fi - -# Warning echo is really, really unportable!!!!! Different -# behaviour in bash and dash and in a lot of other shells! -# Use printf for serious work! -# Extract the first word of "echo", so it can be a program name with args. -set dummy echo; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_ECHO+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $ECHO in - [\\/]* | ?:[\\/]*) - ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -ECHO=$ac_cv_path_ECHO -if test -n "$ECHO"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5 -$as_echo "$ECHO" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable ECHO is not empty. - if test "" = "$ECHO"; then as_fn_error $? "Could not find echo !" "$LINENO" 5 ; fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 -$as_echo_n "checking for grep that handles long lines and -e... " >&6; } -if test "${ac_cv_path_GREP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -z "$GREP"; then - ac_path_GREP_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in grep ggrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue -# Check for GNU ac_path_GREP and select it if it is found. - # Check for GNU $ac_path_GREP -case `"$ac_path_GREP" --version 2>&1` in -*GNU*) - ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; -*) - ac_count=0 - $as_echo_n 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - $as_echo 'GREP' >> "conftest.nl" - "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break - as_fn_arith $ac_count + 1 && ac_count=$as_val - if test $ac_count -gt ${ac_path_GREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_GREP="$ac_path_GREP" - ac_path_GREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_GREP_found && break 3 - done - done - done -IFS=$as_save_IFS - if test -z "$ac_cv_path_GREP"; then - as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 - fi -else - ac_cv_path_GREP=$GREP -fi - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 -$as_echo "$ac_cv_path_GREP" >&6; } - GREP="$ac_cv_path_GREP" - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 -$as_echo_n "checking for egrep... " >&6; } -if test "${ac_cv_path_EGREP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 - then ac_cv_path_EGREP="$GREP -E" - else - if test -z "$EGREP"; then - ac_path_EGREP_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in egrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue -# Check for GNU ac_path_EGREP and select it if it is found. - # Check for GNU $ac_path_EGREP -case `"$ac_path_EGREP" --version 2>&1` in -*GNU*) - ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; -*) - ac_count=0 - $as_echo_n 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - $as_echo 'EGREP' >> "conftest.nl" - "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break - as_fn_arith $ac_count + 1 && ac_count=$as_val - if test $ac_count -gt ${ac_path_EGREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_EGREP="$ac_path_EGREP" - ac_path_EGREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_EGREP_found && break 3 - done - done - done -IFS=$as_save_IFS - if test -z "$ac_cv_path_EGREP"; then - as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 - fi -else - ac_cv_path_EGREP=$EGREP -fi - - fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 -$as_echo "$ac_cv_path_EGREP" >&6; } - EGREP="$ac_cv_path_EGREP" - - - - # Test that variable EGREP is not empty. - if test "" = "$EGREP"; then as_fn_error $? "Could not find egrep !" "$LINENO" 5 ; fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 -$as_echo_n "checking for fgrep... " >&6; } -if test "${ac_cv_path_FGREP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 - then ac_cv_path_FGREP="$GREP -F" - else - if test -z "$FGREP"; then - ac_path_FGREP_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in fgrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_FGREP" && $as_test_x "$ac_path_FGREP"; } || continue -# Check for GNU ac_path_FGREP and select it if it is found. - # Check for GNU $ac_path_FGREP -case `"$ac_path_FGREP" --version 2>&1` in -*GNU*) - ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;; -*) - ac_count=0 - $as_echo_n 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - $as_echo 'FGREP' >> "conftest.nl" - "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break - as_fn_arith $ac_count + 1 && ac_count=$as_val - if test $ac_count -gt ${ac_path_FGREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_FGREP="$ac_path_FGREP" - ac_path_FGREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_FGREP_found && break 3 - done - done - done -IFS=$as_save_IFS - if test -z "$ac_cv_path_FGREP"; then - as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 - fi -else - ac_cv_path_FGREP=$FGREP -fi - - fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 -$as_echo "$ac_cv_path_FGREP" >&6; } - FGREP="$ac_cv_path_FGREP" - - - - # Test that variable FGREP is not empty. - if test "" = "$FGREP"; then as_fn_error $? "Could not find fgrep !" "$LINENO" 5 ; fi - - -# Extract the first word of "find", so it can be a program name with args. -set dummy find; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_FIND+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $FIND in - [\\/]* | ?:[\\/]*) - ac_cv_path_FIND="$FIND" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -FIND=$ac_cv_path_FIND -if test -n "$FIND"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5 -$as_echo "$FIND" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable FIND is not empty. - if test "" = "$FIND"; then as_fn_error $? "Could not find find !" "$LINENO" 5 ; fi - - - # Test if find supports -delete - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5 -$as_echo_n "checking if find supports -delete... " >&6; } - FIND_DELETE="-delete" - - DELETEDIR=`mktemp -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?) - - echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete - - TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1` - if test -f $DELETEDIR/TestIfFindSupportsDelete; then - # No, it does not. - rm $DELETEDIR/TestIfFindSupportsDelete - FIND_DELETE="-exec rm \{\} \+" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - fi - rmdir $DELETEDIR - - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 -$as_echo_n "checking for grep that handles long lines and -e... " >&6; } -if test "${ac_cv_path_GREP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -z "$GREP"; then - ac_path_GREP_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in grep ggrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue -# Check for GNU ac_path_GREP and select it if it is found. - # Check for GNU $ac_path_GREP -case `"$ac_path_GREP" --version 2>&1` in -*GNU*) - ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; -*) - ac_count=0 - $as_echo_n 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - $as_echo 'GREP' >> "conftest.nl" - "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break - as_fn_arith $ac_count + 1 && ac_count=$as_val - if test $ac_count -gt ${ac_path_GREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_GREP="$ac_path_GREP" - ac_path_GREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_GREP_found && break 3 - done - done - done -IFS=$as_save_IFS - if test -z "$ac_cv_path_GREP"; then - as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 - fi -else - ac_cv_path_GREP=$GREP -fi - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 -$as_echo "$ac_cv_path_GREP" >&6; } - GREP="$ac_cv_path_GREP" - - - - # Test that variable GREP is not empty. - if test "" = "$GREP"; then as_fn_error $? "Could not find grep !" "$LINENO" 5 ; fi - -# Extract the first word of "head", so it can be a program name with args. -set dummy head; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_HEAD+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $HEAD in - [\\/]* | ?:[\\/]*) - ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -HEAD=$ac_cv_path_HEAD -if test -n "$HEAD"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5 -$as_echo "$HEAD" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable HEAD is not empty. - if test "" = "$HEAD"; then as_fn_error $? "Could not find head !" "$LINENO" 5 ; fi - -# Extract the first word of "ln", so it can be a program name with args. -set dummy ln; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_LN+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $LN in - [\\/]* | ?:[\\/]*) - ac_cv_path_LN="$LN" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -LN=$ac_cv_path_LN -if test -n "$LN"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5 -$as_echo "$LN" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable LN is not empty. - if test "" = "$LN"; then as_fn_error $? "Could not find ln !" "$LINENO" 5 ; fi - -# Extract the first word of "ls", so it can be a program name with args. -set dummy ls; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_LS+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $LS in - [\\/]* | ?:[\\/]*) - ac_cv_path_LS="$LS" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -LS=$ac_cv_path_LS -if test -n "$LS"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5 -$as_echo "$LS" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable LS is not empty. - if test "" = "$LS"; then as_fn_error $? "Could not find ls !" "$LINENO" 5 ; fi - -for ac_prog in gmake make -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_MAKE+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $MAKE in - [\\/]* | ?:[\\/]*) - ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -MAKE=$ac_cv_path_MAKE -if test -n "$MAKE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5 -$as_echo "$MAKE" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$MAKE" && break -done - - - # Test that variable MAKE is not empty. - if test "" = "$MAKE"; then as_fn_error $? "Could not find make !" "$LINENO" 5 ; fi - -MAKE_VERSION=`$MAKE --version | head -n 1 | grep '3.8[12346789]'` -if test "x$MAKE_VERSION" = x; then - as_fn_error $? "You must use GNU make 3.81 or newer! Please put it in the path." "$LINENO" 5 -fi -# Extract the first word of "mkdir", so it can be a program name with args. -set dummy mkdir; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_MKDIR+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $MKDIR in - [\\/]* | ?:[\\/]*) - ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -MKDIR=$ac_cv_path_MKDIR -if test -n "$MKDIR"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5 -$as_echo "$MKDIR" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable MKDIR is not empty. - if test "" = "$MKDIR"; then as_fn_error $? "Could not find mkdir !" "$LINENO" 5 ; fi - -# Extract the first word of "mv", so it can be a program name with args. -set dummy mv; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_MV+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $MV in - [\\/]* | ?:[\\/]*) - ac_cv_path_MV="$MV" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -MV=$ac_cv_path_MV -if test -n "$MV"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5 -$as_echo "$MV" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable MV is not empty. - if test "" = "$MV"; then as_fn_error $? "Could not find mv !" "$LINENO" 5 ; fi - -for ac_prog in nawk gawk awk -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_NAWK+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $NAWK in - [\\/]* | ?:[\\/]*) - ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -NAWK=$ac_cv_path_NAWK -if test -n "$NAWK"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5 -$as_echo "$NAWK" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$NAWK" && break -done - - - # Test that variable NAWK is not empty. - if test "" = "$NAWK"; then as_fn_error $? "Could not find nawk !" "$LINENO" 5 ; fi - -# Extract the first word of "printf", so it can be a program name with args. -set dummy printf; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_PRINTF+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $PRINTF in - [\\/]* | ?:[\\/]*) - ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -PRINTF=$ac_cv_path_PRINTF -if test -n "$PRINTF"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5 -$as_echo "$PRINTF" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable PRINTF is not empty. - if test "" = "$PRINTF"; then as_fn_error $? "Could not find printf !" "$LINENO" 5 ; fi - -# Extract the first word of "pwd", so it can be a program name with args. -set dummy pwd; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_THEPWDCMD+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $THEPWDCMD in - [\\/]* | ?:[\\/]*) - ac_cv_path_THEPWDCMD="$THEPWDCMD" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_THEPWDCMD="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -THEPWDCMD=$ac_cv_path_THEPWDCMD -if test -n "$THEPWDCMD"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $THEPWDCMD" >&5 -$as_echo "$THEPWDCMD" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -# Extract the first word of "rm", so it can be a program name with args. -set dummy rm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_RM+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $RM in - [\\/]* | ?:[\\/]*) - ac_cv_path_RM="$RM" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -RM=$ac_cv_path_RM -if test -n "$RM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5 -$as_echo "$RM" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable RM is not empty. - if test "" = "$RM"; then as_fn_error $? "Could not find rm !" "$LINENO" 5 ; fi - -RM="$RM -f" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 -$as_echo_n "checking for a sed that does not truncate output... " >&6; } -if test "${ac_cv_path_SED+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ - for ac_i in 1 2 3 4 5 6 7; do - ac_script="$ac_script$as_nl$ac_script" - done - echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed - { ac_script=; unset ac_script;} - if test -z "$SED"; then - ac_path_SED_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in sed gsed; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_SED="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_SED" && $as_test_x "$ac_path_SED"; } || continue -# Check for GNU ac_path_SED and select it if it is found. - # Check for GNU $ac_path_SED -case `"$ac_path_SED" --version 2>&1` in -*GNU*) - ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;; -*) - ac_count=0 - $as_echo_n 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - $as_echo '' >> "conftest.nl" - "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break - as_fn_arith $ac_count + 1 && ac_count=$as_val - if test $ac_count -gt ${ac_path_SED_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_SED="$ac_path_SED" - ac_path_SED_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_SED_found && break 3 - done - done - done -IFS=$as_save_IFS - if test -z "$ac_cv_path_SED"; then - as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5 - fi -else - ac_cv_path_SED=$SED -fi - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 -$as_echo "$ac_cv_path_SED" >&6; } - SED="$ac_cv_path_SED" - rm -f conftest.sed - - - # Test that variable SED is not empty. - if test "" = "$SED"; then as_fn_error $? "Could not find sed !" "$LINENO" 5 ; fi - -# Extract the first word of "sh", so it can be a program name with args. -set dummy sh; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_SH+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $SH in - [\\/]* | ?:[\\/]*) - ac_cv_path_SH="$SH" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -SH=$ac_cv_path_SH -if test -n "$SH"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5 -$as_echo "$SH" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable SH is not empty. - if test "" = "$SH"; then as_fn_error $? "Could not find sh !" "$LINENO" 5 ; fi - -# Extract the first word of "sort", so it can be a program name with args. -set dummy sort; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_SORT+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $SORT in - [\\/]* | ?:[\\/]*) - ac_cv_path_SORT="$SORT" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -SORT=$ac_cv_path_SORT -if test -n "$SORT"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5 -$as_echo "$SORT" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable SORT is not empty. - if test "" = "$SORT"; then as_fn_error $? "Could not find sort !" "$LINENO" 5 ; fi - -# Extract the first word of "tar", so it can be a program name with args. -set dummy tar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_TAR+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $TAR in - [\\/]* | ?:[\\/]*) - ac_cv_path_TAR="$TAR" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -TAR=$ac_cv_path_TAR -if test -n "$TAR"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5 -$as_echo "$TAR" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable TAR is not empty. - if test "" = "$TAR"; then as_fn_error $? "Could not find tar !" "$LINENO" 5 ; fi - -# Extract the first word of "tail", so it can be a program name with args. -set dummy tail; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_TAIL+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $TAIL in - [\\/]* | ?:[\\/]*) - ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -TAIL=$ac_cv_path_TAIL -if test -n "$TAIL"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5 -$as_echo "$TAIL" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable TAIL is not empty. - if test "" = "$TAIL"; then as_fn_error $? "Could not find tail !" "$LINENO" 5 ; fi - -# Extract the first word of "tee", so it can be a program name with args. -set dummy tee; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_TEE+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $TEE in - [\\/]* | ?:[\\/]*) - ac_cv_path_TEE="$TEE" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -TEE=$ac_cv_path_TEE -if test -n "$TEE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5 -$as_echo "$TEE" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable TEE is not empty. - if test "" = "$TEE"; then as_fn_error $? "Could not find tee !" "$LINENO" 5 ; fi - -# Extract the first word of "tr", so it can be a program name with args. -set dummy tr; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_TR+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $TR in - [\\/]* | ?:[\\/]*) - ac_cv_path_TR="$TR" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -TR=$ac_cv_path_TR -if test -n "$TR"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5 -$as_echo "$TR" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable TR is not empty. - if test "" = "$TR"; then as_fn_error $? "Could not find tr !" "$LINENO" 5 ; fi - -# Extract the first word of "touch", so it can be a program name with args. -set dummy touch; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_TOUCH+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $TOUCH in - [\\/]* | ?:[\\/]*) - ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -TOUCH=$ac_cv_path_TOUCH -if test -n "$TOUCH"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5 -$as_echo "$TOUCH" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable TOUCH is not empty. - if test "" = "$TOUCH"; then as_fn_error $? "Could not find touch !" "$LINENO" 5 ; fi - -# Extract the first word of "wc", so it can be a program name with args. -set dummy wc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_WC+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $WC in - [\\/]* | ?:[\\/]*) - ac_cv_path_WC="$WC" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -WC=$ac_cv_path_WC -if test -n "$WC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5 -$as_echo "$WC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable WC is not empty. - if test "" = "$WC"; then as_fn_error $? "Could not find wc !" "$LINENO" 5 ; fi - -# Extract the first word of "xargs", so it can be a program name with args. -set dummy xargs; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_XARGS+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $XARGS in - [\\/]* | ?:[\\/]*) - ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -XARGS=$ac_cv_path_XARGS -if test -n "$XARGS"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5 -$as_echo "$XARGS" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable XARGS is not empty. - if test "" = "$XARGS"; then as_fn_error $? "Could not find xargs !" "$LINENO" 5 ; fi - -# Extract the first word of "zip", so it can be a program name with args. -set dummy zip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_ZIP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $ZIP in - [\\/]* | ?:[\\/]*) - ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -ZIP=$ac_cv_path_ZIP -if test -n "$ZIP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5 -$as_echo "$ZIP" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable ZIP is not empty. - if test "" = "$ZIP"; then as_fn_error $? "Could not find zip !" "$LINENO" 5 ; fi - -# Extract the first word of "unzip", so it can be a program name with args. -set dummy unzip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_UNZIP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $UNZIP in - [\\/]* | ?:[\\/]*) - ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -UNZIP=$ac_cv_path_UNZIP -if test -n "$UNZIP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5 -$as_echo "$UNZIP" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable UNZIP is not empty. - if test "" = "$UNZIP"; then as_fn_error $? "Could not find unzip !" "$LINENO" 5 ; fi - -# Extract the first word of "ldd", so it can be a program name with args. -set dummy ldd; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_LDD+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $LDD in - [\\/]* | ?:[\\/]*) - ac_cv_path_LDD="$LDD" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -LDD=$ac_cv_path_LDD -if test -n "$LDD"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5 -$as_echo "$LDD" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -if test "x$LDD" = "x"; then - # List shared lib dependencies is used for - # debug output and checking for forbidden dependencies. - # We can build without it. - LDD="true" -fi -# Extract the first word of "otool", so it can be a program name with args. -set dummy otool; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_OTOOL+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $OTOOL in - [\\/]* | ?:[\\/]*) - ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -OTOOL=$ac_cv_path_OTOOL -if test -n "$OTOOL"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 -$as_echo "$OTOOL" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -if test "x$OTOOL" = "x"; then - OTOOL="true" -fi -# Extract the first word of "readelf", so it can be a program name with args. -set dummy readelf; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_READELF+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $READELF in - [\\/]* | ?:[\\/]*) - ac_cv_path_READELF="$READELF" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -READELF=$ac_cv_path_READELF -if test -n "$READELF"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5 -$as_echo "$READELF" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -# Extract the first word of "expr", so it can be a program name with args. -set dummy expr; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_EXPR+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $EXPR in - [\\/]* | ?:[\\/]*) - ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -EXPR=$ac_cv_path_EXPR -if test -n "$EXPR"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5 -$as_echo "$EXPR" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable EXPR is not empty. - if test "" = "$EXPR"; then as_fn_error $? "Could not find expr !" "$LINENO" 5 ; fi - -# Extract the first word of "file", so it can be a program name with args. -set dummy file; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_FILE+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $FILE in - [\\/]* | ?:[\\/]*) - ac_cv_path_FILE="$FILE" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -FILE=$ac_cv_path_FILE -if test -n "$FILE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5 -$as_echo "$FILE" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Test that variable FILE is not empty. - if test "" = "$FILE"; then as_fn_error $? "Could not find file !" "$LINENO" 5 ; fi - -# Extract the first word of "hg", so it can be a program name with args. -set dummy hg; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_HG+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $HG in - [\\/]* | ?:[\\/]*) - ac_cv_path_HG="$HG" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -HG=$ac_cv_path_HG -if test -n "$HG"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5 -$as_echo "$HG" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - -# Figure out the build and host system. -# Make sure we can run config.sub. -$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || - as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 -$as_echo_n "checking build system type... " >&6; } -if test "${ac_cv_build+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_build_alias=$build_alias -test "x$ac_build_alias" = x && - ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` -test "x$ac_build_alias" = x && - as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 -ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || - as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 -$as_echo "$ac_cv_build" >&6; } -case $ac_cv_build in -*-*-*) ;; -*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5 ;; -esac -build=$ac_cv_build -ac_save_IFS=$IFS; IFS='-' -set x $ac_cv_build -shift -build_cpu=$1 -build_vendor=$2 -shift; shift -# Remember, the first character of IFS is used to create $*, -# except with old shells: -build_os=$* -IFS=$ac_save_IFS -case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 -$as_echo_n "checking host system type... " >&6; } -if test "${ac_cv_host+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test "x$host_alias" = x; then - ac_cv_host=$ac_cv_build -else - ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || - as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 -fi - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 -$as_echo "$ac_cv_host" >&6; } -case $ac_cv_host in -*-*-*) ;; -*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5 ;; -esac -host=$ac_cv_host -ac_save_IFS=$IFS; IFS='-' -set x $ac_cv_host -shift -host_cpu=$1 -host_vendor=$2 -shift; shift -# Remember, the first character of IFS is used to create $*, -# except with old shells: -host_os=$* -IFS=$ac_save_IFS -case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac - - - - -# Check whether --with-data-model was given. -if test "${with_data_model+set}" = set; then : - withval=$with_data_model; -fi - - -if test "x$with_data_model" != x && \ - test "x$with_data_model" != x32 && \ - test "x$with_data_model" != x64 ; then - as_fn_error $? "The data model can only be 32 or 64!" "$LINENO" 5 -fi -# Translate the standard cpu-vendor-kernel-os quadruplets into -# the new HOST_.... and BUILD_... and the legacy names used by -# the openjdk build. -# It uses $host_os $host_cpu $build_os $build_cpu and $with_data_model - - # Expects $host_os $host_cpu $build_os and $build_cpu - # and $with_data_model to have been setup! - # - # Translate the standard triplet(quadruplet) definition - # of the host/build system into - # HOST_OS=aix,bsd,hpux,linux,macosx,solaris,windows - # HOST_OS_FAMILY=bsd,gnu,sysv,win32,wince - # HOST_OS_API=posix,winapi - # - # HOST_CPU=ia32,x64,sparc,sparcv9,arm,arm64,ppc,ppc64 - # HOST_CPU_ARCH=x86,sparc,pcc,arm - # HOST_CPU_BITS=32,64 - # HOST_CPU_ENDIAN=big,little - # - # The same values are setup for BUILD_... - # - # And the legacy variables, for controlling the old makefiles. - # LEGACY_HOST_CPU1=i586,amd64/x86_64,sparc,sparcv9,arm,arm64... - # LEGACY_HOST_CPU2=i386,amd64,sparc,sparcv9,arm,arm64... - # LEGACY_HOST_CPU3=sparcv9,amd64 (but only on solaris) - # LEGACY_HOST_OS_API=solaris,windows - # - # We also copy the autoconf trip/quadruplet - # verbatim to HOST and BUILD - HOST=${host} - - BUILD=${build} - - - - - case "$host_os" in - *linux*) - VAR_OS=linux - VAR_OS_API=posix - VAR_OS_FAMILY=gnu - ;; - *solaris*) - VAR_OS=solaris - VAR_OS_API=posix - VAR_OS_FAMILY=sysv - ;; - *darwin*) - VAR_OS=macosx - VAR_OS_API=posix - VAR_OS_FAMILY=bsd - ;; - *bsd*) - VAR_OS=bsd - VAR_OS_API=posix - VAR_OS_FAMILY=bsd - ;; - *cygwin*|*windows*) - VAR_OS=windows - VAR_OS_API=winapi - VAR_OS_FAMILY=windows - ;; - *) - as_fn_error $? "unsupported host operating system $host_os" "$LINENO" 5 - ;; - esac - - HOST_OS="$VAR_OS" - HOST_OS_FAMILY="$VAR_OS_FAMILY" - HOST_OS_API="$VAR_OS_API" - - - - - - if test "x$HOST_OS_API" = xposix; then - LEGACY_HOST_OS_API="solaris" - fi - if test "x$HOST_OS_API" = xwinapi; then - LEGACY_HOST_OS_API="windows" - fi - - - - - # First argument is the cpu name from the trip/quad - case "$host_cpu" in - x86_64) - VAR_CPU=x64 - VAR_CPU_ARCH=x86 - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=little - VAR_LEGACY_CPU=amd64 - ;; - i?86) - VAR_CPU=ia32 - VAR_CPU_ARCH=x86 - VAR_CPU_BITS=32 - VAR_CPU_ENDIAN=little - VAR_LEGACY_CPU=i586 - ;; - alpha*) - VAR_CPU=alpha - VAR_CPU_ARCH=alpha - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=alpha - ;; - arm*) - VAR_CPU=arm - VAR_CPU_ARCH=arm - VAR_CPU_BITS=3264 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=arm - ;; - mips) - VAR_CPU=mips - VAR_CPU_ARCH=mips - VAR_CPU_BITS=woot - VAR_CPU_ENDIAN=woot - VAR_LEGACY_CPU=mips - ;; - mipsel) - VAR_CPU=mipsel - VAR_CPU_ARCH=mips - VAR_CPU_BITS=woot - VAR_CPU_ENDIAN=woot - VAR_LEGACY_CPU=mipsel - ;; - powerpc) - VAR_CPU=ppc - VAR_CPU_ARCH=ppc - VAR_CPU_BITS=32 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=ppc - ;; - powerpc64) - VAR_CPU=ppc64 - VAR_CPU_ARCH=ppc - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=32 - VAR_LEGACY_CPU=ppc64 - ;; - sparc) - VAR_CPU=sparc - VAR_CPU_ARCH=sparc - VAR_CPU_BITS=32 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=sparc - ;; - sparc64) - VAR_CPU=sparcv9 - VAR_CPU_ARCH=sparc - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=sparc_sparcv9 - ;; - s390) - VAR_CPU=s390 - VAR_CPU_ARCH=s390 - VAR_CPU_BITS=32 - VAR_CPU_ENDIAN=woot - VAR_LEGACY_CPU=s390 - VAR_LEGACY_CPU=s390 - ;; - s390x) - VAR_CPU=s390x - VAR_CPU_ARCH=s390 - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=woot - VAR_LEGACY_CPU=s390x - ;; - *) - as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5 - ;; - esac - - # Workaround cygwin not knowing about 64 bit. - if test "x$VAR_OS" = "xwindows"; then - if test "x$PROCESSOR_IDENTIFIER" != "x"; then - PROC_ARCH=`echo $PROCESSOR_IDENTIFIER | $CUT -f1 -d' '` - case "$PROC_ARCH" in - intel64|Intel64|INTEL64|em64t|EM64T|amd64|AMD64|8664|x86_64) - VAR_CPU=x64 - VAR_CPU_BITS=64 - VAR_LEGACY_CPU=amd64 - ;; - esac - fi - fi - - if test "x$VAR_CPU_ARCH" = "xx86"; then - if test "x$with_data_model" = "x64"; then - VAR_CPU=x64 - VAR_CPU_BITS=64 - VAR_LEGACY_CPU=amd64 - fi - if test "x$with_data_model" = "x32"; then - VAR_CPU=ia32 - VAR_CPU_BITS=32 - VAR_LEGACY_CPU=i586 - fi - fi - - HOST_CPU="$VAR_CPU" - HOST_CPU_ARCH="$VAR_CPU_ARCH" - HOST_CPU_BITS="$VAR_CPU_BITS" - HOST_CPU_ENDIAN="$VAR_CPU_ENDIAN" - - - - - - - # Also store the legacy naming of the cpu. - # Ie i586 and amd64 instead of ia32 and x64 - LEGACY_HOST_CPU1="$VAR_LEGACY_CPU" - - - # And the second legacy naming of the cpu. - # Ie i386 and amd64 instead of ia32 and x64. - LEGACY_HOST_CPU2="$LEGACY_HOST_CPU1" - if test "x$LEGACY_HOST_CPU1" = xi586; then - LEGACY_HOST_CPU2=i386 - fi - - - # And the third legacy naming of the cpu. - # Ie only amd64 or sparcv9, used for the ISA_DIR on Solaris. - LEGACY_HOST_CPU3="" - if test "x$HOST_CPU" = xx64; then - LEGACY_HOST_CPU3=amd64 - fi - if test "x$HOST_CPU" = xsparcv9; then - LEGACY_HOST_CPU3=sparvc9 - fi - - - - - - case "$build_os" in - *linux*) - VAR_OS=linux - VAR_OS_API=posix - VAR_OS_FAMILY=gnu - ;; - *solaris*) - VAR_OS=solaris - VAR_OS_API=posix - VAR_OS_FAMILY=sysv - ;; - *darwin*) - VAR_OS=macosx - VAR_OS_API=posix - VAR_OS_FAMILY=bsd - ;; - *bsd*) - VAR_OS=bsd - VAR_OS_API=posix - VAR_OS_FAMILY=bsd - ;; - *cygwin*|*windows*) - VAR_OS=windows - VAR_OS_API=winapi - VAR_OS_FAMILY=windows - ;; - *) - as_fn_error $? "unsupported host operating system $build_os" "$LINENO" 5 - ;; - esac - - BUILD_OS="$VAR_OS" - BUILD_OS_FAMILY="$VAR_OS_FAMILY" - BUILD_OS_API="$VAR_OS_API" - - - - - - if test "x$BUILD_OS_API" = xposix; then - LEGACY_BUILD_OS_API="solaris" - fi - if test "x$BUILD_OS_API" = xwinapi; then - LEGACY_BUILD_OS_API="windows" - fi - - - - - # First argument is the cpu name from the trip/quad - case "$build_cpu" in - x86_64) - VAR_CPU=x64 - VAR_CPU_ARCH=x86 - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=little - VAR_LEGACY_CPU=amd64 - ;; - i?86) - VAR_CPU=ia32 - VAR_CPU_ARCH=x86 - VAR_CPU_BITS=32 - VAR_CPU_ENDIAN=little - VAR_LEGACY_CPU=i586 - ;; - alpha*) - VAR_CPU=alpha - VAR_CPU_ARCH=alpha - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=alpha - ;; - arm*) - VAR_CPU=arm - VAR_CPU_ARCH=arm - VAR_CPU_BITS=3264 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=arm - ;; - mips) - VAR_CPU=mips - VAR_CPU_ARCH=mips - VAR_CPU_BITS=woot - VAR_CPU_ENDIAN=woot - VAR_LEGACY_CPU=mips - ;; - mipsel) - VAR_CPU=mipsel - VAR_CPU_ARCH=mips - VAR_CPU_BITS=woot - VAR_CPU_ENDIAN=woot - VAR_LEGACY_CPU=mipsel - ;; - powerpc) - VAR_CPU=ppc - VAR_CPU_ARCH=ppc - VAR_CPU_BITS=32 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=ppc - ;; - powerpc64) - VAR_CPU=ppc64 - VAR_CPU_ARCH=ppc - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=32 - VAR_LEGACY_CPU=ppc64 - ;; - sparc) - VAR_CPU=sparc - VAR_CPU_ARCH=sparc - VAR_CPU_BITS=32 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=sparc - ;; - sparc64) - VAR_CPU=sparcv9 - VAR_CPU_ARCH=sparc - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=sparc_sparcv9 - ;; - s390) - VAR_CPU=s390 - VAR_CPU_ARCH=s390 - VAR_CPU_BITS=32 - VAR_CPU_ENDIAN=woot - VAR_LEGACY_CPU=s390 - VAR_LEGACY_CPU=s390 - ;; - s390x) - VAR_CPU=s390x - VAR_CPU_ARCH=s390 - VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=woot - VAR_LEGACY_CPU=s390x - ;; - *) - as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5 - ;; - esac - - # Workaround cygwin not knowing about 64 bit. - if test "x$VAR_OS" = "xwindows"; then - if test "x$PROCESSOR_IDENTIFIER" != "x"; then - PROC_ARCH=`echo $PROCESSOR_IDENTIFIER | $CUT -f1 -d' '` - case "$PROC_ARCH" in - intel64|Intel64|INTEL64|em64t|EM64T|amd64|AMD64|8664|x86_64) - VAR_CPU=x64 - VAR_CPU_BITS=64 - VAR_LEGACY_CPU=amd64 - ;; - esac - fi - fi - - if test "x$VAR_CPU_ARCH" = "xx86"; then - if test "x$with_data_model" = "x64"; then - VAR_CPU=x64 - VAR_CPU_BITS=64 - VAR_LEGACY_CPU=amd64 - fi - if test "x$with_data_model" = "x32"; then - VAR_CPU=ia32 - VAR_CPU_BITS=32 - VAR_LEGACY_CPU=i586 - fi - fi - - BUILD_CPU="$VAR_CPU" - BUILD_CPU_ARCH="$VAR_CPU_ARCH" - BUILD_CPU_BITS="$VAR_CPU_BITS" - BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN" - - - - - - - # Also store the legacy naming of the cpu. - # Ie i586 and amd64 instead of ia32 and x64 - LEGACY_BUILD_CPU1="$VAR_LEGACY_CPU" - - - # And the second legacy naming of the cpu. - # Ie i386 and amd64 instead of ia32 and x64. - LEGACY_BUILD_CPU2="$LEGACY_BUILD_CPU1" - if test "x$LEGACY_BUILD_CPU1" = xi586; then - LEGACY_BUILD_CPU2=i386 - fi - - - # And the third legacy naming of the cpu. - # Ie only amd64 or sparcv9, used for the ISA_DIR on Solaris. - LEGACY_BUILD_CPU3="" - if test "x$BUILD_CPU" = xx64; then - LEGACY_BUILD_CPU3=amd64 - fi - if test "x$BUILD_CPU" = xsparcv9; then - LEGACY_BUILD_CPU3=sparvc9 - fi - - - - if test "x$HOST_OS" != xsolaris; then - LEGACY_HOST_CPU3="" - LEGACY_BUILD_CPU3="" - fi - - # On MacOSX and MacOSX only, we have a different name for the x64 CPU in ARCH (LEGACY_HOST_CPU1) ... - if test "x$HOST_OS" = xmacosx && test "x$HOST_CPU" = xx64; then - LEGACY_HOST_CPU1="x86_64" - fi - - - if test "x$HOST_OS" = "xsolaris"; then - REQUIRED_OS_NAME=SunOS - REQUIRED_OS_VERSION=5.10 - fi - if test "x$HOST_OS" = "xlinux"; then - REQUIRED_OS_NAME=Linux - REQUIRED_OS_VERSION=2.6 - fi - if test "x$HOST_OS" = "xwindows"; then - REQUIRED_OS_NAME=Windows - REQUIRED_OS_VERSION=5.1 - fi - if test "x$HOST_OS" = "xmacosx"; then - REQUIRED_OS_NAME=Darwin - REQUIRED_OS_VERSION=11.2 - fi - - - - - -# Now the following vars are defined. -# HOST_OS=aix,bsd,hpux,linux,macosx,solaris,windows -# HOST_OS_FAMILY=bsd,gnu,sysv,win32,wince -# HOST_OS_API=posix,winapi -# -# HOST_CPU=ia32,x64,sparc,sparcv9,arm,arm64,ppc,ppc64 -# HOST_CPU_ARCH=x86,sparc,pcc,arm -# HOST_CPU_BITS=32,64 -# HOST_CPU_ENDIAN=big,little -# -# There is also a: -# LEGACY_HOST_CPU1=i586,amd64,.... # used to set the old var ARCH -# LEGACY_HOST_CPU2=i386,amd64,.... # used to set the old var LIBARCH -# LEGACY_HOST_CPU3=only sparcv9,amd64 # used to set the ISA_DIR on Solaris -# There was also a BUILDARCH that had i486,amd64,... but we do not use that -# in the new build. -# LEGACY_HOST_OS_API=solaris,windows # used to select source roots - -DATE_WHEN_CONFIGURED=`LANG=C date` - - -# How many cores do we have on this build system? - -# Check whether --with-num-cores was given. -if test "${with_num_cores+set}" = set; then : - withval=$with_num_cores; -fi - -if test "x$with_num_cores" = x; then - # The number of cores were not specified, try to probe them. - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for number of cores" >&5 -$as_echo_n "checking for number of cores... " >&6; } - NUM_CORES=1 - FOUND_CORES=no - - if test -f /proc/cpuinfo; then - # Looks like a Linux system - NUM_CORES=`cat /proc/cpuinfo | grep -c processor` - FOUND_CORES=yes - fi - - if test -x /usr/sbin/psrinfo; then - # Looks like a Solaris system - NUM_CORES=`LC_MESSAGES=C /usr/sbin/psrinfo -v | grep -c on-line` - FOUND_CORES=yes - fi - - if test -x /usr/sbin/system_profiler; then - # Looks like a MacOSX system - NUM_CORES=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Cores' | awk '{print $5}'` - FOUND_CORES=yes - fi - - if test "x$build_os" = xwindows; then - NUM_CORES=4 - fi - - # For c/c++ code we run twice as many concurrent build - # jobs than we have cores, otherwise we will stall on io. - CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` - - if test "x$FOUND_CORES" = xyes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NUM_CORES" >&5 -$as_echo "$NUM_CORES" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect number of cores, defaulting to 1!" >&5 -$as_echo "could not detect number of cores, defaulting to 1!" >&6; } - fi - - -else - NUM_CORES=$with_num_cores - CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` -fi - - - -# How many cores do we have on this build system? - -# Check whether --with-memory-size was given. -if test "${with_memory_size+set}" = set; then : - withval=$with_memory_size; -fi - -if test "x$with_memory_size" = x; then - # The memory size was not specified, try to probe it. - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for memory size" >&5 -$as_echo_n "checking for memory size... " >&6; } - # Default to 1024MB - MEMORY_SIZE=1024 - FOUND_MEM=no - - if test -f /proc/cpuinfo; then - # Looks like a Linux system - MEMORY_SIZE=`cat /proc/meminfo | grep MemTotal | awk '{print $2}'` - MEMORY_SIZE=`expr $MEMORY_SIZE / 1024` - FOUND_MEM=yes - fi - - if test -x /usr/sbin/prtconf; then - # Looks like a Solaris system - MEMORY_SIZE=`/usr/sbin/prtconf | grep "Memory size" | awk '{ print $3 }'` - FOUND_MEM=yes - fi - - if test -x /usr/sbin/system_profiler; then - # Looks like a MacOSX system - MEMORY_SIZE=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Memory' | awk '{print $2}'` - MEMORY_SIZE=`expr $MEMORY_SIZE \* 1024` - FOUND_MEM=yes - fi - - if test "x$build_os" = xwindows; then - MEMORY_SIZE=`systeminfo | grep 'Total Physical Memory:' | awk '{ print $4 }' | sed 's/,//'` - FOUND_MEM=yes - fi - - if test "x$FOUND_MEM" = xyes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MEMORY_SIZE MB" >&5 -$as_echo "$MEMORY_SIZE MB" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect memory size defaulting to 1024MB!" >&5 -$as_echo "could not detect memory size defaulting to 1024MB!" >&6; } - fi - -else - MEMORY_SIZE=$with_memory_size -fi - - -# Where is the source? It is located two levels above the configure script. -CURDIR="$PWD" -cd "$AUTOCONF_DIR/../.." -SRC_ROOT="`pwd`" - -cd "$CURDIR" - -# For cygwin we need cygpath first, since it is used everywhere. -# Extract the first word of "cygpath", so it can be a program name with args. -set dummy cygpath; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CYGPATH+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $CYGPATH in - [\\/]* | ?:[\\/]*) - ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CYGPATH=$ac_cv_path_CYGPATH -if test -n "$CYGPATH"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5 -$as_echo "$CYGPATH" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -PATH_SEP=":" -if test "x$BUILD_OS" = "xwindows"; then - if test "x$CYGPATH" = x; then - as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5 - fi - PATH_SEP=";" -fi - - - - # Fail with message the path to the source root if var SRC_ROOT contains a path with no spaces in it. - # Unless on Windows, where we can rewrite the path. - HAS_SPACE=`echo "$SRC_ROOT" | grep " "` - if test "x$HAS_SPACE" != x; then - if test "x$BUILD_OS" = "xwindows"; then - SRC_ROOT=`$CYGPATH -s -m -a "$SRC_ROOT"` - SRC_ROOT=`$CYGPATH -u "$SRC_ROOT"` - else - as_fn_error $? "You cannot have spaces in the path to the source root! \"$SRC_ROOT\"" "$LINENO" 5 - fi - fi - - - # Fail with message the path to the current directory if var CURDIR contains a path with no spaces in it. - # Unless on Windows, where we can rewrite the path. - HAS_SPACE=`echo "$CURDIR" | grep " "` - if test "x$HAS_SPACE" != x; then - if test "x$BUILD_OS" = "xwindows"; then - CURDIR=`$CYGPATH -s -m -a "$CURDIR"` - CURDIR=`$CYGPATH -u "$CURDIR"` - else - as_fn_error $? "You cannot have spaces in the path to the current directory! \"$CURDIR\"" "$LINENO" 5 - fi - fi - - -if test "x$BUILD_OS" = "xsolaris"; then - # Also search in /usr/ccs/bin for utilities like ar and as. - PATH="/usr/ccs/bin:$PATH" -fi - -############################################################################### -# -# OpenJDK or closed -# -# Check whether --enable-openjdk-only was given. -if test "${enable_openjdk_only+set}" = set; then : - enableval=$enable_openjdk_only; -fi - - -if test "x$enable_openjdk_only" = "xyes"; then - OPENJDK=true -elif test "x$enable_openjdk_only" = "xno"; then - OPENJDK=false -elif test -d "$SRC_ROOT/jdk/src/closed"; then - OPENJDK=false -else - OPENJDK=true -fi - -if test "x$OPENJDK" = "xtrue"; then - SET_OPENJDK=OPENJDK=true -fi - - - -############################################################################### -# -# JIGSAW or not. The JIGSAW variable is used during the intermediate -# stage when we are building both the old style JDK and the new style modularized JDK. -# When the modularized JDK is finalized, this option will go away. -# -# Check whether --enable-jigsaw was given. -if test "${enable_jigsaw+set}" = set; then : - enableval=$enable_jigsaw; -fi - - -if test "x$enable_jigsaw" = "xyes"; then - JIGSAW=true -else - JIGSAW=false -fi - - -############################################################################### -# -# Check which variant of the JDK that we want to build. -# Currently we have: -# normal: standard edition -# embedded: cut down to a smaller footprint -# -# Effectively the JDK variant gives a name to a specific set of -# modules to compile into the JDK. In the future, these modules -# might even be Jigsaw modules. -# -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5 -$as_echo_n "checking which variant of the JDK to build... " >&6; } - -# Check whether --with-jdk-variant was given. -if test "${with_jdk_variant+set}" = set; then : - withval=$with_jdk_variant; -fi - - -if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then - JAVASE_EMBEDDED="" - MINIMIZE_RAM_USAGE="" - JDK_VARIANT="normal" -elif test "x$with_jdk_variant" = xembedded; then - JAVASE_EMBEDDED="JAVASE_EMBEDDED:=true" - MINIMIZE_RAM_USAGE="MINIMIZE_RAM_USAGE:=true" - JDK_VARIANT="embedded" -else - as_fn_error $? "The available JDK variants are: normal, embedded" "$LINENO" 5 -fi - - - - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5 -$as_echo "$JDK_VARIANT" >&6; } - -############################################################################### -# -# Should we build a JDK/JVM with head support (ie a graphical ui)? -# We always build headless support. -# -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5 -$as_echo_n "checking headful support... " >&6; } -# Check whether --enable-headful was given. -if test "${enable_headful+set}" = set; then : - enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful} -else - SUPPORT_HEADFUL=yes -fi - - -SUPPORT_HEADLESS=yes -BUILD_HEADLESS="BUILD_HEADLESS:=true" - -if test "x$SUPPORT_HEADFUL" = xyes; then - # We are building both headful and headless. - BUILD_HEADLESS_ONLY="" - headful_msg="inlude support for both headful and headless" -fi - -if test "x$SUPPORT_HEADFUL" = xno; then - # Thus we are building headless only. - BUILD_HEADLESS="BUILD_HEADLESS:=true" - BUILD_HEADLESS_ONLY="BUILD_HEADLESS_ONLY:=true" - headful_msg="headless only" -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5 -$as_echo "$headful_msg" >&6; } - - - - - - -############################################################################### -# -# Check which variants of the JVM that we want to build. -# Currently we have: -# server: normal interpreter and a tiered C1/C2 compiler -# client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms) -# kernel: kernel footprint JVM that passes the TCK without major performance problems, -# ie normal interpreter and C1, only the serial GC, kernel jvmti etc -# zero: no machine code interpreter, no compiler -# zeroshark: zero interpreter and shark/llvm compiler backend -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM that should be built" >&5 -$as_echo_n "checking which variants of the JVM that should be built... " >&6; } - -# Check whether --with-jvm-variants was given. -if test "${with_jvm_variants+set}" = set; then : - withval=$with_jvm_variants; -fi - - -if test "x$with_jvm_variants" = x; then - if test "x$JDK_VARIANT" = xembedded; then - with_jvm_variants="kernel" - elif test "x$HOST_CPU_BITS" = x64; then - with_jvm_variants="server" - else - # Yes, on 32-bit machines, the same source (almost) is compiled twice - # to generate two libjvm.so files. Fun, fun. - with_jvm_variants="client,server" - fi -fi - -JVM_VARIANTS=",$with_jvm_variants," -TEST_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,//' -e 's/client,//' -e 's/kernel,//' -e 's/zero,//' -e 's/zeroshark,//'` - -if test "x$TEST_VARIANTS" != "x,"; then - as_fn_error $? "The available JVM variants are: server, client, kernel, zero, zeroshark" "$LINENO" 5 -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5 -$as_echo "$with_jvm_variants" >&6; } - -JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'` -JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'` -JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'` -JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'` -JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'` - -if test "x$JVM_VARIANT_CLIENT" = xtrue; then - if test "x$HOST_CPU_BITS" = x64; then - as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5 - fi -fi -if test "x$JVM_VARIANT_KERNEL" = xtrue; then - if test "x$HOST_CPU_BITS" = x64; then - as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5 - fi -fi - -COUNT_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,/1/' -e 's/client,/1/' -e 's/kernel,/1/' -e 's/zero,/1/' -e 's/zeroshark,/1/'` -# Replace the commas with AND for use in the build directory name. -ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/'` -if test "x$COUNT_VARIANTS" != "x,1"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: NOTE! Longer build time since we are building more than one version of the libjvm! $with_jvm_variants" >&5 -$as_echo "$as_me: NOTE! Longer build time since we are building more than one version of the libjvm! $with_jvm_variants" >&6;} -fi - - - - - - - - -############################################################################### -# -# Set the debug level -# release: no debug information, all optimizations, no asserts. -# fastdebug: debug information (-g), all optimizations, all asserts -# slowdebug: debug information (-g), no optimizations, all asserts -# -DEBUG_LEVEL="release" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5 -$as_echo_n "checking which debug level to use... " >&6; } -# Check whether --enable-debug was given. -if test "${enable_debug+set}" = set; then : - enableval=$enable_debug; - ENABLE_DEBUG="${enableval}" - DEBUG_LEVEL="fastdebug" - -else - ENABLE_DEBUG="no" -fi - - - -# Check whether --with-debug-level was given. -if test "${with_debug_level+set}" = set; then : - withval=$with_debug_level; - DEBUG_LEVEL="${withval}" - if test "x$ENABLE_DEBUG" = xyes; then - as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5 - fi - -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5 -$as_echo "$DEBUG_LEVEL" >&6; } - -if test "x$DEBUG_LEVEL" != xrelease && \ - test "x$DEBUG_LEVEL" != xfastdebug && \ - test "x$DEBUG_LEVEL" != xslowdebug; then - as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5 -fi - -case $DEBUG_LEVEL in - release ) - VARIANT="OPT" - FASTDEBUG="false" - DEBUG_CLASSFILES="false" - BUILD_VARIANT_RELEASE="" - ;; - fastdebug ) - VARIANT="DBG" - FASTDEBUG="true" - DEBUG_CLASSFILES="true" - BUILD_VARIANT_RELEASE="-fastdebug" - ;; - slowdebug ) - VARIANT="DBG" - FASTDEBUG="false" - DEBUG_CLASSFILES="true" - BUILD_VARIANT_RELEASE="-debug" - ;; -esac - - - - - - - -# Source the version numbers -. $AUTOCONF_DIR/version.numbers -if test "x$OPENJDK" = "xfalse"; then - . $AUTOCONF_DIR/closed.version.numbers -fi -# Now set the JDK version, milestone, build number etc. - - - - - - - - - - - - -COPYRIGHT_YEAR=`date +'%Y'` - - -RUNTIME_NAME="$PRODUCT_NAME $PRODUCT_SUFFIX" - - -if test "x$JDK_UPDATE_VERSION" != x; then - JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}" -else - JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}" -fi - - -if test "x$MILESTONE" != x; then - RELEASE="${JDK_VERSION}-${MILESTONE}${BUILD_VARIANT_RELEASE}" -else - RELEASE="${JDK_VERSION}${BUILD_VARIANT_RELEASE}" -fi - - -if test "x$JDK_BUILD_NUMBER" != x; then - FULL_VERSION="${RELEASE}-${JDK_BUILD_NUMBER}" -else - JDK_BUILD_NUMBER=b00 - BUILD_DATE=`date '+%Y_%m_%d_%H_%M'` - # Avoid [:alnum:] since it depends on the locale. - CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyz0123456789'` - USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvqxyz'` - FULL_VERSION="${RELEASE}-${USER_RELEASE_SUFFIX}-${JDK_BUILD_NUMBER}" -fi - -COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'` - - -# Test from where we are running configure, in or outside of src root. -if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" || test "x$CURDIR" = "x$SRC_ROOT/common/makefiles" ; then - # We are running configure from the src root. - # Create a default ./build/host-variant-debuglevel output root. - CONF_NAME="${HOST_OS}-${HOST_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}" - OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}" - mkdir -p "$OUTPUT_ROOT" - if test ! -d "$OUTPUT_ROOT"; then - as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5 - fi -else - # We are running configure from outside of the src dir. - # Then use the current directory as output dir! - # If configuration is situated in normal build directory, just use the build - # directory name as configuration name, otherwise use the complete path. - CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"` - OUTPUT_ROOT="$CURDIR" -fi - - - # Fail with message the path to the output root if var OUTPUT_ROOT contains a path with no spaces in it. - # Unless on Windows, where we can rewrite the path. - HAS_SPACE=`echo "$OUTPUT_ROOT" | grep " "` - if test "x$HAS_SPACE" != x; then - if test "x$BUILD_OS" = "xwindows"; then - OUTPUT_ROOT=`$CYGPATH -s -m -a "$OUTPUT_ROOT"` - OUTPUT_ROOT=`$CYGPATH -u "$OUTPUT_ROOT"` - else - as_fn_error $? "You cannot have spaces in the path to the output root! \"$OUTPUT_ROOT\"" "$LINENO" 5 - fi - fi - - -# Save the arguments given to us -echo "$CONFIGURE_COMMAND_LINE" > $OUTPUT_ROOT/configure-arguments - -# Check if the VS env variables were setup prior to running configure. -# If not, then find vcvarsall.bat and run it automatically, and integrate -# the set env variables into the spec file. -SETUPDEVENV="# No special vars" -if test "x$BUILD_OS" = "xwindows"; then - # If vcvarsall.bat has been run, then VCINSTALLDIR is set. - if test "x$VCINSTALLDIR" != x; then - # No further setup is needed. The build will happen from this kind - # of shell. - SETUPDEVENV="# This spec file expects that you are running bash from within a VS command prompt." - # Make sure to remind you, if you forget to run make from a cygwin bash shell - # that is spawned "bash -l" from a VS command prompt. - CHECK_FOR_VCINSTALLDIR=yes - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if you are running from within a VS command prompt" >&5 -$as_echo_n "checking if you are running from within a VS command prompt... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - else - # Ah, we have not yet run vcvarsall.bat/vsvars32.bat/vsvars64.bat. Lets do that. First find it. - if test "x$VS100COMNTOOLS" != x; then - VARSBAT=`find "$VS100COMNTOOLS/../.." -name vcvarsall.bat` - SEARCH_ROOT="$VS100COMNTOOLS" - else - VARSBAT=`find "$PROGRAMFILES" -name vcvarsall.bat` - SEARCH_ROOT="$PROGRAMFILES" - fi - VCPATH=`dirname "$VARSBAT"` - VCPATH=`cygpath -w "$VCPATH"` - if test "x$VARSBAT" = x || test ! -d "$VCPATH"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can find the VS installation" >&5 -$as_echo_n "checking if we can find the VS installation... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - as_fn_error $? "Tried to find a VS installation using both $SEARCH_ROOT but failed. Please run \"c:\\cygwin\\bin\\bash.exe -l\" from a VS command prompt and then run configure/make from there." "$LINENO" 5 - fi - case "$LEGACY_HOST_CPU1" in - i?86) - VARSBAT_ARCH=x86 - ;; - *) - VARSBAT_ARCH=$LEGACY_HOST_CPU1 - ;; - esac - # Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat - cd $OUTPUT_ROOT - bash $SRC_ROOT/common/bin/extractvcvars.sh "$VARSBAT" "$VARSBAT_ARCH" - cd $CURDIR - if test ! -s $OUTPUT_ROOT/localdevenv.sh || test ! -s $OUTPUT_ROOT/localdevenv.gmk; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can extract the needed env variables" >&5 -$as_echo_n "checking if we can extract the needed env variables... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - as_fn_error $? "Could not succesfully extract the env variables needed for the VS setup. Please run \"c:\\cygwin\\bin\\bash.exe -l\" from a VS command prompt and then run configure/make from there." "$LINENO" 5 - fi - # Now set all paths and other env variables. This will allow the rest of - # the configure script to find and run the compiler in the proper way. - . $OUTPUT_ROOT/localdevenv.sh - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can find the VS installation" >&5 -$as_echo_n "checking if we can find the VS installation... " >&6; } - if test "x$VCINSTALLDIR" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $VCINSTALLDIR" >&5 -$as_echo "$VCINSTALLDIR" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - as_fn_error $? "Could not find VS installation. Please install. If you are sure you have installed VS, then please run \"c:\\cygwin\\bin\\bash.exe -l\" from a VS command prompt and then run configure/make from there." "$LINENO" 5 - fi - CHECK_FOR_VCINSTALLDIR=no - SETUPDEVENV="include $OUTPUT_ROOT/localdevenv.gmk" - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5 -$as_echo_n "checking for msvcr100.dll... " >&6; } - -# Check whether --with-msvcr100dll was given. -if test "${with_msvcr100dll+set}" = set; then : - withval=$with_msvcr100dll; -fi - - if test "x$with_msvcr100dll" != x; then - MSVCR100DLL="$with_msvcr100dll" - else - if test "x$HOST_CPU_BITS" = x64; then - MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | grep x64 | head --lines 1` - else - MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | grep x86 | grep -v ia64 | grep -v x64 | head --lines 1` - if test "x$MSVCR100DLL" = x; then - MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | head --lines 1` - fi - fi - fi - if test "x$MSVCR100DLL" = x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - as_fn_error $? "Could not find msvcr100.dll !" "$LINENO" 5 - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR100DLL" >&5 -$as_echo "$MSVCR100DLL" >&6; } - - # Fail with message the path to msvcr100.dll if var MSVCR100DLL contains a path with no spaces in it. - # Unless on Windows, where we can rewrite the path. - HAS_SPACE=`echo "$MSVCR100DLL" | grep " "` - if test "x$HAS_SPACE" != x; then - if test "x$BUILD_OS" = "xwindows"; then - MSVCR100DLL=`$CYGPATH -s -m -a "$MSVCR100DLL"` - MSVCR100DLL=`$CYGPATH -u "$MSVCR100DLL"` - else - as_fn_error $? "You cannot have spaces in the path to msvcr100.dll! \"$MSVCR100DLL\"" "$LINENO" 5 - fi - fi - - fi -fi - - - - -# Most of the probed defines are put into config.h -ac_config_headers="$ac_config_headers $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in" - -# The spec.gmk file contains all variables for the make system. -ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in" - -# The generated Makefile knows where the spec.gmk is and where the source is. -# You can run make from the OUTPUT_ROOT. If you have only -# one configured host, then you can also run make from the SRC_ROOT, -# since it will go look for a single spec.gmk file. Or perhaps it -# should instead make all configured hosts it can find? -ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in" - - -SPEC=$OUTPUT_ROOT/spec.gmk - -CONF_NAME=$CONF_NAME - -OUTPUT_ROOT=$OUTPUT_ROOT - - -# Where are the sources. Any of these can be overridden -# using --with-override-corba and the likes. -LANGTOOLS_TOPDIR="$SRC_ROOT/langtools" -CORBA_TOPDIR="$SRC_ROOT/corba" -JAXP_TOPDIR="$SRC_ROOT/jaxp" -JAXWS_TOPDIR="$SRC_ROOT/jaxws" -HOTSPOT_TOPDIR="$SRC_ROOT/hotspot" -JDK_TOPDIR="$SRC_ROOT/jdk" - - - - - - - -# Check if pkg-config is available. - - -if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then - if test -n "$ac_tool_prefix"; then - # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args. -set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_PKG_CONFIG+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $PKG_CONFIG in - [\\/]* | ?:[\\/]*) - ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -PKG_CONFIG=$ac_cv_path_PKG_CONFIG -if test -n "$PKG_CONFIG"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5 -$as_echo "$PKG_CONFIG" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -fi -if test -z "$ac_cv_path_PKG_CONFIG"; then - ac_pt_PKG_CONFIG=$PKG_CONFIG - # Extract the first word of "pkg-config", so it can be a program name with args. -set dummy pkg-config; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_ac_pt_PKG_CONFIG+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $ac_pt_PKG_CONFIG in - [\\/]* | ?:[\\/]*) - ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG -if test -n "$ac_pt_PKG_CONFIG"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5 -$as_echo "$ac_pt_PKG_CONFIG" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - if test "x$ac_pt_PKG_CONFIG" = x; then - PKG_CONFIG="" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - PKG_CONFIG=$ac_pt_PKG_CONFIG - fi -else - PKG_CONFIG="$ac_cv_path_PKG_CONFIG" -fi - -fi -if test -n "$PKG_CONFIG"; then - _pkg_min_version=0.9.0 - { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5 -$as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; } - if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - PKG_CONFIG="" - fi - -fi - - -# Check whether --with-builddeps-conf was given. -if test "${with_builddeps_conf+set}" = set; then : - withval=$with_builddeps_conf; -fi - - - -# Check whether --with-builddeps-server was given. -if test "${with_builddeps_server+set}" = set; then : - withval=$with_builddeps_server; -fi - - - -# Check whether --with-builddeps-dir was given. -if test "${with_builddeps_dir+set}" = set; then : - withval=$with_builddeps_dir; -else - with_builddeps_dir=/localhome/builddeps -fi - - - -# Check whether --with-builddeps-group was given. -if test "${with_builddeps_group+set}" = set; then : - withval=$with_builddeps_group; -fi - - -# Check whether --enable-list-builddeps was given. -if test "${enable_list_builddeps+set}" = set; then : - enableval=$enable_list_builddeps; LIST_BUILDDEPS="${enableval}" -else - LIST_BUILDDEPS='no' -fi - - -if test "x$LIST_BUILDDEPS" = xyes; then - echo - echo List of build dependencies known to the configure script, - echo that can be used in builddeps.conf files: - cat $SRC_ROOT/configure.ac | grep BDEPS_CHECK_MODUL | grep -v configure.ac | cut -f 2 -d ',' | tr -d ' ' | sort - echo +for file in configure.ac *.m4 ; do + if $TEST $file -nt generated-configure.sh; then + print_error_not_up_to_date exit 1 -fi - -# If builddeps server or conf file is given. Setup buildeps usage. - - - if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then - if test "x$with_builddeps_conf" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5 -$as_echo_n "checking for supplied builddeps configuration file... " >&6; } - builddepsfile=$with_builddeps_conf - if test -s $builddepsfile; then - . $builddepsfile - { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5 -$as_echo "loaded!" >&6; } - else - as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5 - fi - else - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5 -$as_echo_n "checking for builddeps.conf files in sources...... " >&6; } - builddepsfile=`mktemp` - touch $builddepsfile - # Put all found confs into a single file. - find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile - # Source the file to acquire the variables - if test -s $builddepsfile; then - . $builddepsfile - { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5 -$as_echo "found at least one!" >&6; } - else - as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5 - fi - fi - # Create build and host names that use _ instead of "-" and ".". - # This is necessary to use them in variable names. - build_var=`echo ${build} | tr '-' '_' | tr '.' '_'` - host_var=`echo ${host} | tr '-' '_' | tr '.' '_'` - # Extract rewrite information for build and host - eval rewritten_build=\${REWRITE_${build_var}} - if test "x$rewritten_build" = x; then - rewritten_build=${build} - echo Build stays the same $rewritten_build - else - echo Rewriting build for builddeps into $rewritten_build - fi - eval rewritten_host=\${REWRITE_${host_var}} - if test "x$rewritten_host" = x; then - rewritten_host=${host} - echo Host stays the same $rewritten_host - else - echo Rewriting host for builddeps into $rewritten_host - fi - rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'` - rewritten_host_var=`echo ${rewritten_host} | tr '-' '_' | tr '.' '_'` - fi - for ac_prog in 7z unzip -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_BDEPS_UNZIP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$BDEPS_UNZIP"; then - ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_BDEPS_UNZIP="$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 fi done - done -IFS=$as_save_IFS -fi -fi -BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP -if test -n "$BDEPS_UNZIP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5 -$as_echo "$BDEPS_UNZIP" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$BDEPS_UNZIP" && break -done - - if test "x$BDEPS_UNZIP" = x7z; then - BDEPS_UNZIP="7z x" +if $TEST -e $conf_closed_script_dir/generated-configure.sh; then + # If closed source configure is available, make sure it is up-to-date as well. + for file in configure.ac *.m4 $conf_closed_script_dir/*.m4; do + if $TEST $file -nt $conf_closed_script_dir/generated-configure.sh; then + print_error_not_up_to_date + exit 1 fi - - for ac_prog in wget lftp ftp -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_BDEPS_FTP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$BDEPS_FTP"; then - ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_BDEPS_FTP="$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done done -IFS=$as_save_IFS -fi -fi -BDEPS_FTP=$ac_cv_prog_BDEPS_FTP -if test -n "$BDEPS_FTP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5 -$as_echo "$BDEPS_FTP" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + # Test if open configure is newer than closed configure, if so, closed needs to + # be regenerated. + conf_open_configure_timestamp=`grep DATE_WHEN_GENERATED: $conf_script_dir/generated-configure.sh | cut -d" " -f 3` + conf_closed_configure_timestamp=`grep DATE_WHEN_GENERATED: $conf_closed_script_dir/generated-configure.sh | cut -d" " -f 3` + if $TEST $conf_open_configure_timestamp -gt $conf_closed_configure_timestamp; then + print_error_not_up_to_date + exit 1 + fi + fi +### +### Process command-line arguments +### +conf_processed_arguments= +conf_openjdk_target= +conf_extra_cflags= +conf_extra_cxxflags= - test -n "$BDEPS_FTP" && break -done - - - -############################################################################### -# -# Configure the development tool paths and potential sysroot. -# -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - -DEVKIT= -SYS_ROOT=/ - - -# The option used to specify the target .o,.a or .so file. -# When compiling, how to specify the to be created object file. -CC_OUT_OPTION='-o$(SPACE)' -# When linking, how to specify the to be created executable. -EXE_OUT_OPTION='-o$(SPACE)' -# When linking, how to specify the to be created dynamically linkable library. -LD_OUT_OPTION='-o$(SPACE)' -# When archiving, how to specify the to be create static archive for object files. -AR_OUT_OPTION='rcs$(SPACE)' - - - - - -# If --build AND --host is set, then the configure script will find any -# cross compilation tools in the PATH. Cross compilation tools -# follows the cross compilation standard where they are prefixed with ${host}. -# For example the binary i686-sun-solaris2.10-gcc -# will cross compile for i686-sun-solaris2.10 -# If neither of build and host is not set, then build=host and the -# default compiler found in the path will be used. -# Setting only --host, does not seem to be really supported. -# Please set both --build and --host if you want to cross compile. - -DEFINE_CROSS_COMPILE_ARCH="" -HOSTCC="" -HOSTCXX="" - - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if this is a cross compile" >&5 -$as_echo_n "checking if this is a cross compile... " >&6; } -if test "x$build_var" != "x$host_var"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, from $build_var to $host_var" >&5 -$as_echo "yes, from $build_var to $host_var" >&6; } - # We have detected a cross compile! - DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$LEGACY_HOST_CPU1" - # Now we to find a C/C++ compiler that can build executables for the build - # platform. We can't use the AC_PROG_CC macro, since it can only be used - # once. - for ac_prog in cl cc gcc +for conf_option do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_HOSTCC+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $HOSTCC in - [\\/]* | ?:[\\/]*) - ac_cv_path_HOSTCC="$HOSTCC" # Let the user override the test with a path. - ;; + case $conf_option in + --openjdk-target=*) + conf_openjdk_target=`expr "X$conf_option" : '[^=]*=\(.*\)'` + continue ;; + --with-extra-cflags=*) + conf_extra_cflags=`expr "X$conf_option" : '[^=]*=\(.*\)'` + continue ;; + --with-extra-cxxflags=*) + conf_extra_cxxflags=`expr "X$conf_option" : '[^=]*=\(.*\)'` + continue ;; *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_HOSTCC="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -HOSTCC=$ac_cv_path_HOSTCC -if test -n "$HOSTCC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOSTCC" >&5 -$as_echo "$HOSTCC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$HOSTCC" && break -done - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$HOSTCC" - car="${tmp%% *}" - tmp="$HOSTCC EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - HOSTCC="$car ${cdr% *}" - else - HOSTCC="$car" - fi - - for ac_prog in cl CC g++ -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_HOSTCXX+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $HOSTCXX in - [\\/]* | ?:[\\/]*) - ac_cv_path_HOSTCXX="$HOSTCXX" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_HOSTCXX="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -HOSTCXX=$ac_cv_path_HOSTCXX -if test -n "$HOSTCXX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOSTCXX" >&5 -$as_echo "$HOSTCXX" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$HOSTCXX" && break -done - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$HOSTCXX" - car="${tmp%% *}" - tmp="$HOSTCXX EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - HOSTCXX="$car ${cdr% *}" - else - HOSTCXX="$car" - fi - - # Building for the build platform should be easy. Therefore - # we do not need any linkers or assemblers etc. -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - -# You can force the sys-root if the sys-root encoded into the cross compiler tools -# is not correct. - -# Check whether --with-sys-root was given. -if test "${with_sys_root+set}" = set; then : - withval=$with_sys_root; -fi - - -if test "x$with_sys_root" != x; then - SYS_ROOT=$with_sys_root -fi - -# If a devkit is found on the builddeps server, then prepend its path to the -# PATH variable. If there are cross compilers available in the devkit, these -# will be found by AC_PROG_CC et al. - - - if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then - # Source the builddeps file again, to make sure it uses the latest variables! - . $builddepsfile - # Look for a host and build machine specific resource! - eval resource=\${builddep_devkit_BUILD_${rewritten_build_var}_HOST_${rewritten_host_var}} - if test "x$resource" = x; then - # Ok, lets instead look for a host specific resource - eval resource=\${builddep_devkit_HOST_${rewritten_host_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a build specific resource - eval resource=\${builddep_devkit_BUILD_${rewritten_build_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a generic resource - # (The devkit comes from M4 and not the shell, thus no need for eval here.) - resource=${builddep_devkit} - fi - if test "x$resource" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for devkit" >&5 -$as_echo "$as_me: Using builddeps $resource for devkit" >&6;} - # If the resource in the builddeps.conf file is an existing directory, - # for example /java/linux/cups - if test -d ${resource}; then - depdir=${resource} - else - -# devkit is for example mymodule -# $resource is for example libs/general/libmymod_1_2_3.zip -# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps -# $with_builddeps_dir is for example /localhome/builddeps -# depdir is the name of the variable into which we store the depdir, eg MYMOD -# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and -# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 - filename=`basename $resource` - filebase=`echo $filename | sed 's/\.[^\.]*$//'` - filebase=${filename%%.*} - extension=${filename#*.} - installdir=$with_builddeps_dir/$filebase - if test ! -f $installdir/$filename.unpacked; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency devkit from $with_builddeps_server/$resource and installing into $installdir" >&5 -$as_echo "$as_me: Downloading build dependency devkit from $with_builddeps_server/$resource and installing into $installdir" >&6;} - if test ! -d $installdir; then - mkdir -p $installdir - fi - if test ! -d $installdir; then - as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 - fi - tmpfile=`mktemp $installdir/devkit.XXXXXXXXX` - touch $tmpfile - if test ! -f $tmpfile; then - as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 - fi - - # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip - # $tmpfile is the local file name for the downloaded file. - VALID_TOOL=no - if test "x$BDEPS_FTP" = xwget; then - VALID_TOOL=yes - wget -O $tmpfile $with_builddeps_server/$resource - fi - if test "x$BDEPS_FTP" = xlftp; then - VALID_TOOL=yes - lftp -c "get $with_builddeps_server/$resource -o $tmpfile" - fi - if test "x$BDEPS_FTP" = xftp; then - VALID_TOOL=yes - FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` - FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` - FTPUSERPWD=${FTPSERVER%%@*} - if test "x$FTPSERVER" != "x$FTPUSERPWD"; then - FTPUSER=${userpwd%%:*} - FTPPWD=${userpwd#*@} - FTPSERVER=${FTPSERVER#*@} - else - FTPUSER=ftp - FTPPWD=ftp - fi - # the "pass" command does not work on some - # ftp clients (read ftp.exe) but if it works, - # passive mode is better! - (\ - echo "user $FTPUSER $FTPPWD" ;\ - echo "pass" ;\ - echo "bin" ;\ - echo "get $FTPPATH $tmpfile" ;\ - ) | ftp -in $FTPSERVER - fi - if test "x$VALID_TOOL" != xyes; then - as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 - fi - - mv $tmpfile $installdir/$filename - if test ! -s $installdir/$filename; then - as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 - fi - case "$extension" in - zip) echo "Unzipping $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) - ;; - tar.gz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - tgz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 - ;; - esac - fi - if test -f $installdir/$filename.unpacked; then - depdir=$installdir - fi - - fi - # Source the builddeps file again, because in the previous command, the depdir - # was updated to point at the current build dependency install directory. - . $builddepsfile - # Now extract variables from the builddeps.conf files. - theroot=${builddep_devkit_ROOT} - thecflags=${builddep_devkit_CFLAGS} - thelibs=${builddep_devkit_LIBS} - if test "x$depdir" = x; then - as_fn_error $? "Could not download build dependency devkit" "$LINENO" 5 - fi - DEVKIT=$depdir - if test "x$theroot" != x; then - DEVKIT="$theroot" - fi - if test "x$thecflags" != x; then - DEVKIT_CFLAGS="$thecflags" - fi - if test "x$thelibs" != x; then - DEVKIT_LIBS="$thelibs" - fi - # Found devkit - PATH="$DEVKIT/bin:$PATH" - SYS_ROOT="$DEVKIT/${rewritten_host}/sys-root" - if test "x$x_includes" = "xNONE"; then - x_includes="$SYS_ROOT/usr/include/X11" - fi - if test "x$x_libraries" = "xNONE"; then - x_libraries="$SYS_ROOT/usr/lib" - fi - - - fi - - fi - - -if test "x$SYS_ROOT" != "x/" ; then - CFLAGS="--sysroot=$SYS_ROOT $CFLAGS" - CXXFLAGS="--sysroot=$SYS_ROOT $CXXFLAGS" - OBJCFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" - OBJCXXFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" - CPPFLAGS="--sysroot=$SYS_ROOT $CPPFLAGS" - LDFLAGS="--sysroot=$SYS_ROOT $LDFLAGS" -fi - -# Store the CFLAGS etal passed to the configure script. -ORG_CFLAGS="$CFLAGS" -ORG_CXXFLAGS="$CXXFLAGS" -ORG_OBJCFLAGS="$OBJCFLAGS" - -prepare_help_system - -# gcc is almost always present, but on Windows we -# prefer cl.exe and on Solaris we prefer CC. -# Thus test for them in this order. -ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu -if test -n "$ac_tool_prefix"; then - for ac_prog in cl cc gcc - do - # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. -set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CC+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$CC"; then - ac_cv_prog_CC="$CC" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_CC="$ac_tool_prefix$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -CC=$ac_cv_prog_CC -if test -n "$CC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -$as_echo "$CC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$CC" && break - done -fi -if test -z "$CC"; then - ac_ct_CC=$CC - for ac_prog in cl cc gcc -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$ac_ct_CC"; then - ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_ac_ct_CC="$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -ac_ct_CC=$ac_cv_prog_ac_ct_CC -if test -n "$ac_ct_CC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 -$as_echo "$ac_ct_CC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$ac_ct_CC" && break -done - - if test "x$ac_ct_CC" = x; then - CC="" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - CC=$ac_ct_CC - fi -fi - - -test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "no acceptable C compiler found in \$PATH -See \`config.log' for more details" "$LINENO" 5 ; } - -# Provide some information about the compiler. -$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 -set X $ac_compile -ac_compiler=$2 -for ac_option in --version -v -V -qversion; do - { { ac_try="$ac_compiler $ac_option >&5" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_compiler $ac_option >&5") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - sed '10a\ -... rest of stderr output deleted ... - 10q' conftest.err >conftest.er1 - cat conftest.er1 >&5 - fi - rm -f conftest.er1 conftest.err - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } -done - -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -ac_clean_files_save=$ac_clean_files -ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" -# Try to create an executable without -o first, disregard a.out. -# It will help us diagnose broken compilers, and finding out an intuition -# of exeext. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 -$as_echo_n "checking whether the C compiler works... " >&6; } -ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` - -# The possible output files: -ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" - -ac_rmfiles= -for ac_file in $ac_files -do - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; - * ) ac_rmfiles="$ac_rmfiles $ac_file";; - esac -done -rm -f $ac_rmfiles - -if { { ac_try="$ac_link_default" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_link_default") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then : - # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. -# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' -# in a Makefile. We should not override ac_cv_exeext if it was cached, -# so that the user can short-circuit this test for compilers unknown to -# Autoconf. -for ac_file in $ac_files '' -do - test -f "$ac_file" || continue - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) - ;; - [ab].out ) - # We found the default executable, but exeext='' is most - # certainly right. - break;; - *.* ) - if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; - then :; else - ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` - fi - # We set ac_cv_exeext here because the later test for it is not - # safe: cross compilers may not add the suffix if given an `-o' - # argument, so we may need to know it at that point already. - # Even if this section looks crufty: it has the advantage of - # actually working. - break;; - * ) - break;; - esac -done -test "$ac_cv_exeext" = no && ac_cv_exeext= - -else - ac_file='' -fi -if test -z "$ac_file"; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -$as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - -{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error 77 "C compiler cannot create executables -See \`config.log' for more details" "$LINENO" 5 ; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 -$as_echo_n "checking for C compiler default output file name... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 -$as_echo "$ac_file" >&6; } -ac_exeext=$ac_cv_exeext - -rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out -ac_clean_files=$ac_clean_files_save -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 -$as_echo_n "checking for suffix of executables... " >&6; } -if { { ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_link") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then : - # If both `conftest.exe' and `conftest' are `present' (well, observable) -# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will -# work properly (i.e., refer to `conftest.exe'), while it won't with -# `rm'. -for ac_file in conftest.exe conftest conftest.*; do - test -f "$ac_file" || continue - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; - *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` - break;; - * ) break;; - esac -done -else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "cannot compute suffix of executables: cannot compile and link -See \`config.log' for more details" "$LINENO" 5 ; } -fi -rm -f conftest conftest$ac_cv_exeext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 -$as_echo "$ac_cv_exeext" >&6; } - -rm -f conftest.$ac_ext -EXEEXT=$ac_cv_exeext -ac_exeext=$EXEEXT -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -int -main () -{ -FILE *f = fopen ("conftest.out", "w"); - return ferror (f) || fclose (f) != 0; - - ; - return 0; -} -_ACEOF -ac_clean_files="$ac_clean_files conftest.out" -# Check that the compiler produces executables we can run. If not, either -# the compiler is broken, or we cross compile. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 -$as_echo_n "checking whether we are cross compiling... " >&6; } -if test "$cross_compiling" != yes; then - { { ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_link") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } - if { ac_try='./conftest$ac_cv_exeext' - { { case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_try") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; }; then - cross_compiling=no - else - if test "$cross_compiling" = maybe; then - cross_compiling=yes - else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "cannot run C compiled programs. -If you meant to cross compile, use \`--host'. -See \`config.log' for more details" "$LINENO" 5 ; } - fi - fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 -$as_echo "$cross_compiling" >&6; } - -rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out -ac_clean_files=$ac_clean_files_save -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 -$as_echo_n "checking for suffix of object files... " >&6; } -if test "${ac_cv_objext+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -rm -f conftest.o conftest.obj -if { { ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_compile") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then : - for ac_file in conftest.o conftest.obj conftest.*; do - test -f "$ac_file" || continue; - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; - *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` - break;; - esac -done -else - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - -{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "cannot compute suffix of object files: cannot compile -See \`config.log' for more details" "$LINENO" 5 ; } -fi -rm -f conftest.$ac_cv_objext conftest.$ac_ext -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 -$as_echo "$ac_cv_objext" >&6; } -OBJEXT=$ac_cv_objext -ac_objext=$OBJEXT -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 -$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } -if test "${ac_cv_c_compiler_gnu+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ -#ifndef __GNUC__ - choke me -#endif - - ; - return 0; -} -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_compiler_gnu=yes -else - ac_compiler_gnu=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -ac_cv_c_compiler_gnu=$ac_compiler_gnu - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 -$as_echo "$ac_cv_c_compiler_gnu" >&6; } -if test $ac_compiler_gnu = yes; then - GCC=yes -else - GCC= -fi -ac_test_CFLAGS=${CFLAGS+set} -ac_save_CFLAGS=$CFLAGS -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 -$as_echo_n "checking whether $CC accepts -g... " >&6; } -if test "${ac_cv_prog_cc_g+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_save_c_werror_flag=$ac_c_werror_flag - ac_c_werror_flag=yes - ac_cv_prog_cc_g=no - CFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_prog_cc_g=yes -else - CFLAGS="" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - -else - ac_c_werror_flag=$ac_save_c_werror_flag - CFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_prog_cc_g=yes -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - ac_c_werror_flag=$ac_save_c_werror_flag -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 -$as_echo "$ac_cv_prog_cc_g" >&6; } -if test "$ac_test_CFLAGS" = set; then - CFLAGS=$ac_save_CFLAGS -elif test $ac_cv_prog_cc_g = yes; then - if test "$GCC" = yes; then - CFLAGS="-g -O2" - else - CFLAGS="-g" - fi -else - if test "$GCC" = yes; then - CFLAGS="-O2" - else - CFLAGS= - fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 -$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } -if test "${ac_cv_prog_cc_c89+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_cv_prog_cc_c89=no -ac_save_CC=$CC -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#include -#include -/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ -struct buf { int x; }; -FILE * (*rcsopen) (struct buf *, struct stat *, int); -static char *e (p, i) - char **p; - int i; -{ - return p[i]; -} -static char *f (char * (*g) (char **, int), char **p, ...) -{ - char *s; - va_list v; - va_start (v,p); - s = g (p, va_arg (v,int)); - va_end (v); - return s; -} - -/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has - function prototypes and stuff, but not '\xHH' hex character constants. - These don't provoke an error unfortunately, instead are silently treated - as 'x'. The following induces an error, until -std is added to get - proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an - array size at least. It's necessary to write '\x00'==0 to get something - that's true only with -std. */ -int osf4_cc_array ['\x00' == 0 ? 1 : -1]; - -/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters - inside strings and character constants. */ -#define FOO(x) 'x' -int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; - -int test (int i, double x); -struct s1 {int (*f) (int a);}; -struct s2 {int (*f) (double a);}; -int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); -int argc; -char **argv; -int -main () -{ -return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; - ; - return 0; -} -_ACEOF -for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ - -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" -do - CC="$ac_save_CC $ac_arg" - if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_prog_cc_c89=$ac_arg -fi -rm -f core conftest.err conftest.$ac_objext - test "x$ac_cv_prog_cc_c89" != "xno" && break -done -rm -f conftest.$ac_ext -CC=$ac_save_CC - -fi -# AC_CACHE_VAL -case "x$ac_cv_prog_cc_c89" in - x) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -$as_echo "none needed" >&6; } ;; - xno) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -$as_echo "unsupported" >&6; } ;; - *) - CC="$CC $ac_cv_prog_cc_c89" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 -$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; -esac -if test "x$ac_cv_prog_cc_c89" != xno; then : - -fi - -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - -if test "x$CC" = x; then - help_on_build_dependency devkit - as_fn_error $? "Could not find a compiler. $HELP_MSG" "$LINENO" 5 -fi -if test "x$CC" = xcc && test "x$BUILD_OS" = xmacosx; then - # Do not use cc on MacOSX use gcc instead. - CC="gcc" -fi - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$CC" - car="${tmp%% *}" - tmp="$CC EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - CC="$car ${cdr% *}" - else - CC="$car" - fi - - -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -if test -z "$CXX"; then - if test -n "$CCC"; then - CXX=$CCC - else - if test -n "$ac_tool_prefix"; then - for ac_prog in cl CC g++ - do - # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. -set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CXX+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$CXX"; then - ac_cv_prog_CXX="$CXX" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -CXX=$ac_cv_prog_CXX -if test -n "$CXX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 -$as_echo "$CXX" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$CXX" && break - done -fi -if test -z "$CXX"; then - ac_ct_CXX=$CXX - for ac_prog in cl CC g++ -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$ac_ct_CXX"; then - ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_ac_ct_CXX="$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -ac_ct_CXX=$ac_cv_prog_ac_ct_CXX -if test -n "$ac_ct_CXX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 -$as_echo "$ac_ct_CXX" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$ac_ct_CXX" && break -done - - if test "x$ac_ct_CXX" = x; then - CXX="g++" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - CXX=$ac_ct_CXX - fi -fi - - fi -fi -# Provide some information about the compiler. -$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 -set X $ac_compile -ac_compiler=$2 -for ac_option in --version -v -V -qversion; do - { { ac_try="$ac_compiler $ac_option >&5" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_compiler $ac_option >&5") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - sed '10a\ -... rest of stderr output deleted ... - 10q' conftest.err >conftest.er1 - cat conftest.er1 >&5 - fi - rm -f conftest.er1 conftest.err - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } -done - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 -$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } -if test "${ac_cv_cxx_compiler_gnu+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ -#ifndef __GNUC__ - choke me -#endif - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_compiler_gnu=yes -else - ac_compiler_gnu=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -ac_cv_cxx_compiler_gnu=$ac_compiler_gnu - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 -$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } -if test $ac_compiler_gnu = yes; then - GXX=yes -else - GXX= -fi -ac_test_CXXFLAGS=${CXXFLAGS+set} -ac_save_CXXFLAGS=$CXXFLAGS -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 -$as_echo_n "checking whether $CXX accepts -g... " >&6; } -if test "${ac_cv_prog_cxx_g+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_save_cxx_werror_flag=$ac_cxx_werror_flag - ac_cxx_werror_flag=yes - ac_cv_prog_cxx_g=no - CXXFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_cv_prog_cxx_g=yes -else - CXXFLAGS="" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - -else - ac_cxx_werror_flag=$ac_save_cxx_werror_flag - CXXFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_cv_prog_cxx_g=yes -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - ac_cxx_werror_flag=$ac_save_cxx_werror_flag -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 -$as_echo "$ac_cv_prog_cxx_g" >&6; } -if test "$ac_test_CXXFLAGS" = set; then - CXXFLAGS=$ac_save_CXXFLAGS -elif test $ac_cv_prog_cxx_g = yes; then - if test "$GXX" = yes; then - CXXFLAGS="-g -O2" - else - CXXFLAGS="-g" - fi -else - if test "$GXX" = yes; then - CXXFLAGS="-O2" - else - CXXFLAGS= - fi -fi -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - -if test "x$CXX" = xCC && test "x$BUILD_OS" = xmacosx; then - # The found CC, even though it seems to be a g++ derivate, cannot compile - # c++ code. Override. - CXX="g++" -fi - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$CXX" - car="${tmp%% *}" - tmp="$CXX EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - CXX="$car ${cdr% *}" - else - CXX="$car" - fi - - -if test "x$CXX" = x || test "x$CC" = x; then - help_on_build_dependency devkit - as_fn_error $? "Could not find the needed compilers! $HELP_MSG " "$LINENO" 5 -fi - -if test "x$BUILD_OS" != xwindows; then - ac_ext=m -ac_cpp='$OBJCPP $CPPFLAGS' -ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_objc_compiler_gnu -if test -n "$ac_tool_prefix"; then - for ac_prog in gcc objcc objc cc CC - do - # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. -set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OBJC+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$OBJC"; then - ac_cv_prog_OBJC="$OBJC" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_OBJC="$ac_tool_prefix$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -OBJC=$ac_cv_prog_OBJC -if test -n "$OBJC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJC" >&5 -$as_echo "$OBJC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$OBJC" && break - done -fi -if test -z "$OBJC"; then - ac_ct_OBJC=$OBJC - for ac_prog in gcc objcc objc cc CC -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OBJC+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$ac_ct_OBJC"; then - ac_cv_prog_ac_ct_OBJC="$ac_ct_OBJC" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_ac_ct_OBJC="$ac_prog" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -ac_ct_OBJC=$ac_cv_prog_ac_ct_OBJC -if test -n "$ac_ct_OBJC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJC" >&5 -$as_echo "$ac_ct_OBJC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$ac_ct_OBJC" && break -done - - if test "x$ac_ct_OBJC" = x; then - OBJC="gcc" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - OBJC=$ac_ct_OBJC - fi -fi - -# Provide some information about the compiler. -$as_echo "$as_me:${as_lineno-$LINENO}: checking for Objective C compiler version" >&5 -set X $ac_compile -ac_compiler=$2 -for ac_option in --version -v -V -qversion; do - { { ac_try="$ac_compiler $ac_option >&5" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_compiler $ac_option >&5") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - sed '10a\ -... rest of stderr output deleted ... - 10q' conftest.err >conftest.er1 - cat conftest.er1 >&5 - fi - rm -f conftest.er1 conftest.err - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } -done - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Objective C compiler" >&5 -$as_echo_n "checking whether we are using the GNU Objective C compiler... " >&6; } -if test "${ac_cv_objc_compiler_gnu+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ -#ifndef __GNUC__ - choke me -#endif - - ; - return 0; -} -_ACEOF -if ac_fn_objc_try_compile "$LINENO"; then : - ac_compiler_gnu=yes -else - ac_compiler_gnu=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -ac_cv_objc_compiler_gnu=$ac_compiler_gnu - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objc_compiler_gnu" >&5 -$as_echo "$ac_cv_objc_compiler_gnu" >&6; } -if test $ac_compiler_gnu = yes; then - GOBJC=yes -else - GOBJC= -fi -ac_test_OBJCFLAGS=${OBJCFLAGS+set} -ac_save_OBJCFLAGS=$OBJCFLAGS -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $OBJC accepts -g" >&5 -$as_echo_n "checking whether $OBJC accepts -g... " >&6; } -if test "${ac_cv_prog_objc_g+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_save_objc_werror_flag=$ac_objc_werror_flag - ac_objc_werror_flag=yes - ac_cv_prog_objc_g=no - OBJCFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_objc_try_compile "$LINENO"; then : - ac_cv_prog_objc_g=yes -else - OBJCFLAGS="" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_objc_try_compile "$LINENO"; then : - -else - ac_objc_werror_flag=$ac_save_objc_werror_flag - OBJCFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_objc_try_compile "$LINENO"; then : - ac_cv_prog_objc_g=yes -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - ac_objc_werror_flag=$ac_save_objc_werror_flag -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_objc_g" >&5 -$as_echo "$ac_cv_prog_objc_g" >&6; } -if test "$ac_test_OBJCFLAGS" = set; then - OBJCFLAGS=$ac_save_OBJCFLAGS -elif test $ac_cv_prog_objc_g = yes; then - if test "$GOBJC" = yes; then - OBJCFLAGS="-g -O2" - else - OBJCFLAGS="-g" - fi -else - if test "$GOBJC" = yes; then - OBJCFLAGS="-O2" - else - OBJCFLAGS= - fi -fi -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$OBJC" - car="${tmp%% *}" - tmp="$OBJC EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - OBJC="$car ${cdr% *}" - else - OBJC="$car" - fi - -else - OBJC= -fi - -# Restore the flags to the user specified values. -# This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2" -CFLAGS="$ORG_CFLAGS" -CXXFLAGS="$ORG_CXXFLAGS" -OBJCFLAGS="$ORG_OBJCFLAGS" - -# If we are not cross compiling, use the same compilers for -# building the build platform executables. -if test "x$DEFINE_CROSS_COMPILE_ARCH" = x; then - HOSTCC="$CC" - HOSTCXX="$CXX" -fi - -if test -n "$ac_tool_prefix"; then - # Extract the first word of "${ac_tool_prefix}ld", so it can be a program name with args. -set dummy ${ac_tool_prefix}ld; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_LD+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$LD"; then - ac_cv_prog_LD="$LD" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_LD="${ac_tool_prefix}ld" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -LD=$ac_cv_prog_LD -if test -n "$LD"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 -$as_echo "$LD" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -fi -if test -z "$ac_cv_prog_LD"; then - ac_ct_LD=$LD - # Extract the first word of "ld", so it can be a program name with args. -set dummy ld; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_LD+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$ac_ct_LD"; then - ac_cv_prog_ac_ct_LD="$ac_ct_LD" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_ac_ct_LD="ld" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -ac_ct_LD=$ac_cv_prog_ac_ct_LD -if test -n "$ac_ct_LD"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LD" >&5 -$as_echo "$ac_ct_LD" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - if test "x$ac_ct_LD" = x; then - LD="" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - LD=$ac_ct_LD - fi -else - LD="$ac_cv_prog_LD" -fi - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$LD" - car="${tmp%% *}" - tmp="$LD EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - LD="$car ${cdr% *}" - else - LD="$car" - fi - -LD="$CC" -LDEXE="$CC" -LDCXX="$CXX" -LDEXECXX="$CXX" -# LDEXE is the linker to use, when creating executables. - -# Linking C++ libraries. - -# Linking C++ executables. - - -if test -n "$ac_tool_prefix"; then - # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. -set dummy ${ac_tool_prefix}ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_AR+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$AR"; then - ac_cv_prog_AR="$AR" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_AR="${ac_tool_prefix}ar" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -AR=$ac_cv_prog_AR -if test -n "$AR"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 -$as_echo "$AR" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -fi -if test -z "$ac_cv_prog_AR"; then - ac_ct_AR=$AR - # Extract the first word of "ar", so it can be a program name with args. -set dummy ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_AR+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$ac_ct_AR"; then - ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_ac_ct_AR="ar" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -ac_ct_AR=$ac_cv_prog_ac_ct_AR -if test -n "$ac_ct_AR"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 -$as_echo "$ac_ct_AR" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - if test "x$ac_ct_AR" = x; then - AR="" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - AR=$ac_ct_AR - fi -else - AR="$ac_cv_prog_AR" -fi - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$AR" - car="${tmp%% *}" - tmp="$AR EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - AR="$car ${cdr% *}" - else - AR="$car" - fi - -if test "x$BUILD_OS" = xmacosx; then - ARFLAGS="-r" -else - ARFLAGS="" -fi - - -COMPILER_NAME=gcc -COMPILER_TYPE=CC -if test "x$BUILD_OS" = xwindows; then : - - # For now, assume that we are always compiling using cl.exe. - CC_OUT_OPTION=-Fo - EXE_OUT_OPTION=-out: - LD_OUT_OPTION=-out: - AR_OUT_OPTION=-out: - # On Windows, reject /usr/bin/link, which is a cygwin - # program for something completely different. - # Extract the first word of "link", so it can be a program name with args. -set dummy link; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_WINLD+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$WINLD"; then - ac_cv_prog_WINLD="$WINLD" # Let the user override the test. -else - ac_prog_rejected=no -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/link"; then - ac_prog_rejected=yes - continue - fi - ac_cv_prog_WINLD="link" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -if test $ac_prog_rejected = yes; then - # We found a bogon in the path, so make sure we never use it. - set dummy $ac_cv_prog_WINLD - shift - if test $# != 0; then - # We chose a different compiler from the bogus one. - # However, it has the same basename, so the bogon will be chosen - # first if we set WINLD to just the basename; use the full file name. - shift - ac_cv_prog_WINLD="$as_dir/$ac_word${1+' '}$@" - fi -fi -fi -fi -WINLD=$ac_cv_prog_WINLD -if test -n "$WINLD"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINLD" >&5 -$as_echo "$WINLD" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - # Since we must ignore the first found link, WINLD will contain - # the full path to the link.exe program. - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$WINLD" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$WINLD"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - WINLD="$tmp" - - LD="$WINLD" - LDEXE="$WINLD" - LDCXX="$WINLD" - LDEXECXX="$WINLD" - - # Extract the first word of "mt", so it can be a program name with args. -set dummy mt; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_MT+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$MT"; then - ac_cv_prog_MT="$MT" # Let the user override the test. -else - ac_prog_rejected=no -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/mt"; then - ac_prog_rejected=yes - continue - fi - ac_cv_prog_MT="mt" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -if test $ac_prog_rejected = yes; then - # We found a bogon in the path, so make sure we never use it. - set dummy $ac_cv_prog_MT - shift - if test $# != 0; then - # We chose a different compiler from the bogus one. - # However, it has the same basename, so the bogon will be chosen - # first if we set MT to just the basename; use the full file name. - shift - ac_cv_prog_MT="$as_dir/$ac_word${1+' '}$@" - fi -fi -fi -fi -MT=$ac_cv_prog_MT -if test -n "$MT"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MT" >&5 -$as_echo "$MT" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$MT" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$MT"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - MT="$tmp" - - # The resource compiler - # Extract the first word of "rc", so it can be a program name with args. -set dummy rc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_RC+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$RC"; then - ac_cv_prog_RC="$RC" # Let the user override the test. -else - ac_prog_rejected=no -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/rc"; then - ac_prog_rejected=yes - continue - fi - ac_cv_prog_RC="rc" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -if test $ac_prog_rejected = yes; then - # We found a bogon in the path, so make sure we never use it. - set dummy $ac_cv_prog_RC - shift - if test $# != 0; then - # We chose a different compiler from the bogus one. - # However, it has the same basename, so the bogon will be chosen - # first if we set RC to just the basename; use the full file name. - shift - ac_cv_prog_RC="$as_dir/$ac_word${1+' '}$@" - fi -fi -fi -fi -RC=$ac_cv_prog_RC -if test -n "$RC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RC" >&5 -$as_echo "$RC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$RC" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$RC"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - RC="$tmp" - - - RC_FLAGS="-nologo /l 0x409 /r" - if test "x$VARIANT" = xOPT; then : - - RC_FLAGS="$RC_FLAGS -d NDEBUG" - -fi - JDK_UPDATE_VERSION_NOTNULL=$JDK_UPDATE_VERSION - if test "x$JDK_UPDATE_VERSION" = x; then : - - JDK_UPDATE_VERSION_NOTNULL=0 - -fi - RC_FLAGS="$RC_FLAGS -d \"JDK_BUILD_ID=$FULL_VERSION\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_COMPANY=$COMPANY_NAME\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_COMPONENT=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME binary\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_VER=$JDK_MINOR_VERSION.$JDK_MICRO_VERSION.$JDK_UPDATE_VERSION_NOTNULL.$COOKED_BUILD_NUMBER\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_NAME=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME $JDK_MINOR_VERSION $JDK_UPDATE_META_TAG\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_FVER=$JDK_MINOR_VERSION,$JDK_MICRO_VERSION,$JDK_UPDATE_VERSION_NOTNULL,$COOKED_BUILD_NUMBER\"" - - # lib.exe is used to create static libraries. - # Extract the first word of "lib", so it can be a program name with args. -set dummy lib; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_WINAR+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$WINAR"; then - ac_cv_prog_WINAR="$WINAR" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_WINAR="lib" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -WINAR=$ac_cv_prog_WINAR -if test -n "$WINAR"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINAR" >&5 -$as_echo "$WINAR" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$WINAR" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$WINAR"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - WINAR="$tmp" - - AR="$WINAR" - ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT" - - # Extract the first word of "dumpbin", so it can be a program name with args. -set dummy dumpbin; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_DUMPBIN+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$DUMPBIN"; then - ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_DUMPBIN="dumpbin" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -DUMPBIN=$ac_cv_prog_DUMPBIN -if test -n "$DUMPBIN"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 -$as_echo "$DUMPBIN" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$DUMPBIN" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$DUMPBIN"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - DUMPBIN="$tmp" - - - COMPILER_TYPE=CL - CCXXFLAGS="$CCXXFLAGS -nologo" - LDFLAGS="$LDFLAGS -nologo -opt:ref -incremental:no" - if test "x$LEGACY_HOST_CPU1" = xi586; then - LDFLAGS="$LDFLAGS -safeseh" - fi - # TODO: make -debug optional "--disable-full-debug-symbols" - LDFLAGS="$LDFLAGS -debug" - -fi - - - -ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 -$as_echo_n "checking how to run the C preprocessor... " >&6; } -# On Suns, sometimes $CPP names a directory. -if test -n "$CPP" && test -d "$CPP"; then - CPP= -fi -if test -z "$CPP"; then - if test "${ac_cv_prog_CPP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - # Double quotes because CPP needs to be expanded - for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" - do - ac_preproc_ok=false -for ac_c_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - -else - # Broken: fails on valid input. -continue -fi -rm -f conftest.err conftest.i conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - # Broken: success on invalid input. -continue -else - # Passes both tests. -ac_preproc_ok=: -break -fi -rm -f conftest.err conftest.i conftest.$ac_ext - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : - break -fi - - done - ac_cv_prog_CPP=$CPP - -fi - CPP=$ac_cv_prog_CPP -else - ac_cv_prog_CPP=$CPP -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 -$as_echo "$CPP" >&6; } -ac_preproc_ok=false -for ac_c_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - -else - # Broken: fails on valid input. -continue -fi -rm -f conftest.err conftest.i conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - # Broken: success on invalid input. -continue -else - # Passes both tests. -ac_preproc_ok=: -break -fi -rm -f conftest.err conftest.i conftest.$ac_ext - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : - -else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "C preprocessor \"$CPP\" fails sanity check -See \`config.log' for more details" "$LINENO" 5 ; } -fi - -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$CPP" - car="${tmp%% *}" - tmp="$CPP EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - CPP="$car ${cdr% *}" - else - CPP="$car" - fi - - -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 -$as_echo_n "checking how to run the C++ preprocessor... " >&6; } -if test -z "$CXXCPP"; then - if test "${ac_cv_prog_CXXCPP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - # Double quotes because CXXCPP needs to be expanded - for CXXCPP in "$CXX -E" "/lib/cpp" - do - ac_preproc_ok=false -for ac_cxx_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if ac_fn_cxx_try_cpp "$LINENO"; then : - -else - # Broken: fails on valid input. -continue -fi -rm -f conftest.err conftest.i conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_cxx_try_cpp "$LINENO"; then : - # Broken: success on invalid input. -continue -else - # Passes both tests. -ac_preproc_ok=: -break -fi -rm -f conftest.err conftest.i conftest.$ac_ext - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : - break -fi - - done - ac_cv_prog_CXXCPP=$CXXCPP - -fi - CXXCPP=$ac_cv_prog_CXXCPP -else - ac_cv_prog_CXXCPP=$CXXCPP -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 -$as_echo "$CXXCPP" >&6; } -ac_preproc_ok=false -for ac_cxx_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if ac_fn_cxx_try_cpp "$LINENO"; then : - -else - # Broken: fails on valid input. -continue -fi -rm -f conftest.err conftest.i conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_cxx_try_cpp "$LINENO"; then : - # Broken: success on invalid input. -continue -else - # Passes both tests. -ac_preproc_ok=: -break -fi -rm -f conftest.err conftest.i conftest.$ac_ext - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : - -else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check -See \`config.log' for more details" "$LINENO" 5 ; } -fi - -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$CXXCPP" - car="${tmp%% *}" - tmp="$CXXCPP EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - CXXCPP="$car ${cdr% *}" - else - CXXCPP="$car" - fi - - -# Find the right assembler. -if test "x$BUILD_OS" = xsolaris; then - # Extract the first word of "as", so it can be a program name with args. -set dummy as; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_AS+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $AS in - [\\/]* | ?:[\\/]*) - ac_cv_path_AS="$AS" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -AS=$ac_cv_path_AS -if test -n "$AS"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5 -$as_echo "$AS" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$AS" - car="${tmp%% *}" - tmp="$AS EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - AS="$car ${cdr% *}" - else - AS="$car" - fi - - ASFLAGS=" " -else - AS="$CC -c" - ASFLAGS=" " -fi - - - -if test "x$HOST_CPU_BITS" = x32 && test "x$HOST_OS" = xmacosx; then - # On 32-bit MacOSX the OS requires C-entry points to be 16 byte aligned. - # While waiting for a better solution, the current workaround is to use -mstackrealign. - CFLAGS="$CFLAGS -mstackrealign" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if 32-bit compiler supports -mstackrealign" >&5 -$as_echo_n "checking if 32-bit compiler supports -mstackrealign... " >&6; } - -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -int main() { return 0; } -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - -else - - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - as_fn_error $? "The selected compiler $CXX does not support -mstackrealign! Try to put another compiler in the path." "$LINENO" 5 - -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -fi - -if test "x$BUILD_OS" = xsolaris; then - # Extract the first word of "nm", so it can be a program name with args. -set dummy nm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_NM+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $NM in - [\\/]* | ?:[\\/]*) - ac_cv_path_NM="$NM" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -NM=$ac_cv_path_NM -if test -n "$NM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5 -$as_echo "$NM" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$NM" - car="${tmp%% *}" - tmp="$NM EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - NM="$car ${cdr% *}" - else - NM="$car" - fi - - # Extract the first word of "strip", so it can be a program name with args. -set dummy strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_STRIP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $STRIP in - [\\/]* | ?:[\\/]*) - ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -STRIP=$ac_cv_path_STRIP -if test -n "$STRIP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 -$as_echo "$STRIP" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$STRIP" - car="${tmp%% *}" - tmp="$STRIP EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - STRIP="$car ${cdr% *}" - else - STRIP="$car" - fi - - # Extract the first word of "mcs", so it can be a program name with args. -set dummy mcs; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_MCS+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $MCS in - [\\/]* | ?:[\\/]*) - ac_cv_path_MCS="$MCS" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -MCS=$ac_cv_path_MCS -if test -n "$MCS"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5 -$as_echo "$MCS" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$MCS" - car="${tmp%% *}" - tmp="$MCS EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - MCS="$car ${cdr% *}" - else - MCS="$car" - fi - -else - if test -n "$ac_tool_prefix"; then - # Extract the first word of "${ac_tool_prefix}nm", so it can be a program name with args. -set dummy ${ac_tool_prefix}nm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_NM+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$NM"; then - ac_cv_prog_NM="$NM" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_NM="${ac_tool_prefix}nm" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -NM=$ac_cv_prog_NM -if test -n "$NM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5 -$as_echo "$NM" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -fi -if test -z "$ac_cv_prog_NM"; then - ac_ct_NM=$NM - # Extract the first word of "nm", so it can be a program name with args. -set dummy nm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_NM+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$ac_ct_NM"; then - ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_ac_ct_NM="nm" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -ac_ct_NM=$ac_cv_prog_ac_ct_NM -if test -n "$ac_ct_NM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5 -$as_echo "$ac_ct_NM" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - if test "x$ac_ct_NM" = x; then - NM="" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - NM=$ac_ct_NM - fi -else - NM="$ac_cv_prog_NM" -fi - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$NM" - car="${tmp%% *}" - tmp="$NM EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - NM="$car ${cdr% *}" - else - NM="$car" - fi - - if test -n "$ac_tool_prefix"; then - # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. -set dummy ${ac_tool_prefix}strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_STRIP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$STRIP"; then - ac_cv_prog_STRIP="$STRIP" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_STRIP="${ac_tool_prefix}strip" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -STRIP=$ac_cv_prog_STRIP -if test -n "$STRIP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 -$as_echo "$STRIP" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -fi -if test -z "$ac_cv_prog_STRIP"; then - ac_ct_STRIP=$STRIP - # Extract the first word of "strip", so it can be a program name with args. -set dummy strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$ac_ct_STRIP"; then - ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_ac_ct_STRIP="strip" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP -if test -n "$ac_ct_STRIP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 -$as_echo "$ac_ct_STRIP" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - if test "x$ac_ct_STRIP" = x; then - STRIP="" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - STRIP=$ac_ct_STRIP - fi -else - STRIP="$ac_cv_prog_STRIP" -fi - - - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="$STRIP" - car="${tmp%% *}" - tmp="$STRIP EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$car" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$car"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - car="$tmp" - - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - STRIP="$car ${cdr% *}" - else - STRIP="$car" - fi - -fi - -# When using cygwin, we need a wrapper binary that renames -# /cygdrive/c/ arguments into c:/ arguments and peeks into -# @files and rewrites these too! This wrapper binary is -# called uncygdrive.exe. -UNCYGDRIVE= -if test "x$BUILD_OS" = xwindows; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if uncygdrive can be created" >&5 -$as_echo_n "checking if uncygdrive can be created... " >&6; } - UNCYGDRIVE_SRC=`$CYGPATH -m $SRC_ROOT/common/src/uncygdrive.c` - rm -f $OUTPUT_ROOT/uncygdrive* - UNCYGDRIVE=`$CYGPATH -m $OUTPUT_ROOT/uncygdrive.exe` - cd $OUTPUT_ROOT - $CC $UNCYGDRIVE_SRC /Fe$UNCYGDRIVE > $OUTPUT_ROOT/uncygdrive1.log 2>&1 - cd $CURDIR - - if test ! -x $OUTPUT_ROOT/uncygdrive.exe; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - cat $OUTPUT_ROOT/uncygdrive1.log - as_fn_error $? "Could not create $OUTPUT_ROOT/uncygdrive.exe" "$LINENO" 5 - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNCYGDRIVE" >&5 -$as_echo "$UNCYGDRIVE" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if uncygdrive.exe works" >&5 -$as_echo_n "checking if uncygdrive.exe works... " >&6; } - cd $OUTPUT_ROOT - $UNCYGDRIVE $CC $SRC_ROOT/common/src/uncygdrive.c /Fe$OUTPUT_ROOT/uncygdrive2.exe > $OUTPUT_ROOT/uncygdrive2.log 2>&1 - cd $CURDIR - if test ! -x $OUTPUT_ROOT/uncygdrive2.exe; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - cat $OUTPUT_ROOT/uncygdrive2.log - as_fn_error $? "Uncygdrive did not work!" "$LINENO" 5 - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - rm -f $OUTPUT_ROOT/uncygdrive?.??? $OUTPUT_ROOT/uncygdrive.obj -fi - - - - - # Check whether --enable-ccache was given. -if test "${enable_ccache+set}" = set; then : - enableval=$enable_ccache; ENABLE_CCACHE=${enable_ccache} -else - ENABLE_CCACHE=yes -fi - - if test "x$ENABLE_CCACHE" = xyes; then - # Extract the first word of "ccache", so it can be a program name with args. -set dummy ccache; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CCACHE+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $CCACHE in - [\\/]* | ?:[\\/]*) - ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CCACHE=$ac_cv_path_CCACHE -if test -n "$CCACHE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5 -$as_echo "$CCACHE" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - else - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ccache" >&5 -$as_echo_n "checking for ccache... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: explicitly disabled" >&5 -$as_echo "explicitly disabled" >&6; } - CCACHE= - fi - - - -# Check whether --with-ccache-dir was given. -if test "${with_ccache_dir+set}" = set; then : - withval=$with_ccache_dir; -fi - - - if test "x$with_ccache_dir" != x; then - # When using a non home ccache directory, assume the use is to share ccache files - # with other users. Thus change the umask. - SET_CCACHE_DIR="CCACHE_DIR=$with_ccache_dir CCACHE_UMASK=002" - fi - CCACHE_FOUND="" - if test "x$CCACHE" != x; then - - if test "x$CCACHE" != x; then - CCACHE_FOUND="true" - # Only use ccache if it is 3.1.4 or later, which supports - # precompiled headers. - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if ccache supports precompiled headers" >&5 -$as_echo_n "checking if ccache supports precompiled headers... " >&6; } - HAS_GOOD_CCACHE=`($CCACHE --version | head -n 1 | grep -E 3.1.[456789]) 2> /dev/null` - if test "x$HAS_GOOD_CCACHE" = x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, disabling ccache" >&5 -$as_echo "no, disabling ccache" >&6; } - CCACHE= - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if C-compiler supports ccache precompiled headers" >&5 -$as_echo_n "checking if C-compiler supports ccache precompiled headers... " >&6; } - PUSHED_FLAGS="$CXXFLAGS" - CXXFLAGS="-fpch-preprocess $CXXFLAGS" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - CC_KNOWS_CCACHE_TRICK=yes -else - CC_KNOWS_CCACHE_TRICK=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - CXXFLAGS="$PUSHED_FLAGS" - if test "x$CC_KNOWS_CCACHE_TRICK" = xyes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, disabling ccaching of precompiled headers" >&5 -$as_echo "no, disabling ccaching of precompiled headers" >&6; } - CCACHE= - fi - fi - fi - - if test "x$CCACHE" != x; then - CCACHE_SLOPPINESS=time_macros - CCACHE="CCACHE_COMPRESS=1 $SET_CCACHE_DIR CCACHE_SLOPPINESS=$CCACHE_SLOPPINESS $CCACHE" - CCACHE_FLAGS=-fpch-preprocess - - if test "x$SET_CCACHE_DIR" != x; then - mkdir -p $CCACHE_DIR > /dev/null 2>&1 - chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1 - fi - fi - - fi - - -# Used on GNU/Linux systems, can be empty... -#AC_PATH_PROG(ELFDUMP, elfdump) - -# Setup default logging of stdout and stderr to build.log in the output root. -BUILD_LOG='$(OUTPUT_ROOT)/build.log' -BUILD_LOG_WRAPPER='$(SH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)' - - - -############################################################################### -# -# Now we check if libjvm.so will use 32 or 64 bit pointers for the C/C++ code. -# (The JVM can use 32 or 64 bit Java pointers but that decision -# is made at runtime.) -# -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - -OLD_CXXFLAGS="$CXXFLAGS" -if test "x$HOST_OS" = xsolaris && test "x$with_data_model" != x; then - CXXFLAGS="-m{$with_data_model} $CXXFLAGS" -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 -$as_echo_n "checking for ANSI C header files... " >&6; } -if test "${ac_cv_header_stdc+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#include -#include - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_cv_header_stdc=yes -else - ac_cv_header_stdc=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - -if test $ac_cv_header_stdc = yes; then - # SunOS 4.x string.h does not declare mem*, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "memchr" >/dev/null 2>&1; then : - -else - ac_cv_header_stdc=no -fi -rm -f conftest* - -fi - -if test $ac_cv_header_stdc = yes; then - # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "free" >/dev/null 2>&1; then : - -else - ac_cv_header_stdc=no -fi -rm -f conftest* - -fi - -if test $ac_cv_header_stdc = yes; then - # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. - if test "$cross_compiling" = yes; then : - : -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#if ((' ' & 0x0FF) == 0x020) -# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') -# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) -#else -# define ISLOWER(c) \ - (('a' <= (c) && (c) <= 'i') \ - || ('j' <= (c) && (c) <= 'r') \ - || ('s' <= (c) && (c) <= 'z')) -# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) -#endif - -#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) -int -main () -{ - int i; - for (i = 0; i < 256; i++) - if (XOR (islower (i), ISLOWER (i)) - || toupper (i) != TOUPPER (i)) - return 2; - return 0; -} -_ACEOF -if ac_fn_cxx_try_run "$LINENO"; then : - -else - ac_cv_header_stdc=no -fi -rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ - conftest.$ac_objext conftest.beam conftest.$ac_ext -fi - -fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 -$as_echo "$ac_cv_header_stdc" >&6; } -if test $ac_cv_header_stdc = yes; then - -$as_echo "#define STDC_HEADERS 1" >>confdefs.h - -fi - -# On IRIX 5.3, sys/types and inttypes.h are conflicting. -for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ - inttypes.h stdint.h unistd.h -do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` -ac_fn_cxx_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default -" -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF - -fi - -done - - -# The cast to long int works around a bug in the HP C Compiler -# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects -# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. -# This bug is HP SR number 8606223364. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5 -$as_echo_n "checking size of int *... " >&6; } -if test "${ac_cv_sizeof_int_p+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p" "$ac_includes_default"; then : - -else - if test "$ac_cv_type_int_p" = yes; then - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error 77 "cannot compute sizeof (int *) -See \`config.log' for more details" "$LINENO" 5 ; } - else - ac_cv_sizeof_int_p=0 - fi -fi - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5 -$as_echo "$ac_cv_sizeof_int_p" >&6; } - - - -cat >>confdefs.h <<_ACEOF -#define SIZEOF_INT_P $ac_cv_sizeof_int_p -_ACEOF - - -CXXFLAGS="$OLD_CXXFLAGS" -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - -if test "x$ac_cv_sizeof_int_p" = x0; then - # The test failed, lets pick the assumed value. - ARCH_DATA_MODEL=$HOST_CPU_BITS -else - ARCH_DATA_MODEL=`expr 8 \* $ac_cv_sizeof_int_p` -fi - -if test "x$ARCH_DATA_MODEL" = x64; then - A_LP64="LP64:=" - ADD_LP64="-D_LP64=1" -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for host address size" >&5 -$as_echo_n "checking for host address size... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ARCH_DATA_MODEL bits" >&5 -$as_echo "$ARCH_DATA_MODEL bits" >&6; } -LP64=$A_LP64 - - - -if test "x$ARCH_DATA_MODEL" != "x$HOST_CPU_BITS"; then - as_fn_error $? "The tested number of bits in the host ($ARCH_DATA_MODEL) differs from the number of bits expected to be found in the host ($HOST_CPU_BITS)" "$LINENO" 5 -fi - -############################################################################### -# -# Can the C/C++ compiler use precompiled headers? -# -# Check whether --enable-precompiled-headers was given. -if test "${enable_precompiled_headers+set}" = set; then : - enableval=$enable_precompiled_headers; ENABLE_PRECOMPH=${enable_precompiled-headers} -else - ENABLE_PRECOMPH=yes -fi - - -USE_PRECOMPILED_HEADER=1 -if test "x$ENABLE_PRECOMPH" = xno; then - USE_PRECOMPILED_HEADER=0 -fi - -if test "x$ENABLE_PRECOMPH" = xyes; then - # Check that the compiler actually supports precomp headers. - if test "x$GCC" = xyes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking that precompiled headers work" >&5 -$as_echo_n "checking that precompiled headers work... " >&6; } - echo "int alfa();" > conftest.h - $CXX -x c++-header conftest.h -o conftest.hpp.gch - if test ! -f conftest.hpp.gch; then - echo Precompiled header is not working! - USE_PRECOMPILED_HEADER=0 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - fi - rm -f conftest.h - fi -fi - - - -############################################################################### -# -# How to compile shared libraries. -# - -if test "x$GCC" = xyes; then - COMPILER_NAME=gcc - PICFLAG="-fPIC" - LIBRARY_PREFIX=lib - SHARED_LIBRARY='lib$1.so' - STATIC_LIBRARY='lib$1.a' - SHARED_LIBRARY_FLAGS="-shared" - SHARED_LIBRARY_SUFFIX='.so' - STATIC_LIBRARY_SUFFIX='.a' - OBJ_SUFFIX='.o' - EXE_SUFFIX='' - SET_SHARED_LIBRARY_NAME='-Xlinker -soname=$1' - SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=$1' - C_FLAG_REORDER='' - CXX_FLAG_REORDER='' - SET_SHARED_LIBRARY_ORIGIN='-Xlinker -z -Xlinker origin -Xlinker -rpath -Xlinker \$$$$ORIGIN/$1' - LD="$CC" - LDEXE="$CC" - LDCXX="$CXX" - LDEXECXX="$CXX" - # TODO: for embedded set --strip-unneeded - POST_STRIP_CMD="$STRIP -g" - - # Linking is different on MacOSX - if test "x$BUILD_OS" = xmacosx; then - # Might change in the future to clang. - COMPILER_NAME=gcc - SHARED_LIBRARY='lib$1.dylib' - SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG" - SHARED_LIBRARY_SUFFIX='.dylib' - EXE_SUFFIX='' - SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/$1' - SET_SHARED_LIBRARY_MAPFILE='' - SET_SHARED_LIBRARY_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.' - POST_STRIP_CMD="$STRIP -S" - fi -else - if test "x$BUILD_OS" = xsolaris; then - # If it is not gcc, then assume it is the Oracle Solaris Studio Compiler - COMPILER_NAME=ossc - PICFLAG="-KPIC" - LIBRARY_PREFIX=lib - SHARED_LIBRARY='lib$1.so' - STATIC_LIBRARY='lib$1.a' - SHARED_LIBRARY_FLAGS="-G" - SHARED_LIBRARY_SUFFIX='.so' - STATIC_LIBRARY_SUFFIX='.a' - OBJ_SUFFIX='.o' - EXE_SUFFIX='' - SET_SHARED_LIBRARY_NAME='' - SET_SHARED_LIBRARY_MAPFILE='-M $1' - C_FLAG_REORDER='-xF' - CXX_FLAG_REORDER='-xF' - SET_SHARED_LIBRARY_ORIGIN='-R \$$$$ORIGIN/$1' - CFLAGS_JDKLIB_EXTRA='-xstrconst -D__solaris__' - POST_STRIP_CMD="$STRIP -x" - POST_MCS_CMD="$MCS -d -a \"JDK $FULL_VERSION\"" - fi - if test "x$BUILD_OS" = xwindows; then - # If it is not gcc, then assume it is the MS Visual Studio compiler - COMPILER_NAME=cl - PICFLAG="" - LIBRARY_PREFIX= - SHARED_LIBRARY='$1.dll' - STATIC_LIBRARY='$1.lib' - SHARED_LIBRARY_FLAGS="-LD" - SHARED_LIBRARY_SUFFIX='.dll' - STATIC_LIBRARY_SUFFIX='.lib' - OBJ_SUFFIX='.obj' - EXE_SUFFIX='.exe' - SET_SHARED_LIBRARY_NAME='' - SET_SHARED_LIBRARY_MAPFILE='' - SET_SHARED_LIBRARY_ORIGIN='' - fi -fi - - - - - - - - - - - - - - - - - -# The (cross) compiler is now configured, we can now test capabilities -# of the host platform. - -############################################################################### -# -# Is the host little of big endian? -# - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5 -$as_echo_n "checking whether byte ordering is bigendian... " >&6; } -if test "${ac_cv_c_bigendian+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_cv_c_bigendian=unknown - # See if we're dealing with a universal compiler. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifndef __APPLE_CC__ - not a universal capable compiler - #endif - typedef int dummy; - -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - - # Check for potential -arch flags. It is not universal unless - # there are at least two -arch flags with different values. - ac_arch= - ac_prev= - for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do - if test -n "$ac_prev"; then - case $ac_word in - i?86 | x86_64 | ppc | ppc64) - if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then - ac_arch=$ac_word - else - ac_cv_c_bigendian=universal - break - fi - ;; - esac - ac_prev= - elif test "x$ac_word" = "x-arch"; then - ac_prev=arch - fi - done -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - if test $ac_cv_c_bigendian = unknown; then - # See if sys/param.h defines the BYTE_ORDER macro. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - #include - -int -main () -{ -#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \ - && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \ - && LITTLE_ENDIAN) - bogus endian macros - #endif - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - # It does; now see whether it defined to BIG_ENDIAN or not. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - #include - -int -main () -{ -#if BYTE_ORDER != BIG_ENDIAN - not big endian - #endif - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_cv_c_bigendian=yes -else - ac_cv_c_bigendian=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - fi - if test $ac_cv_c_bigendian = unknown; then - # See if defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris). - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - -int -main () -{ -#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN) - bogus endian macros - #endif - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - # It does; now see whether it defined to _BIG_ENDIAN or not. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - -int -main () -{ -#ifndef _BIG_ENDIAN - not big endian - #endif - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_cv_c_bigendian=yes -else - ac_cv_c_bigendian=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - fi - if test $ac_cv_c_bigendian = unknown; then - # Compile a test program. - if test "$cross_compiling" = yes; then : - # Try to guess by grepping values from an object file. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -short int ascii_mm[] = - { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; - short int ascii_ii[] = - { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; - int use_ascii (int i) { - return ascii_mm[i] + ascii_ii[i]; - } - short int ebcdic_ii[] = - { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; - short int ebcdic_mm[] = - { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; - int use_ebcdic (int i) { - return ebcdic_mm[i] + ebcdic_ii[i]; - } - extern int foo; - -int -main () -{ -return use_ascii (foo) == use_ebcdic (foo); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then - ac_cv_c_bigendian=yes - fi - if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then - if test "$ac_cv_c_bigendian" = unknown; then - ac_cv_c_bigendian=no - else - # finding both strings is unlikely to happen, but who knows? - ac_cv_c_bigendian=unknown - fi - fi -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$ac_includes_default -int -main () -{ - - /* Are we little or big endian? From Harbison&Steele. */ - union - { - long int l; - char c[sizeof (long int)]; - } u; - u.l = 1; - return u.c[sizeof (long int) - 1] == 1; - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_run "$LINENO"; then : - ac_cv_c_bigendian=no -else - ac_cv_c_bigendian=yes -fi -rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ - conftest.$ac_objext conftest.beam conftest.$ac_ext -fi - - fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5 -$as_echo "$ac_cv_c_bigendian" >&6; } - case $ac_cv_c_bigendian in #( - yes) - ENDIAN="big";; #( - no) - ENDIAN="little" ;; #( - universal) - ENDIAN="universal" - ;; #( - *) - ENDIAN="unknown" ;; - esac - - -if test "x$ENDIAN" = xuniversal; then - as_fn_error $? "It seems like someone needs to decide how we are to deal with universal binaries on the MacOSX?" "$LINENO" 5 -fi -if test "x$ENDIAN" = xunknown; then - ENDIAN="$HOST_CPU_ENDIAN" -fi -if test "x$ENDIAN" != "x$HOST_CPU_ENDIAN"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The tested endian in the host ($ENDIAN) differs from the endian expected to be found in the host ($HOST_CPU_ENDIAN)" >&5 -$as_echo "$as_me: WARNING: The tested endian in the host ($ENDIAN) differs from the endian expected to be found in the host ($HOST_CPU_ENDIAN)" >&2;} - ENDIAN="$HOST_CPU_ENDIAN" -fi - - -############################################################################### -# -# We need a Boot JDK to bootstrap the build. -# -BOOT_JDK_FOUND=no - -# Check whether --with-boot-jdk was given. -if test "${with_boot_jdk+set}" = set; then : - withval=$with_boot_jdk; -fi - - -if test "x$with_boot_jdk" != x; then - BOOT_JDK=$with_boot_jdk - BOOT_JDK_FOUND=yes -fi -if test "x$BOOT_JDK_FOUND" = xno; then - - - if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then - # Source the builddeps file again, to make sure it uses the latest variables! - . $builddepsfile - # Look for a host and build machine specific resource! - eval resource=\${builddep_boot-jdk_BUILD_${rewritten_build_var}_HOST_${rewritten_host_var}} - if test "x$resource" = x; then - # Ok, lets instead look for a host specific resource - eval resource=\${builddep_boot-jdk_HOST_${rewritten_host_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a build specific resource - eval resource=\${builddep_boot-jdk_BUILD_${rewritten_build_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a generic resource - # (The boot-jdk comes from M4 and not the shell, thus no need for eval here.) - resource=${builddep_boot-jdk} - fi - if test "x$resource" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for boot-jdk" >&5 -$as_echo "$as_me: Using builddeps $resource for boot-jdk" >&6;} - # If the resource in the builddeps.conf file is an existing directory, - # for example /java/linux/cups - if test -d ${resource}; then - depdir=${resource} - else - -# boot-jdk is for example mymodule -# $resource is for example libs/general/libmymod_1_2_3.zip -# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps -# $with_builddeps_dir is for example /localhome/builddeps -# depdir is the name of the variable into which we store the depdir, eg MYMOD -# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and -# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 - filename=`basename $resource` - filebase=`echo $filename | sed 's/\.[^\.]*$//'` - filebase=${filename%%.*} - extension=${filename#*.} - installdir=$with_builddeps_dir/$filebase - if test ! -f $installdir/$filename.unpacked; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency boot-jdk from $with_builddeps_server/$resource and installing into $installdir" >&5 -$as_echo "$as_me: Downloading build dependency boot-jdk from $with_builddeps_server/$resource and installing into $installdir" >&6;} - if test ! -d $installdir; then - mkdir -p $installdir - fi - if test ! -d $installdir; then - as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 - fi - tmpfile=`mktemp $installdir/boot-jdk.XXXXXXXXX` - touch $tmpfile - if test ! -f $tmpfile; then - as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 - fi - - # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip - # $tmpfile is the local file name for the downloaded file. - VALID_TOOL=no - if test "x$BDEPS_FTP" = xwget; then - VALID_TOOL=yes - wget -O $tmpfile $with_builddeps_server/$resource - fi - if test "x$BDEPS_FTP" = xlftp; then - VALID_TOOL=yes - lftp -c "get $with_builddeps_server/$resource -o $tmpfile" - fi - if test "x$BDEPS_FTP" = xftp; then - VALID_TOOL=yes - FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` - FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` - FTPUSERPWD=${FTPSERVER%%@*} - if test "x$FTPSERVER" != "x$FTPUSERPWD"; then - FTPUSER=${userpwd%%:*} - FTPPWD=${userpwd#*@} - FTPSERVER=${FTPSERVER#*@} - else - FTPUSER=ftp - FTPPWD=ftp - fi - # the "pass" command does not work on some - # ftp clients (read ftp.exe) but if it works, - # passive mode is better! - (\ - echo "user $FTPUSER $FTPPWD" ;\ - echo "pass" ;\ - echo "bin" ;\ - echo "get $FTPPATH $tmpfile" ;\ - ) | ftp -in $FTPSERVER - fi - if test "x$VALID_TOOL" != xyes; then - as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 - fi - - mv $tmpfile $installdir/$filename - if test ! -s $installdir/$filename; then - as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 - fi - case "$extension" in - zip) echo "Unzipping $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) - ;; - tar.gz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - tgz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 - ;; - esac - fi - if test -f $installdir/$filename.unpacked; then - depdir=$installdir - fi - - fi - # Source the builddeps file again, because in the previous command, the depdir - # was updated to point at the current build dependency install directory. - . $builddepsfile - # Now extract variables from the builddeps.conf files. - theroot=${builddep_boot-jdk_ROOT} - thecflags=${builddep_boot-jdk_CFLAGS} - thelibs=${builddep_boot-jdk_LIBS} - if test "x$depdir" = x; then - as_fn_error $? "Could not download build dependency boot-jdk" "$LINENO" 5 - fi - BOOT_JDK=$depdir - if test "x$theroot" != x; then - BOOT_JDK="$theroot" - fi - if test "x$thecflags" != x; then - BOOT_JDK_CFLAGS="$thecflags" - fi - if test "x$thelibs" != x; then - BOOT_JDK_LIBS="$thelibs" - fi - BOOT_JDK_FOUND=yes - else BOOT_JDK_FOUND=no - - fi - else BOOT_JDK_FOUND=no - - fi - -fi - -if test "x$BOOT_JDK_FOUND" = xno; then - if test "x$JAVA_HOME" != x; then - if test ! -d "$JAVA_HOME"; then - as_fn_error $? "Your JAVA_HOME points to a non-existing directory!" "$LINENO" 5 - fi - # Aha, the user has set a JAVA_HOME - # let us use that as the Boot JDK. - BOOT_JDK="$JAVA_HOME" - BOOT_JDK_FOUND=yes - # To be on the safe side, lets check that it is a JDK. - if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then - JAVAC="$BOOT_JDK/bin/javac" - JAVA="$BOOT_JDK/bin/java" - BOOT_JDK_FOUND=yes - else - as_fn_error $? "Your JAVA_HOME points to a JRE! The build needs a JDK! Please point JAVA_HOME to a JDK. JAVA_HOME=$JAVA_HOME" "$LINENO" 5 - fi - fi -fi - -if test "x$BOOT_JDK_FOUND" = xno; then - # Extract the first word of "javac", so it can be a program name with args. -set dummy javac; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_JAVAC_CHECK+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $JAVAC_CHECK in - [\\/]* | ?:[\\/]*) - ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK -if test -n "$JAVAC_CHECK"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5 -$as_echo "$JAVAC_CHECK" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - # Extract the first word of "java", so it can be a program name with args. -set dummy java; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_JAVA_CHECK+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $JAVA_CHECK in - [\\/]* | ?:[\\/]*) - ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -JAVA_CHECK=$ac_cv_path_JAVA_CHECK -if test -n "$JAVA_CHECK"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5 -$as_echo "$JAVA_CHECK" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - BINARY="$JAVAC_CHECK" - if test "x$JAVAC_CHECK" = x; then - BINARY="$JAVA_CHECK" - fi - if test "x$BINARY" != x; then - # So there is a java(c) binary, it might be part of a JDK. - # Lets find the JDK/JRE directory by following symbolic links. - # Linux/GNU systems often have links from /usr/bin/java to - # /etc/alternatives/java to the real JDK binary. - - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="$BINARY" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "$BINARY"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - BINARY="$tmp" - - - if test "x$BUILD_OS" != xwindows; then - # Follow a chain of symbolic links. Use readlink - # where it exists, else fall back to horribly - # complicated shell code. - # Extract the first word of "readlink", so it can be a program name with args. -set dummy readlink; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_READLINK+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $READLINK in - [\\/]* | ?:[\\/]*) - ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -READLINK=$ac_cv_path_READLINK -if test -n "$READLINK"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5 -$as_echo "$READLINK" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - if test "x$READLINK_TESTED" != yes; then - # On MacOSX there is a readlink tool with a different - # purpose than the GNU readlink tool. Check the found readlink. - ISGNU=`$READLINK --help 2>&1 | grep GNU` - if test "x$ISGNU" = x; then - # A readlink that we do not know how to use. - # Are there other non-GNU readlinks out there? - READLINK_TESTED=yes - READLINK= - fi - fi - - if test "x$READLINK" != x; then - BINARY=`$READLINK -f $BINARY` - else - STARTDIR=$PWD - COUNTER=0 - DIR=`dirname $BINARY` - FIL=`basename $BINARY` - while test $COUNTER -lt 20; do - ISLINK=`ls -l $DIR/$FIL | grep '\->' | sed -e 's/.*-> \(.*\)/\1/'` - if test "x$ISLINK" == x; then - # This is not a symbolic link! We are done! - break - fi - # The link might be relative! We have to use cd to travel safely. - cd $DIR - cd `dirname $ISLINK` - DIR=`pwd` - FIL=`basename $ISLINK` - let COUNTER=COUNTER+1 - done - cd $STARTDIR - BINARY=$DIR/$FIL - fi - fi - - BOOT_JDK=`dirname $BINARY` - BOOT_JDK=`cd $BOOT_JDK/..; pwd` - if test -x $BOOT_JDK/bin/javac && test -x $BOOT_JDK/bin/java; then - JAVAC=$BOOT_JDK/bin/javac - JAVA=$BOOT_JDK/bin/java - BOOT_JDK_FOUND=yes - fi - fi -fi - -if test "x$BOOT_JDK_FOUND" = xno; then - # Try the MacOSX way. - if test -x /usr/libexec/java_home; then - BOOT_JDK=`/usr/libexec/java_home` - if test -x $BOOT_JDK/bin/javac && test -x $BOOT_JDK/bin/java; then - JAVAC=$BOOT_JDK/bin/javac - JAVA=$BOOT_JDK/bin/java - BOOT_JDK_FOUND=yes - fi - fi -fi - -if test "x$BOOT_JDK_FOUND" = xno; then - # Extract the first word of "java", so it can be a program name with args. -set dummy java; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_JAVA_CHECK+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $JAVA_CHECK in - [\\/]* | ?:[\\/]*) - ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -JAVA_CHECK=$ac_cv_path_JAVA_CHECK -if test -n "$JAVA_CHECK"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5 -$as_echo "$JAVA_CHECK" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - if test "x$JAVA_CHECK" != x; then - # There is a java in the path. But apparently we have not found a javac - # in the path, since that would have been tested earlier. - if test "x$HOST_OS" = xwindows; then - # Now if this is a windows platform. The default installation of a JDK - # actually puts the JRE in the path and keeps the JDK out of the path! - # Go look in the default installation location. - BOOT_JDK=/cygdrive/c/Program\ Files/Java/`ls /cygdrive/c/Program\ Files/Java | grep jdk | sort -r | head --lines 1` - if test -d "$BOOT_JDK"; then - BOOT_JDK_FOUND=yes - fi - fi - if test "x$BOOT_JDK_FOUND" = xno; then - help_on_build_dependency openjdk - as_fn_error $? "Found a JRE, not not a JDK! Please remove the JRE from your path and put a JDK there instead. $HELP_MSG" "$LINENO" 5 - fi - else - help_on_build_dependency openjdk - as_fn_error $? "Could not find a JDK. $HELP_MSG" "$LINENO" 5 - fi -fi - - - if test "x$BUILD_OS" = "xwindows"; then - # Extract the first word of "cygpath", so it can be a program name with args. -set dummy cygpath; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CYGPATH+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - case $CYGPATH in - [\\/]* | ?:[\\/]*) - ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CYGPATH=$ac_cv_path_CYGPATH -if test -n "$CYGPATH"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5 -$as_echo "$CYGPATH" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - tmp="$BOOT_JDK" - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - BOOT_JDK="$tmp" - fi - - -# Now see if we can find the rt.jar, or its nearest equivalent. -BOOT_RTJAR="$BOOT_JDK/jre/lib/rt.jar" - - # Fail with message the path to the Boot JDK rt.jar (or nearest equivalent) if var BOOT_RTJAR contains a path with no spaces in it. - # Unless on Windows, where we can rewrite the path. - HAS_SPACE=`echo "$BOOT_RTJAR" | grep " "` - if test "x$HAS_SPACE" != x; then - if test "x$BUILD_OS" = "xwindows"; then - BOOT_RTJAR=`$CYGPATH -s -m -a "$BOOT_RTJAR"` - BOOT_RTJAR=`$CYGPATH -u "$BOOT_RTJAR"` - else - as_fn_error $? "You cannot have spaces in the path to the Boot JDK rt.jar (or nearest equivalent)! \"$BOOT_RTJAR\"" "$LINENO" 5 - fi - fi - - -BOOT_TOOLSJAR="$BOOT_JDK/lib/tools.jar" - - # Fail with message the path to the Boot JDK tools.jar (or nearest equivalent) if var BOOT_TOOLSJAR contains a path with no spaces in it. - # Unless on Windows, where we can rewrite the path. - HAS_SPACE=`echo "$BOOT_TOOLSJAR" | grep " "` - if test "x$HAS_SPACE" != x; then - if test "x$BUILD_OS" = "xwindows"; then - BOOT_TOOLSJAR=`$CYGPATH -s -m -a "$BOOT_TOOLSJAR"` - BOOT_TOOLSJAR=`$CYGPATH -u "$BOOT_TOOLSJAR"` - else - as_fn_error $? "You cannot have spaces in the path to the Boot JDK tools.jar (or nearest equivalent)! \"$BOOT_TOOLSJAR\"" "$LINENO" 5 - fi - fi - - -if test ! -f $BOOT_RTJAR; then - # On MacOSX it is called classes.jar - BOOT_RTJAR=$BOOT_JDK/../Classes/classes.jar - if test ! -f $BOOT_RTJAR; then - as_fn_error $? "Cannot find the rt.jar or its equivalent!" "$LINENO" 5 - fi - # Remove the .. - BOOT_RTJAR="`cd ${BOOT_RTJAR%/*} && pwd`/${BOOT_RTJAR##*/}" - # The tools.jar is part of classes.jar - BOOT_TOOLSJAR="$BOOT_RTJAR" -fi - - - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5 -$as_echo_n "checking for Boot JDK... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5 -$as_echo "$BOOT_JDK" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot rt.jar" >&5 -$as_echo_n "checking for Boot rt.jar... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_RTJAR" >&5 -$as_echo "$BOOT_RTJAR" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot tools.jar" >&5 -$as_echo_n "checking for Boot tools.jar... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_TOOLSJAR" >&5 -$as_echo "$BOOT_TOOLSJAR" >&6; } - -# Use the java tool from the Boot JDK. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5 -$as_echo_n "checking for java in Boot JDK... " >&6; } -JAVA=$BOOT_JDK/bin/java -if test ! -x $JAVA; then - as_fn_error $? "Could not find a working java" "$LINENO" 5 -fi -BOOT_JDK_VERSION=`$JAVA -version 2>&1 | head -n 1` -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes $BOOT_JDK_VERSION" >&5 -$as_echo "yes $BOOT_JDK_VERSION" >&6; } - - -# Extra M4 quote needed to protect [] in grep expression. -FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep '\"1\.[78]\.'` -if test "x$FOUND_VERSION_78" = x; then - help_on_build_dependency openjdk - as_fn_error $? "Your boot-jdk must be version 7 or 8. $HELP_MSG" "$LINENO" 5 -fi - -# When compiling code to be executed by the Boot JDK, force jdk7 compatibility. -BOOT_JDK_SOURCETARGET="-source 7 -target 7" - - -# Use the javac tool from the Boot JDK. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5 -$as_echo_n "checking for javac in Boot JDK... " >&6; } -JAVAC=$BOOT_JDK/bin/javac -if test ! -x $JAVAC; then - as_fn_error $? "Could not find a working javac" "$LINENO" 5 -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - - - -# Use the javah tool from the Boot JDK. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5 -$as_echo_n "checking for javah in Boot JDK... " >&6; } -JAVAH=$BOOT_JDK/bin/javah -if test ! -x $JAVAH; then - as_fn_error $? "Could not find a working javah" "$LINENO" 5 -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - - -# Use the jar tool from the Boot JDK. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5 -$as_echo_n "checking for jar in Boot JDK... " >&6; } -JAR=$BOOT_JDK/bin/jar -if test ! -x $JAR; then - as_fn_error $? "Could not find a working jar" "$LINENO" 5 -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - -# Use the rmic tool from the Boot JDK. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for rmic in Boot JDK" >&5 -$as_echo_n "checking for rmic in Boot JDK... " >&6; } -RMIC=$BOOT_JDK/bin/rmic -if test ! -x $RMIC; then - as_fn_error $? "Could not find a working rmic" "$LINENO" 5 -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - -# Use the native2ascii tool from the Boot JDK. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for native2ascii in Boot JDK" >&5 -$as_echo_n "checking for native2ascii in Boot JDK... " >&6; } -NATIVE2ASCII=$BOOT_JDK/bin/native2ascii -if test ! -x $NATIVE2ASCII; then - as_fn_error $? "Could not find a working native2ascii" "$LINENO" 5 -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - - -############################################################################### -# -# Pickup additional source for a component from outside of the source root -# or override source for a component. -# - -# Check whether --with-add-source-root was given. -if test "${with_add_source_root+set}" = set; then : - withval=$with_add_source_root; -fi - - - -# Check whether --with-override-source-root was given. -if test "${with_override_source_root+set}" = set; then : - withval=$with_override_source_root; -fi - - - -# Check whether --with-adds-and-overrides was given. -if test "${with_adds_and_overrides+set}" = set; then : - withval=$with_adds_and_overrides; -fi - - -if test "x$with_adds_and_overrides" != x; then - with_add_source_root="$with_adds_and_overrides/adds" - with_override_source_root="$with_adds_and_overrides/overrides" -fi - -if test "x$with_add_source_root" != x; then - if ! test -d $with_add_source_root; then - as_fn_error $? "Trying to use a non-existant add-source-root $with_add_source_root" "$LINENO" 5 - fi - CURDIR="$PWD" - cd "$with_add_source_root" - ADD_SRC_ROOT="`pwd`" - cd "$CURDIR" - # Verify that the addon source root does not have any root makefiles. - # If it does, then it is usually an error, prevent this. - if test -f $with_add_source_root/langtools/makefiles/Makefile || \ - test -f $with_add_source_root/langtools/make/Makefile; then - as_fn_error $? "Your add source root seems to contain a full langtools repo! An add source root should only contain additional sources." "$LINENO" 5 - fi - if test -f $with_add_source_root/corba/makefiles/Makefile || \ - test -f $with_add_source_root/corba/make/Makefile; then - as_fn_error $? "Your add source root seems to contain a full corba repo! An add source root should only contain additional sources." "$LINENO" 5 - fi - if test -f $with_add_source_root/jaxp/makefiles/Makefile || \ - test -f $with_add_source_root/jaxp/make/Makefile; then - as_fn_error $? "Your add source root seems to contain a full jaxp repo! An add source root should only contain additional sources." "$LINENO" 5 - fi - if test -f $with_add_source_root/jaxws/makefiles/Makefile || \ - test -f $with_add_source_root/jaxws/make/Makefile; then - as_fn_error $? "Your add source root seems to contain a full jaxws repo! An add source root should only contain additional sources." "$LINENO" 5 - fi - if test -f $with_add_source_root/hotspot/makefiles/Makefile || \ - test -f $with_add_source_root/hotspot/make/Makefile; then - as_fn_error $? "Your add source root seems to contain a full hotspot repo! An add source root should only contain additional sources." "$LINENO" 5 - fi - if test -f $with_add_source_root/jdk/makefiles/Makefile || \ - test -f $with_add_source_root/jdk/make/Makefile; then - as_fn_error $? "Your add source root seems to contain a full JDK repo! An add source root should only contain additional sources." "$LINENO" 5 - fi -fi - - -if test "x$with_override_source_root" != x; then - if ! test -d $with_override_source_root; then - as_fn_error $? "Trying to use a non-existant override-source-root $with_override_source_root" "$LINENO" 5 - fi - CURDIR="$PWD" - cd "$with_override_source_root" - OVERRIDE_SRC_ROOT="`pwd`" - cd "$CURDIR" - if test -f $with_override_source_root/langtools/makefiles/Makefile || \ - test -f $with_override_source_root/langtools/make/Makefile; then - as_fn_error $? "Your override source root seems to contain a full langtools repo! An override source root should only contain sources that override." "$LINENO" 5 - fi - if test -f $with_override_source_root/corba/makefiles/Makefile || \ - test -f $with_override_source_root/corba/make/Makefile; then - as_fn_error $? "Your override source root seems to contain a full corba repo! An override source root should only contain sources that override." "$LINENO" 5 - fi - if test -f $with_override_source_root/jaxp/makefiles/Makefile || \ - test -f $with_override_source_root/jaxp/make/Makefile; then - as_fn_error $? "Your override source root seems to contain a full jaxp repo! An override source root should only contain sources that override." "$LINENO" 5 - fi - if test -f $with_override_source_root/jaxws/makefiles/Makefile || \ - test -f $with_override_source_root/jaxws/make/Makefile; then - as_fn_error $? "Your override source root seems to contain a full jaxws repo! An override source root should only contain sources that override." "$LINENO" 5 - fi - if test -f $with_override_source_root/hotspot/makefiles/Makefile || \ - test -f $with_override_source_root/hotspot/make/Makefile; then - as_fn_error $? "Your override source root seems to contain a full hotspot repo! An override source root should only contain sources that override." "$LINENO" 5 - fi - if test -f $with_override_source_root/jdk/makefiles/Makefile || \ - test -f $with_override_source_root/jdk/make/Makefile; then - as_fn_error $? "Your override source root seems to contain a full JDK repo! An override source root should only contain sources that override." "$LINENO" 5 - fi -fi - - -############################################################################### -# -# Override a repo completely, this is used for example when you have 3 small -# development sandboxes of the langtools sources and want to avoid having 3 full -# OpenJDK sources checked out on disk. -# -# Assuming that the 3 langtools sandboxes are located here: -# /home/fredrik/sandbox1/langtools -# /home/fredrik/sandbox2/langtools -# /home/fredrik/sandbox3/langtools -# -# From the source root you create build subdirs manually: -# mkdir -p build1 build2 build3 -# in each build directory run: -# (cd build1 && ../configure --with-override-langtools=/home/fredrik/sandbox1 && make) -# (cd build2 && ../configure --with-override-langtools=/home/fredrik/sandbox2 && make) -# (cd build3 && ../configure --with-override-langtools=/home/fredrik/sandbox3 && make) -# - - -# Check whether --with-override-langtools was given. -if test "${with_override_langtools+set}" = set; then : - withval=$with_override_langtools; -fi - - - -# Check whether --with-override-corba was given. -if test "${with_override_corba+set}" = set; then : - withval=$with_override_corba; -fi - - - -# Check whether --with-override-jaxp was given. -if test "${with_override_jaxp+set}" = set; then : - withval=$with_override_jaxp; -fi - - - -# Check whether --with-override-jaxws was given. -if test "${with_override_jaxws+set}" = set; then : - withval=$with_override_jaxws; -fi - - - -# Check whether --with-override-hotspot was given. -if test "${with_override_hotspot+set}" = set; then : - withval=$with_override_hotspot; -fi - - - -# Check whether --with-override-jdk was given. -if test "${with_override_jdk+set}" = set; then : - withval=$with_override_jdk; -fi - - -if test "x$with_override_langtools" != x; then - CURDIR="$PWD" - cd "$with_override_langtools" - LANGTOOLS_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $LANGTOOLS_TOPDIR/makefiles/Makefile; then - as_fn_error $? "You have to override langtools with a full langtools repo!" "$LINENO" 5 - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if langtools should be overridden" >&5 -$as_echo_n "checking if langtools should be overridden... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $LANGTOOLS_TOPDIR" >&5 -$as_echo "yes with $LANGTOOLS_TOPDIR" >&6; } -fi -if test "x$with_override_corba" != x; then - CURDIR="$PWD" - cd "$with_override_corba" - CORBA_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $CORBA_TOPDIR/makefiles/Makefile; then - as_fn_error $? "You have to override corba with a full corba repo!" "$LINENO" 5 - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if corba should be overridden" >&5 -$as_echo_n "checking if corba should be overridden... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $CORBA_TOPDIR" >&5 -$as_echo "yes with $CORBA_TOPDIR" >&6; } -fi -if test "x$with_override_jaxp" != x; then - CURDIR="$PWD" - cd "$with_override_jaxp" - JAXP_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $JAXP_TOPDIR/makefiles/Makefile; then - as_fn_error $? "You have to override jaxp with a full jaxp repo!" "$LINENO" 5 - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if jaxp should be overridden" >&5 -$as_echo_n "checking if jaxp should be overridden... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JAXP_TOPDIR" >&5 -$as_echo "yes with $JAXP_TOPDIR" >&6; } -fi -if test "x$with_override_jaxws" != x; then - CURDIR="$PWD" - cd "$with_override_jaxws" - JAXWS_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $JAXWS_TOPDIR/makefiles/Makefile; then - as_fn_error $? "You have to override jaxws with a full jaxws repo!" "$LINENO" 5 - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if jaxws should be overridden" >&5 -$as_echo_n "checking if jaxws should be overridden... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JAXWS_TOPDIR" >&5 -$as_echo "yes with $JAXWS_TOPDIR" >&6; } -fi -if test "x$with_override_hotspot" != x; then - CURDIR="$PWD" - cd "$with_override_hotspot" - HOTSPOT_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $HOTSPOT_TOPDIR/make/Makefile && \ - ! test -f $HOTSPOT_TOPDIR/makefiles/Makefile; then - as_fn_error $? "You have to override hotspot with a full hotspot repo!" "$LINENO" 5 - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if hotspot should be overridden" >&5 -$as_echo_n "checking if hotspot should be overridden... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $HOTSPOT_TOPDIR" >&5 -$as_echo "yes with $HOTSPOT_TOPDIR" >&6; } -fi -if test "x$with_override_jdk" != x; then - CURDIR="$PWD" - cd "$with_override_jdk" - JDK_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $JDK_TOPDIR/makefiles/Makefile; then - as_fn_error $? "You have to override JDK with a full JDK repo!" "$LINENO" 5 - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if JDK should be overridden" >&5 -$as_echo_n "checking if JDK should be overridden... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JDK_TOPDIR" >&5 -$as_echo "yes with $JDK_TOPDIR" >&6; } -fi - -############################################################################### -# -# Specify options for anything that is run with the Boot JDK. -# - -# Check whether --with-boot-jdk-jvmargs was given. -if test "${with_boot_jdk_jvmargs+set}" = set; then : - withval=$with_boot_jdk_jvmargs; -fi - - -if test "x$with_boot_jdk_jvmargs" = x; then - # Not all JVM:s accept the same arguments on the command line. - # OpenJDK specific increase in thread stack for JDK build, - # well more specifically, when running javac. - if test "x$BUILD_NUM_BITS" = x32; then - STACK_SIZE=768 - else - # Running Javac on a JVM on a 64-bit machine, the stack takes more space - # since 64-bit pointers are pushed on the stach. Apparently, we need - # to increase the stack space when javacing the JDK.... - STACK_SIZE=1536 - fi - - # Minimum amount of heap memory. - - # Test if -Xms64M is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -Xms64M to boot_jdk_jvmargs - FOUND_WARN=`$JAVA -Xms64M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -Xms64M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - boot_jdk_jvmargs="$boot_jdk_jvmargs -Xms64M" - fi - - if test "x$HOST_OS" = "xmacosx"; then - # Why does macosx need more heap? Its the huge JDK batch. - - # Test if -Xmx1600M is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -Xmx1600M to boot_jdk_jvmargs - FOUND_WARN=`$JAVA -Xmx1600M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -Xmx1600M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - boot_jdk_jvmargs="$boot_jdk_jvmargs -Xmx1600M" - fi - - else - - # Test if -Xmx1100M is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -Xmx1100M to boot_jdk_jvmargs - FOUND_WARN=`$JAVA -Xmx1100M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -Xmx1100M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - boot_jdk_jvmargs="$boot_jdk_jvmargs -Xmx1100M" - fi - - fi - # When is adding -client something that speeds up the JVM? - # ADD_JVM_ARG_IF_OK([-client],boot_jdk_jvmargs,[$JAVA]) - - # Test if -XX:PermSize=32m is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -XX:PermSize=32m to boot_jdk_jvmargs - FOUND_WARN=`$JAVA -XX:PermSize=32m -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -XX:PermSize=32m -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:PermSize=32m" - fi - - - # Test if -XX:MaxPermSize=160m is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -XX:MaxPermSize=160m to boot_jdk_jvmargs - FOUND_WARN=`$JAVA -XX:MaxPermSize=160m -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -XX:MaxPermSize=160m -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:MaxPermSize=160m" - fi - - - # Test if -XX:ThreadStackSize=$STACK_SIZE is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -XX:ThreadStackSize=$STACK_SIZE to boot_jdk_jvmargs - FOUND_WARN=`$JAVA -XX:ThreadStackSize=$STACK_SIZE -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -XX:ThreadStackSize=$STACK_SIZE -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:ThreadStackSize=$STACK_SIZE" - fi - - # Disable special log output when a debug build is used as Boot JDK... - - # Test if -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput to boot_jdk_jvmargs - FOUND_WARN=`$JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput" - fi - -fi - -BOOT_JDK_JVMARGS=$boot_jdk_jvmargs - - - -# Check whether --with-server-java was given. -if test "${with_server_java+set}" = set; then : - withval=$with_server_java; -fi - - -if test "x$with_server_java" != x; then - SERVER_JAVA="$with_server_java" - FOUND_VERSION=`$SERVER_JAVA -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" = x; then - as_fn_error $? "Could not execute server java: $SERVER_JAVA" "$LINENO" 5 - fi -else - SERVER_JAVA="" - # Hotspot specific options. - - # Test if -XX:+UseParallelOldGC is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -XX:+UseParallelOldGC to SERVER_JAVA - FOUND_WARN=`$JAVA -XX:+UseParallelOldGC -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -XX:+UseParallelOldGC -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -XX:+UseParallelOldGC" - fi - - - # Test if -verbosegc is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -verbosegc to SERVER_JAVA - FOUND_WARN=`$JAVA -verbosegc -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -verbosegc -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -verbosegc" - fi - - # JRockit specific options. - - # Test if -Xverbose:gc is a valid argument to $JAVA (often is $JAVA passed as $JAVA) - # If so, then append -Xverbose:gc to SERVER_JAVA - FOUND_WARN=`$JAVA -Xverbose:gc -version 2>&1 | grep -i warn` - FOUND_VERSION=`$JAVA -Xverbose:gc -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xverbose:gc" - fi - - SERVER_JAVA="$JAVA $SERVER_JAVA" -fi - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use shared server for javac" >&5 -$as_echo_n "checking whether to use shared server for javac... " >&6; } -# Check whether --enable-javac-server was given. -if test "${enable_javac_server+set}" = set; then : - enableval=$enable_javac_server; ENABLE_JAVAC_SERVER="${enableval}" -else - ENABLE_JAVAC_SERVER='no' -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JAVAC_SERVER" >&5 -$as_echo "$ENABLE_JAVAC_SERVER" >&6; } -if test "x$ENABLE_JAVAC_SERVER" = xyes; then - JAVAC_USE_REMOTE=true - JAVAC_SERVERS="$OUTPUT_ROOT/javacservers" -else - JAVAC_USE_REMOTE=false - JAVAC_SERVERS= -fi - - - - -# Check whether --with-javac-server-cores was given. -if test "${with_javac_server_cores+set}" = set; then : - withval=$with_javac_server_cores; -fi - -if test "x$with_javac_server_cores" != x; then - JAVAC_SERVER_CORES="$with_javac_server_cores" -else - if test "$NUM_CORES" -gt 16; then - # We set this arbitrary limit because we want to limit the heap - # size of the javac server. - # In the future we will make the javac compilers in the server - # share more and more state, thus enabling us to use more and - # more concurrent threads in the server. - JAVAC_SERVER_CORES="16" - else - JAVAC_SERVER_CORES="$NUM_CORES" - fi - - if test "$MEMORY_SIZE" -gt "17000"; then - MAX_HEAP_MEM=10000 - - # Test if -d64 is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -d64 to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -d64 -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -d64 -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -d64" - fi - - - # Test if -Xms10G -Xmx10G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xms10G -Xmx10G to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xms10G -Xmx10G -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xms10G -Xmx10G -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xms10G -Xmx10G" - fi - - - # Test if -Xmn2G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xmn2G to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xmn2G -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xmn2G -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xmn2G" - fi - - elif test "$MEMORY_SIZE" -gt "10000"; then - MAX_HEAP_MEM=6000 - - # Test if -d64 is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -d64 to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -d64 -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -d64 -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -d64" - fi - - - # Test if -Xms6G -Xmx6G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xms6G -Xmx6G to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xms6G -Xmx6G -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xms6G -Xmx6G -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xms6G -Xmx6G" - fi - - - # Test if -Xmn1G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xmn1G to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xmn1G -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xmn1G -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xmn1G" - fi - - elif test "$MEMORY_SIZE" -gt "5000"; then - MAX_HEAP_MEM=3000 - - # Test if -d64 is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -d64 to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -d64 -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -d64 -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -d64" - fi - - - # Test if -Xms1G -Xmx3G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xms1G -Xmx3G to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xms1G -Xmx3G -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xms1G -Xmx3G -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xms1G -Xmx3G" - fi - - - # Test if -Xmn256M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xmn256M to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xmn256M" - fi - - elif test "$MEMORY_SIZE" -gt "3800"; then - MAX_HEAP_MEM=2500 - - # Test if -Xms1G -Xmx2500M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xms1G -Xmx2500M to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xms1G -Xmx2500M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xms1G -Xmx2500M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xms1G -Xmx2500M" - fi - - - # Test if -Xmn256M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xmn256M to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xmn256M" - fi - - elif test "$MEMORY_SIZE" -gt "1900"; then - MAX_HEAP_MEM=1200 - - # Test if -Xms700M -Xmx1200M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xms700M -Xmx1200M to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xms700M -Xmx1200M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xms700M -Xmx1200M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xms700M -Xmx1200M" - fi - - - # Test if -Xmn256M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xmn256M to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xmn256M" - fi - - elif test "$MEMORY_SIZE" -gt "1000"; then - MAX_HEAP_MEM=900 - - # Test if -Xms400M -Xmx900M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xms400M -Xmx900M to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xms400M -Xmx900M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xms400M -Xmx900M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xms400M -Xmx900M" - fi - - - # Test if -Xmn128M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xmn128M to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xmn128M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xmn128M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xmn128M" - fi - - else - MAX_HEAP_MEM=512 - - # Test if -Xms256M -Xmx512M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xms256M -Xmx512M to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xms256M -Xmx512M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xms256M -Xmx512M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xms256M -Xmx512M" - fi - - - # Test if -Xmn128M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) - # If so, then append -Xmn128M to SERVER_JAVA - FOUND_WARN=`$SERVER_JAVA -Xmn128M -version 2>&1 | grep -i warn` - FOUND_VERSION=`$SERVER_JAVA -Xmn128M -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - SERVER_JAVA="$SERVER_JAVA -Xmn128M" - fi - - fi - - MAX_COMPILERS_IN_HEAP=`expr $MAX_HEAP_MEM / 501` - if test "$JAVAC_SERVER_CORES" -gt "$MAX_COMPILERS_IN_HEAP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if number of server cores must be reduced" >&5 -$as_echo_n "checking if number of server cores must be reduced... " >&6; } - JAVAC_SERVER_CORES="$MAX_COMPILERS_IN_HEAP" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, to $JAVAC_SERVER_CORES with max heap size $MAX_HEAP_MEM MB" >&5 -$as_echo "yes, to $JAVAC_SERVER_CORES with max heap size $MAX_HEAP_MEM MB" >&6; } - fi -fi - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to track dependencies between Java packages" >&5 -$as_echo_n "checking whether to track dependencies between Java packages... " >&6; } -# Check whether --enable-javac-deps was given. -if test "${enable_javac_deps+set}" = set; then : - enableval=$enable_javac_deps; ENABLE_JAVAC_DEPS="${enableval}" -else - ENABLE_JAVAC_DEPS='no' -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JAVAC_DEPS" >&5 -$as_echo "$ENABLE_JAVAC_DEPS" >&6; } -if test "x$ENABLE_JAVAC_DEPS" = xyes; then - JAVAC_USE_DEPS=true -else - JAVAC_USE_DEPS=false -fi - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use multiple cores for javac compilation" >&5 -$as_echo_n "checking whether to use multiple cores for javac compilation... " >&6; } -# Check whether --enable-javac-multi-core was given. -if test "${enable_javac_multi_core+set}" = set; then : - enableval=$enable_javac_multi_core; ENABLE_JAVAC_MULTICORE="${enableval}" -else - ENABLE_JAVAC_MULTICORE='no' -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JAVAC_MULTICORE" >&5 -$as_echo "$ENABLE_JAVAC_MULTICORE" >&6; } -if test "x$ENABLE_JAVAC_MULTICORE" = xyes; then - JAVAC_USE_MODE=MULTI_CORE_CONCURRENT -else - JAVAC_USE_MODE=SINGLE_THREADED_BATCH - if test "x$ENABLE_JAVAC_DEPS" = xyes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Dependency tracking is not supported with single threaded batch compiles of Java source roots. Please add --disable-javac-deps to your configure options." >&5 -$as_echo "$as_me: WARNING: Dependency tracking is not supported with single threaded batch compiles of Java source roots. Please add --disable-javac-deps to your configure options." >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Disabling dependency tracking for you now." >&5 -$as_echo "$as_me: WARNING: Disabling dependency tracking for you now." >&2;} - JAVAC_USE_DEPS=false - fi - if test "x$ENABLE_JAVAC_SERVER" = xyes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The javac server will not be used since single threaded batch compiles are run within their own JVM. Please add --disable-javac-server to your configure options." >&5 -$as_echo "$as_me: WARNING: The javac server will not be used since single threaded batch compiles are run within their own JVM. Please add --disable-javac-server to your configure options." >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Disabling javac server for you now." >&5 -$as_echo "$as_me: WARNING: Disabling javac server for you now." >&2;} - JAVAC_USE_REMOTE=false - fi -fi - - -############################################################################### -# -# OS specific settings that we never will need to probe. -# -if test "x$HOST_OS" = xlinux; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Linux?" >&5 -$as_echo_n "checking what is not needed on Linux?... " >&6; } - PULSE_NOT_NEEDED=yes - { $as_echo "$as_me:${as_lineno-$LINENO}: result: pulse" >&5 -$as_echo "pulse" >&6; } -fi - -if test "x$HOST_OS" = xsolaris; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Solaris?" >&5 -$as_echo_n "checking what is not needed on Solaris?... " >&6; } - ALSA_NOT_NEEDED=yes - PULSE_NOT_NEEDED=yes - { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5 -$as_echo "alsa pulse" >&6; } -fi - -if test "x$HOST_OS" = xwindows; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Windows?" >&5 -$as_echo_n "checking what is not needed on Windows?... " >&6; } - CUPS_NOT_NEEDED=yes - ALSA_NOT_NEEDED=yes - PULSE_NOT_NEEDED=yes - X11_NOT_NEEDED=yes - { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa cups pulse x11" >&5 -$as_echo "alsa cups pulse x11" >&6; } -fi - -if test "x$HOST_OS" = xmacosx; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on MacOSX?" >&5 -$as_echo_n "checking what is not needed on MacOSX?... " >&6; } - ALSA_NOT_NEEDED=yes - PULSE_NOT_NEEDED=yes - X11_NOT_NEEDED=yes - FREETYPE2_NOT_NEEDED=yes - # If the java runtime framework is disabled, then we need X11. - # This will be adjusted below. - { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse x11" >&5 -$as_echo "alsa pulse x11" >&6; } -fi - -if test "x$HOST_OS" = xbsd; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on bsd?" >&5 -$as_echo_n "checking what is not needed on bsd?... " >&6; } - ALSA_NOT_NEEDED=yes - { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa" >&5 -$as_echo "alsa" >&6; } -fi - -############################################################################### -# -# Check for MacOSX support for OpenJDK. If this exists, try to build a JVM -# that uses this API. -# -# Check whether --enable-macosx-runtime-support was given. -if test "${enable_macosx_runtime_support+set}" = set; then : - enableval=$enable_macosx_runtime_support; MACOSX_RUNTIME_SUPPORT="${enableval}" -else - MACOSX_RUNTIME_SUPPORT="no" -fi - - -USE_MACOSX_RUNTIME_SUPPORT=no -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for explicit Java runtime support in the OS" >&5 -$as_echo_n "checking for explicit Java runtime support in the OS... " >&6; } -if test -f /System/Library/Frameworks/JavaVM.framework/Frameworks/JavaRuntimeSupport.framework/Headers/JavaRuntimeSupport.h; then - if test "x$MACOSX_RUNTIME_SUPPORT" != xno; then - MACOSX_RUNTIME_SUPPORT=yes - USE_MACOSX_RUNTIME_SUPPORT=yes - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, does not need alsa freetype2 pulse and X11" >&5 -$as_echo "yes, does not need alsa freetype2 pulse and X11" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, but explicitly disabled." >&5 -$as_echo "yes, but explicitly disabled." >&6; } - fi -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - -if test "x$HOST_OS" = xmacosx && test "x$USE_MACOSX_RUNTIME_SUPPORT" = xno; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on an X11 build on MacOSX?" >&5 -$as_echo_n "checking what is not needed on an X11 build on MacOSX?... " >&6; } - X11_NOT_NEEDED= - FREETYPE2_NOT_NEEDED= - { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5 -$as_echo "alsa pulse" >&6; } -fi - -############################################################################### -# -# Check for X Windows -# -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5 -$as_echo_n "checking for X... " >&6; } - - -# Check whether --with-x was given. -if test "${with_x+set}" = set; then : - withval=$with_x; -fi - -# $have_x is `yes', `no', `disabled', or empty when we do not yet know. -if test "x$with_x" = xno; then - # The user explicitly disabled X. - have_x=disabled -else - case $x_includes,$x_libraries in #( - *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5 ;; #( - *,NONE | NONE,*) if test "${ac_cv_have_x+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - # One or both of the vars are not set, and there is no cached value. -ac_x_includes=no ac_x_libraries=no -rm -f -r conftest.dir -if mkdir conftest.dir; then - cd conftest.dir - cat >Imakefile <<'_ACEOF' -incroot: - @echo incroot='${INCROOT}' -usrlibdir: - @echo usrlibdir='${USRLIBDIR}' -libdir: - @echo libdir='${LIBDIR}' -_ACEOF - if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then - # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. - for ac_var in incroot usrlibdir libdir; do - eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`" - done - # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR. - for ac_extension in a so sl dylib la dll; do - if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" && - test -f "$ac_im_libdir/libX11.$ac_extension"; then - ac_im_usrlibdir=$ac_im_libdir; break - fi - done - # Screen out bogus values from the imake configuration. They are - # bogus both because they are the default anyway, and because - # using them would break gcc on systems where it needs fixed includes. - case $ac_im_incroot in - /usr/include) ac_x_includes= ;; - *) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;; - esac - case $ac_im_usrlibdir in - /usr/lib | /usr/lib64 | /lib | /lib64) ;; - *) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;; - esac - fi - cd .. - rm -f -r conftest.dir -fi - -# Standard set of common directories for X headers. -# Check X11 before X11Rn because it is often a symlink to the current release. -ac_x_header_dirs=' -/usr/X11/include -/usr/X11R7/include -/usr/X11R6/include -/usr/X11R5/include -/usr/X11R4/include - -/usr/include/X11 -/usr/include/X11R7 -/usr/include/X11R6 -/usr/include/X11R5 -/usr/include/X11R4 - -/usr/local/X11/include -/usr/local/X11R7/include -/usr/local/X11R6/include -/usr/local/X11R5/include -/usr/local/X11R4/include - -/usr/local/include/X11 -/usr/local/include/X11R7 -/usr/local/include/X11R6 -/usr/local/include/X11R5 -/usr/local/include/X11R4 - -/usr/X386/include -/usr/x386/include -/usr/XFree86/include/X11 - -/usr/include -/usr/local/include -/usr/unsupported/include -/usr/athena/include -/usr/local/x11r5/include -/usr/lpp/Xamples/include - -/usr/openwin/include -/usr/openwin/share/include' - -if test "$ac_x_includes" = no; then - # Guess where to find include files, by looking for Xlib.h. - # First, try using that file with no special directory specified. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_cxx_try_cpp "$LINENO"; then : - # We can compile using X headers with no special include directory. -ac_x_includes= -else - for ac_dir in $ac_x_header_dirs; do - if test -r "$ac_dir/X11/Xlib.h"; then - ac_x_includes=$ac_dir - break - fi -done -fi -rm -f conftest.err conftest.i conftest.$ac_ext -fi # $ac_x_includes = no - -if test "$ac_x_libraries" = no; then - # Check for the libraries. - # See if we find them without any special options. - # Don't add to $LIBS permanently. - ac_save_LIBS=$LIBS - LIBS="-lX11 $LIBS" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -int -main () -{ -XrmInitialize () - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - LIBS=$ac_save_LIBS -# We can link X programs with no special library path. -ac_x_libraries= -else - LIBS=$ac_save_LIBS -for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g` -do - # Don't even attempt the hair of trying to link an X program! - for ac_extension in a so sl dylib la dll; do - if test -r "$ac_dir/libX11.$ac_extension"; then - ac_x_libraries=$ac_dir - break 2 - fi - done -done -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -fi # $ac_x_libraries = no - -case $ac_x_includes,$ac_x_libraries in #( - no,* | *,no | *\'*) - # Didn't find X, or a directory has "'" in its name. - ac_cv_have_x="have_x=no";; #( - *) - # Record where we found X for the cache. - ac_cv_have_x="have_x=yes\ - ac_x_includes='$ac_x_includes'\ - ac_x_libraries='$ac_x_libraries'" -esac -fi -;; #( - *) have_x=yes;; - esac - eval "$ac_cv_have_x" -fi # $with_x != no - -if test "$have_x" != yes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5 -$as_echo "$have_x" >&6; } - no_x=yes -else - # If each of the values was on the command line, it overrides each guess. - test "x$x_includes" = xNONE && x_includes=$ac_x_includes - test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries - # Update the cache value to reflect the command line values. - ac_cv_have_x="have_x=yes\ - ac_x_includes='$x_includes'\ - ac_x_libraries='$x_libraries'" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5 -$as_echo "libraries $x_libraries, headers $x_includes" >&6; } -fi - -if test "$no_x" = yes; then - # Not all programs may use this symbol, but it does not hurt to define it. - -$as_echo "#define X_DISPLAY_MISSING 1" >>confdefs.h - - X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS= -else - if test -n "$x_includes"; then - X_CFLAGS="$X_CFLAGS -I$x_includes" - fi - - # It would also be nice to do this for all -L options, not just this one. - if test -n "$x_libraries"; then - X_LIBS="$X_LIBS -L$x_libraries" - # For Solaris; some versions of Sun CC require a space after -R and - # others require no space. Words are not sufficient . . . . - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5 -$as_echo_n "checking whether -R must be followed by a space... " >&6; } - ac_xsave_LIBS=$LIBS; LIBS="$LIBS -R$x_libraries" - ac_xsave_cxx_werror_flag=$ac_cxx_werror_flag - ac_cxx_werror_flag=yes - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - X_LIBS="$X_LIBS -R$x_libraries" -else - LIBS="$ac_xsave_LIBS -R $x_libraries" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - X_LIBS="$X_LIBS -R $x_libraries" -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: neither works" >&5 -$as_echo "neither works" >&6; } -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext - ac_cxx_werror_flag=$ac_xsave_cxx_werror_flag - LIBS=$ac_xsave_LIBS - fi - - # Check for system-dependent libraries X programs must link with. - # Do this before checking for the system-independent R6 libraries - # (-lICE), since we may need -lsocket or whatever for X linking. - - if test "$ISC" = yes; then - X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl_s -linet" - else - # Martyn Johnson says this is needed for Ultrix, if the X - # libraries were built with DECnet support. And Karl Berry says - # the Alpha needs dnet_stub (dnet does not exist). - ac_xsave_LIBS="$LIBS"; LIBS="$LIBS $X_LIBS -lX11" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char XOpenDisplay (); -int -main () -{ -return XOpenDisplay (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - -else - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5 -$as_echo_n "checking for dnet_ntoa in -ldnet... " >&6; } -if test "${ac_cv_lib_dnet_dnet_ntoa+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-ldnet $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char dnet_ntoa (); -int -main () -{ -return dnet_ntoa (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_dnet_dnet_ntoa=yes -else - ac_cv_lib_dnet_dnet_ntoa=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5 -$as_echo "$ac_cv_lib_dnet_dnet_ntoa" >&6; } -if test "x$ac_cv_lib_dnet_dnet_ntoa" = x""yes; then : - X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet" -fi - - if test $ac_cv_lib_dnet_dnet_ntoa = no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5 -$as_echo_n "checking for dnet_ntoa in -ldnet_stub... " >&6; } -if test "${ac_cv_lib_dnet_stub_dnet_ntoa+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-ldnet_stub $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char dnet_ntoa (); -int -main () -{ -return dnet_ntoa (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_dnet_stub_dnet_ntoa=yes -else - ac_cv_lib_dnet_stub_dnet_ntoa=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5 -$as_echo "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; } -if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = x""yes; then : - X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub" -fi - - fi -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext - LIBS="$ac_xsave_LIBS" - - # msh@cis.ufl.edu says -lnsl (and -lsocket) are needed for his 386/AT, - # to get the SysV transport functions. - # Chad R. Larson says the Pyramis MIS-ES running DC/OSx (SVR4) - # needs -lnsl. - # The nsl library prevents programs from opening the X display - # on Irix 5.2, according to T.E. Dickey. - # The functions gethostbyname, getservbyname, and inet_addr are - # in -lbsd on LynxOS 3.0.1/i386, according to Lars Hecking. - ac_fn_cxx_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname" -if test "x$ac_cv_func_gethostbyname" = x""yes; then : - -fi - - if test $ac_cv_func_gethostbyname = no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5 -$as_echo_n "checking for gethostbyname in -lnsl... " >&6; } -if test "${ac_cv_lib_nsl_gethostbyname+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lnsl $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char gethostbyname (); -int -main () -{ -return gethostbyname (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_nsl_gethostbyname=yes -else - ac_cv_lib_nsl_gethostbyname=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5 -$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; } -if test "x$ac_cv_lib_nsl_gethostbyname" = x""yes; then : - X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl" -fi - - if test $ac_cv_lib_nsl_gethostbyname = no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5 -$as_echo_n "checking for gethostbyname in -lbsd... " >&6; } -if test "${ac_cv_lib_bsd_gethostbyname+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lbsd $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char gethostbyname (); -int -main () -{ -return gethostbyname (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_bsd_gethostbyname=yes -else - ac_cv_lib_bsd_gethostbyname=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5 -$as_echo "$ac_cv_lib_bsd_gethostbyname" >&6; } -if test "x$ac_cv_lib_bsd_gethostbyname" = x""yes; then : - X_EXTRA_LIBS="$X_EXTRA_LIBS -lbsd" -fi - - fi - fi - - # lieder@skyler.mavd.honeywell.com says without -lsocket, - # socket/setsockopt and other routines are undefined under SCO ODT - # 2.0. But -lsocket is broken on IRIX 5.2 (and is not necessary - # on later versions), says Simon Leinen: it contains gethostby* - # variants that don't use the name server (or something). -lsocket - # must be given before -lnsl if both are needed. We assume that - # if connect needs -lnsl, so does gethostbyname. - ac_fn_cxx_check_func "$LINENO" "connect" "ac_cv_func_connect" -if test "x$ac_cv_func_connect" = x""yes; then : - -fi - - if test $ac_cv_func_connect = no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5 -$as_echo_n "checking for connect in -lsocket... " >&6; } -if test "${ac_cv_lib_socket_connect+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lsocket $X_EXTRA_LIBS $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char connect (); -int -main () -{ -return connect (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_socket_connect=yes -else - ac_cv_lib_socket_connect=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5 -$as_echo "$ac_cv_lib_socket_connect" >&6; } -if test "x$ac_cv_lib_socket_connect" = x""yes; then : - X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS" -fi - - fi - - # Guillermo Gomez says -lposix is necessary on A/UX. - ac_fn_cxx_check_func "$LINENO" "remove" "ac_cv_func_remove" -if test "x$ac_cv_func_remove" = x""yes; then : - -fi - - if test $ac_cv_func_remove = no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5 -$as_echo_n "checking for remove in -lposix... " >&6; } -if test "${ac_cv_lib_posix_remove+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lposix $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char remove (); -int -main () -{ -return remove (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_posix_remove=yes -else - ac_cv_lib_posix_remove=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5 -$as_echo "$ac_cv_lib_posix_remove" >&6; } -if test "x$ac_cv_lib_posix_remove" = x""yes; then : - X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix" -fi - - fi - - # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay. - ac_fn_cxx_check_func "$LINENO" "shmat" "ac_cv_func_shmat" -if test "x$ac_cv_func_shmat" = x""yes; then : - -fi - - if test $ac_cv_func_shmat = no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5 -$as_echo_n "checking for shmat in -lipc... " >&6; } -if test "${ac_cv_lib_ipc_shmat+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lipc $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char shmat (); -int -main () -{ -return shmat (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_ipc_shmat=yes -else - ac_cv_lib_ipc_shmat=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5 -$as_echo "$ac_cv_lib_ipc_shmat" >&6; } -if test "x$ac_cv_lib_ipc_shmat" = x""yes; then : - X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc" -fi - - fi - fi - - # Check for libraries that X11R6 Xt/Xaw programs need. - ac_save_LDFLAGS=$LDFLAGS - test -n "$x_libraries" && LDFLAGS="$LDFLAGS -L$x_libraries" - # SM needs ICE to (dynamically) link under SunOS 4.x (so we have to - # check for ICE first), but we must link in the order -lSM -lICE or - # we get undefined symbols. So assume we have SM if we have ICE. - # These have to be linked with before -lX11, unlike the other - # libraries we check for below, so use a different variable. - # John Interrante, Karl Berry - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5 -$as_echo_n "checking for IceConnectionNumber in -lICE... " >&6; } -if test "${ac_cv_lib_ICE_IceConnectionNumber+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lICE $X_EXTRA_LIBS $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char IceConnectionNumber (); -int -main () -{ -return IceConnectionNumber (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_ICE_IceConnectionNumber=yes -else - ac_cv_lib_ICE_IceConnectionNumber=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5 -$as_echo "$ac_cv_lib_ICE_IceConnectionNumber" >&6; } -if test "x$ac_cv_lib_ICE_IceConnectionNumber" = x""yes; then : - X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE" -fi - - LDFLAGS=$ac_save_LDFLAGS - -fi - - -if test "x$no_x" = xyes && test "x$X11_NOT_NEEDED" != xyes; then - help_on_build_dependency x11 - as_fn_error $? "Could not find X11 libraries. $HELP_MSG" "$LINENO" 5 -fi - -# Some of the old makefiles require a setting of OPENWIN_HOME -# Since the X11R6 directory has disappeared on later Linuxes, -# we need to probe for it. -if test "x$HOST_OS" = xlinux; then - if test -d "$SYS_ROOT/usr/X11R6"; then - OPENWIN_HOME="$SYS_ROOT/usr/X11R6" - fi - if test -d "$SYS_ROOT/usr/include/X11"; then - OPENWIN_HOME="$SYS_ROOT/usr" - fi -fi -if test "x$HOST_OS" = xsolaris; then - OPENWIN_HOME="/usr/openwin" -fi - - - -# -# Weird Sol10 something check...TODO change to try compile -# -if test "x${HOST_OS}" = xsolaris; then - if test "`uname -r`" = "5.10"; then - if test "`${EGREP} -c XLinearGradient ${OPENWIN_HOME}/share/include/X11/extensions/Xrender.h`" = "0"; then - X_CFLAGS="${X_CFLAGS} -DSOLARIS10_NO_XRENDER_STRUCTS" - fi - fi -fi - -ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - -OLD_CFLAGS="$CFLAGS" -CFLAGS="$CFLAGS $X_CFLAGS" - - -for ac_header in X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h -do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` -ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF - X11_A_OK=yes -else - X11_A_OK=no -fi - -done - -CFLAGS="$OLD_CFLAGS" -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - -if test "x$X11_A_OK" = xno && test "x$X11_NOT_NEEDED" != xyes; then - help_on_build_dependency x11 - as_fn_error $? "Could not find all X11 headers (shape.h Xrender.h XTest.h). $HELP_MSG" "$LINENO" 5 -fi - - - - -############################################################################### -# -# The common unix printing system cups is used to print from java. -# - -# Check whether --with-cups was given. -if test "${with_cups+set}" = set; then : - withval=$with_cups; -fi - - -# Check whether --with-cups-include was given. -if test "${with_cups_include+set}" = set; then : - withval=$with_cups_include; -fi - - -# Check whether --with-cups-lib was given. -if test "${with_cups_lib+set}" = set; then : - withval=$with_cups_lib; -fi - - -if test "x$CUPS_NOT_NEEDED" = xyes; then - if test "x${with_cups}" != x || test "x${with_cups_include}" != x || test "x${with_cups_lib}" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cups not used, so --with-cups is ignored" >&5 -$as_echo "$as_me: WARNING: cups not used, so --with-cups is ignored" >&2;} - fi - CUPS_CFLAGS= - CUPS_LIBS= -else - CUPS_FOUND=no - - if test "x${with_cups}" = xno || test "x${with_cups_include}" = xno || test "x${with_cups_lib}" = xno; then - as_fn_error $? "It is not possible to disable the use of cups. Remove the --without-cups option." "$LINENO" 5 - fi - - if test "x${with_cups}" != x; then - CUPS_LIBS="-L${with_cups}/lib -lcups" - CUPS_CFLAGS="-I${with_cups}/include" - CUPS_FOUND=yes - fi - if test "x${with_cups_include}" != x; then - CUPS_CFLAGS="-I${with_cups_include}" - CUPS_FOUND=yes - fi - if test "x${with_cups_lib}" != x; then - CUPS_LIBS="-L${with_cups_lib} -lcups" - CUPS_FOUND=yes - fi - if test "x$CUPS_FOUND" = xno; then - - - if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then - # Source the builddeps file again, to make sure it uses the latest variables! - . $builddepsfile - # Look for a host and build machine specific resource! - eval resource=\${builddep_cups_BUILD_${rewritten_build_var}_HOST_${rewritten_host_var}} - if test "x$resource" = x; then - # Ok, lets instead look for a host specific resource - eval resource=\${builddep_cups_HOST_${rewritten_host_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a build specific resource - eval resource=\${builddep_cups_BUILD_${rewritten_build_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a generic resource - # (The cups comes from M4 and not the shell, thus no need for eval here.) - resource=${builddep_cups} - fi - if test "x$resource" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for cups" >&5 -$as_echo "$as_me: Using builddeps $resource for cups" >&6;} - # If the resource in the builddeps.conf file is an existing directory, - # for example /java/linux/cups - if test -d ${resource}; then - depdir=${resource} - else - -# cups is for example mymodule -# $resource is for example libs/general/libmymod_1_2_3.zip -# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps -# $with_builddeps_dir is for example /localhome/builddeps -# depdir is the name of the variable into which we store the depdir, eg MYMOD -# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and -# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 - filename=`basename $resource` - filebase=`echo $filename | sed 's/\.[^\.]*$//'` - filebase=${filename%%.*} - extension=${filename#*.} - installdir=$with_builddeps_dir/$filebase - if test ! -f $installdir/$filename.unpacked; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&5 -$as_echo "$as_me: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&6;} - if test ! -d $installdir; then - mkdir -p $installdir - fi - if test ! -d $installdir; then - as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 - fi - tmpfile=`mktemp $installdir/cups.XXXXXXXXX` - touch $tmpfile - if test ! -f $tmpfile; then - as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 - fi - - # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip - # $tmpfile is the local file name for the downloaded file. - VALID_TOOL=no - if test "x$BDEPS_FTP" = xwget; then - VALID_TOOL=yes - wget -O $tmpfile $with_builddeps_server/$resource - fi - if test "x$BDEPS_FTP" = xlftp; then - VALID_TOOL=yes - lftp -c "get $with_builddeps_server/$resource -o $tmpfile" - fi - if test "x$BDEPS_FTP" = xftp; then - VALID_TOOL=yes - FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` - FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` - FTPUSERPWD=${FTPSERVER%%@*} - if test "x$FTPSERVER" != "x$FTPUSERPWD"; then - FTPUSER=${userpwd%%:*} - FTPPWD=${userpwd#*@} - FTPSERVER=${FTPSERVER#*@} - else - FTPUSER=ftp - FTPPWD=ftp - fi - # the "pass" command does not work on some - # ftp clients (read ftp.exe) but if it works, - # passive mode is better! - (\ - echo "user $FTPUSER $FTPPWD" ;\ - echo "pass" ;\ - echo "bin" ;\ - echo "get $FTPPATH $tmpfile" ;\ - ) | ftp -in $FTPSERVER - fi - if test "x$VALID_TOOL" != xyes; then - as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 - fi - - mv $tmpfile $installdir/$filename - if test ! -s $installdir/$filename; then - as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 - fi - case "$extension" in - zip) echo "Unzipping $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) - ;; - tar.gz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - tgz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 - ;; - esac - fi - if test -f $installdir/$filename.unpacked; then - depdir=$installdir - fi - - fi - # Source the builddeps file again, because in the previous command, the depdir - # was updated to point at the current build dependency install directory. - . $builddepsfile - # Now extract variables from the builddeps.conf files. - theroot=${builddep_cups_ROOT} - thecflags=${builddep_cups_CFLAGS} - thelibs=${builddep_cups_LIBS} - if test "x$depdir" = x; then - as_fn_error $? "Could not download build dependency cups" "$LINENO" 5 - fi - CUPS=$depdir - if test "x$theroot" != x; then - CUPS="$theroot" - fi - if test "x$thecflags" != x; then - CUPS_CFLAGS="$thecflags" - fi - if test "x$thelibs" != x; then - CUPS_LIBS="$thelibs" - fi - CUPS_FOUND=yes - - fi - - fi - - fi - if test "x$CUPS_FOUND" = xno; then - # Are the cups headers installed in the default /usr/include location? - for ac_header in cups/cups.h cups/ppd.h -do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` -ac_fn_cxx_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF - CUPS_FOUND=yes - CUPS_CFLAGS= - CUPS_LIBS="-lcups" - DEFAULT_CUPS=yes -fi - -done - - fi - if test "x$CUPS_FOUND" = xno; then - # Getting nervous now? Lets poke around for standard Solaris third-party - # package installation locations. - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cups headers and libs" >&5 -$as_echo_n "checking for cups headers and libs... " >&6; } - if test -s /opt/sfw/cups/include/cups/cups.h; then - # An SFW package seems to be installed! - CUPS_FOUND=yes - CUPS_CFLAGS="-I/opt/sfw/cups/include" - CUPS_LIBS="-L/opt/sfw/cups/lib -lcups" - elif test -s /opt/csw/include/cups/cups.h; then - # A CSW package seems to be installed! - CUPS_FOUND=yes - CUPS_CFLAGS="-I/opt/csw/include" - CUPS_LIBS="-L/opt/csw/lib -lcups" - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5 -$as_echo "$CUPS_FOUND" >&6; } - fi - if test "x$CUPS_FOUND" = xno; then - help_on_build_dependency cups - as_fn_error $? "Could not find cups! $HELP_MSG " "$LINENO" 5 - fi -fi - - - - -############################################################################### -# -# The ubiquitous freetype2 library is used to render fonts. -# - -# Check whether --with-freetype was given. -if test "${with_freetype+set}" = set; then : - withval=$with_freetype; -fi - - -# If we are using the OS installed system lib for freetype, then we do not need to copy it to the build tree -USING_SYSTEM_FT_LIB=false - -if test "x$FREETYPE2_NOT_NEEDED" = xyes; then - if test "x$with_freetype" != x || test "x$with_freetype_include" != x || test "x$with_freetype_lib" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: freetype not used, so --with-freetype is ignored" >&5 -$as_echo "$as_me: WARNING: freetype not used, so --with-freetype is ignored" >&2;} - fi - FREETYPE2_CFLAGS= - FREETYPE2_LIBS= - FREETYPE2_LIB_PATH= -else - FREETYPE2_FOUND=no - - if test "x$with_freetype" != x; then - - # Fail with message the path to freetype if var with_freetype contains a path with no spaces in it. - # Unless on Windows, where we can rewrite the path. - HAS_SPACE=`echo "$with_freetype" | grep " "` - if test "x$HAS_SPACE" != x; then - if test "x$BUILD_OS" = "xwindows"; then - with_freetype=`$CYGPATH -s -m -a "$with_freetype"` - with_freetype=`$CYGPATH -u "$with_freetype"` - else - as_fn_error $? "You cannot have spaces in the path to freetype! \"$with_freetype\"" "$LINENO" 5 - fi - fi - - FREETYPE2_LIBS="-L$with_freetype/lib -lfreetype" - if test "x$HOST_OS" = xwindows; then - FREETYPE2_LIBS="$with_freetype/lib/freetype.lib" - fi - FREETYPE2_LIB_PATH="$with_freetype/lib" - FREETYPE2_CFLAGS="-I$with_freetype/include" - if test -s $with_freetype/include/ft2build.h && test -d $with_freetype/include/freetype2/freetype; then - FREETYPE2_CFLAGS="-I$with_freetype/include/freetype2 -I$with_freetype/include" - fi - FREETYPE2_FOUND=yes - if test "x$FREETYPE2_FOUND" = xyes; then - # Verify that the directories exist - if ! test -d "$with_freetype/lib" || ! test -d "$with_freetype/include"; then - as_fn_error $? "Could not find the expected directories $with_freetype/lib and $with_freetype/include" "$LINENO" 5 - fi - # List the contents of the lib. - FREETYPELIB=`ls $with_freetype/lib/libfreetype.so $with_freetype/lib/freetype.dll 2> /dev/null` - if test "x$FREETYPELIB" = x; then - as_fn_error $? "Could not find libfreetype.se nor freetype.dll in $with_freetype/lib" "$LINENO" 5 - fi - # Check one h-file - if ! test -s "$with_freetype/include/ft2build.h"; then - as_fn_error $? "Could not find $with_freetype/include/ft2build.h" "$LINENO" 5 - fi - fi - fi - if test "x$FREETYPE2_FOUND" = xno; then - - - if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then - # Source the builddeps file again, to make sure it uses the latest variables! - . $builddepsfile - # Look for a host and build machine specific resource! - eval resource=\${builddep_freetype2_BUILD_${rewritten_build_var}_HOST_${rewritten_host_var}} - if test "x$resource" = x; then - # Ok, lets instead look for a host specific resource - eval resource=\${builddep_freetype2_HOST_${rewritten_host_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a build specific resource - eval resource=\${builddep_freetype2_BUILD_${rewritten_build_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a generic resource - # (The freetype2 comes from M4 and not the shell, thus no need for eval here.) - resource=${builddep_freetype2} - fi - if test "x$resource" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for freetype2" >&5 -$as_echo "$as_me: Using builddeps $resource for freetype2" >&6;} - # If the resource in the builddeps.conf file is an existing directory, - # for example /java/linux/cups - if test -d ${resource}; then - depdir=${resource} - else - -# freetype2 is for example mymodule -# $resource is for example libs/general/libmymod_1_2_3.zip -# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps -# $with_builddeps_dir is for example /localhome/builddeps -# depdir is the name of the variable into which we store the depdir, eg MYMOD -# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and -# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 - filename=`basename $resource` - filebase=`echo $filename | sed 's/\.[^\.]*$//'` - filebase=${filename%%.*} - extension=${filename#*.} - installdir=$with_builddeps_dir/$filebase - if test ! -f $installdir/$filename.unpacked; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency freetype2 from $with_builddeps_server/$resource and installing into $installdir" >&5 -$as_echo "$as_me: Downloading build dependency freetype2 from $with_builddeps_server/$resource and installing into $installdir" >&6;} - if test ! -d $installdir; then - mkdir -p $installdir - fi - if test ! -d $installdir; then - as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 - fi - tmpfile=`mktemp $installdir/freetype2.XXXXXXXXX` - touch $tmpfile - if test ! -f $tmpfile; then - as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 - fi - - # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip - # $tmpfile is the local file name for the downloaded file. - VALID_TOOL=no - if test "x$BDEPS_FTP" = xwget; then - VALID_TOOL=yes - wget -O $tmpfile $with_builddeps_server/$resource - fi - if test "x$BDEPS_FTP" = xlftp; then - VALID_TOOL=yes - lftp -c "get $with_builddeps_server/$resource -o $tmpfile" - fi - if test "x$BDEPS_FTP" = xftp; then - VALID_TOOL=yes - FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` - FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` - FTPUSERPWD=${FTPSERVER%%@*} - if test "x$FTPSERVER" != "x$FTPUSERPWD"; then - FTPUSER=${userpwd%%:*} - FTPPWD=${userpwd#*@} - FTPSERVER=${FTPSERVER#*@} - else - FTPUSER=ftp - FTPPWD=ftp - fi - # the "pass" command does not work on some - # ftp clients (read ftp.exe) but if it works, - # passive mode is better! - (\ - echo "user $FTPUSER $FTPPWD" ;\ - echo "pass" ;\ - echo "bin" ;\ - echo "get $FTPPATH $tmpfile" ;\ - ) | ftp -in $FTPSERVER - fi - if test "x$VALID_TOOL" != xyes; then - as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 - fi - - mv $tmpfile $installdir/$filename - if test ! -s $installdir/$filename; then - as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 - fi - case "$extension" in - zip) echo "Unzipping $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) - ;; - tar.gz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - tgz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 - ;; - esac - fi - if test -f $installdir/$filename.unpacked; then - depdir=$installdir - fi - - fi - # Source the builddeps file again, because in the previous command, the depdir - # was updated to point at the current build dependency install directory. - . $builddepsfile - # Now extract variables from the builddeps.conf files. - theroot=${builddep_freetype2_ROOT} - thecflags=${builddep_freetype2_CFLAGS} - thelibs=${builddep_freetype2_LIBS} - if test "x$depdir" = x; then - as_fn_error $? "Could not download build dependency freetype2" "$LINENO" 5 - fi - FREETYPE2=$depdir - if test "x$theroot" != x; then - FREETYPE2="$theroot" - fi - if test "x$thecflags" != x; then - FREETYPE2_CFLAGS="$thecflags" - fi - if test "x$thelibs" != x; then - FREETYPE2_LIBS="$thelibs" - fi - FREETYPE2_FOUND=yes - else FREETYPE2_FOUND=no - - fi - else FREETYPE2_FOUND=no - - fi - - USING_SYSTEM_FT_LIB=true - fi - if test "x$FREETYPE2_FOUND" = xno; then - -pkg_failed=no -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FREETYPE2" >&5 -$as_echo_n "checking for FREETYPE2... " >&6; } - -if test -n "$FREETYPE2_CFLAGS"; then - pkg_cv_FREETYPE2_CFLAGS="$FREETYPE2_CFLAGS" - elif test -n "$PKG_CONFIG"; then - if test -n "$PKG_CONFIG" && \ - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5 - ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then - pkg_cv_FREETYPE2_CFLAGS=`$PKG_CONFIG --cflags "freetype2" 2>/dev/null` -else - pkg_failed=yes -fi - else - pkg_failed=untried -fi -if test -n "$FREETYPE2_LIBS"; then - pkg_cv_FREETYPE2_LIBS="$FREETYPE2_LIBS" - elif test -n "$PKG_CONFIG"; then - if test -n "$PKG_CONFIG" && \ - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5 - ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then - pkg_cv_FREETYPE2_LIBS=`$PKG_CONFIG --libs "freetype2" 2>/dev/null` -else - pkg_failed=yes -fi - else - pkg_failed=untried -fi - - - -if test $pkg_failed = yes; then - -if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then - _pkg_short_errors_supported=yes -else - _pkg_short_errors_supported=no -fi - if test $_pkg_short_errors_supported = yes; then - FREETYPE2_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "freetype2" 2>&1` - else - FREETYPE2_PKG_ERRORS=`$PKG_CONFIG --print-errors "freetype2" 2>&1` - fi - # Put the nasty error message in config.log where it belongs - echo "$FREETYPE2_PKG_ERRORS" >&5 - - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - FREETYPE2_FOUND=no -elif test $pkg_failed = untried; then - FREETYPE2_FOUND=no -else - FREETYPE2_CFLAGS=$pkg_cv_FREETYPE2_CFLAGS - FREETYPE2_LIBS=$pkg_cv_FREETYPE2_LIBS - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - FREETYPE2_FOUND=yes -fi - USING_SYSTEM_FT_LIB=true - fi - if test "x$FREETYPE2_FOUND" = xno; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype in some standard locations" >&5 -$as_echo_n "checking for freetype in some standard locations... " >&6; } - - if test -s /usr/X11/include/ft2build.h && test -d /usr/X11/include/freetype2/freetype; then - DEFAULT_FREETYPE_CFLAGS="-I/usr/X11/include/freetype2 -I/usr/X11/include" - DEFAULT_FREETYPE_LIBS="-L/usr/X11/lib -lfreetype" - fi - if test -s /usr/include/ft2build.h && test -d /usr/include/freetype2/freetype; then - DEFAULT_FREETYPE_CFLAGS="-I/usr/include/freetype2" - DEFAULT_FREETYPE_LIBS="-lfreetype" - fi - - PREV_CXXCFLAGS="$CXXFLAGS" - PREV_LDFLAGS="$LDFLAGS" - CXXFLAGS="$CXXFLAGS $DEFAULT_FREETYPE_CFLAGS" - LDFLAGS="$LDFLAGS $DEFAULT_FREETYPE_LIBS" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - #include FT_FREETYPE_H - int main() { return 0; } - -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - - # Yes, the default cflags and libs did the trick. - FREETYPE2_FOUND=yes - FREETYPE2_CFLAGS="$DEFAULT_FREETYPE_CFLAGS" - FREETYPE2_LIBS="$DEFAULT_FREETYPE_LIBS" - -else - - FREETYPE2_FOUND=no - -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext - CXXCFLAGS="$PREV_CXXFLAGS" - LDFLAGS="$PREV_LDFLAGS" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE2_FOUND" >&5 -$as_echo "$FREETYPE2_FOUND" >&6; } - USING_SYSTEM_FT_LIB=true - fi - if test "x$FREETYPE2_FOUND" = xno; then - help_on_build_dependency freetype2 - as_fn_error $? "Could not find freetype2! $HELP_MSG " "$LINENO" 5 - fi -fi - - - - - - -############################################################################### -# -# Check for alsa headers and libraries. Used on Linux/GNU systems. -# - -# Check whether --with-alsa was given. -if test "${with_alsa+set}" = set; then : - withval=$with_alsa; -fi - - -# Check whether --with-alsa-include was given. -if test "${with_alsa_include+set}" = set; then : - withval=$with_alsa_include; -fi - - -# Check whether --with-alsa-lib was given. -if test "${with_alsa_lib+set}" = set; then : - withval=$with_alsa_lib; -fi - - -if test "x$ALSA_NOT_NEEDED" = xyes; then - if test "x${with_alsa}" != x || test "x${with_alsa_include}" != x || test "x${with_alsa_lib}" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: alsa not used, so --with-alsa is ignored" >&5 -$as_echo "$as_me: WARNING: alsa not used, so --with-alsa is ignored" >&2;} - fi - ALSA_CFLAGS= - ALSA_LIBS= -else - ALSA_FOUND=no - - if test "x${with_alsa}" = xno || test "x${with_alsa_include}" = xno || test "x${with_alsa_lib}" = xno; then - as_fn_error $? "It is not possible to disable the use of alsa. Remove the --without-alsa option." "$LINENO" 5 - fi - - if test "x${with_alsa}" != x; then - ALSA_LIBS="-L${with_alsa}/lib -lalsa" - ALSA_CFLAGS="-I${with_alsa}/include" - ALSA_FOUND=yes - fi - if test "x${with_alsa_include}" != x; then - ALSA_CFLAGS="-I${with_alsa_include}" - ALSA_FOUND=yes - fi - if test "x${with_alsa_lib}" != x; then - ALSA_LIBS="-L${with_alsa_lib} -lalsa" - ALSA_FOUND=yes - fi - if test "x$ALSA_FOUND" = xno; then - - - if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then - # Source the builddeps file again, to make sure it uses the latest variables! - . $builddepsfile - # Look for a host and build machine specific resource! - eval resource=\${builddep_alsa_BUILD_${rewritten_build_var}_HOST_${rewritten_host_var}} - if test "x$resource" = x; then - # Ok, lets instead look for a host specific resource - eval resource=\${builddep_alsa_HOST_${rewritten_host_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a build specific resource - eval resource=\${builddep_alsa_BUILD_${rewritten_build_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a generic resource - # (The alsa comes from M4 and not the shell, thus no need for eval here.) - resource=${builddep_alsa} - fi - if test "x$resource" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for alsa" >&5 -$as_echo "$as_me: Using builddeps $resource for alsa" >&6;} - # If the resource in the builddeps.conf file is an existing directory, - # for example /java/linux/cups - if test -d ${resource}; then - depdir=${resource} - else - -# alsa is for example mymodule -# $resource is for example libs/general/libmymod_1_2_3.zip -# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps -# $with_builddeps_dir is for example /localhome/builddeps -# depdir is the name of the variable into which we store the depdir, eg MYMOD -# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and -# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 - filename=`basename $resource` - filebase=`echo $filename | sed 's/\.[^\.]*$//'` - filebase=${filename%%.*} - extension=${filename#*.} - installdir=$with_builddeps_dir/$filebase - if test ! -f $installdir/$filename.unpacked; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&5 -$as_echo "$as_me: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&6;} - if test ! -d $installdir; then - mkdir -p $installdir - fi - if test ! -d $installdir; then - as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 - fi - tmpfile=`mktemp $installdir/alsa.XXXXXXXXX` - touch $tmpfile - if test ! -f $tmpfile; then - as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 - fi - - # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip - # $tmpfile is the local file name for the downloaded file. - VALID_TOOL=no - if test "x$BDEPS_FTP" = xwget; then - VALID_TOOL=yes - wget -O $tmpfile $with_builddeps_server/$resource - fi - if test "x$BDEPS_FTP" = xlftp; then - VALID_TOOL=yes - lftp -c "get $with_builddeps_server/$resource -o $tmpfile" - fi - if test "x$BDEPS_FTP" = xftp; then - VALID_TOOL=yes - FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` - FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` - FTPUSERPWD=${FTPSERVER%%@*} - if test "x$FTPSERVER" != "x$FTPUSERPWD"; then - FTPUSER=${userpwd%%:*} - FTPPWD=${userpwd#*@} - FTPSERVER=${FTPSERVER#*@} - else - FTPUSER=ftp - FTPPWD=ftp - fi - # the "pass" command does not work on some - # ftp clients (read ftp.exe) but if it works, - # passive mode is better! - (\ - echo "user $FTPUSER $FTPPWD" ;\ - echo "pass" ;\ - echo "bin" ;\ - echo "get $FTPPATH $tmpfile" ;\ - ) | ftp -in $FTPSERVER - fi - if test "x$VALID_TOOL" != xyes; then - as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 - fi - - mv $tmpfile $installdir/$filename - if test ! -s $installdir/$filename; then - as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 - fi - case "$extension" in - zip) echo "Unzipping $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) - ;; - tar.gz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - tgz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 - ;; - esac - fi - if test -f $installdir/$filename.unpacked; then - depdir=$installdir - fi - - fi - # Source the builddeps file again, because in the previous command, the depdir - # was updated to point at the current build dependency install directory. - . $builddepsfile - # Now extract variables from the builddeps.conf files. - theroot=${builddep_alsa_ROOT} - thecflags=${builddep_alsa_CFLAGS} - thelibs=${builddep_alsa_LIBS} - if test "x$depdir" = x; then - as_fn_error $? "Could not download build dependency alsa" "$LINENO" 5 - fi - ALSA=$depdir - if test "x$theroot" != x; then - ALSA="$theroot" - fi - if test "x$thecflags" != x; then - ALSA_CFLAGS="$thecflags" - fi - if test "x$thelibs" != x; then - ALSA_LIBS="$thelibs" - fi - ALSA_FOUND=yes - else ALSA_FOUND=no - - fi - else ALSA_FOUND=no - - fi - - fi - if test "x$ALSA_FOUND" = xno; then - -pkg_failed=no -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ALSA" >&5 -$as_echo_n "checking for ALSA... " >&6; } - -if test -n "$ALSA_CFLAGS"; then - pkg_cv_ALSA_CFLAGS="$ALSA_CFLAGS" - elif test -n "$PKG_CONFIG"; then - if test -n "$PKG_CONFIG" && \ - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5 - ($PKG_CONFIG --exists --print-errors "alsa") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then - pkg_cv_ALSA_CFLAGS=`$PKG_CONFIG --cflags "alsa" 2>/dev/null` -else - pkg_failed=yes -fi - else - pkg_failed=untried -fi -if test -n "$ALSA_LIBS"; then - pkg_cv_ALSA_LIBS="$ALSA_LIBS" - elif test -n "$PKG_CONFIG"; then - if test -n "$PKG_CONFIG" && \ - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5 - ($PKG_CONFIG --exists --print-errors "alsa") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then - pkg_cv_ALSA_LIBS=`$PKG_CONFIG --libs "alsa" 2>/dev/null` -else - pkg_failed=yes -fi - else - pkg_failed=untried -fi - - - -if test $pkg_failed = yes; then - -if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then - _pkg_short_errors_supported=yes -else - _pkg_short_errors_supported=no -fi - if test $_pkg_short_errors_supported = yes; then - ALSA_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "alsa" 2>&1` - else - ALSA_PKG_ERRORS=`$PKG_CONFIG --print-errors "alsa" 2>&1` - fi - # Put the nasty error message in config.log where it belongs - echo "$ALSA_PKG_ERRORS" >&5 - - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - ALSA_FOUND=no -elif test $pkg_failed = untried; then - ALSA_FOUND=no -else - ALSA_CFLAGS=$pkg_cv_ALSA_CFLAGS - ALSA_LIBS=$pkg_cv_ALSA_LIBS - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - ALSA_FOUND=yes -fi - fi - if test "x$ALSA_FOUND" = xno; then - for ac_header in alsa/asoundlib.h -do : - ac_fn_cxx_check_header_mongrel "$LINENO" "alsa/asoundlib.h" "ac_cv_header_alsa_asoundlib_h" "$ac_includes_default" -if test "x$ac_cv_header_alsa_asoundlib_h" = x""yes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_ALSA_ASOUNDLIB_H 1 -_ACEOF - ALSA_FOUND=yes - ALSA_CFLAGS=-Iignoreme - ALSA_LIBS=-lasound - DEFAULT_ALSA=yes -else - ALSA_FOUND=no -fi - -done - - fi - if test "x$ALSA_FOUND" = xno; then - help_on_build_dependency alsa - as_fn_error $? "Could not find alsa! $HELP_MSG " "$LINENO" 5 - fi -fi - - - - -############################################################################### -# -# Check for pulse audio headers and libraries. -# -PULSE_FOUND=no - -# Check whether --with-pulse was given. -if test "${with_pulse+set}" = set; then : - withval=$with_pulse; -fi - - -# Check whether --with-pulse-include was given. -if test "${with_pulse_include+set}" = set; then : - withval=$with_pulse_include; -fi - - -# Check whether --with-pulse-lib was given. -if test "${with_pulse_lib+set}" = set; then : - withval=$with_pulse_lib; -fi - - -if test "x${with_pulse}" != x; then - PULSE_LIBS="-L${with_pulse}/lib -lfreetype" - PULSE_CFLAGS="-I${with_pulse}/include" - PULSE_FOUND=yes -fi -if test "x${with_pulse_include}" != x; then - PULSE_CFLAGS="-I${with_pulse_include}" - PULSE_FOUND=yes -fi -if test "x${with_pulse_lib}" != x; then - PULSE_LIBS="-L${with_pulse_lib} -lpulse" - PULSE_FOUND=yes -fi -if test "x$PULSE_FOUND" = xno; then - - - if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then - # Source the builddeps file again, to make sure it uses the latest variables! - . $builddepsfile - # Look for a host and build machine specific resource! - eval resource=\${builddep_pulse_BUILD_${rewritten_build_var}_HOST_${rewritten_host_var}} - if test "x$resource" = x; then - # Ok, lets instead look for a host specific resource - eval resource=\${builddep_pulse_HOST_${rewritten_host_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a build specific resource - eval resource=\${builddep_pulse_BUILD_${rewritten_build_var}} - fi - if test "x$resource" = x; then - # Ok, lets instead look for a generic resource - # (The pulse comes from M4 and not the shell, thus no need for eval here.) - resource=${builddep_pulse} - fi - if test "x$resource" != x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for pulse" >&5 -$as_echo "$as_me: Using builddeps $resource for pulse" >&6;} - # If the resource in the builddeps.conf file is an existing directory, - # for example /java/linux/cups - if test -d ${resource}; then - depdir=${resource} - else - -# pulse is for example mymodule -# $resource is for example libs/general/libmymod_1_2_3.zip -# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps -# $with_builddeps_dir is for example /localhome/builddeps -# depdir is the name of the variable into which we store the depdir, eg MYMOD -# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and -# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 - filename=`basename $resource` - filebase=`echo $filename | sed 's/\.[^\.]*$//'` - filebase=${filename%%.*} - extension=${filename#*.} - installdir=$with_builddeps_dir/$filebase - if test ! -f $installdir/$filename.unpacked; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency pulse from $with_builddeps_server/$resource and installing into $installdir" >&5 -$as_echo "$as_me: Downloading build dependency pulse from $with_builddeps_server/$resource and installing into $installdir" >&6;} - if test ! -d $installdir; then - mkdir -p $installdir - fi - if test ! -d $installdir; then - as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 - fi - tmpfile=`mktemp $installdir/pulse.XXXXXXXXX` - touch $tmpfile - if test ! -f $tmpfile; then - as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 - fi - - # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip - # $tmpfile is the local file name for the downloaded file. - VALID_TOOL=no - if test "x$BDEPS_FTP" = xwget; then - VALID_TOOL=yes - wget -O $tmpfile $with_builddeps_server/$resource - fi - if test "x$BDEPS_FTP" = xlftp; then - VALID_TOOL=yes - lftp -c "get $with_builddeps_server/$resource -o $tmpfile" - fi - if test "x$BDEPS_FTP" = xftp; then - VALID_TOOL=yes - FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` - FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` - FTPUSERPWD=${FTPSERVER%%@*} - if test "x$FTPSERVER" != "x$FTPUSERPWD"; then - FTPUSER=${userpwd%%:*} - FTPPWD=${userpwd#*@} - FTPSERVER=${FTPSERVER#*@} - else - FTPUSER=ftp - FTPPWD=ftp - fi - # the "pass" command does not work on some - # ftp clients (read ftp.exe) but if it works, - # passive mode is better! - (\ - echo "user $FTPUSER $FTPPWD" ;\ - echo "pass" ;\ - echo "bin" ;\ - echo "get $FTPPATH $tmpfile" ;\ - ) | ftp -in $FTPSERVER - fi - if test "x$VALID_TOOL" != xyes; then - as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 - fi - - mv $tmpfile $installdir/$filename - if test ! -s $installdir/$filename; then - as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 - fi - case "$extension" in - zip) echo "Unzipping $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) - ;; - tar.gz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - tgz) echo "Untaring $installdir/$filename..." - (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) - ;; - *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 - ;; - esac - fi - if test -f $installdir/$filename.unpacked; then - depdir=$installdir - fi - - fi - # Source the builddeps file again, because in the previous command, the depdir - # was updated to point at the current build dependency install directory. - . $builddepsfile - # Now extract variables from the builddeps.conf files. - theroot=${builddep_pulse_ROOT} - thecflags=${builddep_pulse_CFLAGS} - thelibs=${builddep_pulse_LIBS} - if test "x$depdir" = x; then - as_fn_error $? "Could not download build dependency pulse" "$LINENO" 5 - fi - PULSE=$depdir - if test "x$theroot" != x; then - PULSE="$theroot" - fi - if test "x$thecflags" != x; then - PULSE_CFLAGS="$thecflags" - fi - if test "x$thelibs" != x; then - PULSE_LIBS="$thelibs" - fi - PULSE_FOUND=yes - else PULSE_FOUND=no - - fi - else PULSE_FOUND=no - - fi - -fi -if test "x$PULSE_FOUND" = xno; then - -pkg_failed=no -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIBPULSE" >&5 -$as_echo_n "checking for LIBPULSE... " >&6; } - -if test -n "$LIBPULSE_CFLAGS"; then - pkg_cv_LIBPULSE_CFLAGS="$LIBPULSE_CFLAGS" - elif test -n "$PKG_CONFIG"; then - if test -n "$PKG_CONFIG" && \ - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpulse >= 0.9.11\""; } >&5 - ($PKG_CONFIG --exists --print-errors "libpulse >= 0.9.11") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then - pkg_cv_LIBPULSE_CFLAGS=`$PKG_CONFIG --cflags "libpulse >= 0.9.11" 2>/dev/null` -else - pkg_failed=yes -fi - else - pkg_failed=untried -fi -if test -n "$LIBPULSE_LIBS"; then - pkg_cv_LIBPULSE_LIBS="$LIBPULSE_LIBS" - elif test -n "$PKG_CONFIG"; then - if test -n "$PKG_CONFIG" && \ - { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpulse >= 0.9.11\""; } >&5 - ($PKG_CONFIG --exists --print-errors "libpulse >= 0.9.11") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then - pkg_cv_LIBPULSE_LIBS=`$PKG_CONFIG --libs "libpulse >= 0.9.11" 2>/dev/null` -else - pkg_failed=yes -fi - else - pkg_failed=untried -fi - - - -if test $pkg_failed = yes; then - -if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then - _pkg_short_errors_supported=yes -else - _pkg_short_errors_supported=no -fi - if test $_pkg_short_errors_supported = yes; then - LIBPULSE_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libpulse >= 0.9.11" 2>&1` - else - LIBPULSE_PKG_ERRORS=`$PKG_CONFIG --print-errors "libpulse >= 0.9.11" 2>&1` - fi - # Put the nasty error message in config.log where it belongs - echo "$LIBPULSE_PKG_ERRORS" >&5 - - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } - PULSE_FOUND=no -elif test $pkg_failed = untried; then - PULSE_FOUND=no -else - LIBPULSE_CFLAGS=$pkg_cv_LIBPULSE_CFLAGS - LIBPULSE_LIBS=$pkg_cv_LIBPULSE_LIBS - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } - PULSE_FOUND=yes -fi -fi -if test "x$PULSE_FOUND" = xno; then - for ac_header in pulse/pulseaudio.h -do : - ac_fn_cxx_check_header_mongrel "$LINENO" "pulse/pulseaudio.h" "ac_cv_header_pulse_pulseaudio_h" "$ac_includes_default" -if test "x$ac_cv_header_pulse_pulseaudio_h" = x""yes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_PULSE_PULSEAUDIO_H 1 -_ACEOF - PULSE_FOUND=yes - PULSE_CFLAGS=-Iignoreme - PULSE_LIBS= - DEFAULT_PULSE=yes -else - PULSE_FOUND=no -fi - -done - -fi - -if test "x$PULSE_FOUND" = xno && test "x$PULSE_NOT_NEEDED" != xyes; then - help_on_build_dependency pulse - as_fn_error $? "Could not find pulse audio libraries. $HELP_MSG " "$LINENO" 5 -fi - - - - -############################################################################### -# -# Check for the jpeg library -# - -USE_EXTERNAL_LIBJPEG=true -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -ljpeg" >&5 -$as_echo_n "checking for main in -ljpeg... " >&6; } -if test "${ac_cv_lib_jpeg_main+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-ljpeg $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - - -int -main () -{ -return main (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_jpeg_main=yes -else - ac_cv_lib_jpeg_main=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jpeg_main" >&5 -$as_echo "$ac_cv_lib_jpeg_main" >&6; } -if test "x$ac_cv_lib_jpeg_main" = x""yes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_LIBJPEG 1 -_ACEOF - - LIBS="-ljpeg $LIBS" - -else - USE_EXTERNAL_LIBJPEG=false - { $as_echo "$as_me:${as_lineno-$LINENO}: Will use jpeg decoder bundled with the OpenJDK source" >&5 -$as_echo "$as_me: Will use jpeg decoder bundled with the OpenJDK source" >&6;} - -fi - - - -############################################################################### -# -# Check for the gif library -# - -USE_EXTERNAL_LIBJPEG=true -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lgif" >&5 -$as_echo_n "checking for main in -lgif... " >&6; } -if test "${ac_cv_lib_gif_main+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lgif $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - - -int -main () -{ -return main (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_gif_main=yes -else - ac_cv_lib_gif_main=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gif_main" >&5 -$as_echo "$ac_cv_lib_gif_main" >&6; } -if test "x$ac_cv_lib_gif_main" = x""yes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_LIBGIF 1 -_ACEOF - - LIBS="-lgif $LIBS" - -else - USE_EXTERNAL_LIBGIF=false - { $as_echo "$as_me:${as_lineno-$LINENO}: Will use gif decoder bundled with the OpenJDK source" >&5 -$as_echo "$as_me: Will use gif decoder bundled with the OpenJDK source" >&6;} - -fi - - - -############################################################################### -# -# Check for the zlib library -# - -USE_EXTERNAL_LIBZ=true -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lz" >&5 -$as_echo_n "checking for main in -lz... " >&6; } -if test "${ac_cv_lib_z_main+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lz $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - - -int -main () -{ -return main (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_z_main=yes -else - ac_cv_lib_z_main=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_main" >&5 -$as_echo "$ac_cv_lib_z_main" >&6; } -if test "x$ac_cv_lib_z_main" = x""yes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_LIBZ 1 -_ACEOF - - LIBS="-lz $LIBS" - -else - USE_EXTERNAL_LIBZ=false - { $as_echo "$as_me:${as_lineno-$LINENO}: Will use zlib bundled with the OpenJDK source" >&5 -$as_echo "$as_me: Will use zlib bundled with the OpenJDK source" >&6;} - -fi - - - -############################################################################### -# -# Check if altzone exists in time.h -# - -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -int -main () -{ -return (int)altzone; - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - has_altzone=yes -else - has_altzone=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -if test "x$has_altzone" = xyes; then - -$as_echo "#define HAVE_ALTZONE 1" >>confdefs.h - -fi - -############################################################################### -# -# Check the maths library -# - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5 -$as_echo_n "checking for cos in -lm... " >&6; } -if test "${ac_cv_lib_m_cos+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lm $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char cos (); -int -main () -{ -return cos (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_m_cos=yes -else - ac_cv_lib_m_cos=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5 -$as_echo "$ac_cv_lib_m_cos" >&6; } -if test "x$ac_cv_lib_m_cos" = x""yes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_LIBM 1 -_ACEOF - - LIBS="-lm $LIBS" - -else - - { $as_echo "$as_me:${as_lineno-$LINENO}: Maths library was not found" >&5 -$as_echo "$as_me: Maths library was not found" >&6;} - -fi - - - -############################################################################### -# -# Check for libdl.so - -save_LIBS="$LIBS" -LIBS="" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 -$as_echo_n "checking for dlopen in -ldl... " >&6; } -if test "${ac_cv_lib_dl_dlopen+set}" = set; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-ldl $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char dlopen (); -int -main () -{ -return dlopen (); - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - ac_cv_lib_dl_dlopen=yes -else - ac_cv_lib_dl_dlopen=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 -$as_echo "$ac_cv_lib_dl_dlopen" >&6; } -if test "x$ac_cv_lib_dl_dlopen" = x""yes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_LIBDL 1 -_ACEOF - - LIBS="-ldl $LIBS" - -fi - -LIBDL="$LIBS" - -LIBS="$save_LIBS" - -############################################################################### -# -# Should we run the painfully slow javadoc tool? -# -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build documentation" >&5 -$as_echo_n "checking whether to build documentation... " >&6; } -# Check whether --enable-docs was given. -if test "${enable_docs+set}" = set; then : - enableval=$enable_docs; ENABLE_DOCS="${enableval}" -else - ENABLE_DOCS='no' -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_DOCS" >&5 -$as_echo "$ENABLE_DOCS" >&6; } - -GENERATE_DOCS=false -if test "x$ENABLE_DOCS" = xyes; then - GENERATE_DOCS=true -fi - - -############################################################################### -# -# Should we compile nimbus swing L&F? We can probably remove this option -# since nimbus is officially part of javax now. -# -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build nimbus L&F" >&5 -$as_echo_n "checking whether to build nimbus L&F... " >&6; } -# Check whether --enable-nimbus was given. -if test "${enable_nimbus+set}" = set; then : - enableval=$enable_nimbus; ENABLE_NIMBUS="${enableval}" -else - ENABLE_NIMBUS='yes' -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_NIMBUS" >&5 -$as_echo "$ENABLE_NIMBUS" >&6; } -DISABLE_NIMBUS= -if test "x$ENABLE_NIMBUS" = xno; then - DISABLE_NIMBUS=true -fi - - -############################################################################### -# -# Setup the opt flags for different compilers -# and different operating systems. -# -C_FLAG_DEPS="-MMD -MF" -CXX_FLAG_DEPS="-MMD -MF" - -case $COMPILER_TYPE in - CC ) - D_FLAG="-g" - case $COMPILER_NAME in - gcc ) - case $PLATFORM in - macosx ) - # On MacOSX we optimize for size, something - # we should do for all platforms? - C_O_FLAG_HI="-Os" - C_O_FLAG_NORM="-Os" - C_O_FLAG_NONE="" - ;; - *) - C_O_FLAG_HI="-O3" - C_O_FLAG_NORM="-O2" - C_O_FLAG_NONE="-O0" - ;; - esac - CXX_O_FLAG_HI="$C_O_FLAG_HI" - CXX_O_FLAG_NORM="$C_O_FLAG_NORM" - CXX_O_FLAG_NONE="$C_O_FLAG_NONE" - ;; - ossc ) - # - # Forte has different names for this with their C++ compiler... - # - CXX_FLAG_DEPS="-xMMD -xMF" - -# Extra options used with HIGHEST -# -# WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be -# done with care, there are some assumptions below that need to -# be understood about the use of pointers, and IEEE behavior. -# -# Use non-standard floating point mode (not IEEE 754) -CC_HIGHEST="$CC_HIGHEST -fns" -# Do some simplification of floating point arithmetic (not IEEE 754) -CC_HIGHEST="$CC_HIGHEST -fsimple" -# Use single precision floating point with 'float' -CC_HIGHEST="$CC_HIGHEST -fsingle" -# Assume memory references via basic pointer types do not alias -# (Source with excessing pointer casting and data access with mixed -# pointer types are not recommended) -CC_HIGHEST="$CC_HIGHEST -xalias_level=basic" -# Use intrinsic or inline versions for math/std functions -# (If you expect perfect errno behavior, do not use this) -CC_HIGHEST="$CC_HIGHEST -xbuiltin=%all" -# Loop data dependency optimizations (need -xO3 or higher) -CC_HIGHEST="$CC_HIGHEST -xdepend" -# Pointer parameters to functions do not overlap -# (Similar to -xalias_level=basic usage, but less obvious sometimes. -# If you pass in multiple pointers to the same data, do not use this) -CC_HIGHEST="$CC_HIGHEST -xrestrict" -# Inline some library routines -# (If you expect perfect errno behavior, do not use this) -CC_HIGHEST="$CC_HIGHEST -xlibmil" -# Use optimized math routines -# (If you expect perfect errno behavior, do not use this) -# Can cause undefined external on Solaris 8 X86 on __sincos, removing for now -#CC_HIGHEST="$CC_HIGHEST -xlibmopt" - - case $LEGACY_HOST_CPU1 in - i586) - C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xchip=pentium" - C_O_FLAG_HI="-xO4 -Wu,-O4~yz" - C_O_FLAG_NORM="-xO2 -Wu,-O2~yz" - C_O_FLAG_NONE="" - CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xchip=pentium" - CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz" - CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz" - CXX_O_FLAG_NONE="" - ;; - sparc) - C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" - C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0" - C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0" - C_O_FLAG_NONE="" - CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" - CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" - CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" - CXX_O_FLAG_NONE="" - ;; - esac - esac - ;; - CL ) - D_FLAG= - C_O_FLAG_HI="-O2" - C_O_FLAG_NORM="-O1" - C_O_FLAG_NONE="-Od" - CXX_O_FLAG_HI="$C_O_FLAG_HI" - CXX_O_FLAG_NORM="$C_O_FLAG_NORM" - CXX_O_FLAG_NONE="$C_O_FLAG_NONE" - ;; -esac - -if test -z "$C_O_FLAG_HIGHEST"; then - C_O_FLAG_HIGHEST="$C_O_FLAG_HI" -fi - -if test -z "$CXX_O_FLAG_HIGHEST"; then - CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HI" -fi - - - - - - - - - - - - -############################################################################### -# -# Setup legacy vars/targets and new vars to deal with different debug levels. -# -case $DEBUG_LEVEL in - release ) - HOTSPOT_DEBUG_LEVEL="product" - HOTSPOT_EXPORT="product" - ;; - fastdebug ) - HOTSPOT_DEBUG_LEVEL="fastdebug" - HOTSPOT_EXPORT="fastdebug" - CFLAGS="$CFLAGS $D_FLAG" - JAVAC_FLAGS="$JAVAC_FLAGS -g" - ;; - slowdebug ) - HOTSPOT_DEBUG_LEVEL="jvmg" - HOTSPOT_EXPORT="debug" - CFLAGS="$CFLAGS $D_FLAG" - C_O_FLAG_HI="$C_O_FLAG_NONE" - C_O_FLAG_NORM="$C_O_FLAG_NONE" - CXX_O_FLAG_HI="$CXX_O_FLAG_NONE" - CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE" - JAVAC_FLAGS="$JAVAC_FLAGS -g" - ;; -esac - -############################################################################### -# -# Generate the legacy makefile targets for hotspot. -# The hotspot api for selecting the build artifacts, really, needs to be improved. -# -HOTSPOT_TARGET="" - -if test "x$JVM_VARIANT_SERVER" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} " -fi - -if test "x$JVM_VARIANT_CLIENT" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 " -fi - -if test "x$JVM_VARIANT_KERNEL" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel " -fi - -if test "x$JVM_VARIANT_ZERO" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero " -fi - -if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark " -fi - -HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT" - -############################################################################### -# -# Setup all directories for the subrepoes and the arguments to the sub makes. -# -LANGTOOLS_OUTPUTDIR="$OUTPUT_ROOT/langtools" -LANGTOOLS_DIST="$OUTPUT_ROOT/langtools/dist" -LANGTOOLS_MAKE_ARGS="" - - - - -CORBA_OUTPUTDIR="$OUTPUT_ROOT/corba" -CORBA_DIST="$OUTPUT_ROOT/corba/dist" -CORBA_MAKE_ARGS="" - - - - -JAXP_OUTPUTDIR="$OUTPUT_ROOT/jaxp" -JAXP_DIST="$OUTPUT_ROOT/jaxp/dist" -JAXP_MAKE_ARGS="" - - - - -JAXWS_OUTPUTDIR="$OUTPUT_ROOT/jaxws" -JAXWS_DIST="$OUTPUT_ROOT/jaxws/dist" -JAXWS_MAKE_ARGS="" - - - - -HOTSPOT_OUTPUTDIR="$OUTPUT_ROOT/hotspot" -HOTSPOT_DIST="$OUTPUT_ROOT/hotspot/dist" -HOTSPOT_MAKE_ARGS="ALT_OUTPUTDIR=$HOTSPOT_OUTPUTDIR ALT_EXPORT_PATH=$HOTSPOT_DIST $HOTSPOT_TARGET" - - - - -JDK_OUTPUTDIR="$OUTPUT_ROOT/jdk" -JDK_MAKE_ARGS="ALT_OUTPUTDIR=\"$OUTPUT_ROOT/jdk\"" - - - -IMAGES_OUTPUTDIR=$OUTPUT_ROOT/images -IMAGES_MAKE_ARGS="ALT_OUTPUTDIR=$OUTPUT_ROOT/jdk \ - SHARE_SRC=$JDK_TOPDIR/src/share \ - PLATFORM_SRC=$JDK_TOPDIR/src/$LEGACY_HOST_OS_API \ - TEMPDIR=$IMAGES_OUTPUTDIR/tmp \ - ABS_TEMPDIR=$IMAGES_OUTPUTDIR/tmp " - - - -############################################################################### -# -# Now setup the CFLAGS and LDFLAGS for the JDK build. -# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build. -# -case $COMPILER_NAME in - gcc ) - CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \ - -pipe -fno-omit-frame-pointer \ - -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE" - CFLAGS_JDK="$CFLAGS_JDK -fno-strict-aliasing" - ;; - ossc ) - CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -norunpath -xnolib" - CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX" - ;; - cl ) - CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \ - -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \ - -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \ - -DWIN32 -DIAL" - case $LEGACY_HOST_CPU1 in - i?86 ) - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86" - ;; - amd64 ) - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64" - ;; - esac - ;; -esac - -CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64" - -# The package path is used only on macosx? -PACKAGE_PATH=/opt/local - - -# Sometimes we use a cpu dir (.../lib/amd64/server) -# Sometimes not (.../lib/server) -LIBARCHDIR="$LEGACY_HOST_CPU2/" -if test "x$ENDIAN" = xlittle; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN" -else - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN" -fi -if test "x$HOST_OS" = xlinux; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX" -fi -if test "x$HOST_OS" = xwindows; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS" -fi -if test "x$HOST_OS" = xsolaris; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS" -fi -if test "x$HOST_OS" = xmacosx; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE" - LIBARCHDIR="" -fi -if test "x$HOST_OS" = xbsd; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE" -fi -if test "x$DEBUG_LEVEL" = xrelease; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG" -else - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG" -fi - -CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$LEGACY_HOST_CPU1\"' -D$LEGACY_HOST_CPU1" -CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"$RELEASE\"'" - -CCXXFLAGS_JDK="$CCXXFLAGS_JDK \ - -I${JDK_OUTPUTDIR}/include \ - -I${JDK_OUTPUTDIR}/include/$PLATFORM \ - -I${JDK_TOPDIR}/src/share/javavm/export \ - -I${JDK_TOPDIR}/src/$LEGACY_HOST_OS_API/javavm/export \ - -I${JDK_TOPDIR}/src/share/native/common \ - -I${JDK_TOPDIR}/src/$LEGACY_HOST_OS_API/native/common" - -# The shared libraries are compiled using the picflag. -CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA" -CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG" - -# Executable flags -CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK" -CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK" - -# Now this is odd. The JDK native libraries have to link against libjvm.so -# On 32-bit machines there is normally two distinct libjvm.so:s, client and server. -# Which should we link to? Are we lucky enough that the binary api to the libjvm.so library -# is identical for client and server? Yes. Which is picked at runtime (client or server)? -# Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following -# libraries will link to whatever is in memory. Yuck. -# -# Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh. -if test "x$COMPILER_TYPE" = xCL; then - LDFLAGS_JDKLIB="$LDFLAGS -dll -libpath:${JDK_OUTPUTDIR}/lib -libpath:${JDK_OUTPUTDIR}/objs" - LDFLAGS_JDKLIB_SUFFIX="" - if test "$HOST_CPU_BITS" == "64"; then - LDFLAGS_STACK_SIZE=1048576 - else - LDFLAGS_STACK_SIZE=327680 - fi - LDFLAGS_JDKEXE="$LDFLAGS /STACK:$LDFLAGS_STACK_SIZE" -else - # If this is a --hash-style=gnu system, use --hash-style=both, why? - HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'` - if test -n "$HAS_GNU_HASH"; then - # And since we now know that the linker is gnu, then add -z defs, to forbid - # undefined symbols in object files. - LDFLAGS="$LDFLAGS -Xlinker --hash-style=both -Xlinker -z -Xlinker defs" - if test "x$DEBUG_LEVEL" == "xrelease"; then - # When building release libraries, tell the linker optimize them. - # Should this be supplied to the OSS linker as well? - LDFLAGS="$LDFLAGS -Xlinker -O1" - fi - fi - - LDFLAGS_JDKLIB="$LDFLAGS $SHARED_LIBRARY_FLAGS \ - -L${JDK_OUTPUTDIR}/objs \ - -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}server \ - -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}client \ - -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}" - LDFLAGS_JDKLIB_SUFFIX="-ljvm -ljava" - if test "x$COMPILER_NAME" = xossc; then - LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc" - fi - - # Only the jli library is explicitly linked when the launchers are built. - # The libjvm is then dynamically loaded/linked by the launcher. - if test "x$HOST_OS" != "xmacosx"; then - LDFLAGS_JDKEXE="$LDFLAGS -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}jli" - LDFLAGS_JDKEXE_SUFFIX="-ljli" - fi -fi - - - - - - - - - - - - - - -############################################################################### -# -# statically link libstdc++ before C++ ABI is stablized on Linux unless -# dynamic build is configured on command line. -# -# Check whether --enable-static-link-stdc++ was given. -if test "${enable_static_link_stdc__+set}" = set; then : - enableval=$enable_static_link_stdc__; -else - - enable_static_link_stdc__=yes - -fi - - -if test "x$HOST_OS" = xlinux; then - # Test if -lstdc++ works. - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if dynamic link of stdc++ is possible" >&5 -$as_echo_n "checking if dynamic link of stdc++ is possible... " >&6; } - ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - OLD_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -lstdc++" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ -return 0; - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - has_dynamic_libstdcxx=yes -else - has_dynamic_libstdcxx=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext - CXXFLAGS="$OLD_CXXFLAGS" - ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_dynamic_libstdcxx" >&5 -$as_echo "$has_dynamic_libstdcxx" >&6; } - - # Test if stdc++ can be linked statically. - { $as_echo "$as_me:${as_lineno-$LINENO}: checking if static link of stdc++ is possible" >&5 -$as_echo_n "checking if static link of stdc++ is possible... " >&6; } - STATIC_STDCXX_FLAGS="-Wl,-Bstatic -lstdc++ -lgcc -Wl,-Bdynamic" - ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - OLD_LIBS="$LIBS" - OLD_CXX="$CXX" - LIBS="$STATIC_STDCXX_FLAGS" - CXX="$CC" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ -return 0; - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_link "$LINENO"; then : - has_static_libstdcxx=yes -else - has_static_libstdcxx=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext - LIBS="$OLD_LIBS" - CXX="$OLD_CXX" - ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_static_libstdcxx" >&5 -$as_echo "$has_static_libstdcxx" >&6; } - - if test "x$has_static_libcxx" = xno && test "x$has_dynamic_libcxx" = xno; then - as_fn_error $? "I cannot link to stdc++! Neither dynamically nor statically." "$LINENO" 5 - fi - - if test "x$enable_static_link_stdc__" = xyes && test "x$has_static_libstdcxx" = xno; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Static linking of libstdc++ was not possible reverting to dynamic linking." >&5 -$as_echo "$as_me: Static linking of libstdc++ was not possible reverting to dynamic linking." >&6;} - enable_static_link_stdc__=no - fi - - if test "x$enable_static_link_stdc__" = xno && test "x$has_dynamic_libstdcxx" = xno; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Dynamic linking of libstdc++ was not possible reverting to static linking." >&5 -$as_echo "$as_me: Dynamic linking of libstdc++ was not possible reverting to static linking." >&6;} - enable_static_link_stdc__=yes - fi - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to link with libstdc++" >&5 -$as_echo_n "checking how to link with libstdc++... " >&6; } - if test "x$enable_static_link_stdc__" = xyes; then - LIBCXX="$LIBCXX $STATIC_STDCXX_FLAGS" - LDCXX="$CC" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: static" >&5 -$as_echo "static" >&6; } - else - LIBCXX="$LIBCXX -lstdc++" - LDCXX="$CXX" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: dynamic" >&5 -$as_echo "dynamic" >&6; } - fi -fi - -############################################################################### -# -# Could someone enlighten this configure script with a comment about libCrun? -# The LEGACY_HOST_CPU3 is the setting for ISA_DIR. -# -if test "x$HOST_OS" = xsolaris && test "x$LIBCXX" = x; then - LIBCXX="/usr/lib${LEGACY_HOST_CPU3}/libCrun.so.1" -fi - -# TODO better (platform agnostic) test -if test "x$HOST_OS" = xmacosx && test "x$LIBCXX" = x && test "x$GCC" = xyes; then - LIBCXX="-lstdc++" -fi - - - -############################################################################### - -OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`" -OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`" -OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`" -OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`" - - - - -############################################################################### -# -# Misc -# - -# The name of the Service Agent jar. -SALIB_NAME="${LIBRARY_PREFIX}saproc${SHARED_LIBRARY_SUFFIX}" -if test "x$HOST_OS" = "xwindows"; then - SALIB_NAME="${LIBRARY_PREFIX}sawindbg${SHARED_LIBRARY_SUFFIX}" -fi - - -# Control wether Hotspot runs Queens test after build. -# Check whether --enable-hotspot-test-in-build was given. -if test "${enable_hotspot_test_in_build+set}" = set; then : - enableval=$enable_hotspot_test_in_build; -else - enable_hotspot_test_in_build=no -fi - -if test "x$enable_hotspot_test_in_build" = "xyes"; then - TEST_IN_BUILD=true -else - TEST_IN_BUILD=false -fi - - -############################################################################### -# -# Choose cacerts source file -# - -# Check whether --with-cacerts-file was given. -if test "${with_cacerts_file+set}" = set; then : - withval=$with_cacerts_file; -fi - -if test "x$with_cacerts_file" != x; then - CACERTS_FILE=$with_cacerts_file -else - if test "x$OPENJDK" = "xtrue"; then - CACERTS_FILE=${SRC_ROOT}/jdk/src/share/lib/security/cacerts - else - CACERTS_FILE=${SRC_ROOT}/jdk/src/closed/share/lib/security/cacerts.internal - fi -fi - - -# Check if build directory is on local disk. -# return 0 if it is on local disk, non-0 if on remote disk or failure -function is_directory_on_local_disk { - # df -l lists only local disks; if the given directory is not found then - # a non-zero exit code is given - $DF -l $1 > /dev/null 2>&1 -} - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5 -$as_echo_n "checking if build directory is on local disk... " >&6; } -if is_directory_on_local_disk $OUTPUT_ROOT; then - OUTPUT_DIR_IS_LOCAL="yes" -else - OUTPUT_DIR_IS_LOCAL="no" -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_DIR_IS_LOCAL" >&5 -$as_echo "$OUTPUT_DIR_IS_LOCAL" >&6; } - -# We're messing a bit with internal autoconf variables to put the config.status in the -# output directory instead of the current directory. -CONFIG_STATUS=$OUTPUT_ROOT/config.status - -# Now create the actual output files, after this, the main work of configure is done -cat >confcache <<\_ACEOF -# This file is a shell script that caches the results of configure -# tests run on this system so they can be shared between configure -# scripts and configure runs, see configure's option --config-cache. -# It is not useful on other systems. If it contains results you don't -# want to keep, you may remove or edit it. -# -# config.status only pays attention to the cache file if you give it -# the --recheck option to rerun configure. -# -# `ac_cv_env_foo' variables (set or unset) will be overridden when -# loading this file, other *unset* `ac_cv_foo' will be assigned the -# following values. - -_ACEOF - -# The following way of writing the cache mishandles newlines in values, -# but we know of no workaround that is simple, portable, and efficient. -# So, we kill variables containing newlines. -# Ultrix sh set writes to stderr and can't be redirected directly, -# and sets the high bit in the cache file unless we assign to the vars. -( - for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do - eval ac_val=\$$ac_var - case $ac_val in #( - *${as_nl}*) - case $ac_var in #( - *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; - esac - case $ac_var in #( - _ | IFS | as_nl) ;; #( - BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( - *) { eval $ac_var=; unset $ac_var;} ;; - esac ;; - esac - done - - (set) 2>&1 | - case $as_nl`(ac_space=' '; set) 2>&1` in #( - *${as_nl}ac_space=\ *) - # `set' does not quote correctly, so add quotes: double-quote - # substitution turns \\\\ into \\, and sed turns \\ into \. - sed -n \ - "s/'/'\\\\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" - ;; #( - *) - # `set' quotes correctly as required by POSIX, so do not add quotes. - sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" - ;; - esac | - sort -) | - sed ' - /^ac_cv_env_/b end - t clear - :clear - s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ - t end - s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ - :end' >>confcache -if diff "$cache_file" confcache >/dev/null 2>&1; then :; else - if test -w "$cache_file"; then - test "x$cache_file" != "x/dev/null" && - { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 -$as_echo "$as_me: updating cache $cache_file" >&6;} - cat confcache >$cache_file - else - { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 -$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} - fi -fi -rm -f confcache - -test "x$prefix" = xNONE && prefix=$ac_default_prefix -# Let make expand exec_prefix. -test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' - -DEFS=-DHAVE_CONFIG_H - -ac_libobjs= -ac_ltlibobjs= -U= -for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue - # 1. Remove the extension, and $U if already installed. - ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' - ac_i=`$as_echo "$ac_i" | sed "$ac_script"` - # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR - # will be set to the directory where LIBOBJS objects are built. - as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" - as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' -done -LIBOBJS=$ac_libobjs - -LTLIBOBJS=$ac_ltlibobjs - - - -: ${CONFIG_STATUS=./config.status} -ac_write_fail=0 -ac_clean_files_save=$ac_clean_files -ac_clean_files="$ac_clean_files $CONFIG_STATUS" -{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 -$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} -as_write_fail=0 -cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 -#! $SHELL -# Generated by $as_me. -# Run this file to recreate the current configuration. -# Compiler output produced by configure, useful for debugging -# configure, is in config.log if it exists. - -debug=false -ac_cs_recheck=false -ac_cs_silent=false - -SHELL=\${CONFIG_SHELL-$SHELL} -export SHELL -_ASEOF -cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 -## -------------------- ## -## M4sh Initialization. ## -## -------------------- ## - -# Be more Bourne compatible -DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : - emulate sh - NULLCMD=: - # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in #( - *posix*) : - set -o posix ;; #( - *) : - ;; -esac -fi - - -as_nl=' -' -export as_nl -# Printing a long string crashes Solaris 7 /usr/bin/printf. -as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo -# Prefer a ksh shell builtin over an external printf program on Solaris, -# but without wasting forks for bash or zsh. -if test -z "$BASH_VERSION$ZSH_VERSION" \ - && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='print -r --' - as_echo_n='print -rn --' -elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='printf %s\n' - as_echo_n='printf %s' -else - if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then - as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' - as_echo_n='/usr/ucb/echo -n' - else - as_echo_body='eval expr "X$1" : "X\\(.*\\)"' - as_echo_n_body='eval - arg=$1; - case $arg in #( - *"$as_nl"*) - expr "X$arg" : "X\\(.*\\)$as_nl"; - arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; - esac; - expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" - ' - export as_echo_n_body - as_echo_n='sh -c $as_echo_n_body as_echo' - fi - export as_echo_body - as_echo='sh -c $as_echo_body as_echo' -fi - -# The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then - PATH_SEPARATOR=: - (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { - (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || - PATH_SEPARATOR=';' - } -fi - - -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -IFS=" "" $as_nl" - -# Find who we are. Look in the path if we contain no directory separator. -case $0 in #(( - *[\\/]* ) as_myself=$0 ;; - *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break - done -IFS=$as_save_IFS - - ;; -esac -# We did not find ourselves, most probably we were run as `sh COMMAND' -# in which case we are not to be found in the path. -if test "x$as_myself" = x; then - as_myself=$0 -fi -if test ! -f "$as_myself"; then - $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 - exit 1 -fi - -# Unset variables that we do not need and which cause bugs (e.g. in -# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" -# suppresses any "Segmentation fault" message there. '((' could -# trigger a bug in pdksh 5.2.14. -for as_var in BASH_ENV ENV MAIL MAILPATH -do eval test x\${$as_var+set} = xset \ - && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -LC_ALL=C -export LC_ALL -LANGUAGE=C -export LANGUAGE - -# CDPATH. -(unset CDPATH) >/dev/null 2>&1 && unset CDPATH - - -# as_fn_error STATUS ERROR [LINENO LOG_FD] -# ---------------------------------------- -# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are -# provided, also output the error to LOG_FD, referencing LINENO. Then exit the -# script with STATUS, using 1 if that was 0. -as_fn_error () -{ - as_status=$1; test $as_status -eq 0 && as_status=1 - if test "$4"; then - as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 - fi - $as_echo "$as_me: error: $2" >&2 - as_fn_exit $as_status -} # as_fn_error - - -# as_fn_set_status STATUS -# ----------------------- -# Set $? to STATUS, without forking. -as_fn_set_status () -{ - return $1 -} # as_fn_set_status - -# as_fn_exit STATUS -# ----------------- -# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. -as_fn_exit () -{ - set +e - as_fn_set_status $1 - exit $1 -} # as_fn_exit - -# as_fn_unset VAR -# --------------- -# Portably unset VAR. -as_fn_unset () -{ - { eval $1=; unset $1;} -} -as_unset=as_fn_unset -# as_fn_append VAR VALUE -# ---------------------- -# Append the text in VALUE to the end of the definition contained in VAR. Take -# advantage of any shell optimizations that allow amortized linear growth over -# repeated appends, instead of the typical quadratic growth present in naive -# implementations. -if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : - eval 'as_fn_append () - { - eval $1+=\$2 - }' -else - as_fn_append () - { - eval $1=\$$1\$2 - } -fi # as_fn_append - -# as_fn_arith ARG... -# ------------------ -# Perform arithmetic evaluation on the ARGs, and store the result in the -# global $as_val. Take advantage of shells that can avoid forks. The arguments -# must be portable across $(()) and expr. -if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : - eval 'as_fn_arith () - { - as_val=$(( $* )) - }' -else - as_fn_arith () - { - as_val=`expr "$@" || test $? -eq 1` - } -fi # as_fn_arith - - -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then - as_basename=basename -else - as_basename=false -fi - -if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then - as_dirname=dirname -else - as_dirname=false -fi - -as_me=`$as_basename -- "$0" || -$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X/"$0" | - sed '/^.*\/\([^/][^/]*\)\/*$/{ - s//\1/ - q - } - /^X\/\(\/\/\)$/{ - s//\1/ - q - } - /^X\/\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - -# Avoid depending upon Character Ranges. -as_cr_letters='abcdefghijklmnopqrstuvwxyz' -as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' -as_cr_Letters=$as_cr_letters$as_cr_LETTERS -as_cr_digits='0123456789' -as_cr_alnum=$as_cr_Letters$as_cr_digits - -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in #((((( --n*) - case `echo 'xy\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - xy) ECHO_C='\c';; - *) echo `echo ksh88 bug on AIX 6.1` > /dev/null - ECHO_T=' ';; - esac;; -*) - ECHO_N='-n';; -esac - -rm -f conf$$ conf$$.exe conf$$.file -if test -d conf$$.dir; then - rm -f conf$$.dir/conf$$.file -else - rm -f conf$$.dir - mkdir conf$$.dir 2>/dev/null -fi -if (echo >conf$$.file) 2>/dev/null; then - if ln -s conf$$.file conf$$ 2>/dev/null; then - as_ln_s='ln -s' - # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. - ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' - elif ln conf$$.file conf$$ 2>/dev/null; then - as_ln_s=ln - else - as_ln_s='cp -p' - fi -else - as_ln_s='cp -p' -fi -rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file -rmdir conf$$.dir 2>/dev/null - - -# as_fn_mkdir_p -# ------------- -# Create "$as_dir" as a directory, including parents if necessary. -as_fn_mkdir_p () -{ - - case $as_dir in #( - -*) as_dir=./$as_dir;; - esac - test -d "$as_dir" || eval $as_mkdir_p || { - as_dirs= - while :; do - case $as_dir in #( - *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( - *) as_qdir=$as_dir;; - esac - as_dirs="'$as_qdir' $as_dirs" - as_dir=`$as_dirname -- "$as_dir" || -$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$as_dir" : 'X\(//\)[^/]' \| \ - X"$as_dir" : 'X\(//\)$' \| \ - X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_dir" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - test -d "$as_dir" && break - done - test -z "$as_dirs" || eval "mkdir $as_dirs" - } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" - - -} # as_fn_mkdir_p -if mkdir -p . 2>/dev/null; then - as_mkdir_p='mkdir -p "$as_dir"' -else - test -d ./-p && rmdir ./-p - as_mkdir_p=false -fi - -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in #( - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x - -# Sed expression to map a string onto a valid CPP name. -as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" - -# Sed expression to map a string onto a valid variable name. -as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" - - -exec 6>&1 -## ----------------------------------- ## -## Main body of $CONFIG_STATUS script. ## -## ----------------------------------- ## -_ASEOF -test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 - -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 -# Save the log message, to keep $0 and so on meaningful, and to -# report actual input values of CONFIG_FILES etc. instead of their -# values after options handling. -ac_log=" -This file was extended by openjdk $as_me version-0.1, which was -generated by GNU Autoconf 2.67. Invocation command line was - - CONFIG_FILES = $CONFIG_FILES - CONFIG_HEADERS = $CONFIG_HEADERS - CONFIG_LINKS = $CONFIG_LINKS - CONFIG_COMMANDS = $CONFIG_COMMANDS - $ $0 $@ - -on `(hostname || uname -n) 2>/dev/null | sed 1q` -" - -_ACEOF - -case $ac_config_files in *" -"*) set x $ac_config_files; shift; ac_config_files=$*;; -esac - -case $ac_config_headers in *" -"*) set x $ac_config_headers; shift; ac_config_headers=$*;; -esac - - -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 -# Files that config.status was made for. -config_files="$ac_config_files" -config_headers="$ac_config_headers" - -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 -ac_cs_usage="\ -\`$as_me' instantiates files and other configuration actions -from templates according to the current configuration. Unless the files -and actions are specified as TAGs, all are instantiated by default. - -Usage: $0 [OPTION]... [TAG]... - - -h, --help print this help, then exit - -V, --version print version number and configuration settings, then exit - --config print configuration, then exit - -q, --quiet, --silent - do not print progress messages - -d, --debug don't remove temporary files - --recheck update $as_me by reconfiguring in the same conditions - --file=FILE[:TEMPLATE] - instantiate the configuration file FILE - --header=FILE[:TEMPLATE] - instantiate the configuration header FILE - -Configuration files: -$config_files - -Configuration headers: -$config_headers - -Report bugs to ." - -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 -ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" -ac_cs_version="\\ -openjdk config.status version-0.1 -configured by $0, generated by GNU Autoconf 2.67, - with options \\"\$ac_cs_config\\" - -Copyright (C) 2010 Free Software Foundation, Inc. -This config.status script is free software; the Free Software Foundation -gives unlimited permission to copy, distribute and modify it." - -ac_pwd='$ac_pwd' -srcdir='$srcdir' -AWK='$AWK' -test -n "\$AWK" || AWK=awk -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 -# The default lists apply if the user does not specify any file. -ac_need_defaults=: -while test $# != 0 -do - case $1 in - --*=?*) - ac_option=`expr "X$1" : 'X\([^=]*\)='` - ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` - ac_shift=: - ;; - --*=) - ac_option=`expr "X$1" : 'X\([^=]*\)='` - ac_optarg= - ac_shift=: - ;; - *) - ac_option=$1 - ac_optarg=$2 - ac_shift=shift - ;; + conf_processed_arguments="$conf_processed_arguments $conf_option" ;; esac - case $ac_option in - # Handling of the options. - -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) - ac_cs_recheck=: ;; - --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) - $as_echo "$ac_cs_version"; exit ;; - --config | --confi | --conf | --con | --co | --c ) - $as_echo "$ac_cs_config"; exit ;; - --debug | --debu | --deb | --de | --d | -d ) - debug=: ;; - --file | --fil | --fi | --f ) - $ac_shift - case $ac_optarg in - *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; - '') as_fn_error $? "missing file argument" ;; - esac - as_fn_append CONFIG_FILES " '$ac_optarg'" - ac_need_defaults=false;; - --header | --heade | --head | --hea ) - $ac_shift - case $ac_optarg in - *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; - esac - as_fn_append CONFIG_HEADERS " '$ac_optarg'" - ac_need_defaults=false;; - --he | --h) - # Conflict between --help and --header - as_fn_error $? "ambiguous option: \`$1' -Try \`$0 --help' for more information.";; - --help | --hel | -h ) - $as_echo "$ac_cs_usage"; exit ;; - -q | -quiet | --quiet | --quie | --qui | --qu | --q \ - | -silent | --silent | --silen | --sile | --sil | --si | --s) - ac_cs_silent=: ;; - - # This is an error. - -*) as_fn_error $? "unrecognized option: \`$1' -Try \`$0 --help' for more information." ;; - - *) as_fn_append ac_config_targets " $1" - ac_need_defaults=false ;; - - esac - shift -done - -ac_configure_extra_args= - -if $ac_cs_silent; then - exec 6>/dev/null - ac_configure_extra_args="$ac_configure_extra_args --silent" -fi - -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 -if \$ac_cs_recheck; then - set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion - shift - \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 - CONFIG_SHELL='$SHELL' - export CONFIG_SHELL - exec "\$@" -fi - -_ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 -exec 5>>config.log -{ - echo - sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX -## Running $as_me. ## -_ASBOX - $as_echo "$ac_log" -} >&5 - -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 - -# Handling of arguments. -for ac_config_target in $ac_config_targets -do - case $ac_config_target in - "$OUTPUT_ROOT/config.h") CONFIG_HEADERS="$CONFIG_HEADERS $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in" ;; - "$OUTPUT_ROOT/spec.gmk") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in" ;; - "$OUTPUT_ROOT/Makefile") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in" ;; - - *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5 ;; + case $conf_option in + -build | --build | --buil | --bui | --bu |-build=* | --build=* | --buil=* | --bui=* | --bu=*) + conf_legacy_crosscompile="$conf_legacy_crosscompile $conf_option" ;; + -target | --target | --targe | --targ | --tar | --ta | --t | -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + conf_legacy_crosscompile="$conf_legacy_crosscompile $conf_option" ;; + -host | --host | --hos | --ho | -host=* | --host=* | --hos=* | --ho=*) + conf_legacy_crosscompile="$conf_legacy_crosscompile $conf_option" ;; esac done - -# If the user did not use the arguments to specify the items to instantiate, -# then the envvar interface is used. Set only those that are not. -# We use the long form for the default assignment because of an extremely -# bizarre bug on SunOS 4.1.3. -if $ac_need_defaults; then - test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files - test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers -fi - -# Have a temporary directory for convenience. Make it in the build tree -# simply because there is no reason against having it here, and in addition, -# creating and moving files from /tmp can sometimes cause problems. -# Hook for its removal unless debugging. -# Note that there is a small window in which the directory will not be cleaned: -# after its creation but before its name has been assigned to `$tmp'. -$debug || -{ - tmp= - trap 'exit_status=$? - { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status -' 0 - trap 'as_fn_exit 1' 1 2 13 15 -} -# Create a (secure) tmp directory for tmp files. - -{ - tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && - test -n "$tmp" && test -d "$tmp" -} || -{ - tmp=./conf$$-$RANDOM - (umask 077 && mkdir "$tmp") -} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 - -# Set up the scripts for CONFIG_FILES section. -# No need to generate them if there are no CONFIG_FILES. -# This happens for instance with `./config.status config.h'. -if test -n "$CONFIG_FILES"; then - - -ac_cr=`echo X | tr X '\015'` -# On cygwin, bash can eat \r inside `` if the user requested igncr. -# But we know of no other shell where ac_cr would be empty at this -# point, so we can use a bashism as a fallback. -if test "x$ac_cr" = x; then - eval ac_cr=\$\'\\r\' -fi -ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` -if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then - ac_cs_awk_cr='\\r' -else - ac_cs_awk_cr=$ac_cr -fi - -echo 'BEGIN {' >"$tmp/subs1.awk" && -_ACEOF - - -{ - echo "cat >conf$$subs.awk <<_ACEOF" && - echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && - echo "_ACEOF" -} >conf$$subs.sh || - as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 -ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` -ac_delim='%!_!# ' -for ac_last_try in false false false false false :; do - . ./conf$$subs.sh || - as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 - - ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` - if test $ac_delim_n = $ac_delim_num; then - break - elif $ac_last_try; then - as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 +if $TEST "x$conf_legacy_crosscompile" != "x"; then + if $TEST "x$conf_openjdk_target" != "x"; then + echo "Error: Specifying --openjdk-target together with autoconf" + echo "legacy cross-compilation flags is not supported." + echo "You specified: --openjdk-target=$conf_openjdk_target and $conf_legacy_crosscompile." + echo "The recommended use is just --openjdk-target." + exit 1 else - ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + echo "Warning: You are using legacy autoconf cross-compilation flags." + echo "It is recommended that you use --openjdk-target instead." + echo "" fi -done -rm -f conf$$subs.sh +fi -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 -cat >>"\$tmp/subs1.awk" <<\\_ACAWK && -_ACEOF -sed -n ' -h -s/^/S["/; s/!.*/"]=/ -p -g -s/^[^!]*!// -:repl -t repl -s/'"$ac_delim"'$// -t delim -:nl -h -s/\(.\{148\}\)..*/\1/ -t more1 -s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ -p -n -b repl -:more1 -s/["\\]/\\&/g; s/^/"/; s/$/"\\/ -p -g -s/.\{148\}// -t nl -:delim -h -s/\(.\{148\}\)..*/\1/ -t more2 -s/["\\]/\\&/g; s/^/"/; s/$/"/ -p -b -:more2 -s/["\\]/\\&/g; s/^/"/; s/$/"\\/ -p -g -s/.\{148\}// -t delim -' >$CONFIG_STATUS || ac_write_fail=1 -rm -f conf$$subs.awk -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 -_ACAWK -cat >>"\$tmp/subs1.awk" <<_ACAWK && - for (key in S) S_is_set[key] = 1 - FS = "" +if $TEST "x$conf_openjdk_target" != "x"; then + conf_build_platform=`sh $conf_script_dir/build-aux/config.guess` + conf_processed_arguments="--build=$conf_build_platform --host=$conf_openjdk_target --target=$conf_openjdk_target $conf_processed_arguments" +fi -} -{ - line = $ 0 - nfields = split(line, field, "@") - substed = 0 - len = length(field[1]) - for (i = 2; i < nfields; i++) { - key = field[i] - keylen = length(key) - if (S_is_set[key]) { - value = S[key] - line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) - len += length(value) + length(field[++i]) - substed = 1 - } else - len += 1 + keylen - } +# Make configure exit with error on invalid options as default. +# Can be overridden by --disable-option-checking, since we prepend our argument +# and later options override earlier. +conf_processed_arguments="--enable-option-checking=fatal $conf_processed_arguments" - print line -} - -_ACAWK -_ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 -if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then - sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +### +### Call the configure script +### +if $TEST -e $conf_closed_script_dir/generated-configure.sh; then + # Closed source configure available; run that instead + . $conf_closed_script_dir/generated-configure.sh $conf_processed_arguments --with-extra-cflags="$conf_extra_cflags" --with-extra-cxxflags="$conf_extra_cxxflags" else - cat -fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \ - || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 -_ACEOF - -# VPATH may cause trouble with some makes, so we remove sole $(srcdir), -# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and -# trailing colons and then remove the whole line if VPATH becomes empty -# (actually we leave an empty line to preserve line numbers). -if test "x$srcdir" = x.; then - ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ -h -s/// -s/^/:/ -s/[ ]*$/:/ -s/:\$(srcdir):/:/g -s/:\${srcdir}:/:/g -s/:@srcdir@:/:/g -s/^:*// -s/:*$// -x -s/\(=[ ]*\).*/\1/ -G -s/\n// -s/^[^=]*=[ ]*$// -}' + . $conf_script_dir/generated-configure.sh $conf_processed_arguments --with-extra-cflags="$conf_extra_cflags" --with-extra-cxxflags="$conf_extra_cxxflags" fi -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 -fi # test -n "$CONFIG_FILES" +### +### Post-processing +### -# Set up the scripts for CONFIG_HEADERS section. -# No need to generate them if there are no CONFIG_HEADERS. -# This happens for instance with `./config.status Makefile'. -if test -n "$CONFIG_HEADERS"; then -cat >"$tmp/defines.awk" <<\_ACAWK || -BEGIN { -_ACEOF - -# Transform confdefs.h into an awk script `defines.awk', embedded as -# here-document in config.status, that substitutes the proper values into -# config.h.in to produce config.h. - -# Create a delimiter string that does not exist in confdefs.h, to ease -# handling of long lines. -ac_delim='%!_!# ' -for ac_last_try in false false :; do - ac_t=`sed -n "/$ac_delim/p" confdefs.h` - if test -z "$ac_t"; then - break - elif $ac_last_try; then - as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 - else - ac_delim="$ac_delim!$ac_delim _$ac_delim!! " - fi -done - -# For the awk script, D is an array of macro values keyed by name, -# likewise P contains macro parameters if any. Preserve backslash -# newline sequences. - -ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* -sed -n ' -s/.\{148\}/&'"$ac_delim"'/g -t rset -:rset -s/^[ ]*#[ ]*define[ ][ ]*/ / -t def -d -:def -s/\\$// -t bsnl -s/["\\]/\\&/g -s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ -D["\1"]=" \3"/p -s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p -d -:bsnl -s/["\\]/\\&/g -s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ -D["\1"]=" \3\\\\\\n"\\/p -t cont -s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p -t cont -d -:cont -n -s/.\{148\}/&'"$ac_delim"'/g -t clear -:clear -s/\\$// -t bsnlc -s/["\\]/\\&/g; s/^/"/; s/$/"/p -d -:bsnlc -s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p -b cont -' >$CONFIG_STATUS || ac_write_fail=1 - -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 - for (key in D) D_is_set[key] = 1 - FS = "" -} -/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { - line = \$ 0 - split(line, arg, " ") - if (arg[1] == "#") { - defundef = arg[2] - mac1 = arg[3] - } else { - defundef = substr(arg[1], 2) - mac1 = arg[2] - } - split(mac1, mac2, "(") #) - macro = mac2[1] - prefix = substr(line, 1, index(line, defundef) - 1) - if (D_is_set[macro]) { - # Preserve the white space surrounding the "#". - print prefix "define", macro P[macro] D[macro] - next - } else { - # Replace #undef with comments. This is necessary, for example, - # in the case of _POSIX_SOURCE, which is predefined and required - # on some systems where configure will not decide to define it. - if (defundef == "undef") { - print "/*", prefix defundef, macro, "*/" - next - } - } -} -{ print } -_ACAWK -_ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 - as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 -fi # test -n "$CONFIG_HEADERS" - - -eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS " -shift -for ac_tag -do - case $ac_tag in - :[FHLC]) ac_mode=$ac_tag; continue;; - esac - case $ac_mode$ac_tag in - :[FHL]*:*);; - :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5 ;; - :[FH]-) ac_tag=-:-;; - :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; - esac - ac_save_IFS=$IFS - IFS=: - set x $ac_tag - IFS=$ac_save_IFS - shift - ac_file=$1 - shift - - case $ac_mode in - :L) ac_source=$1;; - :[FH]) - ac_file_inputs= - for ac_f - do - case $ac_f in - -) ac_f="$tmp/stdin";; - *) # Look for the file first in the build tree, then in the source tree - # (if the path is not absolute). The absolute path cannot be DOS-style, - # because $ac_f cannot contain `:'. - test -f "$ac_f" || - case $ac_f in - [\\/$]*) false;; - *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; - esac || - as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5 ;; - esac - case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac - as_fn_append ac_file_inputs " '$ac_f'" - done - - # Let's still pretend it is `configure' which instantiates (i.e., don't - # use $as_me), people would be surprised to read: - # /* config.h. Generated by config.status. */ - configure_input='Generated from '` - $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' - `' by configure.' - if test x"$ac_file" != x-; then - configure_input="$ac_file. $configure_input" - { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 -$as_echo "$as_me: creating $ac_file" >&6;} - fi - # Neutralize special characters interpreted by sed in replacement strings. - case $configure_input in #( - *\&* | *\|* | *\\* ) - ac_sed_conf_input=`$as_echo "$configure_input" | - sed 's/[\\\\&|]/\\\\&/g'`;; #( - *) ac_sed_conf_input=$configure_input;; - esac - - case $ac_tag in - *:-:* | *:-) cat >"$tmp/stdin" \ - || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; - esac - ;; - esac - - ac_dir=`$as_dirname -- "$ac_file" || -$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$ac_file" : 'X\(//\)[^/]' \| \ - X"$ac_file" : 'X\(//\)$' \| \ - X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$ac_file" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - as_dir="$ac_dir"; as_fn_mkdir_p - ac_builddir=. - -case "$ac_dir" in -.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; -*) - ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` - # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` - case $ac_top_builddir_sub in - "") ac_top_builddir_sub=. ac_top_build_prefix= ;; - *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; - esac ;; -esac -ac_abs_top_builddir=$ac_pwd -ac_abs_builddir=$ac_pwd$ac_dir_suffix -# for backward compatibility: -ac_top_builddir=$ac_top_build_prefix - -case $srcdir in - .) # We are building in place. - ac_srcdir=. - ac_top_srcdir=$ac_top_builddir_sub - ac_abs_top_srcdir=$ac_pwd ;; - [\\/]* | ?:[\\/]* ) # Absolute name. - ac_srcdir=$srcdir$ac_dir_suffix; - ac_top_srcdir=$srcdir - ac_abs_top_srcdir=$srcdir ;; - *) # Relative name. - ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix - ac_top_srcdir=$ac_top_build_prefix$srcdir - ac_abs_top_srcdir=$ac_pwd/$srcdir ;; -esac -ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix - - - case $ac_mode in - :F) - # - # CONFIG_FILE - # - -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 -# If the template does not know about datarootdir, expand it. -# FIXME: This hack should be removed a few years after 2.60. -ac_datarootdir_hack=; ac_datarootdir_seen= -ac_sed_dataroot=' -/datarootdir/ { - p - q -} -/@datadir@/p -/@docdir@/p -/@infodir@/p -/@localedir@/p -/@mandir@/p' -case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in -*datarootdir*) ac_datarootdir_seen=yes;; -*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 -$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 - ac_datarootdir_hack=' - s&@datadir@&$datadir&g - s&@docdir@&$docdir&g - s&@infodir@&$infodir&g - s&@localedir@&$localedir&g - s&@mandir@&$mandir&g - s&\\\${datarootdir}&$datarootdir&g' ;; -esac -_ACEOF - -# Neutralize VPATH when `$srcdir' = `.'. -# Shell code in configure.ac might set extrasub. -# FIXME: do we really want to maintain this feature? -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 -ac_sed_extra="$ac_vpsub -$extrasub -_ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 -:t -/@[a-zA-Z_][a-zA-Z_0-9]*@/!b -s|@configure_input@|$ac_sed_conf_input|;t t -s&@top_builddir@&$ac_top_builddir_sub&;t t -s&@top_build_prefix@&$ac_top_build_prefix&;t t -s&@srcdir@&$ac_srcdir&;t t -s&@abs_srcdir@&$ac_abs_srcdir&;t t -s&@top_srcdir@&$ac_top_srcdir&;t t -s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t -s&@builddir@&$ac_builddir&;t t -s&@abs_builddir@&$ac_abs_builddir&;t t -s&@abs_top_builddir@&$ac_abs_top_builddir&;t t -$ac_datarootdir_hack -" -eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \ - || as_fn_error $? "could not create $ac_file" "$LINENO" 5 - -test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && - { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && - { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' -which seems to be undefined. Please make sure it is defined" >&5 -$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' -which seems to be undefined. Please make sure it is defined" >&2;} - - rm -f "$tmp/stdin" - case $ac_file in - -) cat "$tmp/out" && rm -f "$tmp/out";; - *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";; - esac \ - || as_fn_error $? "could not create $ac_file" "$LINENO" 5 - ;; - :H) - # - # CONFIG_HEADER - # - if test x"$ac_file" != x-; then - { - $as_echo "/* $configure_input */" \ - && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" - } >"$tmp/config.h" \ - || as_fn_error $? "could not create $ac_file" "$LINENO" 5 - if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then - { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 -$as_echo "$as_me: $ac_file is unchanged" >&6;} - else - rm -f "$ac_file" - mv "$tmp/config.h" "$ac_file" \ - || as_fn_error $? "could not create $ac_file" "$LINENO" 5 - fi - else - $as_echo "/* $configure_input */" \ - && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \ - || as_fn_error $? "could not create -" "$LINENO" 5 - fi - ;; - - - esac - -done # for ac_tag - - -as_fn_exit 0 -_ACEOF -ac_clean_files=$ac_clean_files_save - -test $ac_write_fail = 0 || - as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 - - -# configure is writing to config.log, and then calls config.status. -# config.status does its own redirection, appending to config.log. -# Unfortunately, on DOS this fails, as config.log is still kept open -# by configure, so config.status won't be able to write to it; its -# output is simply discarded. So we exec the FD to /dev/null, -# effectively closing config.log, so it can be properly (re)opened and -# appended to by config.status. When coming back to configure, we -# need to make the FD available again. -if test "$no_create" != yes; then - ac_cs_success=: - ac_config_status_args= - test "$silent" = yes && - ac_config_status_args="$ac_config_status_args --quiet" - exec 5>/dev/null - $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false - exec 5>>config.log - # Use ||, not &&, to avoid exiting from the if with $? = 1, which - # would make configure fail if this is the last instruction. - $ac_cs_success || as_fn_exit 1 -fi -if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 -$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} -fi - - -# Finally output some useful information to the user - -if test "x$CCACHE_FOUND" != x; then - if test "x$HAS_GOOD_CCACHE" = x; then - CCACHE_STATUS="installed, but disabled (version older than 3.1.4)" - CCACHE_HELP_MSG="You have ccache installed, but it is a version prior to 3.1.4. Try upgrading." - else - CCACHE_STATUS="installed and in use" - fi -else - if test "x$GCC" = xyes; then - CCACHE_STATUS="not installed (consider installing)" - CCACHE_HELP_MSG="You do not have ccache installed. Try installing it." - else - CCACHE_STATUS="not available for your system" - fi -fi - -printf "\n" -printf "====================================================\n" -printf "A new configuration has been successfully created in\n" -printf "$OUTPUT_ROOT\n" -if test "x$CONFIGURE_COMMAND_LINE" != x; then - printf "using configure arguments '$CONFIGURE_COMMAND_LINE'.\n" -else - printf "using default settings.\n" -fi - -printf "\n" -printf "Configuration summary:\n" -printf "* Debug level: $DEBUG_LEVEL\n" -printf "* JDK variant: $JDK_VARIANT\n" -printf "* JVM variants: $with_jvm_variants\n" -printf "* Host info: OS: $HOST_OS, CPU architecture: $HOST_CPU_ARCH, address length: $HOST_CPU_BITS\n" -printf "* Boot JDK: $BOOT_JDK\n" - -printf "\n" -printf "Build performance summary:\n" -printf "* Cores to use: $NUM_CORES\n" -printf "* Memory limit: $MEMORY_SIZE MB\n" -printf "* ccache status: $CCACHE_STATUS\n" - -if test "x$OUTPUT_DIR_IS_LOCAL" != "xyes"; then - printf "\n" - printf "WARNING: Your build output directory is not on a local disk.\n" - printf "This will severely degrade build performance!\n" - printf "It is recommended that you create an output directory on a local disk,\n" - printf "and run the configure script again from that directory.\n" -fi - -if test "x$CCACHE_HELP_MSG" != x; then - printf "\n" - printf "Build performance tip: ccache gives a tremendous speedup for C++ recompilations.\n" - printf "$CCACHE_HELP_MSG\n" - - help_on_build_dependency ccache - printf "$HELP_MSG\n" +# Move the log file to the output root, if this was successfully created +if $TEST -d "$OUTPUT_ROOT"; then + mv -f config.log "$OUTPUT_ROOT" 2> /dev/null fi diff --git a/common/autoconf/configure.ac b/common/autoconf/configure.ac index be678cc2f15..df8c5f1bcb5 100644 --- a/common/autoconf/configure.ac +++ b/common/autoconf/configure.ac @@ -23,2856 +23,204 @@ # questions. # +############################################################################### +# +# Includes and boilerplate +# +############################################################################### + + AC_PREREQ([2.61]) -AC_INIT(openjdk, version-0.1, build-infra-dev@openjdk.java.net) +AC_INIT(openjdk, jdk8, build-dev@openjdk.java.net) + +# Do not change or remove the following line, it is needed for consistency checks: +# DATE_WHEN_GENERATED: @DATE_WHEN_GENERATED@ AC_CONFIG_AUX_DIR([build-aux]) - m4_include([build-aux/pkg.m4]) + +# Include these first... +m4_include([basics.m4]) m4_include([builddeps.m4]) -m4_include([platform.m4]) -m4_include([cores.m4]) +# ... then the rest +m4_include([boot-jdk.m4]) +m4_include([build-performance.m4]) m4_include([help.m4]) +m4_include([jdk-options.m4]) +m4_include([libraries.m4]) +m4_include([platform.m4]) +m4_include([source-dirs.m4]) +m4_include([toolchain.m4]) -# Save the command line. Do this very early, before it is lost by calling autoconf macros. -CONFIGURE_COMMAND_LINE="$@" -AC_SUBST(CONFIGURE_COMMAND_LINE) - -# Locate the directory of this script. -SCRIPT="[$]0" -REMOVE_SYMBOLIC_LINKS(SCRIPT) -AUTOCONF_DIR=`dirname [$]0` - -# Start with tools that do not need have cross compilation support -# and can be expected to be found in the default PATH. These tools are -# used by configure. Nor are these tools expected to be found in the -# devkit from the builddeps server either, since they are -# needed to download the devkit. -AC_PROG_AWK -CHECK_NONEMPTY(AWK) -AC_PATH_PROG(CAT, cat) -CHECK_NONEMPTY(CAT) -AC_PATH_PROG(CHMOD, chmod) -CHECK_NONEMPTY(CHMOD) -AC_PATH_PROG(CP, cp) -CHECK_NONEMPTY(CP) -AC_PATH_PROG(CPIO, cpio) -CHECK_NONEMPTY(CPIO) -AC_PATH_PROG(CUT, cut) -CHECK_NONEMPTY(CUT) -AC_PATH_PROG(DATE, date) -CHECK_NONEMPTY(DATE) -AC_PATH_PROG(DF, df) -CHECK_NONEMPTY(DF) -AC_PATH_PROG(DIFF, diff) -CHECK_NONEMPTY(DIFF) -# Warning echo is really, really unportable!!!!! Different -# behaviour in bash and dash and in a lot of other shells! -# Use printf for serious work! -AC_PATH_PROG(ECHO, echo) -CHECK_NONEMPTY(ECHO) -AC_PROG_EGREP -CHECK_NONEMPTY(EGREP) -AC_PROG_FGREP -CHECK_NONEMPTY(FGREP) - -AC_PATH_PROG(FIND, find) -CHECK_NONEMPTY(FIND) -CHECK_FIND_DELETE -AC_SUBST(FIND_DELETE) - -AC_PROG_GREP -CHECK_NONEMPTY(GREP) -AC_PATH_PROG(HEAD, head) -CHECK_NONEMPTY(HEAD) -AC_PATH_PROG(LN, ln) -CHECK_NONEMPTY(LN) -AC_PATH_PROG(LS, ls) -CHECK_NONEMPTY(LS) -AC_PATH_PROGS(MAKE, [gmake make]) -CHECK_NONEMPTY(MAKE) -MAKE_VERSION=`$MAKE --version | head -n 1 | grep '3.8[[12346789]]'` -if test "x$MAKE_VERSION" = x; then - AC_MSG_ERROR([You must use GNU make 3.81 or newer! Please put it in the path.]) -fi -AC_PATH_PROG(MKDIR, mkdir) -CHECK_NONEMPTY(MKDIR) -AC_PATH_PROG(MV, mv) -CHECK_NONEMPTY(MV) -AC_PATH_PROGS(NAWK, [nawk gawk awk]) -CHECK_NONEMPTY(NAWK) -AC_PATH_PROG(PRINTF, printf) -CHECK_NONEMPTY(PRINTF) -AC_PATH_PROG(THEPWDCMD, pwd) -AC_PATH_PROG(RM, rm) -CHECK_NONEMPTY(RM) -RM="$RM -f" -AC_PROG_SED -CHECK_NONEMPTY(SED) -AC_PATH_PROG(SH, sh) -CHECK_NONEMPTY(SH) -AC_PATH_PROG(SORT, sort) -CHECK_NONEMPTY(SORT) -AC_PATH_PROG(TAR, tar) -CHECK_NONEMPTY(TAR) -AC_PATH_PROG(TAIL, tail) -CHECK_NONEMPTY(TAIL) -AC_PATH_PROG(TEE, tee) -CHECK_NONEMPTY(TEE) -AC_PATH_PROG(TR, tr) -CHECK_NONEMPTY(TR) -AC_PATH_PROG(TOUCH, touch) -CHECK_NONEMPTY(TOUCH) -AC_PATH_PROG(WC, wc) -CHECK_NONEMPTY(WC) -AC_PATH_PROG(XARGS, xargs) -CHECK_NONEMPTY(XARGS) -AC_PATH_PROG(ZIP, zip) -CHECK_NONEMPTY(ZIP) -AC_PATH_PROG(UNZIP, unzip) -CHECK_NONEMPTY(UNZIP) -AC_PATH_PROG(LDD, ldd) -if test "x$LDD" = "x"; then - # List shared lib dependencies is used for - # debug output and checking for forbidden dependencies. - # We can build without it. - LDD="true" -fi -AC_PATH_PROG(OTOOL, otool) -if test "x$OTOOL" = "x"; then - OTOOL="true" -fi -AC_PATH_PROG(READELF, readelf) -AC_PATH_PROG(EXPR, expr) -CHECK_NONEMPTY(EXPR) -AC_PATH_PROG(FILE, file) -CHECK_NONEMPTY(FILE) -AC_PATH_PROG(HG, hg) - -# Figure out the build and host system. -AC_CANONICAL_BUILD -AC_CANONICAL_HOST - -AC_ARG_WITH(data-model, [AS_HELP_STRING([--with-data-model], - [build 32-bit or 64-bit binaries (for platforms that support it), e.g. --with-data-model=32 @<:@guessed@:>@])]) - -if test "x$with_data_model" != x && \ - test "x$with_data_model" != x32 && \ - test "x$with_data_model" != x64 ; then - AC_MSG_ERROR([The data model can only be 32 or 64!]) -fi -# Translate the standard cpu-vendor-kernel-os quadruplets into -# the new HOST_.... and BUILD_... and the legacy names used by -# the openjdk build. -# It uses $host_os $host_cpu $build_os $build_cpu and $with_data_model -EXTRACT_HOST_AND_BUILD_AND_LEGACY_VARS -# Now the following vars are defined. -# HOST_OS=aix,bsd,hpux,linux,macosx,solaris,windows -# HOST_OS_FAMILY=bsd,gnu,sysv,win32,wince -# HOST_OS_API=posix,winapi -# -# HOST_CPU=ia32,x64,sparc,sparcv9,arm,arm64,ppc,ppc64 -# HOST_CPU_ARCH=x86,sparc,pcc,arm -# HOST_CPU_BITS=32,64 -# HOST_CPU_ENDIAN=big,little -# -# There is also a: -# LEGACY_HOST_CPU1=i586,amd64,.... # used to set the old var ARCH -# LEGACY_HOST_CPU2=i386,amd64,.... # used to set the old var LIBARCH -# LEGACY_HOST_CPU3=only sparcv9,amd64 # used to set the ISA_DIR on Solaris -# There was also a BUILDARCH that had i486,amd64,... but we do not use that -# in the new build. -# LEGACY_HOST_OS_API=solaris,windows # used to select source roots - -DATE_WHEN_CONFIGURED=`LANG=C date` -AC_SUBST(DATE_WHEN_CONFIGURED) - -# How many cores do we have on this build system? -AC_ARG_WITH(num-cores, [AS_HELP_STRING([--with-num-cores], - [number of cores in the build system, e.g. --with-num-cores=8 @<:@probed@:>@])]) -if test "x$with_num_cores" = x; then - # The number of cores were not specified, try to probe them. - CHECK_CORES -else - NUM_CORES=$with_num_cores - CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` -fi -AC_SUBST(NUM_CORES) -AC_SUBST(CONCURRENT_BUILD_JOBS) - -# How many cores do we have on this build system? -AC_ARG_WITH(memory-size, [AS_HELP_STRING([--with-memory-size], - [memory (in MB) available in the build system, e.g. --with-memory-size=1024 @<:@probed@:>@])]) -if test "x$with_memory_size" = x; then - # The memory size was not specified, try to probe it. - CHECK_MEMORY_SIZE -else - MEMORY_SIZE=$with_memory_size -fi -AC_SUBST(MEMORY_SIZE) - -# Where is the source? It is located two levels above the configure script. -CURDIR="$PWD" -cd "$AUTOCONF_DIR/../.." -SRC_ROOT="`pwd`" -AC_SUBST(SRC_ROOT) -cd "$CURDIR" - -# For cygwin we need cygpath first, since it is used everywhere. -AC_PATH_PROG(CYGPATH, cygpath) -PATH_SEP=":" -if test "x$BUILD_OS" = "xwindows"; then - if test "x$CYGPATH" = x; then - AC_MSG_ERROR([Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path]) - fi - PATH_SEP=";" -fi -AC_SUBST(PATH_SEP) - -SPACESAFE(SRC_ROOT,[the path to the source root]) -SPACESAFE(CURDIR,[the path to the current directory]) - -if test "x$BUILD_OS" = "xsolaris"; then - # Also search in /usr/ccs/bin for utilities like ar and as. - PATH="/usr/ccs/bin:$PATH" -fi +# This line needs to be here, verbatim, after all includes. +# It is replaced with closed functionality when building +# closed sources. +AC_DEFUN_ONCE([CLOSED_HOOK]) ############################################################################### # -# OpenJDK or closed +# Initialization # -AC_ARG_ENABLE([openjdk-only], [AS_HELP_STRING([--enable-openjdk-only], - [build OpenJDK regardless of the presence of closed repositories @<:@disabled@:>@])],,) - -if test "x$enable_openjdk_only" = "xyes"; then - OPENJDK=true -elif test "x$enable_openjdk_only" = "xno"; then - OPENJDK=false -elif test -d "$SRC_ROOT/jdk/src/closed"; then - OPENJDK=false -else - OPENJDK=true -fi - -if test "x$OPENJDK" = "xtrue"; then - SET_OPENJDK=OPENJDK=true -fi - -AC_SUBST(SET_OPENJDK) - ############################################################################### -# -# JIGSAW or not. The JIGSAW variable is used during the intermediate -# stage when we are building both the old style JDK and the new style modularized JDK. -# When the modularized JDK is finalized, this option will go away. -# -AC_ARG_ENABLE([jigsaw], [AS_HELP_STRING([--enable-jigsaw], - [build Jigsaw images (not yet available) @<:@disabled@:>@])],,) -if test "x$enable_jigsaw" = "xyes"; then - JIGSAW=true -else - JIGSAW=false -fi -AC_SUBST(JIGSAW) +# Basic initialization that must happen first of all +BASIC_INIT +BASIC_SETUP_PATHS +BASIC_SETUP_LOGGING -############################################################################### -# -# Check which variant of the JDK that we want to build. -# Currently we have: -# normal: standard edition -# embedded: cut down to a smaller footprint -# -# Effectively the JDK variant gives a name to a specific set of -# modules to compile into the JDK. In the future, these modules -# might even be Jigsaw modules. -# -AC_MSG_CHECKING([which variant of the JDK to build]) -AC_ARG_WITH([jdk-variant], [AS_HELP_STRING([--with-jdk-variant], - [JDK variant to build (normal, embedded) @<:@normal@:>@])]) +# Must be done before we can call HELP_MSG_MISSING_DEPENDENCY. +HELP_SETUP_DEPENDENCY_HELP -if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then - JAVASE_EMBEDDED="" - MINIMIZE_RAM_USAGE="" - JDK_VARIANT="normal" -elif test "x$with_jdk_variant" = xembedded; then - JAVASE_EMBEDDED="JAVASE_EMBEDDED:=true" - MINIMIZE_RAM_USAGE="MINIMIZE_RAM_USAGE:=true" - JDK_VARIANT="embedded" -else - AC_MSG_ERROR([The available JDK variants are: normal, embedded]) -fi - -AC_SUBST(JAVASE_EMBEDDED) -AC_SUBST(MINIMIZE_RAM_USAGE) -AC_SUBST(JDK_VARIANT) +# Setup simple tools, that do not need have cross compilation support. +# Without these, we can't properly run the rest of the configure script. +BASIC_SETUP_TOOLS -AC_MSG_RESULT([$JDK_VARIANT]) - -############################################################################### -# -# Should we build a JDK/JVM with head support (ie a graphical ui)? -# We always build headless support. -# -AC_MSG_CHECKING([headful support]) -AC_ARG_ENABLE([headful], [AS_HELP_STRING([--disable-headful], - [build headful support (graphical UI support) @<:@enabled@:>@])], - [SUPPORT_HEADFUL=${enable_headful}], [SUPPORT_HEADFUL=yes]) - -SUPPORT_HEADLESS=yes -BUILD_HEADLESS="BUILD_HEADLESS:=true" - -if test "x$SUPPORT_HEADFUL" = xyes; then - # We are building both headful and headless. - BUILD_HEADLESS_ONLY="" - headful_msg="inlude support for both headful and headless" -fi - -if test "x$SUPPORT_HEADFUL" = xno; then - # Thus we are building headless only. - BUILD_HEADLESS="BUILD_HEADLESS:=true" - BUILD_HEADLESS_ONLY="BUILD_HEADLESS_ONLY:=true" - headful_msg="headless only" -fi - -AC_MSG_RESULT([$headful_msg]) - -AC_SUBST(SUPPORT_HEADLESS) -AC_SUBST(SUPPORT_HEADFUL) -AC_SUBST(BUILD_HEADLESS) -AC_SUBST(BUILD_HEADLESS_ONLY) - -############################################################################### -# -# Check which variants of the JVM that we want to build. -# Currently we have: -# server: normal interpreter and a tiered C1/C2 compiler -# client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms) -# kernel: kernel footprint JVM that passes the TCK without major performance problems, -# ie normal interpreter and C1, only the serial GC, kernel jvmti etc -# zero: no machine code interpreter, no compiler -# zeroshark: zero interpreter and shark/llvm compiler backend -AC_MSG_CHECKING([which variants of the JVM that should be built]) -AC_ARG_WITH([jvm-variants], [AS_HELP_STRING([--with-jvm-variants], - [JVM variants (separated by commas) to build (server, client, kernel, zero, zeroshark) @<:@server@:>@])]) - -if test "x$with_jvm_variants" = x; then - if test "x$JDK_VARIANT" = xembedded; then - with_jvm_variants="kernel" - elif test "x$HOST_CPU_BITS" = x64; then - with_jvm_variants="server" - else - # Yes, on 32-bit machines, the same source (almost) is compiled twice - # to generate two libjvm.so files. Fun, fun. - with_jvm_variants="client,server" - fi -fi - -JVM_VARIANTS=",$with_jvm_variants," -TEST_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,//' -e 's/client,//' -e 's/kernel,//' -e 's/zero,//' -e 's/zeroshark,//'` - -if test "x$TEST_VARIANTS" != "x,"; then - AC_MSG_ERROR([The available JVM variants are: server, client, kernel, zero, zeroshark]) -fi -AC_MSG_RESULT([$with_jvm_variants]) - -JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'` -JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'` -JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'` -JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'` -JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'` - -if test "x$JVM_VARIANT_CLIENT" = xtrue; then - if test "x$HOST_CPU_BITS" = x64; then - AC_MSG_ERROR([You cannot build a client JVM for a 64-bit machine.]) - fi -fi -if test "x$JVM_VARIANT_KERNEL" = xtrue; then - if test "x$HOST_CPU_BITS" = x64; then - AC_MSG_ERROR([You cannot build a kernel JVM for a 64-bit machine.]) - fi -fi - -COUNT_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,/1/' -e 's/client,/1/' -e 's/kernel,/1/' -e 's/zero,/1/' -e 's/zeroshark,/1/'` -# Replace the commas with AND for use in the build directory name. -ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/'` -if test "x$COUNT_VARIANTS" != "x,1"; then - AC_MSG_NOTICE([NOTE! Longer build time since we are building more than one version of the libjvm! $with_jvm_variants]) -fi - -AC_SUBST(JVM_VARIANTS) -AC_SUBST(JVM_VARIANT_SERVER) -AC_SUBST(JVM_VARIANT_CLIENT) -AC_SUBST(JVM_VARIANT_KERNEL) -AC_SUBST(JVM_VARIANT_ZERO) -AC_SUBST(JVM_VARIANT_ZEROSHARK) - -############################################################################### -# -# Set the debug level -# release: no debug information, all optimizations, no asserts. -# fastdebug: debug information (-g), all optimizations, all asserts -# slowdebug: debug information (-g), no optimizations, all asserts -# -DEBUG_LEVEL="release" -AC_MSG_CHECKING([which debug level to use]) -AC_ARG_ENABLE([debug], [AS_HELP_STRING([--enable-debug], - [set the debug level to fastdebug (shorthand for --with-debug-level=fastdebug) @<:@disabled@:>@])], - [ - ENABLE_DEBUG="${enableval}" - DEBUG_LEVEL="fastdebug" - ], [ENABLE_DEBUG="no"]) - -AC_ARG_WITH([debug-level], [AS_HELP_STRING([--with-debug-level], - [set the debug level (release, fastdebug, slowdebug) @<:@release@:>@])], - [ - DEBUG_LEVEL="${withval}" - if test "x$ENABLE_DEBUG" = xyes; then - AC_MSG_ERROR([You cannot use both --enable-debug and --with-debug-level at the same time.]) - fi - ]) -AC_MSG_RESULT([$DEBUG_LEVEL]) - -if test "x$DEBUG_LEVEL" != xrelease && \ - test "x$DEBUG_LEVEL" != xfastdebug && \ - test "x$DEBUG_LEVEL" != xslowdebug; then - AC_MSG_ERROR([Allowed debug levels are: release, fastdebug and slowdebug]) -fi - -case $DEBUG_LEVEL in - release ) - VARIANT="OPT" - FASTDEBUG="false" - DEBUG_CLASSFILES="false" - BUILD_VARIANT_RELEASE="" - ;; - fastdebug ) - VARIANT="DBG" - FASTDEBUG="true" - DEBUG_CLASSFILES="true" - BUILD_VARIANT_RELEASE="-fastdebug" - ;; - slowdebug ) - VARIANT="DBG" - FASTDEBUG="false" - DEBUG_CLASSFILES="true" - BUILD_VARIANT_RELEASE="-debug" - ;; -esac - -AC_SUBST(DEBUG_LEVEL) -AC_SUBST(VARIANT) -AC_SUBST(FASTDEBUG) -AC_SUBST(DEBUG_CLASSFILES) -AC_SUBST(BUILD_VARIANT_RELEASE) - -# Source the version numbers -. $AUTOCONF_DIR/version.numbers -if test "x$OPENJDK" = "xfalse"; then - . $AUTOCONF_DIR/closed.version.numbers -fi -# Now set the JDK version, milestone, build number etc. -AC_SUBST(JDK_MAJOR_VERSION) -AC_SUBST(JDK_MINOR_VERSION) -AC_SUBST(JDK_MICRO_VERSION) -AC_SUBST(JDK_UPDATE_VERSION) -AC_SUBST(JDK_BUILD_NUMBER) -AC_SUBST(MILESTONE) -AC_SUBST(LAUNCHER_NAME) -AC_SUBST(PRODUCT_NAME) -AC_SUBST(PRODUCT_SUFFIX) -AC_SUBST(JDK_RC_PLATFORM_NAME) -AC_SUBST(COMPANY_NAME) - -COPYRIGHT_YEAR=`date +'%Y'` -AC_SUBST(COPYRIGHT_YEAR) - -RUNTIME_NAME="$PRODUCT_NAME $PRODUCT_SUFFIX" -AC_SUBST(RUNTIME_NAME) - -if test "x$JDK_UPDATE_VERSION" != x; then - JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}" -else - JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}" -fi -AC_SUBST(JDK_VERSION) - -if test "x$MILESTONE" != x; then - RELEASE="${JDK_VERSION}-${MILESTONE}${BUILD_VARIANT_RELEASE}" -else - RELEASE="${JDK_VERSION}${BUILD_VARIANT_RELEASE}" -fi -AC_SUBST(RELEASE) - -if test "x$JDK_BUILD_NUMBER" != x; then - FULL_VERSION="${RELEASE}-${JDK_BUILD_NUMBER}" -else - JDK_BUILD_NUMBER=b00 - BUILD_DATE=`date '+%Y_%m_%d_%H_%M'` - # Avoid [:alnum:] since it depends on the locale. - CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyz0123456789'` - USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvqxyz'` - FULL_VERSION="${RELEASE}-${USER_RELEASE_SUFFIX}-${JDK_BUILD_NUMBER}" -fi -AC_SUBST(FULL_VERSION) -COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'` -AC_SUBST(COOKED_BUILD_NUMBER) - -# Test from where we are running configure, in or outside of src root. -if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" || test "x$CURDIR" = "x$SRC_ROOT/common/makefiles" ; then - # We are running configure from the src root. - # Create a default ./build/host-variant-debuglevel output root. - CONF_NAME="${HOST_OS}-${HOST_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}" - OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}" - mkdir -p "$OUTPUT_ROOT" - if test ! -d "$OUTPUT_ROOT"; then - AC_MSG_ERROR([Could not create build directory $OUTPUT_ROOT]) - fi -else - # We are running configure from outside of the src dir. - # Then use the current directory as output dir! - # If configuration is situated in normal build directory, just use the build - # directory name as configuration name, otherwise use the complete path. - CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"` - OUTPUT_ROOT="$CURDIR" -fi - -SPACESAFE(OUTPUT_ROOT,[the path to the output root]) - -# Save the arguments given to us -echo "$CONFIGURE_COMMAND_LINE" > $OUTPUT_ROOT/configure-arguments - -# Check if the VS env variables were setup prior to running configure. -# If not, then find vcvarsall.bat and run it automatically, and integrate -# the set env variables into the spec file. -SETUPDEVENV="# No special vars" -if test "x$BUILD_OS" = "xwindows"; then - # If vcvarsall.bat has been run, then VCINSTALLDIR is set. - if test "x$VCINSTALLDIR" != x; then - # No further setup is needed. The build will happen from this kind - # of shell. - SETUPDEVENV="# This spec file expects that you are running bash from within a VS command prompt." - # Make sure to remind you, if you forget to run make from a cygwin bash shell - # that is spawned "bash -l" from a VS command prompt. - CHECK_FOR_VCINSTALLDIR=yes - AC_MSG_CHECKING([if you are running from within a VS command prompt]) - AC_MSG_RESULT([yes]) - else - # Ah, we have not yet run vcvarsall.bat/vsvars32.bat/vsvars64.bat. Lets do that. First find it. - if test "x$VS100COMNTOOLS" != x; then - VARSBAT=`find "$VS100COMNTOOLS/../.." -name vcvarsall.bat` - SEARCH_ROOT="$VS100COMNTOOLS" - else - VARSBAT=`find "$PROGRAMFILES" -name vcvarsall.bat` - SEARCH_ROOT="$PROGRAMFILES" - fi - VCPATH=`dirname "$VARSBAT"` - VCPATH=`cygpath -w "$VCPATH"` - if test "x$VARSBAT" = x || test ! -d "$VCPATH"; then - AC_MSG_CHECKING([if we can find the VS installation]) - AC_MSG_RESULT([no]) - AC_MSG_ERROR([Tried to find a VS installation using both $SEARCH_ROOT but failed. Please run "c:\\cygwin\\bin\\bash.exe -l" from a VS command prompt and then run configure/make from there.]) - fi - case "$LEGACY_HOST_CPU1" in - i?86) - VARSBAT_ARCH=x86 - ;; - *) - VARSBAT_ARCH=$LEGACY_HOST_CPU1 - ;; - esac - # Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat - cd $OUTPUT_ROOT - bash $SRC_ROOT/common/bin/extractvcvars.sh "$VARSBAT" "$VARSBAT_ARCH" - cd $CURDIR - if test ! -s $OUTPUT_ROOT/localdevenv.sh || test ! -s $OUTPUT_ROOT/localdevenv.gmk; then - AC_MSG_CHECKING([if we can extract the needed env variables]) - AC_MSG_RESULT([no]) - AC_MSG_ERROR([Could not succesfully extract the env variables needed for the VS setup. Please run "c:\\cygwin\\bin\\bash.exe -l" from a VS command prompt and then run configure/make from there.]) - fi - # Now set all paths and other env variables. This will allow the rest of - # the configure script to find and run the compiler in the proper way. - . $OUTPUT_ROOT/localdevenv.sh - AC_MSG_CHECKING([if we can find the VS installation]) - if test "x$VCINSTALLDIR" != x; then - AC_MSG_RESULT([$VCINSTALLDIR]) - else - AC_MSG_RESULT([no]) - AC_MSG_ERROR([Could not find VS installation. Please install. If you are sure you have installed VS, then please run "c:\\cygwin\\bin\\bash.exe -l" from a VS command prompt and then run configure/make from there.]) - fi - CHECK_FOR_VCINSTALLDIR=no - SETUPDEVENV="include $OUTPUT_ROOT/localdevenv.gmk" - - AC_MSG_CHECKING([for msvcr100.dll]) - AC_ARG_WITH(msvcr100dll, [AS_HELP_STRING([--with-msvcr100dll], - [copy this msvcr100.dll into the built JDK])]) - if test "x$with_msvcr100dll" != x; then - MSVCR100DLL="$with_msvcr100dll" - else - if test "x$HOST_CPU_BITS" = x64; then - MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | grep x64 | head --lines 1` - else - MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | grep x86 | grep -v ia64 | grep -v x64 | head --lines 1` - if test "x$MSVCR100DLL" = x; then - MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | head --lines 1` - fi - fi - fi - if test "x$MSVCR100DLL" = x; then - AC_MSG_RESULT([no]) - AC_MSG_ERROR([Could not find msvcr100.dll !]) - fi - AC_MSG_RESULT([$MSVCR100DLL]) - SPACESAFE(MSVCR100DLL,[the path to msvcr100.dll]) - fi -fi -AC_SUBST(SETUPDEVENV) -AC_SUBST(CHECK_FOR_VCINSTALLDIR) -AC_SUBST(MSVCR100DLL) - -# Most of the probed defines are put into config.h -AC_CONFIG_HEADERS([$OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in]) -# The spec.gmk file contains all variables for the make system. -AC_CONFIG_FILES([$OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in]) -# The generated Makefile knows where the spec.gmk is and where the source is. -# You can run make from the OUTPUT_ROOT. If you have only -# one configured host, then you can also run make from the SRC_ROOT, -# since it will go look for a single spec.gmk file. Or perhaps it -# should instead make all configured hosts it can find? -AC_CONFIG_FILES([$OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in]) - -AC_SUBST(SPEC, $OUTPUT_ROOT/spec.gmk) -AC_SUBST(CONF_NAME, $CONF_NAME) -AC_SUBST(OUTPUT_ROOT, $OUTPUT_ROOT) - -# Where are the sources. Any of these can be overridden -# using --with-override-corba and the likes. -LANGTOOLS_TOPDIR="$SRC_ROOT/langtools" -CORBA_TOPDIR="$SRC_ROOT/corba" -JAXP_TOPDIR="$SRC_ROOT/jaxp" -JAXWS_TOPDIR="$SRC_ROOT/jaxws" -HOTSPOT_TOPDIR="$SRC_ROOT/hotspot" -JDK_TOPDIR="$SRC_ROOT/jdk" -AC_SUBST(LANGTOOLS_TOPDIR) -AC_SUBST(CORBA_TOPDIR) -AC_SUBST(JAXP_TOPDIR) -AC_SUBST(JAXWS_TOPDIR) -AC_SUBST(HOTSPOT_TOPDIR) -AC_SUBST(JDK_TOPDIR) +# Setup builddeps, for automatic downloading of tools we need. +# This is needed before we can call BDEPS_CHECK_MODULE, which is done in +# boot-jdk setup, but we need to have basic tools setup first. +BDEPS_CONFIGURE_BUILDDEPS +BDEPS_SCAN_FOR_BUILDDEPS # Check if pkg-config is available. PKG_PROG_PKG_CONFIG -AC_ARG_WITH(builddeps-conf, [AS_HELP_STRING([--with-builddeps-conf], - [use this configuration file for the builddeps])]) +############################################################################### +# +# Determine OpenJDK build and target platforms. +# +############################################################################### -AC_ARG_WITH(builddeps-server, [AS_HELP_STRING([--with-builddeps-server], - [download and use build dependencies from this server url, e.g. --with-builddeps-server=ftp://example.com/dir])]) +PLATFORM_SETUP_OPENJDK_BUILD_AND_TARGET +PLATFORM_SETUP_OPENJDK_BUILD_OS_VERSION -AC_ARG_WITH(builddeps-dir, [AS_HELP_STRING([--with-builddeps-dir], - [store downloaded build dependencies here @<:@d/localhome/builddeps@:>@])], - [], - [with_builddeps_dir=/localhome/builddeps]) - -AC_ARG_WITH(builddeps-group, [AS_HELP_STRING([--with-builddeps-group], - [chgrp the downloaded build dependencies to this group])]) - -AC_ARG_ENABLE([list-builddeps], [AS_HELP_STRING([--enable-list-builddeps], - [list all build dependencies known to the configure script])], - [LIST_BUILDDEPS="${enableval}"], [LIST_BUILDDEPS='no']) - -if test "x$LIST_BUILDDEPS" = xyes; then - echo - echo List of build dependencies known to the configure script, - echo that can be used in builddeps.conf files: - cat $SRC_ROOT/configure.ac | grep BDEPS_CHECK_MODUL | grep -v configure.ac | cut -f 2 -d ',' | tr -d ' ' | sort - echo - exit 1 -fi - -# If builddeps server or conf file is given. Setup buildeps usage. -BDEPS_SCAN_FOR_BUILDDEPS +# With knowledge of the build platform, setup more basic things. +BASIC_SETUP_PATH_SEP +BASIC_SETUP_SEARCHPATH ############################################################################### # -# Configure the development tool paths and potential sysroot. +# Determine OpenJDK variants, options and version numbers. # -AC_LANG(C++) -DEVKIT= -SYS_ROOT=/ -AC_SUBST(SYS_ROOT) +############################################################################### -# The option used to specify the target .o,.a or .so file. -# When compiling, how to specify the to be created object file. -CC_OUT_OPTION='-o$(SPACE)' -# When linking, how to specify the to be created executable. -EXE_OUT_OPTION='-o$(SPACE)' -# When linking, how to specify the to be created dynamically linkable library. -LD_OUT_OPTION='-o$(SPACE)' -# When archiving, how to specify the to be create static archive for object files. -AR_OUT_OPTION='rcs$(SPACE)' -AC_SUBST(CC_OUT_OPTION) -AC_SUBST(EXE_OUT_OPTION) -AC_SUBST(LD_OUT_OPTION) -AC_SUBST(AR_OUT_OPTION) +# We need build & target for this. +JDKOPT_SETUP_JDK_VARIANT +JDKOPT_SETUP_JVM_VARIANTS +JDKOPT_SETUP_DEBUG_LEVEL +JDKOPT_SETUP_JDK_OPTIONS +JDKOPT_SETUP_JDK_VERSION_NUMBERS -# If --build AND --host is set, then the configure script will find any -# cross compilation tools in the PATH. Cross compilation tools -# follows the cross compilation standard where they are prefixed with ${host}. -# For example the binary i686-sun-solaris2.10-gcc -# will cross compile for i686-sun-solaris2.10 -# If neither of build and host is not set, then build=host and the -# default compiler found in the path will be used. -# Setting only --host, does not seem to be really supported. -# Please set both --build and --host if you want to cross compile. - -DEFINE_CROSS_COMPILE_ARCH="" -HOSTCC="" -HOSTCXX="" -AC_SUBST(DEFINE_CROSS_COMPILE_ARCH) -AC_SUBST(HOST_CC) -AC_SUBST(HOST_CXX) -AC_MSG_CHECKING([if this is a cross compile]) -if test "x$build_var" != "x$host_var"; then - AC_MSG_RESULT([yes, from $build_var to $host_var]) - # We have detected a cross compile! - DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$LEGACY_HOST_CPU1" - # Now we to find a C/C++ compiler that can build executables for the build - # platform. We can't use the AC_PROG_CC macro, since it can only be used - # once. - AC_PATH_PROGS(HOSTCC, [cl cc gcc]) - WHICHCMD(HOSTCC) - AC_PATH_PROGS(HOSTCXX, [cl CC g++]) - WHICHCMD(HOSTCXX) - # Building for the build platform should be easy. Therefore - # we do not need any linkers or assemblers etc. -else - AC_MSG_RESULT([no]) -fi - -# You can force the sys-root if the sys-root encoded into the cross compiler tools -# is not correct. -AC_ARG_WITH(sys-root, [AS_HELP_STRING([--with-sys-root], - [pass this sys-root to the compilers and linker (useful if the sys-root encoded in - the cross compiler tools is incorrect)])]) - -if test "x$with_sys_root" != x; then - SYS_ROOT=$with_sys_root -fi - -# If a devkit is found on the builddeps server, then prepend its path to the -# PATH variable. If there are cross compilers available in the devkit, these -# will be found by AC_PROG_CC et al. -BDEPS_CHECK_MODULE(DEVKIT, devkit, xxx, - [# Found devkit - PATH="$DEVKIT/bin:$PATH" - SYS_ROOT="$DEVKIT/${rewritten_host}/sys-root" - if test "x$x_includes" = "xNONE"; then - x_includes="$SYS_ROOT/usr/include/X11" - fi - if test "x$x_libraries" = "xNONE"; then - x_libraries="$SYS_ROOT/usr/lib" - fi - ], - []) - -if test "x$SYS_ROOT" != "x/" ; then - CFLAGS="--sysroot=$SYS_ROOT $CFLAGS" - CXXFLAGS="--sysroot=$SYS_ROOT $CXXFLAGS" - OBJCFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" - OBJCXXFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" - CPPFLAGS="--sysroot=$SYS_ROOT $CPPFLAGS" - LDFLAGS="--sysroot=$SYS_ROOT $LDFLAGS" -fi - -# Store the CFLAGS etal passed to the configure script. -ORG_CFLAGS="$CFLAGS" -ORG_CXXFLAGS="$CXXFLAGS" -ORG_OBJCFLAGS="$OBJCFLAGS" - -prepare_help_system - -# gcc is almost always present, but on Windows we -# prefer cl.exe and on Solaris we prefer CC. -# Thus test for them in this order. -AC_PROG_CC([cl cc gcc]) -if test "x$CC" = x; then - help_on_build_dependency devkit - AC_MSG_ERROR([Could not find a compiler. $HELP_MSG]) -fi -if test "x$CC" = xcc && test "x$BUILD_OS" = xmacosx; then - # Do not use cc on MacOSX use gcc instead. - CC="gcc" -fi -WHICHCMD(CC) - -AC_PROG_CXX([cl CC g++]) -if test "x$CXX" = xCC && test "x$BUILD_OS" = xmacosx; then - # The found CC, even though it seems to be a g++ derivate, cannot compile - # c++ code. Override. - CXX="g++" -fi -WHICHCMD(CXX) - -if test "x$CXX" = x || test "x$CC" = x; then - help_on_build_dependency devkit - AC_MSG_ERROR([Could not find the needed compilers! $HELP_MSG ]) -fi - -if test "x$BUILD_OS" != xwindows; then - AC_PROG_OBJC - WHICHCMD(OBJC) -else - OBJC= -fi - -# Restore the flags to the user specified values. -# This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2" -CFLAGS="$ORG_CFLAGS" -CXXFLAGS="$ORG_CXXFLAGS" -OBJCFLAGS="$ORG_OBJCFLAGS" - -# If we are not cross compiling, use the same compilers for -# building the build platform executables. -if test "x$DEFINE_CROSS_COMPILE_ARCH" = x; then - HOSTCC="$CC" - HOSTCXX="$CXX" -fi - -AC_CHECK_TOOL(LD, ld) -WHICHCMD(LD) -LD="$CC" -LDEXE="$CC" -LDCXX="$CXX" -LDEXECXX="$CXX" -# LDEXE is the linker to use, when creating executables. -AC_SUBST(LDEXE) -# Linking C++ libraries. -AC_SUBST(LDCXX) -# Linking C++ executables. -AC_SUBST(LDEXECXX) - -AC_CHECK_TOOL(AR, ar) -WHICHCMD(AR) -if test "x$BUILD_OS" = xmacosx; then - ARFLAGS="-r" -else - ARFLAGS="" -fi -AC_SUBST(ARFLAGS) - -COMPILER_NAME=gcc -COMPILER_TYPE=CC -AS_IF([test "x$BUILD_OS" = xwindows], [ - # For now, assume that we are always compiling using cl.exe. - CC_OUT_OPTION=-Fo - EXE_OUT_OPTION=-out: - LD_OUT_OPTION=-out: - AR_OUT_OPTION=-out: - # On Windows, reject /usr/bin/link, which is a cygwin - # program for something completely different. - AC_CHECK_PROG([WINLD], [link],[link],,, [/usr/bin/link]) - # Since we must ignore the first found link, WINLD will contain - # the full path to the link.exe program. - WHICHCMD_SPACESAFE([WINLD]) - LD="$WINLD" - LDEXE="$WINLD" - LDCXX="$WINLD" - LDEXECXX="$WINLD" - - AC_CHECK_PROG([MT], [mt], [mt],,, [/usr/bin/mt]) - WHICHCMD_SPACESAFE([MT]) - # The resource compiler - AC_CHECK_PROG([RC], [rc], [rc],,, [/usr/bin/rc]) - WHICHCMD_SPACESAFE([RC]) - - RC_FLAGS="-nologo /l 0x409 /r" - AS_IF([test "x$VARIANT" = xOPT], [ - RC_FLAGS="$RC_FLAGS -d NDEBUG" - ]) - JDK_UPDATE_VERSION_NOTNULL=$JDK_UPDATE_VERSION - AS_IF([test "x$JDK_UPDATE_VERSION" = x], [ - JDK_UPDATE_VERSION_NOTNULL=0 - ]) - RC_FLAGS="$RC_FLAGS -d \"JDK_BUILD_ID=$FULL_VERSION\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_COMPANY=$COMPANY_NAME\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_COMPONENT=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME binary\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_VER=$JDK_MINOR_VERSION.$JDK_MICRO_VERSION.$JDK_UPDATE_VERSION_NOTNULL.$COOKED_BUILD_NUMBER\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_NAME=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME $JDK_MINOR_VERSION $JDK_UPDATE_META_TAG\"" - RC_FLAGS="$RC_FLAGS -d \"JDK_FVER=$JDK_MINOR_VERSION,$JDK_MICRO_VERSION,$JDK_UPDATE_VERSION_NOTNULL,$COOKED_BUILD_NUMBER\"" - - # lib.exe is used to create static libraries. - AC_CHECK_PROG([WINAR], [lib],[lib],,,) - WHICHCMD_SPACESAFE([WINAR]) - AR="$WINAR" - ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT" - - AC_CHECK_PROG([DUMPBIN], [dumpbin], [dumpbin],,,) - WHICHCMD_SPACESAFE([DUMPBIN]) - - COMPILER_TYPE=CL - CCXXFLAGS="$CCXXFLAGS -nologo" - LDFLAGS="$LDFLAGS -nologo -opt:ref -incremental:no" - if test "x$LEGACY_HOST_CPU1" = xi586; then - LDFLAGS="$LDFLAGS -safeseh" - fi - # TODO: make -debug optional "--disable-full-debug-symbols" - LDFLAGS="$LDFLAGS -debug" -]) -AC_SUBST(RC_FLAGS) -AC_SUBST(COMPILER_TYPE) - -AC_PROG_CPP -WHICHCMD(CPP) - -AC_PROG_CXXCPP -WHICHCMD(CXXCPP) - -# Find the right assembler. -if test "x$BUILD_OS" = xsolaris; then - AC_PATH_PROG(AS, as) - WHICHCMD(AS) - ASFLAGS=" " -else - AS="$CC -c" - ASFLAGS=" " -fi -AC_SUBST(AS) -AC_SUBST(ASFLAGS) - -if test "x$HOST_CPU_BITS" = x32 && test "x$HOST_OS" = xmacosx; then - # On 32-bit MacOSX the OS requires C-entry points to be 16 byte aligned. - # While waiting for a better solution, the current workaround is to use -mstackrealign. - CFLAGS="$CFLAGS -mstackrealign" - AC_MSG_CHECKING([if 32-bit compiler supports -mstackrealign]) - AC_LINK_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])], - [ - AC_MSG_RESULT([yes]) - ], - [ - AC_MSG_RESULT([no]) - AC_MSG_ERROR([The selected compiler $CXX does not support -mstackrealign! Try to put another compiler in the path.]) - ]) -fi - -if test "x$BUILD_OS" = xsolaris; then - AC_PATH_PROG(NM, nm) - WHICHCMD(NM) - AC_PATH_PROG(STRIP, strip) - WHICHCMD(STRIP) - AC_PATH_PROG(MCS, mcs) - WHICHCMD(MCS) -else - AC_CHECK_TOOL(NM, nm) - WHICHCMD(NM) - AC_CHECK_TOOL(STRIP, strip) - WHICHCMD(STRIP) -fi - -# When using cygwin, we need a wrapper binary that renames -# /cygdrive/c/ arguments into c:/ arguments and peeks into -# @files and rewrites these too! This wrapper binary is -# called uncygdrive.exe. -UNCYGDRIVE= -if test "x$BUILD_OS" = xwindows; then - AC_MSG_CHECKING([if uncygdrive can be created]) - UNCYGDRIVE_SRC=`$CYGPATH -m $SRC_ROOT/common/src/uncygdrive.c` - rm -f $OUTPUT_ROOT/uncygdrive* - UNCYGDRIVE=`$CYGPATH -m $OUTPUT_ROOT/uncygdrive.exe` - cd $OUTPUT_ROOT - $CC $UNCYGDRIVE_SRC /Fe$UNCYGDRIVE > $OUTPUT_ROOT/uncygdrive1.log 2>&1 - cd $CURDIR - - if test ! -x $OUTPUT_ROOT/uncygdrive.exe; then - AC_MSG_RESULT([no]) - cat $OUTPUT_ROOT/uncygdrive1.log - AC_MSG_ERROR([Could not create $OUTPUT_ROOT/uncygdrive.exe]) - fi - AC_MSG_RESULT([$UNCYGDRIVE]) - AC_MSG_CHECKING([if uncygdrive.exe works]) - cd $OUTPUT_ROOT - $UNCYGDRIVE $CC $SRC_ROOT/common/src/uncygdrive.c /Fe$OUTPUT_ROOT/uncygdrive2.exe > $OUTPUT_ROOT/uncygdrive2.log 2>&1 - cd $CURDIR - if test ! -x $OUTPUT_ROOT/uncygdrive2.exe; then - AC_MSG_RESULT([no]) - cat $OUTPUT_ROOT/uncygdrive2.log - AC_MSG_ERROR([Uncygdrive did not work!]) - fi - AC_MSG_RESULT([yes]) - rm -f $OUTPUT_ROOT/uncygdrive?.??? $OUTPUT_ROOT/uncygdrive.obj -fi - -AC_SUBST(UNCYGDRIVE) - -TESTFOR_PROG_CCACHE - -# Used on GNU/Linux systems, can be empty... -#AC_PATH_PROG(ELFDUMP, elfdump) - -# Setup default logging of stdout and stderr to build.log in the output root. -BUILD_LOG='$(OUTPUT_ROOT)/build.log' -BUILD_LOG_WRAPPER='$(SH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)' -AC_SUBST(BUILD_LOG) -AC_SUBST(BUILD_LOG_WRAPPER) +# To properly create a configuration name, we need to have the OpenJDK target +# and options (variants and debug level) parsed. +BASIC_SETUP_OUTPUT_DIR ############################################################################### # -# Now we check if libjvm.so will use 32 or 64 bit pointers for the C/C++ code. -# (The JVM can use 32 or 64 bit Java pointers but that decision -# is made at runtime.) +# Setup BootJDK, used to bootstrap the build. # -AC_LANG_PUSH(C++) -OLD_CXXFLAGS="$CXXFLAGS" -if test "x$HOST_OS" = xsolaris && test "x$with_data_model" != x; then - CXXFLAGS="-m{$with_data_model} $CXXFLAGS" -fi -AC_CHECK_SIZEOF([int *], [1111]) -CXXFLAGS="$OLD_CXXFLAGS" -AC_LANG_POP(C++) +############################################################################### -if test "x$ac_cv_sizeof_int_p" = x0; then - # The test failed, lets pick the assumed value. - ARCH_DATA_MODEL=$HOST_CPU_BITS -else - ARCH_DATA_MODEL=`expr 8 \* $ac_cv_sizeof_int_p` -fi - -if test "x$ARCH_DATA_MODEL" = x64; then - A_LP64="LP64:=" - ADD_LP64="-D_LP64=1" -fi -AC_MSG_CHECKING([for host address size]) -AC_MSG_RESULT([$ARCH_DATA_MODEL bits]) -AC_SUBST(LP64,$A_LP64) -AC_SUBST(ARCH_DATA_MODEL) - -if test "x$ARCH_DATA_MODEL" != "x$HOST_CPU_BITS"; then - AC_MSG_ERROR([The tested number of bits in the host ($ARCH_DATA_MODEL) differs from the number of bits expected to be found in the host ($HOST_CPU_BITS)]) -fi +BOOTJDK_SETUP_BOOT_JDK +BOOTJDK_SETUP_BOOT_JDK_ARGUMENTS ############################################################################### # +# Configure the sources to use. We can add or override individual directories. +# +############################################################################### + +SRCDIRS_SETUP_TOPDIRS +SRCDIRS_SETUP_ALTERNATIVE_TOPDIRS +SRCDIRS_SETUP_OUTPUT_DIRS + +############################################################################### +# +# Setup the toolchain (compilers etc), i.e. the tools that need to be +# cross-compilation aware. +# +############################################################################### + +TOOLCHAIN_SETUP_SYSROOT_AND_OUT_OPTIONS +TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV +# Locate the actual tools +TOOLCHAIN_SETUP_PATHS + +# FIXME: Currently we must test this after paths but before flags. Fix! + +# And we can test some aspects on the target using configure macros. +PLATFORM_TEST_OPENJDK_TARGET_BITS +PLATFORM_SETUP_OPENJDK_TARGET_ENDIANNESS + +# Configure flags for the tools +TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_LIBS +TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION +TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_JDK + +# After we have toolchain, we can compile the uncygdrive helper +BASIC_COMPILE_UNCYGDRIVE + + +# Setup debug symbols (need objcopy from the toolchain for that) +JDKOPT_SETUP_DEBUG_SYMBOLS + +############################################################################### +# +# Check dependencies for external and internal libraries. +# +############################################################################### + +LIB_SETUP_INIT +LIB_SETUP_X11 +LIB_SETUP_CUPS +LIB_SETUP_FREETYPE +LIB_SETUP_ALSA +LIB_SETUP_MISC_LIBS +LIB_SETUP_STATIC_LINK_LIBSTDCPP + +############################################################################### +# +# We need to do some final tweaking, when everything else is done. +# +############################################################################### + +JDKOPT_SETUP_BUILD_TWEAKS + +############################################################################### +# +# Configure parts of the build that only affect the build performance, +# not the result. +# +############################################################################### + +BPERF_SETUP_BUILD_CORES +BPERF_SETUP_BUILD_MEMORY + +# Setup smart javac (after cores and memory have been setup) +BPERF_SETUP_SMART_JAVAC + # Can the C/C++ compiler use precompiled headers? -# -AC_ARG_ENABLE([precompiled-headers], [AS_HELP_STRING([--disable-precompiled-headers], - [use precompiled headers when compiling C++ @<:@enabled@:>@])], - [ENABLE_PRECOMPH=${enable_precompiled-headers}], [ENABLE_PRECOMPH=yes]) +BPERF_SETUP_PRECOMPILED_HEADERS -USE_PRECOMPILED_HEADER=1 -if test "x$ENABLE_PRECOMPH" = xno; then - USE_PRECOMPILED_HEADER=0 -fi - -if test "x$ENABLE_PRECOMPH" = xyes; then - # Check that the compiler actually supports precomp headers. - if test "x$GCC" = xyes; then - AC_MSG_CHECKING([that precompiled headers work]) - echo "int alfa();" > conftest.h - $CXX -x c++-header conftest.h -o conftest.hpp.gch - if test ! -f conftest.hpp.gch; then - echo Precompiled header is not working! - USE_PRECOMPILED_HEADER=0 - AC_MSG_RESULT([no]) - else - AC_MSG_RESULT([yes]) - fi - rm -f conftest.h - fi -fi - -AC_SUBST(USE_PRECOMPILED_HEADER) +# Setup use of ccache, if available +BPERF_SETUP_CCACHE ############################################################################### # -# How to compile shared libraries. +# And now the finish... # - -if test "x$GCC" = xyes; then - COMPILER_NAME=gcc - PICFLAG="-fPIC" - LIBRARY_PREFIX=lib - SHARED_LIBRARY='lib$1.so' - STATIC_LIBRARY='lib$1.a' - SHARED_LIBRARY_FLAGS="-shared" - SHARED_LIBRARY_SUFFIX='.so' - STATIC_LIBRARY_SUFFIX='.a' - OBJ_SUFFIX='.o' - EXE_SUFFIX='' - SET_SHARED_LIBRARY_NAME='-Xlinker -soname=$1' - SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=$1' - C_FLAG_REORDER='' - CXX_FLAG_REORDER='' - SET_SHARED_LIBRARY_ORIGIN='-Xlinker -z -Xlinker origin -Xlinker -rpath -Xlinker \$$$$ORIGIN/$1' - LD="$CC" - LDEXE="$CC" - LDCXX="$CXX" - LDEXECXX="$CXX" - # TODO: for embedded set --strip-unneeded - POST_STRIP_CMD="$STRIP -g" - - # Linking is different on MacOSX - if test "x$BUILD_OS" = xmacosx; then - # Might change in the future to clang. - COMPILER_NAME=gcc - SHARED_LIBRARY='lib$1.dylib' - SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG" - SHARED_LIBRARY_SUFFIX='.dylib' - EXE_SUFFIX='' - SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/$1' - SET_SHARED_LIBRARY_MAPFILE='' - SET_SHARED_LIBRARY_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.' - POST_STRIP_CMD="$STRIP -S" - fi -else - if test "x$BUILD_OS" = xsolaris; then - # If it is not gcc, then assume it is the Oracle Solaris Studio Compiler - COMPILER_NAME=ossc - PICFLAG="-KPIC" - LIBRARY_PREFIX=lib - SHARED_LIBRARY='lib$1.so' - STATIC_LIBRARY='lib$1.a' - SHARED_LIBRARY_FLAGS="-G" - SHARED_LIBRARY_SUFFIX='.so' - STATIC_LIBRARY_SUFFIX='.a' - OBJ_SUFFIX='.o' - EXE_SUFFIX='' - SET_SHARED_LIBRARY_NAME='' - SET_SHARED_LIBRARY_MAPFILE='-M $1' - C_FLAG_REORDER='-xF' - CXX_FLAG_REORDER='-xF' - SET_SHARED_LIBRARY_ORIGIN='-R \$$$$ORIGIN/$1' - CFLAGS_JDKLIB_EXTRA='-xstrconst -D__solaris__' - POST_STRIP_CMD="$STRIP -x" - POST_MCS_CMD="$MCS -d -a \"JDK $FULL_VERSION\"" - fi - if test "x$BUILD_OS" = xwindows; then - # If it is not gcc, then assume it is the MS Visual Studio compiler - COMPILER_NAME=cl - PICFLAG="" - LIBRARY_PREFIX= - SHARED_LIBRARY='$1.dll' - STATIC_LIBRARY='$1.lib' - SHARED_LIBRARY_FLAGS="-LD" - SHARED_LIBRARY_SUFFIX='.dll' - STATIC_LIBRARY_SUFFIX='.lib' - OBJ_SUFFIX='.obj' - EXE_SUFFIX='.exe' - SET_SHARED_LIBRARY_NAME='' - SET_SHARED_LIBRARY_MAPFILE='' - SET_SHARED_LIBRARY_ORIGIN='' - fi -fi - -AC_SUBST(OBJ_SUFFIX) -AC_SUBST(SHARED_LIBRARY) -AC_SUBST(STATIC_LIBRARY) -AC_SUBST(LIBRARY_PREFIX) -AC_SUBST(SHARED_LIBRARY_SUFFIX) -AC_SUBST(STATIC_LIBRARY_SUFFIX) -AC_SUBST(EXE_SUFFIX) -AC_SUBST(SHARED_LIBRARY_FLAGS) -AC_SUBST(SET_SHARED_LIBRARY_NAME) -AC_SUBST(SET_SHARED_LIBRARY_MAPFILE) -AC_SUBST(C_FLAG_REORDER) -AC_SUBST(CXX_FLAG_REORDER) -AC_SUBST(SET_SHARED_LIBRARY_ORIGIN) -AC_SUBST(POST_STRIP_CMD) -AC_SUBST(POST_MCS_CMD) - -# The (cross) compiler is now configured, we can now test capabilities -# of the host platform. - -############################################################################### -# -# Is the host little of big endian? -# -AC_C_BIGENDIAN([ENDIAN="big"],[ENDIAN="little"],[ENDIAN="unknown"],[ENDIAN="universal"]) - -if test "x$ENDIAN" = xuniversal; then - AC_MSG_ERROR([It seems like someone needs to decide how we are to deal with universal binaries on the MacOSX?]) -fi -if test "x$ENDIAN" = xunknown; then - ENDIAN="$HOST_CPU_ENDIAN" -fi -if test "x$ENDIAN" != "x$HOST_CPU_ENDIAN"; then - AC_MSG_WARN([The tested endian in the host ($ENDIAN) differs from the endian expected to be found in the host ($HOST_CPU_ENDIAN)]) - ENDIAN="$HOST_CPU_ENDIAN" -fi -AC_SUBST(ENDIAN) - -############################################################################### -# -# We need a Boot JDK to bootstrap the build. -# -BOOT_JDK_FOUND=no -AC_ARG_WITH(boot-jdk, [AS_HELP_STRING([--with-boot-jdk], - [path to Boot JDK (used to bootstrap build) @<:@probed@:>@])]) - -if test "x$with_boot_jdk" != x; then - BOOT_JDK=$with_boot_jdk - BOOT_JDK_FOUND=yes -fi -if test "x$BOOT_JDK_FOUND" = xno; then - BDEPS_CHECK_MODULE(BOOT_JDK, boot-jdk, xxx, [BOOT_JDK_FOUND=yes], [BOOT_JDK_FOUND=no]) -fi - -if test "x$BOOT_JDK_FOUND" = xno; then - if test "x$JAVA_HOME" != x; then - if test ! -d "$JAVA_HOME"; then - AC_MSG_ERROR([Your JAVA_HOME points to a non-existing directory!]) - fi - # Aha, the user has set a JAVA_HOME - # let us use that as the Boot JDK. - BOOT_JDK="$JAVA_HOME" - BOOT_JDK_FOUND=yes - # To be on the safe side, lets check that it is a JDK. - if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then - JAVAC="$BOOT_JDK/bin/javac" - JAVA="$BOOT_JDK/bin/java" - BOOT_JDK_FOUND=yes - else - AC_MSG_ERROR([Your JAVA_HOME points to a JRE! The build needs a JDK! Please point JAVA_HOME to a JDK. JAVA_HOME=[$]JAVA_HOME]) - fi - fi -fi - -if test "x$BOOT_JDK_FOUND" = xno; then - AC_PATH_PROG(JAVAC_CHECK, javac) - AC_PATH_PROG(JAVA_CHECK, java) - BINARY="$JAVAC_CHECK" - if test "x$JAVAC_CHECK" = x; then - BINARY="$JAVA_CHECK" - fi - if test "x$BINARY" != x; then - # So there is a java(c) binary, it might be part of a JDK. - # Lets find the JDK/JRE directory by following symbolic links. - # Linux/GNU systems often have links from /usr/bin/java to - # /etc/alternatives/java to the real JDK binary. - WHICHCMD_SPACESAFE(BINARY,[path to javac]) - REMOVE_SYMBOLIC_LINKS(BINARY) - BOOT_JDK=`dirname $BINARY` - BOOT_JDK=`cd $BOOT_JDK/..; pwd` - if test -x $BOOT_JDK/bin/javac && test -x $BOOT_JDK/bin/java; then - JAVAC=$BOOT_JDK/bin/javac - JAVA=$BOOT_JDK/bin/java - BOOT_JDK_FOUND=yes - fi - fi -fi - -if test "x$BOOT_JDK_FOUND" = xno; then - # Try the MacOSX way. - if test -x /usr/libexec/java_home; then - BOOT_JDK=`/usr/libexec/java_home` - if test -x $BOOT_JDK/bin/javac && test -x $BOOT_JDK/bin/java; then - JAVAC=$BOOT_JDK/bin/javac - JAVA=$BOOT_JDK/bin/java - BOOT_JDK_FOUND=yes - fi - fi -fi - -if test "x$BOOT_JDK_FOUND" = xno; then - AC_PATH_PROG(JAVA_CHECK, java) - if test "x$JAVA_CHECK" != x; then - # There is a java in the path. But apparently we have not found a javac - # in the path, since that would have been tested earlier. - if test "x$HOST_OS" = xwindows; then - # Now if this is a windows platform. The default installation of a JDK - # actually puts the JRE in the path and keeps the JDK out of the path! - # Go look in the default installation location. - BOOT_JDK=/cygdrive/c/Program\ Files/Java/`ls /cygdrive/c/Program\ Files/Java | grep jdk | sort -r | head --lines 1` - if test -d "$BOOT_JDK"; then - BOOT_JDK_FOUND=yes - fi - fi - if test "x$BOOT_JDK_FOUND" = xno; then - help_on_build_dependency openjdk - AC_MSG_ERROR([Found a JRE, not not a JDK! Please remove the JRE from your path and put a JDK there instead. $HELP_MSG]) - fi - else - help_on_build_dependency openjdk - AC_MSG_ERROR([Could not find a JDK. $HELP_MSG]) - fi -fi - -WIN_FIX_PATH(BOOT_JDK) - -# Now see if we can find the rt.jar, or its nearest equivalent. -BOOT_RTJAR="$BOOT_JDK/jre/lib/rt.jar" -SPACESAFE(BOOT_RTJAR,[the path to the Boot JDK rt.jar (or nearest equivalent)]) - -BOOT_TOOLSJAR="$BOOT_JDK/lib/tools.jar" -SPACESAFE(BOOT_TOOLSJAR,[the path to the Boot JDK tools.jar (or nearest equivalent)]) - -if test ! -f $BOOT_RTJAR; then - # On MacOSX it is called classes.jar - BOOT_RTJAR=$BOOT_JDK/../Classes/classes.jar - if test ! -f $BOOT_RTJAR; then - AC_MSG_ERROR([Cannot find the rt.jar or its equivalent!]) - fi - # Remove the .. - BOOT_RTJAR="`cd ${BOOT_RTJAR%/*} && pwd`/${BOOT_RTJAR##*/}" - # The tools.jar is part of classes.jar - BOOT_TOOLSJAR="$BOOT_RTJAR" -fi - -AC_SUBST(BOOT_JDK) -AC_SUBST(BOOT_RTJAR) -AC_SUBST(BOOT_TOOLSJAR) -AC_MSG_CHECKING([for Boot JDK]) -AC_MSG_RESULT([$BOOT_JDK]) -AC_MSG_CHECKING([for Boot rt.jar]) -AC_MSG_RESULT([$BOOT_RTJAR]) -AC_MSG_CHECKING([for Boot tools.jar]) -AC_MSG_RESULT([$BOOT_TOOLSJAR]) - -# Use the java tool from the Boot JDK. -AC_MSG_CHECKING([for java in Boot JDK]) -JAVA=$BOOT_JDK/bin/java -if test ! -x $JAVA; then - AC_MSG_ERROR([Could not find a working java]) -fi -BOOT_JDK_VERSION=`$JAVA -version 2>&1 | head -n 1` -AC_MSG_RESULT([yes $BOOT_JDK_VERSION]) -AC_SUBST(JAVA) - -# Extra M4 quote needed to protect [] in grep expression. -[FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep '\"1\.[78]\.'`] -if test "x$FOUND_VERSION_78" = x; then - help_on_build_dependency openjdk - AC_MSG_ERROR([Your boot-jdk must be version 7 or 8. $HELP_MSG]) -fi - -# When compiling code to be executed by the Boot JDK, force jdk7 compatibility. -BOOT_JDK_SOURCETARGET="-source 7 -target 7" -AC_SUBST(BOOT_JDK_SOURCETARGET) - -# Use the javac tool from the Boot JDK. -AC_MSG_CHECKING([for javac in Boot JDK]) -JAVAC=$BOOT_JDK/bin/javac -if test ! -x $JAVAC; then - AC_MSG_ERROR([Could not find a working javac]) -fi -AC_MSG_RESULT(yes) -AC_SUBST(JAVAC) -AC_SUBST(JAVAC_FLAGS) - -# Use the javah tool from the Boot JDK. -AC_MSG_CHECKING([for javah in Boot JDK]) -JAVAH=$BOOT_JDK/bin/javah -if test ! -x $JAVAH; then - AC_MSG_ERROR([Could not find a working javah]) -fi -AC_MSG_RESULT(yes) -AC_SUBST(JAVAH) - -# Use the jar tool from the Boot JDK. -AC_MSG_CHECKING([for jar in Boot JDK]) -JAR=$BOOT_JDK/bin/jar -if test ! -x $JAR; then - AC_MSG_ERROR([Could not find a working jar]) -fi -AC_SUBST(JAR) -AC_MSG_RESULT(yes) - -# Use the rmic tool from the Boot JDK. -AC_MSG_CHECKING([for rmic in Boot JDK]) -RMIC=$BOOT_JDK/bin/rmic -if test ! -x $RMIC; then - AC_MSG_ERROR([Could not find a working rmic]) -fi -AC_SUBST(RMIC) -AC_MSG_RESULT(yes) - -# Use the native2ascii tool from the Boot JDK. -AC_MSG_CHECKING([for native2ascii in Boot JDK]) -NATIVE2ASCII=$BOOT_JDK/bin/native2ascii -if test ! -x $NATIVE2ASCII; then - AC_MSG_ERROR([Could not find a working native2ascii]) -fi -AC_MSG_RESULT(yes) -AC_SUBST(NATIVE2ASCII) - -############################################################################### -# -# Pickup additional source for a component from outside of the source root -# or override source for a component. -# -AC_ARG_WITH(add-source-root, [AS_HELP_STRING([--with-add-source-root], - [for each and every source directory, look in this additional source root for - the same directory; if it exists and have files in it, include it in the build])]) - -AC_ARG_WITH(override-source-root, [AS_HELP_STRING([--with-override-source-root], - [for each and every source directory, look in this override source root for - the same directory; if it exists, use that directory instead and - ignore the directory in the original source root])]) - -AC_ARG_WITH(adds-and-overrides, [AS_HELP_STRING([--with-adds-and-overrides], - [use the subdirs 'adds' and 'overrides' in the specified directory as - add-source-root and override-source-root])]) - -if test "x$with_adds_and_overrides" != x; then - with_add_source_root="$with_adds_and_overrides/adds" - with_override_source_root="$with_adds_and_overrides/overrides" -fi - -if test "x$with_add_source_root" != x; then - if ! test -d $with_add_source_root; then - AC_MSG_ERROR([Trying to use a non-existant add-source-root $with_add_source_root]) - fi - CURDIR="$PWD" - cd "$with_add_source_root" - ADD_SRC_ROOT="`pwd`" - cd "$CURDIR" - # Verify that the addon source root does not have any root makefiles. - # If it does, then it is usually an error, prevent this. - if test -f $with_add_source_root/langtools/makefiles/Makefile || \ - test -f $with_add_source_root/langtools/make/Makefile; then - AC_MSG_ERROR([Your add source root seems to contain a full langtools repo! An add source root should only contain additional sources.]) - fi - if test -f $with_add_source_root/corba/makefiles/Makefile || \ - test -f $with_add_source_root/corba/make/Makefile; then - AC_MSG_ERROR([Your add source root seems to contain a full corba repo! An add source root should only contain additional sources.]) - fi - if test -f $with_add_source_root/jaxp/makefiles/Makefile || \ - test -f $with_add_source_root/jaxp/make/Makefile; then - AC_MSG_ERROR([Your add source root seems to contain a full jaxp repo! An add source root should only contain additional sources.]) - fi - if test -f $with_add_source_root/jaxws/makefiles/Makefile || \ - test -f $with_add_source_root/jaxws/make/Makefile; then - AC_MSG_ERROR([Your add source root seems to contain a full jaxws repo! An add source root should only contain additional sources.]) - fi - if test -f $with_add_source_root/hotspot/makefiles/Makefile || \ - test -f $with_add_source_root/hotspot/make/Makefile; then - AC_MSG_ERROR([Your add source root seems to contain a full hotspot repo! An add source root should only contain additional sources.]) - fi - if test -f $with_add_source_root/jdk/makefiles/Makefile || \ - test -f $with_add_source_root/jdk/make/Makefile; then - AC_MSG_ERROR([Your add source root seems to contain a full JDK repo! An add source root should only contain additional sources.]) - fi -fi -AC_SUBST(ADD_SRC_ROOT) - -if test "x$with_override_source_root" != x; then - if ! test -d $with_override_source_root; then - AC_MSG_ERROR([Trying to use a non-existant override-source-root $with_override_source_root]) - fi - CURDIR="$PWD" - cd "$with_override_source_root" - OVERRIDE_SRC_ROOT="`pwd`" - cd "$CURDIR" - if test -f $with_override_source_root/langtools/makefiles/Makefile || \ - test -f $with_override_source_root/langtools/make/Makefile; then - AC_MSG_ERROR([Your override source root seems to contain a full langtools repo! An override source root should only contain sources that override.]) - fi - if test -f $with_override_source_root/corba/makefiles/Makefile || \ - test -f $with_override_source_root/corba/make/Makefile; then - AC_MSG_ERROR([Your override source root seems to contain a full corba repo! An override source root should only contain sources that override.]) - fi - if test -f $with_override_source_root/jaxp/makefiles/Makefile || \ - test -f $with_override_source_root/jaxp/make/Makefile; then - AC_MSG_ERROR([Your override source root seems to contain a full jaxp repo! An override source root should only contain sources that override.]) - fi - if test -f $with_override_source_root/jaxws/makefiles/Makefile || \ - test -f $with_override_source_root/jaxws/make/Makefile; then - AC_MSG_ERROR([Your override source root seems to contain a full jaxws repo! An override source root should only contain sources that override.]) - fi - if test -f $with_override_source_root/hotspot/makefiles/Makefile || \ - test -f $with_override_source_root/hotspot/make/Makefile; then - AC_MSG_ERROR([Your override source root seems to contain a full hotspot repo! An override source root should only contain sources that override.]) - fi - if test -f $with_override_source_root/jdk/makefiles/Makefile || \ - test -f $with_override_source_root/jdk/make/Makefile; then - AC_MSG_ERROR([Your override source root seems to contain a full JDK repo! An override source root should only contain sources that override.]) - fi -fi -AC_SUBST(OVERRIDE_SRC_ROOT) - -############################################################################### -# -# Override a repo completely, this is used for example when you have 3 small -# development sandboxes of the langtools sources and want to avoid having 3 full -# OpenJDK sources checked out on disk. -# -# Assuming that the 3 langtools sandboxes are located here: -# /home/fredrik/sandbox1/langtools -# /home/fredrik/sandbox2/langtools -# /home/fredrik/sandbox3/langtools -# -# From the source root you create build subdirs manually: -# mkdir -p build1 build2 build3 -# in each build directory run: -# (cd build1 && ../configure --with-override-langtools=/home/fredrik/sandbox1 && make) -# (cd build2 && ../configure --with-override-langtools=/home/fredrik/sandbox2 && make) -# (cd build3 && ../configure --with-override-langtools=/home/fredrik/sandbox3 && make) -# - -AC_ARG_WITH(override-langtools, [AS_HELP_STRING([--with-override-langtools], - [use this langtools dir for the build])]) - -AC_ARG_WITH(override-corba, [AS_HELP_STRING([--with-override-corba], - [use this corba dir for the build])]) - -AC_ARG_WITH(override-jaxp, [AS_HELP_STRING([--with-override-jaxp], - [use this jaxp dir for the build])]) - -AC_ARG_WITH(override-jaxws, [AS_HELP_STRING([--with-override-jaxws], - [use this jaxws dir for the build])]) - -AC_ARG_WITH(override-hotspot, [AS_HELP_STRING([--with-override-hotspot], - [use this hotspot dir for the build])]) - -AC_ARG_WITH(override-jdk, [AS_HELP_STRING([--with-override-jdk], - [use this jdk dir for the build])]) - -if test "x$with_override_langtools" != x; then - CURDIR="$PWD" - cd "$with_override_langtools" - LANGTOOLS_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $LANGTOOLS_TOPDIR/makefiles/Makefile; then - AC_MSG_ERROR([You have to override langtools with a full langtools repo!]) - fi - AC_MSG_CHECKING([if langtools should be overridden]) - AC_MSG_RESULT([yes with $LANGTOOLS_TOPDIR]) -fi -if test "x$with_override_corba" != x; then - CURDIR="$PWD" - cd "$with_override_corba" - CORBA_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $CORBA_TOPDIR/makefiles/Makefile; then - AC_MSG_ERROR([You have to override corba with a full corba repo!]) - fi - AC_MSG_CHECKING([if corba should be overridden]) - AC_MSG_RESULT([yes with $CORBA_TOPDIR]) -fi -if test "x$with_override_jaxp" != x; then - CURDIR="$PWD" - cd "$with_override_jaxp" - JAXP_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $JAXP_TOPDIR/makefiles/Makefile; then - AC_MSG_ERROR([You have to override jaxp with a full jaxp repo!]) - fi - AC_MSG_CHECKING([if jaxp should be overridden]) - AC_MSG_RESULT([yes with $JAXP_TOPDIR]) -fi -if test "x$with_override_jaxws" != x; then - CURDIR="$PWD" - cd "$with_override_jaxws" - JAXWS_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $JAXWS_TOPDIR/makefiles/Makefile; then - AC_MSG_ERROR([You have to override jaxws with a full jaxws repo!]) - fi - AC_MSG_CHECKING([if jaxws should be overridden]) - AC_MSG_RESULT([yes with $JAXWS_TOPDIR]) -fi -if test "x$with_override_hotspot" != x; then - CURDIR="$PWD" - cd "$with_override_hotspot" - HOTSPOT_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $HOTSPOT_TOPDIR/make/Makefile && \ - ! test -f $HOTSPOT_TOPDIR/makefiles/Makefile; then - AC_MSG_ERROR([You have to override hotspot with a full hotspot repo!]) - fi - AC_MSG_CHECKING([if hotspot should be overridden]) - AC_MSG_RESULT([yes with $HOTSPOT_TOPDIR]) -fi -if test "x$with_override_jdk" != x; then - CURDIR="$PWD" - cd "$with_override_jdk" - JDK_TOPDIR="`pwd`" - cd "$CURDIR" - if ! test -f $JDK_TOPDIR/makefiles/Makefile; then - AC_MSG_ERROR([You have to override JDK with a full JDK repo!]) - fi - AC_MSG_CHECKING([if JDK should be overridden]) - AC_MSG_RESULT([yes with $JDK_TOPDIR]) -fi - -############################################################################### -# -# Specify options for anything that is run with the Boot JDK. -# -AC_ARG_WITH(boot-jdk-jvmargs, [AS_HELP_STRING([--with-boot-jdk-jvmargs], - [specify JVM arguments to be passed to all invocations of the Boot JDK, overriding the default values, - e.g --with-boot-jdk-jvmargs="-Xmx8G -enableassertions"])]) - -if test "x$with_boot_jdk_jvmargs" = x; then - # Not all JVM:s accept the same arguments on the command line. - # OpenJDK specific increase in thread stack for JDK build, - # well more specifically, when running javac. - if test "x$BUILD_NUM_BITS" = x32; then - STACK_SIZE=768 - else - # Running Javac on a JVM on a 64-bit machine, the stack takes more space - # since 64-bit pointers are pushed on the stach. Apparently, we need - # to increase the stack space when javacing the JDK.... - STACK_SIZE=1536 - fi - - # Minimum amount of heap memory. - ADD_JVM_ARG_IF_OK([-Xms64M],boot_jdk_jvmargs,[$JAVA]) - if test "x$HOST_OS" = "xmacosx"; then - # Why does macosx need more heap? Its the huge JDK batch. - ADD_JVM_ARG_IF_OK([-Xmx1600M],boot_jdk_jvmargs,[$JAVA]) - else - ADD_JVM_ARG_IF_OK([-Xmx1100M],boot_jdk_jvmargs,[$JAVA]) - fi - # When is adding -client something that speeds up the JVM? - # ADD_JVM_ARG_IF_OK([-client],boot_jdk_jvmargs,[$JAVA]) - ADD_JVM_ARG_IF_OK([-XX:PermSize=32m],boot_jdk_jvmargs,[$JAVA]) - ADD_JVM_ARG_IF_OK([-XX:MaxPermSize=160m],boot_jdk_jvmargs,[$JAVA]) - ADD_JVM_ARG_IF_OK([-XX:ThreadStackSize=$STACK_SIZE],boot_jdk_jvmargs,[$JAVA]) - # Disable special log output when a debug build is used as Boot JDK... - ADD_JVM_ARG_IF_OK([-XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput],boot_jdk_jvmargs,[$JAVA]) -fi - -AC_SUBST(BOOT_JDK_JVMARGS, $boot_jdk_jvmargs) - -AC_ARG_WITH(server-java, [AS_HELP_STRING([--with-server-java], - [use this java binary for running the javac background server and other long running java tasks in the build process, - e.g. ---with-server-java="/opt/jrockit/bin/java -server"])]) - -if test "x$with_server_java" != x; then - SERVER_JAVA="$with_server_java" - FOUND_VERSION=`$SERVER_JAVA -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" = x; then - AC_MSG_ERROR([Could not execute server java: $SERVER_JAVA]) - fi -else - SERVER_JAVA="" - # Hotspot specific options. - ADD_JVM_ARG_IF_OK([-XX:+UseParallelOldGC],SERVER_JAVA,[$JAVA]) - ADD_JVM_ARG_IF_OK([-verbosegc],SERVER_JAVA,[$JAVA]) - # JRockit specific options. - ADD_JVM_ARG_IF_OK([-Xverbose:gc],SERVER_JAVA,[$JAVA]) - SERVER_JAVA="$JAVA $SERVER_JAVA" -fi -AC_SUBST(SERVER_JAVA) - -AC_MSG_CHECKING([whether to use shared server for javac]) -AC_ARG_ENABLE([javac-server], [AS_HELP_STRING([--enable-javac-server], - [enable the shared javac server during the build process @<:@disabled@:>@])], - [ENABLE_JAVAC_SERVER="${enableval}"], [ENABLE_JAVAC_SERVER='no']) -AC_MSG_RESULT([$ENABLE_JAVAC_SERVER]) -if test "x$ENABLE_JAVAC_SERVER" = xyes; then - JAVAC_USE_REMOTE=true - JAVAC_SERVERS="$OUTPUT_ROOT/javacservers" -else - JAVAC_USE_REMOTE=false - JAVAC_SERVERS= -fi -AC_SUBST(JAVAC_USE_REMOTE) -AC_SUBST(JAVAC_SERVERS) - -AC_ARG_WITH(javac-server-cores, [AS_HELP_STRING([--with-javac-server-cores], - [use at most this number of concurrent threads on the javac server @<:@probed@:>@])]) -if test "x$with_javac_server_cores" != x; then - JAVAC_SERVER_CORES="$with_javac_server_cores" -else - if test "$NUM_CORES" -gt 16; then - # We set this arbitrary limit because we want to limit the heap - # size of the javac server. - # In the future we will make the javac compilers in the server - # share more and more state, thus enabling us to use more and - # more concurrent threads in the server. - JAVAC_SERVER_CORES="16" - else - JAVAC_SERVER_CORES="$NUM_CORES" - fi - - if test "$MEMORY_SIZE" -gt "17000"; then - MAX_HEAP_MEM=10000 - ADD_JVM_ARG_IF_OK([-d64],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xms10G -Xmx10G],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xmn2G],SERVER_JAVA,[$SERVER_JAVA]) - elif test "$MEMORY_SIZE" -gt "10000"; then - MAX_HEAP_MEM=6000 - ADD_JVM_ARG_IF_OK([-d64],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xms6G -Xmx6G],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xmn1G],SERVER_JAVA,[$SERVER_JAVA]) - elif test "$MEMORY_SIZE" -gt "5000"; then - MAX_HEAP_MEM=3000 - ADD_JVM_ARG_IF_OK([-d64],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xms1G -Xmx3G],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xmn256M],SERVER_JAVA,[$SERVER_JAVA]) - elif test "$MEMORY_SIZE" -gt "3800"; then - MAX_HEAP_MEM=2500 - ADD_JVM_ARG_IF_OK([-Xms1G -Xmx2500M],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xmn256M],SERVER_JAVA,[$SERVER_JAVA]) - elif test "$MEMORY_SIZE" -gt "1900"; then - MAX_HEAP_MEM=1200 - ADD_JVM_ARG_IF_OK([-Xms700M -Xmx1200M],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xmn256M],SERVER_JAVA,[$SERVER_JAVA]) - elif test "$MEMORY_SIZE" -gt "1000"; then - MAX_HEAP_MEM=900 - ADD_JVM_ARG_IF_OK([-Xms400M -Xmx900M],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xmn128M],SERVER_JAVA,[$SERVER_JAVA]) - else - MAX_HEAP_MEM=512 - ADD_JVM_ARG_IF_OK([-Xms256M -Xmx512M],SERVER_JAVA,[$SERVER_JAVA]) - ADD_JVM_ARG_IF_OK([-Xmn128M],SERVER_JAVA,[$SERVER_JAVA]) - fi - - MAX_COMPILERS_IN_HEAP=`expr $MAX_HEAP_MEM / 501` - if test "$JAVAC_SERVER_CORES" -gt "$MAX_COMPILERS_IN_HEAP"; then - AC_MSG_CHECKING([if number of server cores must be reduced]) - JAVAC_SERVER_CORES="$MAX_COMPILERS_IN_HEAP" - AC_MSG_RESULT([yes, to $JAVAC_SERVER_CORES with max heap size $MAX_HEAP_MEM MB]) - fi -fi -AC_SUBST(JAVAC_SERVER_CORES) - -AC_MSG_CHECKING([whether to track dependencies between Java packages]) -AC_ARG_ENABLE([javac-deps], [AS_HELP_STRING([--enable-javac-deps], - [enable the dependency tracking between Java packages @<:@disabled@:>@])], - [ENABLE_JAVAC_DEPS="${enableval}"], [ENABLE_JAVAC_DEPS='no']) -AC_MSG_RESULT([$ENABLE_JAVAC_DEPS]) -if test "x$ENABLE_JAVAC_DEPS" = xyes; then - JAVAC_USE_DEPS=true -else - JAVAC_USE_DEPS=false -fi -AC_SUBST(JAVAC_USE_DEPS) - -AC_MSG_CHECKING([whether to use multiple cores for javac compilation]) -AC_ARG_ENABLE([javac-multi-core], [AS_HELP_STRING([--enable-javac-multi-core], - [compile Java packages concurrently @<:@disabled@:>@])], - [ENABLE_JAVAC_MULTICORE="${enableval}"], [ENABLE_JAVAC_MULTICORE='no']) -AC_MSG_RESULT([$ENABLE_JAVAC_MULTICORE]) -if test "x$ENABLE_JAVAC_MULTICORE" = xyes; then - JAVAC_USE_MODE=MULTI_CORE_CONCURRENT -else - JAVAC_USE_MODE=SINGLE_THREADED_BATCH - if test "x$ENABLE_JAVAC_DEPS" = xyes; then - AC_MSG_WARN([Dependency tracking is not supported with single threaded batch compiles of Java source roots. Please add --disable-javac-deps to your configure options.]) - AC_MSG_WARN([Disabling dependency tracking for you now.]) - JAVAC_USE_DEPS=false - fi - if test "x$ENABLE_JAVAC_SERVER" = xyes; then - AC_MSG_WARN([The javac server will not be used since single threaded batch compiles are run within their own JVM. Please add --disable-javac-server to your configure options.]) - AC_MSG_WARN([Disabling javac server for you now.]) - JAVAC_USE_REMOTE=false - fi -fi -AC_SUBST(JAVAC_USE_MODE) - -############################################################################### -# -# OS specific settings that we never will need to probe. -# -if test "x$HOST_OS" = xlinux; then - AC_MSG_CHECKING([what is not needed on Linux?]) - PULSE_NOT_NEEDED=yes - AC_MSG_RESULT([pulse]) -fi - -if test "x$HOST_OS" = xsolaris; then - AC_MSG_CHECKING([what is not needed on Solaris?]) - ALSA_NOT_NEEDED=yes - PULSE_NOT_NEEDED=yes - AC_MSG_RESULT([alsa pulse]) -fi - -if test "x$HOST_OS" = xwindows; then - AC_MSG_CHECKING([what is not needed on Windows?]) - CUPS_NOT_NEEDED=yes - ALSA_NOT_NEEDED=yes - PULSE_NOT_NEEDED=yes - X11_NOT_NEEDED=yes - AC_MSG_RESULT([alsa cups pulse x11]) -fi - -if test "x$HOST_OS" = xmacosx; then - AC_MSG_CHECKING([what is not needed on MacOSX?]) - ALSA_NOT_NEEDED=yes - PULSE_NOT_NEEDED=yes - X11_NOT_NEEDED=yes - FREETYPE2_NOT_NEEDED=yes - # If the java runtime framework is disabled, then we need X11. - # This will be adjusted below. - AC_MSG_RESULT([alsa pulse x11]) -fi - -if test "x$HOST_OS" = xbsd; then - AC_MSG_CHECKING([what is not needed on bsd?]) - ALSA_NOT_NEEDED=yes - AC_MSG_RESULT([alsa]) -fi - -############################################################################### -# -# Check for MacOSX support for OpenJDK. If this exists, try to build a JVM -# that uses this API. -# -AC_ARG_ENABLE([macosx-runtime-support], [AS_HELP_STRING([--disable-macosx-runtime-support], - [disable the use of MacOSX Java runtime support framework @<:@enabled@:>@])], - [MACOSX_RUNTIME_SUPPORT="${enableval}"],[MACOSX_RUNTIME_SUPPORT="no"]) - -USE_MACOSX_RUNTIME_SUPPORT=no -AC_MSG_CHECKING([for explicit Java runtime support in the OS]) -if test -f /System/Library/Frameworks/JavaVM.framework/Frameworks/JavaRuntimeSupport.framework/Headers/JavaRuntimeSupport.h; then - if test "x$MACOSX_RUNTIME_SUPPORT" != xno; then - MACOSX_RUNTIME_SUPPORT=yes - USE_MACOSX_RUNTIME_SUPPORT=yes - AC_MSG_RESULT([yes, does not need alsa freetype2 pulse and X11]) - else - AC_MSG_RESULT([yes, but explicitly disabled.]) - fi -else - AC_MSG_RESULT([no]) -fi - -if test "x$HOST_OS" = xmacosx && test "x$USE_MACOSX_RUNTIME_SUPPORT" = xno; then - AC_MSG_CHECKING([what is not needed on an X11 build on MacOSX?]) - X11_NOT_NEEDED= - FREETYPE2_NOT_NEEDED= - AC_MSG_RESULT([alsa pulse]) -fi - -############################################################################### -# -# Check for X Windows -# -AC_PATH_XTRA - -if test "x$no_x" = xyes && test "x$X11_NOT_NEEDED" != xyes; then - help_on_build_dependency x11 - AC_MSG_ERROR([Could not find X11 libraries. $HELP_MSG]) -fi - -# Some of the old makefiles require a setting of OPENWIN_HOME -# Since the X11R6 directory has disappeared on later Linuxes, -# we need to probe for it. -if test "x$HOST_OS" = xlinux; then - if test -d "$SYS_ROOT/usr/X11R6"; then - OPENWIN_HOME="$SYS_ROOT/usr/X11R6" - fi - if test -d "$SYS_ROOT/usr/include/X11"; then - OPENWIN_HOME="$SYS_ROOT/usr" - fi -fi -if test "x$HOST_OS" = xsolaris; then - OPENWIN_HOME="/usr/openwin" -fi -AC_SUBST(OPENWIN_HOME) - - -# -# Weird Sol10 something check...TODO change to try compile -# -if test "x${HOST_OS}" = xsolaris; then - if test "`uname -r`" = "5.10"; then - if test "`${EGREP} -c XLinearGradient ${OPENWIN_HOME}/share/include/X11/extensions/Xrender.h`" = "0"; then - X_CFLAGS="${X_CFLAGS} -DSOLARIS10_NO_XRENDER_STRUCTS" - fi - fi -fi - -AC_LANG_PUSH(C) -OLD_CFLAGS="$CFLAGS" -CFLAGS="$CFLAGS $X_CFLAGS" -AC_CHECK_HEADERS([X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h], - [X11_A_OK=yes], - [X11_A_OK=no]) -CFLAGS="$OLD_CFLAGS" -AC_LANG_POP(C) - -if test "x$X11_A_OK" = xno && test "x$X11_NOT_NEEDED" != xyes; then - help_on_build_dependency x11 - AC_MSG_ERROR([Could not find all X11 headers (shape.h Xrender.h XTest.h). $HELP_MSG]) -fi - -AC_SUBST(X_CFLAGS) -AC_SUBST(X_LIBS) - -############################################################################### -# -# The common unix printing system cups is used to print from java. -# -AC_ARG_WITH(cups, [AS_HELP_STRING([--with-cups], - [specify prefix directory for the cups package - (expecting the libraries under PATH/lib and the headers under PATH/include)])]) -AC_ARG_WITH(cups-include, [AS_HELP_STRING([--with-cups-include], - [specify directory for the cups include files])]) -AC_ARG_WITH(cups-lib, [AS_HELP_STRING([--with-cups-lib], - [specify directory for the cups library])]) - -if test "x$CUPS_NOT_NEEDED" = xyes; then - if test "x${with_cups}" != x || test "x${with_cups_include}" != x || test "x${with_cups_lib}" != x; then - AC_MSG_WARN([cups not used, so --with-cups is ignored]) - fi - CUPS_CFLAGS= - CUPS_LIBS= -else - CUPS_FOUND=no - - if test "x${with_cups}" = xno || test "x${with_cups_include}" = xno || test "x${with_cups_lib}" = xno; then - AC_MSG_ERROR([It is not possible to disable the use of cups. Remove the --without-cups option.]) - fi - - if test "x${with_cups}" != x; then - CUPS_LIBS="-L${with_cups}/lib -lcups" - CUPS_CFLAGS="-I${with_cups}/include" - CUPS_FOUND=yes - fi - if test "x${with_cups_include}" != x; then - CUPS_CFLAGS="-I${with_cups_include}" - CUPS_FOUND=yes - fi - if test "x${with_cups_lib}" != x; then - CUPS_LIBS="-L${with_cups_lib} -lcups" - CUPS_FOUND=yes - fi - if test "x$CUPS_FOUND" = xno; then - BDEPS_CHECK_MODULE(CUPS, cups, xxx, [CUPS_FOUND=yes]) - fi - if test "x$CUPS_FOUND" = xno; then - # Are the cups headers installed in the default /usr/include location? - AC_CHECK_HEADERS([cups/cups.h cups/ppd.h], - [CUPS_FOUND=yes - CUPS_CFLAGS= - CUPS_LIBS="-lcups" - DEFAULT_CUPS=yes]) - fi - if test "x$CUPS_FOUND" = xno; then - # Getting nervous now? Lets poke around for standard Solaris third-party - # package installation locations. - AC_MSG_CHECKING([for cups headers and libs]) - if test -s /opt/sfw/cups/include/cups/cups.h; then - # An SFW package seems to be installed! - CUPS_FOUND=yes - CUPS_CFLAGS="-I/opt/sfw/cups/include" - CUPS_LIBS="-L/opt/sfw/cups/lib -lcups" - elif test -s /opt/csw/include/cups/cups.h; then - # A CSW package seems to be installed! - CUPS_FOUND=yes - CUPS_CFLAGS="-I/opt/csw/include" - CUPS_LIBS="-L/opt/csw/lib -lcups" - fi - AC_MSG_RESULT([$CUPS_FOUND]) - fi - if test "x$CUPS_FOUND" = xno; then - help_on_build_dependency cups - AC_MSG_ERROR([Could not find cups! $HELP_MSG ]) - fi -fi - -AC_SUBST(CUPS_CFLAGS) -AC_SUBST(CUPS_LIBS) - -############################################################################### -# -# The ubiquitous freetype2 library is used to render fonts. -# -AC_ARG_WITH(freetype, [AS_HELP_STRING([--with-freetype], - [specify prefix directory for the freetype2 package - (expecting the libraries under PATH/lib and the headers under PATH/include)])]) - -# If we are using the OS installed system lib for freetype, then we do not need to copy it to the build tree -USING_SYSTEM_FT_LIB=false - -if test "x$FREETYPE2_NOT_NEEDED" = xyes; then - if test "x$with_freetype" != x || test "x$with_freetype_include" != x || test "x$with_freetype_lib" != x; then - AC_MSG_WARN([freetype not used, so --with-freetype is ignored]) - fi - FREETYPE2_CFLAGS= - FREETYPE2_LIBS= - FREETYPE2_LIB_PATH= -else - FREETYPE2_FOUND=no - - if test "x$with_freetype" != x; then - SPACESAFE(with_freetype,[the path to freetype]) - FREETYPE2_LIBS="-L$with_freetype/lib -lfreetype" - if test "x$HOST_OS" = xwindows; then - FREETYPE2_LIBS="$with_freetype/lib/freetype.lib" - fi - FREETYPE2_LIB_PATH="$with_freetype/lib" - FREETYPE2_CFLAGS="-I$with_freetype/include" - if test -s $with_freetype/include/ft2build.h && test -d $with_freetype/include/freetype2/freetype; then - FREETYPE2_CFLAGS="-I$with_freetype/include/freetype2 -I$with_freetype/include" - fi - FREETYPE2_FOUND=yes - if test "x$FREETYPE2_FOUND" = xyes; then - # Verify that the directories exist - if ! test -d "$with_freetype/lib" || ! test -d "$with_freetype/include"; then - AC_MSG_ERROR([Could not find the expected directories $with_freetype/lib and $with_freetype/include]) - fi - # List the contents of the lib. - FREETYPELIB=`ls $with_freetype/lib/libfreetype.so $with_freetype/lib/freetype.dll 2> /dev/null` - if test "x$FREETYPELIB" = x; then - AC_MSG_ERROR([Could not find libfreetype.se nor freetype.dll in $with_freetype/lib]) - fi - # Check one h-file - if ! test -s "$with_freetype/include/ft2build.h"; then - AC_MSG_ERROR([Could not find $with_freetype/include/ft2build.h]) - fi - fi - fi - if test "x$FREETYPE2_FOUND" = xno; then - BDEPS_CHECK_MODULE(FREETYPE2, freetype2, xxx, [FREETYPE2_FOUND=yes], [FREETYPE2_FOUND=no]) - USING_SYSTEM_FT_LIB=true - fi - if test "x$FREETYPE2_FOUND" = xno; then - PKG_CHECK_MODULES(FREETYPE2, freetype2, [FREETYPE2_FOUND=yes], [FREETYPE2_FOUND=no]) - USING_SYSTEM_FT_LIB=true - fi - if test "x$FREETYPE2_FOUND" = xno; then - AC_MSG_CHECKING([for freetype in some standard locations]) - - if test -s /usr/X11/include/ft2build.h && test -d /usr/X11/include/freetype2/freetype; then - DEFAULT_FREETYPE_CFLAGS="-I/usr/X11/include/freetype2 -I/usr/X11/include" - DEFAULT_FREETYPE_LIBS="-L/usr/X11/lib -lfreetype" - fi - if test -s /usr/include/ft2build.h && test -d /usr/include/freetype2/freetype; then - DEFAULT_FREETYPE_CFLAGS="-I/usr/include/freetype2" - DEFAULT_FREETYPE_LIBS="-lfreetype" - fi - - PREV_CXXCFLAGS="$CXXFLAGS" - PREV_LDFLAGS="$LDFLAGS" - CXXFLAGS="$CXXFLAGS $DEFAULT_FREETYPE_CFLAGS" - LDFLAGS="$LDFLAGS $DEFAULT_FREETYPE_LIBS" - AC_LINK_IFELSE([AC_LANG_SOURCE([[#include - #include FT_FREETYPE_H - int main() { return 0; } - ]])], - [ - # Yes, the default cflags and libs did the trick. - FREETYPE2_FOUND=yes - FREETYPE2_CFLAGS="$DEFAULT_FREETYPE_CFLAGS" - FREETYPE2_LIBS="$DEFAULT_FREETYPE_LIBS" - ], - [ - FREETYPE2_FOUND=no - ]) - CXXCFLAGS="$PREV_CXXFLAGS" - LDFLAGS="$PREV_LDFLAGS" - AC_MSG_RESULT([$FREETYPE2_FOUND]) - USING_SYSTEM_FT_LIB=true - fi - if test "x$FREETYPE2_FOUND" = xno; then - help_on_build_dependency freetype2 - AC_MSG_ERROR([Could not find freetype2! $HELP_MSG ]) - fi -fi - -AC_SUBST(USING_SYSTEM_FT_LIB) -AC_SUBST(FREETYPE2_LIB_PATH) -AC_SUBST(FREETYPE2_CFLAGS) -AC_SUBST(FREETYPE2_LIBS) - -############################################################################### -# -# Check for alsa headers and libraries. Used on Linux/GNU systems. -# -AC_ARG_WITH(alsa, [AS_HELP_STRING([--with-alsa], - [specify prefix directory for the alsa package - (expecting the libraries under PATH/lib and the headers under PATH/include)])]) -AC_ARG_WITH(alsa-include, [AS_HELP_STRING([--with-alsa-include], - [specify directory for the alsa include files])]) -AC_ARG_WITH(alsa-lib, [AS_HELP_STRING([--with-alsa-lib], - [specify directory for the alsa library])]) - -if test "x$ALSA_NOT_NEEDED" = xyes; then - if test "x${with_alsa}" != x || test "x${with_alsa_include}" != x || test "x${with_alsa_lib}" != x; then - AC_MSG_WARN([alsa not used, so --with-alsa is ignored]) - fi - ALSA_CFLAGS= - ALSA_LIBS= -else - ALSA_FOUND=no - - if test "x${with_alsa}" = xno || test "x${with_alsa_include}" = xno || test "x${with_alsa_lib}" = xno; then - AC_MSG_ERROR([It is not possible to disable the use of alsa. Remove the --without-alsa option.]) - fi - - if test "x${with_alsa}" != x; then - ALSA_LIBS="-L${with_alsa}/lib -lalsa" - ALSA_CFLAGS="-I${with_alsa}/include" - ALSA_FOUND=yes - fi - if test "x${with_alsa_include}" != x; then - ALSA_CFLAGS="-I${with_alsa_include}" - ALSA_FOUND=yes - fi - if test "x${with_alsa_lib}" != x; then - ALSA_LIBS="-L${with_alsa_lib} -lalsa" - ALSA_FOUND=yes - fi - if test "x$ALSA_FOUND" = xno; then - BDEPS_CHECK_MODULE(ALSA, alsa, xxx, [ALSA_FOUND=yes], [ALSA_FOUND=no]) - fi - if test "x$ALSA_FOUND" = xno; then - PKG_CHECK_MODULES(ALSA, alsa, [ALSA_FOUND=yes], [ALSA_FOUND=no]) - fi - if test "x$ALSA_FOUND" = xno; then - AC_CHECK_HEADERS([alsa/asoundlib.h], - [ALSA_FOUND=yes - ALSA_CFLAGS=-Iignoreme - ALSA_LIBS=-lasound - DEFAULT_ALSA=yes], - [ALSA_FOUND=no]) - fi - if test "x$ALSA_FOUND" = xno; then - help_on_build_dependency alsa - AC_MSG_ERROR([Could not find alsa! $HELP_MSG ]) - fi -fi - -AC_SUBST(ALSA_CFLAGS) -AC_SUBST(ALSA_LIBS) - -############################################################################### -# -# Check for pulse audio headers and libraries. -# -PULSE_FOUND=no -AC_ARG_WITH(pulse, [AS_HELP_STRING([--with-pulse], - [specify prefix directory for the pulseaudio package - (expecting the libraries under PATH/lib and the headers under PATH/include)])]) -AC_ARG_WITH(pulse-include, [AS_HELP_STRING([--with-pulse-include], - [specify directory for the pulseaudio include files])]) -AC_ARG_WITH(pulse-lib, [AS_HELP_STRING([--with-pulse-lib], - [specify directory for the pulseaudio library])]) - -if test "x${with_pulse}" != x; then - PULSE_LIBS="-L${with_pulse}/lib -lfreetype" - PULSE_CFLAGS="-I${with_pulse}/include" - PULSE_FOUND=yes -fi -if test "x${with_pulse_include}" != x; then - PULSE_CFLAGS="-I${with_pulse_include}" - PULSE_FOUND=yes -fi -if test "x${with_pulse_lib}" != x; then - PULSE_LIBS="-L${with_pulse_lib} -lpulse" - PULSE_FOUND=yes -fi -if test "x$PULSE_FOUND" = xno; then - BDEPS_CHECK_MODULE(PULSE, pulse, xxx, [PULSE_FOUND=yes], [PULSE_FOUND=no]) -fi -if test "x$PULSE_FOUND" = xno; then - PKG_CHECK_MODULES(LIBPULSE,[libpulse >= 0.9.11],[PULSE_FOUND=yes],[PULSE_FOUND=no]) -fi -if test "x$PULSE_FOUND" = xno; then - AC_CHECK_HEADERS([pulse/pulseaudio.h], - [PULSE_FOUND=yes - PULSE_CFLAGS=-Iignoreme - PULSE_LIBS= - DEFAULT_PULSE=yes], - [PULSE_FOUND=no]) -fi - -if test "x$PULSE_FOUND" = xno && test "x$PULSE_NOT_NEEDED" != xyes; then - help_on_build_dependency pulse - AC_MSG_ERROR([Could not find pulse audio libraries. $HELP_MSG ]) -fi - -AC_SUBST(PULSE_CFLAGS) -AC_SUBST(PULSE_LIBS) - -############################################################################### -# -# Check for the jpeg library -# - -USE_EXTERNAL_LIBJPEG=true -AC_CHECK_LIB(jpeg, main, [], - [ USE_EXTERNAL_LIBJPEG=false - AC_MSG_NOTICE([Will use jpeg decoder bundled with the OpenJDK source]) - ]) -AC_SUBST(USE_EXTERNAL_LIBJPEG) - -############################################################################### -# -# Check for the gif library -# - -USE_EXTERNAL_LIBJPEG=true -AC_CHECK_LIB(gif, main, [], - [ USE_EXTERNAL_LIBGIF=false - AC_MSG_NOTICE([Will use gif decoder bundled with the OpenJDK source]) - ]) -AC_SUBST(USE_EXTERNAL_LIBGIF) - -############################################################################### -# -# Check for the zlib library -# - -USE_EXTERNAL_LIBZ=true -AC_CHECK_LIB(z, main, [], - [ USE_EXTERNAL_LIBZ=false - AC_MSG_NOTICE([Will use zlib bundled with the OpenJDK source]) - ]) -AC_SUBST(USE_EXTERNAL_LIBZ) - -############################################################################### -# -# Check if altzone exists in time.h -# - -AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ], [return (int)altzone;])], - [has_altzone=yes], - [has_altzone=no]) -if test "x$has_altzone" = xyes; then - AC_DEFINE([HAVE_ALTZONE], 1, [Define if you have the external 'altzone' variable in time.h]) -fi - -############################################################################### -# -# Check the maths library -# - -AC_CHECK_LIB(m, cos, [], - [ - AC_MSG_NOTICE([Maths library was not found]) - ]) -AC_SUBST(LIBM) - -############################################################################### -# -# Check for libdl.so - -save_LIBS="$LIBS" -LIBS="" -AC_CHECK_LIB(dl,dlopen) -LIBDL="$LIBS" -AC_SUBST(LIBDL) -LIBS="$save_LIBS" - -############################################################################### -# -# Should we run the painfully slow javadoc tool? -# -AC_MSG_CHECKING([whether to build documentation]) -AC_ARG_ENABLE([docs], [AS_HELP_STRING([--enable-docs], - [enable generation of Javadoc documentation @<:@disabled@:>@])], - [ENABLE_DOCS="${enableval}"], [ENABLE_DOCS='no']) -AC_MSG_RESULT([$ENABLE_DOCS]) -AC_SUBST(ENABLE_DOCS) -GENERATE_DOCS=false -if test "x$ENABLE_DOCS" = xyes; then - GENERATE_DOCS=true -fi -AC_SUBST(GENERATE_DOCS) - -############################################################################### -# -# Should we compile nimbus swing L&F? We can probably remove this option -# since nimbus is officially part of javax now. -# -AC_MSG_CHECKING([whether to build nimbus L&F]) -AC_ARG_ENABLE([nimbus], [AS_HELP_STRING([--disable-nimbus], - [disable Nimbus L&F @<:@enabled@:>@])], - [ENABLE_NIMBUS="${enableval}"], [ENABLE_NIMBUS='yes']) -AC_MSG_RESULT([$ENABLE_NIMBUS]) -DISABLE_NIMBUS= -if test "x$ENABLE_NIMBUS" = xno; then - DISABLE_NIMBUS=true -fi -AC_SUBST(DISABLE_NIMBUS) - -############################################################################### -# -# Setup the opt flags for different compilers -# and different operating systems. -# -C_FLAG_DEPS="-MMD -MF" -CXX_FLAG_DEPS="-MMD -MF" - -case $COMPILER_TYPE in - CC ) - D_FLAG="-g" - case $COMPILER_NAME in - gcc ) - case $PLATFORM in - macosx ) - # On MacOSX we optimize for size, something - # we should do for all platforms? - C_O_FLAG_HI="-Os" - C_O_FLAG_NORM="-Os" - C_O_FLAG_NONE="" - ;; - *) - C_O_FLAG_HI="-O3" - C_O_FLAG_NORM="-O2" - C_O_FLAG_NONE="-O0" - ;; - esac - CXX_O_FLAG_HI="$C_O_FLAG_HI" - CXX_O_FLAG_NORM="$C_O_FLAG_NORM" - CXX_O_FLAG_NONE="$C_O_FLAG_NONE" - ;; - ossc ) - # - # Forte has different names for this with their C++ compiler... - # - CXX_FLAG_DEPS="-xMMD -xMF" - -# Extra options used with HIGHEST -# -# WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be -# done with care, there are some assumptions below that need to -# be understood about the use of pointers, and IEEE behavior. -# -# Use non-standard floating point mode (not IEEE 754) -CC_HIGHEST="$CC_HIGHEST -fns" -# Do some simplification of floating point arithmetic (not IEEE 754) -CC_HIGHEST="$CC_HIGHEST -fsimple" -# Use single precision floating point with 'float' -CC_HIGHEST="$CC_HIGHEST -fsingle" -# Assume memory references via basic pointer types do not alias -# (Source with excessing pointer casting and data access with mixed -# pointer types are not recommended) -CC_HIGHEST="$CC_HIGHEST -xalias_level=basic" -# Use intrinsic or inline versions for math/std functions -# (If you expect perfect errno behavior, do not use this) -CC_HIGHEST="$CC_HIGHEST -xbuiltin=%all" -# Loop data dependency optimizations (need -xO3 or higher) -CC_HIGHEST="$CC_HIGHEST -xdepend" -# Pointer parameters to functions do not overlap -# (Similar to -xalias_level=basic usage, but less obvious sometimes. -# If you pass in multiple pointers to the same data, do not use this) -CC_HIGHEST="$CC_HIGHEST -xrestrict" -# Inline some library routines -# (If you expect perfect errno behavior, do not use this) -CC_HIGHEST="$CC_HIGHEST -xlibmil" -# Use optimized math routines -# (If you expect perfect errno behavior, do not use this) -# Can cause undefined external on Solaris 8 X86 on __sincos, removing for now -#CC_HIGHEST="$CC_HIGHEST -xlibmopt" - - case $LEGACY_HOST_CPU1 in - i586) - C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xchip=pentium" - C_O_FLAG_HI="-xO4 -Wu,-O4~yz" - C_O_FLAG_NORM="-xO2 -Wu,-O2~yz" - C_O_FLAG_NONE="" - CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xchip=pentium" - CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz" - CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz" - CXX_O_FLAG_NONE="" - ;; - sparc) - C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" - C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0" - C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0" - C_O_FLAG_NONE="" - CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" - CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" - CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" - CXX_O_FLAG_NONE="" - ;; - esac - esac - ;; - CL ) - D_FLAG= - C_O_FLAG_HI="-O2" - C_O_FLAG_NORM="-O1" - C_O_FLAG_NONE="-Od" - CXX_O_FLAG_HI="$C_O_FLAG_HI" - CXX_O_FLAG_NORM="$C_O_FLAG_NORM" - CXX_O_FLAG_NONE="$C_O_FLAG_NONE" - ;; -esac - -if test -z "$C_O_FLAG_HIGHEST"; then - C_O_FLAG_HIGHEST="$C_O_FLAG_HI" -fi - -if test -z "$CXX_O_FLAG_HIGHEST"; then - CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HI" -fi - -AC_SUBST(C_O_FLAG_HIGHEST) -AC_SUBST(C_O_FLAG_HI) -AC_SUBST(C_O_FLAG_NORM) -AC_SUBST(C_O_FLAG_NONE) -AC_SUBST(CXX_O_FLAG_HIGHEST) -AC_SUBST(CXX_O_FLAG_HI) -AC_SUBST(CXX_O_FLAG_NORM) -AC_SUBST(CXX_O_FLAG_NONE) -AC_SUBST(C_FLAG_DEPS) -AC_SUBST(CXX_FLAG_DEPS) - -############################################################################### -# -# Setup legacy vars/targets and new vars to deal with different debug levels. -# -case $DEBUG_LEVEL in - release ) - HOTSPOT_DEBUG_LEVEL="product" - HOTSPOT_EXPORT="product" - ;; - fastdebug ) - HOTSPOT_DEBUG_LEVEL="fastdebug" - HOTSPOT_EXPORT="fastdebug" - CFLAGS="$CFLAGS $D_FLAG" - JAVAC_FLAGS="$JAVAC_FLAGS -g" - ;; - slowdebug ) - HOTSPOT_DEBUG_LEVEL="jvmg" - HOTSPOT_EXPORT="debug" - CFLAGS="$CFLAGS $D_FLAG" - C_O_FLAG_HI="$C_O_FLAG_NONE" - C_O_FLAG_NORM="$C_O_FLAG_NONE" - CXX_O_FLAG_HI="$CXX_O_FLAG_NONE" - CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE" - JAVAC_FLAGS="$JAVAC_FLAGS -g" - ;; -esac - -############################################################################### -# -# Generate the legacy makefile targets for hotspot. -# The hotspot api for selecting the build artifacts, really, needs to be improved. -# -HOTSPOT_TARGET="" - -if test "x$JVM_VARIANT_SERVER" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} " -fi - -if test "x$JVM_VARIANT_CLIENT" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 " -fi - -if test "x$JVM_VARIANT_KERNEL" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel " -fi - -if test "x$JVM_VARIANT_ZERO" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero " -fi - -if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then - HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark " -fi - -HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT" - -############################################################################### -# -# Setup all directories for the subrepoes and the arguments to the sub makes. -# -LANGTOOLS_OUTPUTDIR="$OUTPUT_ROOT/langtools" -LANGTOOLS_DIST="$OUTPUT_ROOT/langtools/dist" -LANGTOOLS_MAKE_ARGS="" -AC_SUBST(LANGTOOLS_OUTPUTDIR) -AC_SUBST(LANGTOOLS_DIST) -AC_SUBST(LANGTOOLS_MAKE_ARGS) - -CORBA_OUTPUTDIR="$OUTPUT_ROOT/corba" -CORBA_DIST="$OUTPUT_ROOT/corba/dist" -CORBA_MAKE_ARGS="" -AC_SUBST(CORBA_OUTPUTDIR) -AC_SUBST(CORBA_DIST) -AC_SUBST(CORBA_MAKE_ARGS) - -JAXP_OUTPUTDIR="$OUTPUT_ROOT/jaxp" -JAXP_DIST="$OUTPUT_ROOT/jaxp/dist" -JAXP_MAKE_ARGS="" -AC_SUBST(JAXP_OUTPUTDIR) -AC_SUBST(JAXP_DIST) -AC_SUBST(JAXP_MAKE_ARGS) - -JAXWS_OUTPUTDIR="$OUTPUT_ROOT/jaxws" -JAXWS_DIST="$OUTPUT_ROOT/jaxws/dist" -JAXWS_MAKE_ARGS="" -AC_SUBST(JAXWS_OUTPUTDIR) -AC_SUBST(JAXWS_DIST) -AC_SUBST(JAXWS_MAKE_ARGS) - -HOTSPOT_OUTPUTDIR="$OUTPUT_ROOT/hotspot" -HOTSPOT_DIST="$OUTPUT_ROOT/hotspot/dist" -HOTSPOT_MAKE_ARGS="ALT_OUTPUTDIR=$HOTSPOT_OUTPUTDIR ALT_EXPORT_PATH=$HOTSPOT_DIST $HOTSPOT_TARGET" -AC_SUBST(HOTSPOT_OUTPUTDIR) -AC_SUBST(HOTSPOT_DIST) -AC_SUBST(HOTSPOT_MAKE_ARGS) - -JDK_OUTPUTDIR="$OUTPUT_ROOT/jdk" -JDK_MAKE_ARGS="ALT_OUTPUTDIR=\"$OUTPUT_ROOT/jdk\"" -AC_SUBST(JDK_OUTPUTDIR) -AC_SUBST(JDK_MAKE_ARGS) - -IMAGES_OUTPUTDIR=$OUTPUT_ROOT/images -IMAGES_MAKE_ARGS="ALT_OUTPUTDIR=$OUTPUT_ROOT/jdk \ - SHARE_SRC=$JDK_TOPDIR/src/share \ - PLATFORM_SRC=$JDK_TOPDIR/src/$LEGACY_HOST_OS_API \ - TEMPDIR=$IMAGES_OUTPUTDIR/tmp \ - ABS_TEMPDIR=$IMAGES_OUTPUTDIR/tmp " -AC_SUBST(IMAGES_OUTPUTDIR) -AC_SUBST(IMAGES_MAKE_ARGS) - -############################################################################### -# -# Now setup the CFLAGS and LDFLAGS for the JDK build. -# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build. -# -case $COMPILER_NAME in - gcc ) - CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \ - -pipe -fno-omit-frame-pointer \ - -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE" - CFLAGS_JDK="$CFLAGS_JDK -fno-strict-aliasing" - ;; - ossc ) - CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -norunpath -xnolib" - CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX" - ;; - cl ) - CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \ - -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \ - -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \ - -DWIN32 -DIAL" - case $LEGACY_HOST_CPU1 in - i?86 ) - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86" - ;; - amd64 ) - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64" - ;; - esac - ;; -esac - -CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64" - -# The package path is used only on macosx? -PACKAGE_PATH=/opt/local -AC_SUBST(PACKAGE_PATH) - -# Sometimes we use a cpu dir (.../lib/amd64/server) -# Sometimes not (.../lib/server) -LIBARCHDIR="$LEGACY_HOST_CPU2/" -if test "x$ENDIAN" = xlittle; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN" -else - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN" -fi -if test "x$HOST_OS" = xlinux; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX" -fi -if test "x$HOST_OS" = xwindows; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS" -fi -if test "x$HOST_OS" = xsolaris; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS" -fi -if test "x$HOST_OS" = xmacosx; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE" - LIBARCHDIR="" -fi -if test "x$HOST_OS" = xbsd; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE" -fi -if test "x$DEBUG_LEVEL" = xrelease; then - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG" -else - CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG" -fi - -CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$LEGACY_HOST_CPU1\"' -D$LEGACY_HOST_CPU1" -CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"$RELEASE\"'" - -CCXXFLAGS_JDK="$CCXXFLAGS_JDK \ - -I${JDK_OUTPUTDIR}/include \ - -I${JDK_OUTPUTDIR}/include/$PLATFORM \ - -I${JDK_TOPDIR}/src/share/javavm/export \ - -I${JDK_TOPDIR}/src/$LEGACY_HOST_OS_API/javavm/export \ - -I${JDK_TOPDIR}/src/share/native/common \ - -I${JDK_TOPDIR}/src/$LEGACY_HOST_OS_API/native/common" - -# The shared libraries are compiled using the picflag. -CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA" -CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG" - -# Executable flags -CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK" -CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK" - -# Now this is odd. The JDK native libraries have to link against libjvm.so -# On 32-bit machines there is normally two distinct libjvm.so:s, client and server. -# Which should we link to? Are we lucky enough that the binary api to the libjvm.so library -# is identical for client and server? Yes. Which is picked at runtime (client or server)? -# Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following -# libraries will link to whatever is in memory. Yuck. -# -# Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh. -if test "x$COMPILER_TYPE" = xCL; then - LDFLAGS_JDKLIB="$LDFLAGS -dll -libpath:${JDK_OUTPUTDIR}/lib -libpath:${JDK_OUTPUTDIR}/objs" - LDFLAGS_JDKLIB_SUFFIX="" - if test "$HOST_CPU_BITS" == "64"; then - LDFLAGS_STACK_SIZE=1048576 - else - LDFLAGS_STACK_SIZE=327680 - fi - LDFLAGS_JDKEXE="$LDFLAGS /STACK:$LDFLAGS_STACK_SIZE" -else - # If this is a --hash-style=gnu system, use --hash-style=both, why? - HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'` - if test -n "$HAS_GNU_HASH"; then - # And since we now know that the linker is gnu, then add -z defs, to forbid - # undefined symbols in object files. - LDFLAGS="$LDFLAGS -Xlinker --hash-style=both -Xlinker -z -Xlinker defs" - if test "x$DEBUG_LEVEL" == "xrelease"; then - # When building release libraries, tell the linker optimize them. - # Should this be supplied to the OSS linker as well? - LDFLAGS="$LDFLAGS -Xlinker -O1" - fi - fi - - LDFLAGS_JDKLIB="$LDFLAGS $SHARED_LIBRARY_FLAGS \ - -L${JDK_OUTPUTDIR}/objs \ - -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}server \ - -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}client \ - -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}" - LDFLAGS_JDKLIB_SUFFIX="-ljvm -ljava" - if test "x$COMPILER_NAME" = xossc; then - LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc" - fi - - # Only the jli library is explicitly linked when the launchers are built. - # The libjvm is then dynamically loaded/linked by the launcher. - if test "x$HOST_OS" != "xmacosx"; then - LDFLAGS_JDKEXE="$LDFLAGS -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}jli" - LDFLAGS_JDKEXE_SUFFIX="-ljli" - fi -fi - - -AC_SUBST(CFLAGS_JDKLIB) -AC_SUBST(CFLAGS_JDKEXE) - -AC_SUBST(CXXFLAGS_JDKLIB) -AC_SUBST(CXXFLAGS_JDKEXE) - -AC_SUBST(LDFLAGS_JDKLIB) -AC_SUBST(LDFLAGS_JDKEXE) -AC_SUBST(LDFLAGS_JDKLIB_SUFFIX) -AC_SUBST(LDFLAGS_JDKEXE_SUFFIX) - - -############################################################################### -# -# statically link libstdc++ before C++ ABI is stablized on Linux unless -# dynamic build is configured on command line. -# -AC_ARG_ENABLE([static-link-stdc++], [AS_HELP_STRING([--disable-static-link-stdc++], - [disable static linking of the C++ runtime on Linux @<:@enabled@:>@])],, - [ - enable_static_link_stdc__=yes - ]) - -if test "x$HOST_OS" = xlinux; then - # Test if -lstdc++ works. - AC_MSG_CHECKING([if dynamic link of stdc++ is possible]) - AC_LANG_PUSH(C++) - OLD_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -lstdc++" - AC_LINK_IFELSE([AC_LANG_PROGRAM([], [return 0;])], - [has_dynamic_libstdcxx=yes], - [has_dynamic_libstdcxx=no]) - CXXFLAGS="$OLD_CXXFLAGS" - AC_LANG_POP(C++) - AC_MSG_RESULT([$has_dynamic_libstdcxx]) - - # Test if stdc++ can be linked statically. - AC_MSG_CHECKING([if static link of stdc++ is possible]) - STATIC_STDCXX_FLAGS="-Wl,-Bstatic -lstdc++ -lgcc -Wl,-Bdynamic" - AC_LANG_PUSH(C++) - OLD_LIBS="$LIBS" - OLD_CXX="$CXX" - LIBS="$STATIC_STDCXX_FLAGS" - CXX="$CC" - AC_LINK_IFELSE([AC_LANG_PROGRAM([], [return 0;])], - [has_static_libstdcxx=yes], - [has_static_libstdcxx=no]) - LIBS="$OLD_LIBS" - CXX="$OLD_CXX" - AC_LANG_POP(C++) - AC_MSG_RESULT([$has_static_libstdcxx]) - - if test "x$has_static_libcxx" = xno && test "x$has_dynamic_libcxx" = xno; then - AC_MSG_ERROR([I cannot link to stdc++! Neither dynamically nor statically.]) - fi - - if test "x$enable_static_link_stdc__" = xyes && test "x$has_static_libstdcxx" = xno; then - AC_MSG_NOTICE([Static linking of libstdc++ was not possible reverting to dynamic linking.]) - enable_static_link_stdc__=no - fi - - if test "x$enable_static_link_stdc__" = xno && test "x$has_dynamic_libstdcxx" = xno; then - AC_MSG_NOTICE([Dynamic linking of libstdc++ was not possible reverting to static linking.]) - enable_static_link_stdc__=yes - fi - - AC_MSG_CHECKING([how to link with libstdc++]) - if test "x$enable_static_link_stdc__" = xyes; then - LIBCXX="$LIBCXX $STATIC_STDCXX_FLAGS" - LDCXX="$CC" - AC_MSG_RESULT([static]) - else - LIBCXX="$LIBCXX -lstdc++" - LDCXX="$CXX" - AC_MSG_RESULT([dynamic]) - fi -fi - -############################################################################### -# -# Could someone enlighten this configure script with a comment about libCrun? -# The LEGACY_HOST_CPU3 is the setting for ISA_DIR. -# -if test "x$HOST_OS" = xsolaris && test "x$LIBCXX" = x; then - LIBCXX="/usr/lib${LEGACY_HOST_CPU3}/libCrun.so.1" -fi - -# TODO better (platform agnostic) test -if test "x$HOST_OS" = xmacosx && test "x$LIBCXX" = x && test "x$GCC" = xyes; then - LIBCXX="-lstdc++" -fi - -AC_SUBST(LIBCXX) - ############################################################################### -OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`" -OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`" -OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`" -OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`" -AC_SUBST(OS_VERSION_MAJOR) -AC_SUBST(OS_VERSION_MINOR) -AC_SUBST(OS_VERSION_MICRO) +# Check for some common pitfalls +BASIC_TEST_USABILITY_ISSUES -############################################################################### -# -# Misc -# +# At the end, call the closed hook. (Dummy macro if no closed sources available) +CLOSED_HOOK -# The name of the Service Agent jar. -SALIB_NAME="${LIBRARY_PREFIX}saproc${SHARED_LIBRARY_SUFFIX}" -if test "x$HOST_OS" = "xwindows"; then - SALIB_NAME="${LIBRARY_PREFIX}sawindbg${SHARED_LIBRARY_SUFFIX}" -fi -AC_SUBST(SALIB_NAME) - -# Control wether Hotspot runs Queens test after build. -AC_ARG_ENABLE([hotspot-test-in-build], [AS_HELP_STRING([--enable-hotspot-test-in-build], - [enable running of Queens test after Hotspot build (not yet available) @<:@disabled@:>@])],, - [enable_hotspot_test_in_build=no]) -if test "x$enable_hotspot_test_in_build" = "xyes"; then - TEST_IN_BUILD=true -else - TEST_IN_BUILD=false -fi -AC_SUBST(TEST_IN_BUILD) - -############################################################################### -# -# Choose cacerts source file -# -AC_ARG_WITH(cacerts-file, [AS_HELP_STRING([--with-cacerts-file], - [specify alternative cacerts file])]) -if test "x$with_cacerts_file" != x; then - CACERTS_FILE=$with_cacerts_file -else - if test "x$OPENJDK" = "xtrue"; then - CACERTS_FILE=${SRC_ROOT}/jdk/src/share/lib/security/cacerts - else - CACERTS_FILE=${SRC_ROOT}/jdk/src/closed/share/lib/security/cacerts.internal - fi -fi -AC_SUBST(CACERTS_FILE) - -# Check if build directory is on local disk. -# return 0 if it is on local disk, non-0 if on remote disk or failure -function is_directory_on_local_disk { - # df -l lists only local disks; if the given directory is not found then - # a non-zero exit code is given - $DF -l $1 > /dev/null 2>&1 -} - -AC_MSG_CHECKING([if build directory is on local disk]) -if is_directory_on_local_disk $OUTPUT_ROOT; then - OUTPUT_DIR_IS_LOCAL="yes" -else - OUTPUT_DIR_IS_LOCAL="no" -fi -AC_MSG_RESULT($OUTPUT_DIR_IS_LOCAL) - -# We're messing a bit with internal autoconf variables to put the config.status in the -# output directory instead of the current directory. -CONFIG_STATUS=$OUTPUT_ROOT/config.status - -# Now create the actual output files, after this, the main work of configure is done +# We're messing a bit with internal autoconf variables to put the config.status +# in the output directory instead of the current directory. +CONFIG_STATUS="$OUTPUT_ROOT/config.status" +# Create the actual output files. Now the main work of configure is done. AC_OUTPUT # Finally output some useful information to the user - -if test "x$CCACHE_FOUND" != x; then - if test "x$HAS_GOOD_CCACHE" = x; then - CCACHE_STATUS="installed, but disabled (version older than 3.1.4)" - CCACHE_HELP_MSG="You have ccache installed, but it is a version prior to 3.1.4. Try upgrading." - else - CCACHE_STATUS="installed and in use" - fi -else - if test "x$GCC" = xyes; then - CCACHE_STATUS="not installed (consider installing)" - CCACHE_HELP_MSG="You do not have ccache installed. Try installing it." - else - CCACHE_STATUS="not available for your system" - fi -fi - -printf "\n" -printf "====================================================\n" -printf "A new configuration has been successfully created in\n" -printf "$OUTPUT_ROOT\n" -if test "x$CONFIGURE_COMMAND_LINE" != x; then - printf "using configure arguments '$CONFIGURE_COMMAND_LINE'.\n" -else - printf "using default settings.\n" -fi - -printf "\n" -printf "Configuration summary:\n" -printf "* Debug level: $DEBUG_LEVEL\n" -printf "* JDK variant: $JDK_VARIANT\n" -printf "* JVM variants: $with_jvm_variants\n" -printf "* Host info: OS: $HOST_OS, CPU architecture: $HOST_CPU_ARCH, address length: $HOST_CPU_BITS\n" -printf "* Boot JDK: $BOOT_JDK\n" - -printf "\n" -printf "Build performance summary:\n" -printf "* Cores to use: $NUM_CORES\n" -printf "* Memory limit: $MEMORY_SIZE MB\n" -printf "* ccache status: $CCACHE_STATUS\n" - -if test "x$OUTPUT_DIR_IS_LOCAL" != "xyes"; then - printf "\n" - printf "WARNING: Your build output directory is not on a local disk.\n" - printf "This will severely degrade build performance!\n" - printf "It is recommended that you create an output directory on a local disk,\n" - printf "and run the configure script again from that directory.\n" -fi - -if test "x$CCACHE_HELP_MSG" != x; then - printf "\n" - printf "Build performance tip: ccache gives a tremendous speedup for C++ recompilations.\n" - printf "$CCACHE_HELP_MSG\n" - - help_on_build_dependency ccache - printf "$HELP_MSG\n" -fi +HELP_PRINT_SUMMARY_AND_WARNINGS diff --git a/common/autoconf/cores.m4 b/common/autoconf/cores.m4 deleted file mode 100644 index f48887d36be..00000000000 --- a/common/autoconf/cores.m4 +++ /dev/null @@ -1,103 +0,0 @@ -# -# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -AC_DEFUN([CHECK_CORES], -[ - AC_MSG_CHECKING([for number of cores]) - NUM_CORES=1 - FOUND_CORES=no - - if test -f /proc/cpuinfo; then - # Looks like a Linux system - NUM_CORES=`cat /proc/cpuinfo | grep -c processor` - FOUND_CORES=yes - fi - - if test -x /usr/sbin/psrinfo; then - # Looks like a Solaris system - NUM_CORES=`LC_MESSAGES=C /usr/sbin/psrinfo -v | grep -c on-line` - FOUND_CORES=yes - fi - - if test -x /usr/sbin/system_profiler; then - # Looks like a MacOSX system - NUM_CORES=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Cores' | awk '{print [$]5}'` - FOUND_CORES=yes - fi - - if test "x$build_os" = xwindows; then - NUM_CORES=4 - fi - - # For c/c++ code we run twice as many concurrent build - # jobs than we have cores, otherwise we will stall on io. - CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` - - if test "x$FOUND_CORES" = xyes; then - AC_MSG_RESULT([$NUM_CORES]) - else - AC_MSG_RESULT([could not detect number of cores, defaulting to 1!]) - fi - -]) - -AC_DEFUN([CHECK_MEMORY_SIZE], -[ - AC_MSG_CHECKING([for memory size]) - # Default to 1024MB - MEMORY_SIZE=1024 - FOUND_MEM=no - - if test -f /proc/cpuinfo; then - # Looks like a Linux system - MEMORY_SIZE=`cat /proc/meminfo | grep MemTotal | awk '{print [$]2}'` - MEMORY_SIZE=`expr $MEMORY_SIZE / 1024` - FOUND_MEM=yes - fi - - if test -x /usr/sbin/prtconf; then - # Looks like a Solaris system - MEMORY_SIZE=`/usr/sbin/prtconf | grep "Memory size" | awk '{ print [$]3 }'` - FOUND_MEM=yes - fi - - if test -x /usr/sbin/system_profiler; then - # Looks like a MacOSX system - MEMORY_SIZE=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Memory' | awk '{print [$]2}'` - MEMORY_SIZE=`expr $MEMORY_SIZE \* 1024` - FOUND_MEM=yes - fi - - if test "x$build_os" = xwindows; then - MEMORY_SIZE=`systeminfo | grep 'Total Physical Memory:' | awk '{ print [$]4 }' | sed 's/,//'` - FOUND_MEM=yes - fi - - if test "x$FOUND_MEM" = xyes; then - AC_MSG_RESULT([$MEMORY_SIZE MB]) - else - AC_MSG_RESULT([could not detect memory size defaulting to 1024MB!]) - fi -]) diff --git a/common/autoconf/help.m4 b/common/autoconf/help.m4 index 6f74b5e65e9..01b48172dae 100644 --- a/common/autoconf/help.m4 +++ b/common/autoconf/help.m4 @@ -23,11 +23,13 @@ # questions. # -function prepare_help_system { +AC_DEFUN_ONCE([HELP_SETUP_DEPENDENCY_HELP], +[ AC_CHECK_PROGS(PKGHANDLER, apt-get yum port pkgutil pkgadd) -} - -function help_on_build_dependency { +]) + +AC_DEFUN([HELP_MSG_MISSING_DEPENDENCY], +[ # Print a helpful message on how to acquire the necessary build dependency. # $1 is the help tag: freetyp2, cups, pulse, alsa etc MISSING_DEPENDENCY=$1 @@ -51,9 +53,9 @@ function help_on_build_dependency { if test "x$PKGHANDLER_COMMAND" != x; then HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." fi -} +]) -function apt_help { +apt_help() { case $1 in devkit) PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;; @@ -76,7 +78,7 @@ function apt_help { esac } -function yum_help { +yum_help() { case $1 in devkit) PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;; @@ -99,14 +101,97 @@ function yum_help { esac } -function port_help { +port_help() { PKGHANDLER_COMMAND="" } -function pkgutil_help { +pkgutil_help() { PKGHANDLER_COMMAND="" } -function pkgadd_help { +pkgadd_help() { PKGHANDLER_COMMAND="" } + +AC_DEFUN_ONCE([HELP_PRINT_SUMMARY_AND_WARNINGS], +[ +# Finally output some useful information to the user + +if test "x$CCACHE_FOUND" != x; then + if test "x$HAS_GOOD_CCACHE" = x; then + CCACHE_STATUS="installed, but disabled (version older than 3.1.4)" + CCACHE_HELP_MSG="You have ccache installed, but it is a version prior to 3.1.4. Try upgrading." + else + CCACHE_STATUS="installed and in use" + fi +else + if test "x$GCC" = xyes; then + CCACHE_STATUS="not installed (consider installing)" + CCACHE_HELP_MSG="You do not have ccache installed. Try installing it." + else + CCACHE_STATUS="not available for your system" + fi +fi + +printf "\n" +printf "====================================================\n" +printf "A new configuration has been successfully created in\n" +printf "$OUTPUT_ROOT\n" +if test "x$CONFIGURE_COMMAND_LINE" != x; then + printf "using configure arguments '$CONFIGURE_COMMAND_LINE'.\n" +else + printf "using default settings.\n" +fi + +printf "\n" +printf "Configuration summary:\n" +printf "* Debug level: $DEBUG_LEVEL\n" +printf "* JDK variant: $JDK_VARIANT\n" +printf "* JVM variants: $with_jvm_variants\n" +printf "* OpenJDK target: OS: $OPENJDK_TARGET_OS, CPU architecture: $OPENJDK_TARGET_CPU_ARCH, address length: $OPENJDK_TARGET_CPU_BITS\n" +printf "* Boot JDK: $BOOT_JDK\n" + +printf "\n" +printf "Build performance summary:\n" +printf "* Cores to use: $NUM_CORES\n" +printf "* Memory limit: $MEMORY_SIZE MB\n" +printf "* ccache status: $CCACHE_STATUS\n" +printf "\n" + +if test "x$CCACHE_HELP_MSG" != x && test "x$HIDE_PERFORMANCE_HINTS" = "xno"; then + printf "Build performance tip: ccache gives a tremendous speedup for C++ recompilations.\n" + printf "$CCACHE_HELP_MSG\n" + HELP_MSG_MISSING_DEPENDENCY([ccache]) + printf "$HELP_MSG\n" + printf "\n" +fi + +if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xyes"; then + printf "NOTE: You have requested to build more than one version of the JVM, which\n" + printf "will result in longer build times.\n" + printf "\n" +fi + +if test "x$FOUND_ALT_VARIABLES" != "x"; then + printf "WARNING: You have old-style ALT_ environment variables set.\n" + printf "These are not respected, and will be ignored. It is recommended\n" + printf "that you clean your environment. The following variables are set:\n" + printf "$FOUND_ALT_VARIABLES\n" + printf "\n" +fi + +if test "x$OUTPUT_DIR_IS_LOCAL" != "xyes"; then + printf "WARNING: Your build output directory is not on a local disk.\n" + printf "This will severely degrade build performance!\n" + printf "It is recommended that you create an output directory on a local disk,\n" + printf "and run the configure script again from that directory.\n" + printf "\n" +fi + +if test "x$IS_RECONFIGURE" = "xyes"; then + printf "WARNING: The result of this configuration has overridden an older\n" + printf "configuration. You *should* run 'make clean' to make sure you get a\n" + printf "proper build. Failure to do so might result in strange build problems.\n" + printf "\n" +fi +]) diff --git a/common/autoconf/platform.m4 b/common/autoconf/platform.m4 index adfae47e3b8..5135c7c6a61 100644 --- a/common/autoconf/platform.m4 +++ b/common/autoconf/platform.m4 @@ -23,272 +23,59 @@ # questions. # -AC_DEFUN([CHECK_FIND_DELETE], -[ - # Test if find supports -delete - AC_MSG_CHECKING([if find supports -delete]) - FIND_DELETE="-delete" - - DELETEDIR=`mktemp -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?) - - echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete - - TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1` - if test -f $DELETEDIR/TestIfFindSupportsDelete; then - # No, it does not. - rm $DELETEDIR/TestIfFindSupportsDelete - FIND_DELETE="-exec rm \{\} \+" - AC_MSG_RESULT([no]) - else - AC_MSG_RESULT([yes]) - fi - rmdir $DELETEDIR -]) - -AC_DEFUN([CHECK_NONEMPTY], -[ - # Test that variable $1 is not empty. - if test "" = "[$]$1"; then AC_MSG_ERROR(Could not find translit($1,A-Z,a-z) !); fi -]) - -AC_DEFUN([ADD_JVM_ARG_IF_OK], -[ - # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3) - # If so, then append $1 to $2 - FOUND_WARN=`$3 $1 -version 2>&1 | grep -i warn` - FOUND_VERSION=`$3 $1 -version 2>&1 | grep " version \""` - if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then - $2="[$]$2 $1" - fi -]) - -AC_DEFUN([WHICHCMD], -[ - # Translate "gcc -E" into "`which gcc` -E" ie - # extract the full path to the binary and at the - # same time maintain any arguments passed to it. - # The command MUST exist in the path, or else! - tmp="[$]$1" - car="${tmp%% *}" - tmp="[$]$1 EOL" - cdr="${tmp#* }" - # On windows we want paths without spaces. - if test "x$BUILD_OS" = "xwindows"; then - WHICHCMD_SPACESAFE(car) - else - # "which" is not portable, but is used here - # because we know that the command exists! - car=`which $car` - fi - if test "x$cdr" != xEOL; then - $1="$car ${cdr% *}" - else - $1="$car" - fi -]) - -AC_DEFUN([SPACESAFE], -[ - # Fail with message $2 if var $1 contains a path with no spaces in it. - # Unless on Windows, where we can rewrite the path. - HAS_SPACE=`echo "[$]$1" | grep " "` - if test "x$HAS_SPACE" != x; then - if test "x$BUILD_OS" = "xwindows"; then - $1=`$CYGPATH -s -m -a "[$]$1"` - $1=`$CYGPATH -u "[$]$1"` - else - AC_MSG_ERROR([You cannot have spaces in $2! "[$]$1"]) - fi - fi -]) - -AC_DEFUN([WHICHCMD_SPACESAFE], -[ - # Translate long cygdrive or C:\sdfsf path - # into a short mixed mode path that has no - # spaces in it. - tmp="[$]$1" - if test "x$BUILD_OS" = "xwindows"; then - tmp=`$CYGPATH -u "[$]$1"` - tmp=`which "$tmp"` - # If file exists with .exe appended, that's the real filename - # and cygpath needs that to convert to short style path. - if test -f "${tmp}.exe"; then - tmp="${tmp}.exe" - elif test -f "${tmp}.cmd"; then - tmp="${tmp}.cmd" - fi - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - fi - $1="$tmp" -]) - -AC_DEFUN([REMOVE_SYMBOLIC_LINKS], -[ - if test "x$BUILD_OS" != xwindows; then - # Follow a chain of symbolic links. Use readlink - # where it exists, else fall back to horribly - # complicated shell code. - AC_PATH_PROG(READLINK, readlink) - if test "x$READLINK_TESTED" != yes; then - # On MacOSX there is a readlink tool with a different - # purpose than the GNU readlink tool. Check the found readlink. - ISGNU=`$READLINK --help 2>&1 | grep GNU` - if test "x$ISGNU" = x; then - # A readlink that we do not know how to use. - # Are there other non-GNU readlinks out there? - READLINK_TESTED=yes - READLINK= - fi - fi - - if test "x$READLINK" != x; then - $1=`$READLINK -f [$]$1` - else - STARTDIR=$PWD - COUNTER=0 - DIR=`dirname [$]$1` - FIL=`basename [$]$1` - while test $COUNTER -lt 20; do - ISLINK=`ls -l $DIR/$FIL | grep '\->' | sed -e 's/.*-> \(.*\)/\1/'` - if test "x$ISLINK" == x; then - # This is not a symbolic link! We are done! - break - fi - # The link might be relative! We have to use cd to travel safely. - cd $DIR - cd `dirname $ISLINK` - DIR=`pwd` - FIL=`basename $ISLINK` - let COUNTER=COUNTER+1 - done - cd $STARTDIR - $1=$DIR/$FIL - fi - fi -]) - -AC_DEFUN([TESTFOR_PROG_CCACHE], -[ - AC_ARG_ENABLE([ccache], - [AS_HELP_STRING([--disable-ccache], - [use ccache to speed up recompilations @<:@enabled@:>@])], - [ENABLE_CCACHE=${enable_ccache}], [ENABLE_CCACHE=yes]) - if test "x$ENABLE_CCACHE" = xyes; then - AC_PATH_PROG(CCACHE, ccache) - else - AC_MSG_CHECKING([for ccache]) - AC_MSG_RESULT([explicitly disabled]) - CCACHE= - fi - AC_SUBST(CCACHE) - - AC_ARG_WITH([ccache-dir], - [AS_HELP_STRING([--with-ccache-dir], - [where to store ccache files @<:@~/.ccache@:>@])]) - - if test "x$with_ccache_dir" != x; then - # When using a non home ccache directory, assume the use is to share ccache files - # with other users. Thus change the umask. - SET_CCACHE_DIR="CCACHE_DIR=$with_ccache_dir CCACHE_UMASK=002" - fi - CCACHE_FOUND="" - if test "x$CCACHE" != x; then - SETUP_CCACHE_USAGE - fi -]) - -AC_DEFUN([SETUP_CCACHE_USAGE], -[ - if test "x$CCACHE" != x; then - CCACHE_FOUND="true" - # Only use ccache if it is 3.1.4 or later, which supports - # precompiled headers. - AC_MSG_CHECKING([if ccache supports precompiled headers]) - HAS_GOOD_CCACHE=`($CCACHE --version | head -n 1 | grep -E 3.1.@<:@456789@:>@) 2> /dev/null` - if test "x$HAS_GOOD_CCACHE" = x; then - AC_MSG_RESULT([no, disabling ccache]) - CCACHE= - else - AC_MSG_RESULT([yes]) - AC_MSG_CHECKING([if C-compiler supports ccache precompiled headers]) - PUSHED_FLAGS="$CXXFLAGS" - CXXFLAGS="-fpch-preprocess $CXXFLAGS" - AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [CC_KNOWS_CCACHE_TRICK=yes], [CC_KNOWS_CCACHE_TRICK=no]) - CXXFLAGS="$PUSHED_FLAGS" - if test "x$CC_KNOWS_CCACHE_TRICK" = xyes; then - AC_MSG_RESULT([yes]) - else - AC_MSG_RESULT([no, disabling ccaching of precompiled headers]) - CCACHE= - fi - fi - fi - - if test "x$CCACHE" != x; then - CCACHE_SLOPPINESS=time_macros - CCACHE="CCACHE_COMPRESS=1 $SET_CCACHE_DIR CCACHE_SLOPPINESS=$CCACHE_SLOPPINESS $CCACHE" - CCACHE_FLAGS=-fpch-preprocess - - if test "x$SET_CCACHE_DIR" != x; then - mkdir -p $CCACHE_DIR > /dev/null 2>&1 - chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1 - fi - fi -]) - -AC_DEFUN([EXTRACT_HOST_AND_BUILD_AND_LEGACY_VARS], +AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD_AND_LEGACY_VARS], [ # Expects $host_os $host_cpu $build_os and $build_cpu - # and $with_data_model to have been setup! + # and $with_target_bits to have been setup! # # Translate the standard triplet(quadruplet) definition - # of the host/build system into - # HOST_OS=aix,bsd,hpux,linux,macosx,solaris,windows - # HOST_OS_FAMILY=bsd,gnu,sysv,win32,wince - # HOST_OS_API=posix,winapi + # of the target/build system into + # OPENJDK_TARGET_OS=aix,bsd,hpux,linux,macosx,solaris,windows + # OPENJDK_TARGET_OS_FAMILY=bsd,gnu,sysv,win32,wince + # OPENJDK_TARGET_OS_API=posix,winapi # - # HOST_CPU=ia32,x64,sparc,sparcv9,arm,arm64,ppc,ppc64 - # HOST_CPU_ARCH=x86,sparc,pcc,arm - # HOST_CPU_BITS=32,64 - # HOST_CPU_ENDIAN=big,little + # OPENJDK_TARGET_CPU=ia32,x64,sparc,sparcv9,arm,arm64,ppc,ppc64 + # OPENJDK_TARGET_CPU_ARCH=x86,sparc,pcc,arm + # OPENJDK_TARGET_CPU_BITS=32,64 + # OPENJDK_TARGET_CPU_ENDIAN=big,little # # The same values are setup for BUILD_... # # And the legacy variables, for controlling the old makefiles. - # LEGACY_HOST_CPU1=i586,amd64/x86_64,sparc,sparcv9,arm,arm64... - # LEGACY_HOST_CPU2=i386,amd64,sparc,sparcv9,arm,arm64... - # LEGACY_HOST_CPU3=sparcv9,amd64 (but only on solaris) - # LEGACY_HOST_OS_API=solaris,windows + # LEGACY_OPENJDK_TARGET_CPU1=i586,amd64/x86_64,sparc,sparcv9,arm,arm64... + # LEGACY_OPENJDK_TARGET_CPU2=i386,amd64,sparc,sparcv9,arm,arm64... + # LEGACY_OPENJDK_TARGET_CPU3=sparcv9,amd64 (but only on solaris) + # LEGACY_OPENJDK_TARGET_OS_API=solaris,windows # # We also copy the autoconf trip/quadruplet - # verbatim to HOST and BUILD - AC_SUBST(HOST, ${host}) - AC_SUBST(BUILD, ${build}) + # verbatim to OPENJDK_TARGET_SYSTEM (from the autoconf "host") and OPENJDK_BUILD_SYSTEM + OPENJDK_TARGET_SYSTEM="$host" + OPENJDK_BUILD_SYSTEM="$build" + AC_SUBST(OPENJDK_TARGET_SYSTEM) + AC_SUBST(OPENJDK_BUILD_SYSTEM) - EXTRACT_VARS_FROM_OS_TO(HOST,$host_os) - EXTRACT_VARS_FROM_CPU_TO(HOST,$host_cpu) + PLATFORM_EXTRACT_VARS_FROM_OS_TO(OPENJDK_TARGET,$host_os) + PLATFORM_EXTRACT_VARS_FROM_CPU_TO(OPENJDK_TARGET,$host_cpu) - EXTRACT_VARS_FROM_OS_TO(BUILD,$build_os) - EXTRACT_VARS_FROM_CPU_TO(BUILD,$build_cpu) + PLATFORM_EXTRACT_VARS_FROM_OS_TO(OPENJDK_BUILD,$build_os) + PLATFORM_EXTRACT_VARS_FROM_CPU_TO(OPENJDK_BUILD,$build_cpu) - if test "x$HOST_OS" != xsolaris; then - LEGACY_HOST_CPU3="" - LEGACY_BUILD_CPU3="" + if test "x$OPENJDK_TARGET_OS" != xsolaris; then + LEGACY_OPENJDK_TARGET_CPU3="" + LEGACY_OPENJDK_BUILD_CPU3="" fi - # On MacOSX and MacOSX only, we have a different name for the x64 CPU in ARCH (LEGACY_HOST_CPU1) ... - if test "x$HOST_OS" = xmacosx && test "x$HOST_CPU" = xx64; then - LEGACY_HOST_CPU1="x86_64" + # On MacOSX and MacOSX only, we have a different name for the x64 CPU in ARCH (LEGACY_OPENJDK_TARGET_CPU1) ... + if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$OPENJDK_TARGET_CPU" = xx64; then + LEGACY_OPENJDK_TARGET_CPU1="x86_64" fi - SET_RELEASE_FILE_OS_VALUES() + PLATFORM_SET_RELEASE_FILE_OS_VALUES ]) -AC_DEFUN([EXTRACT_VARS_FROM_OS_TO], +AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_OS_TO], [ - EXTRACT_VARS_FROM_OS($2) + PLATFORM_EXTRACT_VARS_FROM_OS($2) $1_OS="$VAR_OS" $1_OS_FAMILY="$VAR_OS_FAMILY" $1_OS_API="$VAR_OS_API" @@ -306,9 +93,9 @@ AC_DEFUN([EXTRACT_VARS_FROM_OS_TO], AC_SUBST(LEGACY_$1_OS_API) ]) -AC_DEFUN([EXTRACT_VARS_FROM_CPU_TO], +AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_CPU_TO], [ - EXTRACT_VARS_FROM_CPU($2) + PLATFORM_EXTRACT_VARS_FROM_CPU($2) $1_CPU="$VAR_CPU" $1_CPU_ARCH="$VAR_CPU_ARCH" $1_CPU_BITS="$VAR_CPU_BITS" @@ -339,12 +126,12 @@ AC_DEFUN([EXTRACT_VARS_FROM_CPU_TO], LEGACY_$1_CPU3=amd64 fi if test "x$$1_CPU" = xsparcv9; then - LEGACY_$1_CPU3=sparvc9 + LEGACY_$1_CPU3=sparcv9 fi AC_SUBST(LEGACY_$1_CPU3) ]) -AC_DEFUN([EXTRACT_VARS_FROM_CPU], +AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_CPU], [ # First argument is the cpu name from the trip/quad case "$1" in @@ -372,8 +159,8 @@ AC_DEFUN([EXTRACT_VARS_FROM_CPU], arm*) VAR_CPU=arm VAR_CPU_ARCH=arm - VAR_CPU_BITS=3264 - VAR_CPU_ENDIAN=big + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=little VAR_LEGACY_CPU=arm ;; mips) @@ -401,7 +188,7 @@ AC_DEFUN([EXTRACT_VARS_FROM_CPU], VAR_CPU=ppc64 VAR_CPU_ARCH=ppc VAR_CPU_BITS=64 - VAR_CPU_ENDIAN=32 + VAR_CPU_ENDIAN=big VAR_LEGACY_CPU=ppc64 ;; sparc) @@ -416,7 +203,7 @@ AC_DEFUN([EXTRACT_VARS_FROM_CPU], VAR_CPU_ARCH=sparc VAR_CPU_BITS=64 VAR_CPU_ENDIAN=big - VAR_LEGACY_CPU=sparc_sparcv9 + VAR_LEGACY_CPU=sparcv9 ;; s390) VAR_CPU=s390 @@ -452,21 +239,37 @@ AC_DEFUN([EXTRACT_VARS_FROM_CPU], fi fi + # on solaris x86...default seems to be 32-bit + if test "x$VAR_OS" = "xsolaris" && \ + test "x$with_target_bits" = "x" && \ + test "x$VAR_CPU_ARCH" = "xx86" + then + with_target_bits=32 + fi + if test "x$VAR_CPU_ARCH" = "xx86"; then - if test "x$with_data_model" = "x64"; then + if test "x$with_target_bits" = "x64"; then VAR_CPU=x64 VAR_CPU_BITS=64 VAR_LEGACY_CPU=amd64 fi - if test "x$with_data_model" = "x32"; then + if test "x$with_target_bits" = "x32"; then VAR_CPU=ia32 VAR_CPU_BITS=32 VAR_LEGACY_CPU=i586 fi fi + + if test "x$VAR_CPU_ARCH" = "xsparc"; then + if test "x$with_target_bits" = "x64"; then + VAR_CPU=sparcv9 + VAR_CPU_BITS=64 + VAR_LEGACY_CPU=sparcv9 + fi + fi ]) -AC_DEFUN([EXTRACT_VARS_FROM_OS], +AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_OS], [ case "$1" in *linux*) @@ -495,49 +298,26 @@ AC_DEFUN([EXTRACT_VARS_FROM_OS], VAR_OS_FAMILY=windows ;; *) - AC_MSG_ERROR([unsupported host operating system $1]) + AC_MSG_ERROR([unsupported operating system $1]) ;; esac ]) -AC_DEFUN([CHECK_COMPILER_VERSION], +AC_DEFUN([PLATFORM_SET_RELEASE_FILE_OS_VALUES], [ - # Test the compilers that their versions are new enough. -# AC_MSG_CHECKING([version of GCC]) - gcc_ver=`${CC} -dumpversion` - gcc_major_ver=`echo ${gcc_ver}|cut -d'.' -f1` - gcc_minor_ver=`echo ${gcc_ver}|cut -d'.' -f2` -# AM_CONDITIONAL(GCC_OLD, test ! ${gcc_major_ver} -ge 4 -a ${gcc_minor_ver} -ge 3) -# AC_MSG_RESULT([${gcc_ver} (major version ${gcc_major_ver}, minor version ${gcc_minor_ver})]) -]) - -# Fixes paths on windows hosts to be mixed mode short. -AC_DEFUN([WIN_FIX_PATH], -[ - if test "x$BUILD_OS" = "xwindows"; then - AC_PATH_PROG(CYGPATH, cygpath) - tmp="[$]$1" - # Convert to C:/ mixed style path without spaces. - tmp=`$CYGPATH -s -m "$tmp"` - $1="$tmp" - fi -]) - -AC_DEFUN([SET_RELEASE_FILE_OS_VALUES], -[ - if test "x$HOST_OS" = "xsolaris"; then + if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then REQUIRED_OS_NAME=SunOS REQUIRED_OS_VERSION=5.10 fi - if test "x$HOST_OS" = "xlinux"; then + if test "x$OPENJDK_TARGET_OS" = "xlinux"; then REQUIRED_OS_NAME=Linux REQUIRED_OS_VERSION=2.6 fi - if test "x$HOST_OS" = "xwindows"; then + if test "x$OPENJDK_TARGET_OS" = "xwindows"; then REQUIRED_OS_NAME=Windows REQUIRED_OS_VERSION=5.1 fi - if test "x$HOST_OS" = "xmacosx"; then + if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then REQUIRED_OS_NAME=Darwin REQUIRED_OS_VERSION=11.2 fi @@ -545,3 +325,174 @@ AC_DEFUN([SET_RELEASE_FILE_OS_VALUES], AC_SUBST(REQUIRED_OS_NAME) AC_SUBST(REQUIRED_OS_VERSION) ]) + +#%%% Build and target systems %%% +AC_DEFUN_ONCE([PLATFORM_SETUP_OPENJDK_BUILD_AND_TARGET], +[ +# Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target" +# is confusing; it assumes you are cross-compiling a cross-compiler (!) and "target" is thus the target of the +# product you're building. The target of this build is called "host". Since this is confusing to most people, we +# have not adopted that system, but use "target" as the platform we are building for. In some places though we need +# to use the configure naming style. +AC_CANONICAL_BUILD +AC_CANONICAL_HOST +AC_CANONICAL_TARGET + +AC_ARG_WITH(target-bits, [AS_HELP_STRING([--with-target-bits], + [build 32-bit or 64-bit binaries (for platforms that support it), e.g. --with-target-bits=32 @<:@guessed@:>@])]) + +if test "x$with_target_bits" != x && \ + test "x$with_target_bits" != x32 && \ + test "x$with_target_bits" != x64 ; then + AC_MSG_ERROR([--with-target-bits can only be 32 or 64, you specified $with_target_bits!]) +fi +# Translate the standard cpu-vendor-kernel-os quadruplets into +# the new TARGET_.... and BUILD_... and the legacy names used by +# the openjdk build. +# It uses $host_os $host_cpu $build_os $build_cpu and $with_target_bits +PLATFORM_EXTRACT_TARGET_AND_BUILD_AND_LEGACY_VARS + +# The LEGACY_OPENJDK_TARGET_CPU3 is the setting for ISA_DIR. +if test "x$LEGACY_OPENJDK_TARGET_CPU3" != x; then + LEGACY_OPENJDK_TARGET_CPU3="/${LEGACY_OPENJDK_TARGET_CPU3}" +fi + +# Now the following vars are defined. +# OPENJDK_TARGET_OS=aix,bsd,hpux,linux,macosx,solaris,windows +# OPENJDK_TARGET_OS_FAMILY=bsd,gnu,sysv,win32,wince +# OPENJDK_TARGET_OS_API=posix,winapi +# +# OPENJDK_TARGET_CPU=ia32,x64,sparc,sparcv9,arm,arm64,ppc,ppc64 +# OPENJDK_TARGET_CPU_ARCH=x86,sparc,pcc,arm +# OPENJDK_TARGET_CPU_BITS=32,64 +# OPENJDK_TARGET_CPU_ENDIAN=big,little +# +# There is also a: +# LEGACY_OPENJDK_TARGET_CPU1=i586,amd64,.... # used to set the old var ARCH +# LEGACY_OPENJDK_TARGET_CPU2=i386,amd64,.... # used to set the old var LIBARCH +# LEGACY_OPENJDK_TARGET_CPU3=only sparcv9,amd64 # used to set the ISA_DIR on Solaris +# There was also a BUILDARCH that had i486,amd64,... but we do not use that +# in the new build. +# LEGACY_OPENJDK_TARGET_OS_API=solaris,windows # used to select source roots +]) + +AC_DEFUN_ONCE([PLATFORM_SETUP_OPENJDK_BUILD_OS_VERSION], +[ +############################################################################### + +# Note that this is the build platform OS version! + +OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`" +OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`" +OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`" +OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`" +AC_SUBST(OS_VERSION_MAJOR) +AC_SUBST(OS_VERSION_MINOR) +AC_SUBST(OS_VERSION_MICRO) +]) + +AC_DEFUN_ONCE([PLATFORM_TEST_OPENJDK_TARGET_BITS], +[ +############################################################################### +# +# Now we check if libjvm.so will use 32 or 64 bit pointers for the C/C++ code. +# (The JVM can use 32 or 64 bit Java pointers but that decision +# is made at runtime.) +# +AC_LANG_PUSH(C++) +OLD_CXXFLAGS="$CXXFLAGS" +if test "x$OPENJDK_TARGET_OS" != xwindows && test "x$with_target_bits" != x; then + CXXFLAGS="-m${with_target_bits} $CXXFLAGS" +fi +AC_CHECK_SIZEOF([int *], [1111]) +CXXFLAGS="$OLD_CXXFLAGS" +AC_LANG_POP(C++) + +# keep track of c/cxx flags that we added outselves... +# to prevent emitting warning... +ADDED_CFLAGS= +ADDED_CXXFLAGS= +ADDED_LDFLAGS= + +if test "x$ac_cv_sizeof_int_p" = x0; then + # The test failed, lets pick the assumed value. + ARCH_DATA_MODEL=$OPENJDK_TARGET_CPU_BITS +else + ARCH_DATA_MODEL=`expr 8 \* $ac_cv_sizeof_int_p` + + if test "x$OPENJDK_TARGET_OS" != xwindows && test "x$with_target_bits" != x; then + ADDED_CFLAGS=" -m${with_target_bits}" + ADDED_CXXFLAGS=" -m${with_target_bits}" + ADDED_LDFLAGS=" -m${with_target_bits}" + + CFLAGS="${CFLAGS}${ADDED_CFLAGS}" + CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}" + LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}" + + CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}" + CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}" + LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}" + fi +fi + +if test "x$ARCH_DATA_MODEL" = x64; then + A_LP64="LP64:=" + ADD_LP64="-D_LP64=1" +fi +AC_MSG_CHECKING([for target address size]) +AC_MSG_RESULT([$ARCH_DATA_MODEL bits]) +AC_SUBST(LP64,$A_LP64) +AC_SUBST(ARCH_DATA_MODEL) + +if test "x$ARCH_DATA_MODEL" != "x$OPENJDK_TARGET_CPU_BITS"; then + AC_MSG_ERROR([The tested number of bits in the target ($ARCH_DATA_MODEL) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)]) +fi + +# +# NOTE: check for -mstackrealign needs to be below potential addition of -m32 +# +if test "x$OPENJDK_TARGET_CPU_BITS" = x32 && test "x$OPENJDK_TARGET_OS" = xmacosx; then + # On 32-bit MacOSX the OS requires C-entry points to be 16 byte aligned. + # While waiting for a better solution, the current workaround is to use -mstackrealign. + CFLAGS="$CFLAGS -mstackrealign" + AC_MSG_CHECKING([if 32-bit compiler supports -mstackrealign]) + AC_LINK_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])], + [ + AC_MSG_RESULT([yes]) + ], + [ + AC_MSG_RESULT([no]) + AC_MSG_ERROR([The selected compiler $CXX does not support -mstackrealign! Try to put another compiler in the path.]) + ]) +fi +]) + +AC_DEFUN_ONCE([PLATFORM_SETUP_OPENJDK_TARGET_ENDIANNESS], +[ +############################################################################### +# +# Is the target little of big endian? +# +AC_C_BIGENDIAN([ENDIAN="big"],[ENDIAN="little"],[ENDIAN="unknown"],[ENDIAN="universal_endianness"]) + +if test "x$ENDIAN" = xuniversal_endianness; then + AC_MSG_ERROR([Building with both big and little endianness is not supported]) +fi +if test "x$ENDIAN" = xunknown; then + ENDIAN="$OPENJDK_TARGET_CPU_ENDIAN" +fi +if test "x$ENDIAN" != "x$OPENJDK_TARGET_CPU_ENDIAN"; then + AC_MSG_WARN([The tested endian in the target ($ENDIAN) differs from the endian expected to be found in the target ($OPENJDK_TARGET_CPU_ENDIAN)]) + ENDIAN="$OPENJDK_TARGET_CPU_ENDIAN" +fi +AC_SUBST(ENDIAN) +]) + +AC_DEFUN_ONCE([PLATFORM_SETUP_OPENJDK_TARGET_ISADIR], +[ +############################################################################### +# +# Could someone enlighten this configure script with a comment about libCrun? +# +# +]) diff --git a/common/autoconf/spec.gmk.in b/common/autoconf/spec.gmk.in index 28e248b019c..5c2e43c2fed 100644 --- a/common/autoconf/spec.gmk.in +++ b/common/autoconf/spec.gmk.in @@ -23,8 +23,8 @@ # questions. # -# Configured @DATE_WHEN_CONFIGURED@ to build for a @HOST@ system, -# using ./configure @CONFIGURE_COMMAND_LINE@ +# Configured @DATE_WHEN_CONFIGURED@ to build for a @OPENJDK_TARGET_SYSTEM@ system, +# using 'configure @CONFIGURE_COMMAND_LINE@' # When calling macros, the spaces between arguments are # often semantically important! Sometimes we need to subst @@ -67,48 +67,50 @@ SPEC:=@SPEC@ # The "human readable" name of this configuration CONF_NAME:=@CONF_NAME@ -# The built jdk will run in this host system. -HOST:=@HOST@ -HOST_OS:=@HOST_OS@ -HOST_OS_FAMILY:=@HOST_OS_FAMILY@ -HOST_OS_API:=@HOST_OS_API@ +# The built jdk will run in this target system. +OPENJDK_TARGET_SYSTEM:=@OPENJDK_TARGET_SYSTEM@ -HOST_CPU:=@HOST_CPU@ -HOST_CPU_ARCH:=@HOST_CPU_ARCH@ -HOST_CPU_BITS:=@HOST_CPU_BITS@ -HOST_CPU_ENDIAN:=@HOST_CPU_ENDIAN@ +OPENJDK_TARGET_OS:=@OPENJDK_TARGET_OS@ +OPENJDK_TARGET_OS_FAMILY:=@OPENJDK_TARGET_OS_FAMILY@ +OPENJDK_TARGET_OS_API:=@OPENJDK_TARGET_OS_API@ + +OPENJDK_TARGET_CPU:=@OPENJDK_TARGET_CPU@ +OPENJDK_TARGET_CPU_ARCH:=@OPENJDK_TARGET_CPU_ARCH@ +OPENJDK_TARGET_CPU_BITS:=@OPENJDK_TARGET_CPU_BITS@ +OPENJDK_TARGET_CPU_ENDIAN:=@OPENJDK_TARGET_CPU_ENDIAN@ # We are building on this build system. -# When not cross-compiling, it is the same as the host. -BUILD:=@BUILD@ -BUILD_OS:=@BUILD_OS@ -BUILD_OS_FAMILY:=@BUILD_OS_FAMILY@ -BUILD_OS_API:=@BUILD_OS_API@ +# When not cross-compiling, it is the same as the target. +OPENJDK_BUILD_SYSTEM:=@OPENJDK_BUILD_SYSTEM@ -BUILD_CPU:=@BUILD_CPU@ -BUILD_CPU_ARCH:=@BUILD_CPU_ARCH@ -BUILD_CPU_BITS:=@BUILD_CPU_BITS@ -BUILD_CPU_ENDIAN:=@BUILD_CPU_ENDIAN@ +OPENJDK_BUILD_OS:=@OPENJDK_BUILD_OS@ +OPENJDK_BUILD_OS_FAMILY:=@OPENJDK_BUILD_OS_FAMILY@ +OPENJDK_BUILD_OS_API:=@OPENJDK_BUILD_OS_API@ + +OPENJDK_BUILD_CPU:=@OPENJDK_BUILD_CPU@ +OPENJDK_BUILD_CPU_ARCH:=@OPENJDK_BUILD_CPU_ARCH@ +OPENJDK_BUILD_CPU_BITS:=@OPENJDK_BUILD_CPU_BITS@ +OPENJDK_BUILD_CPU_ENDIAN:=@OPENJDK_BUILD_CPU_ENDIAN@ # Legacy OS values for use in release file. REQUIRED_OS_NAME:=@REQUIRED_OS_NAME@ REQUIRED_OS_VERSION:=@REQUIRED_OS_VERSION@ -# Old name for HOST_OS (aix,bsd,hpux,linux,macosx,solaris,windows etc) -PLATFORM:=@HOST_OS@ -# Old name for HOST_CPU, uses i586 and amd64, instead of ia32 and x64. -ARCH:=@LEGACY_HOST_CPU1@ +# Old name for OPENJDK_TARGET_OS (aix,bsd,hpux,linux,macosx,solaris,windows etc) +PLATFORM:=@OPENJDK_TARGET_OS@ +# Old name for OPENJDK_TARGET_CPU, uses i586 and amd64, instead of ia32 and x64. +ARCH:=@LEGACY_OPENJDK_TARGET_CPU1@ # Yet another name for arch used for an extra subdir below the jvm lib. # Uses i386 and amd64, instead of ia32 and x64. -LIBARCH:=@LEGACY_HOST_CPU2@ +LIBARCH:=@LEGACY_OPENJDK_TARGET_CPU2@ # Use to switch between solaris and windows subdirs in the jdk. -LEGACY_HOST_OS_API:=@LEGACY_HOST_OS_API@ +LEGACY_OPENJDK_TARGET_OS_API:=@LEGACY_OPENJDK_TARGET_OS_API@ # 32 or 64 bit -ARCH_DATA_MODEL:=@HOST_CPU_BITS@ +ARCH_DATA_MODEL:=@OPENJDK_TARGET_CPU_BITS@ # Legacy setting for building for a 64 bit machine. # If yes then this expands to _LP64:=1 @LP64@ -ENDIAN:=@HOST_CPU_ENDIAN@ +ENDIAN:=@OPENJDK_TARGET_CPU_ENDIAN@ @SET_OPENJDK@ JIGSAW:=@JIGSAW@ LIBM:=-lm @@ -185,7 +187,6 @@ SUPPORT_HEADLESS:=@SUPPORT_HEADLESS@ # The java launcher uses the default. # The other can be selected by specifying -client -server -kernel -zero or -zeroshark # on the java launcher command line. -DEFAULT_JVM_VARIANT:=@DEFAULT_JVM_VARIANT@ JVM_VARIANTS:=@JVM_VARIANTS@ JVM_VARIANT_SERVER:=@JVM_VARIANT_SERVER@ JVM_VARIANT_CLIENT:=@JVM_VARIANT_CLIENT@ @@ -202,53 +203,42 @@ DEBUG_CLASSFILES:=@DEBUG_CLASSFILES@ # Legacy setting: -debug or -fastdebug BUILD_VARIANT_RELEASE:=@BUILD_VARIANT_RELEASE@ -LANGTOOLS_OUTPUTDIR:=@OUTPUT_ROOT@/langtools -LANGTOOLS_DIST:=@OUTPUT_ROOT@/langtools/dist -LANGTOOLS_MAKE_ARGS:=@LANGTOOLS_MAKE_ARGS@ - -CORBA_OUTPUTDIR:=@OUTPUT_ROOT@/corba -CORBA_DIST:=@OUTPUT_ROOT@/corba/dist -CORBA_MAKE_ARGS:=@CORBA_MAKE_ARGS@ - -JAXP_OUTPUTDIR:=@OUTPUT_ROOT@/jaxp -JAXP_DIST:=@OUTPUT_ROOT@/jaxp/dist -JAXP_MAKE_ARGS:=@JAXP_MAKE_ARGS@ - -JAXWS_OUTPUTDIR:=@OUTPUT_ROOT@/jaxws -JAXWS_DIST:=@OUTPUT_ROOT@/jaxws/dist -JAXWS_MAKE_ARGS:=@JAXWS_MAKE_ARGS@ - -HOTSPOT_OUTPUTDIR:=@OUTPUT_ROOT@/hotspot -HOTSPOT_DIST:=@OUTPUT_ROOT@/hotspot/dist -HOTSPOT_MAKE_ARGS:=@HOTSPOT_MAKE_ARGS@ +LANGTOOLS_OUTPUTDIR:=@LANGTOOLS_OUTPUTDIR@ +CORBA_OUTPUTDIR:=@CORBA_OUTPUTDIR@ +JAXP_OUTPUTDIR:=@JAXP_OUTPUTDIR@ +JAXWS_OUTPUTDIR:=@JAXWS_OUTPUTDIR@ +HOTSPOT_OUTPUTDIR:=@HOTSPOT_OUTPUTDIR@ # This where a working jvm is built. # You can run $(JDK_OUTPUTDIR)/bin/java # Though the layout of the contents of $(JDK_OUTPUTDIR) is not # yet the same as a default installation. -HOTSPOT_IMPORT_PATH:=@OUTPUT_ROOT@/hotspot/dist JDK_OUTPUTDIR:=@OUTPUT_ROOT@/jdk -JDK_MAKE_ARGS:=@JDK_MAKE_ARGS@ # When you run "make install" it will create the standardized # layout for the jdk and the jre inside the images subdir. # Then it will copy the contents of the jdk into the installation # directory. IMAGES_OUTPUTDIR:=@OUTPUT_ROOT@/images -IMAGES_MAKE_ARGS:=@IMAGES_MAKE_ARGS@ + +LANGTOOLS_DIST:=@LANGTOOLS_DIST@ +CORBA_DIST:=@CORBA_DIST@ +JAXP_DIST:=@JAXP_DIST@ +JAXWS_DIST:=@JAXWS_DIST@ +HOTSPOT_DIST:=@HOTSPOT_DIST@ + # Legacy variables used by Release.gmk JDK_IMAGE_DIR:=$(IMAGES_OUTPUTDIR)/j2sdk-image JRE_IMAGE_DIR:=$(IMAGES_OUTPUTDIR)/j2re-image # Can be /sparcv9 or /amd64 on Solaris -ISA_DIR:=@LEGACY_HOST_CPU3@ +ISA_DIR:=@LEGACY_OPENJDK_TARGET_CPU3@ BINDIR:=$(JDK_OUTPUTDIR)/bin$(ISA_DIR) # The boot jdk to use ALT_BOOTDIR:=@BOOT_JDK@ BOOT_JDK:=@BOOT_JDK@ BOOT_JDK_JVMARGS:=@BOOT_JDK_JVMARGS@ -BOOT_JAVAC_ARGS:=@BOOT_JAVAC_ARGS@ BOOT_RTJAR:=@BOOT_RTJAR@ BOOT_TOOLSJAR:=@BOOT_TOOLSJAR@ @@ -258,8 +248,6 @@ BOOT_JDK_SOURCETARGET:=@BOOT_JDK_SOURCETARGET@ # Information about the build system NUM_CORES:=@NUM_CORES@ -# This is used from the libjvm build for C/C++ code. -HOTSPOT_BUILD_JOBS:=@CONCURRENT_BUILD_JOBS@ # This is used from the jdk build for C/C++ code. PARALLEL_COMPILE_JOBS:=@CONCURRENT_BUILD_JOBS@ # Store javac server synchronization files here, and @@ -282,6 +270,8 @@ JAVAC_SERVER_CORES:=@JAVAC_SERVER_CORES@ JAVAC_USE_DEPS:=@JAVAC_USE_DEPS@ # We can invoke javac: SINGLE_THREADED_BATCH or MULTI_CORE_CONCURRENT JAVAC_USE_MODE:=@JAVAC_USE_MODE@ +# Enable not yet complete sjavac support. +ENABLE_SJAVAC:=@ENABLE_SJAVAC@ # The OpenJDK makefiles should be changed to using the standard # configure output ..._CFLAGS and ..._LIBS. In the meantime we @@ -375,22 +365,24 @@ LDEXECXX:=@UNCYGDRIVE@ @LDEXECXX@ @DEFINE_CROSS_COMPILE_ARCH@ # The HOSTCC should really be named BUILDCC, ie build executable for # the build platform. Same as CC when not cross compiling. -HOSTCC:=@HOSTCC@ -HOSTCXX:=@HOSTCXX@ +HOSTCC:=@UNCYGDRIVE@ @HOSTCC@ +HOSTCXX:=@UNCYGDRIVE@ @HOSTCXX@ # And of course, the jdk spells HOSTCC as NIO_CC/HOST_CC -HOST_CC:=@HOSTCC@ -NIO_CC:=@HOSTCC@ +HOST_CC:=@UNCYGDRIVE@ @HOSTCC@ +NIO_CC:=@UNCYGDRIVE@ @HOSTCC@ -AS:=@AS@ +HOST_LD:=@UNCYGDRIVE@ @HOSTLD@ + +AS:=@UNCYGDRIVE@ @AS@ ASFLAGS:=@ASFLAGS@ # AR is used to create a static library (is ar in posix, lib.exe in winapi) AR:=@UNCYGDRIVE@ @AR@ ARFLAGS:=@ARFLAGS@ -NM:=@NM@ -STRIP:=@STRIP@ -MCS:=@MCS@ +NM:=@UNCYGDRIVE@ @NM@ +STRIP:=@UNCYGDRIVE@ @STRIP@ +MCS:=@UNCYGDRIVE@ @MCS@ # Command to create a shared library SHARED_LIBRARY_FLAGS:=@SHARED_LIBRARY_FLAGS@ @@ -404,6 +396,17 @@ SET_SHARED_LIBRARY_MAPFILE=@SET_SHARED_LIBRARY_MAPFILE@ C_FLAG_REORDER:=@C_FLAG_REORDER@ CXX_FLAG_REORDER:=@CXX_FLAG_REORDER@ +# +# Options for generating debug symbols +ENABLE_DEBUG_SYMBOLS:=@ENABLE_DEBUG_SYMBOLS@ +CFLAGS_DEBUG_SYMBOLS:=@CFLAGS_DEBUG_SYMBOLS@ +CXXFLAGS_DEBUG_SYMBOLS:=@CXXFLAGS_DEBUG_SYMBOLS@ +ZIP_DEBUGINFO_FILES:=@ZIP_DEBUGINFO_FILES@ + +# +# Compress (or not) jars +COMPRESS_JARS=@COMPRESS_JARS@ + # Options to linker to specify the library name. # (Note absence of := assignment, because we do not want to evaluate the macro body here) SET_SHARED_LIBRARY_NAME=@SET_SHARED_LIBRARY_NAME@ @@ -507,23 +510,28 @@ READELF:=@READELF@ EXPR:=@EXPR@ FILE:=@FILE@ HG:=@HG@ +OBJCOPY:=@OBJCOPY@ UNCYGDRIVE:=@UNCYGDRIVE@ # Where the build output is stored for your convenience. BUILD_LOG:=@BUILD_LOG@ +BUILD_LOG_PREVIOUS:=@BUILD_LOG_PREVIOUS@ BUILD_LOG_WRAPPER:=@BUILD_LOG_WRAPPER@ # Build setup ENABLE_DOCS:=@ENABLE_DOCS@ GENERATE_DOCS:=@ENABLE_DOCS@ DISABLE_NIMBUS:=@DISABLE_NIMBUS@ +ENABLE_JFR=@ENABLE_JFR@ USE_EXTERNAL_LIBJPEG:=@USE_EXTERNAL_LIBJPEG@ USE_EXTERNAL_LIBGIF:=@USE_EXTERNAL_LIBGIF@ USE_EXTERNAL_LIBZ:=@USE_EXTERNAL_LIBZ@ +LIBZIP_CAN_USE_MMAP:=@LIBZIP_CAN_USE_MMAP@ CHECK_FOR_VCINSTALLDIR=@CHECK_FOR_VCINSTALLDIR@ MSVCRNN_DLL:=@MSVCR100DLL@ + # ADD_SRCS takes a single argument with source roots # and appends any corresponding source roots found # below --with-add-source-root and below @@ -551,6 +559,17 @@ else OVR_SRCS:= endif +#################################################### +# +# Legacy Hotspot support + +HOTSPOT_DIST:=@HOTSPOT_DIST@ +HOTSPOT_MAKE_ARGS:=@HOTSPOT_MAKE_ARGS@ +# This is used from the libjvm build for C/C++ code. +HOTSPOT_BUILD_JOBS:=@CONCURRENT_BUILD_JOBS@ +# Control wether Hotspot runs Queens test after building +TEST_IN_BUILD=@TEST_IN_BUILD@ + #################################################### # # INSTALLATION @@ -611,10 +630,9 @@ INSTALL_SYSCONFDIR=@sysconfdir@ # Name of Service Agent library SALIB_NAME=@SALIB_NAME@ -# Control wether Hotspot runs Queens test after building -TEST_IN_BUILD=@TEST_IN_BUILD@ - OS_VERSION_MAJOR:=@OS_VERSION_MAJOR@ OS_VERSION_MINOR:=@OS_VERSION_MINOR@ OS_VERSION_MICRO:=@OS_VERSION_MICRO@ +# Include the closed-spec.gmk file if it exists +-include $(dir @SPEC@)/closed-spec.gmk diff --git a/common/bin/compareimage.sh b/common/bin/compareimage.sh index 2e9e8051384..0e5d1f031dd 100644 --- a/common/bin/compareimage.sh +++ b/common/bin/compareimage.sh @@ -177,40 +177,44 @@ else fi fi -if [ "`uname`" == "SunOS" ]; then - PERM="gstat -c%a" -elif [ $OSTYPE == "cygwin" ]; then - PERM= -elif [ "`uname`" == "Darwin" ]; then - PERM="stat -f%p" -elif [ "`uname`" == "Linux" ]; then - PERM="stat -c%A" -else - PERM="stat -c%a" -fi +echo -n Permissions... +found="" +for f in `cd $OLD && find . -type f` +do + if [ ! -f ${OLD}/$f ]; then continue; fi + if [ ! -f ${NEW}/$f ]; then continue; fi + OP=`ls -l ${OLD}/$f | awk '{printf("%.10s\n", $1);}'` + NP=`ls -l ${NEW}/$f | awk '{printf("%.10s\n", $1);}'` + if [ "$OP" != "$NP" ] + then + if [ -z "$found" ]; then echo ; found="yes"; fi + printf "\told: ${OP} new: ${NP}\t$f\n" + fi -if [ "${PERM}" ] -then - echo -n Permissions... - found="" - for f in `cd $OLD && find . -type f` - do - if [ ! -f ${OLD}/$f ]; then continue; fi - if [ ! -f ${NEW}/$f ]; then continue; fi - OP=`${PERM} ${OLD}/$f` - NP=`${PERM} ${NEW}/$f` - if [ "$OP" != "$NP" ] + OF=`cd ${OLD} && file $f` + NF=`cd ${NEW} && file $f` + if [ "$f" = "./src.zip" ] + then + if [ "`echo $OF | grep -ic zip`" -gt 0 -a "`echo $NF | grep -ic zip`" -gt 0 ] then - if [ -z "$found" ]; then echo ; found="yes"; fi - printf "\told: ${OP} new: ${NP}\t$f\n" + # the way we produces zip-files make it so that directories are stored in old file + # but not in new (only files with full-path) + # this makes file-5.09 report them as different + continue; fi - done - if [ -z "$found" ]; then echo ; found="yes"; fi -fi + fi + + if [ "$OF" != "$NF" ] + then + if [ -z "$found" ]; then echo ; found="yes"; fi + printf "\tFILE: old: ${OF} new: ${NF}\t$f\n" + fi +done +if [ -z "$found" ]; then echo ; found="yes"; fi GENERAL_FILES=$(cd $OLD && find . -type f ! -name "*.so" ! -name "*.jar" ! -name "*.zip" \ ! -name "*.debuginfo" ! -name "*.dylib" ! -name "jexec" \ - ! -name "ct.sym" \ + ! -name "ct.sym" ! -name "*.diz" \ | grep -v "./bin/" | sort | $FILTER) echo General files... for f in $GENERAL_FILES diff --git a/common/bin/diffexec.sh b/common/bin/diffexec.sh index 8621e9147f1..85f7b67c69f 100644 --- a/common/bin/diffexec.sh +++ b/common/bin/diffexec.sh @@ -49,21 +49,24 @@ then fi if [ "`uname`" == "SunOS" ]; then - NM=gnm - STAT="gstat -c%s" + if [ -f "`which nm`" ]; then + NM=nm + elif [ -f "`which gnm`" ]; then + NM=gnm + else + echo "No nm command found" + exit 10 + fi LDD=ldd elif [ $OSTYPE == "cygwin" ]; then NM="$VS100COMNTOOLS/../../VC/bin/amd64/dumpbin.exe" NM_ARGS=/exports - STAT="stat -c%s" LDD= elif [ "`uname`" == "Darwin" ]; then NM=nm - STAT="stat -f%z" LDD="otool -L" else NM=nm - STAT="stat -c%s" LDD=ldd fi @@ -79,8 +82,8 @@ fi OLD=$(cd $(dirname $1) && pwd)/$(basename $1) NEW=$(cd $(dirname $2) && pwd)/$(basename $2) -OLD_SIZE=$($STAT "$OLD") -NEW_SIZE=$($STAT "$NEW") +OLD_SIZE=$(ls -l "$OLD" | awk '{ print $5 }') +NEW_SIZE=$(ls -l "$NEW" | awk '{ print $5 }') if [ $# -gt 3 ] then diff --git a/common/bin/diffjarzip.sh b/common/bin/diffjarzip.sh index 3bd96b7e112..6ad0a42c2f6 100644 --- a/common/bin/diffjarzip.sh +++ b/common/bin/diffjarzip.sh @@ -72,7 +72,11 @@ else fi if [ "`uname`" == "SunOS" ]; then - DIFF=gdiff + if [ -f "`which gdiff`" ]; then + DIFF=gdiff + else + DIFF=diff + fi else DIFF=diff fi diff --git a/common/bin/difflib.sh b/common/bin/difflib.sh index e6f8a20ee9a..dc5eed14877 100644 --- a/common/bin/difflib.sh +++ b/common/bin/difflib.sh @@ -53,21 +53,27 @@ then fi if [ "`uname`" == "SunOS" ]; then - NM=gnm - STAT="gstat -c%s" + if [ -f "`which gnm`" ]; then + NM=gnm +# Jonas 2012-05-29: solaris native nm produces radically different output than gnm +# so if using that...we need different filter than "cut -f 2-" +# + elif [ -f "`which nm`" ]; then + NM=nm + else + echo "No nm command found" + exit 10 + fi LDD=ldd elif [ $OSTYPE == "cygwin" ]; then NM="$VS100COMNTOOLS/../../VC/bin/amd64/dumpbin.exe" NM_ARGS=/exports - STAT="stat -c%s" LDD= elif [ "`uname`" == "Darwin" ]; then NM=nm - STAT="stat -f%z" LDD="otool -L" else NM=nm - STAT="stat -c%s" LDD=ldd fi @@ -83,8 +89,8 @@ fi OLD=$(cd $(dirname $1) && pwd)/$(basename $1) NEW=$(cd $(dirname $2) && pwd)/$(basename $2) -OLD_SIZE=$($STAT "$OLD") -NEW_SIZE=$($STAT "$NEW") +OLD_SIZE=$(ls -l "$OLD" | awk '{ print $5 }') +NEW_SIZE=$(ls -l "$NEW" | awk '{ print $5 }') if [ $# -gt 3 ] then @@ -122,8 +128,8 @@ then exit 0 fi -OLD_SYMBOLS=$COMPARE_ROOT/$OLD_NAME.old -NEW_SYMBOLS=$COMPARE_ROOT/$NEW_NAME.new +OLD_SYMBOLS=$COMPARE_ROOT/nm.$OLD_NAME.old +NEW_SYMBOLS=$COMPARE_ROOT/nm.$NEW_NAME.new mkdir -p $(dirname $OLD_SYMBOLS) mkdir -p $(dirname $NEW_SYMBOLS) diff --git a/common/makefiles/IdlCompilation.gmk b/common/makefiles/IdlCompilation.gmk index ae85d378d6f..41758011ac9 100644 --- a/common/makefiles/IdlCompilation.gmk +++ b/common/makefiles/IdlCompilation.gmk @@ -87,6 +87,8 @@ $(if $6,$1_$(strip $6)) $(if $7,$1_$(strip $7)) $(if $8,$1_$(strip $8)) $(if $9,$1_$(strip $9)) +$(if $(10),$(error Internal makefile error: Too many arguments to SetupIdlCompilation, please update IdlCompilation.gmk)) + # Remove any relative addressing in the paths. $1_SRC := $$(abspath $$($1_SRC)) $1_BIN := $$(abspath $$($1_BIN)) @@ -111,4 +113,3 @@ $$(foreach p,$$($1),$$(eval $$(call add_idl_package,$1,$$($1_SRC),$$($1_BIN),$$( endef .SUFFIXES: .java .class .package - diff --git a/common/makefiles/JavaCompilation.gmk b/common/makefiles/JavaCompilation.gmk index a9ddb11a644..38d20969d5c 100644 --- a/common/makefiles/JavaCompilation.gmk +++ b/common/makefiles/JavaCompilation.gmk @@ -94,6 +94,7 @@ define SetupJavaCompiler $(if $7,$1_$(strip $7)) $(if $8,$1_$(strip $8)) $(if $9,$1_$(strip $9)) + $(if $(10),$(error Internal makefile error: Too many arguments to SetupJavaCompiler, please update JavaCompilation.gmk)) ifeq ($$($1_MODE),MULTI_CORE_CONCURRENT) ifneq (,$$($1_SERVER_DIR)) @@ -130,6 +131,7 @@ define SetupArchive # SKIP_METAINF:=Set to prevent contents of an META-INF directory to be automatically # added to the archive. # EXTRA_MANIFEST_ATTR:=Extra attribute to add to manifest. + # CHECK_COMPRESS_JAR Check the COMPRESS_JAR variable $(if $3,$1_$(strip $3)) $(if $4,$1_$(strip $4)) $(if $5,$1_$(strip $5)) @@ -143,6 +145,7 @@ define SetupArchive $(if $(13),$1_$(strip $(13))) $(if $(14),$1_$(strip $(14))) $(if $(15),$1_$(strip $(15))) + $(if $(16),$(error Internal makefile error: Too many arguments to SetupArchive, please update JavaCompilation.gmk)) $1_JARMAIN:=$(strip $$($1_JARMAIN)) $1_JARNAME:=$$(notdir $$($1_JAR)) @@ -243,6 +246,16 @@ define SetupArchive ($(FIND) $$(src) -name _the.package -exec $(TOUCH) -r $$($1_JAR) \{\} \; ; true) &&) # Use a slightly shorter name for logging, but with enough path to identify this jar. $1_NAME:=$$(subst $$(OUTPUT_ROOT)/,,$$($1_JAR)) + + ifneq (,$$($1_CHECK_COMPRESS_JAR)) + $1_JAR_CREATE_OPTIONS := c0fm + ifeq ($(COMPRESS_JARS), true) + $1_JAR_CREATE_OPTIONS := cfm + endif + else + $1_JAR_CREATE_OPTIONS := cfm + endif + # Here is the rule that creates/updates the jar file. $$($1_JAR) : $2 $$($1_ALL_SRC) $(MKDIR) -p $$($1_BIN) @@ -283,7 +296,7 @@ define SetupArchive $$(foreach src,$$($1_SRCS),($(FIND) $$(src) -name _the.package.api.notify $(FIND_DELETE); true) &&) true ; \ fi ; \ else \ - $(ECHO) Creating $$($1_NAME) && $(JAR) cfm $$@ $$($1_MANIFEST_FILE) && \ + $(ECHO) Creating $$($1_NAME) && $(JAR) $$($1_JAR_CREATE_OPTIONS) $$@ $$($1_MANIFEST_FILE) && \ $$($1_SCAPTURE_CONTENTS) \ $$($1_SCAPTURE_METAINF) \ $$($1_SUPDATE_CONTENTS) \ @@ -311,6 +324,7 @@ define SetupZipArchive $(if $7,$1_$(strip $7)) $(if $8,$1_$(strip $8)) $(if $9,$1_$(strip $9)) + $(if $(10),$(error Internal makefile error: Too many arguments to SetupZipArchive, please update JavaCompilation.gmk)) # Find all files in the source tree. $1_SUFFIX_FILTER := $$(patsubst %,-o -name $(DQUOTE)*%$(DQUOTE),$$($1_SUFFIXES)) @@ -648,6 +662,7 @@ define SetupJavaCompilation $(if $(12),$1_$(strip $(12))) $(if $(13),$1_$(strip $(13))) $(if $(14),$1_$(strip $(14))) + $(if $(15),$(error Internal makefile error: Too many arguments to SetupJavaCompilation, please update JavaCompilation.gmk)) # Extract the info from the java compiler setup. $1_MODE := $$($$($1_SETUP)_MODE) @@ -688,6 +703,12 @@ $1_BINS := $$(shell $(FIND) $$($1_BIN) -name "*.class") # Now we have a list of all java files to compile: $$($1_SRCS) # and we have a list of all existing class files: $$($1_BINS) +# Create the corresponding smart javac wrapper command line. +$1_SJAVAC_ARGS:=$$(addprefix -x ,$$(addsuffix .*,$$(subst /,.,$$($1_EXCLUDES)))) \ +$$(addprefix -i ,$$(addsuffix .*,$$(subst /,.,$$($1_INCLUDES)))) \ +$$(addprefix -xf *,$$(strip $$($1_EXCLUDE_FILES))) \ +$$(addprefix -if *,$$(strip $$($1_INCLUDE_FILES))) -src $$(subst $$(SPACE),$$(PATH_SEP),$$(strip $$($1_SRC))) + # Prepend the source/bin path to the filter expressions. ifneq ($$($1_INCLUDES),) $1_SRC_INCLUDES := $$(foreach i,$$($1_SRC),$$(addprefix $$i/,$$(addsuffix /%,$$($1_INCLUDES)))) @@ -799,6 +820,12 @@ ifeq ($$($1_MODE),SINGLE_THREADED_BATCH) $(RM) $$($1_BIN)/_the.batch $$($1_BIN)/_the.batch.tmp $$(call ListPathsSafely,$1_SRCS,\n, >> $$($1_BIN)/_the.batch.tmp) $(ECHO) Compiling `$(WC) $$($1_BIN)/_the.batch.tmp | $(TR) -s ' ' | $(CUT) -f 2 -d ' '` files in batch $1 +ifeq ($$($1_NOSJAVAC),) +ifeq ($$(ENABLE_SJAVAC),yes) + mkdir -p $$($1_BIN)_sjavac + $$($1_JVM) $$(word 1,$$($1_JAVAC)) com.sun.tools.javac.smart.Main $$($1_SJAVAC_ARGS) -mfl $$($1_BIN)/_the.batch.tmp -d $$($1_BIN)_sjavac +endif +endif ($$($1_JVM) $$($1_JAVAC) $$($1_FLAGS) -implicit:none -sourcepath "$$($1_SRCROOTSC)" -d $$($1_BIN) $$($1_HEADERS_ARG) @$$($1_BIN)/_the.batch.tmp && \ $(MV) $$($1_BIN)/_the.batch.tmp $$($1_BIN)/_the.batch) else @@ -890,5 +917,3 @@ ifneq (,$$($1_SRCZIP)) endif endef - - diff --git a/common/makefiles/MakeBase.gmk b/common/makefiles/MakeBase.gmk index 3018a414f3b..be0a6726a28 100644 --- a/common/makefiles/MakeBase.gmk +++ b/common/makefiles/MakeBase.gmk @@ -138,6 +138,7 @@ endef # Hook to be called as the very first thing when running a normal build define AtRootMakeStart + $(if $(findstring -j,$(MAKEFLAGS)), $(error make -j is not supported, use make JOBS=n)) $(call PrintStartMessage) $(call StartTimer) endef diff --git a/common/makefiles/Makefile b/common/makefiles/Makefile index 77420a84296..de5da99f78b 100644 --- a/common/makefiles/Makefile +++ b/common/makefiles/Makefile @@ -26,241 +26,128 @@ # This must be the first rule default: all -# Find out which variables were passed explicitely on the make command line. These -# will be passed on to sub-makes, overriding spec.gmk settings. -MAKE_ARGS=$(foreach var,$(subst =command,,$(filter %=command,$(foreach var,$(.VARIABLES),$(var)=$(firstword $(origin $(var)))))),$(var)=$($(var))) - -define fatal-error - # If the user specificed a "global" target (e.g. 'help'), do not exit but continue running - $$(if $$(findstring help,$$(MAKECMDGOALS)),,$$(error Cannot continue)) -endef - -ifeq ($(origin VERBOSE),undefined) - # Setup logging according to LOG (but only if VERBOSE is not given) - ifeq ($(LOG),) - # Set LOG to "warn" as default if not set (and no VERBOSE given) - LOG=warn - endif - ifeq ($(LOG),warn) - VERBOSE=-s - else ifeq ($(LOG),info) - VERBOSE= - else ifeq ($(LOG),debug) - VERBOSE= - else ifeq ($(LOG),trace) - VERBOSE=-d -p - else - $(info Error: LOG must be one of: warn, info, debug or trace.) - $(eval $(call fatal-error)) - endif -else - ifneq ($(LOG),) - # We have both a VERBOSE and a LOG argument. This is OK only if this is a repeated call by ourselves, - # but complain if this is the top-level make call. - ifeq ($(MAKELEVEL),0) - $(info Cannot use LOG=$(LOG) and VERBOSE=$(VERBOSE) at the same time. Choose one.) - $(eval $(call fatal-error)) - endif - endif -endif - -# TODO: Fix duplication in MakeBase.gmk -define SetupLogging - ifneq ($(findstring $(LOG),debug trace),) - # Shell redefinition trick inspired by http://www.cmcrossroads.com/ask-mr-make/6535-tracing-rule-execution-in-gnu-make - OLD_SHELL:=$$(SHELL) - SHELL = $$(warning Building $$@$$(if $$<, (from $$<))$(if $$?, ($$? newer)))$$(OLD_SHELL) -x - endif -endef - -$(eval $(call SetupLogging)) - -# Find all environment or command line variables that begin with ALT. -list_alt_overrides_with_origins = $(filter ALT_%=environment ALT_%=command,$(foreach var,$(.VARIABLES),$(var)=$(firstword $(origin $(var))))) -list_alt_overrides=$(subst =command,,$(subst =environment,,$(list_alt_overrides_with_origins))) - +# Locate this Makefile ifeq ($(filter /%,$(lastword $(MAKEFILE_LIST))),) - makefile_path=$(CURDIR)/$(lastword $(MAKEFILE_LIST)) + makefile_path:=$(CURDIR)/$(lastword $(MAKEFILE_LIST)) else - makefile_path=$(lastword $(MAKEFILE_LIST)) + makefile_path:=$(lastword $(MAKEFILE_LIST)) endif -root_dir=$(patsubst %/common/makefiles/Makefile,%,$(makefile_path)) -output_dir=$(root_dir)/build +root_dir:=$(patsubst %/common/makefiles/Makefile,%,$(makefile_path)) -ifneq ($(origin SPEC),undefined) - # We have been given a SPEC, check that it works out properly - ifeq ($(wildcard $(SPEC)),) - $(info Cannot locate spec.gmk, given by SPEC=$(SPEC)) - $(eval $(call fatal-error)) - endif - ifneq ($(origin CONF),undefined) - # We also have a CONF argument. This is OK only if this is a repeated call by ourselves, - # but complain if this is the top-level make call. - ifeq ($(MAKELEVEL),0) - $(info Cannot use CONF=$(CONF) and SPEC=$(SPEC) at the same time. Choose one.) - $(eval $(call fatal-error)) - endif - endif - # ... OK, we're satisfied, we'll use this SPEC later on -else - # Find all spec.gmk files in the build output directory - all_spec_files=$(wildcard $(output_dir)/*/spec.gmk) - ifeq ($(all_spec_files),) - $(info No configurations found for $(root_dir)! Please run configure to create a configuration.) - $(eval $(call fatal-error)) - endif - # Extract the configuration names from the path - all_confs=$(patsubst %/spec.gmk,%,$(patsubst $(output_dir)/%,%,$(all_spec_files))) +# ... and then we can include our helper functions +include $(dir $(makefile_path))/MakeHelpers.gmk - ifneq ($(origin CONF),undefined) - # User have given a CONF= argument. - ifeq ($(CONF),) - # If given CONF=, match all configurations - matching_confs=$(strip $(all_confs)) - else - # Otherwise select those that contain the given CONF string - matching_confs=$(strip $(foreach var,$(all_confs),$(if $(findstring $(CONF),$(var)),$(var)))) - endif - ifeq ($(matching_confs),) - $(info No configurations found matching CONF=$(CONF)) - $(info Available configurations:) - $(foreach var,$(all_confs),$(info * $(var))) - $(eval $(call fatal-error)) - else - ifeq ($(words $(matching_confs)),1) - $(info Building '$(matching_confs)' (matching CONF=$(CONF))) - else - $(info Building the following configurations (matching CONF=$(CONF)):) - $(foreach var,$(matching_confs),$(info * $(var))) - endif - endif +$(eval $(call ParseLogLevel)) +$(eval $(call SetupLogging)) +$(eval $(call ParseConfAndSpec)) - # Create a SPEC definition. This will contain the path to one or more spec.gmk files. - SPEC=$(addsuffix /spec.gmk,$(addprefix $(output_dir)/,$(matching_confs))) - else - # No CONF or SPEC given, check the available configurations - ifneq ($(words $(all_spec_files)),1) - $(info No CONF or SPEC given, but more than one spec.gmk found in $(output_dir).) - $(info Available configurations:) - $(foreach var,$(all_confs),$(info * $(var))) - $(info Please retry building with CONF= or SPEC=) - $(eval $(call fatal-error)) - endif - - # We found exactly one configuration, use it - SPEC=$(strip $(all_spec_files)) - endif +# Setup number of jobs to use. -jN is unfortunately not available for us to parse from the command line, +# hence this workaround. +ifeq ($(JOBS),) + JOBS=$(NUM_CORES) endif ifneq ($(words $(SPEC)),1) -# We have multiple configurations to build, call make repeatedly -all jdk hotspot jaxws jaxp corba langtools install images packages clean dist-clean: +### We have multiple configurations to build, call make repeatedly +all jdk hotspot jaxws jaxp corba langtools install images clean dist-clean: @$(foreach spec,$(SPEC),($(MAKE) -f $(makefile_path) SPEC=$(spec) $(VERBOSE) VERBOSE=$(VERBOSE) $@ $(MAKE_ARGS)) &&) true -.PHONY: all jdk hotspot jaxws jaxp corba langtools install images packages clean dist-clean +.PHONY: all jdk hotspot jaxws jaxp corba langtools install images clean dist-clean else -# This is the main part of the Makefile, for the normal case with SPEC specifying a single existing spec.gmk file. +### This is the main part of the Makefile, for the normal case with SPEC specifying a single existing spec.gmk file. # Now load the spec --include $(SPEC) +include $(SPEC) # Load the vital tools for all the makefiles. --include $(SRC_ROOT)/common/makefiles/MakeBase.gmk +include $(SRC_ROOT)/common/makefiles/MakeBase.gmk -# Remove any build.log from a previous run +### Clean up from previous run + +# Remove any build.log from a previous run, if they exist ifneq (,$(BUILD_LOG)) - $(shell $(RM) $(BUILD_LOG)) + ifneq (,$(BUILD_LOG_PREVIOUS)) + # Rotate old log + $(shell $(RM) $(BUILD_LOG_PREVIOUS) 2> /dev/null) + $(shell $(MV) $(BUILD_LOG) $(BUILD_LOG_PREVIOUS) 2> /dev/null) + else + $(shell $(RM) $(BUILD_LOG) 2> /dev/null) + endif endif - # Remove any javac server logs and port files. This # prevents a new make run to reuse the previous servers. ifneq (,$(JAVAC_SERVERS)) $(shell mkdir -p $(JAVAC_SERVERS) && rm -rf $(JAVAC_SERVERS)/*) endif -# Reset the build timers. -$(eval $(call ResetTimers)) # Clean out any notifications from the previous build. $(shell find $(OUTPUT_ROOT) -name "_the.*.notify" $(FIND_DELETE)) -# If make was called explicitely with -j, don't add a -j ourself to sub-makes, since -# this will be inherited automatically by make. Otherwise use our default for sub-makes. -# The -j in MAKEFLAGS is only visible when executing a recipe, hence this macro. -define GetMakeJobFlag - $(if $(findstring -j,$(MAKEFLAGS)),,-j$(NUM_CORES)) -endef +# Reset the build timers. +$(eval $(call ResetTimers)) -define CheckEnvironment - $(if $(list_alt_overrides), - @$(PRINTF) "\nWARNING: You have the following ALT_ variables set:\n" - @$(PRINTF) "$(foreach var,$(list_alt_overrides),$(var)=$$$(var))\n" - @$(PRINTF) "ALT_ variables are deprecated and will be ignored. Please clean your environment.\n" - ) -endef - -define PrintStartMessage - $(if $(VERBOSE),,@$(ECHO) Running make as $(MAKE) $(MFLAGS) $(MAKE_ARGS)) - $(call CheckEnvironment) - @$(ECHO) "Building OpenJDK for target $(if $(MAKECMDGOALS),'$(MAKECMDGOALS)','all') in configuration '$(CONF_NAME)'" -endef - -define PrintEndMessage - @$(ECHO) "Finished building OpenJDK for target '$@'" - $(call CheckEnvironment) -endef +### Main targets all: jdk @$(if $(JAVAC_SERVERS),rm -rf $(JAVAC_SERVERS)/*.port) @$(call AtRootMakeEnd) -langtools: start-make +langtools: start-make langtools-only +langtools-only: @$(call MakeStart,langtools,all) - @($(CD) $(LANGTOOLS_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) $(call GetMakeJobFlag) $(LANGTOOLS_MAKE_ARGS) $(MAKE_ARGS)) + @($(CD) $(LANGTOOLS_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) -j$(JOBS) $(MAKE_ARGS)) @$(call MakeFinish,langtools,all) -corba: langtools +corba: langtools corba-only +corba-only: @$(call MakeStart,corba,all) - @($(CD) $(CORBA_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) $(call GetMakeJobFlag) $(CORBA_MAKE_ARGS) $(MAKE_ARGS)) + @($(CD) $(CORBA_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) -j$(JOBS) $(MAKE_ARGS)) @$(call MakeFinish,corba,all) -jaxp: langtools +jaxp: langtools jaxp-only +jaxp-only: @$(call MakeStart,jaxp,all) - @($(CD) $(JAXP_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) $(call GetMakeJobFlag) $(CORBA_MAKE_ARGS) $(MAKE_ARGS)) + @($(CD) $(JAXP_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) -j$(JOBS) $(MAKE_ARGS)) @$(call MakeFinish,jaxp,all) -jaxws: langtools jaxp +jaxws: langtools jaxp jaxws-only +jaxws-only: @$(call MakeStart,jaxws,all) - @($(CD) $(JAXWS_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) $(call GetMakeJobFlag) $(CORBA_MAKE_ARGS) $(MAKE_ARGS)) + @($(CD) $(JAXWS_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) -j$(JOBS) $(MAKE_ARGS)) @$(call MakeFinish,jaxws,all) -hotspot: langtools +hotspot: langtools hotspot-only +hotspot-only: @$(call MakeStart,hotspot,all) @($(CD) $(HOTSPOT_TOPDIR)/make && $(BUILD_LOG_WRAPPER) $(MAKE) -j1 $(HOTSPOT_MAKE_ARGS) $(MAKE_ARGS)) @$(call MakeFinish,hotspot,all) -jdk: langtools corba jaxp jaxws hotspot +jdk: langtools corba jaxp jaxws hotspot jdk-only +jdk-only: @$(call MakeStart,jdk,all) - @($(CD) $(JDK_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) $(call GetMakeJobFlag) $(JDK_MAKE_ARGS) $(MAKE_ARGS)) + @($(CD) $(JDK_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) -j$(JOBS) $(MAKE_ARGS)) @$(call MakeFinish,jdk,all) -images install packages: source-tips start-make jdk langtools corba jaxp jaxws hotspot +images: source-tips start-make jdk langtools corba jaxp jaxws hotspot images-only +images-only: @$(call MakeStart,jdk-images,$@) - @($(CD) $(JDK_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) $(call GetMakeJobFlag) $(JDK_MAKE_ARGS) $(MAKE_ARGS) $@) + @($(CD) $(JDK_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) -j$(JOBS) $(JDK_MAKE_ARGS) $(MAKE_ARGS) images) @$(call MakeFinish,jdk-images,$@) @$(if $(JAVAC_SERVERS),rm -rf $(JAVAC_SERVERS)/*.port) @$(call AtRootMakeEnd) -old-images: source-tips start-make jdk langtools corba jaxp jaxws hotspot - @$(call MakeStart,jdk-old-images,$@) - @($(CD) $(JDK_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) $(call GetMakeJobFlag) $(JDK_MAKE_ARGS) $(MAKE_ARGS) $@) - @$(call MakeFinish,old-jdk-images,$@) +install: source-tips start-make jdk langtools corba jaxp jaxws hotspot install-only +install-only: + @$(call MakeStart,jdk-images,$@) + @($(CD) $(JDK_TOPDIR)/makefiles && $(BUILD_LOG_WRAPPER) $(MAKE) -j$(JOBS) $(JDK_MAKE_ARGS) $(MAKE_ARGS) install) + @$(call MakeFinish,jdk-images,$@) @$(if $(JAVAC_SERVERS),rm -rf $(JAVAC_SERVERS)/*.port) @$(call AtRootMakeEnd) start-make: @$(call AtRootMakeStart) -.PHONY: jdk hotspot jaxws jaxp corba langtools install images packages start-make +.PHONY: jdk hotspot jaxws jaxp corba langtools install images start-make test: start-make @$(call MakeStart,test,$(if $(TEST),$(TEST),all)) @@ -281,7 +168,7 @@ $(OUTPUT_ROOT)/source_tips: FRC # Remove everything, except the output from configure. clean: - @(cd $(OUTPUT_ROOT) && $(RM) -r `$(LS) $(OUTPUT_ROOT) | grep -v spec.gmk | grep -v Makefile | grep -v config.status | grep -v config.log | grep -v config.h | grep -v configure-arguments | grep -v "localdevenv.*" | grep -v uncygdrive.exe`) + @(cd $(OUTPUT_ROOT) && $(RM) -r `$(LS) $(OUTPUT_ROOT) | grep -v spec.gmk | grep -v spec.sh | grep -v Makefile | grep -v config.status | grep -v config.log | grep -v config.h | grep -v configure-arguments | grep -v "localdevenv.*" | grep -v uncygdrive.exe`) @$(ECHO) Cleaned everything except the build configuration. .PHONY: clean @@ -292,7 +179,7 @@ dist-clean: .PHONY: dist-clean clean-jdk: - @(cd $(OUTPUT_ROOT) && $(RM) -r `$(LS) $(OUTPUT_ROOT) | grep -v spec.gmk | grep -v Makefile | grep -v config.status | grep -v config.log | grep -v config.h | grep -v configure-arguments | \ + @(cd $(OUTPUT_ROOT) && $(RM) -r `$(LS) $(OUTPUT_ROOT) | grep -v spec.gmk | grep -v spec.sh | grep -v Makefile | grep -v config.status | grep -v config.log | grep -v config.h | grep -v configure-arguments | \ grep -v langtools | grep -v corba | grep -v jaxp | grep -v jaxws | grep -v hotspot`) @$(ECHO) "Cleaned jdk build artifacts (but not langtools,corba,jaxp,jaxws,hotspot nor the build configuration)" .PHONY: clean diff --git a/common/makefiles/NativeCompilation.gmk b/common/makefiles/NativeCompilation.gmk index ee18f186c8e..d259459cf8f 100644 --- a/common/makefiles/NativeCompilation.gmk +++ b/common/makefiles/NativeCompilation.gmk @@ -51,47 +51,55 @@ define add_native_source # param 5 = the c compiler # param 6 = the c++ flags to the compiler # param 7 = the c++ compiler + # param 8 = the flags to the assembler ifneq (,$$(filter %.c,$2)) # Compile as a C file - $1_$2_FLAGS=$4 $$($1_$(notdir $2)_CFLAGS) + $1_$2_FLAGS=$4 $$($1_$(notdir $2)_CFLAGS) -c $1_$2_COMP=$5 $1_$2_DEP_FLAG:=$(C_FLAG_DEPS) else ifneq (,$$(filter %.m,$2)) # Compile as a objective-c file - $1_$2_FLAGS=-x objective-c $4 $$($1_$(notdir $2)_CFLAGS) + $1_$2_FLAGS=-x objective-c $4 $$($1_$(notdir $2)_CFLAGS) -c $1_$2_COMP=$5 $1_$2_DEP_FLAG:=$(C_FLAG_DEPS) + else ifneq (,$$(filter %.s,$2)) + # Compile as assembler file + $1_$2_FLAGS=$8 + $1_$2_COMP=$(AS) + $1_$2_DEP_FLAG:= else # Compile as a C++ file - $1_$2_FLAGS=$6 $$($1_$(notdir $2)_CXXFLAGS) + $1_$2_FLAGS=$6 $$($1_$(notdir $2)_CXXFLAGS) -c $1_$2_COMP=$7 $1_$2_DEP_FLAG:=$(CXX_FLAG_DEPS) endif # Generate the .o (.obj) file name and place it in the bin dir. - $1_$2_OBJ:=$3/$$(patsubst %.cpp,%$(OBJ_SUFFIX),$$(patsubst %.c,%$(OBJ_SUFFIX),$$(patsubst %.m,%$(OBJ_SUFFIX),$$(notdir $2)))) + $1_$2_OBJ:=$3/$$(patsubst %.cpp,%$(OBJ_SUFFIX),$$(patsubst %.c,%$(OBJ_SUFFIX),$$(patsubst %.m,%$(OBJ_SUFFIX),$$(patsubst %.s,%$(OBJ_SUFFIX),$$(notdir $2))))) # Only continue if this object file hasn't been processed already. This lets the first found # source file override any other with the same name. ifeq (,$$(findstring $$($1_$2_OBJ),$$($1_OBJS_SO_FAR))) $1_OBJS_SO_FAR+=$$($1_$2_OBJ) - # And this is the dependency file for this obj file. - $1_$2_DEP:=$$(patsubst %$(OBJ_SUFFIX),%.d,$$($1_$2_OBJ)) - # Include previously generated dependency information. (if it exists) - -include $$($1_$2_DEP) + ifeq (,$$(filter %.s,$2)) + # And this is the dependency file for this obj file. + $1_$2_DEP:=$$(patsubst %$(OBJ_SUFFIX),%.d,$$($1_$2_OBJ)) + # Include previously generated dependency information. (if it exists) + -include $$($1_$2_DEP) - ifeq ($(COMPILER_TYPE),CL) - $1_$2_DEBUG_OUT_FLAGS:=-Fd$$(patsubst %$(OBJ_SUFFIX),%.pdb,$$($1_$2_OBJ)) \ - -Fm$$(patsubst %$(OBJ_SUFFIX),%.map,$$($1_$2_OBJ)) + ifeq ($(COMPILER_TYPE),CL) + $1_$2_DEBUG_OUT_FLAGS:=-Fd$$(patsubst %$(OBJ_SUFFIX),%.pdb,$$($1_$2_OBJ)) \ + -Fm$$(patsubst %$(OBJ_SUFFIX),%.map,$$($1_$2_OBJ)) + endif endif $$($1_$2_OBJ) : $2 ifeq ($(COMPILER_TYPE),CC) $$(call COMPILING_MSG,$$(notdir $2)) - $$($1_$2_COMP) $$($1_$2_FLAGS) $$($1_$2_DEP_FLAG) $$($1_$2_DEP) -c $(CC_OUT_OPTION)$$($1_$2_OBJ) $2 + $$($1_$2_COMP) $$($1_$2_FLAGS) $$($1_$2_DEP_FLAG) $$($1_$2_DEP) $(CC_OUT_OPTION)$$($1_$2_OBJ) $2 endif ifeq ($(COMPILER_TYPE),CL) $$(call COMPILING_MSG,$$(notdir $2)) - $$($1_$2_COMP) $$($1_$2_FLAGS) $$($1_$2_DEBUG_OUT_FLAGS) -c $(CC_OUT_OPTION)$$($1_$2_OBJ) $2 + $$($1_$2_COMP) $$($1_$2_FLAGS) $$($1_$2_DEBUG_OUT_FLAGS) $(CC_OUT_OPTION)$$($1_$2_OBJ) $2 endif endif endef @@ -107,9 +115,9 @@ define SetupNativeCompilation # LDFLAGS_SUFFIX the linker flags to be added last on the commandline # typically the libraries linked to. # ARFLAGS the archiver flags to be used - # BIN the directory where we store the object files - # LIB the resulting library file - # EXE the resulting exec file + # OBJECT_DIR the directory where we store the object files + # LIBRARY the resulting library file + # PROGRAM the resulting exec file # INCLUDES only pick source from these directories # EXCLUDES do not pick source from these directories # INCLUDE_FILES only compile exactly these files! @@ -118,6 +126,9 @@ define SetupNativeCompilation # RC_FLAGS flags for RC. # MAPFILE mapfile # REORDER reorder file + # DEBUG_SYMBOLS add debug symbols (if configured on) + # CC the compiler to use, default is $(CC) + # LDEXE the linker to use for linking executables, default is $(LDEXE) $(if $2,$1_$(strip $2)) $(if $3,$1_$(strip $3)) $(if $4,$1_$(strip $4)) @@ -137,13 +148,94 @@ define SetupNativeCompilation $(if $(18),$1_$(strip $(18))) $(if $(19),$1_$(strip $(19))) $(if $(20),$1_$(strip $(20))) + $(if $(21),$1_$(strip $(21))) + $(if $(22),$(error Internal makefile error: Too many arguments to SetupNativeCompilation, please update NativeCompilation.gmk)) + + ifneq (,$$($1_BIN)) + $$(error BIN has been replaced with OBJECT_DIR) + endif + + ifneq (,$$($1_LIB)) + $$(error LIB has been replaced with LIBRARY) + endif + + ifneq (,$$($1_EXE)) + $$(error EXE has been replaced with PROGRAM) + endif + + ifneq (,$$($1_LIBRARY)) + ifeq (,$$($1_OUTPUT_DIR)) + $$(error LIBRARY requires OUTPUT_DIR) + endif + + ifneq ($$($1_LIBRARY),$(basename $$($1_LIBRARY))) + $$(error directory of LIBRARY should be specified using OUTPUT_DIR) + endif + + ifneq (,$(findstring $(SHARED_LIBRARY_SUFFIX),$$($1_LIBRARY))) + $$(error LIBRARY should be specified without SHARED_LIBRARY_SUFFIX: $(SHARED_LIBRARY_SUFFIX)) + endif + + ifneq (,$(findstring $(LIBRARY_PREFIX),$$($1_LIBRARY))) + $$(error LIBRARY should be specified without LIBRARY_PREFIX: $(LIBRARY_PREFIX)) + endif + + $1_BASENAME:=$(LIBRARY_PREFIX)$$($1_LIBRARY)$(SHARED_LIBRARY_SUFFIX) + $1_TARGET:=$$($1_OUTPUT_DIR)/$$($1_BASENAME) + + endif + + ifneq (,$$($1_STATIC_LIBRARY)) + ifeq (,$$($1_OUTPUT_DIR)) + $$(error STATIC_LIBRARY requires OUTPUT_DIR) + endif + + ifneq ($$($1_STATIC_LIBRARY),$(basename $$($1_STATIC_LIBRARY))) + $$(error directory of STATIC_LIBRARY should be specified using OUTPUT_DIR) + endif + + ifneq (,$(findstring $(STATIC_LIBRARY_SUFFIX),$$($1_STATIC_LIBRARY))) + $$(error STATIC_LIBRARY should be specified without STATIC_LIBRARY_SUFFIX: $(STATIC_LIBRARY_SUFFIX)) + endif + + ifneq (,$(findstring $(LIBRARY_PREFIX),$$($1_STATIC_LIBRARY))) + $$(error STATIC_LIBRARY should be specified without LIBRARY_PREFIX: $(LIBRARY_PREFIX)) + endif + + $1_BASENAME:=$(LIBRARY_PREFIX)$$($1_STATIC_LIBRARY)$(STATIC_LIBRARY_SUFFIX) + $1_TARGET:=$$($1_OUTPUT_DIR)/$$($1_BASENAME) + endif + + ifneq (,$$($1_PROGRAM)) + ifeq (,$$($1_OUTPUT_DIR)) + $$(error PROGRAM requires OUTPUT_DIR) + endif + + ifneq ($$($1_PROGRAM),$(basename $$($1_PROGRAM))) + $$(error directory of PROGRAM should be specified using OUTPUT_DIR) + endif + + ifneq (,$(findstring $(EXE_SUFFIX),$$($1_PROGRAM))) + $$(error PROGRAM should be specified without EXE_SUFFIX: $(EXE_SUFFIX)) + endif + + $1_BASENAME:=$$($1_PROGRAM)$(EXE_SUFFIX) + $1_TARGET:=$$($1_OUTPUT_DIR)/$$($1_BASENAME) + + endif + + ifeq (,$$($1_TARGET)) + $$(error Neither PROGRAM, LIBRARY nor STATIC_LIBRARY has been specified for SetupNativeCompilation) + endif ifeq (,$$($1_LANG)) $$(error You have to specify LANG for native compilation $1) endif ifeq (C,$$($1_LANG)) + ifeq ($$($1_LDEXE),) + $1_LDEXE:=$(LDEXE) + endif $1_LD:=$(LD) - $1_LDEXE:=$(LDEXE) else ifeq (C++,$$($1_LANG)) $1_LD:=$(LDCXX) @@ -153,8 +245,12 @@ define SetupNativeCompilation endif endif + ifeq ($$($1_CC),) + $1_CC:=$(CC) + endif + # Make sure the dirs exist. - $$(shell $(MKDIR) -p $$($1_SRC) $$($1_BIN) $$(dir $$($1_LIB)) $$(dir $$($1_EXE))) + $$(shell $(MKDIR) -p $$($1_SRC) $$($1_OBJECT_DIR) $$($1_OUTPUT_DIR)) # Find all files in the source trees. Sort to remove duplicates. $1_ALL_SRCS := $$(sort $$(foreach i,$$($1_SRC), $$(shell $(FIND) $$i -type f))) # Extract the C/C++ files. @@ -163,7 +259,7 @@ define SetupNativeCompilation ifneq ($$($1_EXCLUDE_FILES),) $1_EXCLUDE_FILES:=$$(addprefix %,$$($1_EXCLUDE_FILES)) endif - $1_SRCS := $$(filter-out $$($1_EXCLUDE_FILES),$$(filter %.c %.cpp %.m,$$($1_ALL_SRCS))) + $1_SRCS := $$(filter-out $$($1_EXCLUDE_FILES),$$(filter %.s %.c %.cpp %.m,$$($1_ALL_SRCS))) ifneq (,$$(strip $$($1_INCLUDE_FILES))) $1_SRCS := $$(filter $$($1_INCLUDE_FILES),$$($1_SRCS)) endif @@ -171,7 +267,7 @@ define SetupNativeCompilation $$(error No sources found for $1 when looking inside the dirs $$($1_SRC)) endif # There can be only a single bin dir root, no need to foreach over the roots. - $1_BINS := $$(wildcard $$($1_BIN)/*$(OBJ_SUFFIX)) + $1_BINS := $$(wildcard $$($1_OBJECT_DIR)/*$(OBJ_SUFFIX)) # Now we have a list of all c/c++ files to compile: $$($1_SRCS) # and we have a list of all existing object files: $$($1_BINS) @@ -187,37 +283,36 @@ define SetupNativeCompilation # Calculate the expected output from compiling the sources (sort to remove duplicates. Also provides # a reproducable order on the input files to the linker). - $1_EXPECTED_OBJS:=$$(sort $$(addprefix $$($1_BIN)/,$$(patsubst %.cpp,%$(OBJ_SUFFIX),$$(patsubst %.c,%$(OBJ_SUFFIX),$$(patsubst %.m,%$(OBJ_SUFFIX),$$(notdir $$($1_SRCS))))))) - $1 := $$($1_EXPECTED_OBJS) + $1_EXPECTED_OBJS:=$$(sort $$(addprefix $$($1_OBJECT_DIR)/,$$(patsubst %.cpp,%$(OBJ_SUFFIX),$$(patsubst %.c,%$(OBJ_SUFFIX),$$(patsubst %.m,%$(OBJ_SUFFIX),$$(patsubst %.s,%$(OBJ_SUFFIX),$$(notdir $$($1_SRCS)))))))) # Are there too many object files on disk? Perhaps because some source file was removed? $1_SUPERFLOUS_OBJS:=$$(sort $$(filter-out $$($1_EXPECTED_OBJS),$$($1_BINS))) # Clean out the superfluous object files. $$(shell $(RM) -f $$($1_SUPERFLUOUS_OBJS)) - # Pickup extra HOST_OS_API and/or PLATFORM dependent variables for CFLAGS. - $1_EXTRA_CFLAGS:=$$($1_CFLAGS_$(HOST_OS_API)) $$($1_CFLAGS_$(PLATFORM)) + # Pickup extra OPENJDK_TARGET_OS_API and/or OPENJDK_TARGET_OS dependent variables for CFLAGS. + $1_EXTRA_CFLAGS:=$$($1_CFLAGS_$(OPENJDK_TARGET_OS_API)) $$($1_CFLAGS_$(OPENJDK_TARGET_OS)) ifneq ($(DEBUG_LEVEL),release) # Pickup extra debug dependent variables for CFLAGS $1_EXTRA_CFLAGS+=$$($1_CFLAGS_debug) - $1_EXTRA_CFLAGS+=$$($1_CFLAGS_$(HOST_OS_API)_debug) - $1_EXTRA_CFLAGS+=$$($1_CFLAGS_$(PLATFORM)_debug) + $1_EXTRA_CFLAGS+=$$($1_CFLAGS_$(OPENJDK_TARGET_OS_API)_debug) + $1_EXTRA_CFLAGS+=$$($1_CFLAGS_$(OPENJDK_TARGET_OS)_debug) else $1_EXTRA_CFLAGS+=$$($1_CFLAGS_release) - $1_EXTRA_CFLAGS+=$$($1_CFLAGS_$(HOST_OS_API)_release) - $1_EXTRA_CFLAGS+=$$($1_CFLAGS_$(PLATFORM)_release) + $1_EXTRA_CFLAGS+=$$($1_CFLAGS_$(OPENJDK_TARGET_OS_API)_release) + $1_EXTRA_CFLAGS+=$$($1_CFLAGS_$(OPENJDK_TARGET_OS)_release) endif - # Pickup extra HOST_OS_API and/or PLATFORM dependent variables for CXXFLAGS. - $1_EXTRA_CXXFLAGS:=$$($1_CXXFLAGS_$(HOST_OS_API)) $$($1_CXXFLAGS_$(PLATFORM)) + # Pickup extra OPENJDK_TARGET_OS_API and/or OPENJDK_TARGET_OS dependent variables for CXXFLAGS. + $1_EXTRA_CXXFLAGS:=$$($1_CXXFLAGS_$(OPENJDK_TARGET_OS_API)) $$($1_CXXFLAGS_$(OPENJDK_TARGET_OS)) ifneq ($(DEBUG_LEVEL),release) # Pickup extra debug dependent variables for CXXFLAGS $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_debug) - $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_$(HOST_OS_API)_debug) - $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_$(PLATFORM)_debug) + $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_$(OPENJDK_TARGET_OS_API)_debug) + $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_$(OPENJDK_TARGET_OS)_debug) else $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_release) - $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_$(HOST_OS_API)_release) - $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_$(PLATFORM)_release) + $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_$(OPENJDK_TARGET_OS_API)_release) + $1_EXTRA_CXXFLAGS+=$$($1_CXXFLAGS_$(OPENJDK_TARGET_OS)_release) endif ifeq ($$($1_CXXFLAGS),) @@ -232,33 +327,62 @@ define SetupNativeCompilation $1_EXTRA_CXXFLAGS += $$(CXX_FLAG_REORDER) endif + ifneq (no, $(ENABLE_DEBUG_SYMBOLS)) + ifneq ($(OPENJDK_TARGET_OS), solaris) +# +# There is very weird code in Defs-solaris.gmk that first sets variables as decribed below +# and then a couple of hundreds of line below resets them... +# this feels like a sure bug...but before this is confirmed, mimic this behaviour +# (note: skip indenting this as it will surely be removed anyway) +# + + ifneq (,$$($1_DEBUG_SYMBOLS)) + $1_OPTIMIZATION := LOW + $1_EXTRA_CFLAGS += $(CFLAGS_DEBUG_SYMBOLS) + $1_EXTRA_CXXFLAGS += $(CXXFLAGS_DEBUG_SYMBOLS) + endif + +# + endif +# + endif + + ifeq (NONE, $$($1_OPTIMIZATION)) + $1_EXTRA_CFLAGS += $$(C_O_FLAG_NONE) + $1_EXTRA_CXXFLAGS += $$(CXX_O_FLAG_NONE) + else ifeq (LOW, $$($1_OPTIMIZATION)) + $1_EXTRA_CFLAGS += $$(C_O_FLAG_NORM) + $1_EXTRA_CXXFLAGS += $$(CXX_O_FLAG_NORM) + else ifeq (HIGH, $$($1_OPTIMIZATION)) + $1_EXTRA_CFLAGS += $$(C_O_FLAG_HI) + $1_EXTRA_CXXFLAGS += $$(CXX_O_FLAG_HI) + else ifeq (HIGHEST, $$($1_OPTIMIZATION)) + $1_EXTRA_CFLAGS += $$(C_O_FLAG_HIGHEST) + $1_EXTRA_CXXFLAGS += $$(CXX_O_FLAG_HIGHEST) + else ifneq (, $$($1_OPTIMIZATION)) + $$(error Unknown value for OPTIMIZATION: $$($1_OPTIMIZATION)) + endif + # Now create a list of the packages that are about to compile. Used when sending source # in a batch to the compiler. - $$(shell $(RM) $$($1_BIN)/_the.list_of_sources) - $$(eval $$(call ListPathsSafelyNow,$1_SRCS,\n, >> $$($1_BIN)/_the.list_of_sources)) + $$(shell $(RM) $$($1_OBJECT_DIR)/_the.list_of_sources) + $$(eval $$(call ListPathsSafelyNow,$1_SRCS,\n, >> $$($1_OBJECT_DIR)/_the.list_of_sources)) # Now call add_native_source for each source file we are going to compile. $$(foreach p,$$($1_SRCS),\ - $$(eval $$(call add_native_source,$1,$$p,$$($1_BIN),\ - $$($1_CFLAGS) $$($1_EXTRA_CFLAGS),$(CC),\ - $$($1_CXXFLAGS) $$($1_EXTRA_CXXFLAGS),$(CXX)))) + $$(eval $$(call add_native_source,$1,$$p,$$($1_OBJECT_DIR),\ + $$($1_CFLAGS) $$($1_EXTRA_CFLAGS),$$($1_CC),\ + $$($1_CXXFLAGS) $$($1_EXTRA_CXXFLAGS),$(CXX),$$($1_ASFLAGS)))) # On windows we need to create a resource file - ifeq ($(HOST_OS_API), winapi) + ifeq ($(OPENJDK_TARGET_OS_API), winapi) ifneq (,$$($1_VERSIONINFO_RESOURCE)) - ifneq (,$$($1_LIB)) - $1_BASENAME:=$$(basename $$(notdir $$($1_LIB))) - endif - ifneq (,$$($1_EXE)) - $1_BASENAME:=$$(basename $$(notdir $$($1_EXE))) - endif - $1_RES:=$$($1_BIN)/$$($1_BASENAME).res + $1_RES:=$$($1_OBJECT_DIR)/$$($1_BASENAME).res $$($1_RES): $$($1_VERSIONINFO_RESOURCE) $(RC) $$($1_RC_FLAGS) $(CC_OUT_OPTION)$$@ $$($1_VERSIONINFO_RESOURCE) endif ifneq (,$$($1_MANIFEST)) - $1_PROGRAM:=$$(basename $$(notdir $$($1_EXE))) - $1_GEN_MANIFEST:=$$($1_BIN)/$$($1_PROGRAM).manifest + $1_GEN_MANIFEST:=$$($1_OBJECT_DIR)/$$($1_PROGRAM).manifest IMVERSIONVALUE:=$(JDK_MINOR_VERSION).$(JDK_MICRO_VERSION).$(JDK_UPDATE_VERSION).$(COOKED_BUILD_NUMBER) $$($1_GEN_MANIFEST): $$($1_MANIFEST) $(SED) 's%IMVERSION%$$(IMVERSIONVALUE)%g;s%PROGRAM%$$($1_PROGRAM)%g' $$< > $$@ @@ -266,54 +390,182 @@ define SetupNativeCompilation endif # mapfile doesnt seem to be implemented on macosx (yet??) - ifneq ($(HOST_OS),macosx) - ifneq ($(HOST_OS),windows) - $1_REAL_MAPFILE := $$($1_MAPFILE) + ifneq ($(OPENJDK_TARGET_CPU),ppc) + ifneq ($(OPENJDK_TARGET_CPU),arm) + ifneq ($(OPENJDK_TARGET_OS),macosx) + ifneq ($(OPENJDK_TARGET_OS),windows) + $1_REAL_MAPFILE:=$$($1_MAPFILE) ifneq (,$$($1_REORDER)) - $1_REAL_MAPFILE := $$($1_BIN)/mapfile + $1_REAL_MAPFILE:=$$($1_OBJECT_DIR)/mapfile $$($1_REAL_MAPFILE) : $$($1_MAPFILE) $$($1_REORDER) $$(MKDIR) -p $$(@D) $$(CP) $$($1_MAPFILE) $$@.tmp - $$(SED) -e 's=OUTPUTDIR=$$($1_BIN)=' $$($1_REORDER) >> $$@.tmp + $$(SED) -e 's=OUTPUTDIR=$$($1_OBJECT_DIR)=' $$($1_REORDER) >> $$@.tmp $$(MV) $$@.tmp $$@ endif endif endif + endif + endif - # Pickup extra HOST_OS_API dependent variables (posix or winapi) and + # Pickup extra OPENJDK_TARGET_OS_API dependent variables (posix or winapi) and # (linux,solaris,windows,bsd) for LDFLAGS and LDFLAGS_SUFFIX - $1_EXTRA_LDFLAGS:=$$($1_LDFLAGS_$(HOST_OS_API)) $$($1_LDFLAGS_$(PLATFORM)) - $1_EXTRA_LDFLAGS_SUFFIX:=$$($1_LDFLAGS_SUFFIX_$(HOST_OS_API)) $$($1_LDFLAGS_SUFFIX_$(PLATFORM)) + $1_EXTRA_LDFLAGS:=$$($1_LDFLAGS_$(OPENJDK_TARGET_OS_API)) $$($1_LDFLAGS_$(OPENJDK_TARGET_OS)) + $1_EXTRA_LDFLAGS_SUFFIX:=$$($1_LDFLAGS_SUFFIX_$(OPENJDK_TARGET_OS_API)) $$($1_LDFLAGS_SUFFIX_$(OPENJDK_TARGET_OS)) ifneq (,$$($1_REAL_MAPFILE)) - $1_EXTRA_LDFLAGS += $(call SET_SHARED_LIBRARY_MAPFILE,$$($1_REAL_MAPFILE)) + $1_EXTRA_LDFLAGS += $(call SET_SHARED_LIBRARY_MAPFILE,$$($1_REAL_MAPFILE)) endif - ifneq (,$$($1_LIB)) - ifeq (dynamic,$$(patsubst %$(SHARED_LIBRARY_SUFFIX),dynamic,$$($1_LIB))) - # Generating a dynamic library. - $1_EXTRA_LDFLAGS+=$$(call SET_SHARED_LIBRARY_NAME,$$(notdir $$($1_LIB))) - $$($1_LIB) : $$($1_EXPECTED_OBJS) $$($1_RES) $$($1_REAL_MAPFILE) - $$(call LINKING_MSG,$$(notdir $$($1_LIB))) - $$($1_LD) $$($1_LDFLAGS) $$($1_EXTRA_LDFLAGS) $(LD_OUT_OPTION)$$($1_LIB) \ - $$($1_EXPECTED_OBJS) $$($1_RES) $$($1_LDFLAGS_SUFFIX) $$($1_EXTRA_LDFLAGS_SUFFIX) - else - # Generating a static library, ie object file archive. - $$($1_LIB) : $$($1_EXPECTED_OBJS) $$($1_RES) - $$(call ARCHIVING_MSG,$$(notdir $$($1_LIB))) - $(AR) $$($1_AR_FLAGS) $(AR_OUT_OPTION)$$($1_LIB) $$($1_EXPECTED_OBJS) \ - $$($1_RES) $$($1_LDFLAGS_SUFFIX) $$($1_EXTRA_LDFLAGS_SUFFIX) - endif + $1 := $$($1_TARGET) + ifneq (,$$($1_LIBRARY)) + # Generating a dynamic library. + $1_EXTRA_LDFLAGS+=$$(call SET_SHARED_LIBRARY_NAME,$$($1_BASENAME)) + ifeq ($(OPENJDK_TARGET_OS), windows) + $1_EXTRA_LDFLAGS+="-implib:$$($1_OBJECT_DIR)/$$($1_LIBRARY).lib" + endif + + ifneq (,$$($1_DEBUG_SYMBOLS)) + ifeq ($(ENABLE_DEBUG_SYMBOLS), yes) + ifeq ($(OPENJDK_TARGET_OS), windows) + $1_EXTRA_LDFLAGS+="-pdb:$$($1_OBJECT_DIR)/$$($1_LIBRARY).pdb" \ + "-map:$$($1_OBJECT_DIR)/$$($1_LIBRARY).map" + endif + + $$($1_OUTPUT_DIR)/% : $$($1_OBJECT_DIR)/% + $(CP) $$< $$@ + + + ifeq ($(OPENJDK_TARGET_OS), solaris) + # gobjcopy crashes on "empty" section headers with the SHF_ALLOC flag set. + # Use $(FIX_EMPTY_SEC_HDR_FLAGS) to clear the SHF_ALLOC flag (if set) from + # empty section headers until a fixed $(OBJCOPY) is available. + # An empty section header has sh_addr == 0 and sh_size == 0. + # This problem has only been seen on Solaris X64, but we call this tool + # on all Solaris builds just in case. + # + # $(OBJCOPY) --add-gnu-debuglink=... corrupts SUNW_* sections. + # Use $(ADD_GNU_DEBUGLINK) until a fixed $(OBJCOPY) is available. + $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo : $$($1_TARGET) \ + $(FIX_EMPTY_SEC_HDR_FLAGS) $(ADD_GNU_DEBUGLINK) + $(RM) $$@ + $(FIX_EMPTY_SEC_HDR_FLAGS) $$< + $(OBJCOPY) --only-keep-debug $$< $$@ + $(ADD_GNU_DEBUGLINK) $$@ $$< + else # not solaris + $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo : $$($1_TARGET) + $(RM) $$@ + $(OBJCOPY) --only-keep-debug $$< $$@ + $(OBJCOPY) --add-gnu-debuglink=$$@ $$< + endif + + ifeq ($(ZIP_DEBUGINFO_FILES), 1) + $1 += $$($1_OUTPUT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).diz + + ifeq ($(OPENJDK_TARGET_OS), windows) + $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).diz : $$($1_TARGET) + $(CD) $$($1_OBJECT_DIR) \ + && $(ZIP) -q $$@ $$($1_LIBRARY).map $$($1_LIBRARY).pdb + else + $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).diz : $$($1_TARGET) \ + $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo + $(CD) $$($1_OBJECT_DIR) \ + && $(ZIP) -q $$@ $$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo + endif + else + ifeq ($(OPENJDK_TARGET_OS), windows) + $1 += $$($1_OUTPUT_DIR)/$$($1_LIBRARY).map \ + $$($1_OUTPUT_DIR)/$$($1_LIBRARY).pdb + else + $1 += $$($1_OUTPUT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo + endif + endif + endif + endif + + $$($1_TARGET) : $$($1_EXPECTED_OBJS) $$($1_RES) $$($1_REAL_MAPFILE) + $$(call LINKING_MSG,$$($1_BASENAME)) + $$($1_LD) $$($1_LDFLAGS) $$($1_EXTRA_LDFLAGS) $(LD_OUT_OPTION)$$@ \ + $$($1_EXPECTED_OBJS) $$($1_RES) $$($1_LDFLAGS_SUFFIX) \ + $$($1_EXTRA_LDFLAGS_SUFFIX) + endif - ifneq (,$$($1_EXE)) + + ifneq (,$$($1_STATIC_LIBRARY)) + # Generating a static library, ie object file archive. + $$($1_TARGET) : $$($1_EXPECTED_OBJS) $$($1_RES) + $$(call ARCHIVING_MSG,$$($1_LIBRARY)) + $(AR) $$($1_AR_FLAGS) $(AR_OUT_OPTION)$$($1_TARGET) $$($1_EXPECTED_OBJS) \ + $$($1_RES) $$($1_LDFLAGS_SUFFIX) $$($1_EXTRA_LDFLAGS_SUFFIX) + endif + + ifneq (,$$($1_PROGRAM)) # A executable binary has been specified, setup the target for it. - $$($1_EXE) : $$($1_EXPECTED_OBJS) $$($1_RES) $$($1_GEN_MANIFEST) - $$(call LINKING_EXE_MSG,$$(notdir $$($1_EXE))) - $$($1_LDEXE) $$($1_LDFLAGS) $$($1_EXTRA_LDFLAGS) $(EXE_OUT_OPTION)$$($1_EXE) \ + ifneq (,$$($1_DEBUG_SYMBOLS)) + ifeq ($(ENABLE_DEBUG_SYMBOLS), yes) + ifeq ($(OPENJDK_TARGET_OS), windows) + $1_EXTRA_LDFLAGS+="-pdb:$$($1_OBJECT_DIR)/$$($1_PROGRAM).pdb" \ + "-map:$$($1_OBJECT_DIR)/$$($1_PROGRAM).map" + endif + + $$($1_OUTPUT_DIR)/% : $$($1_OBJECT_DIR)/% + $(CP) $$< $$@ + + ifeq ($(OPENJDK_TARGET_OS), solaris) + # gobjcopy crashes on "empty" section headers with the SHF_ALLOC flag set. + # Use $(FIX_EMPTY_SEC_HDR_FLAGS) to clear the SHF_ALLOC flag (if set) from + # empty section headers until a fixed $(OBJCOPY) is available. + # An empty section header has sh_addr == 0 and sh_size == 0. + # This problem has only been seen on Solaris X64, but we call this tool + # on all Solaris builds just in case. + # + # $(OBJCOPY) --add-gnu-debuglink=... corrupts SUNW_* sections. + # Use $(ADD_GNU_DEBUGLINK) until a fixed $(OBJCOPY) is available. + $$($1_OBJECT_DIR)/$$($1_PROGRAM).debuginfo : $$($1_TARGET) \ + $(FIX_EMPTY_SEC_HDR_FLAGS) $(ADD_GNU_DEBUGLINK) + $(RM) $$@ + $(FIX_EMPTY_SEC_HDR_FLAGS) $$< + $(OBJCOPY) --only-keep-debug $$< $$@ + $(ADD_GNU_DEBUGLINK) $$@ $$< + else # not solaris + $$($1_OBJECT_DIR)/$$($1_PROGRAM).debuginfo : $$($1_TARGET) + $(RM) $$@ + $(OBJCOPY) --only-keep-debug $$< $$@ + $(OBJCOPY) --add-gnu-debuglink=$$@ $$< + endif + + ifeq ($(ZIP_DEBUGINFO_FILES), 1) + $1 += $$($1_OUTPUT_DIR)/$$($1_PROGRAM).diz + + ifeq ($(OPENJDK_TARGET_OS), windows) + $$($1_OBJECT_DIR)/$$($1_PROGRAM).diz : $$($1_TARGET) + $(CD) $$($1_OBJECT_DIR) \ + && $(ZIP) -q $$@ $$($1_PROGRAM).map $$($1_PROGRAM).pdb + else + $$($1_OBJECT_DIR)/$$(PROGRAM_PREFIX)$$($1_PROGRAM).diz : $$($1_TARGET) \ + $$($1_OBJECT_DIR)/$$($1_PROGRAM).debuginfo + $(CD) $$($1_OBJECT_DIR) \ + && $(ZIP) -q $$@ $$($1_PROGRAM).debuginfo + endif + else + ifeq ($(OPENJDK_TARGET_OS), windows) + $1 += $$($1_OUTPUT_DIR)/$$($1_PROGRAM).map \ + $$($1_OUTPUT_DIR)/$$($1_PROGRAM).pdb + else + $1 += $$($1_OUTPUT_DIR)/$$($1_PROGRAM).debuginfo + endif + endif + endif + endif + + $$($1_TARGET) : $$($1_EXPECTED_OBJS) $$($1_RES) $$($1_GEN_MANIFEST) + $$(call LINKING_EXE_MSG,$$($1_BASENAME)) + $$($1_LDEXE) $$($1_LDFLAGS) $$($1_EXTRA_LDFLAGS) $(EXE_OUT_OPTION)$$($1_TARGET) \ $$($1_EXPECTED_OBJS) $$($1_RES) $$($1_LDFLAGS_SUFFIX) \ $$($1_EXTRA_LDFLAGS_SUFFIX) ifneq (,$$($1_GEN_MANIFEST)) $(MT) -nologo /manifest $$($1_GEN_MANIFEST) /outputresource:$$@;#1 endif + endif endef diff --git a/common/makefiles/RMICompile.gmk b/common/makefiles/RMICompile.gmk deleted file mode 100644 index b6168dae7be..00000000000 --- a/common/makefiles/RMICompile.gmk +++ /dev/null @@ -1,103 +0,0 @@ -# -# Copyright (c) 2011, 2012 Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. Oracle designates this -# particular file as subject to the "Classpath" exception as provided -# by Oracle in the LICENSE file that accompanied this code. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - -define SetupRMICompilation - # param 1 is a name for a variable to depend on. - # param 2 and up are named args. - # CLASSES:=List of classes to generate stubs for - # CLASSES_DIR:=Directory where to look for classes - # STUB_CLASSES_DIR:=Directory in where to put stub classes - # RUN_V11:=Set to run rmic with -v1.1 - # RUN_V12:=Set to run rmic with -v1.2 - # RUN_IIOP:=Set to run rmic with -iiop - # RUN_IIOP_STDPKG:=Set to run rmic with -iiop -standardPackage - # KEEP_GENERATED:=Set to keep generated sources around - $(if $2,$1_$(strip $2)) - $(if $3,$1_$(strip $3)) - $(if $4,$1_$(strip $4)) - $(if $5,$1_$(strip $5)) - $(if $6,$1_$(strip $6)) - $(if $7,$1_$(strip $7)) - $(if $8,$1_$(strip $8)) - $(if $9,$1_$(strip $9)) - - - $1_DEP_FILE := $$($1_STUB_CLASSES_DIR)/$1_rmic - - $1_CLASSES_SLASH := $$(subst .,/,$$($1_CLASSES)) - $1_CLASS_FILES := $$(addprefix $$($1_CLASSES_DIR)/,$$(addsuffix .class,$$($1_CLASSES_SLASH))) - $1_STUB_FILES := $$(addprefix $$($1_STUB_CLASSES_DIR)/,$$(addsuffix _Stub.class,$$($1_CLASSES_SLASH))) - $1_TARGETS := $$($1_STUB_FILES) - $1_ARGS := - ifneq (,$$($1_RUN_V11)) - $1_SKEL_FILES := $$(addprefix $$($1_STUB_CLASSES_DIR)/,$$(addsuffix _Skel.class,$$($1_CLASSES_SLASH))) - $1_TARGETS += $$($1_SKEL_FILES) - $1_ARGS += -v1.1 - endif - ifneq (,$$($1_RUN_V12)) - $1_ARGS += -v1.2 - endif - - $1_TIE_BASE_FILES := $$(foreach f,$$($1_CLASSES_SLASH),$$(dir $$f)_$$(notdir $$f)) - $1_TIE_FILES := $$(addprefix $$($1_STUB_CLASSES_DIR)/org/omg/stub/,$$(addsuffix _Tie.class,$$($1_TIE_BASE_FILES))) - $1_TIE_STDPKG_FILES := $$(addprefix $$($1_STUB_CLASSES_DIR)/,$$(addsuffix _Tie.class,$$($1_TIE_BASE_FILES))) - - ifneq (,$$($1_RUN_IIOP)) - $1_TARGETS += $$($1_TIE_FILES) - $1_ARGS += -iiop - endif - ifneq (,$$($1_RUN_IIOP_STDPKG)) - $1_TARGETS += $$($1_TIE_STDPKG_FILES) - $1_ARGS2 := -iiop -standardPackage - endif - - ifneq (,$$($1_KEEP_GENERATED)) - $1_ARGS += -keepgenerated - $1_TARGETS += $$(subst .class,.java,$$($1_TARGETS)) - endif - - $1_DOLLAR_SAFE_CLASSES := $$(subst $$$$,\$$$$,$$($1_CLASSES)) - - $$($1_TARGETS): $$($1_DEP_FILE) $$($1_CLASS_FILES) - - $$($1_DEP_FILE): $$($1_CLASS_FILES) - $(MKDIR) -p $$($1_STUB_CLASSES_DIR) - if [ "x$$($1_ARGS)" != "x" ]; then \ - $(ECHO) Running rmic $$($1_ARGS) for $$($1_DOLLAR_SAFE_CLASSES) &&\ - $(RMIC) $$($1_ARGS) -classpath "$$($1_CLASSES_DIR)" \ - -d $$($1_STUB_CLASSES_DIR) $$($1_DOLLAR_SAFE_CLASSES);\ - fi; - if [ "x$$($1_ARGS2)" != "x" ]; then \ - $(ECHO) Running rmic $$($1_ARGS2) for $$($1_DOLLAR_SAFE_CLASSES) &&\ - $(RMIC) $$($1_ARGS2) -classpath "$$($1_CLASSES_DIR)" \ - -d $$($1_STUB_CLASSES_DIR) $$($1_DOLLAR_SAFE_CLASSES);\ - fi; - - - $1 := $$($1_TARGETS) - - # By marking as secondary, this "touch" file doesn't need to be touched and will never exist. - .SECONDARY: $$($1_DEP_FILE) -endef From af253d110d998403cc55adddc2bc5aa699acb86f Mon Sep 17 00:00:00 2001 From: Mikael Vidstedt Date: Tue, 3 Jul 2012 17:35:00 -0700 Subject: [PATCH 057/160] 7129724: MAC: Core file location is wrong in crash report Updated core path location to reflect macosx default Reviewed-by: dholmes, kamg --- hotspot/src/os/bsd/vm/os_bsd.cpp | 11 +++++++++++ hotspot/src/os/linux/vm/os_linux.cpp | 12 ++++++++++++ hotspot/src/os/posix/vm/os_posix.cpp | 10 +++++----- hotspot/src/os/solaris/vm/os_solaris.cpp | 13 +++++++++++++ hotspot/src/share/vm/runtime/os.hpp | 4 ++++ 5 files changed, 45 insertions(+), 5 deletions(-) diff --git a/hotspot/src/os/bsd/vm/os_bsd.cpp b/hotspot/src/os/bsd/vm/os_bsd.cpp index 0305b3df0de..68ab3fc4c3b 100644 --- a/hotspot/src/os/bsd/vm/os_bsd.cpp +++ b/hotspot/src/os/bsd/vm/os_bsd.cpp @@ -5801,3 +5801,14 @@ bool os::is_headless_jre() { return true; } + +// Get the default path to the core file +// Returns the length of the string +int os::get_core_path(char* buffer, size_t bufferSize) { + int n = jio_snprintf(buffer, bufferSize, "/cores"); + + // Truncate if theoretical string was longer than bufferSize + n = MIN2(n, (int)bufferSize); + + return n; +} diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp index ce7c71b9d43..df6eb0e71c8 100644 --- a/hotspot/src/os/linux/vm/os_linux.cpp +++ b/hotspot/src/os/linux/vm/os_linux.cpp @@ -5447,6 +5447,18 @@ bool os::is_headless_jre() { return true; } +// Get the default path to the core file +// Returns the length of the string +int os::get_core_path(char* buffer, size_t bufferSize) { + const char* p = get_current_directory(buffer, bufferSize); + + if (p == NULL) { + assert(p != NULL, "failed to get current directory"); + return 0; + } + + return strlen(buffer); +} #ifdef JAVASE_EMBEDDED // diff --git a/hotspot/src/os/posix/vm/os_posix.cpp b/hotspot/src/os/posix/vm/os_posix.cpp index 3e49b8b9ddd..ce355c1cc9f 100644 --- a/hotspot/src/os/posix/vm/os_posix.cpp +++ b/hotspot/src/os/posix/vm/os_posix.cpp @@ -34,19 +34,19 @@ // Check core dump limit and report possible place where core can be found void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize) { + int n; struct rlimit rlim; - static char cwd[O_BUFLEN]; bool success; - get_current_directory(cwd, sizeof(cwd)); + n = get_core_path(buffer, bufferSize); if (getrlimit(RLIMIT_CORE, &rlim) != 0) { - jio_snprintf(buffer, bufferSize, "%s/core or core.%d (may not exist)", cwd, current_process_id()); + jio_snprintf(buffer + n, bufferSize - n, "/core or core.%d (may not exist)", current_process_id()); success = true; } else { switch(rlim.rlim_cur) { case RLIM_INFINITY: - jio_snprintf(buffer, bufferSize, "%s/core or core.%d", cwd, current_process_id()); + jio_snprintf(buffer + n, bufferSize - n, "/core or core.%d", current_process_id()); success = true; break; case 0: @@ -54,7 +54,7 @@ void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char* success = false; break; default: - jio_snprintf(buffer, bufferSize, "%s/core or core.%d (max size %lu kB). To ensure a full core dump, try \"ulimit -c unlimited\" before starting Java again", cwd, current_process_id(), (unsigned long)(rlim.rlim_cur >> 10)); + jio_snprintf(buffer + n, bufferSize - n, "/core or core.%d (max size %lu kB). To ensure a full core dump, try \"ulimit -c unlimited\" before starting Java again", current_process_id(), (unsigned long)(rlim.rlim_cur >> 10)); success = true; break; } diff --git a/hotspot/src/os/solaris/vm/os_solaris.cpp b/hotspot/src/os/solaris/vm/os_solaris.cpp index 1d241d650e8..5e11a9d5588 100644 --- a/hotspot/src/os/solaris/vm/os_solaris.cpp +++ b/hotspot/src/os/solaris/vm/os_solaris.cpp @@ -6537,3 +6537,16 @@ int os::bind(int fd, struct sockaddr* him, socklen_t len) { INTERRUPTIBLE_RETURN_INT_NORESTART(::bind(fd, him, len),\ os::Solaris::clear_interrupted); } + +// Get the default path to the core file +// Returns the length of the string +int os::get_core_path(char* buffer, size_t bufferSize) { + const char* p = get_current_directory(buffer, bufferSize); + + if (p == NULL) { + assert(p != NULL, "failed to get current directory"); + return 0; + } + + return strlen(buffer); +} diff --git a/hotspot/src/share/vm/runtime/os.hpp b/hotspot/src/share/vm/runtime/os.hpp index 3be7248a911..508edba8a3e 100644 --- a/hotspot/src/share/vm/runtime/os.hpp +++ b/hotspot/src/share/vm/runtime/os.hpp @@ -665,6 +665,10 @@ class os: AllStatic { // On Windows this will create an actual minidump, on Linux/Solaris it will simply check core dump limits static void check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize); + // Get the default path to the core file + // Returns the length of the string + static int get_core_path(char* buffer, size_t bufferSize); + // JVMTI & JVM monitoring and management support // The thread_cpu_time() and current_thread_cpu_time() are only // supported if is_thread_cpu_time_supported() returns true. From 046f2c92e27737091d5026d9ff621bf42930ecb3 Mon Sep 17 00:00:00 2001 From: Xue-Lei Andrew Fan Date: Tue, 3 Jul 2012 20:29:16 -0700 Subject: [PATCH 058/160] 7180038: regression test failure, SSLEngineBadBufferArrayAccess.java Reviewed-by: weijun --- .../SSLEngineBadBufferArrayAccess.java | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/SSLEngineImpl/SSLEngineBadBufferArrayAccess.java b/jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/SSLEngineImpl/SSLEngineBadBufferArrayAccess.java index f9cd5185b33..aeaf5792cb9 100644 --- a/jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/SSLEngineImpl/SSLEngineBadBufferArrayAccess.java +++ b/jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/SSLEngineImpl/SSLEngineBadBufferArrayAccess.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -287,18 +287,27 @@ public class SSLEngineBadBufferArrayAccess { if (serverClose) { serverEngine.closeOutbound(); } + } + + if (closed && isEngineClosed(serverEngine)) { serverIn.flip(); /* * A sanity check to ensure we got what was sent. */ if (serverIn.remaining() != clientMsg.length) { - throw new Exception("Client: Data length error"); + throw new Exception("Client: Data length error -" + + " IF THIS FAILS, PLEASE REPORT THIS TO THE" + + " SECURITY TEAM. WE HAVE BEEN UNABLE TO" + + " RELIABLY DUPLICATE."); } for (int i = 0; i < clientMsg.length; i++) { if (clientMsg[i] != serverIn.get()) { - throw new Exception("Client: Data content error"); + throw new Exception("Client: Data content error -" + + " IF THIS FAILS, PLEASE REPORT THIS TO THE" + + " SECURITY TEAM. WE HAVE BEEN UNABLE TO" + + " RELIABLY DUPLICATE."); } } serverIn.compact(); From a433c60a8a96a815f7393f2950b67c8ddcdb7346 Mon Sep 17 00:00:00 2001 From: Sergey Bylokhov Date: Wed, 4 Jul 2012 14:38:14 +0400 Subject: [PATCH 059/160] 7124244: [macosx] Shaped windows support Reviewed-by: anthony, art --- .../classes/sun/java2d/opengl/CGLLayer.java | 5 +- .../classes/sun/lwawt/LWComponentPeer.java | 71 +++++-------- .../classes/sun/lwawt/LWRepaintArea.java | 3 - .../macosx/classes/sun/lwawt/LWToolkit.java | 6 -- .../classes/sun/lwawt/LWWindowPeer.java | 100 ++++++++++-------- .../lwawt/macosx/CPlatformEmbeddedFrame.java | 2 +- .../sun/lwawt/macosx/CPlatformView.java | 2 +- .../sun/lwawt/macosx/CPlatformWindow.java | 13 +++ .../classes/sun/lwawt/macosx/LWCToolkit.java | 9 ++ jdk/src/macosx/native/sun/awt/AWTWindow.m | 13 ++- .../classes/javax/swing/RepaintManager.java | 34 +++++- jdk/src/share/classes/sun/awt/SunToolkit.java | 7 ++ 12 files changed, 155 insertions(+), 110 deletions(-) diff --git a/jdk/src/macosx/classes/sun/java2d/opengl/CGLLayer.java b/jdk/src/macosx/classes/sun/java2d/opengl/CGLLayer.java index 219c84cc108..674b97951af 100644 --- a/jdk/src/macosx/classes/sun/java2d/opengl/CGLLayer.java +++ b/jdk/src/macosx/classes/sun/java2d/opengl/CGLLayer.java @@ -68,11 +68,12 @@ public class CGLLayer extends CFRetainedResource { } public boolean isOpaque() { - return peer.isOpaque(); + return !peer.isTranslucent(); } public int getTransparency() { - return (peer.isOpaque() ? Transparency.OPAQUE : Transparency.TRANSLUCENT); + return peer.isTranslucent() ? Transparency.TRANSLUCENT : + Transparency.OPAQUE; } public Object getDestination() { diff --git a/jdk/src/macosx/classes/sun/lwawt/LWComponentPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWComponentPeer.java index 61d0dd060c4..f6ad8838051 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWComponentPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWComponentPeer.java @@ -424,8 +424,7 @@ public abstract class LWComponentPeer @Override public final Graphics getGraphics() { - Graphics g = getWindowPeerOrSelf().isOpaque() ? getOnscreenGraphics() - : getOffscreenGraphics(); + final Graphics g = getOnscreenGraphics(); if (g != null) { synchronized (getPeerTreeLock()){ applyConstrain(g); @@ -443,13 +442,7 @@ public abstract class LWComponentPeer final LWWindowPeer wp = getWindowPeerOrSelf(); return wp.getOnscreenGraphics(getForeground(), getBackground(), getFont()); - } - public final Graphics getOffscreenGraphics() { - final LWWindowPeer wp = getWindowPeerOrSelf(); - - return wp.getOffscreenGraphics(getForeground(), getBackground(), - getFont()); } private void applyConstrain(final Graphics g) { @@ -463,7 +456,7 @@ public abstract class LWComponentPeer } //TODO Move this method to SG2D? - private void SG2DConstraint(final SunGraphics2D sg2d, Region r) { + void SG2DConstraint(final SunGraphics2D sg2d, Region r) { sg2d.constrainX = sg2d.transX; sg2d.constrainY = sg2d.transY; @@ -710,7 +703,7 @@ public abstract class LWComponentPeer // Obtain the metrics from the offscreen window where this peer is // mostly drawn to. // TODO: check for "use platform metrics" settings - Graphics g = getWindowPeer().getOffscreenGraphics(); + Graphics g = getWindowPeer().getGraphics(); try { if (g != null) { return g.getFontMetrics(f); @@ -1011,14 +1004,33 @@ public abstract class LWComponentPeer @Override public final void applyShape(final Region shape) { synchronized (getStateLock()) { - region = shape; + if (region == shape || (region != null && region.equals(shape))) { + return; + } + } + applyShapeImpl(shape); + } + + void applyShapeImpl(final Region shape) { + synchronized (getStateLock()) { + if (shape != null) { + region = Region.WHOLE_REGION.getIntersection(shape); + } else { + region = null; + } } repaintParent(getBounds()); } protected final Region getRegion() { synchronized (getStateLock()) { - return region == null ? Region.getInstance(getSize()) : region; + return isShaped() ? region : Region.getInstance(getSize()); + } + } + + public boolean isShaped() { + synchronized (getStateLock()) { + return region != null; } } @@ -1386,11 +1398,6 @@ public abstract class LWComponentPeer } } - // Just a helper method, thus final - protected final void flushOffscreenGraphics() { - flushOffscreenGraphics(getSize()); - } - protected static final void flushOnscreenGraphics(){ final OGLRenderQueue rq = OGLRenderQueue.getInstance(); rq.lock(); @@ -1401,36 +1408,6 @@ public abstract class LWComponentPeer } } - /* - * Flushes the given rectangle from the back buffer to the screen. - */ - protected void flushOffscreenGraphics(Rectangle r) { - flushOffscreenGraphics(r.x, r.y, r.width, r.height); - } - - private void flushOffscreenGraphics(int x, int y, int width, int height) { - Image bb = getWindowPeerOrSelf().getBackBuffer(); - if (bb != null) { - // g is a screen Graphics from the delegate - final Graphics g = getOnscreenGraphics(); - - if (g != null && g instanceof Graphics2D) { - try { - Graphics2D g2d = (Graphics2D)g; - Point p = localToWindow(new Point(0, 0)); - Composite composite = g2d.getComposite(); - g2d.setComposite(AlphaComposite.Src); - g.drawImage(bb, x, y, x + width, y + height, p.x + x, - p.y + y, p.x + x + width, p.y + y + height, - null); - g2d.setComposite(composite); - } finally { - g.dispose(); - } - } - } - } - /** * Used by ContainerPeer to skip all the paint events during layout. * diff --git a/jdk/src/macosx/classes/sun/lwawt/LWRepaintArea.java b/jdk/src/macosx/classes/sun/lwawt/LWRepaintArea.java index 54cbd332db4..e67b2fa435e 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWRepaintArea.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWRepaintArea.java @@ -58,9 +58,6 @@ final class LWRepaintArea extends RepaintArea { private static void flushBuffers(final LWComponentPeer peer) { if (peer != null) { - if (!peer.getWindowPeerOrSelf().isOpaque()) { - peer.flushOffscreenGraphics(); - } peer.flushOnscreenGraphics(); } } diff --git a/jdk/src/macosx/classes/sun/lwawt/LWToolkit.java b/jdk/src/macosx/classes/sun/lwawt/LWToolkit.java index f41a944b17c..04fd4066cfe 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWToolkit.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWToolkit.java @@ -522,12 +522,6 @@ public abstract class LWToolkit extends SunToolkit implements Runnable { postEvent(targetToAppContext(event.getSource()), event); } - // use peer's back buffer to implement non-opaque windows. - @Override - public boolean needUpdateWindow() { - return true; - } - @Override public void grab(Window w) { if (w.getPeer() != null) { diff --git a/jdk/src/macosx/classes/sun/lwawt/LWWindowPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWWindowPeer.java index 5372a01b474..c78582f3212 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWWindowPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWWindowPeer.java @@ -37,6 +37,7 @@ import sun.awt.*; import sun.java2d.*; import sun.java2d.loops.Blit; import sun.java2d.loops.CompositeType; +import sun.java2d.pipe.Region; import sun.util.logging.PlatformLogger; public class LWWindowPeer @@ -109,6 +110,8 @@ public class LWWindowPeer private volatile boolean skipNextFocusChange; + private static final Color nonOpaqueBackground = new Color(0, 0, 0, 0); + /** * Current modal blocker or null. * @@ -169,6 +172,11 @@ public class LWWindowPeer setAlwaysOnTop(getTarget().isAlwaysOnTop()); updateMinimumSize(); + final Shape shape = getTarget().getShape(); + if (shape != null) { + applyShape(Region.getInstance(shape, null)); + } + final float opacity = getTarget().getOpacity(); if (opacity < 1.0f) { setOpacity(opacity); @@ -178,7 +186,7 @@ public class LWWindowPeer updateInsets(platformWindow.getInsets()); if (getSurfaceData() == null) { - replaceSurfaceData(); + replaceSurfaceData(false); } } @@ -280,7 +288,7 @@ public class LWWindowPeer // "buffer", that's why numBuffers - 1 assert numBuffers > 1; - replaceSurfaceData(numBuffers - 1, caps); + replaceSurfaceData(numBuffers - 1, caps, false); } catch (InvalidPipeException z) { throw new AWTException(z.toString()); } @@ -420,19 +428,30 @@ public class LWWindowPeer public final void setOpaque(final boolean isOpaque) { if (this.isOpaque != isOpaque) { this.isOpaque = isOpaque; - getPlatformWindow().setOpaque(isOpaque); - replaceSurfaceData(); - repaintPeer(); + updateOpaque(); } } - public final boolean isOpaque() { - return isOpaque; + private void updateOpaque() { + getPlatformWindow().setOpaque(!isTranslucent()); + replaceSurfaceData(false); + repaintPeer(); } @Override public void updateWindow() { - flushOffscreenGraphics(); + } + + public final boolean isTranslucent() { + synchronized (getStateLock()) { + return !isOpaque || isShaped(); + } + } + + @Override + final void applyShapeImpl(final Region shape) { + super.applyShapeImpl(shape); + updateOpaque(); } @Override @@ -587,7 +606,18 @@ public class LWWindowPeer getFont()); if (g != null) { try { - g.clearRect(0, 0, w, h); + if (g instanceof Graphics2D) { + ((Graphics2D) g).setComposite(AlphaComposite.Src); + } + if (isTranslucent()) { + g.setColor(nonOpaqueBackground); + g.fillRect(0, 0, w, h); + } + if (g instanceof SunGraphics2D) { + SG2DConstraint((SunGraphics2D) g, getRegion()); + } + g.setColor(getBackground()); + g.fillRect(0, 0, w, h); } finally { g.dispose(); } @@ -894,35 +924,6 @@ public class LWWindowPeer }); } - /** - * This method returns a back buffer Graphics to render all the - * peers to. After the peer is painted, the back buffer contents - * should be flushed to the screen. All the target painting - * (Component.paint() method) should be done directly to the screen. - */ - protected final Graphics getOffscreenGraphics(Color fg, Color bg, Font f) { - final Image bb = getBackBuffer(); - if (bb == null) { - return null; - } - if (fg == null) { - fg = SystemColor.windowText; - } - if (bg == null) { - bg = SystemColor.window; - } - if (f == null) { - f = DEFAULT_FONT; - } - final Graphics2D g = (Graphics2D) bb.getGraphics(); - if (g != null) { - g.setColor(fg); - g.setBackground(bg); - g.setFont(f); - } - return g; - } - /* * May be called by delegate to provide SD to Java2D code. */ @@ -933,11 +934,16 @@ public class LWWindowPeer } private void replaceSurfaceData() { - replaceSurfaceData(backBufferCount, backBufferCaps); + replaceSurfaceData(true); + } + + private void replaceSurfaceData(boolean blit) { + replaceSurfaceData(backBufferCount, backBufferCaps, blit); } private void replaceSurfaceData(int newBackBufferCount, - BufferCapabilities newBackBufferCaps) { + BufferCapabilities newBackBufferCaps, + boolean blit) { synchronized (surfaceDataLock) { final SurfaceData oldData = getSurfaceData(); surfaceData = platformWindow.replaceSurfaceData(); @@ -950,7 +956,10 @@ public class LWWindowPeer if (getSurfaceData() != null && oldData != getSurfaceData()) { clearBackground(size.width, size.height); } - blitSurfaceData(oldData, getSurfaceData()); + + if (blit) { + blitSurfaceData(oldData, getSurfaceData()); + } if (oldData != null && oldData != getSurfaceData()) { // TODO: drop oldData for D3D/WGL pipelines @@ -965,10 +974,15 @@ public class LWWindowPeer Graphics g = backBuffer.getGraphics(); try { Rectangle r = getBounds(); - g.setColor(getBackground()); if (g instanceof Graphics2D) { ((Graphics2D) g).setComposite(AlphaComposite.Src); } + g.setColor(nonOpaqueBackground); + g.fillRect(0, 0, r.width, r.height); + if (g instanceof SunGraphics2D) { + SG2DConstraint((SunGraphics2D) g, getRegion()); + } + g.setColor(getBackground()); g.fillRect(0, 0, r.width, r.height); if (oldBB != null) { // Draw the old back buffer to the new one @@ -993,7 +1007,7 @@ public class LWWindowPeer CompositeType.Src, dst.getSurfaceType()); if (blit != null) { - blit.Blit(src, dst, ((Graphics2D) getGraphics()).getComposite(), + blit.Blit(src, dst, AlphaComposite.Src, getRegion(), 0, 0, 0, 0, size.width, size.height); } } diff --git a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformEmbeddedFrame.java b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformEmbeddedFrame.java index 815a71822e5..aeff2833d9a 100644 --- a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformEmbeddedFrame.java +++ b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformEmbeddedFrame.java @@ -117,7 +117,7 @@ public class CPlatformEmbeddedFrame implements PlatformWindow { Rectangle r = peer.getBounds(); Image im = null; if (!r.isEmpty()) { - int transparency = (peer.isOpaque() ? Transparency.OPAQUE : Transparency.TRANSLUCENT); + int transparency = peer.isTranslucent() ? Transparency.TRANSLUCENT : Transparency.OPAQUE; im = peer.getGraphicsConfiguration().createCompatibleImage(r.width, r.height, transparency); } return im; diff --git a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformView.java b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformView.java index 5c072a69800..8439ca67c2d 100644 --- a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformView.java +++ b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformView.java @@ -64,7 +64,7 @@ public class CPlatformView extends CFRetainedResource { } public boolean isOpaque() { - return peer.isOpaque(); + return !peer.isTranslucent(); } /* diff --git a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java index 514e4268489..cdb84b9f553 100644 --- a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java +++ b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java @@ -737,6 +737,15 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo long clearColor = CWrapper.NSColor.clearColor(); CWrapper.NSWindow.setBackgroundColor(getNSWindowPtr(), clearColor); } + + //This is a temporary workaround. Looks like after 7124236 will be fixed + //the correct place for invalidateShadow() is CGLayer.drawInCGLContext. + SwingUtilities.invokeLater(new Runnable() { + @Override + public void run() { + invalidateShadow(); + } + }); } @Override @@ -805,6 +814,10 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo nativeSetEnabled(getNSWindowPtr(), !blocked); } + public final void invalidateShadow(){ + nativeRevalidateNSWindowShadow(getNSWindowPtr()); + } + // ---------------------------------------------------------------------- // UTILITY METHODS // ---------------------------------------------------------------------- diff --git a/jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java b/jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java index 524abddcf4f..774d31228d5 100644 --- a/jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java +++ b/jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java @@ -749,6 +749,11 @@ public class LWCToolkit extends LWToolkit { (modalityType == Dialog.ModalityType.TOOLKIT_MODAL); } + @Override + public boolean isWindowShapingSupported() { + return true; + } + @Override public boolean isWindowTranslucencySupported() { return true; @@ -759,6 +764,10 @@ public class LWCToolkit extends LWToolkit { return true; } + public boolean isSwingBackbufferTranslucencySupported() { + return true; + } + @Override public boolean enableInputMethodsForTextComponent() { return true; diff --git a/jdk/src/macosx/native/sun/awt/AWTWindow.m b/jdk/src/macosx/native/sun/awt/AWTWindow.m index df222beb235..48ab428521c 100644 --- a/jdk/src/macosx/native/sun/awt/AWTWindow.m +++ b/jdk/src/macosx/native/sun/awt/AWTWindow.m @@ -941,14 +941,17 @@ JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeRevalidateNSW (JNIEnv *env, jclass clazz, jlong windowPtr) { JNF_COCOA_ENTER(env); -AWT_ASSERT_NOT_APPKIT_THREAD; NSWindow *nsWindow = OBJC(windowPtr); - [JNFRunLoop performOnMainThreadWaiting:NO withBlock:^(){ - AWT_ASSERT_APPKIT_THREAD; - + if ([NSThread isMainThread]) { [nsWindow invalidateShadow]; - }]; + } else { + [JNFRunLoop performOnMainThreadWaiting:NO withBlock:^(){ + AWT_ASSERT_APPKIT_THREAD; + + [nsWindow invalidateShadow]; + }]; + } JNF_COCOA_EXIT(env); } diff --git a/jdk/src/share/classes/javax/swing/RepaintManager.java b/jdk/src/share/classes/javax/swing/RepaintManager.java index d1ba1f4c528..aa3f8bdf50c 100644 --- a/jdk/src/share/classes/javax/swing/RepaintManager.java +++ b/jdk/src/share/classes/javax/swing/RepaintManager.java @@ -118,6 +118,11 @@ public class RepaintManager // Whether or not a VolatileImage should be used for double-buffered painting static boolean volatileImageBufferEnabled = true; + /** + * Type of VolatileImage which should be used for double-buffered + * painting. + */ + private static final int volatileBufferType; /** * Value of the system property awt.nativeDoubleBuffering. */ @@ -204,6 +209,13 @@ public class RepaintManager ((SunGraphicsEnvironment)ge).addDisplayChangedListener( new DisplayChangedHandler()); } + Toolkit tk = Toolkit.getDefaultToolkit(); + if ((tk instanceof SunToolkit) + && ((SunToolkit) tk).isSwingBackbufferTranslucencySupported()) { + volatileBufferType = Transparency.TRANSLUCENT; + } else { + volatileBufferType = Transparency.OPAQUE; + } } /** @@ -989,7 +1001,8 @@ public class RepaintManager if (image != null) { image.flush(); } - image = config.createCompatibleVolatileImage(width, height); + image = config.createCompatibleVolatileImage(width, height, + volatileBufferType); volatileMap.put(config, image); } return image; @@ -1483,9 +1496,26 @@ public class RepaintManager for(y=clipY, maxy = clipY + clipH; y < maxy ; y += bh) { osg.translate(-x, -y); osg.setClip(x,y,bw,bh); + if (volatileBufferType != Transparency.OPAQUE + && osg instanceof Graphics2D) { + final Graphics2D g2d = (Graphics2D) osg; + final Color oldBg = g2d.getBackground(); + g2d.setBackground(c.getBackground()); + g2d.clearRect(x, y, bw, bh); + g2d.setBackground(oldBg); + } c.paintToOffscreen(osg, x, y, bw, bh, maxx, maxy); g.setClip(x, y, bw, bh); - g.drawImage(image, x, y, c); + if (volatileBufferType != Transparency.OPAQUE + && g instanceof Graphics2D) { + final Graphics2D g2d = (Graphics2D) g; + final Composite oldComposite = g2d.getComposite(); + g2d.setComposite(AlphaComposite.Src); + g2d.drawImage(image, x, y, c); + g2d.setComposite(oldComposite); + } else { + g.drawImage(image, x, y, c); + } osg.translate(x, y); } } diff --git a/jdk/src/share/classes/sun/awt/SunToolkit.java b/jdk/src/share/classes/sun/awt/SunToolkit.java index a1c0d184eb9..c69f51f10f8 100644 --- a/jdk/src/share/classes/sun/awt/SunToolkit.java +++ b/jdk/src/share/classes/sun/awt/SunToolkit.java @@ -1984,6 +1984,13 @@ public abstract class SunToolkit extends Toolkit return false; } + /** + * Returns true if swing backbuffer should be translucent. + */ + public boolean isSwingBackbufferTranslucencySupported() { + return false; + } + /** * Returns whether or not a containing top level window for the passed * component is From e3a1dad2c0acfdb01bb0243826ba9318618c9b96 Mon Sep 17 00:00:00 2001 From: Sergey Bylokhov Date: Wed, 4 Jul 2012 15:36:48 +0400 Subject: [PATCH 060/160] 7124513: [macosx] Support NSTexturedBackgroundWindowMask/different titlebar styles to create unified toolbar Reviewed-by: anthony, art --- .../classes/com/apple/laf/AquaPanelUI.java | 10 ++++ .../classes/com/apple/laf/AquaRootPaneUI.java | 8 +++ .../classes/com/apple/laf/AquaToolBarUI.java | 12 +++-- .../classes/com/apple/laf/AquaUtils.java | 50 ++++++++++++++++++- .../classes/sun/lwawt/LWWindowPeer.java | 34 ++++++++++--- .../sun/lwawt/macosx/CPlatformWindow.java | 6 ++- .../share/classes/javax/swing/JViewport.java | 10 +++- 7 files changed, 116 insertions(+), 14 deletions(-) diff --git a/jdk/src/macosx/classes/com/apple/laf/AquaPanelUI.java b/jdk/src/macosx/classes/com/apple/laf/AquaPanelUI.java index 07a758f7d9f..960705b8ead 100644 --- a/jdk/src/macosx/classes/com/apple/laf/AquaPanelUI.java +++ b/jdk/src/macosx/classes/com/apple/laf/AquaPanelUI.java @@ -32,10 +32,20 @@ import javax.swing.plaf.basic.BasicPanelUI; import com.apple.laf.AquaUtils.RecyclableSingleton; import com.apple.laf.AquaUtils.RecyclableSingletonFromDefaultConstructor; +import java.awt.Graphics; + public class AquaPanelUI extends BasicPanelUI { static RecyclableSingleton instance = new RecyclableSingletonFromDefaultConstructor(AquaPanelUI.class); public static ComponentUI createUI(final JComponent c) { return instance.get(); } + + @Override + public final void update(final Graphics g, final JComponent c) { + if (c.isOpaque()) { + AquaUtils.fillRect(g, c); + } + paint(g, c); + } } diff --git a/jdk/src/macosx/classes/com/apple/laf/AquaRootPaneUI.java b/jdk/src/macosx/classes/com/apple/laf/AquaRootPaneUI.java index e7277128fe7..6f3c1f2534f 100644 --- a/jdk/src/macosx/classes/com/apple/laf/AquaRootPaneUI.java +++ b/jdk/src/macosx/classes/com/apple/laf/AquaRootPaneUI.java @@ -319,4 +319,12 @@ public class AquaRootPaneUI extends BasicRootPaneUI implements AncestorListener, updateComponentTreeUIActivation(element, active); } } + + @Override + public final void update(final Graphics g, final JComponent c) { + if (c.isOpaque()) { + AquaUtils.fillRect(g, c); + } + paint(g, c); + } } diff --git a/jdk/src/macosx/classes/com/apple/laf/AquaToolBarUI.java b/jdk/src/macosx/classes/com/apple/laf/AquaToolBarUI.java index 660cff318d6..bf87e2d1bb7 100644 --- a/jdk/src/macosx/classes/com/apple/laf/AquaToolBarUI.java +++ b/jdk/src/macosx/classes/com/apple/laf/AquaToolBarUI.java @@ -73,9 +73,7 @@ public class AquaToolBarUI extends BasicToolBarUI implements SwingConstants { g.translate(x, y); if (c.isOpaque()) { - final Color background = c.getBackground(); - g.setColor(background); - g.fillRect(0, 0, w - 1, h - 1); + AquaUtils.fillRect(g, c, c.getBackground(), 0, 0, w - 1, h - 1); } final Color oldColor = g.getColor(); @@ -137,4 +135,12 @@ public class AquaToolBarUI extends BasicToolBarUI implements SwingConstants { return true; } } + + @Override + public final void update(final Graphics g, final JComponent c) { + if (c.isOpaque()) { + AquaUtils.fillRect(g, c); + } + paint(g, c); + } } diff --git a/jdk/src/macosx/classes/com/apple/laf/AquaUtils.java b/jdk/src/macosx/classes/com/apple/laf/AquaUtils.java index 58b0d1efb98..0592da714a2 100644 --- a/jdk/src/macosx/classes/com/apple/laf/AquaUtils.java +++ b/jdk/src/macosx/classes/com/apple/laf/AquaUtils.java @@ -28,18 +28,19 @@ package com.apple.laf; import java.awt.*; import java.awt.image.*; import java.lang.ref.SoftReference; -import java.lang.ref.WeakReference; import java.lang.reflect.Method; import java.security.PrivilegedAction; import java.util.*; import javax.swing.*; import javax.swing.border.Border; +import javax.swing.plaf.UIResource; import sun.awt.AppContext; import sun.lwawt.macosx.CImage; import sun.lwawt.macosx.CImage.Creator; +import sun.lwawt.macosx.CPlatformWindow; import sun.swing.SwingUtilities2; import com.apple.laf.AquaImageFactory.SlicedImageControl; @@ -389,4 +390,51 @@ public class AquaUtils { return false; } } + + protected static boolean isWindowTextured(final Component c) { + if (!(c instanceof JComponent)) { + return false; + } + final JRootPane pane = ((JComponent) c).getRootPane(); + if (pane == null) { + return false; + } + Object prop = pane.getClientProperty( + CPlatformWindow.WINDOW_BRUSH_METAL_LOOK); + if (prop != null) { + return Boolean.parseBoolean(prop.toString()); + } + prop = pane.getClientProperty(CPlatformWindow.WINDOW_STYLE); + return prop != null && "textured".equals(prop); + } + + private static Color resetAlpha(final Color color) { + return new Color(color.getRed(), color.getGreen(), color.getBlue(), 0); + } + + protected static void fillRect(final Graphics g, final Component c) { + fillRect(g, c, c.getBackground(), 0, 0, c.getWidth(), c.getHeight()); + } + + protected static void fillRect(final Graphics g, final Component c, + final Color color, final int x, final int y, + final int w, final int h) { + if (!(g instanceof Graphics2D)) { + return; + } + final Graphics2D cg = (Graphics2D) g.create(); + try { + if (color instanceof UIResource && isWindowTextured(c) + && color.equals(SystemColor.window)) { + cg.setComposite(AlphaComposite.Src); + cg.setColor(resetAlpha(color)); + } else { + cg.setColor(color); + } + cg.fillRect(x, y, w, h); + } finally { + cg.dispose(); + } + } } + diff --git a/jdk/src/macosx/classes/sun/lwawt/LWWindowPeer.java b/jdk/src/macosx/classes/sun/lwawt/LWWindowPeer.java index c78582f3212..dd20e87139a 100644 --- a/jdk/src/macosx/classes/sun/lwawt/LWWindowPeer.java +++ b/jdk/src/macosx/classes/sun/lwawt/LWWindowPeer.java @@ -112,6 +112,8 @@ public class LWWindowPeer private static final Color nonOpaqueBackground = new Color(0, 0, 0, 0); + private volatile boolean textured; + /** * Current modal blocker or null. * @@ -442,9 +444,23 @@ public class LWWindowPeer public void updateWindow() { } + public final boolean isTextured() { + return textured; + } + + public final void setTextured(final boolean isTextured) { + textured = isTextured; + } + public final boolean isTranslucent() { synchronized (getStateLock()) { - return !isOpaque || isShaped(); + /* + * Textured window is a special case of translucent window. + * The difference is only in nswindow background. So when we set + * texture property our peer became fully translucent. It doesn't + * fill background, create non opaque backbuffers and layer etc. + */ + return !isOpaque || isShaped() || isTextured(); } } @@ -613,11 +629,13 @@ public class LWWindowPeer g.setColor(nonOpaqueBackground); g.fillRect(0, 0, w, h); } - if (g instanceof SunGraphics2D) { - SG2DConstraint((SunGraphics2D) g, getRegion()); + if (!isTextured()) { + if (g instanceof SunGraphics2D) { + SG2DConstraint((SunGraphics2D) g, getRegion()); + } + g.setColor(getBackground()); + g.fillRect(0, 0, w, h); } - g.setColor(getBackground()); - g.fillRect(0, 0, w, h); } finally { g.dispose(); } @@ -982,8 +1000,10 @@ public class LWWindowPeer if (g instanceof SunGraphics2D) { SG2DConstraint((SunGraphics2D) g, getRegion()); } - g.setColor(getBackground()); - g.fillRect(0, 0, r.width, r.height); + if (!isTextured()) { + g.setColor(getBackground()); + g.fillRect(0, 0, r.width, r.height); + } if (oldBB != null) { // Draw the old back buffer to the new one g.drawImage(oldBB, 0, 0, null); diff --git a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java index cdb84b9f553..46fece1de63 100644 --- a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java +++ b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java @@ -298,7 +298,7 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo // If the target is a dialog, popup or tooltip we want it to ignore the brushed metal look. if (isPopup) { - styleBits = SET(styleBits, TEXTURED, true); + styleBits = SET(styleBits, TEXTURED, false); // Popups in applets don't activate applet's process styleBits = SET(styleBits, NONACTIVATING, true); } @@ -372,6 +372,8 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo } } + peer.setTextured(IS(TEXTURED, styleBits)); + return styleBits; } @@ -733,7 +735,7 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo @Override public void setOpaque(boolean isOpaque) { CWrapper.NSWindow.setOpaque(getNSWindowPtr(), isOpaque); - if (!isOpaque) { + if (!isOpaque && !peer.isTextured()) { long clearColor = CWrapper.NSColor.clearColor(); CWrapper.NSWindow.setBackgroundColor(getNSWindowPtr(), clearColor); } diff --git a/jdk/src/share/classes/javax/swing/JViewport.java b/jdk/src/share/classes/javax/swing/JViewport.java index 51975d7cd6c..c2ea60bf0ec 100644 --- a/jdk/src/share/classes/javax/swing/JViewport.java +++ b/jdk/src/share/classes/javax/swing/JViewport.java @@ -1586,10 +1586,18 @@ public class JViewport extends JComponent implements Accessible int bdx = blitToX - blitFromX; int bdy = blitToY - blitFromY; + Composite oldComposite = null; // Shift the scrolled region + if (g instanceof Graphics2D) { + Graphics2D g2d = (Graphics2D) g; + oldComposite = g2d.getComposite(); + g2d.setComposite(AlphaComposite.Src); + } rm.copyArea(this, g, blitFromX, blitFromY, blitW, blitH, bdx, bdy, false); - + if (oldComposite != null) { + ((Graphics2D) g).setComposite(oldComposite); + } // Paint the newly exposed region. int x = view.getX(); int y = view.getY(); From 559278381bcc8a4f34fc67b8b75807b4237a32a7 Mon Sep 17 00:00:00 2001 From: Coleen Phillimore Date: Wed, 4 Jul 2012 15:55:45 -0400 Subject: [PATCH 061/160] 7181200: JVM new hashing code breaks SA in product mode Made new_hash() overloaded rather than a virtual function so SA code doesn't need to be changed. Reviewed-by: kvn, acorn, dholmes, fparain --- .../src/share/vm/classfile/symbolTable.cpp | 24 ------------------ .../src/share/vm/classfile/symbolTable.hpp | 12 --------- hotspot/src/share/vm/utilities/hashtable.cpp | 25 ++++++++++++++++++- hotspot/src/share/vm/utilities/hashtable.hpp | 9 ++++++- 4 files changed, 32 insertions(+), 38 deletions(-) diff --git a/hotspot/src/share/vm/classfile/symbolTable.cpp b/hotspot/src/share/vm/classfile/symbolTable.cpp index 85cc5002d10..dd52e8167a8 100644 --- a/hotspot/src/share/vm/classfile/symbolTable.cpp +++ b/hotspot/src/share/vm/classfile/symbolTable.cpp @@ -43,7 +43,6 @@ SymbolTable* SymbolTable::_the_table = NULL; // Static arena for symbols that are not deallocated Arena* SymbolTable::_arena = NULL; bool SymbolTable::_needs_rehashing = false; -jint SymbolTable::_seed = 0; Symbol* SymbolTable::allocate_symbol(const u1* name, int len, bool c_heap, TRAPS) { assert (len <= Symbol::max_length(), "should be checked by caller"); @@ -130,12 +129,6 @@ void SymbolTable::unlink() { } } -unsigned int SymbolTable::new_hash(Symbol* sym) { - ResourceMark rm; - // Use alternate hashing algorithm on this symbol. - return AltHashing::murmur3_32(seed(), (const jbyte*)sym->as_C_string(), sym->utf8_length()); -} - // Create a new table and using alternate hash code, populate the new table // with the existing strings. Set flag to use the alternate hash code afterwards. void SymbolTable::rehash_table() { @@ -145,10 +138,6 @@ void SymbolTable::rehash_table() { // Create a new symbol table SymbolTable* new_table = new SymbolTable(); - // Initialize the global seed for hashing. - _seed = AltHashing::compute_seed(); - assert(seed() != 0, "shouldn't be zero"); - the_table()->move_to(new_table); // Delete the table and buckets (entries are reused in new table). @@ -620,7 +609,6 @@ class StableMemoryChecker : public StackObj { StringTable* StringTable::_the_table = NULL; bool StringTable::_needs_rehashing = false; -jint StringTable::_seed = 0; // Pick hashing algorithm unsigned int StringTable::hash_string(const jchar* s, int len) { @@ -837,14 +825,6 @@ void StringTable::dump(outputStream* st) { } -unsigned int StringTable::new_hash(oop string) { - ResourceMark rm; - int length; - jchar* chars = java_lang_String::as_unicode_string(string, length); - // Use alternate hashing algorithm on the string - return AltHashing::murmur3_32(seed(), chars, length); -} - // Create a new table and using alternate hash code, populate the new table // with the existing strings. Set flag to use the alternate hash code afterwards. void StringTable::rehash_table() { @@ -853,10 +833,6 @@ void StringTable::rehash_table() { if (DumpSharedSpaces) return; StringTable* new_table = new StringTable(); - // Initialize new global seed for hashing. - _seed = AltHashing::compute_seed(); - assert(seed() != 0, "shouldn't be zero"); - // Rehash the table the_table()->move_to(new_table); diff --git a/hotspot/src/share/vm/classfile/symbolTable.hpp b/hotspot/src/share/vm/classfile/symbolTable.hpp index f63de80280e..7812fe1fb6c 100644 --- a/hotspot/src/share/vm/classfile/symbolTable.hpp +++ b/hotspot/src/share/vm/classfile/symbolTable.hpp @@ -81,7 +81,6 @@ private: // Set if one bucket is out of balance due to hash algorithm deficiency static bool _needs_rehashing; - static jint _seed; // For statistics static int symbols_removed; @@ -124,11 +123,6 @@ private: static Arena* arena() { return _arena; } // called for statistics static void initialize_symbols(int arena_alloc_size = 0); - - static bool use_alternate_hashcode() { return _seed != 0; } - static jint seed() { return _seed; } - - unsigned int new_hash(Symbol* sym); public: enum { symbol_alloc_batch_size = 8, @@ -247,7 +241,6 @@ private: // Set if one bucket is out of balance due to hash algorithm deficiency static bool _needs_rehashing; - static jint _seed; static oop intern(Handle string_or_null, jchar* chars, int length, TRAPS); oop basic_add(int index, Handle string_or_null, jchar* name, int len, @@ -261,11 +254,6 @@ private: StringTable(HashtableBucket* t, int number_of_entries) : Hashtable((int)StringTableSize, sizeof (HashtableEntry), t, number_of_entries) {} - - static bool use_alternate_hashcode() { return _seed != 0; } - static jint seed() { return _seed; } - - unsigned int new_hash(oop s); public: // The string table static StringTable* the_table() { return _the_table; } diff --git a/hotspot/src/share/vm/utilities/hashtable.cpp b/hotspot/src/share/vm/utilities/hashtable.cpp index 9b7db5e9a30..39092d95f5c 100644 --- a/hotspot/src/share/vm/utilities/hashtable.cpp +++ b/hotspot/src/share/vm/utilities/hashtable.cpp @@ -23,6 +23,8 @@ */ #include "precompiled.hpp" +#include "classfile/altHashing.hpp" +#include "classfile/javaClasses.hpp" #include "memory/allocation.inline.hpp" #include "memory/filemap.hpp" #include "memory/resourceArea.hpp" @@ -90,12 +92,33 @@ template bool BasicHashtable::check_rehash_table(int count) { return false; } +template jint Hashtable::_seed = 0; + +template unsigned int Hashtable::new_hash(Symbol* sym) { + ResourceMark rm; + // Use alternate hashing algorithm on this symbol. + return AltHashing::murmur3_32(seed(), (const jbyte*)sym->as_C_string(), sym->utf8_length()); +} + +template unsigned int Hashtable::new_hash(oop string) { + ResourceMark rm; + int length; + jchar* chars = java_lang_String::as_unicode_string(string, length); + // Use alternate hashing algorithm on the string + return AltHashing::murmur3_32(seed(), chars, length); +} + // Create a new table and using alternate hash code, populate the new table // with the existing elements. This can be used to change the hash code // and could in the future change the size of the table. template void Hashtable::move_to(Hashtable* new_table) { - int saved_entry_count = BasicHashtable::number_of_entries(); + + // Initialize the global seed for hashing. + _seed = AltHashing::compute_seed(); + assert(seed() != 0, "shouldn't be zero"); + + int saved_entry_count = this->number_of_entries(); // Iterate through the table and create a new entry for the new table for (int i = 0; i < new_table->table_size(); ++i) { diff --git a/hotspot/src/share/vm/utilities/hashtable.hpp b/hotspot/src/share/vm/utilities/hashtable.hpp index bec5e70984d..de7d319c07c 100644 --- a/hotspot/src/share/vm/utilities/hashtable.hpp +++ b/hotspot/src/share/vm/utilities/hashtable.hpp @@ -278,7 +278,14 @@ protected: // Function to move these elements into the new table. void move_to(Hashtable* new_table); - virtual unsigned int new_hash(T) { ShouldNotReachHere(); return 0; } // should be overridden + static bool use_alternate_hashcode() { return _seed != 0; } + static jint seed() { return _seed; } + + private: + static jint _seed; + + unsigned int new_hash(Symbol* s); + unsigned int new_hash(oop string); }; From 48d5be1b33c6d44aafdffa3c48511baf1de3d52a Mon Sep 17 00:00:00 2001 From: Eric Wang Date: Thu, 5 Jul 2012 15:12:10 -0700 Subject: [PATCH 062/160] 6948101: java/rmi/transport/pinLastArguments/PinLastArguments.java failing intermittently Reviewed-by: dholmes, smarks --- jdk/test/ProblemList.txt | 3 --- .../pinLastArguments/PinLastArguments.java | 13 +++++++++---- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/jdk/test/ProblemList.txt b/jdk/test/ProblemList.txt index 81154df8c20..72294911000 100644 --- a/jdk/test/ProblemList.txt +++ b/jdk/test/ProblemList.txt @@ -271,9 +271,6 @@ java/nio/channels/Selector/OutOfBand.java macosx-all # 7140992 java/rmi/server/Unreferenced/finiteGCLatency/FiniteGCLatency.java generic-all -# 6948101 -java/rmi/transport/pinLastArguments/PinLastArguments.java generic-all - # 7146541 java/rmi/transport/rapidExportUnexport/RapidExportUnexport.java linux-all diff --git a/jdk/test/java/rmi/transport/pinLastArguments/PinLastArguments.java b/jdk/test/java/rmi/transport/pinLastArguments/PinLastArguments.java index 445bdf389ba..f82560236c6 100644 --- a/jdk/test/java/rmi/transport/pinLastArguments/PinLastArguments.java +++ b/jdk/test/java/rmi/transport/pinLastArguments/PinLastArguments.java @@ -78,10 +78,15 @@ public class PinLastArguments { } impl = null; - System.gc(); - - if (ref.get() != null) { - throw new Error("TEST FAILED: impl not garbage collected"); + // Might require multiple calls to System.gc() for weak-references + // processing to be complete. If the weak-reference is not cleared as + // expected we will hang here until timed out by the test harness. + while (true) { + System.gc(); + Thread.sleep(20); + if (ref.get() == null) { + break; + } } System.err.println("TEST PASSED"); From b28493b31b42ef09fd4239f00ad771e9c8d2891c Mon Sep 17 00:00:00 2001 From: Eric Wang Date: Thu, 5 Jul 2012 15:13:45 -0700 Subject: [PATCH 063/160] 7123972: test/java/lang/annotation/loaderLeak/Main.java fails intermittently Reviewed-by: dholmes, smarks --- jdk/test/ProblemList.txt | 3 --- jdk/test/java/lang/annotation/loaderLeak/Main.java | 14 +++++++++++--- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/jdk/test/ProblemList.txt b/jdk/test/ProblemList.txt index 72294911000..af875d9fb8b 100644 --- a/jdk/test/ProblemList.txt +++ b/jdk/test/ProblemList.txt @@ -122,9 +122,6 @@ # jdk_lang -# 7123972 -java/lang/annotation/loaderLeak/Main.java generic-all - # 6944188 java/lang/management/ThreadMXBean/ThreadStateTest.java generic-all diff --git a/jdk/test/java/lang/annotation/loaderLeak/Main.java b/jdk/test/java/lang/annotation/loaderLeak/Main.java index dc835a9dcd0..fceda8195ff 100644 --- a/jdk/test/java/lang/annotation/loaderLeak/Main.java +++ b/jdk/test/java/lang/annotation/loaderLeak/Main.java @@ -57,9 +57,17 @@ public class Main { System.gc(); System.gc(); loader = null; - System.gc(); - System.gc(); - if (c.get() != null) throw new AssertionError(); + + // Might require multiple calls to System.gc() for weak-references + // processing to be complete. If the weak-reference is not cleared as + // expected we will hang here until timed out by the test harness. + while (true) { + System.gc(); + Thread.sleep(20); + if (c.get() == null) { + break; + } + } } } From e13a29b3f2bfa0f2ae37ced9adbfb364d56d4446 Mon Sep 17 00:00:00 2001 From: Jiangli Zhou Date: Thu, 5 Jul 2012 18:47:41 -0400 Subject: [PATCH 064/160] 7180914: Compilation warning after: 7172967: Eliminate the constMethod's _method backpointer to the methodOop Use read_pointer(J...) to access from 'constMethod' base in name_for_methodOop(), libjvm_db.c. Reviewed-by: kvn, coleenp --- hotspot/src/os/solaris/dtrace/libjvm_db.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hotspot/src/os/solaris/dtrace/libjvm_db.c b/hotspot/src/os/solaris/dtrace/libjvm_db.c index 2f9a56e919f..62304ec114a 100644 --- a/hotspot/src/os/solaris/dtrace/libjvm_db.c +++ b/hotspot/src/os/solaris/dtrace/libjvm_db.c @@ -516,7 +516,7 @@ name_for_methodOop(jvm_agent_t* J, uint64_t methodOopPtr, char * result, size_t err = read_pointer(J, methodOopPtr + OFFSET_methodOopDesc_constMethod, &constMethod); CHECK_FAIL(err); - err = read_pointer(J->P, constMethod + OFFSET_constMethodOopDesc_constants, &constantPool); + err = read_pointer(J, constMethod + OFFSET_constMethodOopDesc_constants, &constantPool); CHECK_FAIL(err); /* To get name string */ From 494465e69871ed386be9d2f4826f39fc38457b94 Mon Sep 17 00:00:00 2001 From: Jiangli Zhou Date: Thu, 5 Jul 2012 20:54:45 -0400 Subject: [PATCH 065/160] 7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145 Need to copy the inlined exception table to the new constMethodOop during method rewriting. Reviewed-by: coleenp, dholmes --- hotspot/src/share/vm/oops/methodOop.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/hotspot/src/share/vm/oops/methodOop.cpp b/hotspot/src/share/vm/oops/methodOop.cpp index 66c545a6c9b..ee5ef09bfe1 100644 --- a/hotspot/src/share/vm/oops/methodOop.cpp +++ b/hotspot/src/share/vm/oops/methodOop.cpp @@ -1082,6 +1082,7 @@ methodHandle methodOopDesc:: clone_with_new_data(methodHandle m, u_char* new_cod newm->set_method_size(new_method_size); assert(newm->code_size() == new_code_length, "check"); assert(newm->checked_exceptions_length() == checked_exceptions_len, "check"); + assert(newm->exception_table_length() == exception_table_len, "check"); assert(newm->localvariable_table_length() == localvariable_len, "check"); // Copy new byte codes memcpy(newm->code_base(), new_code, new_code_length); @@ -1097,6 +1098,12 @@ methodHandle methodOopDesc:: clone_with_new_data(methodHandle m, u_char* new_cod m->checked_exceptions_start(), checked_exceptions_len * sizeof(CheckedExceptionElement)); } + // Copy exception table + if (exception_table_len > 0) { + memcpy(newm->exception_table_start(), + m->exception_table_start(), + exception_table_len * sizeof(ExceptionTableElement)); + } // Copy local variable number table if (localvariable_len > 0) { memcpy(newm->localvariable_table_start(), From 34570ba690704271f5c09a8cb87fe9fc1ab034c4 Mon Sep 17 00:00:00 2001 From: Erik Joelsson Date: Thu, 5 Jul 2012 18:27:07 -0700 Subject: [PATCH 066/160] 7182051: Update of latest build-infra Makefiles (missing files) Reviewed-by: ohair --- common/autoconf/basics.m4 | 485 + common/autoconf/boot-jdk.m4 | 295 + .../autoconf/build-aux/autoconf-config.guess | 1531 ++ common/autoconf/build-performance.m4 | 378 + common/autoconf/generated-configure.sh | 18054 ++++++++++++++++ common/autoconf/jdk-options.m4 | 551 + common/autoconf/libraries.m4 | 642 + common/autoconf/source-dirs.m4 | 280 + common/autoconf/spec.sh.in | 527 + common/autoconf/toolchain.m4 | 908 + common/bin/compare-objects.sh | 235 + common/makefiles/IdlCompilation.gmk | 18 +- common/makefiles/MakeHelpers.gmk | 185 + common/makefiles/NativeCompilation.gmk | 12 +- common/makefiles/RMICompilation.gmk | 104 + 15 files changed, 24191 insertions(+), 14 deletions(-) create mode 100644 common/autoconf/basics.m4 create mode 100644 common/autoconf/boot-jdk.m4 create mode 100644 common/autoconf/build-aux/autoconf-config.guess create mode 100644 common/autoconf/build-performance.m4 create mode 100644 common/autoconf/generated-configure.sh create mode 100644 common/autoconf/jdk-options.m4 create mode 100644 common/autoconf/libraries.m4 create mode 100644 common/autoconf/source-dirs.m4 create mode 100644 common/autoconf/spec.sh.in create mode 100644 common/autoconf/toolchain.m4 create mode 100644 common/bin/compare-objects.sh create mode 100644 common/makefiles/MakeHelpers.gmk create mode 100644 common/makefiles/RMICompilation.gmk diff --git a/common/autoconf/basics.m4 b/common/autoconf/basics.m4 new file mode 100644 index 00000000000..370854d45fc --- /dev/null +++ b/common/autoconf/basics.m4 @@ -0,0 +1,485 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +AC_DEFUN([ADD_JVM_ARG_IF_OK], +[ + # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3) + # If so, then append $1 to $2 + FOUND_WARN=`$3 $1 -version 2>&1 | grep -i warn` + FOUND_VERSION=`$3 $1 -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + $2="[$]$2 $1" + fi +]) + +AC_DEFUN([WHICHCMD], +[ + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="[$]$1" + car="${tmp%% *}" + tmp="[$]$1 EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + WHICHCMD_SPACESAFE(car) + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + $1="$car ${cdr% *}" + else + $1="$car" + fi +]) + +AC_DEFUN([SPACESAFE], +[ + # Fail with message $2 if var $1 contains a path with no spaces in it. + # Unless on Windows, where we can rewrite the path. + HAS_SPACE=`echo "[$]$1" | grep " "` + if test "x$HAS_SPACE" != x; then + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + $1=`$CYGPATH -s -m -a "[$]$1"` + $1=`$CYGPATH -u "[$]$1"` + else + AC_MSG_ERROR([You cannot have spaces in $2! "[$]$1"]) + fi + fi +]) + +AC_DEFUN([WHICHCMD_SPACESAFE], +[ + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="[$]$1" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "[$]$1"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + $1="$tmp" +]) + +AC_DEFUN([REMOVE_SYMBOLIC_LINKS], +[ + if test "x$OPENJDK_BUILD_OS" != xwindows; then + # Follow a chain of symbolic links. Use readlink + # where it exists, else fall back to horribly + # complicated shell code. + AC_PATH_PROG(READLINK, readlink) + if test "x$READLINK_TESTED" != yes; then + # On MacOSX there is a readlink tool with a different + # purpose than the GNU readlink tool. Check the found readlink. + ISGNU=`$READLINK --help 2>&1 | grep GNU` + if test "x$ISGNU" = x; then + # A readlink that we do not know how to use. + # Are there other non-GNU readlinks out there? + READLINK_TESTED=yes + READLINK= + fi + fi + + if test "x$READLINK" != x; then + $1=`$READLINK -f [$]$1` + else + STARTDIR=$PWD + COUNTER=0 + DIR=`dirname [$]$1` + FIL=`basename [$]$1` + while test $COUNTER -lt 20; do + ISLINK=`ls -l $DIR/$FIL | grep '\->' | sed -e 's/.*-> \(.*\)/\1/'` + if test "x$ISLINK" == x; then + # This is not a symbolic link! We are done! + break + fi + # The link might be relative! We have to use cd to travel safely. + cd $DIR + cd `dirname $ISLINK` + DIR=`pwd` + FIL=`basename $ISLINK` + let COUNTER=COUNTER+1 + done + cd $STARTDIR + $1=$DIR/$FIL + fi + fi +]) + +AC_DEFUN_ONCE([BASIC_INIT], +[ +# Save the original command line. This is passed to us by the wrapper configure script. +AC_SUBST(CONFIGURE_COMMAND_LINE) +DATE_WHEN_CONFIGURED=`LANG=C date` +AC_SUBST(DATE_WHEN_CONFIGURED) + +# Locate the directory of this script. +SCRIPT="[$]0" +REMOVE_SYMBOLIC_LINKS(SCRIPT) +AUTOCONF_DIR=`dirname [$]0` +]) + +AC_DEFUN_ONCE([BASIC_SETUP_PATHS], +[ +# Where is the source? It is located two levels above the configure script. +CURDIR="$PWD" +cd "$AUTOCONF_DIR/../.." +SRC_ROOT="`pwd`" +if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + SRC_ROOT_LENGTH=`pwd|wc -m` + if test $SRC_ROOT_LENGTH -gt 100; then + AC_MSG_ERROR([Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported]) + fi +fi +AC_SUBST(SRC_ROOT) +cd "$CURDIR" + +SPACESAFE(SRC_ROOT,[the path to the source root]) +SPACESAFE(CURDIR,[the path to the current directory]) +]) + +AC_DEFUN_ONCE([BASIC_SETUP_SEARCHPATH], +[ +if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then + # Add extra search paths on solaris for utilities like ar and as etc... + PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin" +fi +]) + +AC_DEFUN_ONCE([BASIC_SETUP_PATH_SEP], +[ +# For cygwin we need cygpath first, since it is used everywhere. +AC_PATH_PROG(CYGPATH, cygpath) +PATH_SEP=":" +if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + if test "x$CYGPATH" = x; then + AC_MSG_ERROR([Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path]) + fi + PATH_SEP=";" +fi +AC_SUBST(PATH_SEP) +]) + +AC_DEFUN_ONCE([BASIC_SETUP_OUTPUT_DIR], +[ + +AC_ARG_WITH(conf-name, [AS_HELP_STRING([--with-conf-name], + [use this as the name of the configuration, overriding the generated default])], + [ CONF_NAME=${with_conf_name} ]) + +# Test from where we are running configure, in or outside of src root. +if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" || test "x$CURDIR" = "x$SRC_ROOT/common/makefiles" ; then + # We are running configure from the src root. + # Create a default ./build/target-variant-debuglevel output root. + if test "x${CONF_NAME}" = x; then + CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}" + fi + OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}" + mkdir -p "$OUTPUT_ROOT" + if test ! -d "$OUTPUT_ROOT"; then + AC_MSG_ERROR([Could not create build directory $OUTPUT_ROOT]) + fi +else + # We are running configure from outside of the src dir. + # Then use the current directory as output dir! + # If configuration is situated in normal build directory, just use the build + # directory name as configuration name, otherwise use the complete path. + if test "x${CONF_NAME}" = x; then + CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"` + fi + OUTPUT_ROOT="$CURDIR" +fi + +SPACESAFE(OUTPUT_ROOT,[the path to the output root]) + +AC_SUBST(SPEC, $OUTPUT_ROOT/spec.gmk) +AC_SUBST(CONF_NAME, $CONF_NAME) +AC_SUBST(OUTPUT_ROOT, $OUTPUT_ROOT) + +# Most of the probed defines are put into config.h +AC_CONFIG_HEADERS([$OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in]) +# The spec.gmk file contains all variables for the make system. +AC_CONFIG_FILES([$OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in]) +# The spec.sh file contains variables for compare{images|-objects}.sh scrips. +AC_CONFIG_FILES([$OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in]) +# The generated Makefile knows where the spec.gmk is and where the source is. +# You can run make from the OUTPUT_ROOT, or from the top-level Makefile +# which will look for generated configurations +AC_CONFIG_FILES([$OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in]) + +# Save the arguments given to us +echo "$CONFIGURE_COMMAND_LINE" > $OUTPUT_ROOT/configure-arguments +]) + +AC_DEFUN_ONCE([BASIC_SETUP_LOGGING], +[ +# Setup default logging of stdout and stderr to build.log in the output root. +BUILD_LOG='$(OUTPUT_ROOT)/build.log' +BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old' +BUILD_LOG_WRAPPER='$(SH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)' +AC_SUBST(BUILD_LOG) +AC_SUBST(BUILD_LOG_PREVIOUS) +AC_SUBST(BUILD_LOG_WRAPPER) +]) + + +#%%% Simple tools %%% + +AC_DEFUN([BASIC_CHECK_FIND_DELETE], +[ + # Test if find supports -delete + AC_MSG_CHECKING([if find supports -delete]) + FIND_DELETE="-delete" + + DELETEDIR=`mktemp -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?) + + echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete + + TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1` + if test -f $DELETEDIR/TestIfFindSupportsDelete; then + # No, it does not. + rm $DELETEDIR/TestIfFindSupportsDelete + FIND_DELETE="-exec rm \{\} \+" + AC_MSG_RESULT([no]) + else + AC_MSG_RESULT([yes]) + fi + rmdir $DELETEDIR +]) + +AC_DEFUN([CHECK_NONEMPTY], +[ + # Test that variable $1 is not empty. + if test "" = "[$]$1"; then AC_MSG_ERROR(Could not find translit($1,A-Z,a-z) !); fi +]) + +AC_DEFUN_ONCE([BASIC_SETUP_TOOLS], +[ +# Start with tools that do not need have cross compilation support +# and can be expected to be found in the default PATH. These tools are +# used by configure. Nor are these tools expected to be found in the +# devkit from the builddeps server either, since they are +# needed to download the devkit. +AC_PROG_AWK +CHECK_NONEMPTY(AWK) +AC_PATH_PROG(CAT, cat) +CHECK_NONEMPTY(CAT) +AC_PATH_PROG(CHMOD, chmod) +CHECK_NONEMPTY(CHMOD) +AC_PATH_PROG(CP, cp) +CHECK_NONEMPTY(CP) +AC_PATH_PROG(CPIO, cpio) +CHECK_NONEMPTY(CPIO) +AC_PATH_PROG(CUT, cut) +CHECK_NONEMPTY(CUT) +AC_PATH_PROG(DATE, date) +CHECK_NONEMPTY(DATE) +AC_PATH_PROG(DF, df) +CHECK_NONEMPTY(DF) +AC_PATH_PROG(DIFF, diff) +CHECK_NONEMPTY(DIFF) +# Warning echo is really, really unportable!!!!! Different +# behaviour in bash and dash and in a lot of other shells! +# Use printf for serious work! +AC_PATH_PROG(ECHO, echo) +CHECK_NONEMPTY(ECHO) +AC_PROG_EGREP +CHECK_NONEMPTY(EGREP) +AC_PROG_FGREP +CHECK_NONEMPTY(FGREP) + +AC_PATH_PROG(FIND, find) +CHECK_NONEMPTY(FIND) +BASIC_CHECK_FIND_DELETE +AC_SUBST(FIND_DELETE) + +AC_PROG_GREP +CHECK_NONEMPTY(GREP) +AC_PATH_PROG(HEAD, head) +CHECK_NONEMPTY(HEAD) +AC_PATH_PROG(LN, ln) +CHECK_NONEMPTY(LN) +AC_PATH_PROG(LS, ls) +CHECK_NONEMPTY(LS) +AC_PATH_PROGS(MAKE, [gmake make]) +CHECK_NONEMPTY(MAKE) +MAKE_VERSION=`$MAKE --version | head -n 1 | grep '3.8[[12346789]]'` +if test "x$MAKE_VERSION" = x; then + AC_MSG_ERROR([You must use GNU make 3.81 or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure.]) +fi +AC_PATH_PROG(MKDIR, mkdir) +CHECK_NONEMPTY(MKDIR) +AC_PATH_PROG(MV, mv) +CHECK_NONEMPTY(MV) +AC_PATH_PROGS(NAWK, [nawk gawk awk]) +CHECK_NONEMPTY(NAWK) +AC_PATH_PROG(PRINTF, printf) +CHECK_NONEMPTY(PRINTF) +AC_PATH_PROG(THEPWDCMD, pwd) +AC_PATH_PROG(RM, rm) +CHECK_NONEMPTY(RM) +RM="$RM -f" +AC_PROG_SED +CHECK_NONEMPTY(SED) +AC_PATH_PROG(SH, sh) +CHECK_NONEMPTY(SH) +AC_PATH_PROG(SORT, sort) +CHECK_NONEMPTY(SORT) +AC_PATH_PROG(TAR, tar) +CHECK_NONEMPTY(TAR) +AC_PATH_PROG(TAIL, tail) +CHECK_NONEMPTY(TAIL) +AC_PATH_PROG(TEE, tee) +CHECK_NONEMPTY(TEE) +AC_PATH_PROG(TR, tr) +CHECK_NONEMPTY(TR) +AC_PATH_PROG(TOUCH, touch) +CHECK_NONEMPTY(TOUCH) +AC_PATH_PROG(WC, wc) +CHECK_NONEMPTY(WC) +AC_PATH_PROG(XARGS, xargs) +CHECK_NONEMPTY(XARGS) +AC_PATH_PROG(ZIP, zip) +CHECK_NONEMPTY(ZIP) +AC_PATH_PROG(UNZIP, unzip) +CHECK_NONEMPTY(UNZIP) +AC_PATH_PROG(LDD, ldd) +if test "x$LDD" = "x"; then + # List shared lib dependencies is used for + # debug output and checking for forbidden dependencies. + # We can build without it. + LDD="true" +fi +AC_PATH_PROG(OTOOL, otool) +if test "x$OTOOL" = "x"; then + OTOOL="true" +fi +AC_PATH_PROG(READELF, readelf) +AC_PATH_PROG(EXPR, expr) +CHECK_NONEMPTY(EXPR) +AC_PATH_PROG(FILE, file) +CHECK_NONEMPTY(FILE) +AC_PATH_PROG(HG, hg) +]) + + + +AC_DEFUN_ONCE([BASIC_COMPILE_UNCYGDRIVE], +[ +# When using cygwin, we need a wrapper binary that renames +# /cygdrive/c/ arguments into c:/ arguments and peeks into +# @files and rewrites these too! This wrapper binary is +# called uncygdrive.exe. +UNCYGDRIVE= +if test "x$OPENJDK_BUILD_OS" = xwindows; then + AC_MSG_CHECKING([if uncygdrive can be created]) + UNCYGDRIVE_SRC=`$CYGPATH -m $SRC_ROOT/common/src/uncygdrive.c` + rm -f $OUTPUT_ROOT/uncygdrive* + UNCYGDRIVE=`$CYGPATH -m $OUTPUT_ROOT/uncygdrive.exe` + cd $OUTPUT_ROOT + $CC $UNCYGDRIVE_SRC /Fe$UNCYGDRIVE > $OUTPUT_ROOT/uncygdrive1.log 2>&1 + cd $CURDIR + + if test ! -x $OUTPUT_ROOT/uncygdrive.exe; then + AC_MSG_RESULT([no]) + cat $OUTPUT_ROOT/uncygdrive1.log + AC_MSG_ERROR([Could not create $OUTPUT_ROOT/uncygdrive.exe]) + fi + AC_MSG_RESULT([$UNCYGDRIVE]) + AC_MSG_CHECKING([if uncygdrive.exe works]) + cd $OUTPUT_ROOT + $UNCYGDRIVE $CC $SRC_ROOT/common/src/uncygdrive.c /Fe$OUTPUT_ROOT/uncygdrive2.exe > $OUTPUT_ROOT/uncygdrive2.log 2>&1 + cd $CURDIR + if test ! -x $OUTPUT_ROOT/uncygdrive2.exe; then + AC_MSG_RESULT([no]) + cat $OUTPUT_ROOT/uncygdrive2.log + AC_MSG_ERROR([Uncygdrive did not work!]) + fi + AC_MSG_RESULT([yes]) + rm -f $OUTPUT_ROOT/uncygdrive?.??? $OUTPUT_ROOT/uncygdrive.obj +fi + +AC_SUBST(UNCYGDRIVE) +]) + + +# Check if build directory is on local disk. +# Argument 1: directory to test +# Argument 2: what to do if it is on local disk +# Argument 3: what to do otherwise (remote disk or failure) +AC_DEFUN([BASIC_CHECK_DIR_ON_LOCAL_DISK], +[ + # df -l lists only local disks; if the given directory is not found then + # a non-zero exit code is given + if $DF -l $1 > /dev/null 2>&1; then + $2 + else + $3 + fi +]) + +AC_DEFUN_ONCE([BASIC_TEST_USABILITY_ISSUES], +[ + +AC_MSG_CHECKING([if build directory is on local disk]) +BASIC_CHECK_DIR_ON_LOCAL_DISK($OUTPUT_ROOT, + [OUTPUT_DIR_IS_LOCAL="yes"], + [OUTPUT_DIR_IS_LOCAL="no"]) +AC_MSG_RESULT($OUTPUT_DIR_IS_LOCAL) + +# Check if the user has any old-style ALT_ variables set. +FOUND_ALT_VARIABLES=`env | grep ^ALT_` + +# Before generating output files, test if they exist. If they do, this is a reconfigure. +# Since we can't properly handle the dependencies for this, warn the user about the situation +if test -e $OUTPUT_ROOT/spec.gmk; then + IS_RECONFIGURE=yes +else + IS_RECONFIGURE=no +fi + +if test -e $SRC_ROOT/build/.hide-configure-performance-hints; then + HIDE_PERFORMANCE_HINTS=yes +else + HIDE_PERFORMANCE_HINTS=no + # Hide it the next time around... + $TOUCH $SRC_ROOT/build/.hide-configure-performance-hints > /dev/null 2>&1 +fi + +]) diff --git a/common/autoconf/boot-jdk.m4 b/common/autoconf/boot-jdk.m4 new file mode 100644 index 00000000000..f8204f9c2d2 --- /dev/null +++ b/common/autoconf/boot-jdk.m4 @@ -0,0 +1,295 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +# Fixes paths on windows to be mixed mode short. +AC_DEFUN([BOOTJDK_WIN_FIX_PATH], +[ + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + AC_PATH_PROG(CYGPATH, cygpath) + tmp="[$]$1" + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + $1="$tmp" + fi +]) + +AC_DEFUN([BOOTJDK_MISSING_ERROR], +[ + AC_MSG_NOTICE([This might be fixed by explicitely setting --with-boot-jdk]) + AC_MSG_ERROR([Cannot continue]) +]) + +############################################################################### +# +# We need a Boot JDK to bootstrap the build. +# + +AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK], +[ +BOOT_JDK_FOUND=no +AC_ARG_WITH(boot-jdk, [AS_HELP_STRING([--with-boot-jdk], + [path to Boot JDK (used to bootstrap build) @<:@probed@:>@])]) + +if test "x$with_boot_jdk" != x; then + BOOT_JDK=$with_boot_jdk + BOOT_JDK_FOUND=yes +fi +if test "x$BOOT_JDK_FOUND" = xno; then + BDEPS_CHECK_MODULE(BOOT_JDK, boot-jdk, xxx, [BOOT_JDK_FOUND=yes], [BOOT_JDK_FOUND=no]) +fi + +if test "x$BOOT_JDK_FOUND" = xno; then + if test "x$JAVA_HOME" != x; then + if test ! -d "$JAVA_HOME"; then + AC_MSG_NOTICE([Your JAVA_HOME points to a non-existing directory!]) + BOOTJDK_MISSING_ERROR + fi + # Aha, the user has set a JAVA_HOME + # let us use that as the Boot JDK. + BOOT_JDK="$JAVA_HOME" + BOOT_JDK_FOUND=yes + # To be on the safe side, lets check that it is a JDK. + if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then + JAVAC="$BOOT_JDK/bin/javac" + JAVA="$BOOT_JDK/bin/java" + BOOT_JDK_FOUND=yes + else + AC_MSG_NOTICE([Your JAVA_HOME points to a JRE! The build needs a JDK! Please point JAVA_HOME to a JDK. JAVA_HOME=[$]JAVA_HOME]) + BOOTJDK_MISSING_ERROR + fi + fi +fi + +if test "x$BOOT_JDK_FOUND" = xno; then + AC_PATH_PROG(JAVAC_CHECK, javac) + AC_PATH_PROG(JAVA_CHECK, java) + BINARY="$JAVAC_CHECK" + if test "x$JAVAC_CHECK" = x; then + BINARY="$JAVA_CHECK" + fi + if test "x$BINARY" != x; then + # So there is a java(c) binary, it might be part of a JDK. + # Lets find the JDK/JRE directory by following symbolic links. + # Linux/GNU systems often have links from /usr/bin/java to + # /etc/alternatives/java to the real JDK binary. + WHICHCMD_SPACESAFE(BINARY,[path to javac]) + REMOVE_SYMBOLIC_LINKS(BINARY) + BOOT_JDK=`dirname $BINARY` + BOOT_JDK=`cd $BOOT_JDK/..; pwd` + if test -x $BOOT_JDK/bin/javac && test -x $BOOT_JDK/bin/java; then + JAVAC=$BOOT_JDK/bin/javac + JAVA=$BOOT_JDK/bin/java + BOOT_JDK_FOUND=yes + fi + fi +fi + +if test "x$BOOT_JDK_FOUND" = xno; then + # Try the MacOSX way. + if test -x /usr/libexec/java_home; then + BOOT_JDK=`/usr/libexec/java_home` + if test -x $BOOT_JDK/bin/javac && test -x $BOOT_JDK/bin/java; then + JAVAC=$BOOT_JDK/bin/javac + JAVA=$BOOT_JDK/bin/java + BOOT_JDK_FOUND=yes + fi + fi +fi + +if test "x$BOOT_JDK_FOUND" = xno; then + AC_PATH_PROG(JAVA_CHECK, java) + if test "x$JAVA_CHECK" != x; then + # There is a java in the path. But apparently we have not found a javac + # in the path, since that would have been tested earlier. + if test "x$OPENJDK_TARGET_OS" = xwindows; then + # Now if this is a windows platform. The default installation of a JDK + # actually puts the JRE in the path and keeps the JDK out of the path! + # Go look in the default installation location. + BOOT_JDK=/cygdrive/c/Program\ Files/Java/`ls /cygdrive/c/Program\ Files/Java | grep jdk | sort -r | head --lines 1` + if test -d "$BOOT_JDK"; then + BOOT_JDK_FOUND=yes + fi + fi + if test "x$BOOT_JDK_FOUND" = xno; then + HELP_MSG_MISSING_DEPENDENCY([openjdk]) + AC_MSG_NOTICE([Found a JRE, not not a JDK! Please remove the JRE from your path and put a JDK there instead. $HELP_MSG]) + BOOTJDK_MISSING_ERROR + fi + else + HELP_MSG_MISSING_DEPENDENCY([openjdk]) + AC_MSG_NOTICE([Could not find a JDK. $HELP_MSG]) + BOOTJDK_MISSING_ERROR + fi +fi + +BOOTJDK_WIN_FIX_PATH(BOOT_JDK) + +# Now see if we can find the rt.jar, or its nearest equivalent. +BOOT_RTJAR="$BOOT_JDK/jre/lib/rt.jar" +SPACESAFE(BOOT_RTJAR,[the path to the Boot JDK rt.jar (or nearest equivalent)]) + +BOOT_TOOLSJAR="$BOOT_JDK/lib/tools.jar" +SPACESAFE(BOOT_TOOLSJAR,[the path to the Boot JDK tools.jar (or nearest equivalent)]) + +if test ! -f $BOOT_RTJAR; then + # On MacOSX it is called classes.jar + BOOT_RTJAR=$BOOT_JDK/../Classes/classes.jar + if test ! -f $BOOT_RTJAR; then + AC_MSG_NOTICE([Cannot find the rt.jar or its equivalent!]) + AC_MSG_NOTICE([This typically means that configure failed to automatically find a suitable Boot JDK]) + BOOTJDK_MISSING_ERROR + fi + # Remove the .. + BOOT_RTJAR="`cd ${BOOT_RTJAR%/*} && pwd`/${BOOT_RTJAR##*/}" + # The tools.jar is part of classes.jar + BOOT_TOOLSJAR="$BOOT_RTJAR" +fi + +AC_SUBST(BOOT_JDK) +AC_SUBST(BOOT_RTJAR) +AC_SUBST(BOOT_TOOLSJAR) +AC_MSG_CHECKING([for Boot JDK]) +AC_MSG_RESULT([$BOOT_JDK]) +AC_MSG_CHECKING([for Boot rt.jar]) +AC_MSG_RESULT([$BOOT_RTJAR]) +AC_MSG_CHECKING([for Boot tools.jar]) +AC_MSG_RESULT([$BOOT_TOOLSJAR]) + +# Use the java tool from the Boot JDK. +AC_MSG_CHECKING([for java in Boot JDK]) +JAVA=$BOOT_JDK/bin/java +if test ! -x $JAVA; then + AC_MSG_NOTICE([Could not find a working java]) + BOOTJDK_MISSING_ERROR +fi +BOOT_JDK_VERSION=`$JAVA -version 2>&1 | head -n 1` +AC_MSG_RESULT([yes $BOOT_JDK_VERSION]) +AC_SUBST(JAVA) + +# Extra M4 quote needed to protect [] in grep expression. +[FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep '\"1\.[78]\.'`] +if test "x$FOUND_VERSION_78" = x; then + HELP_MSG_MISSING_DEPENDENCY([openjdk]) + AC_MSG_NOTICE([Your boot-jdk must be version 7 or 8. $HELP_MSG]) + BOOTJDK_MISSING_ERROR +fi + +# When compiling code to be executed by the Boot JDK, force jdk7 compatibility. +BOOT_JDK_SOURCETARGET="-source 7 -target 7" +AC_SUBST(BOOT_JDK_SOURCETARGET) + +# Use the javac tool from the Boot JDK. +AC_MSG_CHECKING([for javac in Boot JDK]) +JAVAC=$BOOT_JDK/bin/javac +if test ! -x $JAVAC; then + AC_MSG_ERROR([Could not find a working javac]) +fi +AC_MSG_RESULT(yes) +AC_SUBST(JAVAC) +AC_SUBST(JAVAC_FLAGS) + +# Use the javah tool from the Boot JDK. +AC_MSG_CHECKING([for javah in Boot JDK]) +JAVAH=$BOOT_JDK/bin/javah +if test ! -x $JAVAH; then + AC_MSG_NOTICE([Could not find a working javah]) + BOOTJDK_MISSING_ERROR +fi +AC_MSG_RESULT(yes) +AC_SUBST(JAVAH) + +# Use the jar tool from the Boot JDK. +AC_MSG_CHECKING([for jar in Boot JDK]) +JAR=$BOOT_JDK/bin/jar +if test ! -x $JAR; then + AC_MSG_NOTICE([Could not find a working jar]) + BOOTJDK_MISSING_ERROR +fi +AC_SUBST(JAR) +AC_MSG_RESULT(yes) + +# Use the rmic tool from the Boot JDK. +AC_MSG_CHECKING([for rmic in Boot JDK]) +RMIC=$BOOT_JDK/bin/rmic +if test ! -x $RMIC; then + AC_MSG_NOTICE([Could not find a working rmic]) + BOOTJDK_MISSING_ERROR +fi +AC_SUBST(RMIC) +AC_MSG_RESULT(yes) + +# Use the native2ascii tool from the Boot JDK. +AC_MSG_CHECKING([for native2ascii in Boot JDK]) +NATIVE2ASCII=$BOOT_JDK/bin/native2ascii +if test ! -x $NATIVE2ASCII; then + AC_MSG_NOTICE([Could not find a working native2ascii]) + BOOTJDK_MISSING_ERROR +fi +AC_MSG_RESULT(yes) +AC_SUBST(NATIVE2ASCII) +]) + +AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK_ARGUMENTS], +[ +############################################################################## +# +# Specify options for anything that is run with the Boot JDK. +# +AC_ARG_WITH(boot-jdk-jvmargs, [AS_HELP_STRING([--with-boot-jdk-jvmargs], + [specify JVM arguments to be passed to all invocations of the Boot JDK, overriding the default values, + e.g --with-boot-jdk-jvmargs="-Xmx8G -enableassertions"])]) + +if test "x$with_boot_jdk_jvmargs" = x; then + # Not all JVM:s accept the same arguments on the command line. + # OpenJDK specific increase in thread stack for JDK build, + # well more specifically, when running javac. + if test "x$BUILD_NUM_BITS" = x32; then + STACK_SIZE=768 + else + # Running Javac on a JVM on a 64-bit machine, the stack takes more space + # since 64-bit pointers are pushed on the stach. Apparently, we need + # to increase the stack space when javacing the JDK.... + STACK_SIZE=1536 + fi + + # Minimum amount of heap memory. + ADD_JVM_ARG_IF_OK([-Xms64M],boot_jdk_jvmargs,[$JAVA]) + if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then + # Why does macosx need more heap? Its the huge JDK batch. + ADD_JVM_ARG_IF_OK([-Xmx1600M],boot_jdk_jvmargs,[$JAVA]) + else + ADD_JVM_ARG_IF_OK([-Xmx1100M],boot_jdk_jvmargs,[$JAVA]) + fi + # When is adding -client something that speeds up the JVM? + # ADD_JVM_ARG_IF_OK([-client],boot_jdk_jvmargs,[$JAVA]) + ADD_JVM_ARG_IF_OK([-XX:PermSize=32m],boot_jdk_jvmargs,[$JAVA]) + ADD_JVM_ARG_IF_OK([-XX:MaxPermSize=160m],boot_jdk_jvmargs,[$JAVA]) + ADD_JVM_ARG_IF_OK([-XX:ThreadStackSize=$STACK_SIZE],boot_jdk_jvmargs,[$JAVA]) + # Disable special log output when a debug build is used as Boot JDK... + ADD_JVM_ARG_IF_OK([-XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput],boot_jdk_jvmargs,[$JAVA]) +fi + +AC_SUBST(BOOT_JDK_JVMARGS, $boot_jdk_jvmargs) +]) diff --git a/common/autoconf/build-aux/autoconf-config.guess b/common/autoconf/build-aux/autoconf-config.guess new file mode 100644 index 00000000000..e69905d5201 --- /dev/null +++ b/common/autoconf/build-aux/autoconf-config.guess @@ -0,0 +1,1531 @@ +#! /bin/sh +# Attempt to guess a canonical system name. +# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, +# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 +# Free Software Foundation, Inc. + +timestamp='2008-01-23' + +# This file is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program 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 for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA +# 02110-1301, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + + +# Originally written by Per Bothner . +# Please send patches to . Submit a context +# diff and a properly formatted ChangeLog entry. +# +# This script attempts to guess a canonical system name similar to +# config.sub. If it succeeds, it prints the system name on stdout, and +# exits with 0. Otherwise, it exits with 1. +# +# The plan is that this can be called by configure scripts if you +# don't specify an explicit build system type. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] + +Output the configuration name of the system \`$me' is run on. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.guess ($timestamp) + +Originally written by Per Bothner. +Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, +2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit ;; + --version | -v ) + echo "$version" ; exit ;; + --help | --h* | -h ) + echo "$usage"; exit ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" >&2 + exit 1 ;; + * ) + break ;; + esac +done + +if test $# != 0; then + echo "$me: too many arguments$help" >&2 + exit 1 +fi + +trap 'exit 1' 1 2 15 + +# CC_FOR_BUILD -- compiler used by this script. Note that the use of a +# compiler to aid in system detection is discouraged as it requires +# temporary files to be created and, as you can see below, it is a +# headache to deal with in a portable fashion. + +# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still +# use `HOST_CC' if defined, but it is deprecated. + +# Portable tmp directory creation inspired by the Autoconf team. + +set_cc_for_build=' +trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; +trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; +: ${TMPDIR=/tmp} ; + { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; +dummy=$tmp/dummy ; +tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; +case $CC_FOR_BUILD,$HOST_CC,$CC in + ,,) echo "int x;" > $dummy.c ; + for c in cc gcc c89 c99 ; do + if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then + CC_FOR_BUILD="$c"; break ; + fi ; + done ; + if test x"$CC_FOR_BUILD" = x ; then + CC_FOR_BUILD=no_compiler_found ; + fi + ;; + ,,*) CC_FOR_BUILD=$CC ;; + ,*,*) CC_FOR_BUILD=$HOST_CC ;; +esac ; set_cc_for_build= ;' + +# This is needed to find uname on a Pyramid OSx when run in the BSD universe. +# (ghazi@noc.rutgers.edu 1994-08-24) +if (test -f /.attbin/uname) >/dev/null 2>&1 ; then + PATH=$PATH:/.attbin ; export PATH +fi + +UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown +UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown +UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown +UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown + +# Note: order is significant - the case branches are not exclusive. + +case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in + *:NetBSD:*:*) + # NetBSD (nbsd) targets should (where applicable) match one or + # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, + # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently + # switched to ELF, *-*-netbsd* would select the old + # object file format. This provides both forward + # compatibility and a consistent mechanism for selecting the + # object file format. + # + # Note: NetBSD doesn't particularly care about the vendor + # portion of the name. We always set it to "unknown". + sysctl="sysctl -n hw.machine_arch" + UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ + /usr/sbin/$sysctl 2>/dev/null || echo unknown)` + case "${UNAME_MACHINE_ARCH}" in + armeb) machine=armeb-unknown ;; + arm*) machine=arm-unknown ;; + sh3el) machine=shl-unknown ;; + sh3eb) machine=sh-unknown ;; + sh5el) machine=sh5le-unknown ;; + *) machine=${UNAME_MACHINE_ARCH}-unknown ;; + esac + # The Operating System including object format, if it has switched + # to ELF recently, or will in the future. + case "${UNAME_MACHINE_ARCH}" in + arm*|i386|m68k|ns32k|sh3*|sparc|vax) + eval $set_cc_for_build + if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep __ELF__ >/dev/null + then + # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). + # Return netbsd for either. FIX? + os=netbsd + else + os=netbsdelf + fi + ;; + *) + os=netbsd + ;; + esac + # The OS release + # Debian GNU/NetBSD machines have a different userland, and + # thus, need a distinct triplet. However, they do not need + # kernel version information, so it can be replaced with a + # suitable tag, in the style of linux-gnu. + case "${UNAME_VERSION}" in + Debian*) + release='-gnu' + ;; + *) + release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` + ;; + esac + # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: + # contains redundant information, the shorter form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. + echo "${machine}-${os}${release}" + exit ;; + *:OpenBSD:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` + echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} + exit ;; + *:ekkoBSD:*:*) + echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} + exit ;; + *:SolidBSD:*:*) + echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} + exit ;; + macppc:MirBSD:*:*) + echo powerpc-unknown-mirbsd${UNAME_RELEASE} + exit ;; + *:MirBSD:*:*) + echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} + exit ;; + alpha:OSF1:*:*) + case $UNAME_RELEASE in + *4.0) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` + ;; + *5.*) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` + ;; + esac + # According to Compaq, /usr/sbin/psrinfo has been available on + # OSF/1 and Tru64 systems produced since 1995. I hope that + # covers most systems running today. This code pipes the CPU + # types through head -n 1, so we only detect the type of CPU 0. + ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` + case "$ALPHA_CPU_TYPE" in + "EV4 (21064)") + UNAME_MACHINE="alpha" ;; + "EV4.5 (21064)") + UNAME_MACHINE="alpha" ;; + "LCA4 (21066/21068)") + UNAME_MACHINE="alpha" ;; + "EV5 (21164)") + UNAME_MACHINE="alphaev5" ;; + "EV5.6 (21164A)") + UNAME_MACHINE="alphaev56" ;; + "EV5.6 (21164PC)") + UNAME_MACHINE="alphapca56" ;; + "EV5.7 (21164PC)") + UNAME_MACHINE="alphapca57" ;; + "EV6 (21264)") + UNAME_MACHINE="alphaev6" ;; + "EV6.7 (21264A)") + UNAME_MACHINE="alphaev67" ;; + "EV6.8CB (21264C)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8AL (21264B)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8CX (21264D)") + UNAME_MACHINE="alphaev68" ;; + "EV6.9A (21264/EV69A)") + UNAME_MACHINE="alphaev69" ;; + "EV7 (21364)") + UNAME_MACHINE="alphaev7" ;; + "EV7.9 (21364A)") + UNAME_MACHINE="alphaev79" ;; + esac + # A Pn.n version is a patched version. + # A Vn.n version is a released version. + # A Tn.n version is a released field test version. + # A Xn.n version is an unreleased experimental baselevel. + # 1.2 uses "1.2" for uname -r. + echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + exit ;; + Alpha\ *:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # Should we change UNAME_MACHINE based on the output of uname instead + # of the specific Alpha model? + echo alpha-pc-interix + exit ;; + 21064:Windows_NT:50:3) + echo alpha-dec-winnt3.5 + exit ;; + Amiga*:UNIX_System_V:4.0:*) + echo m68k-unknown-sysv4 + exit ;; + *:[Aa]miga[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-amigaos + exit ;; + *:[Mm]orph[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-morphos + exit ;; + *:OS/390:*:*) + echo i370-ibm-openedition + exit ;; + *:z/VM:*:*) + echo s390-ibm-zvmoe + exit ;; + *:OS400:*:*) + echo powerpc-ibm-os400 + exit ;; + arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) + echo arm-acorn-riscix${UNAME_RELEASE} + exit ;; + arm:riscos:*:*|arm:RISCOS:*:*) + echo arm-unknown-riscos + exit ;; + SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) + echo hppa1.1-hitachi-hiuxmpp + exit ;; + Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) + # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. + if test "`(/bin/universe) 2>/dev/null`" = att ; then + echo pyramid-pyramid-sysv3 + else + echo pyramid-pyramid-bsd + fi + exit ;; + NILE*:*:*:dcosx) + echo pyramid-pyramid-svr4 + exit ;; + DRS?6000:unix:4.0:6*) + echo sparc-icl-nx6 + exit ;; + DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) + case `/usr/bin/uname -p` in + sparc) echo sparc-icl-nx7; exit ;; + esac ;; + sun4H:SunOS:5.*:*) + echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) + echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) + echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:6*:*) + # According to config.sub, this is the proper way to canonicalize + # SunOS6. Hard to guess exactly what SunOS6 will be like, but + # it's likely to be more like Solaris than SunOS4. + echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:*:*) + case "`/usr/bin/arch -k`" in + Series*|S4*) + UNAME_RELEASE=`uname -v` + ;; + esac + # Japanese Language versions have a version number like `4.1.3-JL'. + echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` + exit ;; + sun3*:SunOS:*:*) + echo m68k-sun-sunos${UNAME_RELEASE} + exit ;; + sun*:*:4.2BSD:*) + UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` + test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 + case "`/bin/arch`" in + sun3) + echo m68k-sun-sunos${UNAME_RELEASE} + ;; + sun4) + echo sparc-sun-sunos${UNAME_RELEASE} + ;; + esac + exit ;; + aushp:SunOS:*:*) + echo sparc-auspex-sunos${UNAME_RELEASE} + exit ;; + # The situation for MiNT is a little confusing. The machine name + # can be virtually everything (everything which is not + # "atarist" or "atariste" at least should have a processor + # > m68000). The system name ranges from "MiNT" over "FreeMiNT" + # to the lowercase version "mint" (or "freemint"). Finally + # the system name "TOS" denotes a system which is actually not + # MiNT. But MiNT is downward compatible to TOS, so this should + # be no problem. + atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) + echo m68k-milan-mint${UNAME_RELEASE} + exit ;; + hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) + echo m68k-hades-mint${UNAME_RELEASE} + exit ;; + *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) + echo m68k-unknown-mint${UNAME_RELEASE} + exit ;; + m68k:machten:*:*) + echo m68k-apple-machten${UNAME_RELEASE} + exit ;; + powerpc:machten:*:*) + echo powerpc-apple-machten${UNAME_RELEASE} + exit ;; + RISC*:Mach:*:*) + echo mips-dec-mach_bsd4.3 + exit ;; + RISC*:ULTRIX:*:*) + echo mips-dec-ultrix${UNAME_RELEASE} + exit ;; + VAX*:ULTRIX*:*:*) + echo vax-dec-ultrix${UNAME_RELEASE} + exit ;; + 2020:CLIX:*:* | 2430:CLIX:*:*) + echo clipper-intergraph-clix${UNAME_RELEASE} + exit ;; + mips:*:*:UMIPS | mips:*:*:RISCos) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c +#ifdef __cplusplus +#include /* for printf() prototype */ + int main (int argc, char *argv[]) { +#else + int main (argc, argv) int argc; char *argv[]; { +#endif + #if defined (host_mips) && defined (MIPSEB) + #if defined (SYSTYPE_SYSV) + printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_SVR4) + printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) + printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); + #endif + #endif + exit (-1); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && + dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && + SYSTEM_NAME=`$dummy $dummyarg` && + { echo "$SYSTEM_NAME"; exit; } + echo mips-mips-riscos${UNAME_RELEASE} + exit ;; + Motorola:PowerMAX_OS:*:*) + echo powerpc-motorola-powermax + exit ;; + Motorola:*:4.3:PL8-*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:Power_UNIX:*:*) + echo powerpc-harris-powerunix + exit ;; + m88k:CX/UX:7*:*) + echo m88k-harris-cxux7 + exit ;; + m88k:*:4*:R4*) + echo m88k-motorola-sysv4 + exit ;; + m88k:*:3*:R3*) + echo m88k-motorola-sysv3 + exit ;; + AViiON:dgux:*:*) + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` + if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] + then + if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ + [ ${TARGET_BINARY_INTERFACE}x = x ] + then + echo m88k-dg-dgux${UNAME_RELEASE} + else + echo m88k-dg-dguxbcs${UNAME_RELEASE} + fi + else + echo i586-dg-dgux${UNAME_RELEASE} + fi + exit ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) + echo m88k-dolphin-sysv3 + exit ;; + M88*:*:R3*:*) + # Delta 88k system running SVR3 + echo m88k-motorola-sysv3 + exit ;; + XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) + echo m88k-tektronix-sysv3 + exit ;; + Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) + echo m68k-tektronix-bsd + exit ;; + *:IRIX*:*:*) + echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` + exit ;; + ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. + echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id + exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + i*86:AIX:*:*) + echo i386-ibm-aix + exit ;; + ia64:AIX:*:*) + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} + exit ;; + *:AIX:2:3) + if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + + main() + { + if (!__power_pc()) + exit(1); + puts("powerpc-ibm-aix3.2.5"); + exit(0); + } +EOF + if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` + then + echo "$SYSTEM_NAME" + else + echo rs6000-ibm-aix3.2.5 + fi + elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then + echo rs6000-ibm-aix3.2.4 + else + echo rs6000-ibm-aix3.2 + fi + exit ;; + *:AIX:*:[456]) + IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` + if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then + IBM_ARCH=rs6000 + else + IBM_ARCH=powerpc + fi + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${IBM_ARCH}-ibm-aix${IBM_REV} + exit ;; + *:AIX:*:*) + echo rs6000-ibm-aix + exit ;; + ibmrt:4.4BSD:*|romp-ibm:BSD:*) + echo romp-ibm-bsd4.4 + exit ;; + ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and + echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to + exit ;; # report: romp-ibm BSD 4.3 + *:BOSX:*:*) + echo rs6000-bull-bosx + exit ;; + DPX/2?00:B.O.S.:*:*) + echo m68k-bull-sysv3 + exit ;; + 9000/[34]??:4.3bsd:1.*:*) + echo m68k-hp-bsd + exit ;; + hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) + echo m68k-hp-bsd4.4 + exit ;; + 9000/[34678]??:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + case "${UNAME_MACHINE}" in + 9000/31? ) HP_ARCH=m68000 ;; + 9000/[34]?? ) HP_ARCH=m68k ;; + 9000/[678][0-9][0-9]) + if [ -x /usr/bin/getconf ]; then + sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` + case "${sc_cpu_version}" in + 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 + 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 + case "${sc_kernel_bits}" in + 32) HP_ARCH="hppa2.0n" ;; + 64) HP_ARCH="hppa2.0w" ;; + '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 + esac ;; + esac + fi + if [ "${HP_ARCH}" = "" ]; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + + #define _HPUX_SOURCE + #include + #include + + int main () + { + #if defined(_SC_KERNEL_BITS) + long bits = sysconf(_SC_KERNEL_BITS); + #endif + long cpu = sysconf (_SC_CPU_VERSION); + + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1"); break; + case CPU_PA_RISC2_0: + #if defined(_SC_KERNEL_BITS) + switch (bits) + { + case 64: puts ("hppa2.0w"); break; + case 32: puts ("hppa2.0n"); break; + default: puts ("hppa2.0"); break; + } break; + #else /* !defined(_SC_KERNEL_BITS) */ + puts ("hppa2.0"); break; + #endif + default: puts ("hppa1.0"); break; + } + exit (0); + } +EOF + (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` + test -z "$HP_ARCH" && HP_ARCH=hppa + fi ;; + esac + if [ ${HP_ARCH} = "hppa2.0w" ] + then + eval $set_cc_for_build + + # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating + # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler + # generating 64-bit code. GNU and HP use different nomenclature: + # + # $ CC_FOR_BUILD=cc ./config.guess + # => hppa2.0w-hp-hpux11.23 + # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess + # => hppa64-hp-hpux11.23 + + if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | + grep __LP64__ >/dev/null + then + HP_ARCH="hppa2.0w" + else + HP_ARCH="hppa64" + fi + fi + echo ${HP_ARCH}-hp-hpux${HPUX_REV} + exit ;; + ia64:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + echo ia64-hp-hpux${HPUX_REV} + exit ;; + 3050*:HI-UX:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + int + main () + { + long cpu = sysconf (_SC_CPU_VERSION); + /* The order matters, because CPU_IS_HP_MC68K erroneously returns + true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct + results, however. */ + if (CPU_IS_PA_RISC (cpu)) + { + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; + case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; + default: puts ("hppa-hitachi-hiuxwe2"); break; + } + } + else if (CPU_IS_HP_MC68K (cpu)) + puts ("m68k-hitachi-hiuxwe2"); + else puts ("unknown-hitachi-hiuxwe2"); + exit (0); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && + { echo "$SYSTEM_NAME"; exit; } + echo unknown-hitachi-hiuxwe2 + exit ;; + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) + echo hppa1.1-hp-bsd + exit ;; + 9000/8??:4.3bsd:*:*) + echo hppa1.0-hp-bsd + exit ;; + *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) + echo hppa1.0-hp-mpeix + exit ;; + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) + echo hppa1.1-hp-osf + exit ;; + hp8??:OSF1:*:*) + echo hppa1.0-hp-osf + exit ;; + i*86:OSF1:*:*) + if [ -x /usr/sbin/sysversion ] ; then + echo ${UNAME_MACHINE}-unknown-osf1mk + else + echo ${UNAME_MACHINE}-unknown-osf1 + fi + exit ;; + parisc*:Lites*:*:*) + echo hppa1.1-hp-lites + exit ;; + C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) + echo c1-convex-bsd + exit ;; + C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit ;; + C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) + echo c34-convex-bsd + exit ;; + C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) + echo c38-convex-bsd + exit ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) + echo c4-convex-bsd + exit ;; + CRAY*Y-MP:*:*:*) + echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*[A-Z]90:*:*:*) + echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ + | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ + -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ + -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*TS:*:*:*) + echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*T3E:*:*:*) + echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*SV1:*:*:*) + echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + *:UNICOS/mp:*:*) + echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) + FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` + echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + 5000:UNIX_System_V:4.*:*) + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` + echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) + echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} + exit ;; + sparc*:BSD/OS:*:*) + echo sparc-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:BSD/OS:*:*) + echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:FreeBSD:*:*) + case ${UNAME_MACHINE} in + pc98) + echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + amd64) + echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + *) + echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + esac + exit ;; + i*:CYGWIN*:*) + echo ${UNAME_MACHINE}-pc-cygwin + exit ;; + *:MINGW*:*) + echo ${UNAME_MACHINE}-pc-mingw32 + exit ;; + i*:windows32*:*) + # uname -m includes "-pc" on this system. + echo ${UNAME_MACHINE}-mingw32 + exit ;; + i*:PW*:*) + echo ${UNAME_MACHINE}-pc-pw32 + exit ;; + *:Interix*:[3456]*) + case ${UNAME_MACHINE} in + x86) + echo i586-pc-interix${UNAME_RELEASE} + exit ;; + EM64T | authenticamd) + echo x86_64-unknown-interix${UNAME_RELEASE} + exit ;; + IA64) + echo ia64-unknown-interix${UNAME_RELEASE} + exit ;; + esac ;; + [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) + echo i${UNAME_MACHINE}-pc-mks + exit ;; + i*:Windows_NT*:* | Pentium*:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we + # UNAME_MACHINE based on the output of uname instead of i386? + echo i586-pc-interix + exit ;; + i*:UWIN*:*) + echo ${UNAME_MACHINE}-pc-uwin + exit ;; + amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) + echo x86_64-unknown-cygwin + exit ;; + p*:CYGWIN*:*) + echo powerpcle-unknown-cygwin + exit ;; + prep*:SunOS:5.*:*) + echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + *:GNU:*:*) + # the GNU system + echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` + exit ;; + *:GNU/*:*:*) + # other systems with GNU libc and userland + echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu + exit ;; + i*86:Minix:*:*) + echo ${UNAME_MACHINE}-pc-minix + exit ;; + arm*:Linux:*:*) + eval $set_cc_for_build + if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_EABI__ + then + echo ${UNAME_MACHINE}-unknown-linux-gnu + else + echo ${UNAME_MACHINE}-unknown-linux-gnueabi + fi + exit ;; + avr32*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + cris:Linux:*:*) + echo cris-axis-linux-gnu + exit ;; + crisv32:Linux:*:*) + echo crisv32-axis-linux-gnu + exit ;; + frv:Linux:*:*) + echo frv-unknown-linux-gnu + exit ;; + ia64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + m32r*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + m68*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + mips:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips + #undef mipsel + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mipsel + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips + #else + CPU= + #endif + #endif +EOF + eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' + /^CPU/{ + s: ::g + p + }'`" + test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } + ;; + mips64:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips64 + #undef mips64el + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mips64el + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips64 + #else + CPU= + #endif + #endif +EOF + eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' + /^CPU/{ + s: ::g + p + }'`" + test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } + ;; + or32:Linux:*:*) + echo or32-unknown-linux-gnu + exit ;; + ppc:Linux:*:*) + echo powerpc-unknown-linux-gnu + exit ;; + ppc64:Linux:*:*) + echo powerpc64-unknown-linux-gnu + exit ;; + alpha:Linux:*:*) + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + EV5) UNAME_MACHINE=alphaev5 ;; + EV56) UNAME_MACHINE=alphaev56 ;; + PCA56) UNAME_MACHINE=alphapca56 ;; + PCA57) UNAME_MACHINE=alphapca56 ;; + EV6) UNAME_MACHINE=alphaev6 ;; + EV67) UNAME_MACHINE=alphaev67 ;; + EV68*) UNAME_MACHINE=alphaev68 ;; + esac + objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null + if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi + echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} + exit ;; + parisc:Linux:*:* | hppa:Linux:*:*) + # Look for CPU level + case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in + PA7*) echo hppa1.1-unknown-linux-gnu ;; + PA8*) echo hppa2.0-unknown-linux-gnu ;; + *) echo hppa-unknown-linux-gnu ;; + esac + exit ;; + parisc64:Linux:*:* | hppa64:Linux:*:*) + echo hppa64-unknown-linux-gnu + exit ;; + s390:Linux:*:* | s390x:Linux:*:*) + echo ${UNAME_MACHINE}-ibm-linux + exit ;; + sh64*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + sh*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + sparc:Linux:*:* | sparc64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + vax:Linux:*:*) + echo ${UNAME_MACHINE}-dec-linux-gnu + exit ;; + x86_64:Linux:*:*) + echo x86_64-unknown-linux-gnu + exit ;; + xtensa*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit ;; + i*86:Linux:*:*) + # The BFD linker knows what the default object file format is, so + # first see if it will tell us. cd to the root directory to prevent + # problems with other programs or directories called `ld' in the path. + # Set LC_ALL=C to ensure ld outputs messages in English. + ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \ + | sed -ne '/supported targets:/!d + s/[ ][ ]*/ /g + s/.*supported targets: *// + s/ .*// + p'` + case "$ld_supported_targets" in + elf32-i386) + TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu" + ;; + a.out-i386-linux) + echo "${UNAME_MACHINE}-pc-linux-gnuaout" + exit ;; + coff-i386) + echo "${UNAME_MACHINE}-pc-linux-gnucoff" + exit ;; + "") + # Either a pre-BFD a.out linker (linux-gnuoldld) or + # one that does not give us useful --help. + echo "${UNAME_MACHINE}-pc-linux-gnuoldld" + exit ;; + esac + # Determine whether the default compiler is a.out or elf + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + #ifdef __ELF__ + # ifdef __GLIBC__ + # if __GLIBC__ >= 2 + LIBC=gnu + # else + LIBC=gnulibc1 + # endif + # else + LIBC=gnulibc1 + # endif + #else + #if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__SUNPRO_C) || defined(__SUNPRO_CC) + LIBC=gnu + #else + LIBC=gnuaout + #endif + #endif + #ifdef __dietlibc__ + LIBC=dietlibc + #endif +EOF + eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n ' + /^LIBC/{ + s: ::g + p + }'`" + test x"${LIBC}" != x && { + echo "${UNAME_MACHINE}-pc-linux-${LIBC}" + exit + } + test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; } + ;; + i*86:DYNIX/ptx:4*:*) + # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. + # earlier versions are messed up and put the nodename in both + # sysname and nodename. + echo i386-sequent-sysv4 + exit ;; + i*86:UNIX_SV:4.2MP:2.*) + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, + # I just have to hope. -- rms. + # Use sysv4.2uw... so that sysv4* matches it. + echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} + exit ;; + i*86:OS/2:*:*) + # If we were able to find `uname', then EMX Unix compatibility + # is probably installed. + echo ${UNAME_MACHINE}-pc-os2-emx + exit ;; + i*86:XTS-300:*:STOP) + echo ${UNAME_MACHINE}-unknown-stop + exit ;; + i*86:atheos:*:*) + echo ${UNAME_MACHINE}-unknown-atheos + exit ;; + i*86:syllable:*:*) + echo ${UNAME_MACHINE}-pc-syllable + exit ;; + i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*) + echo i386-unknown-lynxos${UNAME_RELEASE} + exit ;; + i*86:*DOS:*:*) + echo ${UNAME_MACHINE}-pc-msdosdjgpp + exit ;; + i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) + UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` + if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then + echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} + else + echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} + fi + exit ;; + i*86:*:5:[678]*) + # UnixWare 7.x, OpenUNIX and OpenServer 6. + case `/bin/uname -X | grep "^Machine"` in + *486*) UNAME_MACHINE=i486 ;; + *Pentium) UNAME_MACHINE=i586 ;; + *Pent*|*Celeron) UNAME_MACHINE=i686 ;; + esac + echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} + exit ;; + i*86:*:3.2:*) + if test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then + UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` + (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 + (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ + && UNAME_MACHINE=i586 + (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ + && UNAME_MACHINE=i686 + (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ + && UNAME_MACHINE=i686 + echo ${UNAME_MACHINE}-pc-sco$UNAME_REL + else + echo ${UNAME_MACHINE}-pc-sysv32 + fi + exit ;; + pc:*:*:*) + # Left here for compatibility: + # uname -m prints for DJGPP always 'pc', but it prints nothing about + # the processor, so we play safe by assuming i386. + echo i386-pc-msdosdjgpp + exit ;; + Intel:Mach:3*:*) + echo i386-pc-mach3 + exit ;; + paragon:*:*:*) + echo i860-intel-osf1 + exit ;; + i860:*:4.*:*) # i860-SVR4 + if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then + echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. + echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 + fi + exit ;; + mini*:CTIX:SYS*5:*) + # "miniframe" + echo m68010-convergent-sysv + exit ;; + mc68k:UNIX:SYSTEM5:3.51m) + echo m68k-convergent-sysv + exit ;; + M680?0:D-NIX:5.3:*) + echo m68k-diab-dnix + exit ;; + M68*:*:R3V[5678]*:*) + test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; + 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) + OS_REL='' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; + 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4; exit; } ;; + m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) + echo m68k-unknown-lynxos${UNAME_RELEASE} + exit ;; + mc68030:UNIX_System_V:4.*:*) + echo m68k-atari-sysv4 + exit ;; + TSUNAMI:LynxOS:2.*:*) + echo sparc-unknown-lynxos${UNAME_RELEASE} + exit ;; + rs6000:LynxOS:2.*:*) + echo rs6000-unknown-lynxos${UNAME_RELEASE} + exit ;; + PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*) + echo powerpc-unknown-lynxos${UNAME_RELEASE} + exit ;; + SM[BE]S:UNIX_SV:*:*) + echo mips-dde-sysv${UNAME_RELEASE} + exit ;; + RM*:ReliantUNIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + RM*:SINIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` + echo ${UNAME_MACHINE}-sni-sysv4 + else + echo ns32k-sni-sysv + fi + exit ;; + PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort + # says + echo i586-unisys-sysv4 + exit ;; + *:UNIX_System_V:4*:FTX*) + # From Gerald Hewes . + # How about differentiating between stratus architectures? -djm + echo hppa1.1-stratus-sysv4 + exit ;; + *:*:*:FTX*) + # From seanf@swdc.stratus.com. + echo i860-stratus-sysv4 + exit ;; + i*86:VOS:*:*) + # From Paul.Green@stratus.com. + echo ${UNAME_MACHINE}-stratus-vos + exit ;; + *:VOS:*:*) + # From Paul.Green@stratus.com. + echo hppa1.1-stratus-vos + exit ;; + mc68*:A/UX:*:*) + echo m68k-apple-aux${UNAME_RELEASE} + exit ;; + news*:NEWS-OS:6*:*) + echo mips-sony-newsos6 + exit ;; + R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) + if [ -d /usr/nec ]; then + echo mips-nec-sysv${UNAME_RELEASE} + else + echo mips-unknown-sysv${UNAME_RELEASE} + fi + exit ;; + BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. + echo powerpc-be-beos + exit ;; + BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. + echo powerpc-apple-beos + exit ;; + BePC:BeOS:*:*) # BeOS running on Intel PC compatible. + echo i586-pc-beos + exit ;; + SX-4:SUPER-UX:*:*) + echo sx4-nec-superux${UNAME_RELEASE} + exit ;; + SX-5:SUPER-UX:*:*) + echo sx5-nec-superux${UNAME_RELEASE} + exit ;; + SX-6:SUPER-UX:*:*) + echo sx6-nec-superux${UNAME_RELEASE} + exit ;; + SX-7:SUPER-UX:*:*) + echo sx7-nec-superux${UNAME_RELEASE} + exit ;; + SX-8:SUPER-UX:*:*) + echo sx8-nec-superux${UNAME_RELEASE} + exit ;; + SX-8R:SUPER-UX:*:*) + echo sx8r-nec-superux${UNAME_RELEASE} + exit ;; + Power*:Rhapsody:*:*) + echo powerpc-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Rhapsody:*:*) + echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Darwin:*:*) + UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown + eval $set_cc_for_build + echo "int main(){}" > $dummy.c + if test "`$CC_FOR_BUILD -o $dummy $dummy.c; file $dummy | grep -c x86_64`" = 1 ; then + UNAME_PROCESSOR=x86_64 + fi + case $UNAME_PROCESSOR in + unknown) UNAME_PROCESSOR=powerpc ;; + esac + echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} + exit ;; + *:procnto*:*:* | *:QNX:[0123456789]*:*) + UNAME_PROCESSOR=`uname -p` + if test "$UNAME_PROCESSOR" = "x86"; then + UNAME_PROCESSOR=i386 + UNAME_MACHINE=pc + fi + echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} + exit ;; + *:QNX:*:4*) + echo i386-pc-qnx + exit ;; + NSE-?:NONSTOP_KERNEL:*:*) + echo nse-tandem-nsk${UNAME_RELEASE} + exit ;; + NSR-?:NONSTOP_KERNEL:*:*) + echo nsr-tandem-nsk${UNAME_RELEASE} + exit ;; + *:NonStop-UX:*:*) + echo mips-compaq-nonstopux + exit ;; + BS2000:POSIX*:*:*) + echo bs2000-siemens-sysv + exit ;; + DS/*:UNIX_System_V:*:*) + echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} + exit ;; + *:Plan9:*:*) + # "uname -m" is not consistent, so use $cputype instead. 386 + # is converted to i386 for consistency with other x86 + # operating systems. + if test "$cputype" = "386"; then + UNAME_MACHINE=i386 + else + UNAME_MACHINE="$cputype" + fi + echo ${UNAME_MACHINE}-unknown-plan9 + exit ;; + *:TOPS-10:*:*) + echo pdp10-unknown-tops10 + exit ;; + *:TENEX:*:*) + echo pdp10-unknown-tenex + exit ;; + KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) + echo pdp10-dec-tops20 + exit ;; + XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) + echo pdp10-xkl-tops20 + exit ;; + *:TOPS-20:*:*) + echo pdp10-unknown-tops20 + exit ;; + *:ITS:*:*) + echo pdp10-unknown-its + exit ;; + SEI:*:*:SEIUX) + echo mips-sei-seiux${UNAME_RELEASE} + exit ;; + *:DragonFly:*:*) + echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` + exit ;; + *:*VMS:*:*) + UNAME_MACHINE=`(uname -p) 2>/dev/null` + case "${UNAME_MACHINE}" in + A*) echo alpha-dec-vms ; exit ;; + I*) echo ia64-dec-vms ; exit ;; + V*) echo vax-dec-vms ; exit ;; + esac ;; + *:XENIX:*:SysV) + echo i386-pc-xenix + exit ;; + i*86:skyos:*:*) + echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' + exit ;; + i*86:rdos:*:*) + echo ${UNAME_MACHINE}-pc-rdos + exit ;; +esac + +#echo '(No uname command or uname output not recognized.)' 1>&2 +#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 + +eval $set_cc_for_build +cat >$dummy.c < +# include +#endif +main () +{ +#if defined (sony) +#if defined (MIPSEB) + /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, + I don't know.... */ + printf ("mips-sony-bsd\n"); exit (0); +#else +#include + printf ("m68k-sony-newsos%s\n", +#ifdef NEWSOS4 + "4" +#else + "" +#endif + ); exit (0); +#endif +#endif + +#if defined (__arm) && defined (__acorn) && defined (__unix) + printf ("arm-acorn-riscix\n"); exit (0); +#endif + +#if defined (hp300) && !defined (hpux) + printf ("m68k-hp-bsd\n"); exit (0); +#endif + +#if defined (NeXT) +#if !defined (__ARCHITECTURE__) +#define __ARCHITECTURE__ "m68k" +#endif + int version; + version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; + if (version < 4) + printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); + else + printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); + exit (0); +#endif + +#if defined (MULTIMAX) || defined (n16) +#if defined (UMAXV) + printf ("ns32k-encore-sysv\n"); exit (0); +#else +#if defined (CMU) + printf ("ns32k-encore-mach\n"); exit (0); +#else + printf ("ns32k-encore-bsd\n"); exit (0); +#endif +#endif +#endif + +#if defined (__386BSD__) + printf ("i386-pc-bsd\n"); exit (0); +#endif + +#if defined (sequent) +#if defined (i386) + printf ("i386-sequent-dynix\n"); exit (0); +#endif +#if defined (ns32000) + printf ("ns32k-sequent-dynix\n"); exit (0); +#endif +#endif + +#if defined (_SEQUENT_) + struct utsname un; + + uname(&un); + + if (strncmp(un.version, "V2", 2) == 0) { + printf ("i386-sequent-ptx2\n"); exit (0); + } + if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ + printf ("i386-sequent-ptx1\n"); exit (0); + } + printf ("i386-sequent-ptx\n"); exit (0); + +#endif + +#if defined (vax) +# if !defined (ultrix) +# include +# if defined (BSD) +# if BSD == 43 + printf ("vax-dec-bsd4.3\n"); exit (0); +# else +# if BSD == 199006 + printf ("vax-dec-bsd4.3reno\n"); exit (0); +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# endif +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# else + printf ("vax-dec-ultrix\n"); exit (0); +# endif +#endif + +#if defined (alliant) && defined (i860) + printf ("i860-alliant-bsd\n"); exit (0); +#endif + + exit (1); +} +EOF + +$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && + { echo "$SYSTEM_NAME"; exit; } + +# Apollos put the system type in the environment. + +test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } + +# Convex versions that predate uname can use getsysinfo(1) + +if [ -x /usr/convex/getsysinfo ] +then + case `getsysinfo -f cpu_type` in + c1*) + echo c1-convex-bsd + exit ;; + c2*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit ;; + c34*) + echo c34-convex-bsd + exit ;; + c38*) + echo c38-convex-bsd + exit ;; + c4*) + echo c4-convex-bsd + exit ;; + esac +fi + +cat >&2 < in order to provide the needed +information to handle your system. + +config.guess timestamp = $timestamp + +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null` + +hostinfo = `(hostinfo) 2>/dev/null` +/bin/universe = `(/bin/universe) 2>/dev/null` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` +/bin/arch = `(/bin/arch) 2>/dev/null` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` + +UNAME_MACHINE = ${UNAME_MACHINE} +UNAME_RELEASE = ${UNAME_RELEASE} +UNAME_SYSTEM = ${UNAME_SYSTEM} +UNAME_VERSION = ${UNAME_VERSION} +EOF + +exit 1 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/common/autoconf/build-performance.m4 b/common/autoconf/build-performance.m4 new file mode 100644 index 00000000000..964f890b792 --- /dev/null +++ b/common/autoconf/build-performance.m4 @@ -0,0 +1,378 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +AC_DEFUN([BPERF_CHECK_CORES], +[ + AC_MSG_CHECKING([for number of cores]) + NUM_CORES=1 + FOUND_CORES=no + + if test -f /proc/cpuinfo; then + # Looks like a Linux system + NUM_CORES=`cat /proc/cpuinfo | grep -c processor` + FOUND_CORES=yes + fi + + if test -x /usr/sbin/psrinfo; then + # Looks like a Solaris system + NUM_CORES=`LC_MESSAGES=C /usr/sbin/psrinfo -v | grep -c on-line` + FOUND_CORES=yes + fi + + if test -x /usr/sbin/system_profiler; then + # Looks like a MacOSX system + NUM_CORES=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Cores' | awk '{print [$]5}'` + FOUND_CORES=yes + fi + + if test "x$build_os" = xwindows; then + NUM_CORES=4 + fi + + # For c/c++ code we run twice as many concurrent build + # jobs than we have cores, otherwise we will stall on io. + CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` + + if test "x$FOUND_CORES" = xyes; then + AC_MSG_RESULT([$NUM_CORES]) + else + AC_MSG_RESULT([could not detect number of cores, defaulting to 1!]) + fi + +]) + +AC_DEFUN([BPERF_CHECK_MEMORY_SIZE], +[ + AC_MSG_CHECKING([for memory size]) + # Default to 1024MB + MEMORY_SIZE=1024 + FOUND_MEM=no + + if test -f /proc/cpuinfo; then + # Looks like a Linux system + MEMORY_SIZE=`cat /proc/meminfo | grep MemTotal | awk '{print [$]2}'` + MEMORY_SIZE=`expr $MEMORY_SIZE / 1024` + FOUND_MEM=yes + fi + + if test -x /usr/sbin/prtconf; then + # Looks like a Solaris system + MEMORY_SIZE=`/usr/sbin/prtconf | grep "Memory size" | awk '{ print [$]3 }'` + FOUND_MEM=yes + fi + + if test -x /usr/sbin/system_profiler; then + # Looks like a MacOSX system + MEMORY_SIZE=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Memory' | awk '{print [$]2}'` + MEMORY_SIZE=`expr $MEMORY_SIZE \* 1024` + FOUND_MEM=yes + fi + + if test "x$build_os" = xwindows; then + MEMORY_SIZE=`systeminfo | grep 'Total Physical Memory:' | awk '{ print [$]4 }' | sed 's/,//'` + FOUND_MEM=yes + fi + + if test "x$FOUND_MEM" = xyes; then + AC_MSG_RESULT([$MEMORY_SIZE MB]) + else + AC_MSG_RESULT([could not detect memory size defaulting to 1024MB!]) + fi +]) + +AC_DEFUN_ONCE([BPERF_SETUP_BUILD_CORES], +[ +# How many cores do we have on this build system? +AC_ARG_WITH(num-cores, [AS_HELP_STRING([--with-num-cores], + [number of cores in the build system, e.g. --with-num-cores=8 @<:@probed@:>@])]) +if test "x$with_num_cores" = x; then + # The number of cores were not specified, try to probe them. + BPERF_CHECK_CORES +else + NUM_CORES=$with_num_cores + CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` +fi +AC_SUBST(NUM_CORES) +AC_SUBST(CONCURRENT_BUILD_JOBS) +]) + +AC_DEFUN_ONCE([BPERF_SETUP_BUILD_MEMORY], +[ +# How much memory do we have on this build system? +AC_ARG_WITH(memory-size, [AS_HELP_STRING([--with-memory-size], + [memory (in MB) available in the build system, e.g. --with-memory-size=1024 @<:@probed@:>@])]) +if test "x$with_memory_size" = x; then + # The memory size was not specified, try to probe it. + BPERF_CHECK_MEMORY_SIZE +else + MEMORY_SIZE=$with_memory_size +fi +AC_SUBST(MEMORY_SIZE) +]) + +AC_DEFUN([BPERF_SETUP_CCACHE], +[ + AC_ARG_ENABLE([ccache], + [AS_HELP_STRING([--disable-ccache], + [use ccache to speed up recompilations @<:@enabled@:>@])], + [ENABLE_CCACHE=${enable_ccache}], [ENABLE_CCACHE=yes]) + if test "x$ENABLE_CCACHE" = xyes; then + AC_PATH_PROG(CCACHE, ccache) + else + AC_MSG_CHECKING([for ccache]) + AC_MSG_RESULT([explicitly disabled]) + CCACHE= + fi + AC_SUBST(CCACHE) + + AC_ARG_WITH([ccache-dir], + [AS_HELP_STRING([--with-ccache-dir], + [where to store ccache files @<:@~/.ccache@:>@])]) + + if test "x$with_ccache_dir" != x; then + # When using a non home ccache directory, assume the use is to share ccache files + # with other users. Thus change the umask. + SET_CCACHE_DIR="CCACHE_DIR=$with_ccache_dir CCACHE_UMASK=002" + fi + CCACHE_FOUND="" + if test "x$CCACHE" != x; then + BPERF_SETUP_CCACHE_USAGE + fi +]) + +AC_DEFUN([BPERF_SETUP_CCACHE_USAGE], +[ + if test "x$CCACHE" != x; then + CCACHE_FOUND="true" + # Only use ccache if it is 3.1.4 or later, which supports + # precompiled headers. + AC_MSG_CHECKING([if ccache supports precompiled headers]) + HAS_GOOD_CCACHE=`($CCACHE --version | head -n 1 | grep -E 3.1.@<:@456789@:>@) 2> /dev/null` + if test "x$HAS_GOOD_CCACHE" = x; then + AC_MSG_RESULT([no, disabling ccache]) + CCACHE= + else + AC_MSG_RESULT([yes]) + AC_MSG_CHECKING([if C-compiler supports ccache precompiled headers]) + PUSHED_FLAGS="$CXXFLAGS" + CXXFLAGS="-fpch-preprocess $CXXFLAGS" + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [CC_KNOWS_CCACHE_TRICK=yes], [CC_KNOWS_CCACHE_TRICK=no]) + CXXFLAGS="$PUSHED_FLAGS" + if test "x$CC_KNOWS_CCACHE_TRICK" = xyes; then + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no, disabling ccaching of precompiled headers]) + CCACHE= + fi + fi + fi + + if test "x$CCACHE" != x; then + CCACHE_SLOPPINESS=time_macros + CCACHE="CCACHE_COMPRESS=1 $SET_CCACHE_DIR CCACHE_SLOPPINESS=$CCACHE_SLOPPINESS $CCACHE" + CCACHE_FLAGS=-fpch-preprocess + + if test "x$SET_CCACHE_DIR" != x; then + mkdir -p $CCACHE_DIR > /dev/null 2>&1 + chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1 + fi + fi +]) + +AC_DEFUN_ONCE([BPERF_SETUP_PRECOMPILED_HEADERS], +[ + +############################################################################### +# +# Can the C/C++ compiler use precompiled headers? +# +AC_ARG_ENABLE([precompiled-headers], [AS_HELP_STRING([--disable-precompiled-headers], + [use precompiled headers when compiling C++ @<:@enabled@:>@])], + [ENABLE_PRECOMPH=${enable_precompiled-headers}], [ENABLE_PRECOMPH=yes]) + +USE_PRECOMPILED_HEADER=1 +if test "x$ENABLE_PRECOMPH" = xno; then + USE_PRECOMPILED_HEADER=0 +fi + +if test "x$ENABLE_PRECOMPH" = xyes; then + # Check that the compiler actually supports precomp headers. + if test "x$GCC" = xyes; then + AC_MSG_CHECKING([that precompiled headers work]) + echo "int alfa();" > conftest.h + $CXX -x c++-header conftest.h -o conftest.hpp.gch + if test ! -f conftest.hpp.gch; then + echo Precompiled header is not working! + USE_PRECOMPILED_HEADER=0 + AC_MSG_RESULT([no]) + else + AC_MSG_RESULT([yes]) + fi + rm -f conftest.h + fi +fi + +AC_SUBST(USE_PRECOMPILED_HEADER) +]) + + +AC_DEFUN_ONCE([BPERF_SETUP_SMART_JAVAC], +[ +AC_ARG_WITH(server-java, [AS_HELP_STRING([--with-server-java], + [use this java binary for running the javac background server and other long running java tasks in the build process, + e.g. ---with-server-java="/opt/jrockit/bin/java -server"])]) + +if test "x$with_server_java" != x; then + SERVER_JAVA="$with_server_java" + FOUND_VERSION=`$SERVER_JAVA -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" = x; then + AC_MSG_ERROR([Could not execute server java: $SERVER_JAVA]) + fi +else + SERVER_JAVA="" + # Hotspot specific options. + ADD_JVM_ARG_IF_OK([-XX:+UseParallelOldGC],SERVER_JAVA,[$JAVA]) + ADD_JVM_ARG_IF_OK([-verbosegc],SERVER_JAVA,[$JAVA]) + # JRockit specific options. + ADD_JVM_ARG_IF_OK([-Xverbose:gc],SERVER_JAVA,[$JAVA]) + SERVER_JAVA="$JAVA $SERVER_JAVA" +fi +AC_SUBST(SERVER_JAVA) + +AC_MSG_CHECKING([whether to use shared server for javac]) +AC_ARG_ENABLE([javac-server], [AS_HELP_STRING([--enable-javac-server], + [enable the shared javac server during the build process @<:@disabled@:>@])], + [ENABLE_JAVAC_SERVER="${enableval}"], [ENABLE_JAVAC_SERVER='no']) +AC_MSG_RESULT([$ENABLE_JAVAC_SERVER]) +if test "x$ENABLE_JAVAC_SERVER" = xyes; then + JAVAC_USE_REMOTE=true + JAVAC_SERVERS="$OUTPUT_ROOT/javacservers" +else + JAVAC_USE_REMOTE=false + JAVAC_SERVERS= +fi +AC_SUBST(JAVAC_USE_REMOTE) +AC_SUBST(JAVAC_SERVERS) + +AC_ARG_WITH(javac-server-cores, [AS_HELP_STRING([--with-javac-server-cores], + [use at most this number of concurrent threads on the javac server @<:@probed@:>@])]) +if test "x$with_javac_server_cores" != x; then + JAVAC_SERVER_CORES="$with_javac_server_cores" +else + if test "$NUM_CORES" -gt 16; then + # We set this arbitrary limit because we want to limit the heap + # size of the javac server. + # In the future we will make the javac compilers in the server + # share more and more state, thus enabling us to use more and + # more concurrent threads in the server. + JAVAC_SERVER_CORES="16" + else + JAVAC_SERVER_CORES="$NUM_CORES" + fi + + if test "$MEMORY_SIZE" -gt "17000"; then + MAX_HEAP_MEM=10000 + ADD_JVM_ARG_IF_OK([-d64],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xms10G -Xmx10G],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xmn2G],SERVER_JAVA,[$SERVER_JAVA]) + elif test "$MEMORY_SIZE" -gt "10000"; then + MAX_HEAP_MEM=6000 + ADD_JVM_ARG_IF_OK([-d64],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xms6G -Xmx6G],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xmn1G],SERVER_JAVA,[$SERVER_JAVA]) + elif test "$MEMORY_SIZE" -gt "5000"; then + MAX_HEAP_MEM=3000 + ADD_JVM_ARG_IF_OK([-d64],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xms1G -Xmx3G],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xmn256M],SERVER_JAVA,[$SERVER_JAVA]) + elif test "$MEMORY_SIZE" -gt "3800"; then + MAX_HEAP_MEM=2500 + ADD_JVM_ARG_IF_OK([-Xms1G -Xmx2500M],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xmn256M],SERVER_JAVA,[$SERVER_JAVA]) + elif test "$MEMORY_SIZE" -gt "1900"; then + MAX_HEAP_MEM=1200 + ADD_JVM_ARG_IF_OK([-Xms700M -Xmx1200M],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xmn256M],SERVER_JAVA,[$SERVER_JAVA]) + elif test "$MEMORY_SIZE" -gt "1000"; then + MAX_HEAP_MEM=900 + ADD_JVM_ARG_IF_OK([-Xms400M -Xmx900M],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xmn128M],SERVER_JAVA,[$SERVER_JAVA]) + else + MAX_HEAP_MEM=512 + ADD_JVM_ARG_IF_OK([-Xms256M -Xmx512M],SERVER_JAVA,[$SERVER_JAVA]) + ADD_JVM_ARG_IF_OK([-Xmn128M],SERVER_JAVA,[$SERVER_JAVA]) + fi + + MAX_COMPILERS_IN_HEAP=`expr $MAX_HEAP_MEM / 501` + if test "$JAVAC_SERVER_CORES" -gt "$MAX_COMPILERS_IN_HEAP"; then + AC_MSG_CHECKING([if number of server cores must be reduced]) + JAVAC_SERVER_CORES="$MAX_COMPILERS_IN_HEAP" + AC_MSG_RESULT([yes, to $JAVAC_SERVER_CORES with max heap size $MAX_HEAP_MEM MB]) + fi +fi +AC_SUBST(JAVAC_SERVER_CORES) + +AC_MSG_CHECKING([whether to track dependencies between Java packages]) +AC_ARG_ENABLE([javac-deps], [AS_HELP_STRING([--enable-javac-deps], + [enable the dependency tracking between Java packages @<:@disabled@:>@])], + [ENABLE_JAVAC_DEPS="${enableval}"], [ENABLE_JAVAC_DEPS='no']) +AC_MSG_RESULT([$ENABLE_JAVAC_DEPS]) +if test "x$ENABLE_JAVAC_DEPS" = xyes; then + JAVAC_USE_DEPS=true +else + JAVAC_USE_DEPS=false +fi +AC_SUBST(JAVAC_USE_DEPS) + +AC_MSG_CHECKING([whether to use multiple cores for javac compilation]) +AC_ARG_ENABLE([javac-multi-core], [AS_HELP_STRING([--enable-javac-multi-core], + [compile Java packages concurrently @<:@disabled@:>@])], + [ENABLE_JAVAC_MULTICORE="${enableval}"], [ENABLE_JAVAC_MULTICORE='no']) +AC_MSG_RESULT([$ENABLE_JAVAC_MULTICORE]) +if test "x$ENABLE_JAVAC_MULTICORE" = xyes; then + JAVAC_USE_MODE=MULTI_CORE_CONCURRENT +else + JAVAC_USE_MODE=SINGLE_THREADED_BATCH + if test "x$ENABLE_JAVAC_DEPS" = xyes; then + AC_MSG_WARN([Dependency tracking is not supported with single threaded batch compiles of Java source roots. Please add --disable-javac-deps to your configure options.]) + AC_MSG_WARN([Disabling dependency tracking for you now.]) + JAVAC_USE_DEPS=false + fi + if test "x$ENABLE_JAVAC_SERVER" = xyes; then + AC_MSG_WARN([The javac server will not be used since single threaded batch compiles are run within their own JVM. Please add --disable-javac-server to your configure options.]) + AC_MSG_WARN([Disabling javac server for you now.]) + JAVAC_USE_REMOTE=false + fi +fi +AC_SUBST(JAVAC_USE_MODE) + +AC_MSG_CHECKING([whether to use sjavac]) +AC_ARG_ENABLE([sjavac], [AS_HELP_STRING([--enable-sjavac], + [use sjavac to do fast incremental compiles @<:@disabled@:>@])], + [ENABLE_SJAVAC="${enableval}"], [ENABLE_SJAVAC='no']) +AC_MSG_RESULT([$ENABLE_SJAVAC]) +AC_SUBST(ENABLE_SJAVAC) + +]) diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh new file mode 100644 index 00000000000..5f7058f9300 --- /dev/null +++ b/common/autoconf/generated-configure.sh @@ -0,0 +1,18054 @@ +#! /bin/sh +# Guess values for system-dependent variables and create Makefiles. +# Generated by GNU Autoconf 2.67 for openjdk jdk8. +# +# Report bugs to . +# +# +# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, +# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software +# Foundation, Inc. +# +# +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +if test "x$CONFIG_SHELL" = x; then + as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi +" + as_required="as_fn_return () { (exit \$1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } + +exitcode=0 +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : + +else + exitcode=1; echo positional parameters were not saved. +fi +test x\$exitcode = x0 || exit 1" + as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO + as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO + eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && + test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 +test \$(( 1 + 1 )) = 2 || exit 1" + if (eval "$as_required") 2>/dev/null; then : + as_have_required=yes +else + as_have_required=no +fi + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + as_found=: + case $as_dir in #( + /*) + for as_base in sh bash ksh sh5; do + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + if { test -f "$as_shell" || test -f "$as_shell.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + CONFIG_SHELL=$as_shell as_have_required=yes + if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + break 2 +fi +fi + done;; + esac + as_found=false +done +$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi; } +IFS=$as_save_IFS + + + if test "x$CONFIG_SHELL" != x; then : + # We cannot yet assume a decent shell, so we have to provide a + # neutralization value for shells without unset; and this also + # works around shells that cannot unset nonexistent variables. + BASH_ENV=/dev/null + ENV=/dev/null + (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV + export CONFIG_SHELL + exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} +fi + + if test x$as_have_required = xno; then : + $as_echo "$0: This script requires a shell more modern than all" + $as_echo "$0: the shells that I found on your system." + if test x${ZSH_VERSION+set} = xset ; then + $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" + $as_echo "$0: be upgraded to zsh 4.3.4 or later." + else + $as_echo "$0: Please tell bug-autoconf@gnu.org and +$0: build-dev@openjdk.java.net about your system, including +$0: any error possibly output before this message. Then +$0: install a modern shell, or manually run the script +$0: under such a shell if you do have one." + fi + exit 1 +fi +fi +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS + +## --------------------- ## +## M4sh Shell Functions. ## +## --------------------- ## +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + + + as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { + # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) + sed -n ' + p + /[$]LINENO/= + ' <$as_myself | + sed ' + s/[$]LINENO.*/&-/ + t lineno + b + :lineno + N + :loop + s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ + t loop + s/-\n.*// + ' >$as_me.lineno && + chmod +x "$as_me.lineno" || + { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensitive to this). + . "./$as_me.lineno" + # Exit status is that of the last command. + exit +} + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -p'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -p' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -p' + fi +else + as_ln_s='cp -p' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +if test -x / >/dev/null 2>&1; then + as_test_x='test -x' +else + if ls -dL / >/dev/null 2>&1; then + as_ls_L_option=L + else + as_ls_L_option= + fi + as_test_x=' + eval sh -c '\'' + if test -d "$1"; then + test -d "$1/."; + else + case $1 in #( + -*)set "./$1";; + esac; + case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( + ???[sx]*):;;*)false;;esac;fi + '\'' sh + ' +fi +as_executable_p=$as_test_x + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +test -n "$DJDIR" || exec 7<&0 &1 + +# Name of the host. +# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_clean_files= +ac_config_libobj_dir=. +LIBOBJS= +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= + +# Identity of this package. +PACKAGE_NAME='openjdk' +PACKAGE_TARNAME='openjdk' +PACKAGE_VERSION='jdk8' +PACKAGE_STRING='openjdk jdk8' +PACKAGE_BUGREPORT='build-dev@openjdk.java.net' +PACKAGE_URL='' + +# Factoring default headers for most tests. +ac_includes_default="\ +#include +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef STDC_HEADERS +# include +# include +#else +# ifdef HAVE_STDLIB_H +# include +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include +# endif +# include +#endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_INTTYPES_H +# include +#endif +#ifdef HAVE_STDINT_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include +#endif" + +ac_subst_vars='LTLIBOBJS +LIBOBJS +CCACHE +USE_PRECOMPILED_HEADER +ENABLE_SJAVAC +JAVAC_USE_MODE +JAVAC_USE_DEPS +JAVAC_SERVER_CORES +JAVAC_SERVERS +JAVAC_USE_REMOTE +SERVER_JAVA +MEMORY_SIZE +CONCURRENT_BUILD_JOBS +NUM_CORES +SALIB_NAME +HOTSPOT_MAKE_ARGS +LIBCXX +LIBDL +LIBM +LIBZIP_CAN_USE_MMAP +USE_EXTERNAL_LIBZ +USE_EXTERNAL_LIBGIF +USE_EXTERNAL_LIBJPEG +ALSA_LIBS +ALSA_CFLAGS +FREETYPE2_LIB_PATH +USING_SYSTEM_FT_LIB +FREETYPE2_LIBS +FREETYPE2_CFLAGS +CUPS_LIBS +CUPS_CFLAGS +OPENWIN_HOME +X_EXTRA_LIBS +X_LIBS +X_PRE_LIBS +X_CFLAGS +XMKMF +CXXFLAGS_DEBUG_SYMBOLS +CFLAGS_DEBUG_SYMBOLS +ZIP_DEBUGINFO_FILES +ENABLE_DEBUG_SYMBOLS +UNCYGDRIVE +LDFLAGS_JDKEXE_SUFFIX +LDFLAGS_JDKLIB_SUFFIX +LDFLAGS_JDKEXE +LDFLAGS_JDKLIB +CXXFLAGS_JDKEXE +CXXFLAGS_JDKLIB +CFLAGS_JDKEXE +CFLAGS_JDKLIB +PACKAGE_PATH +CXX_FLAG_DEPS +C_FLAG_DEPS +CXX_O_FLAG_NONE +CXX_O_FLAG_NORM +CXX_O_FLAG_HI +CXX_O_FLAG_HIGHEST +C_O_FLAG_NONE +C_O_FLAG_NORM +C_O_FLAG_HI +C_O_FLAG_HIGHEST +POST_MCS_CMD +POST_STRIP_CMD +SET_SHARED_LIBRARY_ORIGIN +CXX_FLAG_REORDER +C_FLAG_REORDER +SET_SHARED_LIBRARY_MAPFILE +SET_SHARED_LIBRARY_NAME +SHARED_LIBRARY_FLAGS +EXE_SUFFIX +STATIC_LIBRARY_SUFFIX +SHARED_LIBRARY_SUFFIX +LIBRARY_PREFIX +STATIC_LIBRARY +SHARED_LIBRARY +OBJ_SUFFIX +ENDIAN +ARCH_DATA_MODEL +LP64 +OBJCOPY +MCS +STRIP +NM +ASFLAGS +AS +CXXCPP +CPP +COMPILER_TYPE +RC_FLAGS +DUMPBIN +WINAR +RC +MT +WINLD +ARFLAGS +AR +LDEXECXX +LDCXX +LDEXE +LD +ac_ct_OBJC +OBJCFLAGS +OBJC +ac_ct_CXX +CXXFLAGS +CXX +OBJEXT +EXEEXT +ac_ct_CC +CPPFLAGS +LDFLAGS +CFLAGS +CC +HOSTLD +HOSTCXX +HOSTCC +DEFINE_CROSS_COMPILE_ARCH +MSVCR100DLL +CHECK_FOR_VCINSTALLDIR +SETUPDEVENV +AR_OUT_OPTION +LD_OUT_OPTION +EXE_OUT_OPTION +CC_OUT_OPTION +SYS_ROOT +HOTSPOT_DIST +JAXWS_DIST +JAXP_DIST +CORBA_DIST +LANGTOOLS_DIST +IMAGES_OUTPUTDIR +JDK_OUTPUTDIR +HOTSPOT_OUTPUTDIR +JAXWS_OUTPUTDIR +JAXP_OUTPUTDIR +CORBA_OUTPUTDIR +LANGTOOLS_OUTPUTDIR +OVERRIDE_SRC_ROOT +ADD_SRC_ROOT +JDK_TOPDIR +HOTSPOT_TOPDIR +JAXWS_TOPDIR +JAXP_TOPDIR +CORBA_TOPDIR +LANGTOOLS_TOPDIR +BOOT_JDK_JVMARGS +NATIVE2ASCII +RMIC +JAR +JAVAH +JAVAC_FLAGS +JAVAC +BOOT_JDK_SOURCETARGET +JAVA +BOOT_TOOLSJAR +BOOT_RTJAR +BOOT_JDK +JAVA_CHECK +JAVAC_CHECK +OUTPUT_ROOT +CONF_NAME +SPEC +COOKED_BUILD_NUMBER +FULL_VERSION +RELEASE +JDK_VERSION +RUNTIME_NAME +COPYRIGHT_YEAR +COMPANY_NAME +JDK_RC_PLATFORM_NAME +PRODUCT_SUFFIX +PRODUCT_NAME +LAUNCHER_NAME +MILESTONE +JDK_BUILD_NUMBER +JDK_UPDATE_VERSION +JDK_MICRO_VERSION +JDK_MINOR_VERSION +JDK_MAJOR_VERSION +ENABLE_JFR +COMPRESS_JARS +CACERTS_FILE +TEST_IN_BUILD +DISABLE_NIMBUS +GENERATE_DOCS +ENABLE_DOCS +BUILD_HEADLESS_ONLY +BUILD_HEADLESS +SUPPORT_HEADFUL +SUPPORT_HEADLESS +JIGSAW +SET_OPENJDK +BUILD_VARIANT_RELEASE +DEBUG_CLASSFILES +FASTDEBUG +VARIANT +DEBUG_LEVEL +JVM_VARIANT_ZEROSHARK +JVM_VARIANT_ZERO +JVM_VARIANT_KERNEL +JVM_VARIANT_CLIENT +JVM_VARIANT_SERVER +JVM_VARIANTS +JDK_VARIANT +MINIMIZE_RAM_USAGE +JAVASE_EMBEDDED +PATH_SEP +CYGPATH +OS_VERSION_MICRO +OS_VERSION_MINOR +OS_VERSION_MAJOR +REQUIRED_OS_VERSION +REQUIRED_OS_NAME +LEGACY_OPENJDK_BUILD_CPU3 +LEGACY_OPENJDK_BUILD_CPU2 +LEGACY_OPENJDK_BUILD_CPU1 +OPENJDK_BUILD_CPU_ENDIAN +OPENJDK_BUILD_CPU_BITS +OPENJDK_BUILD_CPU_ARCH +OPENJDK_BUILD_CPU +LEGACY_OPENJDK_BUILD_OS_API +OPENJDK_BUILD_OS_API +OPENJDK_BUILD_OS_FAMILY +OPENJDK_BUILD_OS +LEGACY_OPENJDK_TARGET_CPU3 +LEGACY_OPENJDK_TARGET_CPU2 +LEGACY_OPENJDK_TARGET_CPU1 +OPENJDK_TARGET_CPU_ENDIAN +OPENJDK_TARGET_CPU_BITS +OPENJDK_TARGET_CPU_ARCH +OPENJDK_TARGET_CPU +LEGACY_OPENJDK_TARGET_OS_API +OPENJDK_TARGET_OS_API +OPENJDK_TARGET_OS_FAMILY +OPENJDK_TARGET_OS +OPENJDK_BUILD_SYSTEM +OPENJDK_TARGET_SYSTEM +target_os +target_vendor +target_cpu +target +host_os +host_vendor +host_cpu +host +build_os +build_vendor +build_cpu +build +PKG_CONFIG +BDEPS_FTP +BDEPS_UNZIP +HG +FILE +EXPR +READELF +OTOOL +LDD +UNZIP +ZIP +XARGS +WC +TOUCH +TR +TEE +TAIL +TAR +SORT +SH +SED +RM +THEPWDCMD +PRINTF +NAWK +MV +MKDIR +MAKE +LS +LN +HEAD +FIND_DELETE +FIND +FGREP +EGREP +GREP +ECHO +DIFF +DF +DATE +CUT +CPIO +CP +CHMOD +CAT +AWK +PKGHANDLER +BUILD_LOG_WRAPPER +BUILD_LOG_PREVIOUS +BUILD_LOG +SRC_ROOT +READLINK +DATE_WHEN_CONFIGURED +CONFIGURE_COMMAND_LINE +target_alias +host_alias +build_alias +LIBS +ECHO_T +ECHO_N +ECHO_C +DEFS +mandir +localedir +libdir +psdir +pdfdir +dvidir +htmldir +infodir +docdir +oldincludedir +includedir +localstatedir +sharedstatedir +sysconfdir +datadir +datarootdir +libexecdir +sbindir +bindir +program_transform_name +prefix +exec_prefix +PACKAGE_URL +PACKAGE_BUGREPORT +PACKAGE_STRING +PACKAGE_VERSION +PACKAGE_TARNAME +PACKAGE_NAME +PATH_SEPARATOR +SHELL' +ac_subst_files='' +ac_user_opts=' +enable_option_checking +with_builddeps_conf +with_builddeps_server +with_builddeps_dir +with_builddeps_group +enable_list_builddeps +with_target_bits +with_jdk_variant +with_jvm_variants +enable_debug +with_debug_level +enable_openjdk_only +enable_jigsaw +enable_headful +enable_docs +enable_nimbus +enable_hotspot_test_in_build +with_cacerts_file +enable_jfr +with_conf_name +with_boot_jdk +with_boot_jdk_jvmargs +with_add_source_root +with_override_source_root +with_adds_and_overrides +with_override_langtools +with_override_corba +with_override_jaxp +with_override_jaxws +with_override_hotspot +with_override_jdk +with_msvcr100dll +with_sys_root +with_tools_dir +with_devkit +with_extra_cflags +with_extra_cxxflags +with_extra_ldflags +enable_debug_symbols +enable_zip_debug_info +enable_macosx_runtime_support +with_x +with_cups +with_cups_include +with_cups_lib +with_freetype +with_alsa +with_alsa_include +with_alsa_lib +with_zlib +enable_static_link_stdc__ +with_num_cores +with_memory_size +with_server_java +enable_javac_server +with_javac_server_cores +enable_javac_deps +enable_javac_multi_core +enable_sjavac +enable_precompiled_headers +enable_ccache +with_ccache_dir +' + ac_precious_vars='build_alias +host_alias +target_alias +PKG_CONFIG +CC +CFLAGS +LDFLAGS +LIBS +CPPFLAGS +CXX +CXXFLAGS +CCC +OBJC +OBJCFLAGS +CPP +CXXCPP +XMKMF +FREETYPE2_CFLAGS +FREETYPE2_LIBS +ALSA_CFLAGS +ALSA_LIBS' + + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +# (The list follows the same order as the GNU Coding Standards.) +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datarootdir='${prefix}/share' +datadir='${datarootdir}' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +includedir='${prefix}/include' +oldincludedir='/usr/include' +docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' +infodir='${datarootdir}/info' +htmldir='${docdir}' +dvidir='${docdir}' +pdfdir='${docdir}' +psdir='${docdir}' +libdir='${exec_prefix}/lib' +localedir='${datarootdir}/locale' +mandir='${datarootdir}/man' + +ac_prev= +ac_dashdash= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval $ac_prev=\$ac_option + ac_prev= + continue + fi + + case $ac_option in + *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; + *=) ac_optarg= ;; + *) ac_optarg=yes ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_dashdash$ac_option in + --) + ac_dashdash=yes ;; + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=*) + datadir=$ac_optarg ;; + + -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ + | --dataroo | --dataro | --datar) + ac_prev=datarootdir ;; + -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ + | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) + datarootdir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=no ;; + + -docdir | --docdir | --docdi | --doc | --do) + ac_prev=docdir ;; + -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) + docdir=$ac_optarg ;; + + -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) + ac_prev=dvidir ;; + -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) + dvidir=$ac_optarg ;; + + -enable-* | --enable-*) + ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=\$ac_optarg ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) + ac_prev=htmldir ;; + -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ + | --ht=*) + htmldir=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localedir | --localedir | --localedi | --localed | --locale) + ac_prev=localedir ;; + -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) + localedir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst | --locals) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) + ac_prev=pdfdir ;; + -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) + pdfdir=$ac_optarg ;; + + -psdir | --psdir | --psdi | --psd | --ps) + ac_prev=psdir ;; + -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) + psdir=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=\$ac_optarg ;; + + -without-* | --without-*) + ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=no ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) as_fn_error $? "unrecognized option: \`$ac_option' +Try \`$0 --help' for more information" + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + case $ac_envvar in #( + '' | [0-9]* | *[!_$as_cr_alnum]* ) + as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; + esac + eval $ac_envvar=\$ac_optarg + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + as_fn_error $? "missing argument to $ac_option" +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; + *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + esac +fi + +# Check all directory arguments for consistency. +for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ + datadir sysconfdir sharedstatedir localstatedir includedir \ + oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ + libdir localedir mandir +do + eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. + case $ac_val in + [\\/$]* | ?:[\\/]* ) continue;; + NONE | '' ) case $ac_var in *prefix ) continue;; esac;; + esac + as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host. + If a cross compiler is detected then cross compile mode will be used" >&2 + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +ac_pwd=`pwd` && test -n "$ac_pwd" && +ac_ls_di=`ls -di .` && +ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || + as_fn_error $? "working directory cannot be determined" +test "X$ac_ls_di" = "X$ac_pwd_ls_di" || + as_fn_error $? "pwd does not report name of working directory" + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then the parent directory. + ac_confdir=`$as_dirname -- "$as_myself" || +$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_myself" : 'X\(//\)[^/]' \| \ + X"$as_myself" : 'X\(//\)$' \| \ + X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_myself" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r "$srcdir/$ac_unique_file"; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r "$srcdir/$ac_unique_file"; then + test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." + as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" +fi +ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_abs_confdir=`( + cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" + pwd)` +# When building in place, set srcdir=. +if test "$ac_abs_confdir" = "$ac_pwd"; then + srcdir=. +fi +# Remove unnecessary trailing slashes from srcdir. +# Double slashes in file names in object file debugging info +# mess up M-x gdb in Emacs. +case $srcdir in +*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; +esac +for ac_var in $ac_precious_vars; do + eval ac_env_${ac_var}_set=\${${ac_var}+set} + eval ac_env_${ac_var}_value=\$${ac_var} + eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} + eval ac_cv_env_${ac_var}_value=\$${ac_var} +done + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures openjdk jdk8 to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking ...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [PREFIX] + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] + --docdir=DIR documentation root [DATAROOTDIR/doc/openjdk] + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] +_ACEOF + + cat <<\_ACEOF + +X features: + --x-includes=DIR X include files are in DIR + --x-libraries=DIR X library files are in DIR + +System types: + --build=BUILD configure for building on BUILD [guessed] + --host=HOST cross-compile to build programs to run on HOST [BUILD] + --target=TARGET configure for building compilers for TARGET [HOST] +_ACEOF +fi + +if test -n "$ac_init_help"; then + case $ac_init_help in + short | recursive ) echo "Configuration of openjdk jdk8:";; + esac + cat <<\_ACEOF + +Optional Features: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --enable-list-builddeps list all build dependencies known to the configure + script + --enable-debug set the debug level to fastdebug (shorthand for + --with-debug-level=fastdebug) [disabled] + --enable-openjdk-only build OpenJDK regardless of the presence of closed + repositories [disabled] + --enable-jigsaw build Jigsaw images (not yet available) [disabled] + --disable-headful build headful support (graphical UI support) + [enabled] + --enable-docs enable generation of Javadoc documentation + [disabled] + --disable-nimbus disable Nimbus L&F [enabled] + --enable-hotspot-test-in-build + enable running of Queens test after Hotspot build + (not yet available) [disabled] + --enable-jfr enable jfr (default is no) + ENABLE_JFR="${enableval}" + --disable-debug-symbols disable generation of debug symbols ([enabled]) + --disable-zip-debug-info + don't zip debug-info files ([enabled@:@) + --disable-macosx-runtime-support + disable the use of MacOSX Java runtime support + framework [enabled] + --disable-static-link-stdc++ + disable static linking of the C++ runtime on Linux + [enabled] + --enable-javac-server enable the shared javac server during the build + process [disabled] + --enable-javac-deps enable the dependency tracking between Java packages + [disabled] + --enable-javac-multi-core + compile Java packages concurrently [disabled] + --enable-sjavac use sjavac to do fast incremental compiles + [disabled] + --disable-precompiled-headers + use precompiled headers when compiling C++ [enabled] + --disable-ccache use ccache to speed up recompilations [enabled] + +Optional Packages: + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --with-builddeps-conf use this configuration file for the builddeps + --with-builddeps-server download and use build dependencies from this server + url, e.g. + --with-builddeps-server=ftp://example.com/dir + --with-builddeps-dir store downloaded build dependencies here + [d/localhome/builddeps] + --with-builddeps-group chgrp the downloaded build dependencies to this + group + --with-target-bits build 32-bit or 64-bit binaries (for platforms that + support it), e.g. --with-target-bits=32 [guessed] + --with-jdk-variant JDK variant to build (normal, embedded) [normal] + --with-jvm-variants JVM variants (separated by commas) to build (server, + client, kernel, zero, zeroshark) [server] + --with-debug-level set the debug level (release, fastdebug, slowdebug) + [release] + --with-cacerts-file specify alternative cacerts file + --with-conf-name use this as the name of the configuration, + overriding the generated default + --with-boot-jdk path to Boot JDK (used to bootstrap build) [probed] + --with-boot-jdk-jvmargs specify JVM arguments to be passed to all + invocations of the Boot JDK, overriding the default + values, e.g --with-boot-jdk-jvmargs="-Xmx8G + -enableassertions" + --with-add-source-root for each and every source directory, look in this + additional source root for the same directory; if it + exists and have files in it, include it in the build + --with-override-source-root + for each and every source directory, look in this + override source root for the same directory; if it + exists, use that directory instead and ignore the + directory in the original source root + --with-adds-and-overrides + use the subdirs 'adds' and 'overrides' in the + specified directory as add-source-root and + override-source-root + --with-override-langtools + use this langtools dir for the build + --with-override-corba use this corba dir for the build + --with-override-jaxp use this jaxp dir for the build + --with-override-jaxws use this jaxws dir for the build + --with-override-hotspot use this hotspot dir for the build + --with-override-jdk use this jdk dir for the build + --with-msvcr100dll copy this msvcr100.dll into the built JDK + --with-sys-root pass this sys-root to the compilers and linker + (useful if the sys-root encoded in the cross + compiler tools is incorrect) + --with-tools-dir search this directory for compilers and tools + --with-devkit use this directory as base for tools-dir and + sys-root + --with-extra-cflags extra flags to be used when compiling jdk c-files + --with-extra-cxxflags extra flags to be used when compiling jdk c++-files + --with-extra-ldflags extra flags to be used when linking jdk + --with-x use the X Window System + --with-cups specify prefix directory for the cups package + (expecting the libraries under PATH/lib and the + headers under PATH/include) + --with-cups-include specify directory for the cups include files + --with-cups-lib specify directory for the cups library + --with-freetype specify prefix directory for the freetype2 package + (expecting the libraries under PATH/lib and the + headers under PATH/include) + --with-alsa specify prefix directory for the alsa package + (expecting the libraries under PATH/lib and the + headers under PATH/include) + --with-alsa-include specify directory for the alsa include files + --with-alsa-lib specify directory for the alsa library + --with-zlib use zlib from build system or OpenJDK source + (system, bundled) [bundled] + --with-num-cores number of cores in the build system, e.g. + --with-num-cores=8 [probed] + --with-memory-size memory (in MB) available in the build system, e.g. + --with-memory-size=1024 [probed] + --with-server-java use this java binary for running the javac + background server and other long running java tasks + in the build process, e.g. + ---with-server-java="/opt/jrockit/bin/java -server" + --with-javac-server-cores + use at most this number of concurrent threads on the + javac server [probed] + --with-ccache-dir where to store ccache files [~/.ccache] + +Some influential environment variables: + PKG_CONFIG path to pkg-config utility + CC C compiler command + CFLAGS C compiler flags + LDFLAGS linker flags, e.g. -L if you have libraries in a + nonstandard directory + LIBS libraries to pass to the linker, e.g. -l + CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if + you have headers in a nonstandard directory + CXX C++ compiler command + CXXFLAGS C++ compiler flags + OBJC Objective C compiler command + OBJCFLAGS Objective C compiler flags + CPP C preprocessor + CXXCPP C++ preprocessor + XMKMF Path to xmkmf, Makefile generator for X Window System + FREETYPE2_CFLAGS + C compiler flags for FREETYPE2, overriding pkg-config + FREETYPE2_LIBS + linker flags for FREETYPE2, overriding pkg-config + ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config + ALSA_LIBS linker flags for ALSA, overriding pkg-config + +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations. + +Report bugs to . +_ACEOF +ac_status=$? +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + cd "$ac_dir" || { ac_status=$?; continue; } + # Check for guested configure. + if test -f "$ac_srcdir/configure.gnu"; then + echo && + $SHELL "$ac_srcdir/configure.gnu" --help=recursive + elif test -f "$ac_srcdir/configure"; then + echo && + $SHELL "$ac_srcdir/configure" --help=recursive + else + $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi || ac_status=$? + cd "$ac_pwd" || { ac_status=$?; break; } + done +fi + +test -n "$ac_init_help" && exit $ac_status +if $ac_init_version; then + cat <<\_ACEOF +openjdk configure jdk8 +generated by GNU Autoconf 2.67 + +Copyright (C) 2010 Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit +fi + +## ------------------------ ## +## Autoconf initialization. ## +## ------------------------ ## + +# ac_fn_c_try_compile LINENO +# -------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + as_fn_set_status $ac_retval + +} # ac_fn_c_try_compile + +# ac_fn_cxx_try_compile LINENO +# ---------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_compile + +# ac_fn_objc_try_compile LINENO +# ----------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_objc_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_objc_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + as_fn_set_status $ac_retval + +} # ac_fn_objc_try_compile + +# ac_fn_c_try_cpp LINENO +# ---------------------- +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + as_fn_set_status $ac_retval + +} # ac_fn_c_try_cpp + +# ac_fn_cxx_try_cpp LINENO +# ------------------------ +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_cpp + +# ac_fn_cxx_try_run LINENO +# ------------------------ +# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes +# that executables *can* be run. +ac_fn_cxx_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then : + ac_retval=0 +else + $as_echo "$as_me: program exited with status $ac_status" >&5 + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=$ac_status +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_run + +# ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES +# ---------------------------------------------- +# Tries to find the compile-time value of EXPR in a program that includes +# INCLUDES, setting VAR accordingly. Returns whether the value could be +# computed +ac_fn_cxx_compute_int () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +int +main () +{ +static int test_array [1 - 2 * !(($2) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_lo=0 ac_mid=0 + while :; do + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +int +main () +{ +static int test_array [1 - 2 * !(($2) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_hi=$ac_mid; break +else + as_fn_arith $ac_mid + 1 && ac_lo=$as_val + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +int +main () +{ +static int test_array [1 - 2 * !(($2) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_hi=-1 ac_mid=-1 + while :; do + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +int +main () +{ +static int test_array [1 - 2 * !(($2) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_lo=$ac_mid; break +else + as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + ac_lo= ac_hi= +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +int +main () +{ +static int test_array [1 - 2 * !(($2) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_hi=$ac_mid +else + as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in #(( +?*) eval "$3=\$ac_lo"; ac_retval=0 ;; +'') ac_retval=1 ;; +esac + else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +static long int longval () { return $2; } +static unsigned long int ulongval () { return $2; } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + return 1; + if (($2) < 0) + { + long int i = longval (); + if (i != ($2)) + return 1; + fprintf (f, "%ld", i); + } + else + { + unsigned long int i = ulongval (); + if (i != ($2)) + return 1; + fprintf (f, "%lu", i); + } + /* Do not output a trailing newline, as this causes \r\n confusion + on some platforms. */ + return ferror (f) || fclose (f) != 0; + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_run "$LINENO"; then : + echo >>conftest.val; read $3 &5 +$as_echo_n "checking for $2... " >&6; } +if eval "test \"\${$3+set}\"" = set; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + +} # ac_fn_cxx_check_header_compile + +# ac_fn_cxx_try_link LINENO +# ------------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + $as_test_x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_link + +# ac_fn_cxx_check_func LINENO FUNC VAR +# ------------------------------------ +# Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_cxx_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval "test \"\${$3+set}\"" = set; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main () +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + +} # ac_fn_cxx_check_func + +# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES +# ------------------------------------------------------- +# Tests whether HEADER exists, giving a warning if it cannot be compiled using +# the include files in INCLUDES and setting the cache variable VAR +# accordingly. +ac_fn_c_check_header_mongrel () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if eval "test \"\${$3+set}\"" = set; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval "test \"\${$3+set}\"" = set; then : + $as_echo_n "(cached) " >&6 +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +else + # Is the header compilable? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 +$as_echo_n "checking $2 usability... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_header_compiler=yes +else + ac_header_compiler=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 +$as_echo "$ac_header_compiler" >&6; } + +# Is the header present? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 +$as_echo_n "checking $2 presence... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include <$2> +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + ac_header_preproc=yes +else + ac_header_preproc=no +fi +rm -f conftest.err conftest.i conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 +$as_echo "$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( + yes:no: ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 +$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} + ;; + no:yes:* ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 +$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 +$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 +$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 +$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} +( $as_echo "## ----------------------------------------- ## +## Report this to build-dev@openjdk.java.net ## +## ----------------------------------------- ##" + ) | sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval "test \"\${$3+set}\"" = set; then : + $as_echo_n "(cached) " >&6 +else + eval "$3=\$ac_header_compiler" +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +fi + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + +} # ac_fn_c_check_header_mongrel + +# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES +# --------------------------------------------------------- +# Tests whether HEADER exists, giving a warning if it cannot be compiled using +# the include files in INCLUDES and setting the cache variable VAR +# accordingly. +ac_fn_cxx_check_header_mongrel () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if eval "test \"\${$3+set}\"" = set; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval "test \"\${$3+set}\"" = set; then : + $as_echo_n "(cached) " >&6 +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +else + # Is the header compilable? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 +$as_echo_n "checking $2 usability... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_header_compiler=yes +else + ac_header_compiler=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 +$as_echo "$ac_header_compiler" >&6; } + +# Is the header present? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 +$as_echo_n "checking $2 presence... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include <$2> +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + ac_header_preproc=yes +else + ac_header_preproc=no +fi +rm -f conftest.err conftest.i conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 +$as_echo "$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #(( + yes:no: ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 +$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} + ;; + no:yes:* ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 +$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 +$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 +$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 +$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} +( $as_echo "## ----------------------------------------- ## +## Report this to build-dev@openjdk.java.net ## +## ----------------------------------------- ##" + ) | sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval "test \"\${$3+set}\"" = set; then : + $as_echo_n "(cached) " >&6 +else + eval "$3=\$ac_header_compiler" +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +fi + eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + +} # ac_fn_cxx_check_header_mongrel +cat >config.log <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by openjdk $as_me jdk8, which was +generated by GNU Autoconf 2.67. Invocation command line was + + $ $0 $@ + +_ACEOF +exec 5>>config.log +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + $as_echo "PATH: $as_dir" + done +IFS=$as_save_IFS + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *\'*) + ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; + 2) + as_fn_append ac_configure_args1 " '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + as_fn_append ac_configure_args " '$ac_arg'" + ;; + esac + done +done +{ ac_configure_args0=; unset ac_configure_args0;} +{ ac_configure_args1=; unset ac_configure_args1;} + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Use '\'' to represent an apostrophe within the trap. +# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + $as_echo "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + # The following way of writing the cache mishandles newlines in values, +( + for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + (set) 2>&1 | + case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + sed -n \ + "s/'\''/'\''\\\\'\'''\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + ;; #( + *) + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) + echo + + $as_echo "## ----------------- ## +## Output variables. ## +## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + + if test -n "$ac_subst_files"; then + $as_echo "## ------------------- ## +## File substitutions. ## +## ------------------- ##" + echo + for ac_var in $ac_subst_files + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + fi + + if test -s confdefs.h; then + $as_echo "## ----------- ## +## confdefs.h. ## +## ----------- ##" + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + $as_echo "$as_me: caught signal $ac_signal" + $as_echo "$as_me: exit $exit_status" + } >&5 + rm -f core *.core core.conftest.* && + rm -f -r conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status +' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -f -r conftest* confdefs.h + +$as_echo "/* confdefs.h */" > confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_URL "$PACKAGE_URL" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE +if test -n "$CONFIG_SITE"; then + # We do not want a PATH search for config.site. + case $CONFIG_SITE in #(( + -*) ac_site_file1=./$CONFIG_SITE;; + */*) ac_site_file1=$CONFIG_SITE;; + *) ac_site_file1=./$CONFIG_SITE;; + esac +elif test "x$prefix" != xNONE; then + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site +else + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site +fi +for ac_site_file in "$ac_site_file1" "$ac_site_file2" +do + test "x$ac_site_file" = xNONE && continue + if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +$as_echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" \ + || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "failed to load site script $ac_site_file +See \`config.log' for more details" "$LINENO" 5 ; } + fi +done + +if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special files + # actually), so we avoid doing that. DJGPP emulates it as a regular file. + if test /dev/null != "$cache_file" && test -f "$cache_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +$as_echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . "$cache_file";; + *) . "./$cache_file";; + esac + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +$as_echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + eval ac_new_val=\$ac_env_${ac_var}_value + case $ac_old_set,$ac_new_set in + set,) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + # differences in whitespace do not lead to failure. + ac_old_val_w=`echo x $ac_old_val` + ac_new_val_w=`echo x $ac_new_val` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 +$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + ac_cache_corrupted=: + else + { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 +$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + eval $ac_var=\$ac_old_val + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 +$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 +$as_echo "$as_me: current value: \`$ac_new_val'" >&2;} + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} + as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + + +# Do not change or remove the following line, it is needed for consistency checks: +# DATE_WHEN_GENERATED: 1341161875 + +ac_aux_dir= +for ac_dir in build-aux "$srcdir"/build-aux; do + if test -f "$ac_dir/install-sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f "$ac_dir/install.sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f "$ac_dir/shtool"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + as_fn_error $? "cannot find install-sh, install.sh, or shtool in build-aux \"$srcdir\"/build-aux" "$LINENO" 5 +fi + +# These three variables are undocumented and unsupported, +# and are intended to be withdrawn in a future Autoconf release. +# They can cause serious problems if a builder's source tree is in a directory +# whose full name contains unusual characters. +ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. +ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. +ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + + +# pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- +# +# Copyright © 2004 Scott James Remnant . +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program 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 for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# PKG_PROG_PKG_CONFIG([MIN-VERSION]) +# ---------------------------------- +# PKG_PROG_PKG_CONFIG + +# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# +# Check to see whether a particular set of modules exists. Similar +# to PKG_CHECK_MODULES(), but does not set variables or print errors. +# +# +# Similar to PKG_CHECK_MODULES, make sure that the first instance of +# this or PKG_CHECK_MODULES is called, or make sure to call +# PKG_CHECK_EXISTS manually +# -------------------------------------------------------------- + + + +# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES]) +# --------------------------------------------- +# _PKG_CONFIG + +# _PKG_SHORT_ERRORS_SUPPORTED +# ----------------------------- +# _PKG_SHORT_ERRORS_SUPPORTED + + +# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND], +# [ACTION-IF-NOT-FOUND]) +# +# +# Note that if there is a possibility the first call to +# PKG_CHECK_MODULES might not happen, you should be sure to include an +# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac +# +# +# -------------------------------------------------------------- +# PKG_CHECK_MODULES + + +# Include these first... +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + + + + + + + + + + + + + + + + + + + + + + + + +#%%% Simple tools %%% + + + + + + + + + + + + +# Check if build directory is on local disk. +# Argument 1: directory to test +# Argument 2: what to do if it is on local disk +# Argument 3: what to do otherwise (remote disk or failure) + + + + +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + + + + + + + + + + + +# ... then the rest +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +# Fixes paths on windows to be mixed mode short. + + + + +############################################################################### +# +# We need a Boot JDK to bootstrap the build. +# + + + + + +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + + + + + + + + + + + + + + + + + + +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + + + + + +apt_help() { + case $1 in + devkit) + PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;; + openjdk) + PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;; + alsa) + PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;; + cups) + PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;; + freetype2) + PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;; + pulse) + PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;; + x11) + PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev" ;; + ccache) + PKGHANDLER_COMMAND="sudo apt-get install ccache" ;; + * ) + break ;; + esac +} + +yum_help() { + case $1 in + devkit) + PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;; + openjdk) + PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;; + alsa) + PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;; + cups) + PKGHANDLER_COMMAND="sudo yum install cups-devel" ;; + freetype2) + PKGHANDLER_COMMAND="sudo yum install freetype2-devel" ;; + pulse) + PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;; + x11) + PKGHANDLER_COMMAND="sudo yum install libXtst-devel" ;; + ccache) + PKGHANDLER_COMMAND="sudo yum install ccache" ;; + * ) + break ;; + esac +} + +port_help() { + PKGHANDLER_COMMAND="" +} + +pkgutil_help() { + PKGHANDLER_COMMAND="" +} + +pkgadd_help() { + PKGHANDLER_COMMAND="" +} + + + +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + + + + + + + + + + + + + + + +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + + + + + + + + + + + + + + + +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + + + + + + + + + + + + + +#%%% Build and target systems %%% + + + + + + + + + + +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + + + + + + + + +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + + + + + + + + + + + + + + + +# This line needs to be here, verbatim, after all includes. +# It is replaced with closed functionality when building +# closed sources. + + +############################################################################### +# +# Initialization +# +############################################################################### + +# Basic initialization that must happen first of all + +# Save the original command line. This is passed to us by the wrapper configure script. + +DATE_WHEN_CONFIGURED=`LANG=C date` + + +# Locate the directory of this script. +SCRIPT="$0" + + if test "x$OPENJDK_BUILD_OS" != xwindows; then + # Follow a chain of symbolic links. Use readlink + # where it exists, else fall back to horribly + # complicated shell code. + # Extract the first word of "readlink", so it can be a program name with args. +set dummy readlink; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_READLINK+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $READLINK in + [\\/]* | ?:[\\/]*) + ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +READLINK=$ac_cv_path_READLINK +if test -n "$READLINK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5 +$as_echo "$READLINK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + if test "x$READLINK_TESTED" != yes; then + # On MacOSX there is a readlink tool with a different + # purpose than the GNU readlink tool. Check the found readlink. + ISGNU=`$READLINK --help 2>&1 | grep GNU` + if test "x$ISGNU" = x; then + # A readlink that we do not know how to use. + # Are there other non-GNU readlinks out there? + READLINK_TESTED=yes + READLINK= + fi + fi + + if test "x$READLINK" != x; then + SCRIPT=`$READLINK -f $SCRIPT` + else + STARTDIR=$PWD + COUNTER=0 + DIR=`dirname $SCRIPT` + FIL=`basename $SCRIPT` + while test $COUNTER -lt 20; do + ISLINK=`ls -l $DIR/$FIL | grep '\->' | sed -e 's/.*-> \(.*\)/\1/'` + if test "x$ISLINK" == x; then + # This is not a symbolic link! We are done! + break + fi + # The link might be relative! We have to use cd to travel safely. + cd $DIR + cd `dirname $ISLINK` + DIR=`pwd` + FIL=`basename $ISLINK` + let COUNTER=COUNTER+1 + done + cd $STARTDIR + SCRIPT=$DIR/$FIL + fi + fi + +AUTOCONF_DIR=`dirname $0` + + +# Where is the source? It is located two levels above the configure script. +CURDIR="$PWD" +cd "$AUTOCONF_DIR/../.." +SRC_ROOT="`pwd`" +if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + SRC_ROOT_LENGTH=`pwd|wc -m` + if test $SRC_ROOT_LENGTH -gt 100; then + as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5 + fi +fi + +cd "$CURDIR" + + + # Fail with message the path to the source root if var SRC_ROOT contains a path with no spaces in it. + # Unless on Windows, where we can rewrite the path. + HAS_SPACE=`echo "$SRC_ROOT" | grep " "` + if test "x$HAS_SPACE" != x; then + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + SRC_ROOT=`$CYGPATH -s -m -a "$SRC_ROOT"` + SRC_ROOT=`$CYGPATH -u "$SRC_ROOT"` + else + as_fn_error $? "You cannot have spaces in the path to the source root! \"$SRC_ROOT\"" "$LINENO" 5 + fi + fi + + + # Fail with message the path to the current directory if var CURDIR contains a path with no spaces in it. + # Unless on Windows, where we can rewrite the path. + HAS_SPACE=`echo "$CURDIR" | grep " "` + if test "x$HAS_SPACE" != x; then + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + CURDIR=`$CYGPATH -s -m -a "$CURDIR"` + CURDIR=`$CYGPATH -u "$CURDIR"` + else + as_fn_error $? "You cannot have spaces in the path to the current directory! \"$CURDIR\"" "$LINENO" 5 + fi + fi + + + +# Setup default logging of stdout and stderr to build.log in the output root. +BUILD_LOG='$(OUTPUT_ROOT)/build.log' +BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old' +BUILD_LOG_WRAPPER='$(SH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)' + + + + + +# Must be done before we can call HELP_MSG_MISSING_DEPENDENCY. + + for ac_prog in apt-get yum port pkgutil pkgadd +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_PKGHANDLER+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$PKGHANDLER"; then + ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_PKGHANDLER="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +PKGHANDLER=$ac_cv_prog_PKGHANDLER +if test -n "$PKGHANDLER"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5 +$as_echo "$PKGHANDLER" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$PKGHANDLER" && break +done + + + +# Setup simple tools, that do not need have cross compilation support. +# Without these, we can't properly run the rest of the configure script. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +$as_echo_n "checking for grep that handles long lines and -e... " >&6; } +if test "${ac_cv_path_GREP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in grep ggrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" + { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'GREP' >> "conftest.nl" + "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_GREP=$GREP +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +$as_echo "$ac_cv_path_GREP" >&6; } + GREP="$ac_cv_path_GREP" + + + +# Start with tools that do not need have cross compilation support +# and can be expected to be found in the default PATH. These tools are +# used by configure. Nor are these tools expected to be found in the +# devkit from the builddeps server either, since they are +# needed to download the devkit. +for ac_prog in gawk mawk nawk awk +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_AWK+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AWK"; then + ac_cv_prog_AWK="$AWK" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_AWK="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AWK=$ac_cv_prog_AWK +if test -n "$AWK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +$as_echo "$AWK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AWK" && break +done + + + # Test that variable AWK is not empty. + if test "" = "$AWK"; then as_fn_error $? "Could not find awk !" "$LINENO" 5 ; fi + +# Extract the first word of "cat", so it can be a program name with args. +set dummy cat; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_CAT+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $CAT in + [\\/]* | ?:[\\/]*) + ac_cv_path_CAT="$CAT" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CAT=$ac_cv_path_CAT +if test -n "$CAT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5 +$as_echo "$CAT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable CAT is not empty. + if test "" = "$CAT"; then as_fn_error $? "Could not find cat !" "$LINENO" 5 ; fi + +# Extract the first word of "chmod", so it can be a program name with args. +set dummy chmod; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_CHMOD+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $CHMOD in + [\\/]* | ?:[\\/]*) + ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CHMOD=$ac_cv_path_CHMOD +if test -n "$CHMOD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5 +$as_echo "$CHMOD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable CHMOD is not empty. + if test "" = "$CHMOD"; then as_fn_error $? "Could not find chmod !" "$LINENO" 5 ; fi + +# Extract the first word of "cp", so it can be a program name with args. +set dummy cp; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_CP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $CP in + [\\/]* | ?:[\\/]*) + ac_cv_path_CP="$CP" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CP=$ac_cv_path_CP +if test -n "$CP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5 +$as_echo "$CP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable CP is not empty. + if test "" = "$CP"; then as_fn_error $? "Could not find cp !" "$LINENO" 5 ; fi + +# Extract the first word of "cpio", so it can be a program name with args. +set dummy cpio; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_CPIO+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $CPIO in + [\\/]* | ?:[\\/]*) + ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CPIO=$ac_cv_path_CPIO +if test -n "$CPIO"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5 +$as_echo "$CPIO" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable CPIO is not empty. + if test "" = "$CPIO"; then as_fn_error $? "Could not find cpio !" "$LINENO" 5 ; fi + +# Extract the first word of "cut", so it can be a program name with args. +set dummy cut; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_CUT+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $CUT in + [\\/]* | ?:[\\/]*) + ac_cv_path_CUT="$CUT" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CUT=$ac_cv_path_CUT +if test -n "$CUT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5 +$as_echo "$CUT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable CUT is not empty. + if test "" = "$CUT"; then as_fn_error $? "Could not find cut !" "$LINENO" 5 ; fi + +# Extract the first word of "date", so it can be a program name with args. +set dummy date; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_DATE+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $DATE in + [\\/]* | ?:[\\/]*) + ac_cv_path_DATE="$DATE" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +DATE=$ac_cv_path_DATE +if test -n "$DATE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5 +$as_echo "$DATE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable DATE is not empty. + if test "" = "$DATE"; then as_fn_error $? "Could not find date !" "$LINENO" 5 ; fi + +# Extract the first word of "df", so it can be a program name with args. +set dummy df; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_DF+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $DF in + [\\/]* | ?:[\\/]*) + ac_cv_path_DF="$DF" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +DF=$ac_cv_path_DF +if test -n "$DF"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5 +$as_echo "$DF" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable DF is not empty. + if test "" = "$DF"; then as_fn_error $? "Could not find df !" "$LINENO" 5 ; fi + +# Extract the first word of "diff", so it can be a program name with args. +set dummy diff; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_DIFF+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $DIFF in + [\\/]* | ?:[\\/]*) + ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +DIFF=$ac_cv_path_DIFF +if test -n "$DIFF"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5 +$as_echo "$DIFF" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable DIFF is not empty. + if test "" = "$DIFF"; then as_fn_error $? "Could not find diff !" "$LINENO" 5 ; fi + +# Warning echo is really, really unportable!!!!! Different +# behaviour in bash and dash and in a lot of other shells! +# Use printf for serious work! +# Extract the first word of "echo", so it can be a program name with args. +set dummy echo; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_ECHO+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $ECHO in + [\\/]* | ?:[\\/]*) + ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +ECHO=$ac_cv_path_ECHO +if test -n "$ECHO"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5 +$as_echo "$ECHO" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable ECHO is not empty. + if test "" = "$ECHO"; then as_fn_error $? "Could not find echo !" "$LINENO" 5 ; fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 +$as_echo_n "checking for egrep... " >&6; } +if test "${ac_cv_path_EGREP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + if test -z "$EGREP"; then + ac_path_EGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in egrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" + { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue +# Check for GNU ac_path_EGREP and select it if it is found. + # Check for GNU $ac_path_EGREP +case `"$ac_path_EGREP" --version 2>&1` in +*GNU*) + ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'EGREP' >> "conftest.nl" + "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_EGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_EGREP="$ac_path_EGREP" + ac_path_EGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_EGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_EGREP"; then + as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_EGREP=$EGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 +$as_echo "$ac_cv_path_EGREP" >&6; } + EGREP="$ac_cv_path_EGREP" + + + + # Test that variable EGREP is not empty. + if test "" = "$EGREP"; then as_fn_error $? "Could not find egrep !" "$LINENO" 5 ; fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 +$as_echo_n "checking for fgrep... " >&6; } +if test "${ac_cv_path_FGREP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 + then ac_cv_path_FGREP="$GREP -F" + else + if test -z "$FGREP"; then + ac_path_FGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in fgrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext" + { test -f "$ac_path_FGREP" && $as_test_x "$ac_path_FGREP"; } || continue +# Check for GNU ac_path_FGREP and select it if it is found. + # Check for GNU $ac_path_FGREP +case `"$ac_path_FGREP" --version 2>&1` in +*GNU*) + ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'FGREP' >> "conftest.nl" + "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_FGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_FGREP="$ac_path_FGREP" + ac_path_FGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_FGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_FGREP"; then + as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_FGREP=$FGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 +$as_echo "$ac_cv_path_FGREP" >&6; } + FGREP="$ac_cv_path_FGREP" + + + + # Test that variable FGREP is not empty. + if test "" = "$FGREP"; then as_fn_error $? "Could not find fgrep !" "$LINENO" 5 ; fi + + +# Extract the first word of "find", so it can be a program name with args. +set dummy find; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_FIND+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $FIND in + [\\/]* | ?:[\\/]*) + ac_cv_path_FIND="$FIND" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +FIND=$ac_cv_path_FIND +if test -n "$FIND"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5 +$as_echo "$FIND" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable FIND is not empty. + if test "" = "$FIND"; then as_fn_error $? "Could not find find !" "$LINENO" 5 ; fi + + + # Test if find supports -delete + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5 +$as_echo_n "checking if find supports -delete... " >&6; } + FIND_DELETE="-delete" + + DELETEDIR=`mktemp -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?) + + echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete + + TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1` + if test -f $DELETEDIR/TestIfFindSupportsDelete; then + # No, it does not. + rm $DELETEDIR/TestIfFindSupportsDelete + FIND_DELETE="-exec rm \{\} \+" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + fi + rmdir $DELETEDIR + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +$as_echo_n "checking for grep that handles long lines and -e... " >&6; } +if test "${ac_cv_path_GREP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in grep ggrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" + { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'GREP' >> "conftest.nl" + "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_GREP=$GREP +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +$as_echo "$ac_cv_path_GREP" >&6; } + GREP="$ac_cv_path_GREP" + + + + # Test that variable GREP is not empty. + if test "" = "$GREP"; then as_fn_error $? "Could not find grep !" "$LINENO" 5 ; fi + +# Extract the first word of "head", so it can be a program name with args. +set dummy head; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_HEAD+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $HEAD in + [\\/]* | ?:[\\/]*) + ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +HEAD=$ac_cv_path_HEAD +if test -n "$HEAD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5 +$as_echo "$HEAD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable HEAD is not empty. + if test "" = "$HEAD"; then as_fn_error $? "Could not find head !" "$LINENO" 5 ; fi + +# Extract the first word of "ln", so it can be a program name with args. +set dummy ln; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_LN+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $LN in + [\\/]* | ?:[\\/]*) + ac_cv_path_LN="$LN" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +LN=$ac_cv_path_LN +if test -n "$LN"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5 +$as_echo "$LN" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable LN is not empty. + if test "" = "$LN"; then as_fn_error $? "Could not find ln !" "$LINENO" 5 ; fi + +# Extract the first word of "ls", so it can be a program name with args. +set dummy ls; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_LS+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $LS in + [\\/]* | ?:[\\/]*) + ac_cv_path_LS="$LS" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +LS=$ac_cv_path_LS +if test -n "$LS"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5 +$as_echo "$LS" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable LS is not empty. + if test "" = "$LS"; then as_fn_error $? "Could not find ls !" "$LINENO" 5 ; fi + +for ac_prog in gmake make +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_MAKE+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $MAKE in + [\\/]* | ?:[\\/]*) + ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +MAKE=$ac_cv_path_MAKE +if test -n "$MAKE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5 +$as_echo "$MAKE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$MAKE" && break +done + + + # Test that variable MAKE is not empty. + if test "" = "$MAKE"; then as_fn_error $? "Could not find make !" "$LINENO" 5 ; fi + +MAKE_VERSION=`$MAKE --version | head -n 1 | grep '3.8[12346789]'` +if test "x$MAKE_VERSION" = x; then + as_fn_error $? "You must use GNU make 3.81 or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5 +fi +# Extract the first word of "mkdir", so it can be a program name with args. +set dummy mkdir; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_MKDIR+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $MKDIR in + [\\/]* | ?:[\\/]*) + ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +MKDIR=$ac_cv_path_MKDIR +if test -n "$MKDIR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5 +$as_echo "$MKDIR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable MKDIR is not empty. + if test "" = "$MKDIR"; then as_fn_error $? "Could not find mkdir !" "$LINENO" 5 ; fi + +# Extract the first word of "mv", so it can be a program name with args. +set dummy mv; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_MV+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $MV in + [\\/]* | ?:[\\/]*) + ac_cv_path_MV="$MV" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +MV=$ac_cv_path_MV +if test -n "$MV"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5 +$as_echo "$MV" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable MV is not empty. + if test "" = "$MV"; then as_fn_error $? "Could not find mv !" "$LINENO" 5 ; fi + +for ac_prog in nawk gawk awk +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_NAWK+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $NAWK in + [\\/]* | ?:[\\/]*) + ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +NAWK=$ac_cv_path_NAWK +if test -n "$NAWK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5 +$as_echo "$NAWK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$NAWK" && break +done + + + # Test that variable NAWK is not empty. + if test "" = "$NAWK"; then as_fn_error $? "Could not find nawk !" "$LINENO" 5 ; fi + +# Extract the first word of "printf", so it can be a program name with args. +set dummy printf; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_PRINTF+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $PRINTF in + [\\/]* | ?:[\\/]*) + ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +PRINTF=$ac_cv_path_PRINTF +if test -n "$PRINTF"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5 +$as_echo "$PRINTF" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable PRINTF is not empty. + if test "" = "$PRINTF"; then as_fn_error $? "Could not find printf !" "$LINENO" 5 ; fi + +# Extract the first word of "pwd", so it can be a program name with args. +set dummy pwd; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_THEPWDCMD+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $THEPWDCMD in + [\\/]* | ?:[\\/]*) + ac_cv_path_THEPWDCMD="$THEPWDCMD" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_THEPWDCMD="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +THEPWDCMD=$ac_cv_path_THEPWDCMD +if test -n "$THEPWDCMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $THEPWDCMD" >&5 +$as_echo "$THEPWDCMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +# Extract the first word of "rm", so it can be a program name with args. +set dummy rm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_RM+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $RM in + [\\/]* | ?:[\\/]*) + ac_cv_path_RM="$RM" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +RM=$ac_cv_path_RM +if test -n "$RM"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5 +$as_echo "$RM" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable RM is not empty. + if test "" = "$RM"; then as_fn_error $? "Could not find rm !" "$LINENO" 5 ; fi + +RM="$RM -f" +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 +$as_echo_n "checking for a sed that does not truncate output... " >&6; } +if test "${ac_cv_path_SED+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ + for ac_i in 1 2 3 4 5 6 7; do + ac_script="$ac_script$as_nl$ac_script" + done + echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed + { ac_script=; unset ac_script;} + if test -z "$SED"; then + ac_path_SED_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_SED="$as_dir/$ac_prog$ac_exec_ext" + { test -f "$ac_path_SED" && $as_test_x "$ac_path_SED"; } || continue +# Check for GNU ac_path_SED and select it if it is found. + # Check for GNU $ac_path_SED +case `"$ac_path_SED" --version 2>&1` in +*GNU*) + ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo '' >> "conftest.nl" + "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_SED_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_SED="$ac_path_SED" + ac_path_SED_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_SED_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_SED"; then + as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5 + fi +else + ac_cv_path_SED=$SED +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 +$as_echo "$ac_cv_path_SED" >&6; } + SED="$ac_cv_path_SED" + rm -f conftest.sed + + + # Test that variable SED is not empty. + if test "" = "$SED"; then as_fn_error $? "Could not find sed !" "$LINENO" 5 ; fi + +# Extract the first word of "sh", so it can be a program name with args. +set dummy sh; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_SH+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $SH in + [\\/]* | ?:[\\/]*) + ac_cv_path_SH="$SH" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +SH=$ac_cv_path_SH +if test -n "$SH"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5 +$as_echo "$SH" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable SH is not empty. + if test "" = "$SH"; then as_fn_error $? "Could not find sh !" "$LINENO" 5 ; fi + +# Extract the first word of "sort", so it can be a program name with args. +set dummy sort; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_SORT+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $SORT in + [\\/]* | ?:[\\/]*) + ac_cv_path_SORT="$SORT" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +SORT=$ac_cv_path_SORT +if test -n "$SORT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5 +$as_echo "$SORT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable SORT is not empty. + if test "" = "$SORT"; then as_fn_error $? "Could not find sort !" "$LINENO" 5 ; fi + +# Extract the first word of "tar", so it can be a program name with args. +set dummy tar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_TAR+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $TAR in + [\\/]* | ?:[\\/]*) + ac_cv_path_TAR="$TAR" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +TAR=$ac_cv_path_TAR +if test -n "$TAR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5 +$as_echo "$TAR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable TAR is not empty. + if test "" = "$TAR"; then as_fn_error $? "Could not find tar !" "$LINENO" 5 ; fi + +# Extract the first word of "tail", so it can be a program name with args. +set dummy tail; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_TAIL+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $TAIL in + [\\/]* | ?:[\\/]*) + ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +TAIL=$ac_cv_path_TAIL +if test -n "$TAIL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5 +$as_echo "$TAIL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable TAIL is not empty. + if test "" = "$TAIL"; then as_fn_error $? "Could not find tail !" "$LINENO" 5 ; fi + +# Extract the first word of "tee", so it can be a program name with args. +set dummy tee; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_TEE+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $TEE in + [\\/]* | ?:[\\/]*) + ac_cv_path_TEE="$TEE" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +TEE=$ac_cv_path_TEE +if test -n "$TEE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5 +$as_echo "$TEE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable TEE is not empty. + if test "" = "$TEE"; then as_fn_error $? "Could not find tee !" "$LINENO" 5 ; fi + +# Extract the first word of "tr", so it can be a program name with args. +set dummy tr; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_TR+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $TR in + [\\/]* | ?:[\\/]*) + ac_cv_path_TR="$TR" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +TR=$ac_cv_path_TR +if test -n "$TR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5 +$as_echo "$TR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable TR is not empty. + if test "" = "$TR"; then as_fn_error $? "Could not find tr !" "$LINENO" 5 ; fi + +# Extract the first word of "touch", so it can be a program name with args. +set dummy touch; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_TOUCH+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $TOUCH in + [\\/]* | ?:[\\/]*) + ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +TOUCH=$ac_cv_path_TOUCH +if test -n "$TOUCH"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5 +$as_echo "$TOUCH" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable TOUCH is not empty. + if test "" = "$TOUCH"; then as_fn_error $? "Could not find touch !" "$LINENO" 5 ; fi + +# Extract the first word of "wc", so it can be a program name with args. +set dummy wc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_WC+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $WC in + [\\/]* | ?:[\\/]*) + ac_cv_path_WC="$WC" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +WC=$ac_cv_path_WC +if test -n "$WC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5 +$as_echo "$WC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable WC is not empty. + if test "" = "$WC"; then as_fn_error $? "Could not find wc !" "$LINENO" 5 ; fi + +# Extract the first word of "xargs", so it can be a program name with args. +set dummy xargs; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_XARGS+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $XARGS in + [\\/]* | ?:[\\/]*) + ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +XARGS=$ac_cv_path_XARGS +if test -n "$XARGS"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5 +$as_echo "$XARGS" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable XARGS is not empty. + if test "" = "$XARGS"; then as_fn_error $? "Could not find xargs !" "$LINENO" 5 ; fi + +# Extract the first word of "zip", so it can be a program name with args. +set dummy zip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_ZIP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $ZIP in + [\\/]* | ?:[\\/]*) + ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +ZIP=$ac_cv_path_ZIP +if test -n "$ZIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5 +$as_echo "$ZIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable ZIP is not empty. + if test "" = "$ZIP"; then as_fn_error $? "Could not find zip !" "$LINENO" 5 ; fi + +# Extract the first word of "unzip", so it can be a program name with args. +set dummy unzip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_UNZIP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $UNZIP in + [\\/]* | ?:[\\/]*) + ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +UNZIP=$ac_cv_path_UNZIP +if test -n "$UNZIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5 +$as_echo "$UNZIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable UNZIP is not empty. + if test "" = "$UNZIP"; then as_fn_error $? "Could not find unzip !" "$LINENO" 5 ; fi + +# Extract the first word of "ldd", so it can be a program name with args. +set dummy ldd; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_LDD+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $LDD in + [\\/]* | ?:[\\/]*) + ac_cv_path_LDD="$LDD" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +LDD=$ac_cv_path_LDD +if test -n "$LDD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5 +$as_echo "$LDD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +if test "x$LDD" = "x"; then + # List shared lib dependencies is used for + # debug output and checking for forbidden dependencies. + # We can build without it. + LDD="true" +fi +# Extract the first word of "otool", so it can be a program name with args. +set dummy otool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_OTOOL+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $OTOOL in + [\\/]* | ?:[\\/]*) + ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +OTOOL=$ac_cv_path_OTOOL +if test -n "$OTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 +$as_echo "$OTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +if test "x$OTOOL" = "x"; then + OTOOL="true" +fi +# Extract the first word of "readelf", so it can be a program name with args. +set dummy readelf; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_READELF+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $READELF in + [\\/]* | ?:[\\/]*) + ac_cv_path_READELF="$READELF" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +READELF=$ac_cv_path_READELF +if test -n "$READELF"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5 +$as_echo "$READELF" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +# Extract the first word of "expr", so it can be a program name with args. +set dummy expr; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_EXPR+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $EXPR in + [\\/]* | ?:[\\/]*) + ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +EXPR=$ac_cv_path_EXPR +if test -n "$EXPR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5 +$as_echo "$EXPR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable EXPR is not empty. + if test "" = "$EXPR"; then as_fn_error $? "Could not find expr !" "$LINENO" 5 ; fi + +# Extract the first word of "file", so it can be a program name with args. +set dummy file; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_FILE+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $FILE in + [\\/]* | ?:[\\/]*) + ac_cv_path_FILE="$FILE" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +FILE=$ac_cv_path_FILE +if test -n "$FILE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5 +$as_echo "$FILE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Test that variable FILE is not empty. + if test "" = "$FILE"; then as_fn_error $? "Could not find file !" "$LINENO" 5 ; fi + +# Extract the first word of "hg", so it can be a program name with args. +set dummy hg; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_HG+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $HG in + [\\/]* | ?:[\\/]*) + ac_cv_path_HG="$HG" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +HG=$ac_cv_path_HG +if test -n "$HG"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5 +$as_echo "$HG" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + +# Setup builddeps, for automatic downloading of tools we need. +# This is needed before we can call BDEPS_CHECK_MODULE, which is done in +# boot-jdk setup, but we need to have basic tools setup first. + + +# Check whether --with-builddeps-conf was given. +if test "${with_builddeps_conf+set}" = set; then : + withval=$with_builddeps_conf; +fi + + + +# Check whether --with-builddeps-server was given. +if test "${with_builddeps_server+set}" = set; then : + withval=$with_builddeps_server; +fi + + + +# Check whether --with-builddeps-dir was given. +if test "${with_builddeps_dir+set}" = set; then : + withval=$with_builddeps_dir; +else + with_builddeps_dir=/localhome/builddeps +fi + + + +# Check whether --with-builddeps-group was given. +if test "${with_builddeps_group+set}" = set; then : + withval=$with_builddeps_group; +fi + + +# Check whether --enable-list-builddeps was given. +if test "${enable_list_builddeps+set}" = set; then : + enableval=$enable_list_builddeps; LIST_BUILDDEPS="${enableval}" +else + LIST_BUILDDEPS='no' +fi + + +if test "x$LIST_BUILDDEPS" = xyes; then + echo + echo List of build dependencies known to the configure script, + echo that can be used in builddeps.conf files: + cat $AUTOCONF_DIR/*.ac $AUTOCONF_DIR/*.m4 | grep BDEPS_CHECK_MODULE\( | cut -f 2 -d ',' | tr -d ' ' | sort + echo + exit 1 +fi + + + + if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then + if test "x$with_builddeps_conf" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5 +$as_echo_n "checking for supplied builddeps configuration file... " >&6; } + builddepsfile=$with_builddeps_conf + if test -s $builddepsfile; then + . $builddepsfile + { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5 +$as_echo "loaded!" >&6; } + else + as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5 + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5 +$as_echo_n "checking for builddeps.conf files in sources...... " >&6; } + builddepsfile=`mktemp` + touch $builddepsfile + # Put all found confs into a single file. + find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile + # Source the file to acquire the variables + if test -s $builddepsfile; then + . $builddepsfile + { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5 +$as_echo "found at least one!" >&6; } + else + as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5 + fi + fi + # Create build and target names that use _ instead of "-" and ".". + # This is necessary to use them in variable names. + build_var=`echo ${OPENJDK_BUILD_SYSTEM} | tr '-' '_' | tr '.' '_'` + target_var=`echo ${OPENJDK_TARGET_SYSTEM} | tr '-' '_' | tr '.' '_'` + # Extract rewrite information for build and target + eval rewritten_build=\${REWRITE_${build_var}} + if test "x$rewritten_build" = x; then + rewritten_build=${OPENJDK_BUILD_SYSTEM} + echo Build stays the same $rewritten_build + else + echo Rewriting build for builddeps into $rewritten_build + fi + eval rewritten_target=\${REWRITE_${target_var}} + if test "x$rewritten_target" = x; then + rewritten_target=${OPENJDK_TARGET_SYSTEM} + echo Target stays the same $rewritten_target + else + echo Rewriting target for builddeps into $rewritten_target + fi + rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'` + rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'` + fi + for ac_prog in 7z unzip +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_BDEPS_UNZIP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$BDEPS_UNZIP"; then + ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_BDEPS_UNZIP="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP +if test -n "$BDEPS_UNZIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5 +$as_echo "$BDEPS_UNZIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$BDEPS_UNZIP" && break +done + + if test "x$BDEPS_UNZIP" = x7z; then + BDEPS_UNZIP="7z x" + fi + + for ac_prog in wget lftp ftp +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_BDEPS_FTP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$BDEPS_FTP"; then + ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_BDEPS_FTP="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +BDEPS_FTP=$ac_cv_prog_BDEPS_FTP +if test -n "$BDEPS_FTP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5 +$as_echo "$BDEPS_FTP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$BDEPS_FTP" && break +done + + + +# Check if pkg-config is available. + + +if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args. +set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_PKG_CONFIG+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $PKG_CONFIG in + [\\/]* | ?:[\\/]*) + ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +PKG_CONFIG=$ac_cv_path_PKG_CONFIG +if test -n "$PKG_CONFIG"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5 +$as_echo "$PKG_CONFIG" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_path_PKG_CONFIG"; then + ac_pt_PKG_CONFIG=$PKG_CONFIG + # Extract the first word of "pkg-config", so it can be a program name with args. +set dummy pkg-config; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_ac_pt_PKG_CONFIG+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $ac_pt_PKG_CONFIG in + [\\/]* | ?:[\\/]*) + ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG +if test -n "$ac_pt_PKG_CONFIG"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5 +$as_echo "$ac_pt_PKG_CONFIG" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_pt_PKG_CONFIG" = x; then + PKG_CONFIG="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + PKG_CONFIG=$ac_pt_PKG_CONFIG + fi +else + PKG_CONFIG="$ac_cv_path_PKG_CONFIG" +fi + +fi +if test -n "$PKG_CONFIG"; then + _pkg_min_version=0.9.0 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5 +$as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; } + if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + PKG_CONFIG="" + fi + +fi + +############################################################################### +# +# Determine OpenJDK build and target platforms. +# +############################################################################### + +# Make sure we can run config.sub. +$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || + as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 +$as_echo_n "checking build system type... " >&6; } +if test "${ac_cv_build+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_build_alias=$build_alias +test "x$ac_build_alias" = x && + ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` +test "x$ac_build_alias" = x && + as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 +ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 +$as_echo "$ac_cv_build" >&6; } +case $ac_cv_build in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5 ;; +esac +build=$ac_cv_build +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_build +shift +build_cpu=$1 +build_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +build_os=$* +IFS=$ac_save_IFS +case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 +$as_echo_n "checking host system type... " >&6; } +if test "${ac_cv_host+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test "x$host_alias" = x; then + ac_cv_host=$ac_cv_build +else + ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 +$as_echo "$ac_cv_host" >&6; } +case $ac_cv_host in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5 ;; +esac +host=$ac_cv_host +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_host +shift +host_cpu=$1 +host_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +host_os=$* +IFS=$ac_save_IFS +case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5 +$as_echo_n "checking target system type... " >&6; } +if test "${ac_cv_target+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test "x$target_alias" = x; then + ac_cv_target=$ac_cv_host +else + ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5 +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5 +$as_echo "$ac_cv_target" >&6; } +case $ac_cv_target in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical target" "$LINENO" 5 ;; +esac +target=$ac_cv_target +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_target +shift +target_cpu=$1 +target_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +target_os=$* +IFS=$ac_save_IFS +case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac + + +# The aliases save the names the user supplied, while $host etc. +# will get canonicalized. +test -n "$target_alias" && + test "$program_prefix$program_suffix$program_transform_name" = \ + NONENONEs,x,x, && + program_prefix=${target_alias}- + +# Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target" +# is confusing; it assumes you are cross-compiling a cross-compiler (!) and "target" is thus the target of the +# product you're building. The target of this build is called "host". Since this is confusing to most people, we +# have not adopted that system, but use "target" as the platform we are building for. In some places though we need +# to use the configure naming style. + + + + + +# Check whether --with-target-bits was given. +if test "${with_target_bits+set}" = set; then : + withval=$with_target_bits; +fi + + +if test "x$with_target_bits" != x && \ + test "x$with_target_bits" != x32 && \ + test "x$with_target_bits" != x64 ; then + as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5 +fi +# Translate the standard cpu-vendor-kernel-os quadruplets into +# the new TARGET_.... and BUILD_... and the legacy names used by +# the openjdk build. +# It uses $host_os $host_cpu $build_os $build_cpu and $with_target_bits + + # Expects $host_os $host_cpu $build_os and $build_cpu + # and $with_target_bits to have been setup! + # + # Translate the standard triplet(quadruplet) definition + # of the target/build system into + # OPENJDK_TARGET_OS=aix,bsd,hpux,linux,macosx,solaris,windows + # OPENJDK_TARGET_OS_FAMILY=bsd,gnu,sysv,win32,wince + # OPENJDK_TARGET_OS_API=posix,winapi + # + # OPENJDK_TARGET_CPU=ia32,x64,sparc,sparcv9,arm,arm64,ppc,ppc64 + # OPENJDK_TARGET_CPU_ARCH=x86,sparc,pcc,arm + # OPENJDK_TARGET_CPU_BITS=32,64 + # OPENJDK_TARGET_CPU_ENDIAN=big,little + # + # The same values are setup for BUILD_... + # + # And the legacy variables, for controlling the old makefiles. + # LEGACY_OPENJDK_TARGET_CPU1=i586,amd64/x86_64,sparc,sparcv9,arm,arm64... + # LEGACY_OPENJDK_TARGET_CPU2=i386,amd64,sparc,sparcv9,arm,arm64... + # LEGACY_OPENJDK_TARGET_CPU3=sparcv9,amd64 (but only on solaris) + # LEGACY_OPENJDK_TARGET_OS_API=solaris,windows + # + # We also copy the autoconf trip/quadruplet + # verbatim to OPENJDK_TARGET_SYSTEM (from the autoconf "host") and OPENJDK_BUILD_SYSTEM + OPENJDK_TARGET_SYSTEM="$host" + OPENJDK_BUILD_SYSTEM="$build" + + + + + + case "$host_os" in + *linux*) + VAR_OS=linux + VAR_OS_API=posix + VAR_OS_FAMILY=gnu + ;; + *solaris*) + VAR_OS=solaris + VAR_OS_API=posix + VAR_OS_FAMILY=sysv + ;; + *darwin*) + VAR_OS=macosx + VAR_OS_API=posix + VAR_OS_FAMILY=bsd + ;; + *bsd*) + VAR_OS=bsd + VAR_OS_API=posix + VAR_OS_FAMILY=bsd + ;; + *cygwin*|*windows*) + VAR_OS=windows + VAR_OS_API=winapi + VAR_OS_FAMILY=windows + ;; + *) + as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5 + ;; + esac + + OPENJDK_TARGET_OS="$VAR_OS" + OPENJDK_TARGET_OS_FAMILY="$VAR_OS_FAMILY" + OPENJDK_TARGET_OS_API="$VAR_OS_API" + + + + + + if test "x$OPENJDK_TARGET_OS_API" = xposix; then + LEGACY_OPENJDK_TARGET_OS_API="solaris" + fi + if test "x$OPENJDK_TARGET_OS_API" = xwinapi; then + LEGACY_OPENJDK_TARGET_OS_API="windows" + fi + + + + + # First argument is the cpu name from the trip/quad + case "$host_cpu" in + x86_64) + VAR_CPU=x64 + VAR_CPU_ARCH=x86 + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=little + VAR_LEGACY_CPU=amd64 + ;; + i?86) + VAR_CPU=ia32 + VAR_CPU_ARCH=x86 + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=little + VAR_LEGACY_CPU=i586 + ;; + alpha*) + VAR_CPU=alpha + VAR_CPU_ARCH=alpha + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=alpha + ;; + arm*) + VAR_CPU=arm + VAR_CPU_ARCH=arm + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=little + VAR_LEGACY_CPU=arm + ;; + mips) + VAR_CPU=mips + VAR_CPU_ARCH=mips + VAR_CPU_BITS=woot + VAR_CPU_ENDIAN=woot + VAR_LEGACY_CPU=mips + ;; + mipsel) + VAR_CPU=mipsel + VAR_CPU_ARCH=mips + VAR_CPU_BITS=woot + VAR_CPU_ENDIAN=woot + VAR_LEGACY_CPU=mipsel + ;; + powerpc) + VAR_CPU=ppc + VAR_CPU_ARCH=ppc + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=ppc + ;; + powerpc64) + VAR_CPU=ppc64 + VAR_CPU_ARCH=ppc + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=ppc64 + ;; + sparc) + VAR_CPU=sparc + VAR_CPU_ARCH=sparc + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=sparc + ;; + sparc64) + VAR_CPU=sparcv9 + VAR_CPU_ARCH=sparc + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=sparcv9 + ;; + s390) + VAR_CPU=s390 + VAR_CPU_ARCH=s390 + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=woot + VAR_LEGACY_CPU=s390 + VAR_LEGACY_CPU=s390 + ;; + s390x) + VAR_CPU=s390x + VAR_CPU_ARCH=s390 + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=woot + VAR_LEGACY_CPU=s390x + ;; + *) + as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5 + ;; + esac + + # Workaround cygwin not knowing about 64 bit. + if test "x$VAR_OS" = "xwindows"; then + if test "x$PROCESSOR_IDENTIFIER" != "x"; then + PROC_ARCH=`echo $PROCESSOR_IDENTIFIER | $CUT -f1 -d' '` + case "$PROC_ARCH" in + intel64|Intel64|INTEL64|em64t|EM64T|amd64|AMD64|8664|x86_64) + VAR_CPU=x64 + VAR_CPU_BITS=64 + VAR_LEGACY_CPU=amd64 + ;; + esac + fi + fi + + # on solaris x86...default seems to be 32-bit + if test "x$VAR_OS" = "xsolaris" && \ + test "x$with_target_bits" = "x" && \ + test "x$VAR_CPU_ARCH" = "xx86" + then + with_target_bits=32 + fi + + if test "x$VAR_CPU_ARCH" = "xx86"; then + if test "x$with_target_bits" = "x64"; then + VAR_CPU=x64 + VAR_CPU_BITS=64 + VAR_LEGACY_CPU=amd64 + fi + if test "x$with_target_bits" = "x32"; then + VAR_CPU=ia32 + VAR_CPU_BITS=32 + VAR_LEGACY_CPU=i586 + fi + fi + + if test "x$VAR_CPU_ARCH" = "xsparc"; then + if test "x$with_target_bits" = "x64"; then + VAR_CPU=sparcv9 + VAR_CPU_BITS=64 + VAR_LEGACY_CPU=sparcv9 + fi + fi + + OPENJDK_TARGET_CPU="$VAR_CPU" + OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH" + OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS" + OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN" + + + + + + + # Also store the legacy naming of the cpu. + # Ie i586 and amd64 instead of ia32 and x64 + LEGACY_OPENJDK_TARGET_CPU1="$VAR_LEGACY_CPU" + + + # And the second legacy naming of the cpu. + # Ie i386 and amd64 instead of ia32 and x64. + LEGACY_OPENJDK_TARGET_CPU2="$LEGACY_OPENJDK_TARGET_CPU1" + if test "x$LEGACY_OPENJDK_TARGET_CPU1" = xi586; then + LEGACY_OPENJDK_TARGET_CPU2=i386 + fi + + + # And the third legacy naming of the cpu. + # Ie only amd64 or sparcv9, used for the ISA_DIR on Solaris. + LEGACY_OPENJDK_TARGET_CPU3="" + if test "x$OPENJDK_TARGET_CPU" = xx64; then + LEGACY_OPENJDK_TARGET_CPU3=amd64 + fi + if test "x$OPENJDK_TARGET_CPU" = xsparcv9; then + LEGACY_OPENJDK_TARGET_CPU3=sparcv9 + fi + + + + + + case "$build_os" in + *linux*) + VAR_OS=linux + VAR_OS_API=posix + VAR_OS_FAMILY=gnu + ;; + *solaris*) + VAR_OS=solaris + VAR_OS_API=posix + VAR_OS_FAMILY=sysv + ;; + *darwin*) + VAR_OS=macosx + VAR_OS_API=posix + VAR_OS_FAMILY=bsd + ;; + *bsd*) + VAR_OS=bsd + VAR_OS_API=posix + VAR_OS_FAMILY=bsd + ;; + *cygwin*|*windows*) + VAR_OS=windows + VAR_OS_API=winapi + VAR_OS_FAMILY=windows + ;; + *) + as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5 + ;; + esac + + OPENJDK_BUILD_OS="$VAR_OS" + OPENJDK_BUILD_OS_FAMILY="$VAR_OS_FAMILY" + OPENJDK_BUILD_OS_API="$VAR_OS_API" + + + + + + if test "x$OPENJDK_BUILD_OS_API" = xposix; then + LEGACY_OPENJDK_BUILD_OS_API="solaris" + fi + if test "x$OPENJDK_BUILD_OS_API" = xwinapi; then + LEGACY_OPENJDK_BUILD_OS_API="windows" + fi + + + + + # First argument is the cpu name from the trip/quad + case "$build_cpu" in + x86_64) + VAR_CPU=x64 + VAR_CPU_ARCH=x86 + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=little + VAR_LEGACY_CPU=amd64 + ;; + i?86) + VAR_CPU=ia32 + VAR_CPU_ARCH=x86 + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=little + VAR_LEGACY_CPU=i586 + ;; + alpha*) + VAR_CPU=alpha + VAR_CPU_ARCH=alpha + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=alpha + ;; + arm*) + VAR_CPU=arm + VAR_CPU_ARCH=arm + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=little + VAR_LEGACY_CPU=arm + ;; + mips) + VAR_CPU=mips + VAR_CPU_ARCH=mips + VAR_CPU_BITS=woot + VAR_CPU_ENDIAN=woot + VAR_LEGACY_CPU=mips + ;; + mipsel) + VAR_CPU=mipsel + VAR_CPU_ARCH=mips + VAR_CPU_BITS=woot + VAR_CPU_ENDIAN=woot + VAR_LEGACY_CPU=mipsel + ;; + powerpc) + VAR_CPU=ppc + VAR_CPU_ARCH=ppc + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=ppc + ;; + powerpc64) + VAR_CPU=ppc64 + VAR_CPU_ARCH=ppc + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=ppc64 + ;; + sparc) + VAR_CPU=sparc + VAR_CPU_ARCH=sparc + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=sparc + ;; + sparc64) + VAR_CPU=sparcv9 + VAR_CPU_ARCH=sparc + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=big + VAR_LEGACY_CPU=sparcv9 + ;; + s390) + VAR_CPU=s390 + VAR_CPU_ARCH=s390 + VAR_CPU_BITS=32 + VAR_CPU_ENDIAN=woot + VAR_LEGACY_CPU=s390 + VAR_LEGACY_CPU=s390 + ;; + s390x) + VAR_CPU=s390x + VAR_CPU_ARCH=s390 + VAR_CPU_BITS=64 + VAR_CPU_ENDIAN=woot + VAR_LEGACY_CPU=s390x + ;; + *) + as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5 + ;; + esac + + # Workaround cygwin not knowing about 64 bit. + if test "x$VAR_OS" = "xwindows"; then + if test "x$PROCESSOR_IDENTIFIER" != "x"; then + PROC_ARCH=`echo $PROCESSOR_IDENTIFIER | $CUT -f1 -d' '` + case "$PROC_ARCH" in + intel64|Intel64|INTEL64|em64t|EM64T|amd64|AMD64|8664|x86_64) + VAR_CPU=x64 + VAR_CPU_BITS=64 + VAR_LEGACY_CPU=amd64 + ;; + esac + fi + fi + + # on solaris x86...default seems to be 32-bit + if test "x$VAR_OS" = "xsolaris" && \ + test "x$with_target_bits" = "x" && \ + test "x$VAR_CPU_ARCH" = "xx86" + then + with_target_bits=32 + fi + + if test "x$VAR_CPU_ARCH" = "xx86"; then + if test "x$with_target_bits" = "x64"; then + VAR_CPU=x64 + VAR_CPU_BITS=64 + VAR_LEGACY_CPU=amd64 + fi + if test "x$with_target_bits" = "x32"; then + VAR_CPU=ia32 + VAR_CPU_BITS=32 + VAR_LEGACY_CPU=i586 + fi + fi + + if test "x$VAR_CPU_ARCH" = "xsparc"; then + if test "x$with_target_bits" = "x64"; then + VAR_CPU=sparcv9 + VAR_CPU_BITS=64 + VAR_LEGACY_CPU=sparcv9 + fi + fi + + OPENJDK_BUILD_CPU="$VAR_CPU" + OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH" + OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS" + OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN" + + + + + + + # Also store the legacy naming of the cpu. + # Ie i586 and amd64 instead of ia32 and x64 + LEGACY_OPENJDK_BUILD_CPU1="$VAR_LEGACY_CPU" + + + # And the second legacy naming of the cpu. + # Ie i386 and amd64 instead of ia32 and x64. + LEGACY_OPENJDK_BUILD_CPU2="$LEGACY_OPENJDK_BUILD_CPU1" + if test "x$LEGACY_OPENJDK_BUILD_CPU1" = xi586; then + LEGACY_OPENJDK_BUILD_CPU2=i386 + fi + + + # And the third legacy naming of the cpu. + # Ie only amd64 or sparcv9, used for the ISA_DIR on Solaris. + LEGACY_OPENJDK_BUILD_CPU3="" + if test "x$OPENJDK_BUILD_CPU" = xx64; then + LEGACY_OPENJDK_BUILD_CPU3=amd64 + fi + if test "x$OPENJDK_BUILD_CPU" = xsparcv9; then + LEGACY_OPENJDK_BUILD_CPU3=sparcv9 + fi + + + + if test "x$OPENJDK_TARGET_OS" != xsolaris; then + LEGACY_OPENJDK_TARGET_CPU3="" + LEGACY_OPENJDK_BUILD_CPU3="" + fi + + # On MacOSX and MacOSX only, we have a different name for the x64 CPU in ARCH (LEGACY_OPENJDK_TARGET_CPU1) ... + if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$OPENJDK_TARGET_CPU" = xx64; then + LEGACY_OPENJDK_TARGET_CPU1="x86_64" + fi + + + if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then + REQUIRED_OS_NAME=SunOS + REQUIRED_OS_VERSION=5.10 + fi + if test "x$OPENJDK_TARGET_OS" = "xlinux"; then + REQUIRED_OS_NAME=Linux + REQUIRED_OS_VERSION=2.6 + fi + if test "x$OPENJDK_TARGET_OS" = "xwindows"; then + REQUIRED_OS_NAME=Windows + REQUIRED_OS_VERSION=5.1 + fi + if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then + REQUIRED_OS_NAME=Darwin + REQUIRED_OS_VERSION=11.2 + fi + + + + + + +# The LEGACY_OPENJDK_TARGET_CPU3 is the setting for ISA_DIR. +if test "x$LEGACY_OPENJDK_TARGET_CPU3" != x; then + LEGACY_OPENJDK_TARGET_CPU3="/${LEGACY_OPENJDK_TARGET_CPU3}" +fi + +# Now the following vars are defined. +# OPENJDK_TARGET_OS=aix,bsd,hpux,linux,macosx,solaris,windows +# OPENJDK_TARGET_OS_FAMILY=bsd,gnu,sysv,win32,wince +# OPENJDK_TARGET_OS_API=posix,winapi +# +# OPENJDK_TARGET_CPU=ia32,x64,sparc,sparcv9,arm,arm64,ppc,ppc64 +# OPENJDK_TARGET_CPU_ARCH=x86,sparc,pcc,arm +# OPENJDK_TARGET_CPU_BITS=32,64 +# OPENJDK_TARGET_CPU_ENDIAN=big,little +# +# There is also a: +# LEGACY_OPENJDK_TARGET_CPU1=i586,amd64,.... # used to set the old var ARCH +# LEGACY_OPENJDK_TARGET_CPU2=i386,amd64,.... # used to set the old var LIBARCH +# LEGACY_OPENJDK_TARGET_CPU3=only sparcv9,amd64 # used to set the ISA_DIR on Solaris +# There was also a BUILDARCH that had i486,amd64,... but we do not use that +# in the new build. +# LEGACY_OPENJDK_TARGET_OS_API=solaris,windows # used to select source roots + + +############################################################################### + +# Note that this is the build platform OS version! + +OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`" +OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`" +OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`" +OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`" + + + + + +# With knowledge of the build platform, setup more basic things. + +# For cygwin we need cygpath first, since it is used everywhere. +# Extract the first word of "cygpath", so it can be a program name with args. +set dummy cygpath; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_CYGPATH+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $CYGPATH in + [\\/]* | ?:[\\/]*) + ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CYGPATH=$ac_cv_path_CYGPATH +if test -n "$CYGPATH"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5 +$as_echo "$CYGPATH" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +PATH_SEP=":" +if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + if test "x$CYGPATH" = x; then + as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5 + fi + PATH_SEP=";" +fi + + + +if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then + # Add extra search paths on solaris for utilities like ar and as etc... + PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin" +fi + + +############################################################################### +# +# Determine OpenJDK variants, options and version numbers. +# +############################################################################### + +# We need build & target for this. + +############################################################################### +# +# Check which variant of the JDK that we want to build. +# Currently we have: +# normal: standard edition +# embedded: cut down to a smaller footprint +# +# Effectively the JDK variant gives a name to a specific set of +# modules to compile into the JDK. In the future, these modules +# might even be Jigsaw modules. +# +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5 +$as_echo_n "checking which variant of the JDK to build... " >&6; } + +# Check whether --with-jdk-variant was given. +if test "${with_jdk_variant+set}" = set; then : + withval=$with_jdk_variant; +fi + + +if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then + JAVASE_EMBEDDED="" + MINIMIZE_RAM_USAGE="" + JDK_VARIANT="normal" +elif test "x$with_jdk_variant" = xembedded; then + JAVASE_EMBEDDED="JAVASE_EMBEDDED:=true" + MINIMIZE_RAM_USAGE="MINIMIZE_RAM_USAGE:=true" + JDK_VARIANT="embedded" +else + as_fn_error $? "The available JDK variants are: normal, embedded" "$LINENO" 5 +fi + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5 +$as_echo "$JDK_VARIANT" >&6; } + + + +############################################################################### +# +# Check which variants of the JVM that we want to build. +# Currently we have: +# server: normal interpreter and a tiered C1/C2 compiler +# client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms) +# kernel: kernel footprint JVM that passes the TCK without major performance problems, +# ie normal interpreter and C1, only the serial GC, kernel jvmti etc +# zero: no machine code interpreter, no compiler +# zeroshark: zero interpreter and shark/llvm compiler backend +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM that should be built" >&5 +$as_echo_n "checking which variants of the JVM that should be built... " >&6; } + +# Check whether --with-jvm-variants was given. +if test "${with_jvm_variants+set}" = set; then : + withval=$with_jvm_variants; +fi + + +if test "x$with_jvm_variants" = x; then + if test "x$JDK_VARIANT" = xembedded; then + with_jvm_variants="client" + else + with_jvm_variants="server" + fi +fi + +JVM_VARIANTS=",$with_jvm_variants," +TEST_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,//' -e 's/client,//' -e 's/kernel,//' -e 's/zero,//' -e 's/zeroshark,//'` + +if test "x$TEST_VARIANTS" != "x,"; then + as_fn_error $? "The available JVM variants are: server, client, kernel, zero, zeroshark" "$LINENO" 5 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5 +$as_echo "$with_jvm_variants" >&6; } + +JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'` +JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'` +JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'` +JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'` +JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'` + +if test "x$JVM_VARIANT_CLIENT" = xtrue; then + if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then + as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5 + fi +fi +if test "x$JVM_VARIANT_KERNEL" = xtrue; then + if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then + as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5 + fi +fi + +# Replace the commas with AND for use in the build directory name. +ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/'` +COUNT_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,/1/' -e 's/client,/1/' -e 's/kernel,/1/' -e 's/zero,/1/' -e 's/zeroshark,/1/'` +if test "x$COUNT_VARIANTS" != "x,1"; then + BUILDING_MULTIPLE_JVM_VARIANTS=yes +else + BUILDING_MULTIPLE_JVM_VARIANTS=no +fi + + + + + + + + + + + +############################################################################### +# +# Set the debug level +# release: no debug information, all optimizations, no asserts. +# fastdebug: debug information (-g), all optimizations, all asserts +# slowdebug: debug information (-g), no optimizations, all asserts +# +DEBUG_LEVEL="release" +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5 +$as_echo_n "checking which debug level to use... " >&6; } +# Check whether --enable-debug was given. +if test "${enable_debug+set}" = set; then : + enableval=$enable_debug; + ENABLE_DEBUG="${enableval}" + DEBUG_LEVEL="fastdebug" + +else + ENABLE_DEBUG="no" +fi + + + +# Check whether --with-debug-level was given. +if test "${with_debug_level+set}" = set; then : + withval=$with_debug_level; + DEBUG_LEVEL="${withval}" + if test "x$ENABLE_DEBUG" = xyes; then + as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5 + fi + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5 +$as_echo "$DEBUG_LEVEL" >&6; } + +if test "x$DEBUG_LEVEL" != xrelease && \ + test "x$DEBUG_LEVEL" != xfastdebug && \ + test "x$DEBUG_LEVEL" != xslowdebug; then + as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5 +fi + + +############################################################################### +# +# Setup legacy vars/targets and new vars to deal with different debug levels. +# + +case $DEBUG_LEVEL in + release ) + VARIANT="OPT" + FASTDEBUG="false" + DEBUG_CLASSFILES="false" + BUILD_VARIANT_RELEASE="" + HOTSPOT_DEBUG_LEVEL="product" + HOTSPOT_EXPORT="product" + ;; + fastdebug ) + VARIANT="DBG" + FASTDEBUG="true" + DEBUG_CLASSFILES="true" + BUILD_VARIANT_RELEASE="-fastdebug" + HOTSPOT_DEBUG_LEVEL="fastdebug" + HOTSPOT_EXPORT="fastdebug" + ;; + slowdebug ) + VARIANT="DBG" + FASTDEBUG="false" + DEBUG_CLASSFILES="true" + BUILD_VARIANT_RELEASE="-debug" + HOTSPOT_DEBUG_LEVEL="jvmg" + HOTSPOT_EXPORT="debug" + ;; +esac + +##### +# Generate the legacy makefile targets for hotspot. +# The hotspot api for selecting the build artifacts, really, needs to be improved. +# +HOTSPOT_TARGET="" + +if test "x$JVM_VARIANT_SERVER" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} " +fi + +if test "x$JVM_VARIANT_CLIENT" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 " +fi + +if test "x$JVM_VARIANT_KERNEL" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel " +fi + +if test "x$JVM_VARIANT_ZERO" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero " +fi + +if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark " +fi + +HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT" + +##### + + + + + + + + + +############################################################################### +# +# Should we build only OpenJDK even if closed sources are present? +# +# Check whether --enable-openjdk-only was given. +if test "${enable_openjdk_only+set}" = set; then : + enableval=$enable_openjdk_only; +fi + + +if test "x$enable_openjdk_only" = "xyes"; then + OPENJDK=true +elif test "x$enable_openjdk_only" = "xno"; then + OPENJDK=false +elif test -d "$SRC_ROOT/jdk/src/closed"; then + OPENJDK=false +else + OPENJDK=true +fi + +if test "x$OPENJDK" = "xtrue"; then + SET_OPENJDK=OPENJDK=true +fi + + + +############################################################################### +# +# JIGSAW or not. The JIGSAW variable is used during the intermediate +# stage when we are building both the old style JDK and the new style modularized JDK. +# When the modularized JDK is finalized, this option will go away. +# +# Check whether --enable-jigsaw was given. +if test "${enable_jigsaw+set}" = set; then : + enableval=$enable_jigsaw; +fi + + +if test "x$enable_jigsaw" = "xyes"; then + JIGSAW=true +else + JIGSAW=false +fi + + +############################################################################### +# +# Should we build a JDK/JVM with headful support (ie a graphical ui)? +# We always build headless support. +# +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5 +$as_echo_n "checking headful support... " >&6; } +# Check whether --enable-headful was given. +if test "${enable_headful+set}" = set; then : + enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful} +else + SUPPORT_HEADFUL=yes +fi + + +SUPPORT_HEADLESS=yes +BUILD_HEADLESS="BUILD_HEADLESS:=true" + +if test "x$SUPPORT_HEADFUL" = xyes; then + # We are building both headful and headless. + BUILD_HEADLESS_ONLY="" + headful_msg="inlude support for both headful and headless" +fi + +if test "x$SUPPORT_HEADFUL" = xno; then + # Thus we are building headless only. + BUILD_HEADLESS="BUILD_HEADLESS:=true" + BUILD_HEADLESS_ONLY="BUILD_HEADLESS_ONLY:=true" + headful_msg="headless only" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5 +$as_echo "$headful_msg" >&6; } + + + + + + +############################################################################### +# +# Should we run the painfully slow javadoc tool? +# +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build documentation" >&5 +$as_echo_n "checking whether to build documentation... " >&6; } +# Check whether --enable-docs was given. +if test "${enable_docs+set}" = set; then : + enableval=$enable_docs; ENABLE_DOCS="${enableval}" +else + ENABLE_DOCS='no' +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_DOCS" >&5 +$as_echo "$ENABLE_DOCS" >&6; } + +GENERATE_DOCS=false +if test "x$ENABLE_DOCS" = xyes; then + GENERATE_DOCS=true +fi + + +############################################################################### +# +# Should we compile nimbus swing L&F? We can probably remove this option +# since nimbus is officially part of javax now. +# +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build nimbus L&F" >&5 +$as_echo_n "checking whether to build nimbus L&F... " >&6; } +# Check whether --enable-nimbus was given. +if test "${enable_nimbus+set}" = set; then : + enableval=$enable_nimbus; ENABLE_NIMBUS="${enableval}" +else + ENABLE_NIMBUS='yes' +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_NIMBUS" >&5 +$as_echo "$ENABLE_NIMBUS" >&6; } +DISABLE_NIMBUS= +if test "x$ENABLE_NIMBUS" = xno; then + DISABLE_NIMBUS=true +fi + + +# Control wether Hotspot runs Queens test after build. +# Check whether --enable-hotspot-test-in-build was given. +if test "${enable_hotspot_test_in_build+set}" = set; then : + enableval=$enable_hotspot_test_in_build; +else + enable_hotspot_test_in_build=no +fi + +if test "x$enable_hotspot_test_in_build" = "xyes"; then + TEST_IN_BUILD=true +else + TEST_IN_BUILD=false +fi + + +############################################################################### +# +# Choose cacerts source file +# + +# Check whether --with-cacerts-file was given. +if test "${with_cacerts_file+set}" = set; then : + withval=$with_cacerts_file; +fi + +if test "x$with_cacerts_file" != x; then + CACERTS_FILE=$with_cacerts_file +else + if test "x$OPENJDK" = "xtrue"; then + CACERTS_FILE=${SRC_ROOT}/jdk/src/share/lib/security/cacerts + else + CACERTS_FILE=${SRC_ROOT}/jdk/src/closed/share/lib/security/cacerts.internal + fi +fi + + +############################################################################### +# +# Compress jars +# +COMPRESS_JARS=false + +# default for embedded is yes... +if test "x$JDK_VARIANT" = "xembedded"; then + COMPRESS_JARS=true +fi + + +############################################################################### +# +# Should we compile JFR +# default no, except for on closed-jdk and !embedded +# +ENABLE_JFR=no + +# Is the JFR source present + +# +# For closed && !embedded default is yes if the source is present +# +if test "x${OPENJDK}" != "xtrue" && test "x$JDK_VARIANT" != "xembedded" && test -d "$SRC_ROOT/jdk/src/closed/share/native/oracle/jfr"; then + ENABLE_JFR=yes +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build jfr" >&5 +$as_echo_n "checking whether to build jfr... " >&6; } +# Check whether --enable-jfr was given. +if test "${enable_jfr+set}" = set; then : + enableval=$enable_jfr; +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${ENABLE_JFR}" >&5 +$as_echo "${ENABLE_JFR}" >&6; } + +if test "x$ENABLE_JFR" = "xyes"; then + ENABLE_JFR=true +elif test "x$ENABLE_JFR" = "xno"; then + ENABLE_JFR=false +else + as_fn_error $? "Invalid argument to --enable-jfr" "$LINENO" 5 +fi + + + + +# Source the version numbers +. $AUTOCONF_DIR/version.numbers +if test "x$OPENJDK" = "xfalse"; then + . $AUTOCONF_DIR/closed.version.numbers +fi +# Now set the JDK version, milestone, build number etc. + + + + + + + + + + + + +COPYRIGHT_YEAR=`date +'%Y'` + + +RUNTIME_NAME="$PRODUCT_NAME $PRODUCT_SUFFIX" + + +if test "x$JDK_UPDATE_VERSION" != x; then + JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}" +else + JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}" +fi + + +if test "x$MILESTONE" != x; then + RELEASE="${JDK_VERSION}-${MILESTONE}${BUILD_VARIANT_RELEASE}" +else + RELEASE="${JDK_VERSION}${BUILD_VARIANT_RELEASE}" +fi + + +if test "x$JDK_BUILD_NUMBER" != x; then + FULL_VERSION="${RELEASE}-${JDK_BUILD_NUMBER}" +else + JDK_BUILD_NUMBER=b00 + BUILD_DATE=`date '+%Y_%m_%d_%H_%M'` + # Avoid [:alnum:] since it depends on the locale. + CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyz0123456789'` + USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvqxyz'` + FULL_VERSION="${RELEASE}-${USER_RELEASE_SUFFIX}-${JDK_BUILD_NUMBER}" +fi + +COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'` + + + +# To properly create a configuration name, we need to have the OpenJDK target +# and options (variants and debug level) parsed. + + + +# Check whether --with-conf-name was given. +if test "${with_conf_name+set}" = set; then : + withval=$with_conf_name; CONF_NAME=${with_conf_name} +fi + + +# Test from where we are running configure, in or outside of src root. +if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" || test "x$CURDIR" = "x$SRC_ROOT/common/makefiles" ; then + # We are running configure from the src root. + # Create a default ./build/target-variant-debuglevel output root. + if test "x${CONF_NAME}" = x; then + CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}" + fi + OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}" + mkdir -p "$OUTPUT_ROOT" + if test ! -d "$OUTPUT_ROOT"; then + as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5 + fi +else + # We are running configure from outside of the src dir. + # Then use the current directory as output dir! + # If configuration is situated in normal build directory, just use the build + # directory name as configuration name, otherwise use the complete path. + if test "x${CONF_NAME}" = x; then + CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"` + fi + OUTPUT_ROOT="$CURDIR" +fi + + + # Fail with message the path to the output root if var OUTPUT_ROOT contains a path with no spaces in it. + # Unless on Windows, where we can rewrite the path. + HAS_SPACE=`echo "$OUTPUT_ROOT" | grep " "` + if test "x$HAS_SPACE" != x; then + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + OUTPUT_ROOT=`$CYGPATH -s -m -a "$OUTPUT_ROOT"` + OUTPUT_ROOT=`$CYGPATH -u "$OUTPUT_ROOT"` + else + as_fn_error $? "You cannot have spaces in the path to the output root! \"$OUTPUT_ROOT\"" "$LINENO" 5 + fi + fi + + +SPEC=$OUTPUT_ROOT/spec.gmk + +CONF_NAME=$CONF_NAME + +OUTPUT_ROOT=$OUTPUT_ROOT + + +# Most of the probed defines are put into config.h +ac_config_headers="$ac_config_headers $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in" + +# The spec.gmk file contains all variables for the make system. +ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in" + +# The spec.sh file contains variables for compare{images|-objects}.sh scrips. +ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in" + +# The generated Makefile knows where the spec.gmk is and where the source is. +# You can run make from the OUTPUT_ROOT, or from the top-level Makefile +# which will look for generated configurations +ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in" + + +# Save the arguments given to us +echo "$CONFIGURE_COMMAND_LINE" > $OUTPUT_ROOT/configure-arguments + + +############################################################################### +# +# Setup BootJDK, used to bootstrap the build. +# +############################################################################### + + +BOOT_JDK_FOUND=no + +# Check whether --with-boot-jdk was given. +if test "${with_boot_jdk+set}" = set; then : + withval=$with_boot_jdk; +fi + + +if test "x$with_boot_jdk" != x; then + BOOT_JDK=$with_boot_jdk + BOOT_JDK_FOUND=yes +fi +if test "x$BOOT_JDK_FOUND" = xno; then + + + if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then + # Source the builddeps file again, to make sure it uses the latest variables! + . $builddepsfile + # Look for a target and build machine specific resource! + eval resource=\${builddep_boot-jdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}} + if test "x$resource" = x; then + # Ok, lets instead look for a target specific resource + eval resource=\${builddep_boot-jdk_TARGET_${rewritten_target_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a build specific resource + eval resource=\${builddep_boot-jdk_BUILD_${rewritten_build_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a generic resource + # (The boot-jdk comes from M4 and not the shell, thus no need for eval here.) + resource=${builddep_boot-jdk} + fi + if test "x$resource" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for boot-jdk" >&5 +$as_echo "$as_me: Using builddeps $resource for boot-jdk" >&6;} + # If the resource in the builddeps.conf file is an existing directory, + # for example /java/linux/cups + if test -d ${resource}; then + depdir=${resource} + else + +# boot-jdk is for example mymodule +# $resource is for example libs/general/libmymod_1_2_3.zip +# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps +# $with_builddeps_dir is for example /localhome/builddeps +# depdir is the name of the variable into which we store the depdir, eg MYMOD +# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and +# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 + filename=`basename $resource` + filebase=`echo $filename | sed 's/\.[^\.]*$//'` + filebase=${filename%%.*} + extension=${filename#*.} + installdir=$with_builddeps_dir/$filebase + if test ! -f $installdir/$filename.unpacked; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency boot-jdk from $with_builddeps_server/$resource and installing into $installdir" >&5 +$as_echo "$as_me: Downloading build dependency boot-jdk from $with_builddeps_server/$resource and installing into $installdir" >&6;} + if test ! -d $installdir; then + mkdir -p $installdir + fi + if test ! -d $installdir; then + as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 + fi + tmpfile=`mktemp $installdir/boot-jdk.XXXXXXXXX` + touch $tmpfile + if test ! -f $tmpfile; then + as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 + fi + + # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip + # $tmpfile is the local file name for the downloaded file. + VALID_TOOL=no + if test "x$BDEPS_FTP" = xwget; then + VALID_TOOL=yes + wget -O $tmpfile $with_builddeps_server/$resource + fi + if test "x$BDEPS_FTP" = xlftp; then + VALID_TOOL=yes + lftp -c "get $with_builddeps_server/$resource -o $tmpfile" + fi + if test "x$BDEPS_FTP" = xftp; then + VALID_TOOL=yes + FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` + FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` + FTPUSERPWD=${FTPSERVER%%@*} + if test "x$FTPSERVER" != "x$FTPUSERPWD"; then + FTPUSER=${userpwd%%:*} + FTPPWD=${userpwd#*@} + FTPSERVER=${FTPSERVER#*@} + else + FTPUSER=ftp + FTPPWD=ftp + fi + # the "pass" command does not work on some + # ftp clients (read ftp.exe) but if it works, + # passive mode is better! + (\ + echo "user $FTPUSER $FTPPWD" ;\ + echo "pass" ;\ + echo "bin" ;\ + echo "get $FTPPATH $tmpfile" ;\ + ) | ftp -in $FTPSERVER + fi + if test "x$VALID_TOOL" != xyes; then + as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 + fi + + mv $tmpfile $installdir/$filename + if test ! -s $installdir/$filename; then + as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 + fi + case "$extension" in + zip) echo "Unzipping $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) + ;; + tar.gz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + tgz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 + ;; + esac + fi + if test -f $installdir/$filename.unpacked; then + depdir=$installdir + fi + + fi + # Source the builddeps file again, because in the previous command, the depdir + # was updated to point at the current build dependency install directory. + . $builddepsfile + # Now extract variables from the builddeps.conf files. + theroot=${builddep_boot-jdk_ROOT} + thecflags=${builddep_boot-jdk_CFLAGS} + thelibs=${builddep_boot-jdk_LIBS} + if test "x$depdir" = x; then + as_fn_error $? "Could not download build dependency boot-jdk" "$LINENO" 5 + fi + BOOT_JDK=$depdir + if test "x$theroot" != x; then + BOOT_JDK="$theroot" + fi + if test "x$thecflags" != x; then + BOOT_JDK_CFLAGS="$thecflags" + fi + if test "x$thelibs" != x; then + BOOT_JDK_LIBS="$thelibs" + fi + BOOT_JDK_FOUND=yes + else BOOT_JDK_FOUND=no + + fi + else BOOT_JDK_FOUND=no + + fi + +fi + +if test "x$BOOT_JDK_FOUND" = xno; then + if test "x$JAVA_HOME" != x; then + if test ! -d "$JAVA_HOME"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5 +$as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + + fi + # Aha, the user has set a JAVA_HOME + # let us use that as the Boot JDK. + BOOT_JDK="$JAVA_HOME" + BOOT_JDK_FOUND=yes + # To be on the safe side, lets check that it is a JDK. + if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then + JAVAC="$BOOT_JDK/bin/javac" + JAVA="$BOOT_JDK/bin/java" + BOOT_JDK_FOUND=yes + else + { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a JRE! The build needs a JDK! Please point JAVA_HOME to a JDK. JAVA_HOME=$JAVA_HOME" >&5 +$as_echo "$as_me: Your JAVA_HOME points to a JRE! The build needs a JDK! Please point JAVA_HOME to a JDK. JAVA_HOME=$JAVA_HOME" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + + fi + fi +fi + +if test "x$BOOT_JDK_FOUND" = xno; then + # Extract the first word of "javac", so it can be a program name with args. +set dummy javac; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_JAVAC_CHECK+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $JAVAC_CHECK in + [\\/]* | ?:[\\/]*) + ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK +if test -n "$JAVAC_CHECK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5 +$as_echo "$JAVAC_CHECK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + # Extract the first word of "java", so it can be a program name with args. +set dummy java; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_JAVA_CHECK+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $JAVA_CHECK in + [\\/]* | ?:[\\/]*) + ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +JAVA_CHECK=$ac_cv_path_JAVA_CHECK +if test -n "$JAVA_CHECK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5 +$as_echo "$JAVA_CHECK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + BINARY="$JAVAC_CHECK" + if test "x$JAVAC_CHECK" = x; then + BINARY="$JAVA_CHECK" + fi + if test "x$BINARY" != x; then + # So there is a java(c) binary, it might be part of a JDK. + # Lets find the JDK/JRE directory by following symbolic links. + # Linux/GNU systems often have links from /usr/bin/java to + # /etc/alternatives/java to the real JDK binary. + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$BINARY" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$BINARY"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + BINARY="$tmp" + + + if test "x$OPENJDK_BUILD_OS" != xwindows; then + # Follow a chain of symbolic links. Use readlink + # where it exists, else fall back to horribly + # complicated shell code. + # Extract the first word of "readlink", so it can be a program name with args. +set dummy readlink; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_READLINK+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $READLINK in + [\\/]* | ?:[\\/]*) + ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +READLINK=$ac_cv_path_READLINK +if test -n "$READLINK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5 +$as_echo "$READLINK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + if test "x$READLINK_TESTED" != yes; then + # On MacOSX there is a readlink tool with a different + # purpose than the GNU readlink tool. Check the found readlink. + ISGNU=`$READLINK --help 2>&1 | grep GNU` + if test "x$ISGNU" = x; then + # A readlink that we do not know how to use. + # Are there other non-GNU readlinks out there? + READLINK_TESTED=yes + READLINK= + fi + fi + + if test "x$READLINK" != x; then + BINARY=`$READLINK -f $BINARY` + else + STARTDIR=$PWD + COUNTER=0 + DIR=`dirname $BINARY` + FIL=`basename $BINARY` + while test $COUNTER -lt 20; do + ISLINK=`ls -l $DIR/$FIL | grep '\->' | sed -e 's/.*-> \(.*\)/\1/'` + if test "x$ISLINK" == x; then + # This is not a symbolic link! We are done! + break + fi + # The link might be relative! We have to use cd to travel safely. + cd $DIR + cd `dirname $ISLINK` + DIR=`pwd` + FIL=`basename $ISLINK` + let COUNTER=COUNTER+1 + done + cd $STARTDIR + BINARY=$DIR/$FIL + fi + fi + + BOOT_JDK=`dirname $BINARY` + BOOT_JDK=`cd $BOOT_JDK/..; pwd` + if test -x $BOOT_JDK/bin/javac && test -x $BOOT_JDK/bin/java; then + JAVAC=$BOOT_JDK/bin/javac + JAVA=$BOOT_JDK/bin/java + BOOT_JDK_FOUND=yes + fi + fi +fi + +if test "x$BOOT_JDK_FOUND" = xno; then + # Try the MacOSX way. + if test -x /usr/libexec/java_home; then + BOOT_JDK=`/usr/libexec/java_home` + if test -x $BOOT_JDK/bin/javac && test -x $BOOT_JDK/bin/java; then + JAVAC=$BOOT_JDK/bin/javac + JAVA=$BOOT_JDK/bin/java + BOOT_JDK_FOUND=yes + fi + fi +fi + +if test "x$BOOT_JDK_FOUND" = xno; then + # Extract the first word of "java", so it can be a program name with args. +set dummy java; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_JAVA_CHECK+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $JAVA_CHECK in + [\\/]* | ?:[\\/]*) + ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +JAVA_CHECK=$ac_cv_path_JAVA_CHECK +if test -n "$JAVA_CHECK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5 +$as_echo "$JAVA_CHECK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + if test "x$JAVA_CHECK" != x; then + # There is a java in the path. But apparently we have not found a javac + # in the path, since that would have been tested earlier. + if test "x$OPENJDK_TARGET_OS" = xwindows; then + # Now if this is a windows platform. The default installation of a JDK + # actually puts the JRE in the path and keeps the JDK out of the path! + # Go look in the default installation location. + BOOT_JDK=/cygdrive/c/Program\ Files/Java/`ls /cygdrive/c/Program\ Files/Java | grep jdk | sort -r | head --lines 1` + if test -d "$BOOT_JDK"; then + BOOT_JDK_FOUND=yes + fi + fi + if test "x$BOOT_JDK_FOUND" = xno; then + + # Print a helpful message on how to acquire the necessary build dependency. + # openjdk is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=openjdk + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: Found a JRE, not not a JDK! Please remove the JRE from your path and put a JDK there instead. $HELP_MSG" >&5 +$as_echo "$as_me: Found a JRE, not not a JDK! Please remove the JRE from your path and put a JDK there instead. $HELP_MSG" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + + fi + else + + # Print a helpful message on how to acquire the necessary build dependency. + # openjdk is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=openjdk + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a JDK. $HELP_MSG" >&5 +$as_echo "$as_me: Could not find a JDK. $HELP_MSG" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + + fi +fi + + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + # Extract the first word of "cygpath", so it can be a program name with args. +set dummy cygpath; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_CYGPATH+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $CYGPATH in + [\\/]* | ?:[\\/]*) + ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CYGPATH=$ac_cv_path_CYGPATH +if test -n "$CYGPATH"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5 +$as_echo "$CYGPATH" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + tmp="$BOOT_JDK" + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + BOOT_JDK="$tmp" + fi + + +# Now see if we can find the rt.jar, or its nearest equivalent. +BOOT_RTJAR="$BOOT_JDK/jre/lib/rt.jar" + + # Fail with message the path to the Boot JDK rt.jar (or nearest equivalent) if var BOOT_RTJAR contains a path with no spaces in it. + # Unless on Windows, where we can rewrite the path. + HAS_SPACE=`echo "$BOOT_RTJAR" | grep " "` + if test "x$HAS_SPACE" != x; then + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + BOOT_RTJAR=`$CYGPATH -s -m -a "$BOOT_RTJAR"` + BOOT_RTJAR=`$CYGPATH -u "$BOOT_RTJAR"` + else + as_fn_error $? "You cannot have spaces in the path to the Boot JDK rt.jar (or nearest equivalent)! \"$BOOT_RTJAR\"" "$LINENO" 5 + fi + fi + + +BOOT_TOOLSJAR="$BOOT_JDK/lib/tools.jar" + + # Fail with message the path to the Boot JDK tools.jar (or nearest equivalent) if var BOOT_TOOLSJAR contains a path with no spaces in it. + # Unless on Windows, where we can rewrite the path. + HAS_SPACE=`echo "$BOOT_TOOLSJAR" | grep " "` + if test "x$HAS_SPACE" != x; then + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + BOOT_TOOLSJAR=`$CYGPATH -s -m -a "$BOOT_TOOLSJAR"` + BOOT_TOOLSJAR=`$CYGPATH -u "$BOOT_TOOLSJAR"` + else + as_fn_error $? "You cannot have spaces in the path to the Boot JDK tools.jar (or nearest equivalent)! \"$BOOT_TOOLSJAR\"" "$LINENO" 5 + fi + fi + + +if test ! -f $BOOT_RTJAR; then + # On MacOSX it is called classes.jar + BOOT_RTJAR=$BOOT_JDK/../Classes/classes.jar + if test ! -f $BOOT_RTJAR; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot find the rt.jar or its equivalent!" >&5 +$as_echo "$as_me: Cannot find the rt.jar or its equivalent!" >&6;} + { $as_echo "$as_me:${as_lineno-$LINENO}: This typically means that configure failed to automatically find a suitable Boot JDK" >&5 +$as_echo "$as_me: This typically means that configure failed to automatically find a suitable Boot JDK" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + + fi + # Remove the .. + BOOT_RTJAR="`cd ${BOOT_RTJAR%/*} && pwd`/${BOOT_RTJAR##*/}" + # The tools.jar is part of classes.jar + BOOT_TOOLSJAR="$BOOT_RTJAR" +fi + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5 +$as_echo_n "checking for Boot JDK... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5 +$as_echo "$BOOT_JDK" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot rt.jar" >&5 +$as_echo_n "checking for Boot rt.jar... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_RTJAR" >&5 +$as_echo "$BOOT_RTJAR" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot tools.jar" >&5 +$as_echo_n "checking for Boot tools.jar... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_TOOLSJAR" >&5 +$as_echo "$BOOT_TOOLSJAR" >&6; } + +# Use the java tool from the Boot JDK. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5 +$as_echo_n "checking for java in Boot JDK... " >&6; } +JAVA=$BOOT_JDK/bin/java +if test ! -x $JAVA; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a working java" >&5 +$as_echo "$as_me: Could not find a working java" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + +fi +BOOT_JDK_VERSION=`$JAVA -version 2>&1 | head -n 1` +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes $BOOT_JDK_VERSION" >&5 +$as_echo "yes $BOOT_JDK_VERSION" >&6; } + + +# Extra M4 quote needed to protect [] in grep expression. +FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep '\"1\.[78]\.'` +if test "x$FOUND_VERSION_78" = x; then + + # Print a helpful message on how to acquire the necessary build dependency. + # openjdk is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=openjdk + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: Your boot-jdk must be version 7 or 8. $HELP_MSG" >&5 +$as_echo "$as_me: Your boot-jdk must be version 7 or 8. $HELP_MSG" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + +fi + +# When compiling code to be executed by the Boot JDK, force jdk7 compatibility. +BOOT_JDK_SOURCETARGET="-source 7 -target 7" + + +# Use the javac tool from the Boot JDK. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5 +$as_echo_n "checking for javac in Boot JDK... " >&6; } +JAVAC=$BOOT_JDK/bin/javac +if test ! -x $JAVAC; then + as_fn_error $? "Could not find a working javac" "$LINENO" 5 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + + + +# Use the javah tool from the Boot JDK. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5 +$as_echo_n "checking for javah in Boot JDK... " >&6; } +JAVAH=$BOOT_JDK/bin/javah +if test ! -x $JAVAH; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a working javah" >&5 +$as_echo "$as_me: Could not find a working javah" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + + +# Use the jar tool from the Boot JDK. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5 +$as_echo_n "checking for jar in Boot JDK... " >&6; } +JAR=$BOOT_JDK/bin/jar +if test ! -x $JAR; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a working jar" >&5 +$as_echo "$as_me: Could not find a working jar" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + +# Use the rmic tool from the Boot JDK. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for rmic in Boot JDK" >&5 +$as_echo_n "checking for rmic in Boot JDK... " >&6; } +RMIC=$BOOT_JDK/bin/rmic +if test ! -x $RMIC; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a working rmic" >&5 +$as_echo "$as_me: Could not find a working rmic" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + +# Use the native2ascii tool from the Boot JDK. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for native2ascii in Boot JDK" >&5 +$as_echo_n "checking for native2ascii in Boot JDK... " >&6; } +NATIVE2ASCII=$BOOT_JDK/bin/native2ascii +if test ! -x $NATIVE2ASCII; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a working native2ascii" >&5 +$as_echo "$as_me: Could not find a working native2ascii" >&6;} + + { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5 +$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;} + as_fn_error $? "Cannot continue" "$LINENO" 5 + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + + + +############################################################################## +# +# Specify options for anything that is run with the Boot JDK. +# + +# Check whether --with-boot-jdk-jvmargs was given. +if test "${with_boot_jdk_jvmargs+set}" = set; then : + withval=$with_boot_jdk_jvmargs; +fi + + +if test "x$with_boot_jdk_jvmargs" = x; then + # Not all JVM:s accept the same arguments on the command line. + # OpenJDK specific increase in thread stack for JDK build, + # well more specifically, when running javac. + if test "x$BUILD_NUM_BITS" = x32; then + STACK_SIZE=768 + else + # Running Javac on a JVM on a 64-bit machine, the stack takes more space + # since 64-bit pointers are pushed on the stach. Apparently, we need + # to increase the stack space when javacing the JDK.... + STACK_SIZE=1536 + fi + + # Minimum amount of heap memory. + + # Test if -Xms64M is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -Xms64M to boot_jdk_jvmargs + FOUND_WARN=`$JAVA -Xms64M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -Xms64M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + boot_jdk_jvmargs="$boot_jdk_jvmargs -Xms64M" + fi + + if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then + # Why does macosx need more heap? Its the huge JDK batch. + + # Test if -Xmx1600M is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -Xmx1600M to boot_jdk_jvmargs + FOUND_WARN=`$JAVA -Xmx1600M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -Xmx1600M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + boot_jdk_jvmargs="$boot_jdk_jvmargs -Xmx1600M" + fi + + else + + # Test if -Xmx1100M is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -Xmx1100M to boot_jdk_jvmargs + FOUND_WARN=`$JAVA -Xmx1100M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -Xmx1100M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + boot_jdk_jvmargs="$boot_jdk_jvmargs -Xmx1100M" + fi + + fi + # When is adding -client something that speeds up the JVM? + # ADD_JVM_ARG_IF_OK([-client],boot_jdk_jvmargs,[$JAVA]) + + # Test if -XX:PermSize=32m is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -XX:PermSize=32m to boot_jdk_jvmargs + FOUND_WARN=`$JAVA -XX:PermSize=32m -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -XX:PermSize=32m -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:PermSize=32m" + fi + + + # Test if -XX:MaxPermSize=160m is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -XX:MaxPermSize=160m to boot_jdk_jvmargs + FOUND_WARN=`$JAVA -XX:MaxPermSize=160m -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -XX:MaxPermSize=160m -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:MaxPermSize=160m" + fi + + + # Test if -XX:ThreadStackSize=$STACK_SIZE is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -XX:ThreadStackSize=$STACK_SIZE to boot_jdk_jvmargs + FOUND_WARN=`$JAVA -XX:ThreadStackSize=$STACK_SIZE -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -XX:ThreadStackSize=$STACK_SIZE -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:ThreadStackSize=$STACK_SIZE" + fi + + # Disable special log output when a debug build is used as Boot JDK... + + # Test if -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput to boot_jdk_jvmargs + FOUND_WARN=`$JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput" + fi + +fi + +BOOT_JDK_JVMARGS=$boot_jdk_jvmargs + + + +############################################################################### +# +# Configure the sources to use. We can add or override individual directories. +# +############################################################################### + + + +# Where are the sources. Any of these can be overridden +# using --with-override-corba and the likes. +LANGTOOLS_TOPDIR="$SRC_ROOT/langtools" +CORBA_TOPDIR="$SRC_ROOT/corba" +JAXP_TOPDIR="$SRC_ROOT/jaxp" +JAXWS_TOPDIR="$SRC_ROOT/jaxws" +HOTSPOT_TOPDIR="$SRC_ROOT/hotspot" +JDK_TOPDIR="$SRC_ROOT/jdk" + + + + + + + + + +############################################################################### +# +# Pickup additional source for a component from outside of the source root +# or override source for a component. +# + +# Check whether --with-add-source-root was given. +if test "${with_add_source_root+set}" = set; then : + withval=$with_add_source_root; +fi + + + +# Check whether --with-override-source-root was given. +if test "${with_override_source_root+set}" = set; then : + withval=$with_override_source_root; +fi + + + +# Check whether --with-adds-and-overrides was given. +if test "${with_adds_and_overrides+set}" = set; then : + withval=$with_adds_and_overrides; +fi + + +if test "x$with_adds_and_overrides" != x; then + with_add_source_root="$with_adds_and_overrides/adds" + with_override_source_root="$with_adds_and_overrides/overrides" +fi + +if test "x$with_add_source_root" != x; then + if ! test -d $with_add_source_root; then + as_fn_error $? "Trying to use a non-existant add-source-root $with_add_source_root" "$LINENO" 5 + fi + CURDIR="$PWD" + cd "$with_add_source_root" + ADD_SRC_ROOT="`pwd`" + cd "$CURDIR" + # Verify that the addon source root does not have any root makefiles. + # If it does, then it is usually an error, prevent this. + if test -f $with_add_source_root/langtools/makefiles/Makefile || \ + test -f $with_add_source_root/langtools/make/Makefile; then + as_fn_error $? "Your add source root seems to contain a full langtools repo! An add source root should only contain additional sources." "$LINENO" 5 + fi + if test -f $with_add_source_root/corba/makefiles/Makefile || \ + test -f $with_add_source_root/corba/make/Makefile; then + as_fn_error $? "Your add source root seems to contain a full corba repo! An add source root should only contain additional sources." "$LINENO" 5 + fi + if test -f $with_add_source_root/jaxp/makefiles/Makefile || \ + test -f $with_add_source_root/jaxp/make/Makefile; then + as_fn_error $? "Your add source root seems to contain a full jaxp repo! An add source root should only contain additional sources." "$LINENO" 5 + fi + if test -f $with_add_source_root/jaxws/makefiles/Makefile || \ + test -f $with_add_source_root/jaxws/make/Makefile; then + as_fn_error $? "Your add source root seems to contain a full jaxws repo! An add source root should only contain additional sources." "$LINENO" 5 + fi + if test -f $with_add_source_root/hotspot/makefiles/Makefile || \ + test -f $with_add_source_root/hotspot/make/Makefile; then + as_fn_error $? "Your add source root seems to contain a full hotspot repo! An add source root should only contain additional sources." "$LINENO" 5 + fi + if test -f $with_add_source_root/jdk/makefiles/Makefile || \ + test -f $with_add_source_root/jdk/make/Makefile; then + as_fn_error $? "Your add source root seems to contain a full JDK repo! An add source root should only contain additional sources." "$LINENO" 5 + fi +fi + + +if test "x$with_override_source_root" != x; then + if ! test -d $with_override_source_root; then + as_fn_error $? "Trying to use a non-existant override-source-root $with_override_source_root" "$LINENO" 5 + fi + CURDIR="$PWD" + cd "$with_override_source_root" + OVERRIDE_SRC_ROOT="`pwd`" + cd "$CURDIR" + if test -f $with_override_source_root/langtools/makefiles/Makefile || \ + test -f $with_override_source_root/langtools/make/Makefile; then + as_fn_error $? "Your override source root seems to contain a full langtools repo! An override source root should only contain sources that override." "$LINENO" 5 + fi + if test -f $with_override_source_root/corba/makefiles/Makefile || \ + test -f $with_override_source_root/corba/make/Makefile; then + as_fn_error $? "Your override source root seems to contain a full corba repo! An override source root should only contain sources that override." "$LINENO" 5 + fi + if test -f $with_override_source_root/jaxp/makefiles/Makefile || \ + test -f $with_override_source_root/jaxp/make/Makefile; then + as_fn_error $? "Your override source root seems to contain a full jaxp repo! An override source root should only contain sources that override." "$LINENO" 5 + fi + if test -f $with_override_source_root/jaxws/makefiles/Makefile || \ + test -f $with_override_source_root/jaxws/make/Makefile; then + as_fn_error $? "Your override source root seems to contain a full jaxws repo! An override source root should only contain sources that override." "$LINENO" 5 + fi + if test -f $with_override_source_root/hotspot/makefiles/Makefile || \ + test -f $with_override_source_root/hotspot/make/Makefile; then + as_fn_error $? "Your override source root seems to contain a full hotspot repo! An override source root should only contain sources that override." "$LINENO" 5 + fi + if test -f $with_override_source_root/jdk/makefiles/Makefile || \ + test -f $with_override_source_root/jdk/make/Makefile; then + as_fn_error $? "Your override source root seems to contain a full JDK repo! An override source root should only contain sources that override." "$LINENO" 5 + fi +fi + + +############################################################################### +# +# Override a repo completely, this is used for example when you have 3 small +# development sandboxes of the langtools sources and want to avoid having 3 full +# OpenJDK sources checked out on disk. +# +# Assuming that the 3 langtools sandboxes are located here: +# /home/fredrik/sandbox1/langtools +# /home/fredrik/sandbox2/langtools +# /home/fredrik/sandbox3/langtools +# +# From the source root you create build subdirs manually: +# mkdir -p build1 build2 build3 +# in each build directory run: +# (cd build1 && ../configure --with-override-langtools=/home/fredrik/sandbox1 && make) +# (cd build2 && ../configure --with-override-langtools=/home/fredrik/sandbox2 && make) +# (cd build3 && ../configure --with-override-langtools=/home/fredrik/sandbox3 && make) +# + + +# Check whether --with-override-langtools was given. +if test "${with_override_langtools+set}" = set; then : + withval=$with_override_langtools; +fi + + + +# Check whether --with-override-corba was given. +if test "${with_override_corba+set}" = set; then : + withval=$with_override_corba; +fi + + + +# Check whether --with-override-jaxp was given. +if test "${with_override_jaxp+set}" = set; then : + withval=$with_override_jaxp; +fi + + + +# Check whether --with-override-jaxws was given. +if test "${with_override_jaxws+set}" = set; then : + withval=$with_override_jaxws; +fi + + + +# Check whether --with-override-hotspot was given. +if test "${with_override_hotspot+set}" = set; then : + withval=$with_override_hotspot; +fi + + + +# Check whether --with-override-jdk was given. +if test "${with_override_jdk+set}" = set; then : + withval=$with_override_jdk; +fi + + +if test "x$with_override_langtools" != x; then + CURDIR="$PWD" + cd "$with_override_langtools" + LANGTOOLS_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $LANGTOOLS_TOPDIR/makefiles/Makefile; then + as_fn_error $? "You have to override langtools with a full langtools repo!" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if langtools should be overridden" >&5 +$as_echo_n "checking if langtools should be overridden... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $LANGTOOLS_TOPDIR" >&5 +$as_echo "yes with $LANGTOOLS_TOPDIR" >&6; } +fi +if test "x$with_override_corba" != x; then + CURDIR="$PWD" + cd "$with_override_corba" + CORBA_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $CORBA_TOPDIR/makefiles/Makefile; then + as_fn_error $? "You have to override corba with a full corba repo!" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if corba should be overridden" >&5 +$as_echo_n "checking if corba should be overridden... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $CORBA_TOPDIR" >&5 +$as_echo "yes with $CORBA_TOPDIR" >&6; } +fi +if test "x$with_override_jaxp" != x; then + CURDIR="$PWD" + cd "$with_override_jaxp" + JAXP_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $JAXP_TOPDIR/makefiles/Makefile; then + as_fn_error $? "You have to override jaxp with a full jaxp repo!" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if jaxp should be overridden" >&5 +$as_echo_n "checking if jaxp should be overridden... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JAXP_TOPDIR" >&5 +$as_echo "yes with $JAXP_TOPDIR" >&6; } +fi +if test "x$with_override_jaxws" != x; then + CURDIR="$PWD" + cd "$with_override_jaxws" + JAXWS_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $JAXWS_TOPDIR/makefiles/Makefile; then + as_fn_error $? "You have to override jaxws with a full jaxws repo!" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if jaxws should be overridden" >&5 +$as_echo_n "checking if jaxws should be overridden... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JAXWS_TOPDIR" >&5 +$as_echo "yes with $JAXWS_TOPDIR" >&6; } +fi +if test "x$with_override_hotspot" != x; then + CURDIR="$PWD" + cd "$with_override_hotspot" + HOTSPOT_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $HOTSPOT_TOPDIR/make/Makefile && \ + ! test -f $HOTSPOT_TOPDIR/makefiles/Makefile; then + as_fn_error $? "You have to override hotspot with a full hotspot repo!" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if hotspot should be overridden" >&5 +$as_echo_n "checking if hotspot should be overridden... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $HOTSPOT_TOPDIR" >&5 +$as_echo "yes with $HOTSPOT_TOPDIR" >&6; } +fi +if test "x$with_override_jdk" != x; then + CURDIR="$PWD" + cd "$with_override_jdk" + JDK_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $JDK_TOPDIR/makefiles/Makefile; then + as_fn_error $? "You have to override JDK with a full JDK repo!" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if JDK should be overridden" >&5 +$as_echo_n "checking if JDK should be overridden... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JDK_TOPDIR" >&5 +$as_echo "yes with $JDK_TOPDIR" >&6; } +fi + + + +LANGTOOLS_OUTPUTDIR="$OUTPUT_ROOT/langtools" +CORBA_OUTPUTDIR="$OUTPUT_ROOT/corba" +JAXP_OUTPUTDIR="$OUTPUT_ROOT/jaxp" +JAXWS_OUTPUTDIR="$OUTPUT_ROOT/jaxws" +HOTSPOT_OUTPUTDIR="$OUTPUT_ROOT/hotspot" +JDK_OUTPUTDIR="$OUTPUT_ROOT/jdk" +IMAGES_OUTPUTDIR="$OUTPUT_ROOT/images" + + + + + + + + + +LANGTOOLS_DIST="$OUTPUT_ROOT/langtools/dist" +CORBA_DIST="$OUTPUT_ROOT/corba/dist" +JAXP_DIST="$OUTPUT_ROOT/jaxp/dist" +JAXWS_DIST="$OUTPUT_ROOT/jaxws/dist" +HOTSPOT_DIST="$OUTPUT_ROOT/hotspot/dist" + + + + + + + + +############################################################################### +# +# Setup the toolchain (compilers etc), i.e. the tools that need to be +# cross-compilation aware. +# +############################################################################### + + +############################################################################### +# +# Configure the development tool paths and potential sysroot. +# +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +DEVKIT= +SYS_ROOT=/ + + +# The option used to specify the target .o,.a or .so file. +# When compiling, how to specify the to be created object file. +CC_OUT_OPTION='-o$(SPACE)' +# When linking, how to specify the to be created executable. +EXE_OUT_OPTION='-o$(SPACE)' +# When linking, how to specify the to be created dynamically linkable library. +LD_OUT_OPTION='-o$(SPACE)' +# When archiving, how to specify the to be create static archive for object files. +AR_OUT_OPTION='rcs$(SPACE)' + + + + + + + +# Check if the VS env variables were setup prior to running configure. +# If not, then find vcvarsall.bat and run it automatically, and integrate +# the set env variables into the spec file. +SETUPDEVENV="# No special vars" +if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + # If vcvarsall.bat has been run, then VCINSTALLDIR is set. + if test "x$VCINSTALLDIR" != x; then + # No further setup is needed. The build will happen from this kind + # of shell. + SETUPDEVENV="# This spec file expects that you are running bash from within a VS command prompt." + # Make sure to remind you, if you forget to run make from a cygwin bash shell + # that is spawned "bash -l" from a VS command prompt. + CHECK_FOR_VCINSTALLDIR=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if you are running from within a VS command prompt" >&5 +$as_echo_n "checking if you are running from within a VS command prompt... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + # Ah, we have not yet run vcvarsall.bat/vsvars32.bat/vsvars64.bat. Lets do that. First find it. + if test "x$VS100COMNTOOLS" != x; then + VARSBAT=`find "$VS100COMNTOOLS/../.." -name vcvarsall.bat` + SEARCH_ROOT="$VS100COMNTOOLS" + else + VARSBAT=`find "$PROGRAMFILES" -name vcvarsall.bat` + SEARCH_ROOT="$PROGRAMFILES" + fi + VCPATH=`dirname "$VARSBAT"` + VCPATH=`cygpath -w "$VCPATH"` + if test "x$VARSBAT" = x || test ! -d "$VCPATH"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can find the VS installation" >&5 +$as_echo_n "checking if we can find the VS installation... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "Tried to find a VS installation using both $SEARCH_ROOT but failed. Please run \"c:\\cygwin\\bin\\bash.exe -l\" from a VS command prompt and then run configure/make from there." "$LINENO" 5 + fi + case "$LEGACY_OPENJDK_TARGET_CPU1" in + i?86) + VARSBAT_ARCH=x86 + ;; + *) + VARSBAT_ARCH=$LEGACY_OPENJDK_TARGET_CPU1 + ;; + esac + # Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat + cd $OUTPUT_ROOT + bash $SRC_ROOT/common/bin/extractvcvars.sh "$VARSBAT" "$VARSBAT_ARCH" + cd $CURDIR + if test ! -s $OUTPUT_ROOT/localdevenv.sh || test ! -s $OUTPUT_ROOT/localdevenv.gmk; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can extract the needed env variables" >&5 +$as_echo_n "checking if we can extract the needed env variables... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "Could not succesfully extract the env variables needed for the VS setup. Please run \"c:\\cygwin\\bin\\bash.exe -l\" from a VS command prompt and then run configure/make from there." "$LINENO" 5 + fi + # Now set all paths and other env variables. This will allow the rest of + # the configure script to find and run the compiler in the proper way. + . $OUTPUT_ROOT/localdevenv.sh + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can find the VS installation" >&5 +$as_echo_n "checking if we can find the VS installation... " >&6; } + if test "x$VCINSTALLDIR" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $VCINSTALLDIR" >&5 +$as_echo "$VCINSTALLDIR" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "Could not find VS installation. Please install. If you are sure you have installed VS, then please run \"c:\\cygwin\\bin\\bash.exe -l\" from a VS command prompt and then run configure/make from there." "$LINENO" 5 + fi + CHECK_FOR_VCINSTALLDIR=no + SETUPDEVENV="include $OUTPUT_ROOT/localdevenv.gmk" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for msvcr100.dll" >&5 +$as_echo_n "checking for msvcr100.dll... " >&6; } + +# Check whether --with-msvcr100dll was given. +if test "${with_msvcr100dll+set}" = set; then : + withval=$with_msvcr100dll; +fi + + if test "x$with_msvcr100dll" != x; then + MSVCR100DLL="$with_msvcr100dll" + else + if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then + MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | grep x64 | head --lines 1` + else + MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | grep x86 | grep -v ia64 | grep -v x64 | head --lines 1` + if test "x$MSVCR100DLL" = x; then + MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | head --lines 1` + fi + fi + fi + if test "x$MSVCR100DLL" = x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "Could not find msvcr100.dll !" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVCR100DLL" >&5 +$as_echo "$MSVCR100DLL" >&6; } + + # Fail with message the path to msvcr100.dll if var MSVCR100DLL contains a path with no spaces in it. + # Unless on Windows, where we can rewrite the path. + HAS_SPACE=`echo "$MSVCR100DLL" | grep " "` + if test "x$HAS_SPACE" != x; then + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + MSVCR100DLL=`$CYGPATH -s -m -a "$MSVCR100DLL"` + MSVCR100DLL=`$CYGPATH -u "$MSVCR100DLL"` + else + as_fn_error $? "You cannot have spaces in the path to msvcr100.dll! \"$MSVCR100DLL\"" "$LINENO" 5 + fi + fi + + fi +fi + + + + +# Locate the actual tools + +# If --build AND --host is set, then the configure script will find any +# cross compilation tools in the PATH. Cross compilation tools +# follows the cross compilation standard where they are prefixed with ${host}. +# For example the binary i686-sun-solaris2.10-gcc +# will cross compile for i686-sun-solaris2.10 +# If neither of build and host is not set, then build=host and the +# default compiler found in the path will be used. +# Setting only --host, does not seem to be really supported. +# Please set both --build and --host if you want to cross compile. + +DEFINE_CROSS_COMPILE_ARCH="" +HOSTCC="" +HOSTCXX="" +HOSTLD="" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if this is a cross compile" >&5 +$as_echo_n "checking if this is a cross compile... " >&6; } +if test "x$OPENJDK_BUILD_SYSTEM" != "x$OPENJDK_TARGET_SYSTEM"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, from $OPENJDK_BUILD_SYSTEM to $OPENJDK_TARGET_SYSTEM" >&5 +$as_echo "yes, from $OPENJDK_BUILD_SYSTEM to $OPENJDK_TARGET_SYSTEM" >&6; } + # We have detected a cross compile! + DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$LEGACY_OPENJDK_TARGET_CPU1" + # Now we to find a C/C++ compiler that can build executables for the build + # platform. We can't use the AC_PROG_CC macro, since it can only be used + # once. + for ac_prog in cl cc gcc +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_HOSTCC+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $HOSTCC in + [\\/]* | ?:[\\/]*) + ac_cv_path_HOSTCC="$HOSTCC" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_HOSTCC="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +HOSTCC=$ac_cv_path_HOSTCC +if test -n "$HOSTCC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOSTCC" >&5 +$as_echo "$HOSTCC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$HOSTCC" && break +done + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$HOSTCC" + car="${tmp%% *}" + tmp="$HOSTCC EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + HOSTCC="$car ${cdr% *}" + else + HOSTCC="$car" + fi + + for ac_prog in cl CC g++ +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_HOSTCXX+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $HOSTCXX in + [\\/]* | ?:[\\/]*) + ac_cv_path_HOSTCXX="$HOSTCXX" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_HOSTCXX="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +HOSTCXX=$ac_cv_path_HOSTCXX +if test -n "$HOSTCXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOSTCXX" >&5 +$as_echo "$HOSTCXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$HOSTCXX" && break +done + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$HOSTCXX" + car="${tmp%% *}" + tmp="$HOSTCXX EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + HOSTCXX="$car ${cdr% *}" + else + HOSTCXX="$car" + fi + + # Extract the first word of "ld", so it can be a program name with args. +set dummy ld; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_HOSTLD+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $HOSTLD in + [\\/]* | ?:[\\/]*) + ac_cv_path_HOSTLD="$HOSTLD" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_HOSTLD="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +HOSTLD=$ac_cv_path_HOSTLD +if test -n "$HOSTLD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOSTLD" >&5 +$as_echo "$HOSTLD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$HOSTLD" + car="${tmp%% *}" + tmp="$HOSTLD EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + HOSTLD="$car ${cdr% *}" + else + HOSTLD="$car" + fi + + # Building for the build platform should be easy. Therefore + # we do not need any linkers or assemblers etc. +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + +# You can force the sys-root if the sys-root encoded into the cross compiler tools +# is not correct. + +# Check whether --with-sys-root was given. +if test "${with_sys_root+set}" = set; then : + withval=$with_sys_root; +fi + + +if test "x$with_sys_root" != x; then + SYS_ROOT=$with_sys_root +fi + +# If a devkit is found on the builddeps server, then prepend its path to the +# PATH variable. If there are cross compilers available in the devkit, these +# will be found by AC_PROG_CC et al. + + + if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then + # Source the builddeps file again, to make sure it uses the latest variables! + . $builddepsfile + # Look for a target and build machine specific resource! + eval resource=\${builddep_devkit_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}} + if test "x$resource" = x; then + # Ok, lets instead look for a target specific resource + eval resource=\${builddep_devkit_TARGET_${rewritten_target_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a build specific resource + eval resource=\${builddep_devkit_BUILD_${rewritten_build_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a generic resource + # (The devkit comes from M4 and not the shell, thus no need for eval here.) + resource=${builddep_devkit} + fi + if test "x$resource" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for devkit" >&5 +$as_echo "$as_me: Using builddeps $resource for devkit" >&6;} + # If the resource in the builddeps.conf file is an existing directory, + # for example /java/linux/cups + if test -d ${resource}; then + depdir=${resource} + else + +# devkit is for example mymodule +# $resource is for example libs/general/libmymod_1_2_3.zip +# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps +# $with_builddeps_dir is for example /localhome/builddeps +# depdir is the name of the variable into which we store the depdir, eg MYMOD +# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and +# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 + filename=`basename $resource` + filebase=`echo $filename | sed 's/\.[^\.]*$//'` + filebase=${filename%%.*} + extension=${filename#*.} + installdir=$with_builddeps_dir/$filebase + if test ! -f $installdir/$filename.unpacked; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency devkit from $with_builddeps_server/$resource and installing into $installdir" >&5 +$as_echo "$as_me: Downloading build dependency devkit from $with_builddeps_server/$resource and installing into $installdir" >&6;} + if test ! -d $installdir; then + mkdir -p $installdir + fi + if test ! -d $installdir; then + as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 + fi + tmpfile=`mktemp $installdir/devkit.XXXXXXXXX` + touch $tmpfile + if test ! -f $tmpfile; then + as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 + fi + + # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip + # $tmpfile is the local file name for the downloaded file. + VALID_TOOL=no + if test "x$BDEPS_FTP" = xwget; then + VALID_TOOL=yes + wget -O $tmpfile $with_builddeps_server/$resource + fi + if test "x$BDEPS_FTP" = xlftp; then + VALID_TOOL=yes + lftp -c "get $with_builddeps_server/$resource -o $tmpfile" + fi + if test "x$BDEPS_FTP" = xftp; then + VALID_TOOL=yes + FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` + FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` + FTPUSERPWD=${FTPSERVER%%@*} + if test "x$FTPSERVER" != "x$FTPUSERPWD"; then + FTPUSER=${userpwd%%:*} + FTPPWD=${userpwd#*@} + FTPSERVER=${FTPSERVER#*@} + else + FTPUSER=ftp + FTPPWD=ftp + fi + # the "pass" command does not work on some + # ftp clients (read ftp.exe) but if it works, + # passive mode is better! + (\ + echo "user $FTPUSER $FTPPWD" ;\ + echo "pass" ;\ + echo "bin" ;\ + echo "get $FTPPATH $tmpfile" ;\ + ) | ftp -in $FTPSERVER + fi + if test "x$VALID_TOOL" != xyes; then + as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 + fi + + mv $tmpfile $installdir/$filename + if test ! -s $installdir/$filename; then + as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 + fi + case "$extension" in + zip) echo "Unzipping $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) + ;; + tar.gz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + tgz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 + ;; + esac + fi + if test -f $installdir/$filename.unpacked; then + depdir=$installdir + fi + + fi + # Source the builddeps file again, because in the previous command, the depdir + # was updated to point at the current build dependency install directory. + . $builddepsfile + # Now extract variables from the builddeps.conf files. + theroot=${builddep_devkit_ROOT} + thecflags=${builddep_devkit_CFLAGS} + thelibs=${builddep_devkit_LIBS} + if test "x$depdir" = x; then + as_fn_error $? "Could not download build dependency devkit" "$LINENO" 5 + fi + DEVKIT=$depdir + if test "x$theroot" != x; then + DEVKIT="$theroot" + fi + if test "x$thecflags" != x; then + DEVKIT_CFLAGS="$thecflags" + fi + if test "x$thelibs" != x; then + DEVKIT_LIBS="$thelibs" + fi + # Found devkit + PATH="$DEVKIT/bin:$PATH" + SYS_ROOT="$DEVKIT/${rewritten_target}/sys-root" + if test "x$x_includes" = "xNONE"; then + x_includes="$SYS_ROOT/usr/include/X11" + fi + if test "x$x_libraries" = "xNONE"; then + x_libraries="$SYS_ROOT/usr/lib" + fi + + + fi + + fi + + +if test "x$SYS_ROOT" != "x/" ; then + CFLAGS="--sysroot=$SYS_ROOT $CFLAGS" + CXXFLAGS="--sysroot=$SYS_ROOT $CXXFLAGS" + OBJCFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" + OBJCXXFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" + CPPFLAGS="--sysroot=$SYS_ROOT $CPPFLAGS" + LDFLAGS="--sysroot=$SYS_ROOT $LDFLAGS" +fi + +# Store the CFLAGS etal passed to the configure script. +ORG_CFLAGS="$CFLAGS" +ORG_CXXFLAGS="$CXXFLAGS" +ORG_OBJCFLAGS="$OBJCFLAGS" + + +# Check whether --with-tools-dir was given. +if test "${with_tools_dir+set}" = set; then : + withval=$with_tools_dir; TOOLS_DIR=$with_tools_dir +fi + + + +# Check whether --with-devkit was given. +if test "${with_devkit+set}" = set; then : + withval=$with_devkit; + if test "x$with_sys_root" != x; then + as_fn_error $? "Cannot specify both --with-devkit and --with-sys-root at the same time" "$LINENO" 5 + fi + if test "x$with_tools_dir" != x; then + as_fn_error $? "Cannot specify both --with-devkit and --with-tools-dir at the same time" "$LINENO" 5 + fi + TOOLS_DIR=$with_devkit/bin + SYS_ROOT=$with_devkit/$host_alias/libc + +fi + + +# autoconf magic only relies on PATH, so update it if tools dir is specified +OLD_PATH="$PATH" +if test "x$TOOLS_DIR" != x; then + PATH=$TOOLS_DIR:$PATH +fi + +# gcc is almost always present, but on Windows we +# prefer cl.exe and on Solaris we prefer CC. +# Thus test for them in this order. +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +if test -n "$ac_tool_prefix"; then + for ac_prog in cl cc gcc + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_CC+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_CC="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in cl cc gcc +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_ac_ct_CC="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CC" && break +done + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi + + +test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "no acceptable C compiler found in \$PATH +See \`config.log' for more details" "$LINENO" 5 ; } + +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" +# Try to create an executable without -o first, disregard a.out. +# It will help us diagnose broken compilers, and finding out an intuition +# of exeext. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 +$as_echo_n "checking whether the C compiler works... " >&6; } +ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` + +# The possible output files: +ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" + +ac_rmfiles= +for ac_file in $ac_files +do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + * ) ac_rmfiles="$ac_rmfiles $ac_file";; + esac +done +rm -f $ac_rmfiles + +if { { ac_try="$ac_link_default" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link_default") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. +# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' +# in a Makefile. We should not override ac_cv_exeext if it was cached, +# so that the user can short-circuit this test for compilers unknown to +# Autoconf. +for ac_file in $ac_files '' +do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) + ;; + [ab].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + then :; else + ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + fi + # We set ac_cv_exeext here because the later test for it is not + # safe: cross compilers may not add the suffix if given an `-o' + # argument, so we may need to know it at that point already. + # Even if this section looks crufty: it has the advantage of + # actually working. + break;; + * ) + break;; + esac +done +test "$ac_cv_exeext" = no && ac_cv_exeext= + +else + ac_file='' +fi +if test -z "$ac_file"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +$as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error 77 "C compiler cannot create executables +See \`config.log' for more details" "$LINENO" 5 ; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 +$as_echo_n "checking for C compiler default output file name... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 +$as_echo "$ac_file" >&6; } +ac_exeext=$ac_cv_exeext + +rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 +$as_echo_n "checking for suffix of executables... " >&6; } +if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + break;; + * ) break;; + esac +done +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details" "$LINENO" 5 ; } +fi +rm -f conftest conftest$ac_cv_exeext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 +$as_echo "$ac_cv_exeext" >&6; } + +rm -f conftest.$ac_ext +EXEEXT=$ac_cv_exeext +ac_exeext=$EXEEXT +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +FILE *f = fopen ("conftest.out", "w"); + return ferror (f) || fclose (f) != 0; + + ; + return 0; +} +_ACEOF +ac_clean_files="$ac_clean_files conftest.out" +# Check that the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 +$as_echo_n "checking whether we are cross compiling... " >&6; } +if test "$cross_compiling" != yes; then + { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if { ac_try='./conftest$ac_cv_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details" "$LINENO" 5 ; } + fi + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 +$as_echo "$cross_compiling" >&6; } + +rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 +$as_echo_n "checking for suffix of object files... " >&6; } +if test "${ac_cv_objext+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.o conftest.obj +if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + for ac_file in conftest.o conftest.obj conftest.*; do + test -f "$ac_file" || continue; + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of object files: cannot compile +See \`config.log' for more details" "$LINENO" 5 ; } +fi +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 +$as_echo "$ac_cv_objext" >&6; } +OBJEXT=$ac_cv_objext +ac_objext=$OBJEXT +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 +$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } +if test "${ac_cv_c_compiler_gnu+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +$as_echo "$ac_cv_c_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +$as_echo_n "checking whether $CC accepts -g... " >&6; } +if test "${ac_cv_prog_cc_g+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +else + CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + +else + ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +$as_echo "$ac_cv_prog_cc_g" >&6; } +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 +$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } +if test "${ac_cv_prog_cc_c89+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_prog_cc_c89=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) 'x' +int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ + -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_c89=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext + test "x$ac_cv_prog_cc_c89" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC + +fi +# AC_CACHE_VAL +case "x$ac_cv_prog_cc_c89" in + x) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; + xno) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; + *) + CC="$CC $ac_cv_prog_cc_c89" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; +esac +if test "x$ac_cv_prog_cc_c89" != xno; then : + +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +if test "x$CC" = x; then + + # Print a helpful message on how to acquire the necessary build dependency. + # devkit is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=devkit + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + as_fn_error $? "Could not find a compiler. $HELP_MSG" "$LINENO" 5 +fi +if test "x$CC" = xcc && test "x$OPENJDK_BUILD_OS" = xmacosx; then + # Do not use cc on MacOSX use gcc instead. + CC="gcc" +fi + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$CC" + car="${tmp%% *}" + tmp="$CC EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + CC="$car ${cdr% *}" + else + CC="$car" + fi + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +if test -z "$CXX"; then + if test -n "$CCC"; then + CXX=$CCC + else + if test -n "$ac_tool_prefix"; then + for ac_prog in cl CC g++ + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_CXX+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CXX"; then + ac_cv_prog_CXX="$CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CXX=$ac_cv_prog_CXX +if test -n "$CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +$as_echo "$CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CXX" && break + done +fi +if test -z "$CXX"; then + ac_ct_CXX=$CXX + for ac_prog in cl CC g++ +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CXX"; then + ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_ac_ct_CXX="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CXX=$ac_cv_prog_ac_ct_CXX +if test -n "$ac_ct_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +$as_echo "$ac_ct_CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CXX" && break +done + + if test "x$ac_ct_CXX" = x; then + CXX="g++" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CXX=$ac_ct_CXX + fi +fi + + fi +fi +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 +$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } +if test "${ac_cv_cxx_compiler_gnu+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_cxx_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GXX=yes +else + GXX= +fi +ac_test_CXXFLAGS=${CXXFLAGS+set} +ac_save_CXXFLAGS=$CXXFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +$as_echo_n "checking whether $CXX accepts -g... " >&6; } +if test "${ac_cv_prog_cxx_g+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +else + CXXFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + +else + ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_cxx_werror_flag=$ac_save_cxx_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +$as_echo "$ac_cv_prog_cxx_g" >&6; } +if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS=$ac_save_CXXFLAGS +elif test $ac_cv_prog_cxx_g = yes; then + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-g" + fi +else + if test "$GXX" = yes; then + CXXFLAGS="-O2" + else + CXXFLAGS= + fi +fi +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +if test "x$CXX" = xCC && test "x$OPENJDK_BUILD_OS" = xmacosx; then + # The found CC, even though it seems to be a g++ derivate, cannot compile + # c++ code. Override. + CXX="g++" +fi + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$CXX" + car="${tmp%% *}" + tmp="$CXX EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + CXX="$car ${cdr% *}" + else + CXX="$car" + fi + + +if test "x$CXX" = x || test "x$CC" = x; then + + # Print a helpful message on how to acquire the necessary build dependency. + # devkit is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=devkit + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + as_fn_error $? "Could not find the needed compilers! $HELP_MSG " "$LINENO" 5 +fi + +if test "x$OPENJDK_BUILD_OS" != xwindows; then + ac_ext=m +ac_cpp='$OBJCPP $CPPFLAGS' +ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_objc_compiler_gnu +if test -n "$ac_tool_prefix"; then + for ac_prog in gcc objcc objc cc CC + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_OBJC+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OBJC"; then + ac_cv_prog_OBJC="$OBJC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_OBJC="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OBJC=$ac_cv_prog_OBJC +if test -n "$OBJC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJC" >&5 +$as_echo "$OBJC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$OBJC" && break + done +fi +if test -z "$OBJC"; then + ac_ct_OBJC=$OBJC + for ac_prog in gcc objcc objc cc CC +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_ac_ct_OBJC+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OBJC"; then + ac_cv_prog_ac_ct_OBJC="$ac_ct_OBJC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_ac_ct_OBJC="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OBJC=$ac_cv_prog_ac_ct_OBJC +if test -n "$ac_ct_OBJC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJC" >&5 +$as_echo "$ac_ct_OBJC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_OBJC" && break +done + + if test "x$ac_ct_OBJC" = x; then + OBJC="gcc" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OBJC=$ac_ct_OBJC + fi +fi + +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for Objective C compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Objective C compiler" >&5 +$as_echo_n "checking whether we are using the GNU Objective C compiler... " >&6; } +if test "${ac_cv_objc_compiler_gnu+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_objc_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_objc_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objc_compiler_gnu" >&5 +$as_echo "$ac_cv_objc_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GOBJC=yes +else + GOBJC= +fi +ac_test_OBJCFLAGS=${OBJCFLAGS+set} +ac_save_OBJCFLAGS=$OBJCFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $OBJC accepts -g" >&5 +$as_echo_n "checking whether $OBJC accepts -g... " >&6; } +if test "${ac_cv_prog_objc_g+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_save_objc_werror_flag=$ac_objc_werror_flag + ac_objc_werror_flag=yes + ac_cv_prog_objc_g=no + OBJCFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_objc_try_compile "$LINENO"; then : + ac_cv_prog_objc_g=yes +else + OBJCFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_objc_try_compile "$LINENO"; then : + +else + ac_objc_werror_flag=$ac_save_objc_werror_flag + OBJCFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_objc_try_compile "$LINENO"; then : + ac_cv_prog_objc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_objc_werror_flag=$ac_save_objc_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_objc_g" >&5 +$as_echo "$ac_cv_prog_objc_g" >&6; } +if test "$ac_test_OBJCFLAGS" = set; then + OBJCFLAGS=$ac_save_OBJCFLAGS +elif test $ac_cv_prog_objc_g = yes; then + if test "$GOBJC" = yes; then + OBJCFLAGS="-g -O2" + else + OBJCFLAGS="-g" + fi +else + if test "$GOBJC" = yes; then + OBJCFLAGS="-O2" + else + OBJCFLAGS= + fi +fi +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$OBJC" + car="${tmp%% *}" + tmp="$OBJC EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + OBJC="$car ${cdr% *}" + else + OBJC="$car" + fi + +else + OBJC= +fi + +# Restore the flags to the user specified values. +# This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2" +CFLAGS="$ORG_CFLAGS" +CXXFLAGS="$ORG_CXXFLAGS" +OBJCFLAGS="$ORG_OBJCFLAGS" + +# If we are not cross compiling, use the same compilers for +# building the build platform executables. +if test "x$DEFINE_CROSS_COMPILE_ARCH" = x; then + HOSTCC="$CC" + HOSTCXX="$CXX" +fi + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ld", so it can be a program name with args. +set dummy ${ac_tool_prefix}ld; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_LD+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$LD"; then + ac_cv_prog_LD="$LD" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_LD="${ac_tool_prefix}ld" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +LD=$ac_cv_prog_LD +if test -n "$LD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_LD"; then + ac_ct_LD=$LD + # Extract the first word of "ld", so it can be a program name with args. +set dummy ld; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_ac_ct_LD+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_LD"; then + ac_cv_prog_ac_ct_LD="$ac_ct_LD" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_ac_ct_LD="ld" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_LD=$ac_cv_prog_ac_ct_LD +if test -n "$ac_ct_LD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LD" >&5 +$as_echo "$ac_ct_LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_LD" = x; then + LD="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + LD=$ac_ct_LD + fi +else + LD="$ac_cv_prog_LD" +fi + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$LD" + car="${tmp%% *}" + tmp="$LD EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + LD="$car ${cdr% *}" + else + LD="$car" + fi + +LD="$CC" +LDEXE="$CC" +LDCXX="$CXX" +LDEXECXX="$CXX" +# LDEXE is the linker to use, when creating executables. + +# Linking C++ libraries. + +# Linking C++ executables. + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. +set dummy ${ac_tool_prefix}ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_AR+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_AR="${ac_tool_prefix}ar" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +$as_echo "$AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_AR"; then + ac_ct_AR=$AR + # Extract the first word of "ar", so it can be a program name with args. +set dummy ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_ac_ct_AR+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_ac_ct_AR="ar" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +$as_echo "$ac_ct_AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_AR" = x; then + AR="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AR=$ac_ct_AR + fi +else + AR="$ac_cv_prog_AR" +fi + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$AR" + car="${tmp%% *}" + tmp="$AR EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + AR="$car ${cdr% *}" + else + AR="$car" + fi + +if test "x$OPENJDK_BUILD_OS" = xmacosx; then + ARFLAGS="-r" +else + ARFLAGS="" +fi + + +COMPILER_NAME=gcc +COMPILER_TYPE=CC +if test "x$OPENJDK_BUILD_OS" = xwindows; then : + + # For now, assume that we are always compiling using cl.exe. + CC_OUT_OPTION=-Fo + EXE_OUT_OPTION=-out: + LD_OUT_OPTION=-out: + AR_OUT_OPTION=-out: + # On Windows, reject /usr/bin/link, which is a cygwin + # program for something completely different. + # Extract the first word of "link", so it can be a program name with args. +set dummy link; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_WINLD+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$WINLD"; then + ac_cv_prog_WINLD="$WINLD" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/link"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_WINLD="link" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_WINLD + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set WINLD to just the basename; use the full file name. + shift + ac_cv_prog_WINLD="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +WINLD=$ac_cv_prog_WINLD +if test -n "$WINLD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINLD" >&5 +$as_echo "$WINLD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + # Since we must ignore the first found link, WINLD will contain + # the full path to the link.exe program. + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$WINLD" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$WINLD"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + WINLD="$tmp" + + LD="$WINLD" + LDEXE="$WINLD" + LDCXX="$WINLD" + LDEXECXX="$WINLD" + # Set HOSTLD to same as LD until we fully support cross compilation + # on windows. + HOSTLD="$WINLD" + + # Extract the first word of "mt", so it can be a program name with args. +set dummy mt; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_MT+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$MT"; then + ac_cv_prog_MT="$MT" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/mt"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_MT="mt" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_MT + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set MT to just the basename; use the full file name. + shift + ac_cv_prog_MT="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +MT=$ac_cv_prog_MT +if test -n "$MT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MT" >&5 +$as_echo "$MT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$MT" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$MT"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + MT="$tmp" + + # The resource compiler + # Extract the first word of "rc", so it can be a program name with args. +set dummy rc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_RC+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$RC"; then + ac_cv_prog_RC="$RC" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/rc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_RC="rc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_RC + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set RC to just the basename; use the full file name. + shift + ac_cv_prog_RC="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +RC=$ac_cv_prog_RC +if test -n "$RC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RC" >&5 +$as_echo "$RC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$RC" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$RC"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + RC="$tmp" + + + RC_FLAGS="-nologo /l 0x409 /r" + if test "x$VARIANT" = xOPT; then : + + RC_FLAGS="$RC_FLAGS -d NDEBUG" + +fi + JDK_UPDATE_VERSION_NOTNULL=$JDK_UPDATE_VERSION + if test "x$JDK_UPDATE_VERSION" = x; then : + + JDK_UPDATE_VERSION_NOTNULL=0 + +fi + RC_FLAGS="$RC_FLAGS -d \"JDK_BUILD_ID=$FULL_VERSION\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_COMPANY=$COMPANY_NAME\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_COMPONENT=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME binary\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_VER=$JDK_MINOR_VERSION.$JDK_MICRO_VERSION.$JDK_UPDATE_VERSION_NOTNULL.$COOKED_BUILD_NUMBER\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_NAME=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME $JDK_MINOR_VERSION $JDK_UPDATE_META_TAG\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_FVER=$JDK_MINOR_VERSION,$JDK_MICRO_VERSION,$JDK_UPDATE_VERSION_NOTNULL,$COOKED_BUILD_NUMBER\"" + + # lib.exe is used to create static libraries. + # Extract the first word of "lib", so it can be a program name with args. +set dummy lib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_WINAR+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$WINAR"; then + ac_cv_prog_WINAR="$WINAR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_WINAR="lib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +WINAR=$ac_cv_prog_WINAR +if test -n "$WINAR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINAR" >&5 +$as_echo "$WINAR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$WINAR" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$WINAR"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + WINAR="$tmp" + + AR="$WINAR" + ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT" + + # Extract the first word of "dumpbin", so it can be a program name with args. +set dummy dumpbin; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_DUMPBIN+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DUMPBIN"; then + ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_DUMPBIN="dumpbin" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DUMPBIN=$ac_cv_prog_DUMPBIN +if test -n "$DUMPBIN"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 +$as_echo "$DUMPBIN" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$DUMPBIN" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$DUMPBIN"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + DUMPBIN="$tmp" + + + COMPILER_TYPE=CL + CCXXFLAGS="$CCXXFLAGS -nologo" + +fi + + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 +$as_echo_n "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if test "${ac_cv_prog_CPP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 +$as_echo "$CPP" >&6; } +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5 ; } +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$CPP" + car="${tmp%% *}" + tmp="$CPP EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + CPP="$car ${cdr% *}" + else + CPP="$car" + fi + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 +$as_echo_n "checking how to run the C++ preprocessor... " >&6; } +if test -z "$CXXCPP"; then + if test "${ac_cv_prog_CXXCPP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CXXCPP needs to be expanded + for CXXCPP in "$CXX -E" "/lib/cpp" + do + ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CXXCPP=$CXXCPP + +fi + CXXCPP=$ac_cv_prog_CXXCPP +else + ac_cv_prog_CXXCPP=$CXXCPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 +$as_echo "$CXXCPP" >&6; } +ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5 ; } +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$CXXCPP" + car="${tmp%% *}" + tmp="$CXXCPP EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + CXXCPP="$car ${cdr% *}" + else + CXXCPP="$car" + fi + + +# for solaris we really need solaris tools, and not gnu equivalent +# these seems to normally reside in /usr/ccs/bin so add that to path before +# starting to probe +# +# NOTE: I add this /usr/ccs/bin after TOOLS but before OLD_PATH +# so that it can be overriden --with-tools-dir +if test "x$OPENJDK_BUILD_OS" = xsolaris; then + PATH="${TOOLS_DIR}:/usr/ccs/bin:${OLD_PATH}" +fi + +# Find the right assembler. +if test "x$OPENJDK_BUILD_OS" = xsolaris; then + # Extract the first word of "as", so it can be a program name with args. +set dummy as; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_AS+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $AS in + [\\/]* | ?:[\\/]*) + ac_cv_path_AS="$AS" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +AS=$ac_cv_path_AS +if test -n "$AS"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5 +$as_echo "$AS" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$AS" + car="${tmp%% *}" + tmp="$AS EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + AS="$car ${cdr% *}" + else + AS="$car" + fi + + ASFLAGS=" " +else + AS="$CC -c" + ASFLAGS=" " +fi + + + +if test "x$OPENJDK_BUILD_OS" = xsolaris; then + # Extract the first word of "nm", so it can be a program name with args. +set dummy nm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_NM+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $NM in + [\\/]* | ?:[\\/]*) + ac_cv_path_NM="$NM" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +NM=$ac_cv_path_NM +if test -n "$NM"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5 +$as_echo "$NM" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$NM" + car="${tmp%% *}" + tmp="$NM EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + NM="$car ${cdr% *}" + else + NM="$car" + fi + + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_STRIP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $STRIP in + [\\/]* | ?:[\\/]*) + ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +STRIP=$ac_cv_path_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$STRIP" + car="${tmp%% *}" + tmp="$STRIP EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + STRIP="$car ${cdr% *}" + else + STRIP="$car" + fi + + # Extract the first word of "mcs", so it can be a program name with args. +set dummy mcs; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_MCS+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $MCS in + [\\/]* | ?:[\\/]*) + ac_cv_path_MCS="$MCS" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +MCS=$ac_cv_path_MCS +if test -n "$MCS"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5 +$as_echo "$MCS" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$MCS" + car="${tmp%% *}" + tmp="$MCS EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + MCS="$car ${cdr% *}" + else + MCS="$car" + fi + +else + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}nm", so it can be a program name with args. +set dummy ${ac_tool_prefix}nm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_NM+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NM"; then + ac_cv_prog_NM="$NM" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_NM="${ac_tool_prefix}nm" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +NM=$ac_cv_prog_NM +if test -n "$NM"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5 +$as_echo "$NM" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_NM"; then + ac_ct_NM=$NM + # Extract the first word of "nm", so it can be a program name with args. +set dummy nm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_ac_ct_NM+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_NM"; then + ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_ac_ct_NM="nm" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_NM=$ac_cv_prog_ac_ct_NM +if test -n "$ac_ct_NM"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5 +$as_echo "$ac_ct_NM" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_NM" = x; then + NM="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + NM=$ac_ct_NM + fi +else + NM="$ac_cv_prog_NM" +fi + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$NM" + car="${tmp%% *}" + tmp="$NM EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + NM="$car ${cdr% *}" + else + NM="$car" + fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_STRIP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + + + # Translate "gcc -E" into "`which gcc` -E" ie + # extract the full path to the binary and at the + # same time maintain any arguments passed to it. + # The command MUST exist in the path, or else! + tmp="$STRIP" + car="${tmp%% *}" + tmp="$STRIP EOL" + cdr="${tmp#* }" + # On windows we want paths without spaces. + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + + # Translate long cygdrive or C:\sdfsf path + # into a short mixed mode path that has no + # spaces in it. + tmp="$car" + + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + tmp=`$CYGPATH -u "$car"` + tmp=`which "$tmp"` + # If file exists with .exe appended, that's the real filename + # and cygpath needs that to convert to short style path. + if test -f "${tmp}.exe"; then + tmp="${tmp}.exe" + elif test -f "${tmp}.cmd"; then + tmp="${tmp}.cmd" + fi + # Convert to C:/ mixed style path without spaces. + tmp=`$CYGPATH -s -m "$tmp"` + fi + car="$tmp" + + else + # "which" is not portable, but is used here + # because we know that the command exists! + car=`which $car` + fi + if test "x$cdr" != xEOL; then + STRIP="$car ${cdr% *}" + else + STRIP="$car" + fi + +fi + +### +# +# Check for objcopy +# +# but search for gobjcopy first... +# since I on solaris found a broken objcopy...buhh +# +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}gobjcopy", so it can be a program name with args. +set dummy ${ac_tool_prefix}gobjcopy; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_OBJCOPY+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $OBJCOPY in + [\\/]* | ?:[\\/]*) + ac_cv_path_OBJCOPY="$OBJCOPY" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_OBJCOPY="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +OBJCOPY=$ac_cv_path_OBJCOPY +if test -n "$OBJCOPY"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5 +$as_echo "$OBJCOPY" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_path_OBJCOPY"; then + ac_pt_OBJCOPY=$OBJCOPY + # Extract the first word of "gobjcopy", so it can be a program name with args. +set dummy gobjcopy; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_ac_pt_OBJCOPY+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $ac_pt_OBJCOPY in + [\\/]* | ?:[\\/]*) + ac_cv_path_ac_pt_OBJCOPY="$ac_pt_OBJCOPY" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_ac_pt_OBJCOPY="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +ac_pt_OBJCOPY=$ac_cv_path_ac_pt_OBJCOPY +if test -n "$ac_pt_OBJCOPY"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_OBJCOPY" >&5 +$as_echo "$ac_pt_OBJCOPY" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_pt_OBJCOPY" = x; then + OBJCOPY="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OBJCOPY=$ac_pt_OBJCOPY + fi +else + OBJCOPY="$ac_cv_path_OBJCOPY" +fi + +if test "x$OBJCOPY" = x; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}objcopy", so it can be a program name with args. +set dummy ${ac_tool_prefix}objcopy; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_OBJCOPY+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $OBJCOPY in + [\\/]* | ?:[\\/]*) + ac_cv_path_OBJCOPY="$OBJCOPY" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_OBJCOPY="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +OBJCOPY=$ac_cv_path_OBJCOPY +if test -n "$OBJCOPY"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5 +$as_echo "$OBJCOPY" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_path_OBJCOPY"; then + ac_pt_OBJCOPY=$OBJCOPY + # Extract the first word of "objcopy", so it can be a program name with args. +set dummy objcopy; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_ac_pt_OBJCOPY+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $ac_pt_OBJCOPY in + [\\/]* | ?:[\\/]*) + ac_cv_path_ac_pt_OBJCOPY="$ac_pt_OBJCOPY" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_ac_pt_OBJCOPY="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +ac_pt_OBJCOPY=$ac_cv_path_ac_pt_OBJCOPY +if test -n "$ac_pt_OBJCOPY"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_OBJCOPY" >&5 +$as_echo "$ac_pt_OBJCOPY" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_pt_OBJCOPY" = x; then + OBJCOPY="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OBJCOPY=$ac_pt_OBJCOPY + fi +else + OBJCOPY="$ac_cv_path_OBJCOPY" +fi + +fi + +# Restore old path without tools dir +PATH="$OLD_PATH" + + +# FIXME: Currently we must test this after paths but before flags. Fix! + +# And we can test some aspects on the target using configure macros. + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 +$as_echo_n "checking for ANSI C header files... " >&6; } +if test "${ac_cv_header_stdc+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_header_stdc=yes +else + ac_cv_header_stdc=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then : + : +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + return 2; + return 0; +} +_ACEOF +if ac_fn_cxx_try_run "$LINENO"; then : + +else + ac_cv_header_stdc=no +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 +$as_echo "$ac_cv_header_stdc" >&6; } +if test $ac_cv_header_stdc = yes; then + +$as_echo "#define STDC_HEADERS 1" >>confdefs.h + +fi + +# On IRIX 5.3, sys/types and inttypes.h are conflicting. +for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_cxx_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default +" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + + +############################################################################### +# +# Now we check if libjvm.so will use 32 or 64 bit pointers for the C/C++ code. +# (The JVM can use 32 or 64 bit Java pointers but that decision +# is made at runtime.) +# +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +OLD_CXXFLAGS="$CXXFLAGS" +if test "x$OPENJDK_TARGET_OS" != xwindows && test "x$with_target_bits" != x; then + CXXFLAGS="-m${with_target_bits} $CXXFLAGS" +fi +# The cast to long int works around a bug in the HP C Compiler +# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects +# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. +# This bug is HP SR number 8606223364. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5 +$as_echo_n "checking size of int *... " >&6; } +if test "${ac_cv_sizeof_int_p+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p" "$ac_includes_default"; then : + +else + if test "$ac_cv_type_int_p" = yes; then + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error 77 "cannot compute sizeof (int *) +See \`config.log' for more details" "$LINENO" 5 ; } + else + ac_cv_sizeof_int_p=0 + fi +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5 +$as_echo "$ac_cv_sizeof_int_p" >&6; } + + + +cat >>confdefs.h <<_ACEOF +#define SIZEOF_INT_P $ac_cv_sizeof_int_p +_ACEOF + + +CXXFLAGS="$OLD_CXXFLAGS" +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +# keep track of c/cxx flags that we added outselves... +# to prevent emitting warning... +ADDED_CFLAGS= +ADDED_CXXFLAGS= +ADDED_LDFLAGS= + +if test "x$ac_cv_sizeof_int_p" = x0; then + # The test failed, lets pick the assumed value. + ARCH_DATA_MODEL=$OPENJDK_TARGET_CPU_BITS +else + ARCH_DATA_MODEL=`expr 8 \* $ac_cv_sizeof_int_p` + + if test "x$OPENJDK_TARGET_OS" != xwindows && test "x$with_target_bits" != x; then + ADDED_CFLAGS=" -m${with_target_bits}" + ADDED_CXXFLAGS=" -m${with_target_bits}" + ADDED_LDFLAGS=" -m${with_target_bits}" + + CFLAGS="${CFLAGS}${ADDED_CFLAGS}" + CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}" + LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}" + + CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}" + CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}" + LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}" + fi +fi + +if test "x$ARCH_DATA_MODEL" = x64; then + A_LP64="LP64:=" + ADD_LP64="-D_LP64=1" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for target address size" >&5 +$as_echo_n "checking for target address size... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ARCH_DATA_MODEL bits" >&5 +$as_echo "$ARCH_DATA_MODEL bits" >&6; } +LP64=$A_LP64 + + + +if test "x$ARCH_DATA_MODEL" != "x$OPENJDK_TARGET_CPU_BITS"; then + as_fn_error $? "The tested number of bits in the target ($ARCH_DATA_MODEL) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)" "$LINENO" 5 +fi + +# +# NOTE: check for -mstackrealign needs to be below potential addition of -m32 +# +if test "x$OPENJDK_TARGET_CPU_BITS" = x32 && test "x$OPENJDK_TARGET_OS" = xmacosx; then + # On 32-bit MacOSX the OS requires C-entry points to be 16 byte aligned. + # While waiting for a better solution, the current workaround is to use -mstackrealign. + CFLAGS="$CFLAGS -mstackrealign" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if 32-bit compiler supports -mstackrealign" >&5 +$as_echo_n "checking if 32-bit compiler supports -mstackrealign... " >&6; } + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +int main() { return 0; } +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + +else + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "The selected compiler $CXX does not support -mstackrealign! Try to put another compiler in the path." "$LINENO" 5 + +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi + + +############################################################################### +# +# Is the target little of big endian? +# + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5 +$as_echo_n "checking whether byte ordering is bigendian... " >&6; } +if test "${ac_cv_c_bigendian+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_c_bigendian=unknown + # See if we're dealing with a universal compiler. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifndef __APPLE_CC__ + not a universal capable compiler + #endif + typedef int dummy; + +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + + # Check for potential -arch flags. It is not universal unless + # there are at least two -arch flags with different values. + ac_arch= + ac_prev= + for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do + if test -n "$ac_prev"; then + case $ac_word in + i?86 | x86_64 | ppc | ppc64) + if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then + ac_arch=$ac_word + else + ac_cv_c_bigendian=universal + break + fi + ;; + esac + ac_prev= + elif test "x$ac_word" = "x-arch"; then + ac_prev=arch + fi + done +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + if test $ac_cv_c_bigendian = unknown; then + # See if sys/param.h defines the BYTE_ORDER macro. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + #include + +int +main () +{ +#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \ + && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \ + && LITTLE_ENDIAN) + bogus endian macros + #endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + # It does; now see whether it defined to BIG_ENDIAN or not. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + #include + +int +main () +{ +#if BYTE_ORDER != BIG_ENDIAN + not big endian + #endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_c_bigendian=yes +else + ac_cv_c_bigendian=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + fi + if test $ac_cv_c_bigendian = unknown; then + # See if defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris). + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +int +main () +{ +#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN) + bogus endian macros + #endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + # It does; now see whether it defined to _BIG_ENDIAN or not. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +int +main () +{ +#ifndef _BIG_ENDIAN + not big endian + #endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_c_bigendian=yes +else + ac_cv_c_bigendian=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + fi + if test $ac_cv_c_bigendian = unknown; then + # Compile a test program. + if test "$cross_compiling" = yes; then : + # Try to guess by grepping values from an object file. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +short int ascii_mm[] = + { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; + short int ascii_ii[] = + { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; + int use_ascii (int i) { + return ascii_mm[i] + ascii_ii[i]; + } + short int ebcdic_ii[] = + { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; + short int ebcdic_mm[] = + { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; + int use_ebcdic (int i) { + return ebcdic_mm[i] + ebcdic_ii[i]; + } + extern int foo; + +int +main () +{ +return use_ascii (foo) == use_ebcdic (foo); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then + ac_cv_c_bigendian=yes + fi + if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then + if test "$ac_cv_c_bigendian" = unknown; then + ac_cv_c_bigendian=no + else + # finding both strings is unlikely to happen, but who knows? + ac_cv_c_bigendian=unknown + fi + fi +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ + + /* Are we little or big endian? From Harbison&Steele. */ + union + { + long int l; + char c[sizeof (long int)]; + } u; + u.l = 1; + return u.c[sizeof (long int) - 1] == 1; + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_run "$LINENO"; then : + ac_cv_c_bigendian=no +else + ac_cv_c_bigendian=yes +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5 +$as_echo "$ac_cv_c_bigendian" >&6; } + case $ac_cv_c_bigendian in #( + yes) + ENDIAN="big";; #( + no) + ENDIAN="little" ;; #( + universal) + ENDIAN="universal_endianness" + ;; #( + *) + ENDIAN="unknown" ;; + esac + + +if test "x$ENDIAN" = xuniversal_endianness; then + as_fn_error $? "Building with both big and little endianness is not supported" "$LINENO" 5 +fi +if test "x$ENDIAN" = xunknown; then + ENDIAN="$OPENJDK_TARGET_CPU_ENDIAN" +fi +if test "x$ENDIAN" != "x$OPENJDK_TARGET_CPU_ENDIAN"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The tested endian in the target ($ENDIAN) differs from the endian expected to be found in the target ($OPENJDK_TARGET_CPU_ENDIAN)" >&5 +$as_echo "$as_me: WARNING: The tested endian in the target ($ENDIAN) differs from the endian expected to be found in the target ($OPENJDK_TARGET_CPU_ENDIAN)" >&2;} + ENDIAN="$OPENJDK_TARGET_CPU_ENDIAN" +fi + + + +# Configure flags for the tools + + +############################################################################### +# +# How to compile shared libraries. +# + +if test "x$GCC" = xyes; then + COMPILER_NAME=gcc + PICFLAG="-fPIC" + LIBRARY_PREFIX=lib + SHARED_LIBRARY='lib$1.so' + STATIC_LIBRARY='lib$1.a' + SHARED_LIBRARY_FLAGS="-shared" + SHARED_LIBRARY_SUFFIX='.so' + STATIC_LIBRARY_SUFFIX='.a' + OBJ_SUFFIX='.o' + EXE_SUFFIX='' + SET_SHARED_LIBRARY_NAME='-Xlinker -soname=$1' + SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=$1' + C_FLAG_REORDER='' + CXX_FLAG_REORDER='' + SET_SHARED_LIBRARY_ORIGIN='-Xlinker -z -Xlinker origin -Xlinker -rpath -Xlinker \$$$$ORIGIN/$1' + LD="$CC" + LDEXE="$CC" + LDCXX="$CXX" + LDEXECXX="$CXX" + POST_STRIP_CMD="$STRIP -g" + if test "x$JDK_VARIANT" = xembedded; then + POST_STRIP_CMD="$STRIP --strip-unneeded" + fi + + # Linking is different on MacOSX + if test "x$OPENJDK_BUILD_OS" = xmacosx; then + # Might change in the future to clang. + COMPILER_NAME=gcc + SHARED_LIBRARY='lib$1.dylib' + SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG" + SHARED_LIBRARY_SUFFIX='.dylib' + EXE_SUFFIX='' + SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/$1' + SET_SHARED_LIBRARY_MAPFILE='' + SET_SHARED_LIBRARY_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.' + POST_STRIP_CMD="$STRIP -S" + fi +else + if test "x$OPENJDK_BUILD_OS" = xsolaris; then + # If it is not gcc, then assume it is the Oracle Solaris Studio Compiler + COMPILER_NAME=ossc + PICFLAG="-KPIC" + LIBRARY_PREFIX=lib + SHARED_LIBRARY='lib$1.so' + STATIC_LIBRARY='lib$1.a' + SHARED_LIBRARY_FLAGS="-z defs -xildoff -ztext -G" + SHARED_LIBRARY_SUFFIX='.so' + STATIC_LIBRARY_SUFFIX='.a' + OBJ_SUFFIX='.o' + EXE_SUFFIX='' + SET_SHARED_LIBRARY_NAME='' + SET_SHARED_LIBRARY_MAPFILE='-M$1' + C_FLAG_REORDER='-xF' + CXX_FLAG_REORDER='-xF' + SET_SHARED_LIBRARY_ORIGIN='-R \$$$$ORIGIN/$1' + CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__" + CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__" + CFLAGS_JDKLIB_EXTRA='-xstrconst' + POST_STRIP_CMD="$STRIP -x" + POST_MCS_CMD="$MCS -d -a \"JDK $FULL_VERSION\"" + fi + if test "x$OPENJDK_BUILD_OS" = xwindows; then + # If it is not gcc, then assume it is the MS Visual Studio compiler + COMPILER_NAME=cl + PICFLAG="" + LIBRARY_PREFIX= + SHARED_LIBRARY='$1.dll' + STATIC_LIBRARY='$1.lib' + SHARED_LIBRARY_FLAGS="-LD" + SHARED_LIBRARY_SUFFIX='.dll' + STATIC_LIBRARY_SUFFIX='.lib' + OBJ_SUFFIX='.obj' + EXE_SUFFIX='.exe' + SET_SHARED_LIBRARY_NAME='' + SET_SHARED_LIBRARY_MAPFILE='' + SET_SHARED_LIBRARY_ORIGIN='' + fi +fi + + + + + + + + + + + + + + + + + +# The (cross) compiler is now configured, we can now test capabilities +# of the target platform. + + + +############################################################################### +# +# Setup the opt flags for different compilers +# and different operating systems. +# +C_FLAG_DEPS="-MMD -MF" +CXX_FLAG_DEPS="-MMD -MF" + +case $COMPILER_TYPE in + CC ) + D_FLAG="-g" + case $COMPILER_NAME in + gcc ) + case $OPENJDK_TARGET_OS in + macosx ) + # On MacOSX we optimize for size, something + # we should do for all platforms? + C_O_FLAG_HI="-Os" + C_O_FLAG_NORM="-Os" + C_O_FLAG_NONE="" + ;; + *) + C_O_FLAG_HI="-O3" + C_O_FLAG_NORM="-O2" + C_O_FLAG_NONE="-O0" + CFLAGS_DEBUG_SYMBOLS="-g" + CXXFLAGS_DEBUG_SYMBOLS="-g" + if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then + CFLAGS_DEBUG_SYMBOLS="-g1" + CXXFLAGS_DEBUG_SYMBOLSG="-g1" + fi + ;; + esac + CXX_O_FLAG_HI="$C_O_FLAG_HI" + CXX_O_FLAG_NORM="$C_O_FLAG_NORM" + CXX_O_FLAG_NONE="$C_O_FLAG_NONE" + ;; + ossc ) + # + # Forte has different names for this with their C++ compiler... + # + C_FLAG_DEPS="-xMMD -xMF" + CXX_FLAG_DEPS="-xMMD -xMF" + +# Extra options used with HIGHEST +# +# WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be +# done with care, there are some assumptions below that need to +# be understood about the use of pointers, and IEEE behavior. +# +# Use non-standard floating point mode (not IEEE 754) +CC_HIGHEST="$CC_HIGHEST -fns" +# Do some simplification of floating point arithmetic (not IEEE 754) +CC_HIGHEST="$CC_HIGHEST -fsimple" +# Use single precision floating point with 'float' +CC_HIGHEST="$CC_HIGHEST -fsingle" +# Assume memory references via basic pointer types do not alias +# (Source with excessing pointer casting and data access with mixed +# pointer types are not recommended) +CC_HIGHEST="$CC_HIGHEST -xalias_level=basic" +# Use intrinsic or inline versions for math/std functions +# (If you expect perfect errno behavior, do not use this) +CC_HIGHEST="$CC_HIGHEST -xbuiltin=%all" +# Loop data dependency optimizations (need -xO3 or higher) +CC_HIGHEST="$CC_HIGHEST -xdepend" +# Pointer parameters to functions do not overlap +# (Similar to -xalias_level=basic usage, but less obvious sometimes. +# If you pass in multiple pointers to the same data, do not use this) +CC_HIGHEST="$CC_HIGHEST -xrestrict" +# Inline some library routines +# (If you expect perfect errno behavior, do not use this) +CC_HIGHEST="$CC_HIGHEST -xlibmil" +# Use optimized math routines +# (If you expect perfect errno behavior, do not use this) +# Can cause undefined external on Solaris 8 X86 on __sincos, removing for now +#CC_HIGHEST="$CC_HIGHEST -xlibmopt" + + case $LEGACY_OPENJDK_TARGET_CPU1 in + i586) + C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xchip=pentium" + C_O_FLAG_HI="-xO4 -Wu,-O4~yz" + C_O_FLAG_NORM="-xO2 -Wu,-O2~yz" + C_O_FLAG_NONE="" + CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xchip=pentium" + CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz" + CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz" + CXX_O_FLAG_NONE="" + ;; + sparc) + CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s" + CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s" + CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl" + CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl" + C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" + C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0" + C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0" + C_O_FLAG_NONE="" + CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" + CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" + CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" + CXX_O_FLAG_NONE="" + ;; + esac + + CFLAGS_DEBUG_SYMBOLS="-g -xs" + CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs" + esac + ;; + CL ) + D_FLAG= + C_O_FLAG_HI="-O2" + C_O_FLAG_NORM="-O1" + C_O_FLAG_NONE="-Od" + CXX_O_FLAG_HI="$C_O_FLAG_HI" + CXX_O_FLAG_NORM="$C_O_FLAG_NORM" + CXX_O_FLAG_NONE="$C_O_FLAG_NONE" + ;; +esac + +if test -z "$C_O_FLAG_HIGHEST"; then + C_O_FLAG_HIGHEST="$C_O_FLAG_HI" +fi + +if test -z "$CXX_O_FLAG_HIGHEST"; then + CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HI" +fi + + + + + + + + + + + + + + +if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags\"" >&5 +$as_echo "$as_me: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags\"" >&2;} +fi + +if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags\"" >&5 +$as_echo "$as_me: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags\"" >&2;} +fi + +if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags\"" >&5 +$as_echo "$as_me: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags\"" >&2;} +fi + + +# Check whether --with-extra-cflags was given. +if test "${with_extra_cflags+set}" = set; then : + withval=$with_extra_cflags; +fi + + + +# Check whether --with-extra-cxxflags was given. +if test "${with_extra_cxxflags+set}" = set; then : + withval=$with_extra_cxxflags; +fi + + + +# Check whether --with-extra-ldflags was given. +if test "${with_extra_ldflags+set}" = set; then : + withval=$with_extra_ldflags; +fi + + +CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags" +CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags" +LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags" + +############################################################################### +# +# Now setup the CFLAGS and LDFLAGS for the JDK build. +# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build. +# +case $COMPILER_NAME in + gcc ) + CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \ + -pipe \ + -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE" + case $OPENJDK_TARGET_CPU_ARCH in + arm ) + # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing + CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" + ;; + ppc ) + # on ppc we don't prevent gcc to omit frame pointer nor strict-aliasing + ;; + * ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer" + CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" + ;; + esac + ;; + ossc ) + CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -norunpath -xnolib" + CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX" + ;; + cl ) + CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \ + -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \ + -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \ + -DWIN32 -DIAL" + case $LEGACY_OPENJDK_TARGET_CPU1 in + i?86 ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86" + ;; + amd64 ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64" + ;; + esac + ;; +esac + +############################################################################### +# +# Cross-compile arch specific flags + +# +if test "x$JDK_VARIANT" = "xembedded"; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DJAVASE_EMBEDDED" +fi + +case $OPENJDK_TARGET_CPU_ARCH in +arm ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fsigned-char" + ;; +ppc ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fsigned-char" + ;; +esac + +############################################################################### + +CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64" + +# The package path is used only on macosx? +PACKAGE_PATH=/opt/local + + +# Sometimes we use a cpu dir (.../lib/amd64/server) +# Sometimes not (.../lib/server) +LIBARCHDIR="$LEGACY_OPENJDK_TARGET_CPU2/" +if test "x$ENDIAN" = xlittle; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN" +else + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN" +fi +if test "x$OPENJDK_TARGET_OS" = xlinux; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX" +fi +if test "x$OPENJDK_TARGET_OS" = xwindows; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS" +fi +if test "x$OPENJDK_TARGET_OS" = xsolaris; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS" +fi +if test "x$OPENJDK_TARGET_OS" = xmacosx; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE" + LIBARCHDIR="" +fi +if test "x$OPENJDK_TARGET_OS" = xbsd; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE" +fi +if test "x$DEBUG_LEVEL" = xrelease; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG" +else + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG" +fi + +CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$LEGACY_OPENJDK_TARGET_CPU1\"' -D$LEGACY_OPENJDK_TARGET_CPU1" +CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"$RELEASE\"'" + +CCXXFLAGS_JDK="$CCXXFLAGS_JDK \ + -I${JDK_OUTPUTDIR}/include \ + -I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \ + -I${JDK_TOPDIR}/src/share/javavm/export \ + -I${JDK_TOPDIR}/src/$LEGACY_OPENJDK_TARGET_OS_API/javavm/export \ + -I${JDK_TOPDIR}/src/share/native/common \ + -I${JDK_TOPDIR}/src/$LEGACY_OPENJDK_TARGET_OS_API/native/common" + +# The shared libraries are compiled using the picflag. +CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA" +CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA " + +# Executable flags +CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK" +CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK" + +# Now this is odd. The JDK native libraries have to link against libjvm.so +# On 32-bit machines there is normally two distinct libjvm.so:s, client and server. +# Which should we link to? Are we lucky enough that the binary api to the libjvm.so library +# is identical for client and server? Yes. Which is picked at runtime (client or server)? +# Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following +# libraries will link to whatever is in memory. Yuck. +# +# Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh. +if test "x$COMPILER_TYPE" = xCL; then + LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no" + if test "x$LEGACY_OPENJDK_TARGET_CPU1" = xi586; then + LDFLAGS_JDK="$LDFLAGS_JDK -safeseh" + fi + # TODO: make -debug optional "--disable-full-debug-symbols" + LDFLAGS_JDK="$LDFLAGS_JDK -debug" + LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib" + LDFLAGS_JDKLIB_SUFFIX="" + if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then + LDFLAGS_STACK_SIZE=1048576 + else + LDFLAGS_STACK_SIZE=327680 + fi + LDFLAGS_JDKEXE="${LDFLAGS_JDK} /STACK:$LDFLAGS_STACK_SIZE" +else + # If this is a --hash-style=gnu system, use --hash-style=both, why? + HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'` + if test -n "$HAS_GNU_HASH"; then + # And since we now know that the linker is gnu, then add -z defs, to forbid + # undefined symbols in object files. + LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both -Xlinker -z -Xlinker defs" + if test "x$DEBUG_LEVEL" == "xrelease"; then + # When building release libraries, tell the linker optimize them. + # Should this be supplied to the OSS linker as well? + LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1" + fi + fi + + LDFLAGS_JDKLIB="${LDFLAGS_JDK} $SHARED_LIBRARY_FLAGS \ + -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}server \ + -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}client \ + -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}" + LDFLAGS_JDKLIB_SUFFIX="-ljvm -ljava" + if test "x$COMPILER_NAME" = xossc; then + LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc" + fi + + # Only the jli library is explicitly linked when the launchers are built. + # The libjvm is then dynamically loaded/linked by the launcher. + LDFLAGS_JDKEXE="${LDFLAGS_JDK}" + if test "x$OPENJDK_TARGET_OS" != "xmacosx"; then + LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}jli" + LDFLAGS_JDKEXE_SUFFIX="-ljli" + fi +fi + +# Adjust flags according to debug level. +case $DEBUG_LEVEL in + fastdebug ) + CFLAGS="$CFLAGS $D_FLAG" + JAVAC_FLAGS="$JAVAC_FLAGS -g" + ;; + slowdebug ) + CFLAGS="$CFLAGS $D_FLAG" + C_O_FLAG_HI="$C_O_FLAG_NONE" + C_O_FLAG_NORM="$C_O_FLAG_NONE" + CXX_O_FLAG_HI="$CXX_O_FLAG_NONE" + CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE" + JAVAC_FLAGS="$JAVAC_FLAGS -g" + ;; +esac + + + + + + + + + + + + + + +# After we have toolchain, we can compile the uncygdrive helper + +# When using cygwin, we need a wrapper binary that renames +# /cygdrive/c/ arguments into c:/ arguments and peeks into +# @files and rewrites these too! This wrapper binary is +# called uncygdrive.exe. +UNCYGDRIVE= +if test "x$OPENJDK_BUILD_OS" = xwindows; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if uncygdrive can be created" >&5 +$as_echo_n "checking if uncygdrive can be created... " >&6; } + UNCYGDRIVE_SRC=`$CYGPATH -m $SRC_ROOT/common/src/uncygdrive.c` + rm -f $OUTPUT_ROOT/uncygdrive* + UNCYGDRIVE=`$CYGPATH -m $OUTPUT_ROOT/uncygdrive.exe` + cd $OUTPUT_ROOT + $CC $UNCYGDRIVE_SRC /Fe$UNCYGDRIVE > $OUTPUT_ROOT/uncygdrive1.log 2>&1 + cd $CURDIR + + if test ! -x $OUTPUT_ROOT/uncygdrive.exe; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + cat $OUTPUT_ROOT/uncygdrive1.log + as_fn_error $? "Could not create $OUTPUT_ROOT/uncygdrive.exe" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNCYGDRIVE" >&5 +$as_echo "$UNCYGDRIVE" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if uncygdrive.exe works" >&5 +$as_echo_n "checking if uncygdrive.exe works... " >&6; } + cd $OUTPUT_ROOT + $UNCYGDRIVE $CC $SRC_ROOT/common/src/uncygdrive.c /Fe$OUTPUT_ROOT/uncygdrive2.exe > $OUTPUT_ROOT/uncygdrive2.log 2>&1 + cd $CURDIR + if test ! -x $OUTPUT_ROOT/uncygdrive2.exe; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + cat $OUTPUT_ROOT/uncygdrive2.log + as_fn_error $? "Uncygdrive did not work!" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + rm -f $OUTPUT_ROOT/uncygdrive?.??? $OUTPUT_ROOT/uncygdrive.obj +fi + + + + + +# Setup debug symbols (need objcopy from the toolchain for that) + +# +# ENABLE_DEBUG_SYMBOLS +# This must be done after the toolchain is setup, since we're looking at objcopy. +# +ENABLE_DEBUG_SYMBOLS=default + +# default on macosx is no... +if test "x$OPENJDK_TARGET_OS" = xmacosx; then + ENABLE_DEBUG_SYMBOLS=no +fi + +# default for embedded is no... +if test "x$JDK_VARIANT" = "xembedded"; then + ENABLE_DEBUG_SYMBOLS=no +fi + +# Check whether --enable-debug-symbols was given. +if test "${enable_debug_symbols+set}" = set; then : + enableval=$enable_debug_symbols; ENABLE_DEBUG_SYMBOLS=${enable_debug_symbols} +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should generate debug symbols" >&5 +$as_echo_n "checking if we should generate debug symbols... " >&6; } + +if test "x$ENABLE_DEBUG_SYMBOLS" = "xyes" && test "x$OBJCOPY" = x; then + # explicit enabling of enable-debug-symbols and can't find objcopy + # this is an error + as_fn_error $? "Unable to find objcopy, cannot enable debug-symbols" "$LINENO" 5 +fi + +if test "x$ENABLE_DEBUG_SYMBOLS" = "xdefault"; then + # Default is on if objcopy is found, otherwise off + if test "x$OBJCOPY" != x; then + ENABLE_DEBUG_SYMBOLS=yes + else + ENABLE_DEBUG_SYMBOLS=no + fi +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_DEBUG_SYMBOLS" >&5 +$as_echo "$ENABLE_DEBUG_SYMBOLS" >&6; } + +# +# ZIP_DEBUGINFO_FILES +# +ZIP_DEBUGINFO_FILES=yes + +# Check whether --enable-zip-debug-info was given. +if test "${enable_zip_debug_info+set}" = set; then : + enableval=$enable_zip_debug_info; ZIP_DEBUGINFO_FILES=${enable_zip_debug_info} +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should zip debug-info files" >&5 +$as_echo_n "checking if we should zip debug-info files... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP_DEBUGINFO_FILES" >&5 +$as_echo "$ZIP_DEBUGINFO_FILES" >&6; } + +# Hotspot wants ZIP_DEBUGINFO_FILES to be 1 for yes +# use that... +if test "x$ZIP_DEBUGINFO_FILES" = "xyes"; then + ZIP_DEBUGINFO_FILES=1 +else + ZIP_DEBUGINFO_FILES=0 +fi + + + + + + + +############################################################################### +# +# Check dependencies for external and internal libraries. +# +############################################################################### + + + +############################################################################### +# +# OS specific settings that we never will need to probe. +# +if test "x$OPENJDK_TARGET_OS" = xlinux; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Linux?" >&5 +$as_echo_n "checking what is not needed on Linux?... " >&6; } + PULSE_NOT_NEEDED=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: result: pulse" >&5 +$as_echo "pulse" >&6; } +fi + +if test "x$OPENJDK_TARGET_OS" = xsolaris; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Solaris?" >&5 +$as_echo_n "checking what is not needed on Solaris?... " >&6; } + ALSA_NOT_NEEDED=yes + PULSE_NOT_NEEDED=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5 +$as_echo "alsa pulse" >&6; } +fi + +if test "x$OPENJDK_TARGET_OS" = xwindows; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Windows?" >&5 +$as_echo_n "checking what is not needed on Windows?... " >&6; } + CUPS_NOT_NEEDED=yes + ALSA_NOT_NEEDED=yes + PULSE_NOT_NEEDED=yes + X11_NOT_NEEDED=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa cups pulse x11" >&5 +$as_echo "alsa cups pulse x11" >&6; } +fi + +if test "x$OPENJDK_TARGET_OS" = xmacosx; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on MacOSX?" >&5 +$as_echo_n "checking what is not needed on MacOSX?... " >&6; } + ALSA_NOT_NEEDED=yes + PULSE_NOT_NEEDED=yes + X11_NOT_NEEDED=yes + FREETYPE2_NOT_NEEDED=yes + # If the java runtime framework is disabled, then we need X11. + # This will be adjusted below. + { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse x11" >&5 +$as_echo "alsa pulse x11" >&6; } +fi + +if test "x$OPENJDK_TARGET_OS" = xbsd; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on bsd?" >&5 +$as_echo_n "checking what is not needed on bsd?... " >&6; } + ALSA_NOT_NEEDED=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa" >&5 +$as_echo "alsa" >&6; } +fi + +if test "x$OPENJDK" = "xfalse"; then + FREETYPE2_NOT_NEEDED=yes +fi + +############################################################################### +# +# Check for MacOSX support for OpenJDK. If this exists, try to build a JVM +# that uses this API. +# +# Check whether --enable-macosx-runtime-support was given. +if test "${enable_macosx_runtime_support+set}" = set; then : + enableval=$enable_macosx_runtime_support; MACOSX_RUNTIME_SUPPORT="${enableval}" +else + MACOSX_RUNTIME_SUPPORT="no" +fi + + +USE_MACOSX_RUNTIME_SUPPORT=no +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for explicit Java runtime support in the OS" >&5 +$as_echo_n "checking for explicit Java runtime support in the OS... " >&6; } +if test -f /System/Library/Frameworks/JavaVM.framework/Frameworks/JavaRuntimeSupport.framework/Headers/JavaRuntimeSupport.h; then + if test "x$MACOSX_RUNTIME_SUPPORT" != xno; then + MACOSX_RUNTIME_SUPPORT=yes + USE_MACOSX_RUNTIME_SUPPORT=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, does not need alsa freetype2 pulse and X11" >&5 +$as_echo "yes, does not need alsa freetype2 pulse and X11" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, but explicitly disabled." >&5 +$as_echo "yes, but explicitly disabled." >&6; } + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + +if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$USE_MACOSX_RUNTIME_SUPPORT" = xno; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on an X11 build on MacOSX?" >&5 +$as_echo_n "checking what is not needed on an X11 build on MacOSX?... " >&6; } + X11_NOT_NEEDED= + FREETYPE2_NOT_NEEDED= + { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5 +$as_echo "alsa pulse" >&6; } +fi + + + + + +############################################################################### +# +# Check for X Windows +# + +# Check if the user has specified sysroot, but not --x-includes or --x-libraries. +# Make a simple check for the libraries at the sysroot, and setup --x-includes and +# --x-libraries for the sysroot, if that seems to be correct. +if test "x$SYS_ROOT" != "x/"; then + if test "x$x_includes" = xNONE; then + if test -f "$SYS_ROOT/usr/X11R6/include/X11/Xlib.h"; then + x_includes="$SYS_ROOT/usr/X11R6/include" + fi + fi + if test "x$x_libraries" = xNONE; then + if test -f "$SYS_ROOT/usr/X11R6/lib/libX11.so"; then + x_libraries="$SYS_ROOT/usr/X11R6/lib" + fi + fi +fi + +# Now let autoconf do it's magic +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5 +$as_echo_n "checking for X... " >&6; } + + +# Check whether --with-x was given. +if test "${with_x+set}" = set; then : + withval=$with_x; +fi + +# $have_x is `yes', `no', `disabled', or empty when we do not yet know. +if test "x$with_x" = xno; then + # The user explicitly disabled X. + have_x=disabled +else + case $x_includes,$x_libraries in #( + *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5 ;; #( + *,NONE | NONE,*) if test "${ac_cv_have_x+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + # One or both of the vars are not set, and there is no cached value. +ac_x_includes=no ac_x_libraries=no +rm -f -r conftest.dir +if mkdir conftest.dir; then + cd conftest.dir + cat >Imakefile <<'_ACEOF' +incroot: + @echo incroot='${INCROOT}' +usrlibdir: + @echo usrlibdir='${USRLIBDIR}' +libdir: + @echo libdir='${LIBDIR}' +_ACEOF + if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then + # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. + for ac_var in incroot usrlibdir libdir; do + eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`" + done + # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR. + for ac_extension in a so sl dylib la dll; do + if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" && + test -f "$ac_im_libdir/libX11.$ac_extension"; then + ac_im_usrlibdir=$ac_im_libdir; break + fi + done + # Screen out bogus values from the imake configuration. They are + # bogus both because they are the default anyway, and because + # using them would break gcc on systems where it needs fixed includes. + case $ac_im_incroot in + /usr/include) ac_x_includes= ;; + *) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;; + esac + case $ac_im_usrlibdir in + /usr/lib | /usr/lib64 | /lib | /lib64) ;; + *) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;; + esac + fi + cd .. + rm -f -r conftest.dir +fi + +# Standard set of common directories for X headers. +# Check X11 before X11Rn because it is often a symlink to the current release. +ac_x_header_dirs=' +/usr/X11/include +/usr/X11R7/include +/usr/X11R6/include +/usr/X11R5/include +/usr/X11R4/include + +/usr/include/X11 +/usr/include/X11R7 +/usr/include/X11R6 +/usr/include/X11R5 +/usr/include/X11R4 + +/usr/local/X11/include +/usr/local/X11R7/include +/usr/local/X11R6/include +/usr/local/X11R5/include +/usr/local/X11R4/include + +/usr/local/include/X11 +/usr/local/include/X11R7 +/usr/local/include/X11R6 +/usr/local/include/X11R5 +/usr/local/include/X11R4 + +/usr/X386/include +/usr/x386/include +/usr/XFree86/include/X11 + +/usr/include +/usr/local/include +/usr/unsupported/include +/usr/athena/include +/usr/local/x11r5/include +/usr/lpp/Xamples/include + +/usr/openwin/include +/usr/openwin/share/include' + +if test "$ac_x_includes" = no; then + # Guess where to find include files, by looking for Xlib.h. + # First, try using that file with no special directory specified. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # We can compile using X headers with no special include directory. +ac_x_includes= +else + for ac_dir in $ac_x_header_dirs; do + if test -r "$ac_dir/X11/Xlib.h"; then + ac_x_includes=$ac_dir + break + fi +done +fi +rm -f conftest.err conftest.i conftest.$ac_ext +fi # $ac_x_includes = no + +if test "$ac_x_libraries" = no; then + # Check for the libraries. + # See if we find them without any special options. + # Don't add to $LIBS permanently. + ac_save_LIBS=$LIBS + LIBS="-lX11 $LIBS" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +XrmInitialize () + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + LIBS=$ac_save_LIBS +# We can link X programs with no special library path. +ac_x_libraries= +else + LIBS=$ac_save_LIBS +for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g` +do + # Don't even attempt the hair of trying to link an X program! + for ac_extension in a so sl dylib la dll; do + if test -r "$ac_dir/libX11.$ac_extension"; then + ac_x_libraries=$ac_dir + break 2 + fi + done +done +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi # $ac_x_libraries = no + +case $ac_x_includes,$ac_x_libraries in #( + no,* | *,no | *\'*) + # Didn't find X, or a directory has "'" in its name. + ac_cv_have_x="have_x=no";; #( + *) + # Record where we found X for the cache. + ac_cv_have_x="have_x=yes\ + ac_x_includes='$ac_x_includes'\ + ac_x_libraries='$ac_x_libraries'" +esac +fi +;; #( + *) have_x=yes;; + esac + eval "$ac_cv_have_x" +fi # $with_x != no + +if test "$have_x" != yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5 +$as_echo "$have_x" >&6; } + no_x=yes +else + # If each of the values was on the command line, it overrides each guess. + test "x$x_includes" = xNONE && x_includes=$ac_x_includes + test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries + # Update the cache value to reflect the command line values. + ac_cv_have_x="have_x=yes\ + ac_x_includes='$x_includes'\ + ac_x_libraries='$x_libraries'" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5 +$as_echo "libraries $x_libraries, headers $x_includes" >&6; } +fi + +if test "$no_x" = yes; then + # Not all programs may use this symbol, but it does not hurt to define it. + +$as_echo "#define X_DISPLAY_MISSING 1" >>confdefs.h + + X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS= +else + if test -n "$x_includes"; then + X_CFLAGS="$X_CFLAGS -I$x_includes" + fi + + # It would also be nice to do this for all -L options, not just this one. + if test -n "$x_libraries"; then + X_LIBS="$X_LIBS -L$x_libraries" + # For Solaris; some versions of Sun CC require a space after -R and + # others require no space. Words are not sufficient . . . . + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5 +$as_echo_n "checking whether -R must be followed by a space... " >&6; } + ac_xsave_LIBS=$LIBS; LIBS="$LIBS -R$x_libraries" + ac_xsave_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + X_LIBS="$X_LIBS -R$x_libraries" +else + LIBS="$ac_xsave_LIBS -R $x_libraries" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + X_LIBS="$X_LIBS -R $x_libraries" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: neither works" >&5 +$as_echo "neither works" >&6; } +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + ac_cxx_werror_flag=$ac_xsave_cxx_werror_flag + LIBS=$ac_xsave_LIBS + fi + + # Check for system-dependent libraries X programs must link with. + # Do this before checking for the system-independent R6 libraries + # (-lICE), since we may need -lsocket or whatever for X linking. + + if test "$ISC" = yes; then + X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl_s -linet" + else + # Martyn Johnson says this is needed for Ultrix, if the X + # libraries were built with DECnet support. And Karl Berry says + # the Alpha needs dnet_stub (dnet does not exist). + ac_xsave_LIBS="$LIBS"; LIBS="$LIBS $X_LIBS -lX11" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char XOpenDisplay (); +int +main () +{ +return XOpenDisplay (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5 +$as_echo_n "checking for dnet_ntoa in -ldnet... " >&6; } +if test "${ac_cv_lib_dnet_dnet_ntoa+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldnet $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dnet_ntoa (); +int +main () +{ +return dnet_ntoa (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dnet_dnet_ntoa=yes +else + ac_cv_lib_dnet_dnet_ntoa=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5 +$as_echo "$ac_cv_lib_dnet_dnet_ntoa" >&6; } +if test "x$ac_cv_lib_dnet_dnet_ntoa" = x""yes; then : + X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet" +fi + + if test $ac_cv_lib_dnet_dnet_ntoa = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5 +$as_echo_n "checking for dnet_ntoa in -ldnet_stub... " >&6; } +if test "${ac_cv_lib_dnet_stub_dnet_ntoa+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldnet_stub $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dnet_ntoa (); +int +main () +{ +return dnet_ntoa (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dnet_stub_dnet_ntoa=yes +else + ac_cv_lib_dnet_stub_dnet_ntoa=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5 +$as_echo "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; } +if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = x""yes; then : + X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub" +fi + + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LIBS="$ac_xsave_LIBS" + + # msh@cis.ufl.edu says -lnsl (and -lsocket) are needed for his 386/AT, + # to get the SysV transport functions. + # Chad R. Larson says the Pyramis MIS-ES running DC/OSx (SVR4) + # needs -lnsl. + # The nsl library prevents programs from opening the X display + # on Irix 5.2, according to T.E. Dickey. + # The functions gethostbyname, getservbyname, and inet_addr are + # in -lbsd on LynxOS 3.0.1/i386, according to Lars Hecking. + ac_fn_cxx_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname" +if test "x$ac_cv_func_gethostbyname" = x""yes; then : + +fi + + if test $ac_cv_func_gethostbyname = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5 +$as_echo_n "checking for gethostbyname in -lnsl... " >&6; } +if test "${ac_cv_lib_nsl_gethostbyname+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lnsl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char gethostbyname (); +int +main () +{ +return gethostbyname (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_nsl_gethostbyname=yes +else + ac_cv_lib_nsl_gethostbyname=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5 +$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; } +if test "x$ac_cv_lib_nsl_gethostbyname" = x""yes; then : + X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl" +fi + + if test $ac_cv_lib_nsl_gethostbyname = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5 +$as_echo_n "checking for gethostbyname in -lbsd... " >&6; } +if test "${ac_cv_lib_bsd_gethostbyname+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lbsd $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char gethostbyname (); +int +main () +{ +return gethostbyname (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_bsd_gethostbyname=yes +else + ac_cv_lib_bsd_gethostbyname=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5 +$as_echo "$ac_cv_lib_bsd_gethostbyname" >&6; } +if test "x$ac_cv_lib_bsd_gethostbyname" = x""yes; then : + X_EXTRA_LIBS="$X_EXTRA_LIBS -lbsd" +fi + + fi + fi + + # lieder@skyler.mavd.honeywell.com says without -lsocket, + # socket/setsockopt and other routines are undefined under SCO ODT + # 2.0. But -lsocket is broken on IRIX 5.2 (and is not necessary + # on later versions), says Simon Leinen: it contains gethostby* + # variants that don't use the name server (or something). -lsocket + # must be given before -lnsl if both are needed. We assume that + # if connect needs -lnsl, so does gethostbyname. + ac_fn_cxx_check_func "$LINENO" "connect" "ac_cv_func_connect" +if test "x$ac_cv_func_connect" = x""yes; then : + +fi + + if test $ac_cv_func_connect = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5 +$as_echo_n "checking for connect in -lsocket... " >&6; } +if test "${ac_cv_lib_socket_connect+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsocket $X_EXTRA_LIBS $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char connect (); +int +main () +{ +return connect (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_socket_connect=yes +else + ac_cv_lib_socket_connect=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5 +$as_echo "$ac_cv_lib_socket_connect" >&6; } +if test "x$ac_cv_lib_socket_connect" = x""yes; then : + X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS" +fi + + fi + + # Guillermo Gomez says -lposix is necessary on A/UX. + ac_fn_cxx_check_func "$LINENO" "remove" "ac_cv_func_remove" +if test "x$ac_cv_func_remove" = x""yes; then : + +fi + + if test $ac_cv_func_remove = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5 +$as_echo_n "checking for remove in -lposix... " >&6; } +if test "${ac_cv_lib_posix_remove+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lposix $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char remove (); +int +main () +{ +return remove (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_posix_remove=yes +else + ac_cv_lib_posix_remove=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5 +$as_echo "$ac_cv_lib_posix_remove" >&6; } +if test "x$ac_cv_lib_posix_remove" = x""yes; then : + X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix" +fi + + fi + + # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay. + ac_fn_cxx_check_func "$LINENO" "shmat" "ac_cv_func_shmat" +if test "x$ac_cv_func_shmat" = x""yes; then : + +fi + + if test $ac_cv_func_shmat = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5 +$as_echo_n "checking for shmat in -lipc... " >&6; } +if test "${ac_cv_lib_ipc_shmat+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lipc $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shmat (); +int +main () +{ +return shmat (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_ipc_shmat=yes +else + ac_cv_lib_ipc_shmat=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5 +$as_echo "$ac_cv_lib_ipc_shmat" >&6; } +if test "x$ac_cv_lib_ipc_shmat" = x""yes; then : + X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc" +fi + + fi + fi + + # Check for libraries that X11R6 Xt/Xaw programs need. + ac_save_LDFLAGS=$LDFLAGS + test -n "$x_libraries" && LDFLAGS="$LDFLAGS -L$x_libraries" + # SM needs ICE to (dynamically) link under SunOS 4.x (so we have to + # check for ICE first), but we must link in the order -lSM -lICE or + # we get undefined symbols. So assume we have SM if we have ICE. + # These have to be linked with before -lX11, unlike the other + # libraries we check for below, so use a different variable. + # John Interrante, Karl Berry + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5 +$as_echo_n "checking for IceConnectionNumber in -lICE... " >&6; } +if test "${ac_cv_lib_ICE_IceConnectionNumber+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lICE $X_EXTRA_LIBS $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char IceConnectionNumber (); +int +main () +{ +return IceConnectionNumber (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_ICE_IceConnectionNumber=yes +else + ac_cv_lib_ICE_IceConnectionNumber=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5 +$as_echo "$ac_cv_lib_ICE_IceConnectionNumber" >&6; } +if test "x$ac_cv_lib_ICE_IceConnectionNumber" = x""yes; then : + X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE" +fi + + LDFLAGS=$ac_save_LDFLAGS + +fi + + +if test "x$no_x" = xyes && test "x$X11_NOT_NEEDED" != xyes; then + + # Print a helpful message on how to acquire the necessary build dependency. + # x11 is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=x11 + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + as_fn_error $? "Could not find X11 libraries. $HELP_MSG" "$LINENO" 5 +fi + +# Some of the old makefiles require a setting of OPENWIN_HOME +# Since the X11R6 directory has disappeared on later Linuxes, +# we need to probe for it. +if test "x$OPENJDK_TARGET_OS" = xlinux; then + if test -d "$SYS_ROOT/usr/X11R6"; then + OPENWIN_HOME="$SYS_ROOT/usr/X11R6" + fi + if test -d "$SYS_ROOT/usr/include/X11"; then + OPENWIN_HOME="$SYS_ROOT/usr" + fi +fi +if test "x$OPENJDK_TARGET_OS" = xsolaris; then + OPENWIN_HOME="/usr/openwin" +fi + + + +# +# Weird Sol10 something check...TODO change to try compile +# +if test "x${OPENJDK_TARGET_OS}" = xsolaris; then + if test "`uname -r`" = "5.10"; then + if test "`${EGREP} -c XLinearGradient ${OPENWIN_HOME}/share/include/X11/extensions/Xrender.h`" = "0"; then + X_CFLAGS="${X_CFLAGS} -DSOLARIS10_NO_XRENDER_STRUCTS" + fi + fi +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +OLD_CFLAGS="$CFLAGS" +CFLAGS="$CFLAGS $X_CFLAGS" +for ac_header in X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + X11_A_OK=yes +else + X11_A_OK=no +fi + +done + +CFLAGS="$OLD_CFLAGS" +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +if test "x$X11_A_OK" = xno && test "x$X11_NOT_NEEDED" != xyes; then + + # Print a helpful message on how to acquire the necessary build dependency. + # x11 is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=x11 + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + as_fn_error $? "Could not find all X11 headers (shape.h Xrender.h XTest.h). $HELP_MSG" "$LINENO" 5 +fi + + + + + + +############################################################################### +# +# The common unix printing system cups is used to print from java. +# + +# Check whether --with-cups was given. +if test "${with_cups+set}" = set; then : + withval=$with_cups; +fi + + +# Check whether --with-cups-include was given. +if test "${with_cups_include+set}" = set; then : + withval=$with_cups_include; +fi + + +# Check whether --with-cups-lib was given. +if test "${with_cups_lib+set}" = set; then : + withval=$with_cups_lib; +fi + + +if test "x$CUPS_NOT_NEEDED" = xyes; then + if test "x${with_cups}" != x || test "x${with_cups_include}" != x || test "x${with_cups_lib}" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cups not used, so --with-cups is ignored" >&5 +$as_echo "$as_me: WARNING: cups not used, so --with-cups is ignored" >&2;} + fi + CUPS_CFLAGS= + CUPS_LIBS= +else + CUPS_FOUND=no + + if test "x${with_cups}" = xno || test "x${with_cups_include}" = xno || test "x${with_cups_lib}" = xno; then + as_fn_error $? "It is not possible to disable the use of cups. Remove the --without-cups option." "$LINENO" 5 + fi + + if test "x${with_cups}" != x; then + CUPS_LIBS="-L${with_cups}/lib -lcups" + CUPS_CFLAGS="-I${with_cups}/include" + CUPS_FOUND=yes + fi + if test "x${with_cups_include}" != x; then + CUPS_CFLAGS="-I${with_cups_include}" + CUPS_FOUND=yes + fi + if test "x${with_cups_lib}" != x; then + CUPS_LIBS="-L${with_cups_lib} -lcups" + CUPS_FOUND=yes + fi + if test "x$CUPS_FOUND" = xno; then + + + if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then + # Source the builddeps file again, to make sure it uses the latest variables! + . $builddepsfile + # Look for a target and build machine specific resource! + eval resource=\${builddep_cups_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}} + if test "x$resource" = x; then + # Ok, lets instead look for a target specific resource + eval resource=\${builddep_cups_TARGET_${rewritten_target_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a build specific resource + eval resource=\${builddep_cups_BUILD_${rewritten_build_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a generic resource + # (The cups comes from M4 and not the shell, thus no need for eval here.) + resource=${builddep_cups} + fi + if test "x$resource" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for cups" >&5 +$as_echo "$as_me: Using builddeps $resource for cups" >&6;} + # If the resource in the builddeps.conf file is an existing directory, + # for example /java/linux/cups + if test -d ${resource}; then + depdir=${resource} + else + +# cups is for example mymodule +# $resource is for example libs/general/libmymod_1_2_3.zip +# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps +# $with_builddeps_dir is for example /localhome/builddeps +# depdir is the name of the variable into which we store the depdir, eg MYMOD +# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and +# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 + filename=`basename $resource` + filebase=`echo $filename | sed 's/\.[^\.]*$//'` + filebase=${filename%%.*} + extension=${filename#*.} + installdir=$with_builddeps_dir/$filebase + if test ! -f $installdir/$filename.unpacked; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&5 +$as_echo "$as_me: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&6;} + if test ! -d $installdir; then + mkdir -p $installdir + fi + if test ! -d $installdir; then + as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 + fi + tmpfile=`mktemp $installdir/cups.XXXXXXXXX` + touch $tmpfile + if test ! -f $tmpfile; then + as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 + fi + + # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip + # $tmpfile is the local file name for the downloaded file. + VALID_TOOL=no + if test "x$BDEPS_FTP" = xwget; then + VALID_TOOL=yes + wget -O $tmpfile $with_builddeps_server/$resource + fi + if test "x$BDEPS_FTP" = xlftp; then + VALID_TOOL=yes + lftp -c "get $with_builddeps_server/$resource -o $tmpfile" + fi + if test "x$BDEPS_FTP" = xftp; then + VALID_TOOL=yes + FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` + FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` + FTPUSERPWD=${FTPSERVER%%@*} + if test "x$FTPSERVER" != "x$FTPUSERPWD"; then + FTPUSER=${userpwd%%:*} + FTPPWD=${userpwd#*@} + FTPSERVER=${FTPSERVER#*@} + else + FTPUSER=ftp + FTPPWD=ftp + fi + # the "pass" command does not work on some + # ftp clients (read ftp.exe) but if it works, + # passive mode is better! + (\ + echo "user $FTPUSER $FTPPWD" ;\ + echo "pass" ;\ + echo "bin" ;\ + echo "get $FTPPATH $tmpfile" ;\ + ) | ftp -in $FTPSERVER + fi + if test "x$VALID_TOOL" != xyes; then + as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 + fi + + mv $tmpfile $installdir/$filename + if test ! -s $installdir/$filename; then + as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 + fi + case "$extension" in + zip) echo "Unzipping $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) + ;; + tar.gz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + tgz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 + ;; + esac + fi + if test -f $installdir/$filename.unpacked; then + depdir=$installdir + fi + + fi + # Source the builddeps file again, because in the previous command, the depdir + # was updated to point at the current build dependency install directory. + . $builddepsfile + # Now extract variables from the builddeps.conf files. + theroot=${builddep_cups_ROOT} + thecflags=${builddep_cups_CFLAGS} + thelibs=${builddep_cups_LIBS} + if test "x$depdir" = x; then + as_fn_error $? "Could not download build dependency cups" "$LINENO" 5 + fi + CUPS=$depdir + if test "x$theroot" != x; then + CUPS="$theroot" + fi + if test "x$thecflags" != x; then + CUPS_CFLAGS="$thecflags" + fi + if test "x$thelibs" != x; then + CUPS_LIBS="$thelibs" + fi + CUPS_FOUND=yes + + fi + + fi + + fi + if test "x$CUPS_FOUND" = xno; then + # Are the cups headers installed in the default /usr/include location? + for ac_header in cups/cups.h cups/ppd.h +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_cxx_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + CUPS_FOUND=yes + CUPS_CFLAGS= + CUPS_LIBS="-lcups" + DEFAULT_CUPS=yes +fi + +done + + fi + if test "x$CUPS_FOUND" = xno; then + # Getting nervous now? Lets poke around for standard Solaris third-party + # package installation locations. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cups headers and libs" >&5 +$as_echo_n "checking for cups headers and libs... " >&6; } + if test -s /opt/sfw/cups/include/cups/cups.h; then + # An SFW package seems to be installed! + CUPS_FOUND=yes + CUPS_CFLAGS="-I/opt/sfw/cups/include" + CUPS_LIBS="-L/opt/sfw/cups/lib -lcups" + elif test -s /opt/csw/include/cups/cups.h; then + # A CSW package seems to be installed! + CUPS_FOUND=yes + CUPS_CFLAGS="-I/opt/csw/include" + CUPS_LIBS="-L/opt/csw/lib -lcups" + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5 +$as_echo "$CUPS_FOUND" >&6; } + fi + if test "x$CUPS_FOUND" = xno; then + + # Print a helpful message on how to acquire the necessary build dependency. + # cups is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=cups + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + as_fn_error $? "Could not find cups! $HELP_MSG " "$LINENO" 5 + fi +fi + + + + + + + +############################################################################### +# +# The ubiquitous freetype2 library is used to render fonts. +# + +# Check whether --with-freetype was given. +if test "${with_freetype+set}" = set; then : + withval=$with_freetype; +fi + + +# If we are using the OS installed system lib for freetype, then we do not need to copy it to the build tree +USING_SYSTEM_FT_LIB=false + +if test "x$FREETYPE2_NOT_NEEDED" = xyes; then + if test "x$with_freetype" != x || test "x$with_freetype_include" != x || test "x$with_freetype_lib" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: freetype not used, so --with-freetype is ignored" >&5 +$as_echo "$as_me: WARNING: freetype not used, so --with-freetype is ignored" >&2;} + fi + FREETYPE2_CFLAGS= + FREETYPE2_LIBS= + FREETYPE2_LIB_PATH= +else + FREETYPE2_FOUND=no + + if test "x$with_freetype" != x; then + + # Fail with message the path to freetype if var with_freetype contains a path with no spaces in it. + # Unless on Windows, where we can rewrite the path. + HAS_SPACE=`echo "$with_freetype" | grep " "` + if test "x$HAS_SPACE" != x; then + if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + with_freetype=`$CYGPATH -s -m -a "$with_freetype"` + with_freetype=`$CYGPATH -u "$with_freetype"` + else + as_fn_error $? "You cannot have spaces in the path to freetype! \"$with_freetype\"" "$LINENO" 5 + fi + fi + + FREETYPE2_LIBS="-L$with_freetype/lib -lfreetype" + if test "x$OPENJDK_TARGET_OS" = xwindows; then + FREETYPE2_LIBS="$with_freetype/lib/freetype.lib" + fi + FREETYPE2_LIB_PATH="$with_freetype/lib" + FREETYPE2_CFLAGS="-I$with_freetype/include" + if test -s $with_freetype/include/ft2build.h && test -d $with_freetype/include/freetype2/freetype; then + FREETYPE2_CFLAGS="-I$with_freetype/include/freetype2 -I$with_freetype/include" + fi + FREETYPE2_FOUND=yes + if test "x$FREETYPE2_FOUND" = xyes; then + # Verify that the directories exist + if ! test -d "$with_freetype/lib" || ! test -d "$with_freetype/include"; then + as_fn_error $? "Could not find the expected directories $with_freetype/lib and $with_freetype/include" "$LINENO" 5 + fi + # List the contents of the lib. + FREETYPELIB=`ls $with_freetype/lib/libfreetype.so $with_freetype/lib/freetype.dll 2> /dev/null` + if test "x$FREETYPELIB" = x; then + as_fn_error $? "Could not find libfreetype.se nor freetype.dll in $with_freetype/lib" "$LINENO" 5 + fi + # Check one h-file + if ! test -s "$with_freetype/include/ft2build.h"; then + as_fn_error $? "Could not find $with_freetype/include/ft2build.h" "$LINENO" 5 + fi + fi + fi + if test "x$FREETYPE2_FOUND" = xno; then + + + if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then + # Source the builddeps file again, to make sure it uses the latest variables! + . $builddepsfile + # Look for a target and build machine specific resource! + eval resource=\${builddep_freetype2_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}} + if test "x$resource" = x; then + # Ok, lets instead look for a target specific resource + eval resource=\${builddep_freetype2_TARGET_${rewritten_target_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a build specific resource + eval resource=\${builddep_freetype2_BUILD_${rewritten_build_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a generic resource + # (The freetype2 comes from M4 and not the shell, thus no need for eval here.) + resource=${builddep_freetype2} + fi + if test "x$resource" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for freetype2" >&5 +$as_echo "$as_me: Using builddeps $resource for freetype2" >&6;} + # If the resource in the builddeps.conf file is an existing directory, + # for example /java/linux/cups + if test -d ${resource}; then + depdir=${resource} + else + +# freetype2 is for example mymodule +# $resource is for example libs/general/libmymod_1_2_3.zip +# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps +# $with_builddeps_dir is for example /localhome/builddeps +# depdir is the name of the variable into which we store the depdir, eg MYMOD +# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and +# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 + filename=`basename $resource` + filebase=`echo $filename | sed 's/\.[^\.]*$//'` + filebase=${filename%%.*} + extension=${filename#*.} + installdir=$with_builddeps_dir/$filebase + if test ! -f $installdir/$filename.unpacked; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency freetype2 from $with_builddeps_server/$resource and installing into $installdir" >&5 +$as_echo "$as_me: Downloading build dependency freetype2 from $with_builddeps_server/$resource and installing into $installdir" >&6;} + if test ! -d $installdir; then + mkdir -p $installdir + fi + if test ! -d $installdir; then + as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 + fi + tmpfile=`mktemp $installdir/freetype2.XXXXXXXXX` + touch $tmpfile + if test ! -f $tmpfile; then + as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 + fi + + # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip + # $tmpfile is the local file name for the downloaded file. + VALID_TOOL=no + if test "x$BDEPS_FTP" = xwget; then + VALID_TOOL=yes + wget -O $tmpfile $with_builddeps_server/$resource + fi + if test "x$BDEPS_FTP" = xlftp; then + VALID_TOOL=yes + lftp -c "get $with_builddeps_server/$resource -o $tmpfile" + fi + if test "x$BDEPS_FTP" = xftp; then + VALID_TOOL=yes + FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` + FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` + FTPUSERPWD=${FTPSERVER%%@*} + if test "x$FTPSERVER" != "x$FTPUSERPWD"; then + FTPUSER=${userpwd%%:*} + FTPPWD=${userpwd#*@} + FTPSERVER=${FTPSERVER#*@} + else + FTPUSER=ftp + FTPPWD=ftp + fi + # the "pass" command does not work on some + # ftp clients (read ftp.exe) but if it works, + # passive mode is better! + (\ + echo "user $FTPUSER $FTPPWD" ;\ + echo "pass" ;\ + echo "bin" ;\ + echo "get $FTPPATH $tmpfile" ;\ + ) | ftp -in $FTPSERVER + fi + if test "x$VALID_TOOL" != xyes; then + as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 + fi + + mv $tmpfile $installdir/$filename + if test ! -s $installdir/$filename; then + as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 + fi + case "$extension" in + zip) echo "Unzipping $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) + ;; + tar.gz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + tgz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 + ;; + esac + fi + if test -f $installdir/$filename.unpacked; then + depdir=$installdir + fi + + fi + # Source the builddeps file again, because in the previous command, the depdir + # was updated to point at the current build dependency install directory. + . $builddepsfile + # Now extract variables from the builddeps.conf files. + theroot=${builddep_freetype2_ROOT} + thecflags=${builddep_freetype2_CFLAGS} + thelibs=${builddep_freetype2_LIBS} + if test "x$depdir" = x; then + as_fn_error $? "Could not download build dependency freetype2" "$LINENO" 5 + fi + FREETYPE2=$depdir + if test "x$theroot" != x; then + FREETYPE2="$theroot" + fi + if test "x$thecflags" != x; then + FREETYPE2_CFLAGS="$thecflags" + fi + if test "x$thelibs" != x; then + FREETYPE2_LIBS="$thelibs" + fi + FREETYPE2_FOUND=yes + else FREETYPE2_FOUND=no + + fi + else FREETYPE2_FOUND=no + + fi + + USING_SYSTEM_FT_LIB=true + fi + if test "x$FREETYPE2_FOUND" = xno; then + +pkg_failed=no +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FREETYPE2" >&5 +$as_echo_n "checking for FREETYPE2... " >&6; } + +if test -n "$FREETYPE2_CFLAGS"; then + pkg_cv_FREETYPE2_CFLAGS="$FREETYPE2_CFLAGS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5 + ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_FREETYPE2_CFLAGS=`$PKG_CONFIG --cflags "freetype2" 2>/dev/null` +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi +if test -n "$FREETYPE2_LIBS"; then + pkg_cv_FREETYPE2_LIBS="$FREETYPE2_LIBS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5 + ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_FREETYPE2_LIBS=`$PKG_CONFIG --libs "freetype2" 2>/dev/null` +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi + + + +if test $pkg_failed = yes; then + +if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then + _pkg_short_errors_supported=yes +else + _pkg_short_errors_supported=no +fi + if test $_pkg_short_errors_supported = yes; then + FREETYPE2_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "freetype2" 2>&1` + else + FREETYPE2_PKG_ERRORS=`$PKG_CONFIG --print-errors "freetype2" 2>&1` + fi + # Put the nasty error message in config.log where it belongs + echo "$FREETYPE2_PKG_ERRORS" >&5 + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + FREETYPE2_FOUND=no +elif test $pkg_failed = untried; then + FREETYPE2_FOUND=no +else + FREETYPE2_CFLAGS=$pkg_cv_FREETYPE2_CFLAGS + FREETYPE2_LIBS=$pkg_cv_FREETYPE2_LIBS + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + FREETYPE2_FOUND=yes +fi + USING_SYSTEM_FT_LIB=true + fi + if test "x$FREETYPE2_FOUND" = xno; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype in some standard locations" >&5 +$as_echo_n "checking for freetype in some standard locations... " >&6; } + + if test -s /usr/X11/include/ft2build.h && test -d /usr/X11/include/freetype2/freetype; then + DEFAULT_FREETYPE_CFLAGS="-I/usr/X11/include/freetype2 -I/usr/X11/include" + DEFAULT_FREETYPE_LIBS="-L/usr/X11/lib -lfreetype" + fi + if test -s /usr/include/ft2build.h && test -d /usr/include/freetype2/freetype; then + DEFAULT_FREETYPE_CFLAGS="-I/usr/include/freetype2" + DEFAULT_FREETYPE_LIBS="-lfreetype" + fi + + PREV_CXXCFLAGS="$CXXFLAGS" + PREV_LDFLAGS="$LDFLAGS" + CXXFLAGS="$CXXFLAGS $DEFAULT_FREETYPE_CFLAGS" + LDFLAGS="$LDFLAGS $DEFAULT_FREETYPE_LIBS" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + #include FT_FREETYPE_H + int main() { return 0; } + +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + + # Yes, the default cflags and libs did the trick. + FREETYPE2_FOUND=yes + FREETYPE2_CFLAGS="$DEFAULT_FREETYPE_CFLAGS" + FREETYPE2_LIBS="$DEFAULT_FREETYPE_LIBS" + +else + + FREETYPE2_FOUND=no + +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + CXXCFLAGS="$PREV_CXXFLAGS" + LDFLAGS="$PREV_LDFLAGS" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE2_FOUND" >&5 +$as_echo "$FREETYPE2_FOUND" >&6; } + USING_SYSTEM_FT_LIB=true + fi + if test "x$FREETYPE2_FOUND" = xno; then + + # Print a helpful message on how to acquire the necessary build dependency. + # freetype2 is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=freetype2 + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + as_fn_error $? "Could not find freetype2! $HELP_MSG " "$LINENO" 5 + fi +fi + + + + + + + + + +############################################################################### +# +# Check for alsa headers and libraries. Used on Linux/GNU systems. +# + +# Check whether --with-alsa was given. +if test "${with_alsa+set}" = set; then : + withval=$with_alsa; +fi + + +# Check whether --with-alsa-include was given. +if test "${with_alsa_include+set}" = set; then : + withval=$with_alsa_include; +fi + + +# Check whether --with-alsa-lib was given. +if test "${with_alsa_lib+set}" = set; then : + withval=$with_alsa_lib; +fi + + +if test "x$ALSA_NOT_NEEDED" = xyes; then + if test "x${with_alsa}" != x || test "x${with_alsa_include}" != x || test "x${with_alsa_lib}" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: alsa not used, so --with-alsa is ignored" >&5 +$as_echo "$as_me: WARNING: alsa not used, so --with-alsa is ignored" >&2;} + fi + ALSA_CFLAGS= + ALSA_LIBS= +else + ALSA_FOUND=no + + if test "x${with_alsa}" = xno || test "x${with_alsa_include}" = xno || test "x${with_alsa_lib}" = xno; then + as_fn_error $? "It is not possible to disable the use of alsa. Remove the --without-alsa option." "$LINENO" 5 + fi + + if test "x${with_alsa}" != x; then + ALSA_LIBS="-L${with_alsa}/lib -lalsa" + ALSA_CFLAGS="-I${with_alsa}/include" + ALSA_FOUND=yes + fi + if test "x${with_alsa_include}" != x; then + ALSA_CFLAGS="-I${with_alsa_include}" + ALSA_FOUND=yes + fi + if test "x${with_alsa_lib}" != x; then + ALSA_LIBS="-L${with_alsa_lib} -lalsa" + ALSA_FOUND=yes + fi + if test "x$ALSA_FOUND" = xno; then + + + if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then + # Source the builddeps file again, to make sure it uses the latest variables! + . $builddepsfile + # Look for a target and build machine specific resource! + eval resource=\${builddep_alsa_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}} + if test "x$resource" = x; then + # Ok, lets instead look for a target specific resource + eval resource=\${builddep_alsa_TARGET_${rewritten_target_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a build specific resource + eval resource=\${builddep_alsa_BUILD_${rewritten_build_var}} + fi + if test "x$resource" = x; then + # Ok, lets instead look for a generic resource + # (The alsa comes from M4 and not the shell, thus no need for eval here.) + resource=${builddep_alsa} + fi + if test "x$resource" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for alsa" >&5 +$as_echo "$as_me: Using builddeps $resource for alsa" >&6;} + # If the resource in the builddeps.conf file is an existing directory, + # for example /java/linux/cups + if test -d ${resource}; then + depdir=${resource} + else + +# alsa is for example mymodule +# $resource is for example libs/general/libmymod_1_2_3.zip +# $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps +# $with_builddeps_dir is for example /localhome/builddeps +# depdir is the name of the variable into which we store the depdir, eg MYMOD +# Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and +# unzip into the directory: /localhome/builddeps/libmymod_1_2_3 + filename=`basename $resource` + filebase=`echo $filename | sed 's/\.[^\.]*$//'` + filebase=${filename%%.*} + extension=${filename#*.} + installdir=$with_builddeps_dir/$filebase + if test ! -f $installdir/$filename.unpacked; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&5 +$as_echo "$as_me: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&6;} + if test ! -d $installdir; then + mkdir -p $installdir + fi + if test ! -d $installdir; then + as_fn_error $? "Could not create directory $installdir" "$LINENO" 5 + fi + tmpfile=`mktemp $installdir/alsa.XXXXXXXXX` + touch $tmpfile + if test ! -f $tmpfile; then + as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5 + fi + + # $with_builddeps_server/$resource is the ftp://abuilddeps.server.com/libs/cups.zip + # $tmpfile is the local file name for the downloaded file. + VALID_TOOL=no + if test "x$BDEPS_FTP" = xwget; then + VALID_TOOL=yes + wget -O $tmpfile $with_builddeps_server/$resource + fi + if test "x$BDEPS_FTP" = xlftp; then + VALID_TOOL=yes + lftp -c "get $with_builddeps_server/$resource -o $tmpfile" + fi + if test "x$BDEPS_FTP" = xftp; then + VALID_TOOL=yes + FTPSERVER=`echo $with_builddeps_server/$resource | cut -f 3 -d '/'` + FTPPATH=`echo $with_builddeps_server/$resource | cut -f 4- -d '/'` + FTPUSERPWD=${FTPSERVER%%@*} + if test "x$FTPSERVER" != "x$FTPUSERPWD"; then + FTPUSER=${userpwd%%:*} + FTPPWD=${userpwd#*@} + FTPSERVER=${FTPSERVER#*@} + else + FTPUSER=ftp + FTPPWD=ftp + fi + # the "pass" command does not work on some + # ftp clients (read ftp.exe) but if it works, + # passive mode is better! + (\ + echo "user $FTPUSER $FTPPWD" ;\ + echo "pass" ;\ + echo "bin" ;\ + echo "get $FTPPATH $tmpfile" ;\ + ) | ftp -in $FTPSERVER + fi + if test "x$VALID_TOOL" != xyes; then + as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5 + fi + + mv $tmpfile $installdir/$filename + if test ! -s $installdir/$filename; then + as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5 + fi + case "$extension" in + zip) echo "Unzipping $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked) + ;; + tar.gz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + tgz) echo "Untaring $installdir/$filename..." + (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked) + ;; + *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5 + ;; + esac + fi + if test -f $installdir/$filename.unpacked; then + depdir=$installdir + fi + + fi + # Source the builddeps file again, because in the previous command, the depdir + # was updated to point at the current build dependency install directory. + . $builddepsfile + # Now extract variables from the builddeps.conf files. + theroot=${builddep_alsa_ROOT} + thecflags=${builddep_alsa_CFLAGS} + thelibs=${builddep_alsa_LIBS} + if test "x$depdir" = x; then + as_fn_error $? "Could not download build dependency alsa" "$LINENO" 5 + fi + ALSA=$depdir + if test "x$theroot" != x; then + ALSA="$theroot" + fi + if test "x$thecflags" != x; then + ALSA_CFLAGS="$thecflags" + fi + if test "x$thelibs" != x; then + ALSA_LIBS="$thelibs" + fi + ALSA_FOUND=yes + else ALSA_FOUND=no + + fi + else ALSA_FOUND=no + + fi + + fi + if test "x$ALSA_FOUND" = xno; then + +pkg_failed=no +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ALSA" >&5 +$as_echo_n "checking for ALSA... " >&6; } + +if test -n "$ALSA_CFLAGS"; then + pkg_cv_ALSA_CFLAGS="$ALSA_CFLAGS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5 + ($PKG_CONFIG --exists --print-errors "alsa") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_ALSA_CFLAGS=`$PKG_CONFIG --cflags "alsa" 2>/dev/null` +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi +if test -n "$ALSA_LIBS"; then + pkg_cv_ALSA_LIBS="$ALSA_LIBS" + elif test -n "$PKG_CONFIG"; then + if test -n "$PKG_CONFIG" && \ + { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5 + ($PKG_CONFIG --exists --print-errors "alsa") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + pkg_cv_ALSA_LIBS=`$PKG_CONFIG --libs "alsa" 2>/dev/null` +else + pkg_failed=yes +fi + else + pkg_failed=untried +fi + + + +if test $pkg_failed = yes; then + +if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then + _pkg_short_errors_supported=yes +else + _pkg_short_errors_supported=no +fi + if test $_pkg_short_errors_supported = yes; then + ALSA_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "alsa" 2>&1` + else + ALSA_PKG_ERRORS=`$PKG_CONFIG --print-errors "alsa" 2>&1` + fi + # Put the nasty error message in config.log where it belongs + echo "$ALSA_PKG_ERRORS" >&5 + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ALSA_FOUND=no +elif test $pkg_failed = untried; then + ALSA_FOUND=no +else + ALSA_CFLAGS=$pkg_cv_ALSA_CFLAGS + ALSA_LIBS=$pkg_cv_ALSA_LIBS + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + ALSA_FOUND=yes +fi + fi + if test "x$ALSA_FOUND" = xno; then + for ac_header in alsa/asoundlib.h +do : + ac_fn_cxx_check_header_mongrel "$LINENO" "alsa/asoundlib.h" "ac_cv_header_alsa_asoundlib_h" "$ac_includes_default" +if test "x$ac_cv_header_alsa_asoundlib_h" = x""yes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_ALSA_ASOUNDLIB_H 1 +_ACEOF + ALSA_FOUND=yes + ALSA_CFLAGS=-Iignoreme + ALSA_LIBS=-lasound + DEFAULT_ALSA=yes +else + ALSA_FOUND=no +fi + +done + + fi + if test "x$ALSA_FOUND" = xno; then + + # Print a helpful message on how to acquire the necessary build dependency. + # alsa is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=alsa + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + as_fn_error $? "Could not find alsa! $HELP_MSG " "$LINENO" 5 + fi +fi + + + + + + + +############################################################################### +# +# Check for the jpeg library +# + +USE_EXTERNAL_LIBJPEG=true +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -ljpeg" >&5 +$as_echo_n "checking for main in -ljpeg... " >&6; } +if test "${ac_cv_lib_jpeg_main+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ljpeg $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + +int +main () +{ +return main (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_jpeg_main=yes +else + ac_cv_lib_jpeg_main=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jpeg_main" >&5 +$as_echo "$ac_cv_lib_jpeg_main" >&6; } +if test "x$ac_cv_lib_jpeg_main" = x""yes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_LIBJPEG 1 +_ACEOF + + LIBS="-ljpeg $LIBS" + +else + USE_EXTERNAL_LIBJPEG=false + { $as_echo "$as_me:${as_lineno-$LINENO}: Will use jpeg decoder bundled with the OpenJDK source" >&5 +$as_echo "$as_me: Will use jpeg decoder bundled with the OpenJDK source" >&6;} + +fi + + + +############################################################################### +# +# Check for the gif library +# + +USE_EXTERNAL_LIBJPEG=true +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lgif" >&5 +$as_echo_n "checking for main in -lgif... " >&6; } +if test "${ac_cv_lib_gif_main+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lgif $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + +int +main () +{ +return main (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_gif_main=yes +else + ac_cv_lib_gif_main=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gif_main" >&5 +$as_echo "$ac_cv_lib_gif_main" >&6; } +if test "x$ac_cv_lib_gif_main" = x""yes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_LIBGIF 1 +_ACEOF + + LIBS="-lgif $LIBS" + +else + USE_EXTERNAL_LIBGIF=false + { $as_echo "$as_me:${as_lineno-$LINENO}: Will use gif decoder bundled with the OpenJDK source" >&5 +$as_echo "$as_me: Will use gif decoder bundled with the OpenJDK source" >&6;} + +fi + + + +############################################################################### +# +# Check for the zlib library +# + + +# Check whether --with-zlib was given. +if test "${with_zlib+set}" = set; then : + withval=$with_zlib; +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for compress in -lz" >&5 +$as_echo_n "checking for compress in -lz... " >&6; } +if test "${ac_cv_lib_z_compress+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lz $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char compress (); +int +main () +{ +return compress (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_z_compress=yes +else + ac_cv_lib_z_compress=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_compress" >&5 +$as_echo "$ac_cv_lib_z_compress" >&6; } +if test "x$ac_cv_lib_z_compress" = x""yes; then : + ZLIB_FOUND=yes +else + ZLIB_FOUND=no +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for which zlib to use" >&5 +$as_echo_n "checking for which zlib to use... " >&6; } + +DEFAULT_ZLIB=bundled +if test "x$OPENJDK_TARGET_OS" = xmacosx; then +# +# On macosx default is system...on others default is +# + DEFAULT_ZLIB=system +fi + +if test "x${ZLIB_FOUND}" != "xyes"; then +# +# If we don't find any system...set default to bundled +# + DEFAULT_ZLIB=bundled +fi + +# +# If user didn't specify, use DEFAULT_ZLIB +# +if test "x${with_zlib}" = "x"; then + with_zlib=${DEFAULT_ZLIB} +fi + +if test "x${with_zlib}" = "xbundled"; then + USE_EXTERNAL_LIBZ=false + { $as_echo "$as_me:${as_lineno-$LINENO}: result: bundled" >&5 +$as_echo "bundled" >&6; } +elif test "x${with_zlib}" = "xsystem"; then + if test "x${ZLIB_FOUND}" = "xyes"; then + USE_EXTERNAL_LIBZ=true + { $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5 +$as_echo "system" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: system not found" >&5 +$as_echo "system not found" >&6; } + as_fn_error $? "--with-zlib=system specified, but no zlib found!" "$LINENO" 5 + fi +else + as_fn_error $? "Invalid value for --with-zlib: ${with_zlib}, use 'system' or 'bundled'" "$LINENO" 5 +fi + + + +############################################################################### +LIBZIP_CAN_USE_MMAP=true +if test "x$JDK_VARIANT" = "xembedded"; then + LIBZIP_CAN_USE_MMAP=false +fi + + +############################################################################### +# +# Check if altzone exists in time.h +# + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +return (int)altzone; + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + has_altzone=yes +else + has_altzone=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test "x$has_altzone" = xyes; then + +$as_echo "#define HAVE_ALTZONE 1" >>confdefs.h + +fi + +############################################################################### +# +# Check the maths library +# + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5 +$as_echo_n "checking for cos in -lm... " >&6; } +if test "${ac_cv_lib_m_cos+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lm $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char cos (); +int +main () +{ +return cos (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_m_cos=yes +else + ac_cv_lib_m_cos=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5 +$as_echo "$ac_cv_lib_m_cos" >&6; } +if test "x$ac_cv_lib_m_cos" = x""yes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_LIBM 1 +_ACEOF + + LIBS="-lm $LIBS" + +else + + { $as_echo "$as_me:${as_lineno-$LINENO}: Maths library was not found" >&5 +$as_echo "$as_me: Maths library was not found" >&6;} + +fi + + + +############################################################################### +# +# Check for libdl.so + +save_LIBS="$LIBS" +LIBS="" +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if test "${ac_cv_lib_dl_dlopen+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = x""yes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_LIBDL 1 +_ACEOF + + LIBS="-ldl $LIBS" + +fi + +LIBDL="$LIBS" + +LIBS="$save_LIBS" + + + +############################################################################### +# +# statically link libstdc++ before C++ ABI is stablized on Linux unless +# dynamic build is configured on command line. +# +# Check whether --enable-static-link-stdc++ was given. +if test "${enable_static_link_stdc__+set}" = set; then : + enableval=$enable_static_link_stdc__; +else + + enable_static_link_stdc__=yes + +fi + + +if test "x$OPENJDK_TARGET_OS" = xlinux; then + # Test if -lstdc++ works. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if dynamic link of stdc++ is possible" >&5 +$as_echo_n "checking if dynamic link of stdc++ is possible... " >&6; } + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + OLD_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -lstdc++" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +return 0; + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + has_dynamic_libstdcxx=yes +else + has_dynamic_libstdcxx=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + CXXFLAGS="$OLD_CXXFLAGS" + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_dynamic_libstdcxx" >&5 +$as_echo "$has_dynamic_libstdcxx" >&6; } + + # Test if stdc++ can be linked statically. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if static link of stdc++ is possible" >&5 +$as_echo_n "checking if static link of stdc++ is possible... " >&6; } + STATIC_STDCXX_FLAGS="-Wl,-Bstatic -lstdc++ -lgcc -Wl,-Bdynamic" + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + OLD_LIBS="$LIBS" + OLD_CXX="$CXX" + LIBS="$STATIC_STDCXX_FLAGS" + CXX="$CC" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +return 0; + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + has_static_libstdcxx=yes +else + has_static_libstdcxx=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LIBS="$OLD_LIBS" + CXX="$OLD_CXX" + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_static_libstdcxx" >&5 +$as_echo "$has_static_libstdcxx" >&6; } + + if test "x$has_static_libcxx" = xno && test "x$has_dynamic_libcxx" = xno; then + as_fn_error $? "I cannot link to stdc++! Neither dynamically nor statically." "$LINENO" 5 + fi + + if test "x$enable_static_link_stdc__" = xyes && test "x$has_static_libstdcxx" = xno; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Static linking of libstdc++ was not possible reverting to dynamic linking." >&5 +$as_echo "$as_me: Static linking of libstdc++ was not possible reverting to dynamic linking." >&6;} + enable_static_link_stdc__=no + fi + + if test "x$enable_static_link_stdc__" = xno && test "x$has_dynamic_libstdcxx" = xno; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Dynamic linking of libstdc++ was not possible reverting to static linking." >&5 +$as_echo "$as_me: Dynamic linking of libstdc++ was not possible reverting to static linking." >&6;} + enable_static_link_stdc__=yes + fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to link with libstdc++" >&5 +$as_echo_n "checking how to link with libstdc++... " >&6; } + if test "x$enable_static_link_stdc__" = xyes; then + LIBCXX="$LIBCXX $STATIC_STDCXX_FLAGS" + LDCXX="$CC" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: static" >&5 +$as_echo "static" >&6; } + else + LIBCXX="$LIBCXX -lstdc++" + LDCXX="$CXX" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: dynamic" >&5 +$as_echo "dynamic" >&6; } + fi +fi + +# libCrun is the c++ runtime-library with SunStudio (roughly the equivalent of gcc's libstdc++.so) +if test "x$OPENJDK_TARGET_OS" = xsolaris && test "x$LIBCXX" = x; then + LIBCXX="/usr/lib${LEGACY_OPENJDK_TARGET_CPU3}/libCrun.so.1" +fi + +# TODO better (platform agnostic) test +if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$LIBCXX" = x && test "x$GCC" = xyes; then + LIBCXX="-lstdc++" +fi + + + + + +############################################################################### +# +# We need to do some final tweaking, when everything else is done. +# +############################################################################### + + +HOTSPOT_MAKE_ARGS="ALT_OUTPUTDIR=$HOTSPOT_OUTPUTDIR ALT_EXPORT_PATH=$HOTSPOT_DIST $HOTSPOT_TARGET" + + +# The name of the Service Agent jar. +SALIB_NAME="${LIBRARY_PREFIX}saproc${SHARED_LIBRARY_SUFFIX}" +if test "x$OPENJDK_TARGET_OS" = "xwindows"; then + SALIB_NAME="${LIBRARY_PREFIX}sawindbg${SHARED_LIBRARY_SUFFIX}" +fi + + + + +############################################################################### +# +# Configure parts of the build that only affect the build performance, +# not the result. +# +############################################################################### + + +# How many cores do we have on this build system? + +# Check whether --with-num-cores was given. +if test "${with_num_cores+set}" = set; then : + withval=$with_num_cores; +fi + +if test "x$with_num_cores" = x; then + # The number of cores were not specified, try to probe them. + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for number of cores" >&5 +$as_echo_n "checking for number of cores... " >&6; } + NUM_CORES=1 + FOUND_CORES=no + + if test -f /proc/cpuinfo; then + # Looks like a Linux system + NUM_CORES=`cat /proc/cpuinfo | grep -c processor` + FOUND_CORES=yes + fi + + if test -x /usr/sbin/psrinfo; then + # Looks like a Solaris system + NUM_CORES=`LC_MESSAGES=C /usr/sbin/psrinfo -v | grep -c on-line` + FOUND_CORES=yes + fi + + if test -x /usr/sbin/system_profiler; then + # Looks like a MacOSX system + NUM_CORES=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Cores' | awk '{print $5}'` + FOUND_CORES=yes + fi + + if test "x$build_os" = xwindows; then + NUM_CORES=4 + fi + + # For c/c++ code we run twice as many concurrent build + # jobs than we have cores, otherwise we will stall on io. + CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` + + if test "x$FOUND_CORES" = xyes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NUM_CORES" >&5 +$as_echo "$NUM_CORES" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect number of cores, defaulting to 1!" >&5 +$as_echo "could not detect number of cores, defaulting to 1!" >&6; } + fi + + +else + NUM_CORES=$with_num_cores + CONCURRENT_BUILD_JOBS=`expr $NUM_CORES \* 2` +fi + + + + +# How much memory do we have on this build system? + +# Check whether --with-memory-size was given. +if test "${with_memory_size+set}" = set; then : + withval=$with_memory_size; +fi + +if test "x$with_memory_size" = x; then + # The memory size was not specified, try to probe it. + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for memory size" >&5 +$as_echo_n "checking for memory size... " >&6; } + # Default to 1024MB + MEMORY_SIZE=1024 + FOUND_MEM=no + + if test -f /proc/cpuinfo; then + # Looks like a Linux system + MEMORY_SIZE=`cat /proc/meminfo | grep MemTotal | awk '{print $2}'` + MEMORY_SIZE=`expr $MEMORY_SIZE / 1024` + FOUND_MEM=yes + fi + + if test -x /usr/sbin/prtconf; then + # Looks like a Solaris system + MEMORY_SIZE=`/usr/sbin/prtconf | grep "Memory size" | awk '{ print $3 }'` + FOUND_MEM=yes + fi + + if test -x /usr/sbin/system_profiler; then + # Looks like a MacOSX system + MEMORY_SIZE=`/usr/sbin/system_profiler -detailLevel full SPHardwareDataType | grep 'Memory' | awk '{print $2}'` + MEMORY_SIZE=`expr $MEMORY_SIZE \* 1024` + FOUND_MEM=yes + fi + + if test "x$build_os" = xwindows; then + MEMORY_SIZE=`systeminfo | grep 'Total Physical Memory:' | awk '{ print $4 }' | sed 's/,//'` + FOUND_MEM=yes + fi + + if test "x$FOUND_MEM" = xyes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MEMORY_SIZE MB" >&5 +$as_echo "$MEMORY_SIZE MB" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect memory size defaulting to 1024MB!" >&5 +$as_echo "could not detect memory size defaulting to 1024MB!" >&6; } + fi + +else + MEMORY_SIZE=$with_memory_size +fi + + + +# Setup smart javac (after cores and memory have been setup) + + +# Check whether --with-server-java was given. +if test "${with_server_java+set}" = set; then : + withval=$with_server_java; +fi + + +if test "x$with_server_java" != x; then + SERVER_JAVA="$with_server_java" + FOUND_VERSION=`$SERVER_JAVA -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" = x; then + as_fn_error $? "Could not execute server java: $SERVER_JAVA" "$LINENO" 5 + fi +else + SERVER_JAVA="" + # Hotspot specific options. + + # Test if -XX:+UseParallelOldGC is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -XX:+UseParallelOldGC to SERVER_JAVA + FOUND_WARN=`$JAVA -XX:+UseParallelOldGC -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -XX:+UseParallelOldGC -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -XX:+UseParallelOldGC" + fi + + + # Test if -verbosegc is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -verbosegc to SERVER_JAVA + FOUND_WARN=`$JAVA -verbosegc -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -verbosegc -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -verbosegc" + fi + + # JRockit specific options. + + # Test if -Xverbose:gc is a valid argument to $JAVA (often is $JAVA passed as $JAVA) + # If so, then append -Xverbose:gc to SERVER_JAVA + FOUND_WARN=`$JAVA -Xverbose:gc -version 2>&1 | grep -i warn` + FOUND_VERSION=`$JAVA -Xverbose:gc -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xverbose:gc" + fi + + SERVER_JAVA="$JAVA $SERVER_JAVA" +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use shared server for javac" >&5 +$as_echo_n "checking whether to use shared server for javac... " >&6; } +# Check whether --enable-javac-server was given. +if test "${enable_javac_server+set}" = set; then : + enableval=$enable_javac_server; ENABLE_JAVAC_SERVER="${enableval}" +else + ENABLE_JAVAC_SERVER='no' +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JAVAC_SERVER" >&5 +$as_echo "$ENABLE_JAVAC_SERVER" >&6; } +if test "x$ENABLE_JAVAC_SERVER" = xyes; then + JAVAC_USE_REMOTE=true + JAVAC_SERVERS="$OUTPUT_ROOT/javacservers" +else + JAVAC_USE_REMOTE=false + JAVAC_SERVERS= +fi + + + + +# Check whether --with-javac-server-cores was given. +if test "${with_javac_server_cores+set}" = set; then : + withval=$with_javac_server_cores; +fi + +if test "x$with_javac_server_cores" != x; then + JAVAC_SERVER_CORES="$with_javac_server_cores" +else + if test "$NUM_CORES" -gt 16; then + # We set this arbitrary limit because we want to limit the heap + # size of the javac server. + # In the future we will make the javac compilers in the server + # share more and more state, thus enabling us to use more and + # more concurrent threads in the server. + JAVAC_SERVER_CORES="16" + else + JAVAC_SERVER_CORES="$NUM_CORES" + fi + + if test "$MEMORY_SIZE" -gt "17000"; then + MAX_HEAP_MEM=10000 + + # Test if -d64 is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -d64 to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -d64 -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -d64 -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -d64" + fi + + + # Test if -Xms10G -Xmx10G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xms10G -Xmx10G to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xms10G -Xmx10G -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xms10G -Xmx10G -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xms10G -Xmx10G" + fi + + + # Test if -Xmn2G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xmn2G to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xmn2G -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xmn2G -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xmn2G" + fi + + elif test "$MEMORY_SIZE" -gt "10000"; then + MAX_HEAP_MEM=6000 + + # Test if -d64 is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -d64 to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -d64 -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -d64 -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -d64" + fi + + + # Test if -Xms6G -Xmx6G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xms6G -Xmx6G to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xms6G -Xmx6G -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xms6G -Xmx6G -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xms6G -Xmx6G" + fi + + + # Test if -Xmn1G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xmn1G to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xmn1G -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xmn1G -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xmn1G" + fi + + elif test "$MEMORY_SIZE" -gt "5000"; then + MAX_HEAP_MEM=3000 + + # Test if -d64 is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -d64 to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -d64 -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -d64 -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -d64" + fi + + + # Test if -Xms1G -Xmx3G is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xms1G -Xmx3G to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xms1G -Xmx3G -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xms1G -Xmx3G -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xms1G -Xmx3G" + fi + + + # Test if -Xmn256M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xmn256M to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xmn256M" + fi + + elif test "$MEMORY_SIZE" -gt "3800"; then + MAX_HEAP_MEM=2500 + + # Test if -Xms1G -Xmx2500M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xms1G -Xmx2500M to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xms1G -Xmx2500M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xms1G -Xmx2500M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xms1G -Xmx2500M" + fi + + + # Test if -Xmn256M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xmn256M to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xmn256M" + fi + + elif test "$MEMORY_SIZE" -gt "1900"; then + MAX_HEAP_MEM=1200 + + # Test if -Xms700M -Xmx1200M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xms700M -Xmx1200M to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xms700M -Xmx1200M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xms700M -Xmx1200M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xms700M -Xmx1200M" + fi + + + # Test if -Xmn256M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xmn256M to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xmn256M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xmn256M" + fi + + elif test "$MEMORY_SIZE" -gt "1000"; then + MAX_HEAP_MEM=900 + + # Test if -Xms400M -Xmx900M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xms400M -Xmx900M to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xms400M -Xmx900M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xms400M -Xmx900M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xms400M -Xmx900M" + fi + + + # Test if -Xmn128M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xmn128M to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xmn128M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xmn128M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xmn128M" + fi + + else + MAX_HEAP_MEM=512 + + # Test if -Xms256M -Xmx512M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xms256M -Xmx512M to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xms256M -Xmx512M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xms256M -Xmx512M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xms256M -Xmx512M" + fi + + + # Test if -Xmn128M is a valid argument to $SERVER_JAVA (often is $JAVA passed as $SERVER_JAVA) + # If so, then append -Xmn128M to SERVER_JAVA + FOUND_WARN=`$SERVER_JAVA -Xmn128M -version 2>&1 | grep -i warn` + FOUND_VERSION=`$SERVER_JAVA -Xmn128M -version 2>&1 | grep " version \""` + if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then + SERVER_JAVA="$SERVER_JAVA -Xmn128M" + fi + + fi + + MAX_COMPILERS_IN_HEAP=`expr $MAX_HEAP_MEM / 501` + if test "$JAVAC_SERVER_CORES" -gt "$MAX_COMPILERS_IN_HEAP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if number of server cores must be reduced" >&5 +$as_echo_n "checking if number of server cores must be reduced... " >&6; } + JAVAC_SERVER_CORES="$MAX_COMPILERS_IN_HEAP" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, to $JAVAC_SERVER_CORES with max heap size $MAX_HEAP_MEM MB" >&5 +$as_echo "yes, to $JAVAC_SERVER_CORES with max heap size $MAX_HEAP_MEM MB" >&6; } + fi +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to track dependencies between Java packages" >&5 +$as_echo_n "checking whether to track dependencies between Java packages... " >&6; } +# Check whether --enable-javac-deps was given. +if test "${enable_javac_deps+set}" = set; then : + enableval=$enable_javac_deps; ENABLE_JAVAC_DEPS="${enableval}" +else + ENABLE_JAVAC_DEPS='no' +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JAVAC_DEPS" >&5 +$as_echo "$ENABLE_JAVAC_DEPS" >&6; } +if test "x$ENABLE_JAVAC_DEPS" = xyes; then + JAVAC_USE_DEPS=true +else + JAVAC_USE_DEPS=false +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use multiple cores for javac compilation" >&5 +$as_echo_n "checking whether to use multiple cores for javac compilation... " >&6; } +# Check whether --enable-javac-multi-core was given. +if test "${enable_javac_multi_core+set}" = set; then : + enableval=$enable_javac_multi_core; ENABLE_JAVAC_MULTICORE="${enableval}" +else + ENABLE_JAVAC_MULTICORE='no' +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JAVAC_MULTICORE" >&5 +$as_echo "$ENABLE_JAVAC_MULTICORE" >&6; } +if test "x$ENABLE_JAVAC_MULTICORE" = xyes; then + JAVAC_USE_MODE=MULTI_CORE_CONCURRENT +else + JAVAC_USE_MODE=SINGLE_THREADED_BATCH + if test "x$ENABLE_JAVAC_DEPS" = xyes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Dependency tracking is not supported with single threaded batch compiles of Java source roots. Please add --disable-javac-deps to your configure options." >&5 +$as_echo "$as_me: WARNING: Dependency tracking is not supported with single threaded batch compiles of Java source roots. Please add --disable-javac-deps to your configure options." >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Disabling dependency tracking for you now." >&5 +$as_echo "$as_me: WARNING: Disabling dependency tracking for you now." >&2;} + JAVAC_USE_DEPS=false + fi + if test "x$ENABLE_JAVAC_SERVER" = xyes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The javac server will not be used since single threaded batch compiles are run within their own JVM. Please add --disable-javac-server to your configure options." >&5 +$as_echo "$as_me: WARNING: The javac server will not be used since single threaded batch compiles are run within their own JVM. Please add --disable-javac-server to your configure options." >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Disabling javac server for you now." >&5 +$as_echo "$as_me: WARNING: Disabling javac server for you now." >&2;} + JAVAC_USE_REMOTE=false + fi +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use sjavac" >&5 +$as_echo_n "checking whether to use sjavac... " >&6; } +# Check whether --enable-sjavac was given. +if test "${enable_sjavac+set}" = set; then : + enableval=$enable_sjavac; ENABLE_SJAVAC="${enableval}" +else + ENABLE_SJAVAC='no' +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_SJAVAC" >&5 +$as_echo "$ENABLE_SJAVAC" >&6; } + + + + +# Can the C/C++ compiler use precompiled headers? + + +############################################################################### +# +# Can the C/C++ compiler use precompiled headers? +# +# Check whether --enable-precompiled-headers was given. +if test "${enable_precompiled_headers+set}" = set; then : + enableval=$enable_precompiled_headers; ENABLE_PRECOMPH=${enable_precompiled-headers} +else + ENABLE_PRECOMPH=yes +fi + + +USE_PRECOMPILED_HEADER=1 +if test "x$ENABLE_PRECOMPH" = xno; then + USE_PRECOMPILED_HEADER=0 +fi + +if test "x$ENABLE_PRECOMPH" = xyes; then + # Check that the compiler actually supports precomp headers. + if test "x$GCC" = xyes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking that precompiled headers work" >&5 +$as_echo_n "checking that precompiled headers work... " >&6; } + echo "int alfa();" > conftest.h + $CXX -x c++-header conftest.h -o conftest.hpp.gch + if test ! -f conftest.hpp.gch; then + echo Precompiled header is not working! + USE_PRECOMPILED_HEADER=0 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + fi + rm -f conftest.h + fi +fi + + + + +# Setup use of ccache, if available + + # Check whether --enable-ccache was given. +if test "${enable_ccache+set}" = set; then : + enableval=$enable_ccache; ENABLE_CCACHE=${enable_ccache} +else + ENABLE_CCACHE=yes +fi + + if test "x$ENABLE_CCACHE" = xyes; then + # Extract the first word of "ccache", so it can be a program name with args. +set dummy ccache; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if test "${ac_cv_path_CCACHE+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + case $CCACHE in + [\\/]* | ?:[\\/]*) + ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CCACHE=$ac_cv_path_CCACHE +if test -n "$CCACHE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5 +$as_echo "$CCACHE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ccache" >&5 +$as_echo_n "checking for ccache... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: explicitly disabled" >&5 +$as_echo "explicitly disabled" >&6; } + CCACHE= + fi + + + +# Check whether --with-ccache-dir was given. +if test "${with_ccache_dir+set}" = set; then : + withval=$with_ccache_dir; +fi + + + if test "x$with_ccache_dir" != x; then + # When using a non home ccache directory, assume the use is to share ccache files + # with other users. Thus change the umask. + SET_CCACHE_DIR="CCACHE_DIR=$with_ccache_dir CCACHE_UMASK=002" + fi + CCACHE_FOUND="" + if test "x$CCACHE" != x; then + + if test "x$CCACHE" != x; then + CCACHE_FOUND="true" + # Only use ccache if it is 3.1.4 or later, which supports + # precompiled headers. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if ccache supports precompiled headers" >&5 +$as_echo_n "checking if ccache supports precompiled headers... " >&6; } + HAS_GOOD_CCACHE=`($CCACHE --version | head -n 1 | grep -E 3.1.[456789]) 2> /dev/null` + if test "x$HAS_GOOD_CCACHE" = x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, disabling ccache" >&5 +$as_echo "no, disabling ccache" >&6; } + CCACHE= + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if C-compiler supports ccache precompiled headers" >&5 +$as_echo_n "checking if C-compiler supports ccache precompiled headers... " >&6; } + PUSHED_FLAGS="$CXXFLAGS" + CXXFLAGS="-fpch-preprocess $CXXFLAGS" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + CC_KNOWS_CCACHE_TRICK=yes +else + CC_KNOWS_CCACHE_TRICK=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + CXXFLAGS="$PUSHED_FLAGS" + if test "x$CC_KNOWS_CCACHE_TRICK" = xyes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, disabling ccaching of precompiled headers" >&5 +$as_echo "no, disabling ccaching of precompiled headers" >&6; } + CCACHE= + fi + fi + fi + + if test "x$CCACHE" != x; then + CCACHE_SLOPPINESS=time_macros + CCACHE="CCACHE_COMPRESS=1 $SET_CCACHE_DIR CCACHE_SLOPPINESS=$CCACHE_SLOPPINESS $CCACHE" + CCACHE_FLAGS=-fpch-preprocess + + if test "x$SET_CCACHE_DIR" != x; then + mkdir -p $CCACHE_DIR > /dev/null 2>&1 + chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1 + fi + fi + + fi + + +############################################################################### +# +# And now the finish... +# +############################################################################### + +# Check for some common pitfalls + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5 +$as_echo_n "checking if build directory is on local disk... " >&6; } + + # df -l lists only local disks; if the given directory is not found then + # a non-zero exit code is given + if $DF -l $OUTPUT_ROOT > /dev/null 2>&1; then + OUTPUT_DIR_IS_LOCAL="yes" + else + OUTPUT_DIR_IS_LOCAL="no" + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_DIR_IS_LOCAL" >&5 +$as_echo "$OUTPUT_DIR_IS_LOCAL" >&6; } + +# Check if the user has any old-style ALT_ variables set. +FOUND_ALT_VARIABLES=`env | grep ^ALT_` + +# Before generating output files, test if they exist. If they do, this is a reconfigure. +# Since we can't properly handle the dependencies for this, warn the user about the situation +if test -e $OUTPUT_ROOT/spec.gmk; then + IS_RECONFIGURE=yes +else + IS_RECONFIGURE=no +fi + +if test -e $SRC_ROOT/build/.hide-configure-performance-hints; then + HIDE_PERFORMANCE_HINTS=yes +else + HIDE_PERFORMANCE_HINTS=no + # Hide it the next time around... + $TOUCH $SRC_ROOT/build/.hide-configure-performance-hints > /dev/null 2>&1 +fi + + + +# At the end, call the closed hook. (Dummy macro if no closed sources available) + + +# We're messing a bit with internal autoconf variables to put the config.status +# in the output directory instead of the current directory. +CONFIG_STATUS="$OUTPUT_ROOT/config.status" +# Create the actual output files. Now the main work of configure is done. +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +( + for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + + (set) 2>&1 | + case $as_nl`(ac_space=' '; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + # `set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. + sed -n \ + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" + ;; #( + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) | + sed ' + /^ac_cv_env_/b end + t clear + :clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + :end' >>confcache +if diff "$cache_file" confcache >/dev/null 2>&1; then :; else + if test -w "$cache_file"; then + test "x$cache_file" != "x/dev/null" && + { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +$as_echo "$as_me: updating cache $cache_file" >&6;} + cat confcache >$cache_file + else + { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +DEFS=-DHAVE_CONFIG_H + +ac_libobjs= +ac_ltlibobjs= +U= +for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' + ac_i=`$as_echo "$ac_i" | sed "$ac_script"` + # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR + # will be set to the directory where LIBOBJS objects are built. + as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" + as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' +done +LIBOBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + + +: ${CONFIG_STATUS=./config.status} +ac_write_fail=0 +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +as_write_fail=0 +cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false + +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -p'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -p' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -p' + fi +else + as_ln_s='cp -p' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +if test -x / >/dev/null 2>&1; then + as_test_x='test -x' +else + if ls -dL / >/dev/null 2>&1; then + as_ls_L_option=L + else + as_ls_L_option= + fi + as_test_x=' + eval sh -c '\'' + if test -d "$1"; then + test -d "$1/."; + else + case $1 in #( + -*)set "./$1";; + esac; + case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( + ???[sx]*):;;*)false;;esac;fi + '\'' sh + ' +fi +as_executable_p=$as_test_x + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# Save the log message, to keep $0 and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. +ac_log=" +This file was extended by openjdk $as_me jdk8, which was +generated by GNU Autoconf 2.67. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +on `(hostname || uname -n) 2>/dev/null | sed 1q` +" + +_ACEOF + +case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$*;; +esac + +case $ac_config_headers in *" +"*) set x $ac_config_headers; shift; ac_config_headers=$*;; +esac + + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# Files that config.status was made for. +config_files="$ac_config_files" +config_headers="$ac_config_headers" + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +ac_cs_usage="\ +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. + +Usage: $0 [OPTION]... [TAG]... + + -h, --help print this help, then exit + -V, --version print version number and configuration settings, then exit + --config print configuration, then exit + -q, --quiet, --silent + do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE + +Configuration files: +$config_files + +Configuration headers: +$config_headers + +Report bugs to ." + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_version="\\ +openjdk config.status jdk8 +configured by $0, generated by GNU Autoconf 2.67, + with options \\"\$ac_cs_config\\" + +Copyright (C) 2010 Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." + +ac_pwd='$ac_pwd' +srcdir='$srcdir' +AWK='$AWK' +test -n "\$AWK" || AWK=awk +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# The default lists apply if the user does not specify any file. +ac_need_defaults=: +while test $# != 0 +do + case $1 in + --*=?*) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` + ac_shift=: + ;; + --*=) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg= + ac_shift=: + ;; + *) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + esac + + case $ac_option in + # Handling of the options. + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) + $as_echo "$ac_cs_version"; exit ;; + --config | --confi | --conf | --con | --co | --c ) + $as_echo "$ac_cs_config"; exit ;; + --debug | --debu | --deb | --de | --d | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + '') as_fn_error $? "missing file argument" ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" + ac_need_defaults=false;; + --header | --heade | --head | --hea ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_HEADERS " '$ac_optarg'" + ac_need_defaults=false;; + --he | --h) + # Conflict between --help and --header + as_fn_error $? "ambiguous option: \`$1' +Try \`$0 --help' for more information.";; + --help | --hel | -h ) + $as_echo "$ac_cs_usage"; exit ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) as_fn_error $? "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; + + *) as_fn_append ac_config_targets " $1" + ac_need_defaults=false ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +if \$ac_cs_recheck; then + set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + shift + \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + CONFIG_SHELL='$SHELL' + export CONFIG_SHELL + exec "\$@" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX + $as_echo "$ac_log" +} >&5 + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + +# Handling of arguments. +for ac_config_target in $ac_config_targets +do + case $ac_config_target in + "$OUTPUT_ROOT/config.h") CONFIG_HEADERS="$CONFIG_HEADERS $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in" ;; + "$OUTPUT_ROOT/spec.gmk") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in" ;; + "$OUTPUT_ROOT/spec.sh") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in" ;; + "$OUTPUT_ROOT/Makefile") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in" ;; + + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5 ;; + esac +done + + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason against having it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Hook for its removal unless debugging. +# Note that there is a small window in which the directory will not be cleaned: +# after its creation but before its name has been assigned to `$tmp'. +$debug || +{ + tmp= + trap 'exit_status=$? + { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status +' 0 + trap 'as_fn_exit 1' 1 2 13 15 +} +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && + test -n "$tmp" && test -d "$tmp" +} || +{ + tmp=./conf$$-$RANDOM + (umask 077 && mkdir "$tmp") +} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 + +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. +if test -n "$CONFIG_FILES"; then + + +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$tmp/subs1.awk" && +_ACEOF + + +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + echo "_ACEOF" +} >conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 +ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim='%!_!# ' +for ac_last_try in false false false false false :; do + . ./conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + if test $ac_delim_n = $ac_delim_num; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done +rm -f conf$$subs.sh + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{148\}\)..*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t nl +:delim +h +s/\(.\{148\}\)..*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t delim +' >$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} + +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \ + || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 +_ACEOF + +# VPATH may cause trouble with some makes, so we remove sole $(srcdir), +# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ +h +s/// +s/^/:/ +s/[ ]*$/:/ +s/:\$(srcdir):/:/g +s/:\${srcdir}:/:/g +s/:@srcdir@:/:/g +s/^:*// +s/:*$// +x +s/\(=[ ]*\).*/\1/ +G +s/\n// +s/^[^=]*=[ ]*$// +}' +fi + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +fi # test -n "$CONFIG_FILES" + +# Set up the scripts for CONFIG_HEADERS section. +# No need to generate them if there are no CONFIG_HEADERS. +# This happens for instance with `./config.status Makefile'. +if test -n "$CONFIG_HEADERS"; then +cat >"$tmp/defines.awk" <<\_ACAWK || +BEGIN { +_ACEOF + +# Transform confdefs.h into an awk script `defines.awk', embedded as +# here-document in config.status, that substitutes the proper values into +# config.h.in to produce config.h. + +# Create a delimiter string that does not exist in confdefs.h, to ease +# handling of long lines. +ac_delim='%!_!# ' +for ac_last_try in false false :; do + ac_t=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_t"; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done + +# For the awk script, D is an array of macro values keyed by name, +# likewise P contains macro parameters if any. Preserve backslash +# newline sequences. + +ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* +sed -n ' +s/.\{148\}/&'"$ac_delim"'/g +t rset +:rset +s/^[ ]*#[ ]*define[ ][ ]*/ / +t def +d +:def +s/\\$// +t bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3"/p +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p +d +:bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3\\\\\\n"\\/p +t cont +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p +t cont +d +:cont +n +s/.\{148\}/&'"$ac_delim"'/g +t clear +:clear +s/\\$// +t bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/"/p +d +:bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p +b cont +' >$CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + for (key in D) D_is_set[key] = 1 + FS = "" +} +/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { + line = \$ 0 + split(line, arg, " ") + if (arg[1] == "#") { + defundef = arg[2] + mac1 = arg[3] + } else { + defundef = substr(arg[1], 2) + mac1 = arg[2] + } + split(mac1, mac2, "(") #) + macro = mac2[1] + prefix = substr(line, 1, index(line, defundef) - 1) + if (D_is_set[macro]) { + # Preserve the white space surrounding the "#". + print prefix "define", macro P[macro] D[macro] + next + } else { + # Replace #undef with comments. This is necessary, for example, + # in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + if (defundef == "undef") { + print "/*", prefix defundef, macro, "*/" + next + } + } +} +{ print } +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 +fi # test -n "$CONFIG_HEADERS" + + +eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS " +shift +for ac_tag +do + case $ac_tag in + :[FHLC]) ac_mode=$ac_tag; continue;; + esac + case $ac_mode$ac_tag in + :[FHL]*:*);; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5 ;; + :[FH]-) ac_tag=-:-;; + :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; + esac + ac_save_IFS=$IFS + IFS=: + set x $ac_tag + IFS=$ac_save_IFS + shift + ac_file=$1 + shift + + case $ac_mode in + :L) ac_source=$1;; + :[FH]) + ac_file_inputs= + for ac_f + do + case $ac_f in + -) ac_f="$tmp/stdin";; + *) # Look for the file first in the build tree, then in the source tree + # (if the path is not absolute). The absolute path cannot be DOS-style, + # because $ac_f cannot contain `:'. + test -f "$ac_f" || + case $ac_f in + [\\/$]*) false;; + *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; + esac || + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5 ;; + esac + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" + done + + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' + if test x"$ac_file" != x-; then + configure_input="$ac_file. $configure_input" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} + fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac + + case $ac_tag in + *:-:* | *:-) cat >"$tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + esac + ;; + esac + + ac_dir=`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir="$ac_dir"; as_fn_mkdir_p + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + + case $ac_mode in + :F) + # + # CONFIG_FILE + # + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# If the template does not know about datarootdir, expand it. +# FIXME: This hack should be removed a few years after 2.60. +ac_datarootdir_hack=; ac_datarootdir_seen= +ac_sed_dataroot=' +/datarootdir/ { + p + q +} +/@datadir@/p +/@docdir@/p +/@infodir@/p +/@localedir@/p +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in +*datarootdir*) ac_datarootdir_seen=yes;; +*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + ac_datarootdir_hack=' + s&@datadir@&$datadir&g + s&@docdir@&$docdir&g + s&@infodir@&$infodir&g + s&@localedir@&$localedir&g + s&@mandir@&$mandir&g + s&\\\${datarootdir}&$datarootdir&g' ;; +esac +_ACEOF + +# Neutralize VPATH when `$srcdir' = `.'. +# Shell code in configure.ac might set extrasub. +# FIXME: do we really want to maintain this feature? +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_sed_extra="$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +:t +/@[a-zA-Z_][a-zA-Z_0-9]*@/!b +s|@configure_input@|$ac_sed_conf_input|;t t +s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t +s&@srcdir@&$ac_srcdir&;t t +s&@abs_srcdir@&$ac_abs_srcdir&;t t +s&@top_srcdir@&$ac_top_srcdir&;t t +s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t +s&@builddir@&$ac_builddir&;t t +s&@abs_builddir@&$ac_abs_builddir&;t t +s&@abs_top_builddir@&$ac_abs_top_builddir&;t t +$ac_datarootdir_hack +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + +test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && + { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&5 +$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&2;} + + rm -f "$tmp/stdin" + case $ac_file in + -) cat "$tmp/out" && rm -f "$tmp/out";; + *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";; + esac \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + ;; + :H) + # + # CONFIG_HEADER + # + if test x"$ac_file" != x-; then + { + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" + } >"$tmp/config.h" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then + { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +$as_echo "$as_me: $ac_file is unchanged" >&6;} + else + rm -f "$ac_file" + mv "$tmp/config.h" "$ac_file" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + fi + else + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \ + || as_fn_error $? "could not create -" "$LINENO" 5 + fi + ;; + + + esac + +done # for ac_tag + + +as_fn_exit 0 +_ACEOF +ac_clean_files=$ac_clean_files_save + +test $ac_write_fail = 0 || + as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec 5>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec 5>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || as_fn_exit 1 +fi +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} +fi + + +# Finally output some useful information to the user + +# Finally output some useful information to the user + +if test "x$CCACHE_FOUND" != x; then + if test "x$HAS_GOOD_CCACHE" = x; then + CCACHE_STATUS="installed, but disabled (version older than 3.1.4)" + CCACHE_HELP_MSG="You have ccache installed, but it is a version prior to 3.1.4. Try upgrading." + else + CCACHE_STATUS="installed and in use" + fi +else + if test "x$GCC" = xyes; then + CCACHE_STATUS="not installed (consider installing)" + CCACHE_HELP_MSG="You do not have ccache installed. Try installing it." + else + CCACHE_STATUS="not available for your system" + fi +fi + +printf "\n" +printf "====================================================\n" +printf "A new configuration has been successfully created in\n" +printf "$OUTPUT_ROOT\n" +if test "x$CONFIGURE_COMMAND_LINE" != x; then + printf "using configure arguments '$CONFIGURE_COMMAND_LINE'.\n" +else + printf "using default settings.\n" +fi + +printf "\n" +printf "Configuration summary:\n" +printf "* Debug level: $DEBUG_LEVEL\n" +printf "* JDK variant: $JDK_VARIANT\n" +printf "* JVM variants: $with_jvm_variants\n" +printf "* OpenJDK target: OS: $OPENJDK_TARGET_OS, CPU architecture: $OPENJDK_TARGET_CPU_ARCH, address length: $OPENJDK_TARGET_CPU_BITS\n" +printf "* Boot JDK: $BOOT_JDK\n" + +printf "\n" +printf "Build performance summary:\n" +printf "* Cores to use: $NUM_CORES\n" +printf "* Memory limit: $MEMORY_SIZE MB\n" +printf "* ccache status: $CCACHE_STATUS\n" +printf "\n" + +if test "x$CCACHE_HELP_MSG" != x && test "x$HIDE_PERFORMANCE_HINTS" = "xno"; then + printf "Build performance tip: ccache gives a tremendous speedup for C++ recompilations.\n" + printf "$CCACHE_HELP_MSG\n" + + # Print a helpful message on how to acquire the necessary build dependency. + # ccache is the help tag: freetyp2, cups, pulse, alsa etc + MISSING_DEPENDENCY=ccache + PKGHANDLER_COMMAND= + + case $PKGHANDLER in + apt-get) + apt_help $MISSING_DEPENDENCY ;; + yum) + yum_help $MISSING_DEPENDENCY ;; + port) + port_help $MISSING_DEPENDENCY ;; + pkgutil) + pkgutil_help $MISSING_DEPENDENCY ;; + pkgadd) + pkgadd_help $MISSING_DEPENDENCY ;; + * ) + break ;; + esac + + if test "x$PKGHANDLER_COMMAND" != x; then + HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'." + fi + + printf "$HELP_MSG\n" + printf "\n" +fi + +if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xyes"; then + printf "NOTE: You have requested to build more than one version of the JVM, which\n" + printf "will result in longer build times.\n" + printf "\n" +fi + +if test "x$FOUND_ALT_VARIABLES" != "x"; then + printf "WARNING: You have old-style ALT_ environment variables set.\n" + printf "These are not respected, and will be ignored. It is recommended\n" + printf "that you clean your environment. The following variables are set:\n" + printf "$FOUND_ALT_VARIABLES\n" + printf "\n" +fi + +if test "x$OUTPUT_DIR_IS_LOCAL" != "xyes"; then + printf "WARNING: Your build output directory is not on a local disk.\n" + printf "This will severely degrade build performance!\n" + printf "It is recommended that you create an output directory on a local disk,\n" + printf "and run the configure script again from that directory.\n" + printf "\n" +fi + +if test "x$IS_RECONFIGURE" = "xyes"; then + printf "WARNING: The result of this configuration has overridden an older\n" + printf "configuration. You *should* run 'make clean' to make sure you get a\n" + printf "proper build. Failure to do so might result in strange build problems.\n" + printf "\n" +fi + diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4 new file mode 100644 index 00000000000..28266251f99 --- /dev/null +++ b/common/autoconf/jdk-options.m4 @@ -0,0 +1,551 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_VARIANT], +[ +############################################################################### +# +# Check which variant of the JDK that we want to build. +# Currently we have: +# normal: standard edition +# embedded: cut down to a smaller footprint +# +# Effectively the JDK variant gives a name to a specific set of +# modules to compile into the JDK. In the future, these modules +# might even be Jigsaw modules. +# +AC_MSG_CHECKING([which variant of the JDK to build]) +AC_ARG_WITH([jdk-variant], [AS_HELP_STRING([--with-jdk-variant], + [JDK variant to build (normal, embedded) @<:@normal@:>@])]) + +if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then + JAVASE_EMBEDDED="" + MINIMIZE_RAM_USAGE="" + JDK_VARIANT="normal" +elif test "x$with_jdk_variant" = xembedded; then + JAVASE_EMBEDDED="JAVASE_EMBEDDED:=true" + MINIMIZE_RAM_USAGE="MINIMIZE_RAM_USAGE:=true" + JDK_VARIANT="embedded" +else + AC_MSG_ERROR([The available JDK variants are: normal, embedded]) +fi + +AC_SUBST(JAVASE_EMBEDDED) +AC_SUBST(MINIMIZE_RAM_USAGE) +AC_SUBST(JDK_VARIANT) + +AC_MSG_RESULT([$JDK_VARIANT]) +]) + +AC_DEFUN_ONCE([JDKOPT_SETUP_JVM_VARIANTS], +[ + +############################################################################### +# +# Check which variants of the JVM that we want to build. +# Currently we have: +# server: normal interpreter and a tiered C1/C2 compiler +# client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms) +# kernel: kernel footprint JVM that passes the TCK without major performance problems, +# ie normal interpreter and C1, only the serial GC, kernel jvmti etc +# zero: no machine code interpreter, no compiler +# zeroshark: zero interpreter and shark/llvm compiler backend +AC_MSG_CHECKING([which variants of the JVM that should be built]) +AC_ARG_WITH([jvm-variants], [AS_HELP_STRING([--with-jvm-variants], + [JVM variants (separated by commas) to build (server, client, kernel, zero, zeroshark) @<:@server@:>@])]) + +if test "x$with_jvm_variants" = x; then + if test "x$JDK_VARIANT" = xembedded; then + with_jvm_variants="client" + else + with_jvm_variants="server" + fi +fi + +JVM_VARIANTS=",$with_jvm_variants," +TEST_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,//' -e 's/client,//' -e 's/kernel,//' -e 's/zero,//' -e 's/zeroshark,//'` + +if test "x$TEST_VARIANTS" != "x,"; then + AC_MSG_ERROR([The available JVM variants are: server, client, kernel, zero, zeroshark]) +fi +AC_MSG_RESULT([$with_jvm_variants]) + +JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'` +JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'` +JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'` +JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'` +JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'` + +if test "x$JVM_VARIANT_CLIENT" = xtrue; then + if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then + AC_MSG_ERROR([You cannot build a client JVM for a 64-bit machine.]) + fi +fi +if test "x$JVM_VARIANT_KERNEL" = xtrue; then + if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then + AC_MSG_ERROR([You cannot build a kernel JVM for a 64-bit machine.]) + fi +fi + +# Replace the commas with AND for use in the build directory name. +ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/'` +COUNT_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,/1/' -e 's/client,/1/' -e 's/kernel,/1/' -e 's/zero,/1/' -e 's/zeroshark,/1/'` +if test "x$COUNT_VARIANTS" != "x,1"; then + BUILDING_MULTIPLE_JVM_VARIANTS=yes +else + BUILDING_MULTIPLE_JVM_VARIANTS=no +fi + +AC_SUBST(JVM_VARIANTS) +AC_SUBST(JVM_VARIANT_SERVER) +AC_SUBST(JVM_VARIANT_CLIENT) +AC_SUBST(JVM_VARIANT_KERNEL) +AC_SUBST(JVM_VARIANT_ZERO) +AC_SUBST(JVM_VARIANT_ZEROSHARK) + + +]) + +AC_DEFUN_ONCE([JDKOPT_SETUP_DEBUG_LEVEL], +[ +############################################################################### +# +# Set the debug level +# release: no debug information, all optimizations, no asserts. +# fastdebug: debug information (-g), all optimizations, all asserts +# slowdebug: debug information (-g), no optimizations, all asserts +# +DEBUG_LEVEL="release" +AC_MSG_CHECKING([which debug level to use]) +AC_ARG_ENABLE([debug], [AS_HELP_STRING([--enable-debug], + [set the debug level to fastdebug (shorthand for --with-debug-level=fastdebug) @<:@disabled@:>@])], + [ + ENABLE_DEBUG="${enableval}" + DEBUG_LEVEL="fastdebug" + ], [ENABLE_DEBUG="no"]) + +AC_ARG_WITH([debug-level], [AS_HELP_STRING([--with-debug-level], + [set the debug level (release, fastdebug, slowdebug) @<:@release@:>@])], + [ + DEBUG_LEVEL="${withval}" + if test "x$ENABLE_DEBUG" = xyes; then + AC_MSG_ERROR([You cannot use both --enable-debug and --with-debug-level at the same time.]) + fi + ]) +AC_MSG_RESULT([$DEBUG_LEVEL]) + +if test "x$DEBUG_LEVEL" != xrelease && \ + test "x$DEBUG_LEVEL" != xfastdebug && \ + test "x$DEBUG_LEVEL" != xslowdebug; then + AC_MSG_ERROR([Allowed debug levels are: release, fastdebug and slowdebug]) +fi + + +############################################################################### +# +# Setup legacy vars/targets and new vars to deal with different debug levels. +# + +case $DEBUG_LEVEL in + release ) + VARIANT="OPT" + FASTDEBUG="false" + DEBUG_CLASSFILES="false" + BUILD_VARIANT_RELEASE="" + HOTSPOT_DEBUG_LEVEL="product" + HOTSPOT_EXPORT="product" + ;; + fastdebug ) + VARIANT="DBG" + FASTDEBUG="true" + DEBUG_CLASSFILES="true" + BUILD_VARIANT_RELEASE="-fastdebug" + HOTSPOT_DEBUG_LEVEL="fastdebug" + HOTSPOT_EXPORT="fastdebug" + ;; + slowdebug ) + VARIANT="DBG" + FASTDEBUG="false" + DEBUG_CLASSFILES="true" + BUILD_VARIANT_RELEASE="-debug" + HOTSPOT_DEBUG_LEVEL="jvmg" + HOTSPOT_EXPORT="debug" + ;; +esac + +##### +# Generate the legacy makefile targets for hotspot. +# The hotspot api for selecting the build artifacts, really, needs to be improved. +# +HOTSPOT_TARGET="" + +if test "x$JVM_VARIANT_SERVER" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} " +fi + +if test "x$JVM_VARIANT_CLIENT" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 " +fi + +if test "x$JVM_VARIANT_KERNEL" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel " +fi + +if test "x$JVM_VARIANT_ZERO" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero " +fi + +if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then + HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark " +fi + +HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT" + +##### + +AC_SUBST(DEBUG_LEVEL) +AC_SUBST(VARIANT) +AC_SUBST(FASTDEBUG) +AC_SUBST(DEBUG_CLASSFILES) +AC_SUBST(BUILD_VARIANT_RELEASE) +]) + +AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_OPTIONS], +[ + +############################################################################### +# +# Should we build only OpenJDK even if closed sources are present? +# +AC_ARG_ENABLE([openjdk-only], [AS_HELP_STRING([--enable-openjdk-only], + [build OpenJDK regardless of the presence of closed repositories @<:@disabled@:>@])],,) + +if test "x$enable_openjdk_only" = "xyes"; then + OPENJDK=true +elif test "x$enable_openjdk_only" = "xno"; then + OPENJDK=false +elif test -d "$SRC_ROOT/jdk/src/closed"; then + OPENJDK=false +else + OPENJDK=true +fi + +if test "x$OPENJDK" = "xtrue"; then + SET_OPENJDK=OPENJDK=true +fi + +AC_SUBST(SET_OPENJDK) + +############################################################################### +# +# JIGSAW or not. The JIGSAW variable is used during the intermediate +# stage when we are building both the old style JDK and the new style modularized JDK. +# When the modularized JDK is finalized, this option will go away. +# +AC_ARG_ENABLE([jigsaw], [AS_HELP_STRING([--enable-jigsaw], + [build Jigsaw images (not yet available) @<:@disabled@:>@])],,) + +if test "x$enable_jigsaw" = "xyes"; then + JIGSAW=true +else + JIGSAW=false +fi +AC_SUBST(JIGSAW) + +############################################################################### +# +# Should we build a JDK/JVM with headful support (ie a graphical ui)? +# We always build headless support. +# +AC_MSG_CHECKING([headful support]) +AC_ARG_ENABLE([headful], [AS_HELP_STRING([--disable-headful], + [build headful support (graphical UI support) @<:@enabled@:>@])], + [SUPPORT_HEADFUL=${enable_headful}], [SUPPORT_HEADFUL=yes]) + +SUPPORT_HEADLESS=yes +BUILD_HEADLESS="BUILD_HEADLESS:=true" + +if test "x$SUPPORT_HEADFUL" = xyes; then + # We are building both headful and headless. + BUILD_HEADLESS_ONLY="" + headful_msg="inlude support for both headful and headless" +fi + +if test "x$SUPPORT_HEADFUL" = xno; then + # Thus we are building headless only. + BUILD_HEADLESS="BUILD_HEADLESS:=true" + BUILD_HEADLESS_ONLY="BUILD_HEADLESS_ONLY:=true" + headful_msg="headless only" +fi + +AC_MSG_RESULT([$headful_msg]) + +AC_SUBST(SUPPORT_HEADLESS) +AC_SUBST(SUPPORT_HEADFUL) +AC_SUBST(BUILD_HEADLESS) +AC_SUBST(BUILD_HEADLESS_ONLY) + +############################################################################### +# +# Should we run the painfully slow javadoc tool? +# +AC_MSG_CHECKING([whether to build documentation]) +AC_ARG_ENABLE([docs], [AS_HELP_STRING([--enable-docs], + [enable generation of Javadoc documentation @<:@disabled@:>@])], + [ENABLE_DOCS="${enableval}"], [ENABLE_DOCS='no']) +AC_MSG_RESULT([$ENABLE_DOCS]) +AC_SUBST(ENABLE_DOCS) +GENERATE_DOCS=false +if test "x$ENABLE_DOCS" = xyes; then + GENERATE_DOCS=true +fi +AC_SUBST(GENERATE_DOCS) + +############################################################################### +# +# Should we compile nimbus swing L&F? We can probably remove this option +# since nimbus is officially part of javax now. +# +AC_MSG_CHECKING([whether to build nimbus L&F]) +AC_ARG_ENABLE([nimbus], [AS_HELP_STRING([--disable-nimbus], + [disable Nimbus L&F @<:@enabled@:>@])], + [ENABLE_NIMBUS="${enableval}"], [ENABLE_NIMBUS='yes']) +AC_MSG_RESULT([$ENABLE_NIMBUS]) +DISABLE_NIMBUS= +if test "x$ENABLE_NIMBUS" = xno; then + DISABLE_NIMBUS=true +fi +AC_SUBST(DISABLE_NIMBUS) + +# Control wether Hotspot runs Queens test after build. +AC_ARG_ENABLE([hotspot-test-in-build], [AS_HELP_STRING([--enable-hotspot-test-in-build], + [enable running of Queens test after Hotspot build (not yet available) @<:@disabled@:>@])],, + [enable_hotspot_test_in_build=no]) +if test "x$enable_hotspot_test_in_build" = "xyes"; then + TEST_IN_BUILD=true +else + TEST_IN_BUILD=false +fi +AC_SUBST(TEST_IN_BUILD) + +############################################################################### +# +# Choose cacerts source file +# +AC_ARG_WITH(cacerts-file, [AS_HELP_STRING([--with-cacerts-file], + [specify alternative cacerts file])]) +if test "x$with_cacerts_file" != x; then + CACERTS_FILE=$with_cacerts_file +else + if test "x$OPENJDK" = "xtrue"; then + CACERTS_FILE=${SRC_ROOT}/jdk/src/share/lib/security/cacerts + else + CACERTS_FILE=${SRC_ROOT}/jdk/src/closed/share/lib/security/cacerts.internal + fi +fi +AC_SUBST(CACERTS_FILE) + +############################################################################### +# +# Compress jars +# +COMPRESS_JARS=false + +# default for embedded is yes... +if test "x$JDK_VARIANT" = "xembedded"; then + COMPRESS_JARS=true +fi +AC_SUBST(COMPRESS_JARS) + +############################################################################### +# +# Should we compile JFR +# default no, except for on closed-jdk and !embedded +# +ENABLE_JFR=no + +# Is the JFR source present + +# +# For closed && !embedded default is yes if the source is present +# +if test "x${OPENJDK}" != "xtrue" && test "x$JDK_VARIANT" != "xembedded" && test -d "$SRC_ROOT/jdk/src/closed/share/native/oracle/jfr"; then + ENABLE_JFR=yes +fi + +AC_MSG_CHECKING([whether to build jfr]) +AC_ARG_ENABLE([jfr], [AS_HELP_STRING([--enable-jfr], + [enable jfr (default is no)])] + [ENABLE_JFR="${enableval}"]) +AC_MSG_RESULT([${ENABLE_JFR}]) + +if test "x$ENABLE_JFR" = "xyes"; then + ENABLE_JFR=true +elif test "x$ENABLE_JFR" = "xno"; then + ENABLE_JFR=false +else + AC_MSG_ERROR([Invalid argument to --enable-jfr]) +fi + +AC_SUBST(ENABLE_JFR) +]) + +AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_VERSION_NUMBERS], +[ +# Source the version numbers +. $AUTOCONF_DIR/version.numbers +if test "x$OPENJDK" = "xfalse"; then + . $AUTOCONF_DIR/closed.version.numbers +fi +# Now set the JDK version, milestone, build number etc. +AC_SUBST(JDK_MAJOR_VERSION) +AC_SUBST(JDK_MINOR_VERSION) +AC_SUBST(JDK_MICRO_VERSION) +AC_SUBST(JDK_UPDATE_VERSION) +AC_SUBST(JDK_BUILD_NUMBER) +AC_SUBST(MILESTONE) +AC_SUBST(LAUNCHER_NAME) +AC_SUBST(PRODUCT_NAME) +AC_SUBST(PRODUCT_SUFFIX) +AC_SUBST(JDK_RC_PLATFORM_NAME) +AC_SUBST(COMPANY_NAME) + +COPYRIGHT_YEAR=`date +'%Y'` +AC_SUBST(COPYRIGHT_YEAR) + +RUNTIME_NAME="$PRODUCT_NAME $PRODUCT_SUFFIX" +AC_SUBST(RUNTIME_NAME) + +if test "x$JDK_UPDATE_VERSION" != x; then + JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}" +else + JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}" +fi +AC_SUBST(JDK_VERSION) + +if test "x$MILESTONE" != x; then + RELEASE="${JDK_VERSION}-${MILESTONE}${BUILD_VARIANT_RELEASE}" +else + RELEASE="${JDK_VERSION}${BUILD_VARIANT_RELEASE}" +fi +AC_SUBST(RELEASE) + +if test "x$JDK_BUILD_NUMBER" != x; then + FULL_VERSION="${RELEASE}-${JDK_BUILD_NUMBER}" +else + JDK_BUILD_NUMBER=b00 + BUILD_DATE=`date '+%Y_%m_%d_%H_%M'` + # Avoid [:alnum:] since it depends on the locale. + CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyz0123456789'` + USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvqxyz'` + FULL_VERSION="${RELEASE}-${USER_RELEASE_SUFFIX}-${JDK_BUILD_NUMBER}" +fi +AC_SUBST(FULL_VERSION) +COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'` +AC_SUBST(COOKED_BUILD_NUMBER) +]) + +AC_DEFUN_ONCE([JDKOPT_SETUP_BUILD_TWEAKS], +[ +HOTSPOT_MAKE_ARGS="ALT_OUTPUTDIR=$HOTSPOT_OUTPUTDIR ALT_EXPORT_PATH=$HOTSPOT_DIST $HOTSPOT_TARGET" +AC_SUBST(HOTSPOT_MAKE_ARGS) + +# The name of the Service Agent jar. +SALIB_NAME="${LIBRARY_PREFIX}saproc${SHARED_LIBRARY_SUFFIX}" +if test "x$OPENJDK_TARGET_OS" = "xwindows"; then + SALIB_NAME="${LIBRARY_PREFIX}sawindbg${SHARED_LIBRARY_SUFFIX}" +fi +AC_SUBST(SALIB_NAME) + +]) + +AC_DEFUN_ONCE([JDKOPT_SETUP_DEBUG_SYMBOLS], +[ +# +# ENABLE_DEBUG_SYMBOLS +# This must be done after the toolchain is setup, since we're looking at objcopy. +# +ENABLE_DEBUG_SYMBOLS=default + +# default on macosx is no... +if test "x$OPENJDK_TARGET_OS" = xmacosx; then + ENABLE_DEBUG_SYMBOLS=no +fi + +# default for embedded is no... +if test "x$JDK_VARIANT" = "xembedded"; then + ENABLE_DEBUG_SYMBOLS=no +fi + +AC_ARG_ENABLE([debug-symbols], + [AS_HELP_STRING([--disable-debug-symbols],[disable generation of debug symbols (@<:@enabled@:>@)])], + [ENABLE_DEBUG_SYMBOLS=${enable_debug_symbols}], +) + +AC_MSG_CHECKING([if we should generate debug symbols]) + +if test "x$ENABLE_DEBUG_SYMBOLS" = "xyes" && test "x$OBJCOPY" = x; then + # explicit enabling of enable-debug-symbols and can't find objcopy + # this is an error + AC_MSG_ERROR([Unable to find objcopy, cannot enable debug-symbols]) +fi + +if test "x$ENABLE_DEBUG_SYMBOLS" = "xdefault"; then + # Default is on if objcopy is found, otherwise off + if test "x$OBJCOPY" != x; then + ENABLE_DEBUG_SYMBOLS=yes + else + ENABLE_DEBUG_SYMBOLS=no + fi +fi + +AC_MSG_RESULT([$ENABLE_DEBUG_SYMBOLS]) + +# +# ZIP_DEBUGINFO_FILES +# +ZIP_DEBUGINFO_FILES=yes + +AC_ARG_ENABLE([zip-debug-info], + [AS_HELP_STRING([--disable-zip-debug-info],[don't zip debug-info files (@<:@enabled@:@)])], + [ZIP_DEBUGINFO_FILES=${enable_zip_debug_info}], +) + +AC_MSG_CHECKING([if we should zip debug-info files]) +AC_MSG_RESULT([$ZIP_DEBUGINFO_FILES]) + +# Hotspot wants ZIP_DEBUGINFO_FILES to be 1 for yes +# use that... +if test "x$ZIP_DEBUGINFO_FILES" = "xyes"; then + ZIP_DEBUGINFO_FILES=1 +else + ZIP_DEBUGINFO_FILES=0 +fi + +AC_SUBST(ENABLE_DEBUG_SYMBOLS) +AC_SUBST(ZIP_DEBUGINFO_FILES) +AC_SUBST(CFLAGS_DEBUG_SYMBOLS) +AC_SUBST(CXXFLAGS_DEBUG_SYMBOLS) +]) diff --git a/common/autoconf/libraries.m4 b/common/autoconf/libraries.m4 new file mode 100644 index 00000000000..e6364a6dc9d --- /dev/null +++ b/common/autoconf/libraries.m4 @@ -0,0 +1,642 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +AC_DEFUN_ONCE([LIB_SETUP_INIT], +[ + +############################################################################### +# +# OS specific settings that we never will need to probe. +# +if test "x$OPENJDK_TARGET_OS" = xlinux; then + AC_MSG_CHECKING([what is not needed on Linux?]) + PULSE_NOT_NEEDED=yes + AC_MSG_RESULT([pulse]) +fi + +if test "x$OPENJDK_TARGET_OS" = xsolaris; then + AC_MSG_CHECKING([what is not needed on Solaris?]) + ALSA_NOT_NEEDED=yes + PULSE_NOT_NEEDED=yes + AC_MSG_RESULT([alsa pulse]) +fi + +if test "x$OPENJDK_TARGET_OS" = xwindows; then + AC_MSG_CHECKING([what is not needed on Windows?]) + CUPS_NOT_NEEDED=yes + ALSA_NOT_NEEDED=yes + PULSE_NOT_NEEDED=yes + X11_NOT_NEEDED=yes + AC_MSG_RESULT([alsa cups pulse x11]) +fi + +if test "x$OPENJDK_TARGET_OS" = xmacosx; then + AC_MSG_CHECKING([what is not needed on MacOSX?]) + ALSA_NOT_NEEDED=yes + PULSE_NOT_NEEDED=yes + X11_NOT_NEEDED=yes + FREETYPE2_NOT_NEEDED=yes + # If the java runtime framework is disabled, then we need X11. + # This will be adjusted below. + AC_MSG_RESULT([alsa pulse x11]) +fi + +if test "x$OPENJDK_TARGET_OS" = xbsd; then + AC_MSG_CHECKING([what is not needed on bsd?]) + ALSA_NOT_NEEDED=yes + AC_MSG_RESULT([alsa]) +fi + +if test "x$OPENJDK" = "xfalse"; then + FREETYPE2_NOT_NEEDED=yes +fi + +############################################################################### +# +# Check for MacOSX support for OpenJDK. If this exists, try to build a JVM +# that uses this API. +# +AC_ARG_ENABLE([macosx-runtime-support], [AS_HELP_STRING([--disable-macosx-runtime-support], + [disable the use of MacOSX Java runtime support framework @<:@enabled@:>@])], + [MACOSX_RUNTIME_SUPPORT="${enableval}"],[MACOSX_RUNTIME_SUPPORT="no"]) + +USE_MACOSX_RUNTIME_SUPPORT=no +AC_MSG_CHECKING([for explicit Java runtime support in the OS]) +if test -f /System/Library/Frameworks/JavaVM.framework/Frameworks/JavaRuntimeSupport.framework/Headers/JavaRuntimeSupport.h; then + if test "x$MACOSX_RUNTIME_SUPPORT" != xno; then + MACOSX_RUNTIME_SUPPORT=yes + USE_MACOSX_RUNTIME_SUPPORT=yes + AC_MSG_RESULT([yes, does not need alsa freetype2 pulse and X11]) + else + AC_MSG_RESULT([yes, but explicitly disabled.]) + fi +else + AC_MSG_RESULT([no]) +fi + +if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$USE_MACOSX_RUNTIME_SUPPORT" = xno; then + AC_MSG_CHECKING([what is not needed on an X11 build on MacOSX?]) + X11_NOT_NEEDED= + FREETYPE2_NOT_NEEDED= + AC_MSG_RESULT([alsa pulse]) +fi +]) + +AC_DEFUN_ONCE([LIB_SETUP_X11], +[ + +############################################################################### +# +# Check for X Windows +# + +# Check if the user has specified sysroot, but not --x-includes or --x-libraries. +# Make a simple check for the libraries at the sysroot, and setup --x-includes and +# --x-libraries for the sysroot, if that seems to be correct. +if test "x$SYS_ROOT" != "x/"; then + if test "x$x_includes" = xNONE; then + if test -f "$SYS_ROOT/usr/X11R6/include/X11/Xlib.h"; then + x_includes="$SYS_ROOT/usr/X11R6/include" + fi + fi + if test "x$x_libraries" = xNONE; then + if test -f "$SYS_ROOT/usr/X11R6/lib/libX11.so"; then + x_libraries="$SYS_ROOT/usr/X11R6/lib" + fi + fi +fi + +# Now let autoconf do it's magic +AC_PATH_X +AC_PATH_XTRA + +if test "x$no_x" = xyes && test "x$X11_NOT_NEEDED" != xyes; then + HELP_MSG_MISSING_DEPENDENCY([x11]) + AC_MSG_ERROR([Could not find X11 libraries. $HELP_MSG]) +fi + +# Some of the old makefiles require a setting of OPENWIN_HOME +# Since the X11R6 directory has disappeared on later Linuxes, +# we need to probe for it. +if test "x$OPENJDK_TARGET_OS" = xlinux; then + if test -d "$SYS_ROOT/usr/X11R6"; then + OPENWIN_HOME="$SYS_ROOT/usr/X11R6" + fi + if test -d "$SYS_ROOT/usr/include/X11"; then + OPENWIN_HOME="$SYS_ROOT/usr" + fi +fi +if test "x$OPENJDK_TARGET_OS" = xsolaris; then + OPENWIN_HOME="/usr/openwin" +fi +AC_SUBST(OPENWIN_HOME) + + +# +# Weird Sol10 something check...TODO change to try compile +# +if test "x${OPENJDK_TARGET_OS}" = xsolaris; then + if test "`uname -r`" = "5.10"; then + if test "`${EGREP} -c XLinearGradient ${OPENWIN_HOME}/share/include/X11/extensions/Xrender.h`" = "0"; then + X_CFLAGS="${X_CFLAGS} -DSOLARIS10_NO_XRENDER_STRUCTS" + fi + fi +fi + +AC_LANG_PUSH(C) +OLD_CFLAGS="$CFLAGS" +CFLAGS="$CFLAGS $X_CFLAGS" +AC_CHECK_HEADERS([X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h], + [X11_A_OK=yes], + [X11_A_OK=no]) +CFLAGS="$OLD_CFLAGS" +AC_LANG_POP(C) + +if test "x$X11_A_OK" = xno && test "x$X11_NOT_NEEDED" != xyes; then + HELP_MSG_MISSING_DEPENDENCY([x11]) + AC_MSG_ERROR([Could not find all X11 headers (shape.h Xrender.h XTest.h). $HELP_MSG]) +fi + +AC_SUBST(X_CFLAGS) +AC_SUBST(X_LIBS) +]) + +AC_DEFUN_ONCE([LIB_SETUP_CUPS], +[ + +############################################################################### +# +# The common unix printing system cups is used to print from java. +# +AC_ARG_WITH(cups, [AS_HELP_STRING([--with-cups], + [specify prefix directory for the cups package + (expecting the libraries under PATH/lib and the headers under PATH/include)])]) +AC_ARG_WITH(cups-include, [AS_HELP_STRING([--with-cups-include], + [specify directory for the cups include files])]) +AC_ARG_WITH(cups-lib, [AS_HELP_STRING([--with-cups-lib], + [specify directory for the cups library])]) + +if test "x$CUPS_NOT_NEEDED" = xyes; then + if test "x${with_cups}" != x || test "x${with_cups_include}" != x || test "x${with_cups_lib}" != x; then + AC_MSG_WARN([cups not used, so --with-cups is ignored]) + fi + CUPS_CFLAGS= + CUPS_LIBS= +else + CUPS_FOUND=no + + if test "x${with_cups}" = xno || test "x${with_cups_include}" = xno || test "x${with_cups_lib}" = xno; then + AC_MSG_ERROR([It is not possible to disable the use of cups. Remove the --without-cups option.]) + fi + + if test "x${with_cups}" != x; then + CUPS_LIBS="-L${with_cups}/lib -lcups" + CUPS_CFLAGS="-I${with_cups}/include" + CUPS_FOUND=yes + fi + if test "x${with_cups_include}" != x; then + CUPS_CFLAGS="-I${with_cups_include}" + CUPS_FOUND=yes + fi + if test "x${with_cups_lib}" != x; then + CUPS_LIBS="-L${with_cups_lib} -lcups" + CUPS_FOUND=yes + fi + if test "x$CUPS_FOUND" = xno; then + BDEPS_CHECK_MODULE(CUPS, cups, xxx, [CUPS_FOUND=yes]) + fi + if test "x$CUPS_FOUND" = xno; then + # Are the cups headers installed in the default /usr/include location? + AC_CHECK_HEADERS([cups/cups.h cups/ppd.h], + [CUPS_FOUND=yes + CUPS_CFLAGS= + CUPS_LIBS="-lcups" + DEFAULT_CUPS=yes]) + fi + if test "x$CUPS_FOUND" = xno; then + # Getting nervous now? Lets poke around for standard Solaris third-party + # package installation locations. + AC_MSG_CHECKING([for cups headers and libs]) + if test -s /opt/sfw/cups/include/cups/cups.h; then + # An SFW package seems to be installed! + CUPS_FOUND=yes + CUPS_CFLAGS="-I/opt/sfw/cups/include" + CUPS_LIBS="-L/opt/sfw/cups/lib -lcups" + elif test -s /opt/csw/include/cups/cups.h; then + # A CSW package seems to be installed! + CUPS_FOUND=yes + CUPS_CFLAGS="-I/opt/csw/include" + CUPS_LIBS="-L/opt/csw/lib -lcups" + fi + AC_MSG_RESULT([$CUPS_FOUND]) + fi + if test "x$CUPS_FOUND" = xno; then + HELP_MSG_MISSING_DEPENDENCY([cups]) + AC_MSG_ERROR([Could not find cups! $HELP_MSG ]) + fi +fi + +AC_SUBST(CUPS_CFLAGS) +AC_SUBST(CUPS_LIBS) + +]) + +AC_DEFUN_ONCE([LIB_SETUP_FREETYPE], +[ + +############################################################################### +# +# The ubiquitous freetype2 library is used to render fonts. +# +AC_ARG_WITH(freetype, [AS_HELP_STRING([--with-freetype], + [specify prefix directory for the freetype2 package + (expecting the libraries under PATH/lib and the headers under PATH/include)])]) + +# If we are using the OS installed system lib for freetype, then we do not need to copy it to the build tree +USING_SYSTEM_FT_LIB=false + +if test "x$FREETYPE2_NOT_NEEDED" = xyes; then + if test "x$with_freetype" != x || test "x$with_freetype_include" != x || test "x$with_freetype_lib" != x; then + AC_MSG_WARN([freetype not used, so --with-freetype is ignored]) + fi + FREETYPE2_CFLAGS= + FREETYPE2_LIBS= + FREETYPE2_LIB_PATH= +else + FREETYPE2_FOUND=no + + if test "x$with_freetype" != x; then + SPACESAFE(with_freetype,[the path to freetype]) + FREETYPE2_LIBS="-L$with_freetype/lib -lfreetype" + if test "x$OPENJDK_TARGET_OS" = xwindows; then + FREETYPE2_LIBS="$with_freetype/lib/freetype.lib" + fi + FREETYPE2_LIB_PATH="$with_freetype/lib" + FREETYPE2_CFLAGS="-I$with_freetype/include" + if test -s $with_freetype/include/ft2build.h && test -d $with_freetype/include/freetype2/freetype; then + FREETYPE2_CFLAGS="-I$with_freetype/include/freetype2 -I$with_freetype/include" + fi + FREETYPE2_FOUND=yes + if test "x$FREETYPE2_FOUND" = xyes; then + # Verify that the directories exist + if ! test -d "$with_freetype/lib" || ! test -d "$with_freetype/include"; then + AC_MSG_ERROR([Could not find the expected directories $with_freetype/lib and $with_freetype/include]) + fi + # List the contents of the lib. + FREETYPELIB=`ls $with_freetype/lib/libfreetype.so $with_freetype/lib/freetype.dll 2> /dev/null` + if test "x$FREETYPELIB" = x; then + AC_MSG_ERROR([Could not find libfreetype.se nor freetype.dll in $with_freetype/lib]) + fi + # Check one h-file + if ! test -s "$with_freetype/include/ft2build.h"; then + AC_MSG_ERROR([Could not find $with_freetype/include/ft2build.h]) + fi + fi + fi + if test "x$FREETYPE2_FOUND" = xno; then + BDEPS_CHECK_MODULE(FREETYPE2, freetype2, xxx, [FREETYPE2_FOUND=yes], [FREETYPE2_FOUND=no]) + USING_SYSTEM_FT_LIB=true + fi + if test "x$FREETYPE2_FOUND" = xno; then + PKG_CHECK_MODULES(FREETYPE2, freetype2, [FREETYPE2_FOUND=yes], [FREETYPE2_FOUND=no]) + USING_SYSTEM_FT_LIB=true + fi + if test "x$FREETYPE2_FOUND" = xno; then + AC_MSG_CHECKING([for freetype in some standard locations]) + + if test -s /usr/X11/include/ft2build.h && test -d /usr/X11/include/freetype2/freetype; then + DEFAULT_FREETYPE_CFLAGS="-I/usr/X11/include/freetype2 -I/usr/X11/include" + DEFAULT_FREETYPE_LIBS="-L/usr/X11/lib -lfreetype" + fi + if test -s /usr/include/ft2build.h && test -d /usr/include/freetype2/freetype; then + DEFAULT_FREETYPE_CFLAGS="-I/usr/include/freetype2" + DEFAULT_FREETYPE_LIBS="-lfreetype" + fi + + PREV_CXXCFLAGS="$CXXFLAGS" + PREV_LDFLAGS="$LDFLAGS" + CXXFLAGS="$CXXFLAGS $DEFAULT_FREETYPE_CFLAGS" + LDFLAGS="$LDFLAGS $DEFAULT_FREETYPE_LIBS" + AC_LINK_IFELSE([AC_LANG_SOURCE([[#include + #include FT_FREETYPE_H + int main() { return 0; } + ]])], + [ + # Yes, the default cflags and libs did the trick. + FREETYPE2_FOUND=yes + FREETYPE2_CFLAGS="$DEFAULT_FREETYPE_CFLAGS" + FREETYPE2_LIBS="$DEFAULT_FREETYPE_LIBS" + ], + [ + FREETYPE2_FOUND=no + ]) + CXXCFLAGS="$PREV_CXXFLAGS" + LDFLAGS="$PREV_LDFLAGS" + AC_MSG_RESULT([$FREETYPE2_FOUND]) + USING_SYSTEM_FT_LIB=true + fi + if test "x$FREETYPE2_FOUND" = xno; then + HELP_MSG_MISSING_DEPENDENCY([freetype2]) + AC_MSG_ERROR([Could not find freetype2! $HELP_MSG ]) + fi +fi + +AC_SUBST(USING_SYSTEM_FT_LIB) +AC_SUBST(FREETYPE2_LIB_PATH) +AC_SUBST(FREETYPE2_CFLAGS) +AC_SUBST(FREETYPE2_LIBS) + +]) + +AC_DEFUN_ONCE([LIB_SETUP_ALSA], +[ + +############################################################################### +# +# Check for alsa headers and libraries. Used on Linux/GNU systems. +# +AC_ARG_WITH(alsa, [AS_HELP_STRING([--with-alsa], + [specify prefix directory for the alsa package + (expecting the libraries under PATH/lib and the headers under PATH/include)])]) +AC_ARG_WITH(alsa-include, [AS_HELP_STRING([--with-alsa-include], + [specify directory for the alsa include files])]) +AC_ARG_WITH(alsa-lib, [AS_HELP_STRING([--with-alsa-lib], + [specify directory for the alsa library])]) + +if test "x$ALSA_NOT_NEEDED" = xyes; then + if test "x${with_alsa}" != x || test "x${with_alsa_include}" != x || test "x${with_alsa_lib}" != x; then + AC_MSG_WARN([alsa not used, so --with-alsa is ignored]) + fi + ALSA_CFLAGS= + ALSA_LIBS= +else + ALSA_FOUND=no + + if test "x${with_alsa}" = xno || test "x${with_alsa_include}" = xno || test "x${with_alsa_lib}" = xno; then + AC_MSG_ERROR([It is not possible to disable the use of alsa. Remove the --without-alsa option.]) + fi + + if test "x${with_alsa}" != x; then + ALSA_LIBS="-L${with_alsa}/lib -lalsa" + ALSA_CFLAGS="-I${with_alsa}/include" + ALSA_FOUND=yes + fi + if test "x${with_alsa_include}" != x; then + ALSA_CFLAGS="-I${with_alsa_include}" + ALSA_FOUND=yes + fi + if test "x${with_alsa_lib}" != x; then + ALSA_LIBS="-L${with_alsa_lib} -lalsa" + ALSA_FOUND=yes + fi + if test "x$ALSA_FOUND" = xno; then + BDEPS_CHECK_MODULE(ALSA, alsa, xxx, [ALSA_FOUND=yes], [ALSA_FOUND=no]) + fi + if test "x$ALSA_FOUND" = xno; then + PKG_CHECK_MODULES(ALSA, alsa, [ALSA_FOUND=yes], [ALSA_FOUND=no]) + fi + if test "x$ALSA_FOUND" = xno; then + AC_CHECK_HEADERS([alsa/asoundlib.h], + [ALSA_FOUND=yes + ALSA_CFLAGS=-Iignoreme + ALSA_LIBS=-lasound + DEFAULT_ALSA=yes], + [ALSA_FOUND=no]) + fi + if test "x$ALSA_FOUND" = xno; then + HELP_MSG_MISSING_DEPENDENCY([alsa]) + AC_MSG_ERROR([Could not find alsa! $HELP_MSG ]) + fi +fi + +AC_SUBST(ALSA_CFLAGS) +AC_SUBST(ALSA_LIBS) + +]) + +AC_DEFUN_ONCE([LIB_SETUP_MISC_LIBS], +[ + +############################################################################### +# +# Check for the jpeg library +# + +USE_EXTERNAL_LIBJPEG=true +AC_CHECK_LIB(jpeg, main, [], + [ USE_EXTERNAL_LIBJPEG=false + AC_MSG_NOTICE([Will use jpeg decoder bundled with the OpenJDK source]) + ]) +AC_SUBST(USE_EXTERNAL_LIBJPEG) + +############################################################################### +# +# Check for the gif library +# + +USE_EXTERNAL_LIBJPEG=true +AC_CHECK_LIB(gif, main, [], + [ USE_EXTERNAL_LIBGIF=false + AC_MSG_NOTICE([Will use gif decoder bundled with the OpenJDK source]) + ]) +AC_SUBST(USE_EXTERNAL_LIBGIF) + +############################################################################### +# +# Check for the zlib library +# + +AC_ARG_WITH(zlib, [AS_HELP_STRING([--with-zlib], + [use zlib from build system or OpenJDK source (system, bundled) @<:@bundled@:>@])]) + +AC_CHECK_LIB(z, compress, + [ ZLIB_FOUND=yes ], + [ ZLIB_FOUND=no ]) + +AC_MSG_CHECKING([for which zlib to use]) + +DEFAULT_ZLIB=bundled +if test "x$OPENJDK_TARGET_OS" = xmacosx; then +# +# On macosx default is system...on others default is +# + DEFAULT_ZLIB=system +fi + +if test "x${ZLIB_FOUND}" != "xyes"; then +# +# If we don't find any system...set default to bundled +# + DEFAULT_ZLIB=bundled +fi + +# +# If user didn't specify, use DEFAULT_ZLIB +# +if test "x${with_zlib}" = "x"; then + with_zlib=${DEFAULT_ZLIB} +fi + +if test "x${with_zlib}" = "xbundled"; then + USE_EXTERNAL_LIBZ=false + AC_MSG_RESULT([bundled]) +elif test "x${with_zlib}" = "xsystem"; then + if test "x${ZLIB_FOUND}" = "xyes"; then + USE_EXTERNAL_LIBZ=true + AC_MSG_RESULT([system]) + else + AC_MSG_RESULT([system not found]) + AC_MSG_ERROR([--with-zlib=system specified, but no zlib found!]) + fi +else + AC_MSG_ERROR([Invalid value for --with-zlib: ${with_zlib}, use 'system' or 'bundled']) +fi + +AC_SUBST(USE_EXTERNAL_LIBZ) + +############################################################################### +LIBZIP_CAN_USE_MMAP=true +if test "x$JDK_VARIANT" = "xembedded"; then + LIBZIP_CAN_USE_MMAP=false +fi +AC_SUBST(LIBZIP_CAN_USE_MMAP) + +############################################################################### +# +# Check if altzone exists in time.h +# + +AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ], [return (int)altzone;])], + [has_altzone=yes], + [has_altzone=no]) +if test "x$has_altzone" = xyes; then + AC_DEFINE([HAVE_ALTZONE], 1, [Define if you have the external 'altzone' variable in time.h]) +fi + +############################################################################### +# +# Check the maths library +# + +AC_CHECK_LIB(m, cos, [], + [ + AC_MSG_NOTICE([Maths library was not found]) + ]) +AC_SUBST(LIBM) + +############################################################################### +# +# Check for libdl.so + +save_LIBS="$LIBS" +LIBS="" +AC_CHECK_LIB(dl,dlopen) +LIBDL="$LIBS" +AC_SUBST(LIBDL) +LIBS="$save_LIBS" + +]) + +AC_DEFUN_ONCE([LIB_SETUP_STATIC_LINK_LIBSTDCPP], +[ +############################################################################### +# +# statically link libstdc++ before C++ ABI is stablized on Linux unless +# dynamic build is configured on command line. +# +AC_ARG_ENABLE([static-link-stdc++], [AS_HELP_STRING([--disable-static-link-stdc++], + [disable static linking of the C++ runtime on Linux @<:@enabled@:>@])],, + [ + enable_static_link_stdc__=yes + ]) + +if test "x$OPENJDK_TARGET_OS" = xlinux; then + # Test if -lstdc++ works. + AC_MSG_CHECKING([if dynamic link of stdc++ is possible]) + AC_LANG_PUSH(C++) + OLD_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -lstdc++" + AC_LINK_IFELSE([AC_LANG_PROGRAM([], [return 0;])], + [has_dynamic_libstdcxx=yes], + [has_dynamic_libstdcxx=no]) + CXXFLAGS="$OLD_CXXFLAGS" + AC_LANG_POP(C++) + AC_MSG_RESULT([$has_dynamic_libstdcxx]) + + # Test if stdc++ can be linked statically. + AC_MSG_CHECKING([if static link of stdc++ is possible]) + STATIC_STDCXX_FLAGS="-Wl,-Bstatic -lstdc++ -lgcc -Wl,-Bdynamic" + AC_LANG_PUSH(C++) + OLD_LIBS="$LIBS" + OLD_CXX="$CXX" + LIBS="$STATIC_STDCXX_FLAGS" + CXX="$CC" + AC_LINK_IFELSE([AC_LANG_PROGRAM([], [return 0;])], + [has_static_libstdcxx=yes], + [has_static_libstdcxx=no]) + LIBS="$OLD_LIBS" + CXX="$OLD_CXX" + AC_LANG_POP(C++) + AC_MSG_RESULT([$has_static_libstdcxx]) + + if test "x$has_static_libcxx" = xno && test "x$has_dynamic_libcxx" = xno; then + AC_MSG_ERROR([I cannot link to stdc++! Neither dynamically nor statically.]) + fi + + if test "x$enable_static_link_stdc__" = xyes && test "x$has_static_libstdcxx" = xno; then + AC_MSG_NOTICE([Static linking of libstdc++ was not possible reverting to dynamic linking.]) + enable_static_link_stdc__=no + fi + + if test "x$enable_static_link_stdc__" = xno && test "x$has_dynamic_libstdcxx" = xno; then + AC_MSG_NOTICE([Dynamic linking of libstdc++ was not possible reverting to static linking.]) + enable_static_link_stdc__=yes + fi + + AC_MSG_CHECKING([how to link with libstdc++]) + if test "x$enable_static_link_stdc__" = xyes; then + LIBCXX="$LIBCXX $STATIC_STDCXX_FLAGS" + LDCXX="$CC" + AC_MSG_RESULT([static]) + else + LIBCXX="$LIBCXX -lstdc++" + LDCXX="$CXX" + AC_MSG_RESULT([dynamic]) + fi +fi + +# libCrun is the c++ runtime-library with SunStudio (roughly the equivalent of gcc's libstdc++.so) +if test "x$OPENJDK_TARGET_OS" = xsolaris && test "x$LIBCXX" = x; then + LIBCXX="/usr/lib${LEGACY_OPENJDK_TARGET_CPU3}/libCrun.so.1" +fi + +# TODO better (platform agnostic) test +if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$LIBCXX" = x && test "x$GCC" = xyes; then + LIBCXX="-lstdc++" +fi + +AC_SUBST(LIBCXX) + +]) diff --git a/common/autoconf/source-dirs.m4 b/common/autoconf/source-dirs.m4 new file mode 100644 index 00000000000..2eeb3831176 --- /dev/null +++ b/common/autoconf/source-dirs.m4 @@ -0,0 +1,280 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +AC_DEFUN_ONCE([SRCDIRS_SETUP_TOPDIRS], +[ + +# Where are the sources. Any of these can be overridden +# using --with-override-corba and the likes. +LANGTOOLS_TOPDIR="$SRC_ROOT/langtools" +CORBA_TOPDIR="$SRC_ROOT/corba" +JAXP_TOPDIR="$SRC_ROOT/jaxp" +JAXWS_TOPDIR="$SRC_ROOT/jaxws" +HOTSPOT_TOPDIR="$SRC_ROOT/hotspot" +JDK_TOPDIR="$SRC_ROOT/jdk" +AC_SUBST(LANGTOOLS_TOPDIR) +AC_SUBST(CORBA_TOPDIR) +AC_SUBST(JAXP_TOPDIR) +AC_SUBST(JAXWS_TOPDIR) +AC_SUBST(HOTSPOT_TOPDIR) +AC_SUBST(JDK_TOPDIR) +]) + + +AC_DEFUN_ONCE([SRCDIRS_SETUP_ALTERNATIVE_TOPDIRS], +[ + +############################################################################### +# +# Pickup additional source for a component from outside of the source root +# or override source for a component. +# +AC_ARG_WITH(add-source-root, [AS_HELP_STRING([--with-add-source-root], + [for each and every source directory, look in this additional source root for + the same directory; if it exists and have files in it, include it in the build])]) + +AC_ARG_WITH(override-source-root, [AS_HELP_STRING([--with-override-source-root], + [for each and every source directory, look in this override source root for + the same directory; if it exists, use that directory instead and + ignore the directory in the original source root])]) + +AC_ARG_WITH(adds-and-overrides, [AS_HELP_STRING([--with-adds-and-overrides], + [use the subdirs 'adds' and 'overrides' in the specified directory as + add-source-root and override-source-root])]) + +if test "x$with_adds_and_overrides" != x; then + with_add_source_root="$with_adds_and_overrides/adds" + with_override_source_root="$with_adds_and_overrides/overrides" +fi + +if test "x$with_add_source_root" != x; then + if ! test -d $with_add_source_root; then + AC_MSG_ERROR([Trying to use a non-existant add-source-root $with_add_source_root]) + fi + CURDIR="$PWD" + cd "$with_add_source_root" + ADD_SRC_ROOT="`pwd`" + cd "$CURDIR" + # Verify that the addon source root does not have any root makefiles. + # If it does, then it is usually an error, prevent this. + if test -f $with_add_source_root/langtools/makefiles/Makefile || \ + test -f $with_add_source_root/langtools/make/Makefile; then + AC_MSG_ERROR([Your add source root seems to contain a full langtools repo! An add source root should only contain additional sources.]) + fi + if test -f $with_add_source_root/corba/makefiles/Makefile || \ + test -f $with_add_source_root/corba/make/Makefile; then + AC_MSG_ERROR([Your add source root seems to contain a full corba repo! An add source root should only contain additional sources.]) + fi + if test -f $with_add_source_root/jaxp/makefiles/Makefile || \ + test -f $with_add_source_root/jaxp/make/Makefile; then + AC_MSG_ERROR([Your add source root seems to contain a full jaxp repo! An add source root should only contain additional sources.]) + fi + if test -f $with_add_source_root/jaxws/makefiles/Makefile || \ + test -f $with_add_source_root/jaxws/make/Makefile; then + AC_MSG_ERROR([Your add source root seems to contain a full jaxws repo! An add source root should only contain additional sources.]) + fi + if test -f $with_add_source_root/hotspot/makefiles/Makefile || \ + test -f $with_add_source_root/hotspot/make/Makefile; then + AC_MSG_ERROR([Your add source root seems to contain a full hotspot repo! An add source root should only contain additional sources.]) + fi + if test -f $with_add_source_root/jdk/makefiles/Makefile || \ + test -f $with_add_source_root/jdk/make/Makefile; then + AC_MSG_ERROR([Your add source root seems to contain a full JDK repo! An add source root should only contain additional sources.]) + fi +fi +AC_SUBST(ADD_SRC_ROOT) + +if test "x$with_override_source_root" != x; then + if ! test -d $with_override_source_root; then + AC_MSG_ERROR([Trying to use a non-existant override-source-root $with_override_source_root]) + fi + CURDIR="$PWD" + cd "$with_override_source_root" + OVERRIDE_SRC_ROOT="`pwd`" + cd "$CURDIR" + if test -f $with_override_source_root/langtools/makefiles/Makefile || \ + test -f $with_override_source_root/langtools/make/Makefile; then + AC_MSG_ERROR([Your override source root seems to contain a full langtools repo! An override source root should only contain sources that override.]) + fi + if test -f $with_override_source_root/corba/makefiles/Makefile || \ + test -f $with_override_source_root/corba/make/Makefile; then + AC_MSG_ERROR([Your override source root seems to contain a full corba repo! An override source root should only contain sources that override.]) + fi + if test -f $with_override_source_root/jaxp/makefiles/Makefile || \ + test -f $with_override_source_root/jaxp/make/Makefile; then + AC_MSG_ERROR([Your override source root seems to contain a full jaxp repo! An override source root should only contain sources that override.]) + fi + if test -f $with_override_source_root/jaxws/makefiles/Makefile || \ + test -f $with_override_source_root/jaxws/make/Makefile; then + AC_MSG_ERROR([Your override source root seems to contain a full jaxws repo! An override source root should only contain sources that override.]) + fi + if test -f $with_override_source_root/hotspot/makefiles/Makefile || \ + test -f $with_override_source_root/hotspot/make/Makefile; then + AC_MSG_ERROR([Your override source root seems to contain a full hotspot repo! An override source root should only contain sources that override.]) + fi + if test -f $with_override_source_root/jdk/makefiles/Makefile || \ + test -f $with_override_source_root/jdk/make/Makefile; then + AC_MSG_ERROR([Your override source root seems to contain a full JDK repo! An override source root should only contain sources that override.]) + fi +fi +AC_SUBST(OVERRIDE_SRC_ROOT) + +############################################################################### +# +# Override a repo completely, this is used for example when you have 3 small +# development sandboxes of the langtools sources and want to avoid having 3 full +# OpenJDK sources checked out on disk. +# +# Assuming that the 3 langtools sandboxes are located here: +# /home/fredrik/sandbox1/langtools +# /home/fredrik/sandbox2/langtools +# /home/fredrik/sandbox3/langtools +# +# From the source root you create build subdirs manually: +# mkdir -p build1 build2 build3 +# in each build directory run: +# (cd build1 && ../configure --with-override-langtools=/home/fredrik/sandbox1 && make) +# (cd build2 && ../configure --with-override-langtools=/home/fredrik/sandbox2 && make) +# (cd build3 && ../configure --with-override-langtools=/home/fredrik/sandbox3 && make) +# + +AC_ARG_WITH(override-langtools, [AS_HELP_STRING([--with-override-langtools], + [use this langtools dir for the build])]) + +AC_ARG_WITH(override-corba, [AS_HELP_STRING([--with-override-corba], + [use this corba dir for the build])]) + +AC_ARG_WITH(override-jaxp, [AS_HELP_STRING([--with-override-jaxp], + [use this jaxp dir for the build])]) + +AC_ARG_WITH(override-jaxws, [AS_HELP_STRING([--with-override-jaxws], + [use this jaxws dir for the build])]) + +AC_ARG_WITH(override-hotspot, [AS_HELP_STRING([--with-override-hotspot], + [use this hotspot dir for the build])]) + +AC_ARG_WITH(override-jdk, [AS_HELP_STRING([--with-override-jdk], + [use this jdk dir for the build])]) + +if test "x$with_override_langtools" != x; then + CURDIR="$PWD" + cd "$with_override_langtools" + LANGTOOLS_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $LANGTOOLS_TOPDIR/makefiles/Makefile; then + AC_MSG_ERROR([You have to override langtools with a full langtools repo!]) + fi + AC_MSG_CHECKING([if langtools should be overridden]) + AC_MSG_RESULT([yes with $LANGTOOLS_TOPDIR]) +fi +if test "x$with_override_corba" != x; then + CURDIR="$PWD" + cd "$with_override_corba" + CORBA_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $CORBA_TOPDIR/makefiles/Makefile; then + AC_MSG_ERROR([You have to override corba with a full corba repo!]) + fi + AC_MSG_CHECKING([if corba should be overridden]) + AC_MSG_RESULT([yes with $CORBA_TOPDIR]) +fi +if test "x$with_override_jaxp" != x; then + CURDIR="$PWD" + cd "$with_override_jaxp" + JAXP_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $JAXP_TOPDIR/makefiles/Makefile; then + AC_MSG_ERROR([You have to override jaxp with a full jaxp repo!]) + fi + AC_MSG_CHECKING([if jaxp should be overridden]) + AC_MSG_RESULT([yes with $JAXP_TOPDIR]) +fi +if test "x$with_override_jaxws" != x; then + CURDIR="$PWD" + cd "$with_override_jaxws" + JAXWS_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $JAXWS_TOPDIR/makefiles/Makefile; then + AC_MSG_ERROR([You have to override jaxws with a full jaxws repo!]) + fi + AC_MSG_CHECKING([if jaxws should be overridden]) + AC_MSG_RESULT([yes with $JAXWS_TOPDIR]) +fi +if test "x$with_override_hotspot" != x; then + CURDIR="$PWD" + cd "$with_override_hotspot" + HOTSPOT_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $HOTSPOT_TOPDIR/make/Makefile && \ + ! test -f $HOTSPOT_TOPDIR/makefiles/Makefile; then + AC_MSG_ERROR([You have to override hotspot with a full hotspot repo!]) + fi + AC_MSG_CHECKING([if hotspot should be overridden]) + AC_MSG_RESULT([yes with $HOTSPOT_TOPDIR]) +fi +if test "x$with_override_jdk" != x; then + CURDIR="$PWD" + cd "$with_override_jdk" + JDK_TOPDIR="`pwd`" + cd "$CURDIR" + if ! test -f $JDK_TOPDIR/makefiles/Makefile; then + AC_MSG_ERROR([You have to override JDK with a full JDK repo!]) + fi + AC_MSG_CHECKING([if JDK should be overridden]) + AC_MSG_RESULT([yes with $JDK_TOPDIR]) +fi + +]) + +AC_DEFUN_ONCE([SRCDIRS_SETUP_OUTPUT_DIRS], +[ +LANGTOOLS_OUTPUTDIR="$OUTPUT_ROOT/langtools" +CORBA_OUTPUTDIR="$OUTPUT_ROOT/corba" +JAXP_OUTPUTDIR="$OUTPUT_ROOT/jaxp" +JAXWS_OUTPUTDIR="$OUTPUT_ROOT/jaxws" +HOTSPOT_OUTPUTDIR="$OUTPUT_ROOT/hotspot" +JDK_OUTPUTDIR="$OUTPUT_ROOT/jdk" +IMAGES_OUTPUTDIR="$OUTPUT_ROOT/images" + +AC_SUBST(LANGTOOLS_OUTPUTDIR) +AC_SUBST(CORBA_OUTPUTDIR) +AC_SUBST(JAXP_OUTPUTDIR) +AC_SUBST(JAXWS_OUTPUTDIR) +AC_SUBST(HOTSPOT_OUTPUTDIR) +AC_SUBST(JDK_OUTPUTDIR) +AC_SUBST(IMAGES_OUTPUTDIR) + +LANGTOOLS_DIST="$OUTPUT_ROOT/langtools/dist" +CORBA_DIST="$OUTPUT_ROOT/corba/dist" +JAXP_DIST="$OUTPUT_ROOT/jaxp/dist" +JAXWS_DIST="$OUTPUT_ROOT/jaxws/dist" +HOTSPOT_DIST="$OUTPUT_ROOT/hotspot/dist" + +AC_SUBST(LANGTOOLS_DIST) +AC_SUBST(CORBA_DIST) +AC_SUBST(JAXP_DIST) +AC_SUBST(JAXWS_DIST) +AC_SUBST(HOTSPOT_DIST) +]) diff --git a/common/autoconf/spec.sh.in b/common/autoconf/spec.sh.in new file mode 100644 index 00000000000..a1d1c07ef1b --- /dev/null +++ b/common/autoconf/spec.sh.in @@ -0,0 +1,527 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +# Configured"@DATE_WHEN_CONFIGURED@ to build for a @OPENJDK_TARGET_SYSTEM@ system, +# using 'configure @CONFIGURE_COMMAND_LINE@' + +# The "human readable" name of this configuration +CONF_NAME="@CONF_NAME@" + +# The built jdk will run in this target system. +OPENJDK_TARGET_SYSTEM="@OPENJDK_TARGET_SYSTEM@" + +OPENJDK_TARGET_OS="@OPENJDK_TARGET_OS@" +OPENJDK_TARGET_OS_FAMILY="@OPENJDK_TARGET_OS_FAMILY@" +OPENJDK_TARGET_OS_API="@OPENJDK_TARGET_OS_API@" + +OPENJDK_TARGET_CPU="@OPENJDK_TARGET_CPU@" +OPENJDK_TARGET_CPU_ARCH="@OPENJDK_TARGET_CPU_ARCH@" +OPENJDK_TARGET_CPU_BITS="@OPENJDK_TARGET_CPU_BITS@" +OPENJDK_TARGET_CPU_ENDIAN="@OPENJDK_TARGET_CPU_ENDIAN@" + +# We are building on this build system. +# When not cross-compiling, it is the same as the target. +OPENJDK_BUILD_SYSTEM="@OPENJDK_BUILD_SYSTEM@" + +OPENJDK_BUILD_OS="@OPENJDK_BUILD_OS@" +OPENJDK_BUILD_OS_FAMILY="@OPENJDK_BUILD_OS_FAMILY@" +OPENJDK_BUILD_OS_API="@OPENJDK_BUILD_OS_API@" + +OPENJDK_BUILD_CPU="@OPENJDK_BUILD_CPU@" +OPENJDK_BUILD_CPU_ARCH="@OPENJDK_BUILD_CPU_ARCH@" +OPENJDK_BUILD_CPU_BITS="@OPENJDK_BUILD_CPU_BITS@" +OPENJDK_BUILD_CPU_ENDIAN="@OPENJDK_BUILD_CPU_ENDIAN@" + +# Legacy OS values for use in release file. +REQUIRED_OS_NAME="@REQUIRED_OS_NAME@" +REQUIRED_OS_VERSION="@REQUIRED_OS_VERSION@" + +# Old name for OPENJDK_TARGET_OS (aix,bsd,hpux,linux,macosx,solaris,windows etc) +PLATFORM="@OPENJDK_TARGET_OS@" +# Old name for OPENJDK_TARGET_CPU, uses i586 and amd64, instead of ia32 and x64. +ARCH="@LEGACY_OPENJDK_TARGET_CPU1@" +# Yet another name for arch used for an extra subdir below the jvm lib. +# Uses i386 and amd64, instead of ia32 and x64. +LIBARCH="@LEGACY_OPENJDK_TARGET_CPU2@" +# Use to switch between solaris and windows subdirs in the jdk. +LEGACY_OPENJDK_TARGET_OS_API="@LEGACY_OPENJDK_TARGET_OS_API@" +# 32 or 64 bit +ARCH_DATA_MODEL="@OPENJDK_TARGET_CPU_BITS@" +# Legacy setting for building for a 64 bit machine. +# If yes then this expands to _LP64=1 +ENDIAN="@OPENJDK_TARGET_CPU_ENDIAN@" +JIGSAW="@JIGSAW@" +LIBM=-lm +LIBDL="@LIBDL@" + +# colon or semicolon +PATH_SEP="@PATH_SEP@" + +# The sys root where standard headers and libraries are found. +# Usually not needed since the configure script should have +# taken it into account already when setting CFLAGS et al. +SYS_ROOT="@SYS_ROOT@" + +# Paths to the source code +SRC_ROOT="@SRC_ROOT@" +ADD_SRC_ROOT="@ADD_SRC_ROOT@" +OVERRIDE_SRC_ROOT="@OVERRIDE_SRC_ROOT@" +TOPDIR="@SRC_ROOT@" +OUTPUT_ROOT="@OUTPUT_ROOT@" +JDK_MAKE_SHARED_DIR="@JDK_TOPDIR@"/makefiles/common/shared +JDK_TOPDIR="@JDK_TOPDIR@" +LANGTOOLS_TOPDIR="@LANGTOOLS_TOPDIR@" +CORBA_TOPDIR="@CORBA_TOPDIR@" +JAXP_TOPDIR="@JAXP_TOPDIR@" +JAXWS_TOPDIR="@JAXWS_TOPDIR@" +HOTSPOT_TOPDIR="@HOTSPOT_TOPDIR@" +COPYRIGHT_YEAR="@COPYRIGHT_YEAR@" + +# Information gathered from the version.numbers file. +JDK_MAJOR_VERSION="@JDK_MAJOR_VERSION@" +JDK_MINOR_VERSION="@JDK_MINOR_VERSION@" +JDK_MICRO_VERSION="@JDK_MICRO_VERSION@" +JDK_UPDATE_VERSION="@JDK_UPDATE_VERSION@" +JDK_BUILD_NUMBER="@JDK_BUILD_NUMBER@" +MILESTONE="@MILESTONE@" +LAUNCHER_NAME="@LAUNCHER_NAME@" +PRODUCT_NAME="@PRODUCT_NAME@" +PRODUCT_SUFFIX="@PRODUCT_SUFFIX@" +JDK_RC_PLATFORM_NAME="@JDK_RC_PLATFORM_NAME@" +COMPANY_NAME="@COMPANY_NAME@" + +# Different version strings generated from the above information. +JDK_VERSION="@JDK_VERSION@" +RUNTIME_NAME="@RUNTIME_NAME@" +FULL_VERSION="@FULL_VERSION@" +JRE_RELEASE_VERSION="@FULL_VERSION@" +RELEASE="@RELEASE@" +COOKED_BUILD_NUMBER="@COOKED_BUILD_NUMBER@" + +# How to compile the code: release, fastdebug or slowdebug +DEBUG_LEVEL="@DEBUG_LEVEL@" + +# This is the JDK variant to build. +# The JDK variant is a name for a specific set of modules to be compiled for the JDK. +JDK_VARIANT="@JDK_VARIANT@" + +# Should we compile support for running with a graphical UI? (ie headful) +# Should we compile support for running without? (ie headless) +SUPPORT_HEADFUL="@SUPPORT_HEADFUL@" +SUPPORT_HEADLESS="@SUPPORT_HEADLESS@" + +# These are the libjvms that we want to build. +# The java launcher uses the default. +# The other can be selected by specifying -client -server -kernel -zero or -zeroshark +# on the java launcher command line. +JVM_VARIANTS="@JVM_VARIANTS@" +JVM_VARIANT_SERVER="@JVM_VARIANT_SERVER@" +JVM_VARIANT_CLIENT="@JVM_VARIANT_CLIENT@" +JVM_VARIANT_KERNEL="@JVM_VARIANT_KERNEL@" +JVM_VARIANT_ZERO="@JVM_VARIANT_ZERO@" +JVM_VARIANT_ZEROSHARK="@JVM_VARIANT_ZEROSHARK@" + +# Legacy setting: OPT or DBG +VARIANT="@VARIANT@" +# Legacy setting: true or false +FASTDEBUG="@FASTDEBUG@" +# Legacy setting: debugging the class files? +DEBUG_CLASSFILES="@DEBUG_CLASSFILES@" +# Legacy setting: -debug or -fastdebug +BUILD_VARIANT_RELEASE="@BUILD_VARIANT_RELEASE@" + +LANGTOOLS_OUTPUTDIR="@LANGTOOLS_OUTPUTDIR@" +CORBA_OUTPUTDIR="@CORBA_OUTPUTDIR@" +JAXP_OUTPUTDIR="@JAXP_OUTPUTDIR@" +JAXWS_OUTPUTDIR="@JAXWS_OUTPUTDIR@" +HOTSPOT_OUTPUTDIR="@HOTSPOT_OUTPUTDIR@" + +# This where a working jvm is built. +# You can run ${JDK_OUTPUTDIR}/bin/java +# Though the layout of the contents of ${JDK_OUTPUTDIR} is not +# yet the same as a default installation. +JDK_OUTPUTDIR="@OUTPUT_ROOT@"/jdk + +# When you run "make install" it will create the standardized +# layout for the jdk and the jre inside the images subdir. +# Then it will copy the contents of the jdk into the installation +# directory. +IMAGES_OUTPUTDIR="@OUTPUT_ROOT@"/images + +LANGTOOLS_DIST="@LANGTOOLS_DIST@" +CORBA_DIST="@CORBA_DIST@" +JAXP_DIST="@JAXP_DIST@" +JAXWS_DIST="@JAXWS_DIST@" +HOTSPOT_DIST="@HOTSPOT_DIST@" + +# Legacy variables used by Release.gmk +JDK_IMAGE_DIR=${IMAGES_OUTPUTDIR}/j2sdk-image +JRE_IMAGE_DIR=${IMAGES_OUTPUTDIR}/j2re-image + +# Can be /sparcv9 or /amd64 on Solaris +ISA_DIR="@LEGACY_OPENJDK_TARGET_CPU3@" +BINDIR="${JDK_OUTPUTDIR}/bin${ISA_DIR}" + +# The boot jdk to use +ALT_BOOTDIR="@BOOT_JDK@" +BOOT_JDK="@BOOT_JDK@" +BOOT_JDK_JVMARGS="@BOOT_JDK_JVMARGS@" +BOOT_RTJAR="@BOOT_RTJAR@" +BOOT_TOOLSJAR="@BOOT_TOOLSJAR@" + +# When compiling Java source to be run by the boot jdk +# use these extra flags, eg -source 6 -target 6 +BOOT_JDK_SOURCETARGET="@BOOT_JDK_SOURCETARGET@" + +# Information about the build system +NUM_CORES="@NUM_CORES@" +# This is used from the jdk build for C/C++ code. +PARALLEL_COMPILE_JOBS="@CONCURRENT_BUILD_JOBS@" +# Store javac server synchronization files here, and +# the javac server log files. +JAVAC_SERVERS="@JAVAC_SERVERS@" +# Should we use a javac server or not? The javac server gives +# an enormous performance improvement since it reduces the +# startup costs of javac and reuses as much as possible of intermediate +# compilation work. But if we want to compile with a non-Java +# javac compiler, like gcj. Then we cannot use javac server and +# this variable is set to false. +JAVAC_USE_REMOTE="@JAVAC_USE_REMOTE@" +# We can block the Javac server to never use more cores than this. +# This is not for performance reasons, but for memory usage, since each +# core requires its own JavaCompiler. We might have 64 cores and 4GB +# of memory, 64 JavaCompilers will currently not fit in a 3GB heap. +# Since there is no sharing of data between the JavaCompilers. +JAVAC_SERVER_CORES="@JAVAC_SERVER_CORES@" +# Should we use dependency tracking between Java packages? true or false. +JAVAC_USE_DEPS="@JAVAC_USE_DEPS@" +# We can invoke javac: SINGLE_THREADED_BATCH or MULTI_CORE_CONCURRENT +JAVAC_USE_MODE="@JAVAC_USE_MODE@" +# Enable not yet complete sjavac support. +ENABLE_SJAVAC="@ENABLE_SJAVAC@" + +# The OpenJDK makefiles should be changed to using the standard +# configure output ..._CFLAGS and ..._LIBS. In the meantime we +# extract the information here. +FREETYPE2_LIB_PATH="@FREETYPE2_LIB_PATH@" +FREETYPE2_LIBS="@FREETYPE2_LIBS@" +FREETYPE2_CFLAGS="@FREETYPE2_CFLAGS@" +USING_SYSTEM_FT_LIB="@USING_SYSTEM_FT_LIB@" +CUPS_CFLAGS="@CUPS_CFLAGS@" + +PACKAGE_PATH="@PACKAGE_PATH@" + +# Source file for cacerts +CACERTS_FILE="@CACERTS_FILE@" + +#MOZILLA_HEADERS_PATH= + +# Necessary additional compiler flags to compile X11 +X_CFLAGS="@X_CFLAGS@" +X_LIBS="@X_LIBS@" +OPENWIN_HOME="@OPENWIN_HOME@" + +# There are two types: CC or CL +# CC is gcc and others behaving reasonably similar. +# CL is cl.exe only. +COMPILER_TYPE="@COMPILER_TYPE@" + +# Flags used for overriding the default opt setting for a C/C++ source file. +C_O_FLAG_HIGHEST="@C_O_FLAG_HIGHEST@" +C_O_FLAG_HI="@C_O_FLAG_HI@" +C_O_FLAG_NORM="@C_O_FLAG_NORM@" +C_O_FLAG_NONE="@C_O_FLAG_NONE@" +CXX_O_FLAG_HIGHEST="@CXX_O_FLAG_HIGHEST@" +CXX_O_FLAG_HI="@CXX_O_FLAG_HI@" +CXX_O_FLAG_NORM="@CXX_O_FLAG_NORM@" +CXX_O_FLAG_NONE="@CXX_O_FLAG_NONE@" + +C_FLAG_DEPS="@C_FLAG_DEPS@" +CXX_FLAG_DEPS="@CXX_FLAG_DEPS@" + +# Tools that potentially need to be cross compilation aware. +CC="@UNCYGDRIVE@ @CCACHE@ @CC@" + +# CFLAGS used to compile the jdk native libraries (C-code) +CFLAGS_JDKLIB="@CFLAGS_JDKLIB@" +CXXFLAGS_JDKLIB="@CXXFLAGS_JDKLIB@" + +# CFLAGS used to compile the jdk native launchers (C-code) +CFLAGS_JDKEXE="@CFLAGS_JDKEXE@" +CXXFLAGS_JDKEXE="@CXXFLAGS_JDKEXE@" + +CXX="@UNCYGDRIVE@ @CCACHE@ @CXX@" +#CXXFLAGS="@CXXFLAGS@" + +OBJC="@CCACHE@ @OBJC@" +#OBJCFLAGS="@OBJCFLAGS@" + +CPP="@UNCYGDRIVE@ @CPP@" +#CPPFLAGS="@CPPFLAGS@" + +# The linker can be gcc or ld on posix systems, or link.exe on winapi systems. +LD="@UNCYGDRIVE@ @LD@" + +# LDFLAGS used to link the jdk native libraries (C-code) +LDFLAGS_JDKLIB="@LDFLAGS_JDKLIB@" +LDFLAGS_JDKLIB_SUFFIX="@LDFLAGS_JDKLIB_SUFFIX@" + +# On some platforms the linker cannot be used to create executables, thus +# the need for a separate LDEXE command. +LDEXE="@UNCYGDRIVE@ @LDEXE@" + +# LDFLAGS used to link the jdk native launchers (C-code) +LDFLAGS_JDKEXE="@LDFLAGS_JDKEXE@" +LDFLAGS_JDKEXE_SUFFIX="@LDFLAGS_JDKEXE_SUFFIX@" + +# Sometimes a different linker is needed for c++ libs +LDCXX="@UNCYGDRIVE@ @LDCXX@" +# The flags for linking libstdc++ linker. +LIBCXX="@LIBCXX@" + +# Sometimes a different linker is needed for c++ executables +LDEXECXX="@UNCYGDRIVE@ @LDEXECXX@" + +# If cross compiling, then define CROSS_COMPILE_ARCH=cpu_name here. +# The HOSTCC should really be named BUILDCC, ie build executable for +# the build platform. Same as CC when not cross compiling. +HOSTCC="@HOSTCC@" +HOSTCXX="@HOSTCXX@" +# And of course, the jdk spells HOSTCC as NIO_CC/HOST_CC +HOST_CC="@HOSTCC@" +NIO_CC="@HOSTCC@" + +AS="@AS@" +ASFLAGS="@ASFLAGS@" + +# AR is used to create a static library (is ar in posix, lib.exe in winapi) +AR="@UNCYGDRIVE@ @AR@" +ARFLAGS="@ARFLAGS@" + +NM="@NM@" +STRIP="@STRIP@" +MCS="@MCS@" + +# Command to create a shared library +SHARED_LIBRARY_FLAGS="@SHARED_LIBRARY_FLAGS@" + +# Options to linker to specify a mapfile. +# (Note absence of = assignment, because we do not want to evaluate the macro body here) +SET_SHARED_LIBRARY_MAPFILE="@SET_SHARED_LIBRARY_MAPFILE@" + +# Options for C/CXX compiler to be used if linking is performed +# using reorder file +C_FLAG_REORDER="@C_FLAG_REORDER@" +CXX_FLAG_REORDER="@CXX_FLAG_REORDER@" + +# +# Options for generating debug symbols +ENABLE_DEBUG_SYMBOLS="@ENABLE_DEBUG_SYMBOLS@" +CFLAGS_DEBUG_SYMBOLS="@CFLAGS_DEBUG_SYMBOLS@" +CXXFLAGS_DEBUG_SYMBOLS="@CXXFLAGS_DEBUG_SYMBOLS@" +ZIP_DEBUGINFO_FILES="@ZIP_DEBUGINFO_FILES@" + +# Options to linker to specify the library name. +# (Note absence of = assignment, because we do not want to evaluate the macro body here) +SET_SHARED_LIBRARY_NAME="@SET_SHARED_LIBRARY_NAME@" + +# Set origin using the linker, ie use the relative path to the dependent library to find the dependees. +# (Note absence of = assignment, because we do not want to evaluate the macro body here) +SET_SHARED_LIBRARY_ORIGIN="@SET_SHARED_LIBRARY_ORIGIN@" + +# Different OS:es have different ways of naming shared libraries. +# The SHARED_LIBRARY macro takes "verify" as and argument and returns: +# "libverify.so" or "libverify.dylib" or "verify.dll" depending on platform. +# (Note absence of = assignment, because we do not want to evaluate the macro body here) +SHARED_LIBRARY="@SHARED_LIBRARY@" +STATIC_LIBRARY="@STATIC_LIBRARY@" +LIBRARY_PREFIX="@LIBRARY_PREFIX@" +SHARED_LIBRARY_SUFFIX="@SHARED_LIBRARY_SUFFIX@" +STATIC_LIBRARY_SUFFIX="@STATIC_LIBRARY_SUFFIX@" +EXE_SUFFIX="@EXE_SUFFIX@" +OBJ_SUFFIX="@OBJ_SUFFIX@" + +POST_STRIP_CMD="@POST_STRIP_CMD@" +POST_MCS_CMD='@POST_MCS_CMD@' + +JAVA_FLAGS="@BOOT_JDK_JVMARGS@" + +JAVA="@UNCYGDRIVE@ @JAVA@ ${JAVA_FLAGS}" + +JAVAC="@UNCYGDRIVE@ @JAVAC@" +JAVAC_FLAGS="@JAVAC_FLAGS@" + +JAVAH="@UNCYGDRIVE@ @JAVAH@" + +JAR="@UNCYGDRIVE@ @JAR@" + +RMIC="@UNCYGDRIVE@ @RMIC@" + +NATIVE2ASCII="@UNCYGDRIVE@ @NATIVE2ASCII@" + +BOOT_JAR_CMD="@UNCYGDRIVE@ @JAR@" +BOOT_JAR_JFLAGS= + +# Tools adhering to a minimal and common standard of posix compliance. +AWK="@AWK@" +CAT="@CAT@" +CCACHE="@CCACHE@" +# CD is going away, but remains to cater for legacy makefiles. +CD=cd +CHMOD="@CHMOD@" +CP="@CP@" +CPIO="@CPIO@" +CUT="@CUT@" +DATE="@DATE@" +DF="@DF@" +DIFF="@DIFF@" +FIND="@FIND@" +FIND_DELETE="@FIND_DELETE@" +ECHO="@ECHO@" +EGREP="@EGREP@" +FGREP="@FGREP@" +GREP="@GREP@" +HEAD="@HEAD@" +LS="@LS@" +LN="@LN@" +MKDIR="@MKDIR@" +MV="@MV@" +NAWK="@NAWK@" +PRINTF="@PRINTF@" +PWD="@THEPWDCMD@" +RM="@RM@" +SED="@SED@" +SH="@SH@" +SORT="@SORT@" +TAR="@TAR@" +TAIL="@TAIL@" +TEE="@TEE@" +TR="@TR@" +TOUCH="@TOUCH@" +WC="@WC@" +XARGS="@XARGS@" +ZIPEXE="@ZIP@" +ZIP="@ZIP@" +UNZIP="@UNZIP@" +MT="@UNCYGDRIVE@ @MT@" +RC="@UNCYGDRIVE@ @RC@" +DUMPBIN="@UNCYGDRIVE@ @DUMPBIN@" +CYGPATH="@CYGPATH@" +LDD="@LDD@" +OTOOL="@OTOOL@" +READELF="@READELF@" +EXPR="@EXPR@" +FILE="@FILE@" +HG="@HG@" +OBJCOPY="@OBJCOPY@" + +UNCYGDRIVE="@UNCYGDRIVE@" + +# Build setup +ENABLE_DOCS="@ENABLE_DOCS@" +GENERATE_DOCS="@ENABLE_DOCS@" +DISABLE_NIMBUS="@DISABLE_NIMBUS@" +USE_EXTERNAL_LIBJPEG="@USE_EXTERNAL_LIBJPEG@" +USE_EXTERNAL_LIBGIF="@USE_EXTERNAL_LIBGIF@" +USE_EXTERNAL_LIBZ="@USE_EXTERNAL_LIBZ@" +LIBZIP_CAN_USE_MMAP="@LIBZIP_CAN_USE_MMAP@" +CHECK_FOR_VCINSTALLDIR="@CHECK_FOR_VCINSTALLDIR@" +MSVCRNN_DLL="@MSVCR100DLL@" + + +#################################################### +# +# Legacy Hotspot support + +HOTSPOT_DIST="@HOTSPOT_DIST@" +HOTSPOT_MAKE_ARGS="@HOTSPOT_MAKE_ARGS@" +# This is used from the libjvm build for C/C++ code. +HOTSPOT_BUILD_JOBS="@CONCURRENT_BUILD_JOBS@" +# Control wether Hotspot runs Queens test after building +TEST_IN_BUILD="@TEST_IN_BUILD@" + +#################################################### +# +# INSTALLATION +# + +# Common prefix for all installed files. Defaults to /usr/local, +# but /opt/myjdk is another common version. +INSTALL_PREFIX="@prefix@" + +# Directories containing architecture-dependent files should be relative to exec_prefix +INSTALL_EXECPREFIX="@exec_prefix@" + +# java,javac,javah,javap etc are installed here. +INSTALL_BINDIR="@bindir@" + +# Read only architecture-independent data +INSTALL_DATADIR="@datadir@" + +# Root of above. +INSTALL_DATAROOTDIR="@datarootdir@" + +# Doc files, other than info and man. +INSTALL_DOCDIR="@docdir@" + +# Html documentation +INSTALL_HTMLDIR="@htmldir@" + +# Installing C header files, JNI headers for example. +INSTALL_INCLUDEDIR="@includedir@" + +# Installing library files.... +INSTALL_INCLUDEDIR="@libdir@" + +# Executables that other programs run. +INSTALL_LIBEXECDIR="@libexecdir@" + +# Locale-dependent but architecture-independent data, such as message catalogs. +INSTALL_LOCALEDIR="@localedir@" + +# Modifiable single-machine data +INSTALL_LOCALSTATEDIR="@localstatedir@" + +# Man pages +INSTALL_MANDIR="@mandir@" + +# Modifiable architecture-independent data. +INSTALL_SHAREDSTATEDIR="@sharedstatedir@" + +# Read-only single-machine data +INSTALL_SYSCONFDIR="@sysconfdir@" + + +#################################################### +# +# Misc +# + +# Name of Service Agent library +SALIB_NAME="@SALIB_NAME@" + +OS_VERSION_MAJOR="@OS_VERSION_MAJOR@" +OS_VERSION_MINOR="@OS_VERSION_MINOR@" +OS_VERSION_MICRO="@OS_VERSION_MICRO@" diff --git a/common/autoconf/toolchain.m4 b/common/autoconf/toolchain.m4 new file mode 100644 index 00000000000..252e06af4d0 --- /dev/null +++ b/common/autoconf/toolchain.m4 @@ -0,0 +1,908 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +AC_DEFUN_ONCE([TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV], +[ + +# Check if the VS env variables were setup prior to running configure. +# If not, then find vcvarsall.bat and run it automatically, and integrate +# the set env variables into the spec file. +SETUPDEVENV="# No special vars" +if test "x$OPENJDK_BUILD_OS" = "xwindows"; then + # If vcvarsall.bat has been run, then VCINSTALLDIR is set. + if test "x$VCINSTALLDIR" != x; then + # No further setup is needed. The build will happen from this kind + # of shell. + SETUPDEVENV="# This spec file expects that you are running bash from within a VS command prompt." + # Make sure to remind you, if you forget to run make from a cygwin bash shell + # that is spawned "bash -l" from a VS command prompt. + CHECK_FOR_VCINSTALLDIR=yes + AC_MSG_CHECKING([if you are running from within a VS command prompt]) + AC_MSG_RESULT([yes]) + else + # Ah, we have not yet run vcvarsall.bat/vsvars32.bat/vsvars64.bat. Lets do that. First find it. + if test "x$VS100COMNTOOLS" != x; then + VARSBAT=`find "$VS100COMNTOOLS/../.." -name vcvarsall.bat` + SEARCH_ROOT="$VS100COMNTOOLS" + else + VARSBAT=`find "$PROGRAMFILES" -name vcvarsall.bat` + SEARCH_ROOT="$PROGRAMFILES" + fi + VCPATH=`dirname "$VARSBAT"` + VCPATH=`cygpath -w "$VCPATH"` + if test "x$VARSBAT" = x || test ! -d "$VCPATH"; then + AC_MSG_CHECKING([if we can find the VS installation]) + AC_MSG_RESULT([no]) + AC_MSG_ERROR([Tried to find a VS installation using both $SEARCH_ROOT but failed. Please run "c:\\cygwin\\bin\\bash.exe -l" from a VS command prompt and then run configure/make from there.]) + fi + case "$LEGACY_OPENJDK_TARGET_CPU1" in + i?86) + VARSBAT_ARCH=x86 + ;; + *) + VARSBAT_ARCH=$LEGACY_OPENJDK_TARGET_CPU1 + ;; + esac + # Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat + cd $OUTPUT_ROOT + bash $SRC_ROOT/common/bin/extractvcvars.sh "$VARSBAT" "$VARSBAT_ARCH" + cd $CURDIR + if test ! -s $OUTPUT_ROOT/localdevenv.sh || test ! -s $OUTPUT_ROOT/localdevenv.gmk; then + AC_MSG_CHECKING([if we can extract the needed env variables]) + AC_MSG_RESULT([no]) + AC_MSG_ERROR([Could not succesfully extract the env variables needed for the VS setup. Please run "c:\\cygwin\\bin\\bash.exe -l" from a VS command prompt and then run configure/make from there.]) + fi + # Now set all paths and other env variables. This will allow the rest of + # the configure script to find and run the compiler in the proper way. + . $OUTPUT_ROOT/localdevenv.sh + AC_MSG_CHECKING([if we can find the VS installation]) + if test "x$VCINSTALLDIR" != x; then + AC_MSG_RESULT([$VCINSTALLDIR]) + else + AC_MSG_RESULT([no]) + AC_MSG_ERROR([Could not find VS installation. Please install. If you are sure you have installed VS, then please run "c:\\cygwin\\bin\\bash.exe -l" from a VS command prompt and then run configure/make from there.]) + fi + CHECK_FOR_VCINSTALLDIR=no + SETUPDEVENV="include $OUTPUT_ROOT/localdevenv.gmk" + + AC_MSG_CHECKING([for msvcr100.dll]) + AC_ARG_WITH(msvcr100dll, [AS_HELP_STRING([--with-msvcr100dll], + [copy this msvcr100.dll into the built JDK])]) + if test "x$with_msvcr100dll" != x; then + MSVCR100DLL="$with_msvcr100dll" + else + if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then + MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | grep x64 | head --lines 1` + else + MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | grep x86 | grep -v ia64 | grep -v x64 | head --lines 1` + if test "x$MSVCR100DLL" = x; then + MSVCR100DLL=`find "$VCINSTALLDIR/.." -name msvcr100.dll | head --lines 1` + fi + fi + fi + if test "x$MSVCR100DLL" = x; then + AC_MSG_RESULT([no]) + AC_MSG_ERROR([Could not find msvcr100.dll !]) + fi + AC_MSG_RESULT([$MSVCR100DLL]) + SPACESAFE(MSVCR100DLL,[the path to msvcr100.dll]) + fi +fi +AC_SUBST(SETUPDEVENV) +AC_SUBST(CHECK_FOR_VCINSTALLDIR) +AC_SUBST(MSVCR100DLL) +]) + +AC_DEFUN_ONCE([TOOLCHAIN_SETUP_SYSROOT_AND_OUT_OPTIONS], +[ +############################################################################### +# +# Configure the development tool paths and potential sysroot. +# +AC_LANG(C++) +DEVKIT= +SYS_ROOT=/ +AC_SUBST(SYS_ROOT) + +# The option used to specify the target .o,.a or .so file. +# When compiling, how to specify the to be created object file. +CC_OUT_OPTION='-o$(SPACE)' +# When linking, how to specify the to be created executable. +EXE_OUT_OPTION='-o$(SPACE)' +# When linking, how to specify the to be created dynamically linkable library. +LD_OUT_OPTION='-o$(SPACE)' +# When archiving, how to specify the to be create static archive for object files. +AR_OUT_OPTION='rcs$(SPACE)' +AC_SUBST(CC_OUT_OPTION) +AC_SUBST(EXE_OUT_OPTION) +AC_SUBST(LD_OUT_OPTION) +AC_SUBST(AR_OUT_OPTION) +]) + +AC_DEFUN_ONCE([TOOLCHAIN_SETUP_PATHS], +[ +# If --build AND --host is set, then the configure script will find any +# cross compilation tools in the PATH. Cross compilation tools +# follows the cross compilation standard where they are prefixed with ${host}. +# For example the binary i686-sun-solaris2.10-gcc +# will cross compile for i686-sun-solaris2.10 +# If neither of build and host is not set, then build=host and the +# default compiler found in the path will be used. +# Setting only --host, does not seem to be really supported. +# Please set both --build and --host if you want to cross compile. + +DEFINE_CROSS_COMPILE_ARCH="" +HOSTCC="" +HOSTCXX="" +HOSTLD="" +AC_SUBST(DEFINE_CROSS_COMPILE_ARCH) +AC_MSG_CHECKING([if this is a cross compile]) +if test "x$OPENJDK_BUILD_SYSTEM" != "x$OPENJDK_TARGET_SYSTEM"; then + AC_MSG_RESULT([yes, from $OPENJDK_BUILD_SYSTEM to $OPENJDK_TARGET_SYSTEM]) + # We have detected a cross compile! + DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$LEGACY_OPENJDK_TARGET_CPU1" + # Now we to find a C/C++ compiler that can build executables for the build + # platform. We can't use the AC_PROG_CC macro, since it can only be used + # once. + AC_PATH_PROGS(HOSTCC, [cl cc gcc]) + WHICHCMD(HOSTCC) + AC_PATH_PROGS(HOSTCXX, [cl CC g++]) + WHICHCMD(HOSTCXX) + AC_PATH_PROG(HOSTLD, ld) + WHICHCMD(HOSTLD) + # Building for the build platform should be easy. Therefore + # we do not need any linkers or assemblers etc. +else + AC_MSG_RESULT([no]) +fi + +# You can force the sys-root if the sys-root encoded into the cross compiler tools +# is not correct. +AC_ARG_WITH(sys-root, [AS_HELP_STRING([--with-sys-root], + [pass this sys-root to the compilers and linker (useful if the sys-root encoded in + the cross compiler tools is incorrect)])]) + +if test "x$with_sys_root" != x; then + SYS_ROOT=$with_sys_root +fi + +# If a devkit is found on the builddeps server, then prepend its path to the +# PATH variable. If there are cross compilers available in the devkit, these +# will be found by AC_PROG_CC et al. +BDEPS_CHECK_MODULE(DEVKIT, devkit, xxx, + [# Found devkit + PATH="$DEVKIT/bin:$PATH" + SYS_ROOT="$DEVKIT/${rewritten_target}/sys-root" + if test "x$x_includes" = "xNONE"; then + x_includes="$SYS_ROOT/usr/include/X11" + fi + if test "x$x_libraries" = "xNONE"; then + x_libraries="$SYS_ROOT/usr/lib" + fi + ], + []) + +if test "x$SYS_ROOT" != "x/" ; then + CFLAGS="--sysroot=$SYS_ROOT $CFLAGS" + CXXFLAGS="--sysroot=$SYS_ROOT $CXXFLAGS" + OBJCFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" + OBJCXXFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" + CPPFLAGS="--sysroot=$SYS_ROOT $CPPFLAGS" + LDFLAGS="--sysroot=$SYS_ROOT $LDFLAGS" +fi + +# Store the CFLAGS etal passed to the configure script. +ORG_CFLAGS="$CFLAGS" +ORG_CXXFLAGS="$CXXFLAGS" +ORG_OBJCFLAGS="$OBJCFLAGS" + +AC_ARG_WITH([tools-dir], [AS_HELP_STRING([--with-tools-dir], + [search this directory for compilers and tools])], [TOOLS_DIR=$with_tools_dir]) + +AC_ARG_WITH([devkit], [AS_HELP_STRING([--with-devkit], + [use this directory as base for tools-dir and sys-root])], [ + if test "x$with_sys_root" != x; then + AC_MSG_ERROR([Cannot specify both --with-devkit and --with-sys-root at the same time]) + fi + if test "x$with_tools_dir" != x; then + AC_MSG_ERROR([Cannot specify both --with-devkit and --with-tools-dir at the same time]) + fi + TOOLS_DIR=$with_devkit/bin + SYS_ROOT=$with_devkit/$host_alias/libc + ]) + +# autoconf magic only relies on PATH, so update it if tools dir is specified +OLD_PATH="$PATH" +if test "x$TOOLS_DIR" != x; then + PATH=$TOOLS_DIR:$PATH +fi + +# gcc is almost always present, but on Windows we +# prefer cl.exe and on Solaris we prefer CC. +# Thus test for them in this order. +AC_PROG_CC([cl cc gcc]) +if test "x$CC" = x; then + HELP_MSG_MISSING_DEPENDENCY([devkit]) + AC_MSG_ERROR([Could not find a compiler. $HELP_MSG]) +fi +if test "x$CC" = xcc && test "x$OPENJDK_BUILD_OS" = xmacosx; then + # Do not use cc on MacOSX use gcc instead. + CC="gcc" +fi +WHICHCMD(CC) + +AC_PROG_CXX([cl CC g++]) +if test "x$CXX" = xCC && test "x$OPENJDK_BUILD_OS" = xmacosx; then + # The found CC, even though it seems to be a g++ derivate, cannot compile + # c++ code. Override. + CXX="g++" +fi +WHICHCMD(CXX) + +if test "x$CXX" = x || test "x$CC" = x; then + HELP_MSG_MISSING_DEPENDENCY([devkit]) + AC_MSG_ERROR([Could not find the needed compilers! $HELP_MSG ]) +fi + +if test "x$OPENJDK_BUILD_OS" != xwindows; then + AC_PROG_OBJC + WHICHCMD(OBJC) +else + OBJC= +fi + +# Restore the flags to the user specified values. +# This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2" +CFLAGS="$ORG_CFLAGS" +CXXFLAGS="$ORG_CXXFLAGS" +OBJCFLAGS="$ORG_OBJCFLAGS" + +# If we are not cross compiling, use the same compilers for +# building the build platform executables. +if test "x$DEFINE_CROSS_COMPILE_ARCH" = x; then + HOSTCC="$CC" + HOSTCXX="$CXX" +fi + +AC_CHECK_TOOL(LD, ld) +WHICHCMD(LD) +LD="$CC" +LDEXE="$CC" +LDCXX="$CXX" +LDEXECXX="$CXX" +# LDEXE is the linker to use, when creating executables. +AC_SUBST(LDEXE) +# Linking C++ libraries. +AC_SUBST(LDCXX) +# Linking C++ executables. +AC_SUBST(LDEXECXX) + +AC_CHECK_TOOL(AR, ar) +WHICHCMD(AR) +if test "x$OPENJDK_BUILD_OS" = xmacosx; then + ARFLAGS="-r" +else + ARFLAGS="" +fi +AC_SUBST(ARFLAGS) + +COMPILER_NAME=gcc +COMPILER_TYPE=CC +AS_IF([test "x$OPENJDK_BUILD_OS" = xwindows], [ + # For now, assume that we are always compiling using cl.exe. + CC_OUT_OPTION=-Fo + EXE_OUT_OPTION=-out: + LD_OUT_OPTION=-out: + AR_OUT_OPTION=-out: + # On Windows, reject /usr/bin/link, which is a cygwin + # program for something completely different. + AC_CHECK_PROG([WINLD], [link],[link],,, [/usr/bin/link]) + # Since we must ignore the first found link, WINLD will contain + # the full path to the link.exe program. + WHICHCMD_SPACESAFE([WINLD]) + LD="$WINLD" + LDEXE="$WINLD" + LDCXX="$WINLD" + LDEXECXX="$WINLD" + # Set HOSTLD to same as LD until we fully support cross compilation + # on windows. + HOSTLD="$WINLD" + + AC_CHECK_PROG([MT], [mt], [mt],,, [/usr/bin/mt]) + WHICHCMD_SPACESAFE([MT]) + # The resource compiler + AC_CHECK_PROG([RC], [rc], [rc],,, [/usr/bin/rc]) + WHICHCMD_SPACESAFE([RC]) + + RC_FLAGS="-nologo /l 0x409 /r" + AS_IF([test "x$VARIANT" = xOPT], [ + RC_FLAGS="$RC_FLAGS -d NDEBUG" + ]) + JDK_UPDATE_VERSION_NOTNULL=$JDK_UPDATE_VERSION + AS_IF([test "x$JDK_UPDATE_VERSION" = x], [ + JDK_UPDATE_VERSION_NOTNULL=0 + ]) + RC_FLAGS="$RC_FLAGS -d \"JDK_BUILD_ID=$FULL_VERSION\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_COMPANY=$COMPANY_NAME\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_COMPONENT=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME binary\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_VER=$JDK_MINOR_VERSION.$JDK_MICRO_VERSION.$JDK_UPDATE_VERSION_NOTNULL.$COOKED_BUILD_NUMBER\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_NAME=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME $JDK_MINOR_VERSION $JDK_UPDATE_META_TAG\"" + RC_FLAGS="$RC_FLAGS -d \"JDK_FVER=$JDK_MINOR_VERSION,$JDK_MICRO_VERSION,$JDK_UPDATE_VERSION_NOTNULL,$COOKED_BUILD_NUMBER\"" + + # lib.exe is used to create static libraries. + AC_CHECK_PROG([WINAR], [lib],[lib],,,) + WHICHCMD_SPACESAFE([WINAR]) + AR="$WINAR" + ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT" + + AC_CHECK_PROG([DUMPBIN], [dumpbin], [dumpbin],,,) + WHICHCMD_SPACESAFE([DUMPBIN]) + + COMPILER_TYPE=CL + CCXXFLAGS="$CCXXFLAGS -nologo" +]) +AC_SUBST(RC_FLAGS) +AC_SUBST(COMPILER_TYPE) + +AC_PROG_CPP +WHICHCMD(CPP) + +AC_PROG_CXXCPP +WHICHCMD(CXXCPP) + +# for solaris we really need solaris tools, and not gnu equivalent +# these seems to normally reside in /usr/ccs/bin so add that to path before +# starting to probe +# +# NOTE: I add this /usr/ccs/bin after TOOLS but before OLD_PATH +# so that it can be overriden --with-tools-dir +if test "x$OPENJDK_BUILD_OS" = xsolaris; then + PATH="${TOOLS_DIR}:/usr/ccs/bin:${OLD_PATH}" +fi + +# Find the right assembler. +if test "x$OPENJDK_BUILD_OS" = xsolaris; then + AC_PATH_PROG(AS, as) + WHICHCMD(AS) + ASFLAGS=" " +else + AS="$CC -c" + ASFLAGS=" " +fi +AC_SUBST(AS) +AC_SUBST(ASFLAGS) + +if test "x$OPENJDK_BUILD_OS" = xsolaris; then + AC_PATH_PROG(NM, nm) + WHICHCMD(NM) + AC_PATH_PROG(STRIP, strip) + WHICHCMD(STRIP) + AC_PATH_PROG(MCS, mcs) + WHICHCMD(MCS) +else + AC_CHECK_TOOL(NM, nm) + WHICHCMD(NM) + AC_CHECK_TOOL(STRIP, strip) + WHICHCMD(STRIP) +fi + +### +# +# Check for objcopy +# +# but search for gobjcopy first... +# since I on solaris found a broken objcopy...buhh +# +AC_PATH_TOOL(OBJCOPY, gobjcopy) +if test "x$OBJCOPY" = x; then + AC_PATH_TOOL(OBJCOPY, objcopy) +fi + +# Restore old path without tools dir +PATH="$OLD_PATH" +]) + + +AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_LIBS], +[ + +############################################################################### +# +# How to compile shared libraries. +# + +if test "x$GCC" = xyes; then + COMPILER_NAME=gcc + PICFLAG="-fPIC" + LIBRARY_PREFIX=lib + SHARED_LIBRARY='lib[$]1.so' + STATIC_LIBRARY='lib[$]1.a' + SHARED_LIBRARY_FLAGS="-shared" + SHARED_LIBRARY_SUFFIX='.so' + STATIC_LIBRARY_SUFFIX='.a' + OBJ_SUFFIX='.o' + EXE_SUFFIX='' + SET_SHARED_LIBRARY_NAME='-Xlinker -soname=[$]1' + SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=[$]1' + C_FLAG_REORDER='' + CXX_FLAG_REORDER='' + SET_SHARED_LIBRARY_ORIGIN='-Xlinker -z -Xlinker origin -Xlinker -rpath -Xlinker \$$$$ORIGIN/[$]1' + LD="$CC" + LDEXE="$CC" + LDCXX="$CXX" + LDEXECXX="$CXX" + POST_STRIP_CMD="$STRIP -g" + if test "x$JDK_VARIANT" = xembedded; then + POST_STRIP_CMD="$STRIP --strip-unneeded" + fi + + # Linking is different on MacOSX + if test "x$OPENJDK_BUILD_OS" = xmacosx; then + # Might change in the future to clang. + COMPILER_NAME=gcc + SHARED_LIBRARY='lib[$]1.dylib' + SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG" + SHARED_LIBRARY_SUFFIX='.dylib' + EXE_SUFFIX='' + SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/[$]1' + SET_SHARED_LIBRARY_MAPFILE='' + SET_SHARED_LIBRARY_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.' + POST_STRIP_CMD="$STRIP -S" + fi +else + if test "x$OPENJDK_BUILD_OS" = xsolaris; then + # If it is not gcc, then assume it is the Oracle Solaris Studio Compiler + COMPILER_NAME=ossc + PICFLAG="-KPIC" + LIBRARY_PREFIX=lib + SHARED_LIBRARY='lib[$]1.so' + STATIC_LIBRARY='lib[$]1.a' + SHARED_LIBRARY_FLAGS="-z defs -xildoff -ztext -G" + SHARED_LIBRARY_SUFFIX='.so' + STATIC_LIBRARY_SUFFIX='.a' + OBJ_SUFFIX='.o' + EXE_SUFFIX='' + SET_SHARED_LIBRARY_NAME='' + SET_SHARED_LIBRARY_MAPFILE='-M[$]1' + C_FLAG_REORDER='-xF' + CXX_FLAG_REORDER='-xF' + SET_SHARED_LIBRARY_ORIGIN='-R \$$$$ORIGIN/[$]1' + CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__" + CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__" + CFLAGS_JDKLIB_EXTRA='-xstrconst' + POST_STRIP_CMD="$STRIP -x" + POST_MCS_CMD="$MCS -d -a \"JDK $FULL_VERSION\"" + fi + if test "x$OPENJDK_BUILD_OS" = xwindows; then + # If it is not gcc, then assume it is the MS Visual Studio compiler + COMPILER_NAME=cl + PICFLAG="" + LIBRARY_PREFIX= + SHARED_LIBRARY='[$]1.dll' + STATIC_LIBRARY='[$]1.lib' + SHARED_LIBRARY_FLAGS="-LD" + SHARED_LIBRARY_SUFFIX='.dll' + STATIC_LIBRARY_SUFFIX='.lib' + OBJ_SUFFIX='.obj' + EXE_SUFFIX='.exe' + SET_SHARED_LIBRARY_NAME='' + SET_SHARED_LIBRARY_MAPFILE='' + SET_SHARED_LIBRARY_ORIGIN='' + fi +fi + +AC_SUBST(OBJ_SUFFIX) +AC_SUBST(SHARED_LIBRARY) +AC_SUBST(STATIC_LIBRARY) +AC_SUBST(LIBRARY_PREFIX) +AC_SUBST(SHARED_LIBRARY_SUFFIX) +AC_SUBST(STATIC_LIBRARY_SUFFIX) +AC_SUBST(EXE_SUFFIX) +AC_SUBST(SHARED_LIBRARY_FLAGS) +AC_SUBST(SET_SHARED_LIBRARY_NAME) +AC_SUBST(SET_SHARED_LIBRARY_MAPFILE) +AC_SUBST(C_FLAG_REORDER) +AC_SUBST(CXX_FLAG_REORDER) +AC_SUBST(SET_SHARED_LIBRARY_ORIGIN) +AC_SUBST(POST_STRIP_CMD) +AC_SUBST(POST_MCS_CMD) + +# The (cross) compiler is now configured, we can now test capabilities +# of the target platform. +]) + +AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION], +[ + +############################################################################### +# +# Setup the opt flags for different compilers +# and different operating systems. +# +C_FLAG_DEPS="-MMD -MF" +CXX_FLAG_DEPS="-MMD -MF" + +case $COMPILER_TYPE in + CC ) + D_FLAG="-g" + case $COMPILER_NAME in + gcc ) + case $OPENJDK_TARGET_OS in + macosx ) + # On MacOSX we optimize for size, something + # we should do for all platforms? + C_O_FLAG_HI="-Os" + C_O_FLAG_NORM="-Os" + C_O_FLAG_NONE="" + ;; + *) + C_O_FLAG_HI="-O3" + C_O_FLAG_NORM="-O2" + C_O_FLAG_NONE="-O0" + CFLAGS_DEBUG_SYMBOLS="-g" + CXXFLAGS_DEBUG_SYMBOLS="-g" + if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then + CFLAGS_DEBUG_SYMBOLS="-g1" + CXXFLAGS_DEBUG_SYMBOLSG="-g1" + fi + ;; + esac + CXX_O_FLAG_HI="$C_O_FLAG_HI" + CXX_O_FLAG_NORM="$C_O_FLAG_NORM" + CXX_O_FLAG_NONE="$C_O_FLAG_NONE" + ;; + ossc ) + # + # Forte has different names for this with their C++ compiler... + # + C_FLAG_DEPS="-xMMD -xMF" + CXX_FLAG_DEPS="-xMMD -xMF" + +# Extra options used with HIGHEST +# +# WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be +# done with care, there are some assumptions below that need to +# be understood about the use of pointers, and IEEE behavior. +# +# Use non-standard floating point mode (not IEEE 754) +CC_HIGHEST="$CC_HIGHEST -fns" +# Do some simplification of floating point arithmetic (not IEEE 754) +CC_HIGHEST="$CC_HIGHEST -fsimple" +# Use single precision floating point with 'float' +CC_HIGHEST="$CC_HIGHEST -fsingle" +# Assume memory references via basic pointer types do not alias +# (Source with excessing pointer casting and data access with mixed +# pointer types are not recommended) +CC_HIGHEST="$CC_HIGHEST -xalias_level=basic" +# Use intrinsic or inline versions for math/std functions +# (If you expect perfect errno behavior, do not use this) +CC_HIGHEST="$CC_HIGHEST -xbuiltin=%all" +# Loop data dependency optimizations (need -xO3 or higher) +CC_HIGHEST="$CC_HIGHEST -xdepend" +# Pointer parameters to functions do not overlap +# (Similar to -xalias_level=basic usage, but less obvious sometimes. +# If you pass in multiple pointers to the same data, do not use this) +CC_HIGHEST="$CC_HIGHEST -xrestrict" +# Inline some library routines +# (If you expect perfect errno behavior, do not use this) +CC_HIGHEST="$CC_HIGHEST -xlibmil" +# Use optimized math routines +# (If you expect perfect errno behavior, do not use this) +# Can cause undefined external on Solaris 8 X86 on __sincos, removing for now +#CC_HIGHEST="$CC_HIGHEST -xlibmopt" + + case $LEGACY_OPENJDK_TARGET_CPU1 in + i586) + C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xchip=pentium" + C_O_FLAG_HI="-xO4 -Wu,-O4~yz" + C_O_FLAG_NORM="-xO2 -Wu,-O2~yz" + C_O_FLAG_NONE="" + CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xchip=pentium" + CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz" + CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz" + CXX_O_FLAG_NONE="" + ;; + sparc) + CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s" + CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s" + CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl" + CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl" + C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" + C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0" + C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0" + C_O_FLAG_NONE="" + CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" + CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" + CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" + CXX_O_FLAG_NONE="" + ;; + esac + + CFLAGS_DEBUG_SYMBOLS="-g -xs" + CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs" + esac + ;; + CL ) + D_FLAG= + C_O_FLAG_HI="-O2" + C_O_FLAG_NORM="-O1" + C_O_FLAG_NONE="-Od" + CXX_O_FLAG_HI="$C_O_FLAG_HI" + CXX_O_FLAG_NORM="$C_O_FLAG_NORM" + CXX_O_FLAG_NONE="$C_O_FLAG_NONE" + ;; +esac + +if test -z "$C_O_FLAG_HIGHEST"; then + C_O_FLAG_HIGHEST="$C_O_FLAG_HI" +fi + +if test -z "$CXX_O_FLAG_HIGHEST"; then + CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HI" +fi + +AC_SUBST(C_O_FLAG_HIGHEST) +AC_SUBST(C_O_FLAG_HI) +AC_SUBST(C_O_FLAG_NORM) +AC_SUBST(C_O_FLAG_NONE) +AC_SUBST(CXX_O_FLAG_HIGHEST) +AC_SUBST(CXX_O_FLAG_HI) +AC_SUBST(CXX_O_FLAG_NORM) +AC_SUBST(CXX_O_FLAG_NONE) +AC_SUBST(C_FLAG_DEPS) +AC_SUBST(CXX_FLAG_DEPS) +]) + +AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_JDK], +[ + +if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then + AC_MSG_WARN([Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags"]) +fi + +if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then + AC_MSG_WARN([Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags"]) +fi + +if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then + AC_MSG_WARN([Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags"]) +fi + +AC_ARG_WITH(extra-cflags, [AS_HELP_STRING([--with-extra-cflags], + [extra flags to be used when compiling jdk c-files])]) + +AC_ARG_WITH(extra-cxxflags, [AS_HELP_STRING([--with-extra-cxxflags], + [extra flags to be used when compiling jdk c++-files])]) + +AC_ARG_WITH(extra-ldflags, [AS_HELP_STRING([--with-extra-ldflags], + [extra flags to be used when linking jdk])]) + +CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags" +CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags" +LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags" + +############################################################################### +# +# Now setup the CFLAGS and LDFLAGS for the JDK build. +# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build. +# +case $COMPILER_NAME in + gcc ) + CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -W -Wall -Wno-unused -Wno-parentheses \ + -pipe \ + -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE" + case $OPENJDK_TARGET_CPU_ARCH in + arm ) + # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing + CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" + ;; + ppc ) + # on ppc we don't prevent gcc to omit frame pointer nor strict-aliasing + ;; + * ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer" + CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" + ;; + esac + ;; + ossc ) + CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -norunpath -xnolib" + CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX" + ;; + cl ) + CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \ + -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \ + -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \ + -DWIN32 -DIAL" + case $LEGACY_OPENJDK_TARGET_CPU1 in + i?86 ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86" + ;; + amd64 ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64" + ;; + esac + ;; +esac + +############################################################################### +# +# Cross-compile arch specific flags + +# +if test "x$JDK_VARIANT" = "xembedded"; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DJAVASE_EMBEDDED" +fi + +case $OPENJDK_TARGET_CPU_ARCH in +arm ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fsigned-char" + ;; +ppc ) + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fsigned-char" + ;; +esac + +############################################################################### + +CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64" + +# The package path is used only on macosx? +PACKAGE_PATH=/opt/local +AC_SUBST(PACKAGE_PATH) + +# Sometimes we use a cpu dir (.../lib/amd64/server) +# Sometimes not (.../lib/server) +LIBARCHDIR="$LEGACY_OPENJDK_TARGET_CPU2/" +if test "x$ENDIAN" = xlittle; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN" +else + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN" +fi +if test "x$OPENJDK_TARGET_OS" = xlinux; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DLINUX" +fi +if test "x$OPENJDK_TARGET_OS" = xwindows; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DWINDOWS" +fi +if test "x$OPENJDK_TARGET_OS" = xsolaris; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DSOLARIS" +fi +if test "x$OPENJDK_TARGET_OS" = xmacosx; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMACOSX -D_ALLBSD_SOURCE" + LIBARCHDIR="" +fi +if test "x$OPENJDK_TARGET_OS" = xbsd; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DBSD -D_ALLBSD_SOURCE" +fi +if test "x$DEBUG_LEVEL" = xrelease; then + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG" +else + CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG" +fi + +CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$LEGACY_OPENJDK_TARGET_CPU1\"' -D$LEGACY_OPENJDK_TARGET_CPU1" +CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"$RELEASE\"'" + +CCXXFLAGS_JDK="$CCXXFLAGS_JDK \ + -I${JDK_OUTPUTDIR}/include \ + -I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \ + -I${JDK_TOPDIR}/src/share/javavm/export \ + -I${JDK_TOPDIR}/src/$LEGACY_OPENJDK_TARGET_OS_API/javavm/export \ + -I${JDK_TOPDIR}/src/share/native/common \ + -I${JDK_TOPDIR}/src/$LEGACY_OPENJDK_TARGET_OS_API/native/common" + +# The shared libraries are compiled using the picflag. +CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA" +CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA " + +# Executable flags +CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK" +CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK" + +# Now this is odd. The JDK native libraries have to link against libjvm.so +# On 32-bit machines there is normally two distinct libjvm.so:s, client and server. +# Which should we link to? Are we lucky enough that the binary api to the libjvm.so library +# is identical for client and server? Yes. Which is picked at runtime (client or server)? +# Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following +# libraries will link to whatever is in memory. Yuck. +# +# Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh. +if test "x$COMPILER_TYPE" = xCL; then + LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no" + if test "x$LEGACY_OPENJDK_TARGET_CPU1" = xi586; then + LDFLAGS_JDK="$LDFLAGS_JDK -safeseh" + fi + # TODO: make -debug optional "--disable-full-debug-symbols" + LDFLAGS_JDK="$LDFLAGS_JDK -debug" + LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib" + LDFLAGS_JDKLIB_SUFFIX="" + if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then + LDFLAGS_STACK_SIZE=1048576 + else + LDFLAGS_STACK_SIZE=327680 + fi + LDFLAGS_JDKEXE="${LDFLAGS_JDK} /STACK:$LDFLAGS_STACK_SIZE" +else + # If this is a --hash-style=gnu system, use --hash-style=both, why? + HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'` + if test -n "$HAS_GNU_HASH"; then + # And since we now know that the linker is gnu, then add -z defs, to forbid + # undefined symbols in object files. + LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both -Xlinker -z -Xlinker defs" + if test "x$DEBUG_LEVEL" == "xrelease"; then + # When building release libraries, tell the linker optimize them. + # Should this be supplied to the OSS linker as well? + LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1" + fi + fi + + LDFLAGS_JDKLIB="${LDFLAGS_JDK} $SHARED_LIBRARY_FLAGS \ + -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}server \ + -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}client \ + -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}" + LDFLAGS_JDKLIB_SUFFIX="-ljvm -ljava" + if test "x$COMPILER_NAME" = xossc; then + LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc" + fi + + # Only the jli library is explicitly linked when the launchers are built. + # The libjvm is then dynamically loaded/linked by the launcher. + LDFLAGS_JDKEXE="${LDFLAGS_JDK}" + if test "x$OPENJDK_TARGET_OS" != "xmacosx"; then + LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -L${JDK_OUTPUTDIR}/lib/${LIBARCHDIR}jli" + LDFLAGS_JDKEXE_SUFFIX="-ljli" + fi +fi + +# Adjust flags according to debug level. +case $DEBUG_LEVEL in + fastdebug ) + CFLAGS="$CFLAGS $D_FLAG" + JAVAC_FLAGS="$JAVAC_FLAGS -g" + ;; + slowdebug ) + CFLAGS="$CFLAGS $D_FLAG" + C_O_FLAG_HI="$C_O_FLAG_NONE" + C_O_FLAG_NORM="$C_O_FLAG_NONE" + CXX_O_FLAG_HI="$CXX_O_FLAG_NONE" + CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE" + JAVAC_FLAGS="$JAVAC_FLAGS -g" + ;; +esac + + +AC_SUBST(CFLAGS_JDKLIB) +AC_SUBST(CFLAGS_JDKEXE) + +AC_SUBST(CXXFLAGS_JDKLIB) +AC_SUBST(CXXFLAGS_JDKEXE) + +AC_SUBST(LDFLAGS_JDKLIB) +AC_SUBST(LDFLAGS_JDKEXE) +AC_SUBST(LDFLAGS_JDKLIB_SUFFIX) +AC_SUBST(LDFLAGS_JDKEXE_SUFFIX) +]) diff --git a/common/bin/compare-objects.sh b/common/bin/compare-objects.sh new file mode 100644 index 00000000000..ba01d5e4e93 --- /dev/null +++ b/common/bin/compare-objects.sh @@ -0,0 +1,235 @@ +#!/bin/bash +# +# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +# MANUAL +# +# ./common/bin/compare-objects.sh old_jdk_build_dir new_jdk_build_dir +# +# Compares object files +# + +if [ "x$1" = "x-h" ] || [ "x$1" = "x--help" ] || [ "x$1" == "x" ]; then + echo "bash ./common/bin/compare-build.sh old_jdk_build_dir new_jdk_build_dir" + echo "" + echo "Compare object files" + echo "" + exit 10 +fi + +####### +# +# List of files (grep patterns) that are ignored +# +# 1) hotspot object files +IGNORE="-e hotspot" + +# 2) various build artifacts: sizer.32.o sizer.64.o dummyodbc.o +# these are produced during build and then e.g run to produce other data +# i.e not directly put into build => safe to ignore +IGNORE="${IGNORE} -e sizer.32.o -e sizer.64.o" +IGNORE="${IGNORE} -e dummyodbc.o" +IGNORE="${IGNORE} -e genSolarisConstants.o" +IGNORE="${IGNORE} -e genUnixConstants.o" + +OLD="$1" +NEW="$2" +shift; shift +PATTERN="$*" + +if [ -f $NEW/spec.sh ]; then + . $NEW/spec.sh +elif [ -f $NEW/../../spec.sh ]; then + . $NEW/../../spec.sh +elif [ -f $OLD/spec.sh ]; then + . $OLD/spec.sh +elif [ -f $OLD/../../spec.sh ]; then + . $OLD/../../spec.sh +else + echo "Unable to find spec.sh" + echo "Giving up" + exit 1 +fi + +export COMPARE_ROOT=/tmp/cimages.$USER/objects +mkdir -p $COMPARE_ROOT + +(${CD} $OLD && ${FIND} . -name '*.o') > $COMPARE_ROOT/list.old +(${CD} $NEW && ${FIND} . -name '*.o') > $COMPARE_ROOT/list.new + +# On macosx JobjC is build in both i386 and x86_64 variant (universial binary) +# but new build only builds the x86_64 +# Remove the 386 variants from comparison...to avoid "false" positives +${GREP} -v 'JObjC.dst/Objects-normal/i386' $COMPARE_ROOT/list.old > $COMPARE_ROOT/list.old.new +${CP} $COMPARE_ROOT/list.old $COMPARE_ROOT/list.old.full +${CP} $COMPARE_ROOT/list.old.new $COMPARE_ROOT/list.old + +findnew() { + arg_1=$1 + arg_2=$2 + + # special case 1 unpack-cmd => unpackexe + arg_1=`${ECHO} $arg_1 | ${SED} 's!unpack-cmd!unpackexe!g'` + arg_2=`${ECHO} $arg_2 | ${SED} 's!unpack-cmd!unpackexe!g'` + + # special case 2 /JObjC.dst/ => /libjobjc/ + arg_1=`${ECHO} $arg_1 | ${SED} 's!/JObjC.dst/!/libjobjc/!g'` + arg_2=`${ECHO} $arg_2 | ${SED} 's!/JObjC.dst/!/libjobjc/!g'` + + full=`${ECHO} $arg_1 | ${SED} 's!\.!\\\.!g'` + medium=`${ECHO} $arg_1 | ${SED} 's!.*/\([^/]*/[^/]*\)!\1!'` + short=`${ECHO} $arg_2 | ${SED} 's!\.!\\\.!g'` + if [ "`${GREP} -c "/$full" $COMPARE_ROOT/list.new`" -eq 1 ] + then + ${ECHO} $NEW/$arg_1 + return + fi + + if [ "`${GREP} -c "$medium" $COMPARE_ROOT/list.new`" -eq 1 ] + then + ${GREP} "$medium" $COMPARE_ROOT/list.new + return + fi + + if [ "`${GREP} -c "/$short" $COMPARE_ROOT/list.new`" -eq 1 ] + then + ${GREP} "/$short" $COMPARE_ROOT/list.new + return + fi + + # old style has "dir" before obj{64} + dir=`${ECHO} $arg_1 | ${SED} 's!.*/\([^/]*\)/obj[64]*.*!\1!g'` + if [ -n "$dir" -a "$dir" != "$arg_1" ] + then + if [ "`${GREP} $dir $COMPARE_ROOT/list.new | ${GREP} -c "/$short"`" -eq 1 ] + then + ${GREP} $dir $COMPARE_ROOT/list.new | ${GREP} "/$short" + return + fi + + # Try with lib$dir/ + if [ "`${GREP} "lib$dir/" $COMPARE_ROOT/list.new | ${GREP} -c "/$short"`" -eq 1 ] + then + ${GREP} "lib$dir/" $COMPARE_ROOT/list.new | ${GREP} "/$short" + return + fi + + # Try with $dir_objs + if [ "`${GREP} "${dir}_objs" $COMPARE_ROOT/list.new | ${GREP} -c "/$short"`" -eq 1 ] + then + ${GREP} "${dir}_objs" $COMPARE_ROOT/list.new | ${GREP} "/$short" + return + fi + fi + + # check for some specifics... + for i in demo hotspot jobjc + do + if [ "`${ECHO} $full | ${GREP} -c $i`" -gt 0 ] + then + if [ "`${GREP} $i $COMPARE_ROOT/list.new | ${GREP} -c "/$short"`" -eq 1 ] + then + ${GREP} $i $COMPARE_ROOT/list.new | ${GREP} "/$short" + return + fi + fi + done + + # check for specific demo + demo=`${ECHO} $arg_1 | ${SED} 's!.*/demo/jvmti/\([^/]*\)/.*!\1!g'` + if [ -n "$demo" -a "$dir" != "$demo" ] + then + if [ "`${GREP} $demo $COMPARE_ROOT/list.new | ${GREP} -c "/$short"`" -eq 1 ] + then + ${GREP} $demo $COMPARE_ROOT/list.new | ${GREP} "/$short" + return + fi + fi + + return +} + +compare() { + old=$1 + new=$2 + ${DIFF} $old $new > /dev/null + res=$? + if [ $res -eq 0 ] + then + ${ECHO} 0 + return + fi + + # check if stripped objects gives equality + ${CP} $old $COMPARE_ROOT/`basename $old`.old + ${CP} $new $COMPARE_ROOT/`basename $old`.new + ${POST_STRIP_CMD} $COMPARE_ROOT/`basename $old`.old $COMPARE_ROOT/`basename $old`.new > /dev/null 2>&1 + ${DIFF} $COMPARE_ROOT/`basename $old`.old $COMPARE_ROOT/`basename $old`.new > /dev/null + res=$? + ${RM} $COMPARE_ROOT/`basename $old`.old $COMPARE_ROOT/`basename $old`.new + if [ $res -eq 0 ] + then + ${ECHO} S + return + fi + + name=`basename $1 | ${SED} 's!\.o!!'` + cntold=`strings $old | ${GREP} -c $name` + cntnew=`strings $new | ${GREP} -c $name` + + if [ $cntold -gt 0 -a $cntnew -gt 0 ] + then + ${ECHO} F + return + fi + + ${ECHO} 1 +} + +for F in `${CAT} $COMPARE_ROOT/list.old` +do + if [ "${IGNORE}" ] && [ "`${ECHO} $F | ${GREP} ${IGNORE}`" ] + then + # + # skip ignored files + # + continue; + fi + + if [ "$PATTERN" ] && [ `${ECHO} $F | ${GREP} -c $PATTERN` -eq 0 ] + then + continue; + fi + + f=`basename $F` + o=$OLD/$F + n=`findnew $F $f` + + if [ "$n" ] + then + n="$NEW/$n" + ${ECHO} `compare $o $n` : $f : $o : $n + else + ${ECHO} "- : $f : $o " + fi +done diff --git a/common/makefiles/IdlCompilation.gmk b/common/makefiles/IdlCompilation.gmk index 41758011ac9..799c7d6fbf9 100644 --- a/common/makefiles/IdlCompilation.gmk +++ b/common/makefiles/IdlCompilation.gmk @@ -56,10 +56,10 @@ define add_idl_package $4_OLDIMPLBASE_MSG:=with -oldImplBase endif $5 : $4 - mkdir -p $3/$$($4_TMPDIR) - rm -rf $3/$$($4_TMPDIR) - mkdir -p $(dir $5) - echo Compiling IDL $(patsubst $2/%,%,$4) + $(MKDIR) -p $3/$$($4_TMPDIR) + $(RM) -rf $3/$$($4_TMPDIR) + $(MKDIR) -p $(dir $5) + $(ECHO) Compiling IDL $(patsubst $2/%,%,$4) $8 -td $3/$$($4_TMPDIR) \ -i $2/org/omg/CORBA \ -i $2/org/omg/PortableInterceptor \ @@ -69,10 +69,10 @@ define add_idl_package $$($4_OLDIMPLBASE) \ $(PREFIXES) \ $4 - rm -f $$(addprefix $3/$$($4_TMPDIR)/,$6) - cp -rp $3/$$($4_TMPDIR)/* $3 - (cd $3/$$($4_TMPDIR); find . -type f | sed 's!\./!$3/!g' | awk '{ print $$$$1 ": $4" }' > $5) - rm -rf $3/$$($4_TMPDIR) + $(RM) -f $$(addprefix $3/$$($4_TMPDIR)/,$6) + $(CP) -rp $3/$$($4_TMPDIR)/* $3 + ($(CD) $3/$$($4_TMPDIR); find . -type f | sed 's!\./!$3/!g' | awk '{ print $$$$1 ": $4" }' > $5) + $(RM) -rf $3/$$($4_TMPDIR) endef define SetupIdlCompilation @@ -93,7 +93,7 @@ $(if $(10),$(error Internal makefile error: Too many arguments to SetupIdlCompil $1_SRC := $$(abspath $$($1_SRC)) $1_BIN := $$(abspath $$($1_BIN)) # Find all existing java files and existing class files. -$$(shell mkdir -p $$($1_SRC) $$($1_BIN)) +$$(shell $(MKDIR) -p $$($1_SRC) $$($1_BIN)) $1_SRCS := $$(shell find $$($1_SRC) -name "*.idl") $1_BINS := $$(shell find $$($1_BIN) -name "*.java") # Prepend the source/bin path to the filter expressions. diff --git a/common/makefiles/MakeHelpers.gmk b/common/makefiles/MakeHelpers.gmk new file mode 100644 index 00000000000..9747eb87ae6 --- /dev/null +++ b/common/makefiles/MakeHelpers.gmk @@ -0,0 +1,185 @@ +# +# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +################################################################ +# +# This file contains helper functions for the top-level Makefile that does +# not depend on the spec.gmk file having been read. (The purpose of this +# file is ju to avoid cluttering the top-level Makefile.) +# +################################################################ + +ifndef _MAKEHELPERS_GMK +_MAKEHELPERS_GMK := 1 + +############################## +# Stuff to run at include time +############################## + +# Find out which variables were passed explicitely on the make command line. These +# will be passed on to sub-makes, overriding spec.gmk settings. +MAKE_ARGS=$(foreach var,$(subst =command,,$(filter %=command,$(foreach var,$(.VARIABLES),$(var)=$(firstword $(origin $(var)))))),$(var)=$($(var))) + +list_alt_overrides_with_origins=$(filter ALT_%=environment ALT_%=command,$(foreach var,$(.VARIABLES),$(var)=$(firstword $(origin $(var))))) +list_alt_overrides=$(subst =command,,$(subst =environment,,$(list_alt_overrides_with_origins))) + +############################## +# Functions +############################## + +define fatal-error + # If the user specificed a "global" target (e.g. 'help'), do not exit but continue running + $$(if $$(findstring help,$$(MAKECMDGOALS)),,$$(error Cannot continue)) +endef + +define ParseLogLevel + ifeq ($$(origin VERBOSE),undefined) + # Setup logging according to LOG (but only if VERBOSE is not given) + ifeq ($$(LOG),) + # Set LOG to "warn" as default if not set (and no VERBOSE given) + LOG=warn + endif + ifeq ($$(LOG),warn) + VERBOSE=-s + else ifeq ($$(LOG),info) + VERBOSE= + else ifeq ($$(LOG),debug) + VERBOSE= + else ifeq ($$(LOG),trace) + VERBOSE=-d -p + else + $$(info Error: LOG must be one of: warn, info, debug or trace.) + $$(eval $$(call fatal-error)) + endif + else + ifneq ($$(LOG),) + # We have both a VERBOSE and a LOG argument. This is OK only if this is a repeated call by ourselves, + # but complain if this is the top-level make call. + ifeq ($$(MAKELEVEL),0) + $$(info Cannot use LOG=$$(LOG) and VERBOSE=$$(VERBOSE) at the same time. Choose one.) + $$(eval $$(call fatal-error)) + endif + endif + endif +endef + +# TODO: Fix duplication in MakeBase.gmk +define SetupLogging + ifneq ($(findstring $(LOG),debug trace),) + # Shell redefinition trick inspired by http://www.cmcrossroads.com/ask-mr-make/6535-tracing-rule-execution-in-gnu-make + OLD_SHELL:=$$(SHELL) + SHELL = $$(warning Building $$@$$(if $$<, (from $$<))$(if $$?, ($$? newer)))$$(OLD_SHELL) -x + endif +endef + +define ParseConfAndSpec + ifneq ($$(origin SPEC),undefined) + # We have been given a SPEC, check that it works out properly + ifeq ($$(wildcard $$(SPEC)),) + $$(info Cannot locate spec.gmk, given by SPEC=$$(SPEC)) + $$(eval $$(call fatal-error)) + endif + ifneq ($$(origin CONF),undefined) + # We also have a CONF argument. This is OK only if this is a repeated call by ourselves, + # but complain if this is the top-level make call. + ifeq ($$(MAKELEVEL),0) + $$(info Cannot use CONF=$$(CONF) and SPEC=$$(SPEC) at the same time. Choose one.) + $$(eval $$(call fatal-error)) + endif + endif + # ... OK, we're satisfied, we'll use this SPEC later on + else + # Find all spec.gmk files in the build output directory + output_dir=$$(root_dir)/build + all_spec_files=$$(wildcard $$(output_dir)/*/spec.gmk) + ifeq ($$(all_spec_files),) + $$(info No configurations found for $$(root_dir)! Please run configure to create a configuration.) + $$(eval $$(call fatal-error)) + endif + # Extract the configuration names from the path + all_confs=$$(patsubst %/spec.gmk,%,$$(patsubst $$(output_dir)/%,%,$$(all_spec_files))) + + ifneq ($$(origin CONF),undefined) + # User have given a CONF= argument. + ifeq ($$(CONF),) + # If given CONF=, match all configurations + matching_confs=$$(strip $$(all_confs)) + else + # Otherwise select those that contain the given CONF string + matching_confs=$$(strip $$(foreach var,$$(all_confs),$$(if $$(findstring $$(CONF),$$(var)),$$(var)))) + endif + ifeq ($$(matching_confs),) + $$(info No configurations found matching CONF=$$(CONF)) + $$(info Available configurations:) + $$(foreach var,$$(all_confs),$$(info * $$(var))) + $$(eval $$(call fatal-error)) + else + ifeq ($$(words $$(matching_confs)),1) + $$(info Building '$$(matching_confs)' (matching CONF=$$(CONF))) + else + $$(info Building the following configurations (matching CONF=$$(CONF)):) + $$(foreach var,$$(matching_confs),$$(info * $$(var))) + endif + endif + + # Create a SPEC definition. This will contain the path to one or more spec.gmk files. + SPEC=$$(addsuffix /spec.gmk,$$(addprefix $$(output_dir)/,$$(matching_confs))) + else + # No CONF or SPEC given, check the available configurations + ifneq ($$(words $$(all_spec_files)),1) + $$(info No CONF or SPEC given, but more than one spec.gmk found in $$(output_dir).) + $$(info Available configurations:) + $$(foreach var,$$(all_confs),$$(info * $$(var))) + $$(info Please retry building with CONF= or SPEC=) + $$(eval $$(call fatal-error)) + endif + + # We found exactly one configuration, use it + SPEC=$$(strip $$(all_spec_files)) + endif + endif +endef + +define CheckEnvironment + # Find all environment or command line variables that begin with ALT. + $(if $(list_alt_overrides), + @$(PRINTF) "\nWARNING: You have the following ALT_ variables set:\n" + @$(PRINTF) "$(foreach var,$(list_alt_overrides),$(var)=$$$(var))\n" + @$(PRINTF) "ALT_ variables are deprecated and will be ignored. Please clean your environment.\n\n" + ) +endef + +define PrintStartMessage + $(if $(VERBOSE),,@$(ECHO) Running make as $(MAKE) $(MFLAGS) $(MAKE_ARGS)) + $(call CheckEnvironment) + @$(ECHO) "Building OpenJDK for target $(if $(MAKECMDGOALS),'$(MAKECMDGOALS)','all') in configuration '$(CONF_NAME)'" +endef + +define PrintEndMessage + @$(ECHO) "Finished building OpenJDK for target '$@'" + $(call CheckEnvironment) +endef + +endif # _MAKEHELPERS_GMK diff --git a/common/makefiles/NativeCompilation.gmk b/common/makefiles/NativeCompilation.gmk index d259459cf8f..6818a501226 100644 --- a/common/makefiles/NativeCompilation.gmk +++ b/common/makefiles/NativeCompilation.gmk @@ -451,13 +451,14 @@ define SetupNativeCompilation $(RM) $$@ $(FIX_EMPTY_SEC_HDR_FLAGS) $$< $(OBJCOPY) --only-keep-debug $$< $$@ - $(ADD_GNU_DEBUGLINK) $$@ $$< + $(CD) $$(@D) && $(ADD_GNU_DEBUGLINK) $$(@F) $$< else # not solaris $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo : $$($1_TARGET) $(RM) $$@ $(OBJCOPY) --only-keep-debug $$< $$@ - $(OBJCOPY) --add-gnu-debuglink=$$@ $$< - endif + $(CD) $$(@D) && $(OBJCOPY) --add-gnu-debuglink=$$(@F) $$< + endif # Touch to not retrigger rule on rebuild + $(TOUCH) $$@ ifeq ($(ZIP_DEBUGINFO_FILES), 1) $1 += $$($1_OUTPUT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).diz @@ -526,13 +527,14 @@ define SetupNativeCompilation $(RM) $$@ $(FIX_EMPTY_SEC_HDR_FLAGS) $$< $(OBJCOPY) --only-keep-debug $$< $$@ - $(ADD_GNU_DEBUGLINK) $$@ $$< + $(CD) $$(@D) && $(ADD_GNU_DEBUGLINK) $$(@F) $$< else # not solaris $$($1_OBJECT_DIR)/$$($1_PROGRAM).debuginfo : $$($1_TARGET) $(RM) $$@ $(OBJCOPY) --only-keep-debug $$< $$@ - $(OBJCOPY) --add-gnu-debuglink=$$@ $$< + $(CD) $$(@D) && $(OBJCOPY) --add-gnu-debuglink=$$(@F) $$< endif + $(TOUCH) $$@ ifeq ($(ZIP_DEBUGINFO_FILES), 1) $1 += $$($1_OUTPUT_DIR)/$$($1_PROGRAM).diz diff --git a/common/makefiles/RMICompilation.gmk b/common/makefiles/RMICompilation.gmk new file mode 100644 index 00000000000..65ba9e621f9 --- /dev/null +++ b/common/makefiles/RMICompilation.gmk @@ -0,0 +1,104 @@ +# +# Copyright (c) 2011, 2012 Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +define SetupRMICompilation + # param 1 is a name for a variable to depend on. + # param 2 and up are named args. + # CLASSES:=List of classes to generate stubs for + # CLASSES_DIR:=Directory where to look for classes + # STUB_CLASSES_DIR:=Directory in where to put stub classes + # RUN_V11:=Set to run rmic with -v1.1 + # RUN_V12:=Set to run rmic with -v1.2 + # RUN_IIOP:=Set to run rmic with -iiop + # RUN_IIOP_STDPKG:=Set to run rmic with -iiop -standardPackage + # KEEP_GENERATED:=Set to keep generated sources around + $(if $2,$1_$(strip $2)) + $(if $3,$1_$(strip $3)) + $(if $4,$1_$(strip $4)) + $(if $5,$1_$(strip $5)) + $(if $6,$1_$(strip $6)) + $(if $7,$1_$(strip $7)) + $(if $8,$1_$(strip $8)) + $(if $9,$1_$(strip $9)) + $(if $(10),$(error Internal makefile error: Too many arguments to SetupRMICompilation, please update RMICompilation.gmk)) + + + $1_DEP_FILE := $$($1_STUB_CLASSES_DIR)/$1_rmic + + $1_CLASSES_SLASH := $$(subst .,/,$$($1_CLASSES)) + $1_CLASS_FILES := $$(addprefix $$($1_CLASSES_DIR)/,$$(addsuffix .class,$$($1_CLASSES_SLASH))) + $1_STUB_FILES := $$(addprefix $$($1_STUB_CLASSES_DIR)/,$$(addsuffix _Stub.class,$$($1_CLASSES_SLASH))) + $1_TARGETS := $$($1_STUB_FILES) + $1_ARGS := + ifneq (,$$($1_RUN_V11)) + $1_SKEL_FILES := $$(addprefix $$($1_STUB_CLASSES_DIR)/,$$(addsuffix _Skel.class,$$($1_CLASSES_SLASH))) + $1_TARGETS += $$($1_SKEL_FILES) + $1_ARGS += -v1.1 + endif + ifneq (,$$($1_RUN_V12)) + $1_ARGS += -v1.2 + endif + + $1_TIE_BASE_FILES := $$(foreach f,$$($1_CLASSES_SLASH),$$(dir $$f)_$$(notdir $$f)) + $1_TIE_FILES := $$(addprefix $$($1_STUB_CLASSES_DIR)/org/omg/stub/,$$(addsuffix _Tie.class,$$($1_TIE_BASE_FILES))) + $1_TIE_STDPKG_FILES := $$(addprefix $$($1_STUB_CLASSES_DIR)/,$$(addsuffix _Tie.class,$$($1_TIE_BASE_FILES))) + + ifneq (,$$($1_RUN_IIOP)) + $1_TARGETS += $$($1_TIE_FILES) + $1_ARGS += -iiop + endif + ifneq (,$$($1_RUN_IIOP_STDPKG)) + $1_TARGETS += $$($1_TIE_STDPKG_FILES) + $1_ARGS2 := -iiop -standardPackage + endif + + ifneq (,$$($1_KEEP_GENERATED)) + $1_ARGS += -keepgenerated + $1_TARGETS += $$(subst .class,.java,$$($1_TARGETS)) + endif + + $1_DOLLAR_SAFE_CLASSES := $$(subst $$$$,\$$$$,$$($1_CLASSES)) + + $$($1_TARGETS): $$($1_DEP_FILE) $$($1_CLASS_FILES) + + $$($1_DEP_FILE): $$($1_CLASS_FILES) + $(MKDIR) -p $$($1_STUB_CLASSES_DIR) + if [ "x$$($1_ARGS)" != "x" ]; then \ + $(ECHO) Running rmic $$($1_ARGS) for $$($1_DOLLAR_SAFE_CLASSES) &&\ + $(RMIC) $$($1_ARGS) -classpath "$$($1_CLASSES_DIR)" \ + -d $$($1_STUB_CLASSES_DIR) $$($1_DOLLAR_SAFE_CLASSES);\ + fi; + if [ "x$$($1_ARGS2)" != "x" ]; then \ + $(ECHO) Running rmic $$($1_ARGS2) for $$($1_DOLLAR_SAFE_CLASSES) &&\ + $(RMIC) $$($1_ARGS2) -classpath "$$($1_CLASSES_DIR)" \ + -d $$($1_STUB_CLASSES_DIR) $$($1_DOLLAR_SAFE_CLASSES);\ + fi; + + + $1 := $$($1_TARGETS) + + # By marking as secondary, this "touch" file doesn't need to be touched and will never exist. + .SECONDARY: $$($1_DEP_FILE) +endef From 0bf6babbb7ef31915687068b089b0749f76889a2 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 5 Jul 2012 18:43:57 -0700 Subject: [PATCH 067/160] Added tag jdk8-b46 for changeset 8e117f8b08eb --- .hgtags-top-repo | 1 + 1 file changed, 1 insertion(+) diff --git a/.hgtags-top-repo b/.hgtags-top-repo index dc560c35729..8725f6d1dc1 100644 --- a/.hgtags-top-repo +++ b/.hgtags-top-repo @@ -167,3 +167,4 @@ a2b2d435f1d275fa8010774c653197c64e326d3a jdk8-b40 661c9aae602bbd9766d12590800c90f1edd1d8dd jdk8-b43 e4f81a817447c3a4f6868f083c81c2fb1b15d44c jdk8-b44 633f2378c904c92bb922a6e19e9f62fe8eac14af jdk8-b45 +27fa766a2298ba8347dc198f0cf85ba6618e17db jdk8-b46 From a18ea33408837f4187df54b3ec7b5798aa85d521 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 5 Jul 2012 18:44:04 -0700 Subject: [PATCH 068/160] Added tag jdk8-b46 for changeset 3b78e26c0c38 --- corba/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/corba/.hgtags b/corba/.hgtags index d145e022f27..796079e90ac 100644 --- a/corba/.hgtags +++ b/corba/.hgtags @@ -167,3 +167,4 @@ b8cbfb31139f820e5e094ba71449e58159fbe22e jdk8-b38 cd879aff5d3cc1f58829aab3116880aa19525b78 jdk8-b43 439d9bf8e4ff204cc89c9974c1515a508b2cc6ff jdk8-b44 747dad9e9d37d244a5c765a1afe9194f7ddae118 jdk8-b45 +30141e598d72a6146126cb86b034ed6d0bd191b3 jdk8-b46 From 21a3abc4d4240983593ace71dab613b672697ff6 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 5 Jul 2012 18:44:09 -0700 Subject: [PATCH 069/160] Added tag jdk8-b46 for changeset 7604568cf818 --- hotspot/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/hotspot/.hgtags b/hotspot/.hgtags index 8ab00c4f0be..d850f6b9e1c 100644 --- a/hotspot/.hgtags +++ b/hotspot/.hgtags @@ -258,3 +258,4 @@ e77b8e0ed1f84e3e268239e276c7ab64fa573baa jdk8-b43 831e5c76a20af18f3c08c5a95ed31be0e128a010 jdk8-b44 9d5f20961bc5846fa8d098d534effafbbdae0a58 jdk8-b45 40e5a3f2907ed02b335c7caa8ecf068cc801380d hs24-b15 +cf37a594c38db2ea926954154636f9f81da2e032 jdk8-b46 From cb0f1fed69020603613d4d6e843d2e174ae49098 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 5 Jul 2012 18:44:22 -0700 Subject: [PATCH 070/160] Added tag jdk8-b46 for changeset b5166f281c42 --- jaxp/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/jaxp/.hgtags b/jaxp/.hgtags index 93f3d6587f1..a131128f979 100644 --- a/jaxp/.hgtags +++ b/jaxp/.hgtags @@ -167,3 +167,4 @@ f95fdbe525c88ef0d57dc1390be6582a8af5e07c jdk8-b39 eff4ece9c8bc43b3ce2b3758574c4c20147f0689 jdk8-b43 0b3f3a4ce13930430b32b616a717dfc7fe385b28 jdk8-b44 57476f66e13c55eea2f2fe2b858369a4c64b9936 jdk8-b45 +300f45e990643af230d6cca39477ff62c44a9a54 jdk8-b46 From b769ce017f063a25b0031e0300e64dce0fe506a2 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 5 Jul 2012 18:44:26 -0700 Subject: [PATCH 071/160] Added tag jdk8-b46 for changeset a454fca4fd87 --- jaxws/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/jaxws/.hgtags b/jaxws/.hgtags index 0e5917c7e71..b4afc8cdd27 100644 --- a/jaxws/.hgtags +++ b/jaxws/.hgtags @@ -167,3 +167,4 @@ f2072b164b0519227833a2994f78e3988ee67827 jdk8-b41 f00c12994562c2f68d348a7c3e829374a89294e2 jdk8-b43 f6a417540ef124c9b4123d07da5e26f2ab909949 jdk8-b44 e80ac58b5ba904f24e125c742c30d0d740f05f86 jdk8-b45 +ae368a83c2404b65c9e38c65e2aa081f2201ca74 jdk8-b46 From c7a1cb0da06969ead26218f7ba02dd446af37b8d Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 5 Jul 2012 18:44:32 -0700 Subject: [PATCH 072/160] Added tag jdk8-b46 for changeset c35f7a2acbec --- jdk/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/jdk/.hgtags b/jdk/.hgtags index ebc63ad4733..ed858014f63 100644 --- a/jdk/.hgtags +++ b/jdk/.hgtags @@ -167,3 +167,4 @@ cf5c1f6fbc5ba14163fe0ef8eb8601b33f951372 jdk8-b42 b3246687c3695dff6f461bb407f9db88f7d072e7 jdk8-b43 db471a7af03168e4441c245b1d9976f720a7cb77 jdk8-b44 b92353a01aa049bc508fc56f0347d5934b7c4390 jdk8-b45 +8d2ed9d58453c8049715a72a6d26b6b66b37a94c jdk8-b46 From e6c547e0262f8487bd246bfd940d51cc9ab6f982 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 5 Jul 2012 18:44:44 -0700 Subject: [PATCH 073/160] Added tag jdk8-b46 for changeset b7b7fb648bf6 --- langtools/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/langtools/.hgtags b/langtools/.hgtags index 383d61393a4..13843bea9da 100644 --- a/langtools/.hgtags +++ b/langtools/.hgtags @@ -167,3 +167,4 @@ a9f547c218d957306dfc0cdd710be041bb62a555 jdk8-b39 f8c64d835b2806293b8e924b44f0e32b20657ed3 jdk8-b43 59cbead12ff46dbb397120bd26635bcd7d41ff21 jdk8-b44 e111e4587ccada8eb93f72e834e378c76256f4b7 jdk8-b45 +4ca5994971724731233735f055f33d4936fd11d3 jdk8-b46 From e83a16fa42150b6a26d49d9709c5a43f75238f8c Mon Sep 17 00:00:00 2001 From: Sean Chou Date: Fri, 6 Jul 2012 10:36:19 +0800 Subject: [PATCH 074/160] 7181353: Update error message to distinguish native OOM and java OOM in net Reviewed-by: chegar --- jdk/src/solaris/native/java/net/Inet4AddressImpl.c | 4 ++-- jdk/src/solaris/native/java/net/Inet6AddressImpl.c | 2 +- jdk/src/solaris/native/java/net/NetworkInterface.c | 2 +- jdk/src/solaris/native/java/net/PlainDatagramSocketImpl.c | 6 +++--- .../native/java/net/DualStackPlainDatagramSocketImpl.c | 4 ++-- jdk/src/windows/native/java/net/Inet6AddressImpl.c | 2 +- jdk/src/windows/native/java/net/NetworkInterface.c | 4 ++-- .../native/java/net/TwoStacksPlainDatagramSocketImpl.c | 8 ++++---- 8 files changed, 16 insertions(+), 16 deletions(-) diff --git a/jdk/src/solaris/native/java/net/Inet4AddressImpl.c b/jdk/src/solaris/native/java/net/Inet4AddressImpl.c index a6f7ddc1a00..84f739ed50e 100644 --- a/jdk/src/solaris/native/java/net/Inet4AddressImpl.c +++ b/jdk/src/solaris/native/java/net/Inet4AddressImpl.c @@ -196,7 +196,7 @@ Java_java_net_Inet4AddressImpl_lookupAllHostAddr(JNIEnv *env, jobject this, struct addrinfo *next = (struct addrinfo*) malloc(sizeof(struct addrinfo)); if (!next) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); ret = NULL; goto cleanupAndReturn; } @@ -465,7 +465,7 @@ Java_java_net_Inet4AddressImpl_lookupAllHostAddr(JNIEnv *env, jobject this, struct addrinfo *next = (struct addrinfo*) malloc(sizeof(struct addrinfo)); if (!next) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); ret = NULL; goto cleanupAndReturn; } diff --git a/jdk/src/solaris/native/java/net/Inet6AddressImpl.c b/jdk/src/solaris/native/java/net/Inet6AddressImpl.c index 63addd9fb70..17be097e9e3 100644 --- a/jdk/src/solaris/native/java/net/Inet6AddressImpl.c +++ b/jdk/src/solaris/native/java/net/Inet6AddressImpl.c @@ -267,7 +267,7 @@ Java_java_net_Inet6AddressImpl_lookupAllHostAddr(JNIEnv *env, jobject this, struct addrinfo *next = (struct addrinfo*) malloc(sizeof(struct addrinfo)); if (!next) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); ret = NULL; goto cleanupAndReturn; } diff --git a/jdk/src/solaris/native/java/net/NetworkInterface.c b/jdk/src/solaris/native/java/net/NetworkInterface.c index b952626cb82..69780f7bc16 100644 --- a/jdk/src/solaris/native/java/net/NetworkInterface.c +++ b/jdk/src/solaris/native/java/net/NetworkInterface.c @@ -804,7 +804,7 @@ static netif *enumInterfaces(JNIEnv *env) { do{ \ _pointer = (_type)malloc( _size ); \ if (_pointer == NULL) { \ - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); \ + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); \ return ifs; /* return untouched list */ \ } \ } while(0) diff --git a/jdk/src/solaris/native/java/net/PlainDatagramSocketImpl.c b/jdk/src/solaris/native/java/net/PlainDatagramSocketImpl.c index 382ec4c83bc..a508d43e0cc 100644 --- a/jdk/src/solaris/native/java/net/PlainDatagramSocketImpl.c +++ b/jdk/src/solaris/native/java/net/PlainDatagramSocketImpl.c @@ -485,7 +485,7 @@ Java_java_net_PlainDatagramSocketImpl_send(JNIEnv *env, jobject this, fullPacket = (char *)malloc(packetBufferLen); if (!fullPacket) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Send buffer native heap allocation failed"); return; } else { mallocedPacket = JNI_TRUE; @@ -714,7 +714,7 @@ Java_java_net_PlainDatagramSocketImpl_peekData(JNIEnv *env, jobject this, fullPacket = (char *)malloc(packetBufferLen); if (!fullPacket) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Peek buffer native heap allocation failed"); return -1; } else { mallocedPacket = JNI_TRUE; @@ -874,7 +874,7 @@ Java_java_net_PlainDatagramSocketImpl_receive0(JNIEnv *env, jobject this, fullPacket = (char *)malloc(packetBufferLen); if (!fullPacket) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Receive buffer native heap allocation failed"); return; } else { mallocedPacket = JNI_TRUE; diff --git a/jdk/src/windows/native/java/net/DualStackPlainDatagramSocketImpl.c b/jdk/src/windows/native/java/net/DualStackPlainDatagramSocketImpl.c index 6521e1e5f42..0077c37aaa2 100644 --- a/jdk/src/windows/native/java/net/DualStackPlainDatagramSocketImpl.c +++ b/jdk/src/windows/native/java/net/DualStackPlainDatagramSocketImpl.c @@ -265,7 +265,7 @@ JNIEXPORT jint JNICALL Java_java_net_DualStackPlainDatagramSocketImpl_socketRece } fullPacket = (char *)malloc(packetBufferLen); if (!fullPacket) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); return -1; } } else { @@ -427,7 +427,7 @@ JNIEXPORT void JNICALL Java_java_net_DualStackPlainDatagramSocketImpl_socketSend } fullPacket = (char *)malloc(length); if (!fullPacket) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); return; } } else { diff --git a/jdk/src/windows/native/java/net/Inet6AddressImpl.c b/jdk/src/windows/native/java/net/Inet6AddressImpl.c index efdcd54662b..b98b6411b01 100644 --- a/jdk/src/windows/native/java/net/Inet6AddressImpl.c +++ b/jdk/src/windows/native/java/net/Inet6AddressImpl.c @@ -197,7 +197,7 @@ Java_java_net_Inet6AddressImpl_lookupAllHostAddr(JNIEnv *env, jobject this, struct addrinfo *next = (struct addrinfo*) malloc(sizeof(struct addrinfo)); if (!next) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); ret = NULL; goto cleanupAndReturn; } diff --git a/jdk/src/windows/native/java/net/NetworkInterface.c b/jdk/src/windows/native/java/net/NetworkInterface.c index 8dbeb925029..570eac30812 100644 --- a/jdk/src/windows/native/java/net/NetworkInterface.c +++ b/jdk/src/windows/native/java/net/NetworkInterface.c @@ -270,7 +270,7 @@ int enumInterfaces(JNIEnv *env, netif **netifPP) } } if (curr == NULL) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failure"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failure"); free_netif(netifP); free(tableP); return -1; @@ -370,7 +370,7 @@ int enumAddresses_win(JNIEnv *env, netif *netifP, netaddr **netaddrPP) netaddr *curr = (netaddr *)malloc(sizeof(netaddr)); if (curr == NULL) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failure"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failure"); free_netaddr(netaddrP); free(tableP); return -1; diff --git a/jdk/src/windows/native/java/net/TwoStacksPlainDatagramSocketImpl.c b/jdk/src/windows/native/java/net/TwoStacksPlainDatagramSocketImpl.c index 161017754ca..dc6fdf41c47 100644 --- a/jdk/src/windows/native/java/net/TwoStacksPlainDatagramSocketImpl.c +++ b/jdk/src/windows/native/java/net/TwoStacksPlainDatagramSocketImpl.c @@ -243,7 +243,7 @@ jboolean exceedSizeLimit(JNIEnv *env, jint fd, jint addr, jint size) addrList = curr; } LeaveCriticalSection(&sizeCheckLock); - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); return JNI_TRUE; } curr->addr = htonl((*addrp)->S_un.S_addr); @@ -740,7 +740,7 @@ Java_java_net_TwoStacksPlainDatagramSocketImpl_send(JNIEnv *env, jobject this, */ fullPacket = (char *)malloc(packetBufferLen); if (!fullPacket) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Send buf native heap allocation failed"); return; } } else { @@ -1003,7 +1003,7 @@ Java_java_net_TwoStacksPlainDatagramSocketImpl_peekData(JNIEnv *env, jobject thi */ fullPacket = (char *)malloc(packetBufferLen); if (!fullPacket) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); return -1; } } else { @@ -1287,7 +1287,7 @@ Java_java_net_TwoStacksPlainDatagramSocketImpl_receive0(JNIEnv *env, jobject thi */ fullPacket = (char *)malloc(packetBufferLen); if (!fullPacket) { - JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); + JNU_ThrowOutOfMemoryError(env, "Receive buf native heap allocation failed"); return; } } else { From d91b2b6f6ef54557eaa5fa735c80fce2f031c41c Mon Sep 17 00:00:00 2001 From: Anthony Petrov Date: Fri, 6 Jul 2012 14:20:27 +0400 Subject: [PATCH 075/160] 7177173: [macosx] JFrame.setExtendedState(JFrame.MAXIMIZED_BOTH) not working as expected in JDK 7 Avoid unnecessary changes to the extended state Reviewed-by: art, serb --- .../sun/lwawt/macosx/CPlatformWindow.java | 97 ++++++++++--------- .../Frame/HideMaximized/HideMaximized.java | 70 +++++++++++++ 2 files changed, 122 insertions(+), 45 deletions(-) create mode 100644 jdk/test/java/awt/Frame/HideMaximized/HideMaximized.java diff --git a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java index 46fece1de63..b2f0d832999 100644 --- a/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java +++ b/jdk/src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java @@ -209,6 +209,7 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo private boolean undecorated; // initialized in getInitialStyleBits() private Rectangle normalBounds = null; // not-null only for undecorated maximized windows private CPlatformResponder responder; + private volatile boolean zoomed = false; // from native perspective public CPlatformWindow(final PeerType peerType) { super(0, true); @@ -469,26 +470,42 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo nativeSetNSWindowBounds(getNSWindowPtr(), x, y, w, h); } - private void zoom() { + private boolean isMaximized() { + return undecorated ? this.normalBounds != null : zoomed; + } + + private void maximize() { + if (isMaximized()) { + return; + } if (!undecorated) { + zoomed = true; CWrapper.NSWindow.zoom(getNSWindowPtr()); } else { - // OS X handles -zoom incorrectly for undecorated windows - final boolean isZoomed = this.normalBounds == null; - deliverZoom(isZoomed); + deliverZoom(true); - Rectangle toBounds; - if (isZoomed) { - this.normalBounds = peer.getBounds(); - long screen = CWrapper.NSWindow.screen(getNSWindowPtr()); - toBounds = CWrapper.NSScreen.visibleFrame(screen).getBounds(); - // Flip the y coordinate - Rectangle frame = CWrapper.NSScreen.frame(screen).getBounds(); - toBounds.y = frame.height - toBounds.y - toBounds.height; - } else { - toBounds = normalBounds; - this.normalBounds = null; - } + this.normalBounds = peer.getBounds(); + long screen = CWrapper.NSWindow.screen(getNSWindowPtr()); + Rectangle toBounds = CWrapper.NSScreen.visibleFrame(screen).getBounds(); + // Flip the y coordinate + Rectangle frame = CWrapper.NSScreen.frame(screen).getBounds(); + toBounds.y = frame.height - toBounds.y - toBounds.height; + setBounds(toBounds.x, toBounds.y, toBounds.width, toBounds.height); + } + } + + private void unmaximize() { + if (!isMaximized()) { + return; + } + if (!undecorated) { + zoomed = false; + CWrapper.NSWindow.zoom(getNSWindowPtr()); + } else { + deliverZoom(false); + + Rectangle toBounds = this.normalBounds; + this.normalBounds = null; setBounds(toBounds.x, toBounds.y, toBounds.width, toBounds.height); } } @@ -501,9 +518,9 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo public void setVisible(boolean visible) { final long nsWindowPtr = getNSWindowPtr(); - // 1. Process parent-child relationship when hiding + // Process parent-child relationship when hiding if (!visible) { - // 1a. Unparent my children + // Unparent my children for (Window w : target.getOwnedWindows()) { WindowPeer p = (WindowPeer)w.getPeer(); if (p instanceof LWWindowPeer) { @@ -514,30 +531,17 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo } } - // 1b. Unparent myself + // Unparent myself if (owner != null && owner.isVisible()) { CWrapper.NSWindow.removeChildWindow(owner.getNSWindowPtr(), nsWindowPtr); } } - // 2. Configure stuff + // Configure stuff updateIconImages(); updateFocusabilityForAutoRequestFocus(false); - // 3. Manage the extended state when hiding - if (!visible) { - // Cancel out the current native state of the window - switch (peer.getState()) { - case Frame.ICONIFIED: - CWrapper.NSWindow.deminiaturize(nsWindowPtr); - break; - case Frame.MAXIMIZED_BOTH: - zoom(); - break; - } - } - - // 4. Actually show or hide the window + // Actually show or hide the window LWWindowPeer blocker = peer.getBlocker(); if (blocker == null || !visible) { // If it ain't blocked, or is being hidden, go regular way @@ -566,16 +570,19 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo } this.visible = visible; - // 5. Manage the extended state when showing + // Manage the extended state when showing if (visible) { - // Re-apply the extended state as expected in shared code + // Apply the extended state as expected in shared code if (target instanceof Frame) { switch (((Frame)target).getExtendedState()) { case Frame.ICONIFIED: CWrapper.NSWindow.miniaturize(nsWindowPtr); break; case Frame.MAXIMIZED_BOTH: - zoom(); + maximize(); + break; + default: // NORMAL + unmaximize(); // in case it was maximized, otherwise this is a no-op break; } } @@ -583,12 +590,12 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo nativeSynthesizeMouseEnteredExitedEvents(nsWindowPtr); - // 6. Configure stuff #2 + // Configure stuff #2 updateFocusabilityForAutoRequestFocus(true); - // 7. Manage parent-child relationship when showing + // Manage parent-child relationship when showing if (visible) { - // 7a. Add myself as a child + // Add myself as a child if (owner != null && owner.isVisible()) { CWrapper.NSWindow.addChildWindow(owner.getNSWindowPtr(), nsWindowPtr, CWrapper.NSWindow.NSWindowAbove); if (target.isAlwaysOnTop()) { @@ -596,7 +603,7 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo } } - // 7b. Add my own children to myself + // Add my own children to myself for (Window w : target.getOwnedWindows()) { WindowPeer p = (WindowPeer)w.getPeer(); if (p instanceof LWWindowPeer) { @@ -611,7 +618,7 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo } } - // 8. Deal with the blocker of the window being shown + // Deal with the blocker of the window being shown if (blocker != null && visible) { // Make sure the blocker is above its siblings ((CPlatformWindow)blocker.getPlatformWindow()).orderAboveSiblings(); @@ -778,7 +785,7 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo if (prevWindowState == Frame.MAXIMIZED_BOTH) { // let's return into the normal states first // the zoom call toggles between the normal and the max states - zoom(); + unmaximize(); } CWrapper.NSWindow.miniaturize(nsWindowPtr); break; @@ -787,14 +794,14 @@ public class CPlatformWindow extends CFRetainedResource implements PlatformWindo // let's return into the normal states first CWrapper.NSWindow.deminiaturize(nsWindowPtr); } - zoom(); + maximize(); break; case Frame.NORMAL: if (prevWindowState == Frame.ICONIFIED) { CWrapper.NSWindow.deminiaturize(nsWindowPtr); } else if (prevWindowState == Frame.MAXIMIZED_BOTH) { // the zoom call toggles between the normal and the max states - zoom(); + unmaximize(); } break; default: diff --git a/jdk/test/java/awt/Frame/HideMaximized/HideMaximized.java b/jdk/test/java/awt/Frame/HideMaximized/HideMaximized.java new file mode 100644 index 00000000000..9e64b2d97f5 --- /dev/null +++ b/jdk/test/java/awt/Frame/HideMaximized/HideMaximized.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + @test + @bug 7177173 + @summary The maximized state shouldn't be reset upon hiding a frame + @author anthony.petrov@oracle.com: area=awt.toplevel + @run main HideMaximized +*/ + +import java.awt.*; + +public class HideMaximized { + public static void main(String[] args) { + if (!Toolkit.getDefaultToolkit().isFrameStateSupported(Frame.MAXIMIZED_BOTH)) { + // Nothing to test + return; + } + + // First test a decorated frame + Frame frame = new Frame("test"); + test(frame); + + // Now test an undecorated frames + frame = new Frame("undecorated test"); + frame.setUndecorated(true); + test(frame); + } + + private static void test(Frame frame) { + frame.setExtendedState(Frame.MAXIMIZED_BOTH); + frame.setVisible(true); + + try { Thread.sleep(1000); } catch (Exception ex) {} + + if (frame.getExtendedState() != Frame.MAXIMIZED_BOTH) { + throw new RuntimeException("The maximized state has not been applied"); + } + + // This will hide the frame, and also clean things up for safe exiting + frame.dispose(); + + try { Thread.sleep(1000); } catch (Exception ex) {} + + if (frame.getExtendedState() != Frame.MAXIMIZED_BOTH) { + throw new RuntimeException("The maximized state has been reset"); + } + } +} From 13c689d9c3f87741d5adf57c319d0a43953dd556 Mon Sep 17 00:00:00 2001 From: Frederic Parain Date: Mon, 9 Jul 2012 01:28:37 -0700 Subject: [PATCH 076/160] 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K Reviewed-by: sspitsyn, dholmes, coleenp, kamg --- .../jvm/hotspot/jdi/ReferenceTypeImpl.java | 5 +- .../sun/jvm/hotspot/oops/InstanceKlass.java | 2 +- .../share/vm/classfile/classFileParser.cpp | 7 +- hotspot/src/share/vm/oops/instanceKlass.cpp | 23 ++- hotspot/src/share/vm/oops/instanceKlass.hpp | 8 +- .../src/share/vm/oops/instanceKlassKlass.cpp | 5 +- .../vm/prims/jvmtiClassFileReconstituter.cpp | 10 +- hotspot/src/share/vm/prims/jvmtiEnv.cpp | 13 +- .../share/vm/prims/jvmtiRedefineClasses.cpp | 6 +- hotspot/src/share/vm/runtime/vmStructs.cpp | 2 +- .../runtime/6294277/SourceDebugExtension.java | 135 ++++++++++++++++++ hotspot/test/runtime/6294277/Test6294277.sh | 92 ++++++++++++ 12 files changed, 273 insertions(+), 35 deletions(-) create mode 100644 hotspot/test/runtime/6294277/SourceDebugExtension.java create mode 100644 hotspot/test/runtime/6294277/Test6294277.sh diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/jdi/ReferenceTypeImpl.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/jdi/ReferenceTypeImpl.java index d28bca18d2e..662f18e089e 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/jdi/ReferenceTypeImpl.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/jdi/ReferenceTypeImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -688,8 +688,7 @@ implements ReferenceType { if (sde == null) { String extension = null; if (saKlass instanceof InstanceKlass) { - Symbol sdeSym = ((InstanceKlass)saKlass).getSourceDebugExtension(); - extension = (sdeSym != null)? sdeSym.asString() : null; + extension = ((InstanceKlass)saKlass).getSourceDebugExtension(); } if (extension == null) { sde = NO_SDE_INFO_MARK; diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceKlass.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceKlass.java index 9536da39838..acd975206f5 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceKlass.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceKlass.java @@ -342,7 +342,7 @@ public class InstanceKlass extends Klass { public Oop getProtectionDomain() { return protectionDomain.getValue(this); } public ObjArray getSigners() { return (ObjArray) signers.getValue(this); } public Symbol getSourceFileName() { return getSymbol(sourceFileName); } - public Symbol getSourceDebugExtension(){ return getSymbol(sourceDebugExtension); } + public String getSourceDebugExtension(){ return CStringUtilities.getString(sourceDebugExtension.getValue(getHandle())); } public TypeArray getInnerClasses() { return (TypeArray) innerClasses.getValue(this); } public long getNonstaticFieldSize() { return nonstaticFieldSize.getValue(this); } public long getStaticOopFieldCount() { return staticOopFieldCount.getValue(this); } diff --git a/hotspot/src/share/vm/classfile/classFileParser.cpp b/hotspot/src/share/vm/classfile/classFileParser.cpp index 1be1c7bf19c..b2cec5375fa 100644 --- a/hotspot/src/share/vm/classfile/classFileParser.cpp +++ b/hotspot/src/share/vm/classfile/classFileParser.cpp @@ -2337,12 +2337,7 @@ void ClassFileParser::parse_classfile_source_debug_extension_attribute(constantP // Don't bother storing it if there is no way to retrieve it if (JvmtiExport::can_get_source_debug_extension()) { - // Optimistically assume that only 1 byte UTF format is used - // (common case) - TempNewSymbol sde_symbol = SymbolTable::new_symbol((const char*)sde_buffer, length, CHECK); - k->set_source_debug_extension(sde_symbol); - // Note that set_source_debug_extension() increments the reference count - // for its copy of the Symbol*, so use a TempNewSymbol here. + k->set_source_debug_extension((char*)sde_buffer, length); } // Got utf8 string, set stream position forward cfs->skip_u1(length, CHECK); diff --git a/hotspot/src/share/vm/oops/instanceKlass.cpp b/hotspot/src/share/vm/oops/instanceKlass.cpp index b742889b66b..0c0fd34b6b2 100644 --- a/hotspot/src/share/vm/oops/instanceKlass.cpp +++ b/hotspot/src/share/vm/oops/instanceKlass.cpp @@ -847,7 +847,6 @@ void instanceKlass::shared_symbols_iterate(SymbolClosure* closure) { Klass::shared_symbols_iterate(closure); closure->do_symbol(&_generic_signature); closure->do_symbol(&_source_file_name); - closure->do_symbol(&_source_debug_extension); for (JavaFieldStream fs(this); !fs.done(); fs.next()) { int name_index = fs.name_index(); @@ -1944,9 +1943,10 @@ void instanceKlass::release_C_heap_structures() { // class can't be referenced anymore). if (_array_name != NULL) _array_name->decrement_refcount(); if (_source_file_name != NULL) _source_file_name->decrement_refcount(); - if (_source_debug_extension != NULL) _source_debug_extension->decrement_refcount(); // walk constant pool and decrement symbol reference counts _constants->unreference_symbols(); + + if (_source_debug_extension != NULL) FREE_C_HEAP_ARRAY(char, _source_debug_extension, mtClass); } void instanceKlass::set_source_file_name(Symbol* n) { @@ -1954,9 +1954,22 @@ void instanceKlass::set_source_file_name(Symbol* n) { if (_source_file_name != NULL) _source_file_name->increment_refcount(); } -void instanceKlass::set_source_debug_extension(Symbol* n) { - _source_debug_extension = n; - if (_source_debug_extension != NULL) _source_debug_extension->increment_refcount(); +void instanceKlass::set_source_debug_extension(char* array, int length) { + if (array == NULL) { + _source_debug_extension = NULL; + } else { + // Adding one to the attribute length in order to store a null terminator + // character could cause an overflow because the attribute length is + // already coded with an u4 in the classfile, but in practice, it's + // unlikely to happen. + assert((length+1) > length, "Overflow checking"); + char* sde = NEW_C_HEAP_ARRAY(char, (length + 1), mtClass); + for (int i = 0; i < length; i++) { + sde[i] = array[i]; + } + sde[length] = '\0'; + _source_debug_extension = sde; + } } address instanceKlass::static_field_addr(int offset) { diff --git a/hotspot/src/share/vm/oops/instanceKlass.hpp b/hotspot/src/share/vm/oops/instanceKlass.hpp index 93e804c281e..3c24b3f69a1 100644 --- a/hotspot/src/share/vm/oops/instanceKlass.hpp +++ b/hotspot/src/share/vm/oops/instanceKlass.hpp @@ -226,7 +226,9 @@ class instanceKlass: public Klass { // Name of source file containing this klass, NULL if not specified. Symbol* _source_file_name; // the source debug extension for this klass, NULL if not specified. - Symbol* _source_debug_extension; + // Specified as UTF-8 string without terminating zero byte in the classfile, + // it is stored in the instanceklass as a NULL-terminated UTF-8 string + char* _source_debug_extension; // Generic signature, or null if none. Symbol* _generic_signature; // Array name derived from this class which needs unreferencing @@ -542,8 +544,8 @@ class instanceKlass: public Klass { void set_major_version(u2 major_version) { _major_version = major_version; } // source debug extension - Symbol* source_debug_extension() const { return _source_debug_extension; } - void set_source_debug_extension(Symbol* n); + char* source_debug_extension() const { return _source_debug_extension; } + void set_source_debug_extension(char* array, int length); // symbol unloading support (refcount already added) Symbol* array_name() { return _array_name; } diff --git a/hotspot/src/share/vm/oops/instanceKlassKlass.cpp b/hotspot/src/share/vm/oops/instanceKlassKlass.cpp index 12ea2234451..d6ccd423f78 100644 --- a/hotspot/src/share/vm/oops/instanceKlassKlass.cpp +++ b/hotspot/src/share/vm/oops/instanceKlassKlass.cpp @@ -421,8 +421,7 @@ instanceKlassKlass::allocate_instance_klass(Symbol* name, int vtable_len, int it ik->set_protection_domain(NULL); ik->set_signers(NULL); ik->set_source_file_name(NULL); - ik->set_source_debug_extension(NULL); - ik->set_source_debug_extension(NULL); + ik->set_source_debug_extension(NULL, 0); ik->set_array_name(NULL); ik->set_inner_classes(NULL); ik->set_static_oop_field_count(0); @@ -531,7 +530,7 @@ void instanceKlassKlass::oop_print_on(oop obj, outputStream* st) { } if (ik->source_debug_extension() != NULL) { st->print(BULLET"source debug extension: "); - ik->source_debug_extension()->print_value_on(st); + st->print_cr("%s", ik->source_debug_extension()); st->cr(); } diff --git a/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.cpp b/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.cpp index d7dfea5a99e..60a801213be 100644 --- a/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.cpp +++ b/hotspot/src/share/vm/prims/jvmtiClassFileReconstituter.cpp @@ -268,14 +268,18 @@ void JvmtiClassFileReconstituter::write_source_file_attribute() { // JSR45| SourceDebugExtension_attribute { // JSR45| u2 attribute_name_index; // JSR45| u4 attribute_length; -// JSR45| u2 sourcefile_index; +// JSR45| u1 debug_extension[attribute_length]; // JSR45| } void JvmtiClassFileReconstituter::write_source_debug_extension_attribute() { assert(ikh()->source_debug_extension() != NULL, "caller must check"); write_attribute_name_index("SourceDebugExtension"); - write_u4(2); // always length 2 - write_u2(symbol_to_cpool_index(ikh()->source_debug_extension())); + int len = (int)strlen(ikh()->source_debug_extension()); + write_u4(len); + u1* ext = (u1*)ikh()->source_debug_extension(); + for (int i=0; ioop_is_instance()) { return JVMTI_ERROR_ABSENT_INFORMATION; } - Symbol* sdeOop = instanceKlass::cast(k)->source_debug_extension(); - NULL_CHECK(sdeOop, JVMTI_ERROR_ABSENT_INFORMATION); + char* sde = instanceKlass::cast(k)->source_debug_extension(); + NULL_CHECK(sde, JVMTI_ERROR_ABSENT_INFORMATION); { - JavaThread* current_thread = JavaThread::current(); - ResourceMark rm(current_thread); - const char* sdecp = (const char*) sdeOop->as_C_string(); - *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sdecp)+1); - strcpy(*source_debug_extension_ptr, sdecp); + *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1); + strcpy(*source_debug_extension_ptr, sde); } } diff --git a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp index 0eb188a6371..dbab30e4329 100644 --- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp +++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -3236,7 +3236,9 @@ void VM_RedefineClasses::redefine_single_class(jclass the_jclass, // Copy the "source debug extension" attribute from new class version the_class->set_source_debug_extension( - scratch_class->source_debug_extension()); + scratch_class->source_debug_extension(), + scratch_class->source_debug_extension() == NULL ? 0 : + (int)strlen(scratch_class->source_debug_extension())); // Use of javac -g could be different in the old and the new if (scratch_class->access_flags().has_localvariable_table() != diff --git a/hotspot/src/share/vm/runtime/vmStructs.cpp b/hotspot/src/share/vm/runtime/vmStructs.cpp index e1021cd19ad..fbda7f8ed0f 100644 --- a/hotspot/src/share/vm/runtime/vmStructs.cpp +++ b/hotspot/src/share/vm/runtime/vmStructs.cpp @@ -308,7 +308,7 @@ typedef TwoOopHashtable SymbolTwoOopHashtable; nonstatic_field(instanceKlass, _protection_domain, oop) \ nonstatic_field(instanceKlass, _signers, objArrayOop) \ nonstatic_field(instanceKlass, _source_file_name, Symbol*) \ - nonstatic_field(instanceKlass, _source_debug_extension, Symbol*) \ + nonstatic_field(instanceKlass, _source_debug_extension, char*) \ nonstatic_field(instanceKlass, _inner_classes, typeArrayOop) \ nonstatic_field(instanceKlass, _nonstatic_field_size, int) \ nonstatic_field(instanceKlass, _static_field_size, int) \ diff --git a/hotspot/test/runtime/6294277/SourceDebugExtension.java b/hotspot/test/runtime/6294277/SourceDebugExtension.java new file mode 100644 index 00000000000..70b12969ce1 --- /dev/null +++ b/hotspot/test/runtime/6294277/SourceDebugExtension.java @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 6294277 + * @summary java -Xdebug crashes on SourceDebugExtension attribute larger than 64K + */ +import java.io.*; + +public class SourceDebugExtension extends ClassLoader +{ + static final int attrSize = 68000; + static byte[] header = { +(byte)0xca, (byte)0xfe, (byte)0xba, (byte)0xbe, (byte)0x00, (byte)0x00, (byte)0x00, +(byte)0x32, (byte)0x00, (byte)0x1e, (byte)0x0a, (byte)0x00, (byte)0x06, (byte)0x00, +(byte)0x0f, (byte)0x09, (byte)0x00, (byte)0x10, (byte)0x00, (byte)0x11, (byte)0x08, +(byte)0x00, (byte)0x12, (byte)0x0a, (byte)0x00, (byte)0x13, (byte)0x00, (byte)0x14, +(byte)0x07, (byte)0x00, (byte)0x15, (byte)0x07, (byte)0x00, (byte)0x16, (byte)0x01, +(byte)0x00, (byte)0x06, (byte)0x3c, (byte)0x69, (byte)0x6e, (byte)0x69, (byte)0x74, +(byte)0x3e, (byte)0x01, (byte)0x00, (byte)0x03, (byte)0x28, (byte)0x29, (byte)0x56, +(byte)0x01, (byte)0x00, (byte)0x04, (byte)0x43, (byte)0x6f, (byte)0x64, (byte)0x65, +(byte)0x01, (byte)0x00, (byte)0x0f, (byte)0x4c, (byte)0x69, (byte)0x6e, (byte)0x65, +(byte)0x4e, (byte)0x75, (byte)0x6d, (byte)0x62, (byte)0x65, (byte)0x72, (byte)0x54, +(byte)0x61, (byte)0x62, (byte)0x6c, (byte)0x65, (byte)0x01, (byte)0x00, (byte)0x04, +(byte)0x6d, (byte)0x61, (byte)0x69, (byte)0x6e, (byte)0x01, (byte)0x00, (byte)0x16, +(byte)0x28, (byte)0x5b, (byte)0x4c, (byte)0x6a, (byte)0x61, (byte)0x76, (byte)0x61, +(byte)0x2f, (byte)0x6c, (byte)0x61, (byte)0x6e, (byte)0x67, (byte)0x2f, (byte)0x53, +(byte)0x74, (byte)0x72, (byte)0x69, (byte)0x6e, (byte)0x67, (byte)0x3b, (byte)0x29, +(byte)0x56, (byte)0x01, (byte)0x00, (byte)0x0a, (byte)0x53, (byte)0x6f, (byte)0x75, +(byte)0x72, (byte)0x63, (byte)0x65, (byte)0x46, (byte)0x69, (byte)0x6c, (byte)0x65, +(byte)0x01, (byte)0x00, (byte)0x0d, (byte)0x54, (byte)0x65, (byte)0x73, (byte)0x74, +(byte)0x50, (byte)0x72, (byte)0x6f, (byte)0x67, (byte)0x2e, (byte)0x6a, (byte)0x61, +(byte)0x76, (byte)0x61, (byte)0x0c, (byte)0x00, (byte)0x07, (byte)0x00, (byte)0x08, +(byte)0x07, (byte)0x00, (byte)0x17, (byte)0x0c, (byte)0x00, (byte)0x18, (byte)0x00, +(byte)0x19, (byte)0x01, (byte)0x00, (byte)0x34, (byte)0x54, (byte)0x65, (byte)0x73, +(byte)0x74, (byte)0x20, (byte)0x70, (byte)0x72, (byte)0x6f, (byte)0x67, (byte)0x72, +(byte)0x61, (byte)0x6d, (byte)0x20, (byte)0x66, (byte)0x6f, (byte)0x72, (byte)0x20, +(byte)0x62, (byte)0x69, (byte)0x67, (byte)0x20, (byte)0x53, (byte)0x6f, (byte)0x75, +(byte)0x72, (byte)0x63, (byte)0x65, (byte)0x44, (byte)0x65, (byte)0x62, (byte)0x75, +(byte)0x67, (byte)0x45, (byte)0x78, (byte)0x74, (byte)0x65, (byte)0x6e, (byte)0x73, +(byte)0x69, (byte)0x6f, (byte)0x6e, (byte)0x20, (byte)0x61, (byte)0x74, (byte)0x74, +(byte)0x72, (byte)0x69, (byte)0x62, (byte)0x75, (byte)0x74, (byte)0x65, (byte)0x73, +(byte)0x07, (byte)0x00, (byte)0x1a, (byte)0x0c, (byte)0x00, (byte)0x1b, (byte)0x00, +(byte)0x1c, (byte)0x01, (byte)0x00, (byte)0x08, (byte)0x54, (byte)0x65, (byte)0x73, +(byte)0x74, (byte)0x50, (byte)0x72, (byte)0x6f, (byte)0x67, (byte)0x01, (byte)0x00, +(byte)0x10, (byte)0x6a, (byte)0x61, (byte)0x76, (byte)0x61, (byte)0x2f, (byte)0x6c, +(byte)0x61, (byte)0x6e, (byte)0x67, (byte)0x2f, (byte)0x4f, (byte)0x62, (byte)0x6a, +(byte)0x65, (byte)0x63, (byte)0x74, (byte)0x01, (byte)0x00, (byte)0x10, (byte)0x6a, +(byte)0x61, (byte)0x76, (byte)0x61, (byte)0x2f, (byte)0x6c, (byte)0x61, (byte)0x6e, +(byte)0x67, (byte)0x2f, (byte)0x53, (byte)0x79, (byte)0x73, (byte)0x74, (byte)0x65, +(byte)0x6d, (byte)0x01, (byte)0x00, (byte)0x03, (byte)0x6f, (byte)0x75, (byte)0x74, +(byte)0x01, (byte)0x00, (byte)0x15, (byte)0x4c, (byte)0x6a, (byte)0x61, (byte)0x76, +(byte)0x61, (byte)0x2f, (byte)0x69, (byte)0x6f, (byte)0x2f, (byte)0x50, (byte)0x72, +(byte)0x69, (byte)0x6e, (byte)0x74, (byte)0x53, (byte)0x74, (byte)0x72, (byte)0x65, +(byte)0x61, (byte)0x6d, (byte)0x3b, (byte)0x01, (byte)0x00, (byte)0x13, (byte)0x6a, +(byte)0x61, (byte)0x76, (byte)0x61, (byte)0x2f, (byte)0x69, (byte)0x6f, (byte)0x2f, +(byte)0x50, (byte)0x72, (byte)0x69, (byte)0x6e, (byte)0x74, (byte)0x53, (byte)0x74, +(byte)0x72, (byte)0x65, (byte)0x61, (byte)0x6d, (byte)0x01, (byte)0x00, (byte)0x07, +(byte)0x70, (byte)0x72, (byte)0x69, (byte)0x6e, (byte)0x74, (byte)0x6c, (byte)0x6e, +(byte)0x01, (byte)0x00, (byte)0x15, (byte)0x28, (byte)0x4c, (byte)0x6a, (byte)0x61, +(byte)0x76, (byte)0x61, (byte)0x2f, (byte)0x6c, (byte)0x61, (byte)0x6e, (byte)0x67, +(byte)0x2f, (byte)0x53, (byte)0x74, (byte)0x72, (byte)0x69, (byte)0x6e, (byte)0x67, +(byte)0x3b, (byte)0x29, (byte)0x56, (byte)0x01, (byte)0x00, (byte)0x14, (byte)0x53, +(byte)0x6f, (byte)0x75, (byte)0x72, (byte)0x63, (byte)0x65, (byte)0x44, (byte)0x65, +(byte)0x62, (byte)0x75, (byte)0x67, (byte)0x45, (byte)0x78, (byte)0x74, (byte)0x65, +(byte)0x6e, (byte)0x73, (byte)0x69, (byte)0x6f, (byte)0x6e, (byte)0x00, (byte)0x21, +(byte)0x00, (byte)0x05, (byte)0x00, (byte)0x06, (byte)0x00, (byte)0x00, (byte)0x00, +(byte)0x00, (byte)0x00, (byte)0x02, (byte)0x00, (byte)0x01, (byte)0x00, (byte)0x07, +(byte)0x00, (byte)0x08, (byte)0x00, (byte)0x01, (byte)0x00, (byte)0x09, (byte)0x00, +(byte)0x00, (byte)0x00, (byte)0x1d, (byte)0x00, (byte)0x01, (byte)0x00, (byte)0x01, +(byte)0x00, (byte)0x00, (byte)0x00, (byte)0x05, (byte)0x2a, (byte)0xb7, (byte)0x00, +(byte)0x01, (byte)0xb1, (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x01, (byte)0x00, +(byte)0x0a, (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x06, (byte)0x00, (byte)0x01, +(byte)0x00, (byte)0x00, (byte)0x00, (byte)0x01, (byte)0x00, (byte)0x09, (byte)0x00, +(byte)0x0b, (byte)0x00, (byte)0x0c, (byte)0x00, (byte)0x01, (byte)0x00, (byte)0x09, +(byte)0x00, (byte)0x00, (byte)0x00, (byte)0x25, (byte)0x00, (byte)0x02, (byte)0x00, +(byte)0x01, (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x09, (byte)0xb2, (byte)0x00, +(byte)0x02, (byte)0x12, (byte)0x03, (byte)0xb6, (byte)0x00, (byte)0x04, (byte)0xb1, +(byte)0x00, (byte)0x00, (byte)0x00, (byte)0x01, (byte)0x00, (byte)0x0a, (byte)0x00, +(byte)0x00, (byte)0x00, (byte)0x0a, (byte)0x00, (byte)0x02, (byte)0x00, (byte)0x00, +(byte)0x00, (byte)0x03, (byte)0x00, (byte)0x08, (byte)0x00, (byte)0x04, (byte)0x00, +(byte)0x02, (byte)0x00, (byte)0x0d, (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x02, +(byte)0x00, (byte)0x0e, (byte)0x00, (byte)0x1d, (byte)0x00, (byte)0x01, (byte)0x09, +(byte)0xa0 + }; + + public static void main(String[] args) throws Exception + { + try { + SourceDebugExtension loader = new SourceDebugExtension(); + /* The test program creates a class file from the header + * stored above and adding the content of a SourceDebugExtension + * attribute made of the character 0x02 repeated 68000 times. + * This attribute doesn't follow the syntax specified in JSR 45 + * but it's fine because this test just checks that the JVM is + * able to load a class file with a SourceDebugExtension + * attribute bigger than 64KB. The JVM doesn't try to + * parse the content of the attribute, this work is performed + * by the SA or external tools. + */ + byte[] buf = new byte[header.length + attrSize]; + for(int i=0; i test.out 2>&1 & + +P_PID=$! + +sleep 60 +STATUS=1 + +grep "Test PASSES" test.out > ${NULL} +if [ $? = 0 ]; then + cat test.out + STATUS=0 +fi + +exit $STATUS From 95af7bf142e5d04bac1cc2d5221179b49c01f908 Mon Sep 17 00:00:00 2001 From: Rob McKenna Date: Mon, 9 Jul 2012 22:26:08 +0100 Subject: [PATCH 077/160] 7179305: (fs) Method name sun.nio.fs.UnixPath.getPathForExecptionMessage is misspelled Reviewed-by: dholmes, chegar --- .../fs/LinuxUserDefinedFileAttributeView.java | 14 +++++++------- .../classes/sun/nio/fs/LinuxWatchService.java | 4 ++-- .../sun/nio/fs/SolarisAclFileAttributeView.java | 6 +++--- .../fs/SolarisUserDefinedFileAttributeView.java | 14 +++++++------- .../classes/sun/nio/fs/SolarisWatchService.java | 4 ++-- .../solaris/classes/sun/nio/fs/UnixCopyFile.java | 16 ++++++++-------- .../classes/sun/nio/fs/UnixException.java | 8 ++++---- .../sun/nio/fs/UnixFileSystemProvider.java | 10 +++++----- jdk/src/solaris/classes/sun/nio/fs/UnixPath.java | 6 +++--- 9 files changed, 41 insertions(+), 41 deletions(-) diff --git a/jdk/src/solaris/classes/sun/nio/fs/LinuxUserDefinedFileAttributeView.java b/jdk/src/solaris/classes/sun/nio/fs/LinuxUserDefinedFileAttributeView.java index 586e4b3fad1..46e7f2cf6f9 100644 --- a/jdk/src/solaris/classes/sun/nio/fs/LinuxUserDefinedFileAttributeView.java +++ b/jdk/src/solaris/classes/sun/nio/fs/LinuxUserDefinedFileAttributeView.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -55,7 +55,7 @@ class LinuxUserDefinedFileAttributeView name = USER_NAMESPACE + name; byte[] bytes = name.getBytes(); if (bytes.length > XATTR_NAME_MAX) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "'" + name + "' is too big"); } return bytes; @@ -116,7 +116,7 @@ class LinuxUserDefinedFileAttributeView buffer = NativeBuffers.getNativeBuffer(size); continue; } - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Unable to get list of extended attributes: " + x.getMessage()); } @@ -138,7 +138,7 @@ class LinuxUserDefinedFileAttributeView // fgetxattr returns size if called with size==0 return fgetxattr(fd, nameAsBytes(file,name), 0L, 0); } catch (UnixException x) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Unable to get size of extended attribute '" + name + "': " + x.getMessage()); } finally { @@ -191,7 +191,7 @@ class LinuxUserDefinedFileAttributeView } catch (UnixException x) { String msg = (x.errno() == ERANGE) ? "Insufficient space in buffer" : x.getMessage(); - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Error reading extended attribute '" + name + "': " + msg); } finally { close(fd); @@ -243,7 +243,7 @@ class LinuxUserDefinedFileAttributeView src.position(pos + rem); return rem; } catch (UnixException x) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Error writing extended attribute '" + name + "': " + x.getMessage()); } finally { @@ -264,7 +264,7 @@ class LinuxUserDefinedFileAttributeView try { fremovexattr(fd, nameAsBytes(file,name)); } catch (UnixException x) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Unable to delete extended attribute '" + name + "': " + x.getMessage()); } finally { close(fd); diff --git a/jdk/src/solaris/classes/sun/nio/fs/LinuxWatchService.java b/jdk/src/solaris/classes/sun/nio/fs/LinuxWatchService.java index 6b71a65cfd7..123fab5b3ea 100644 --- a/jdk/src/solaris/classes/sun/nio/fs/LinuxWatchService.java +++ b/jdk/src/solaris/classes/sun/nio/fs/LinuxWatchService.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -246,7 +246,7 @@ class LinuxWatchService return x.asIOException(dir); } if (!attrs.isDirectory()) { - return new NotDirectoryException(dir.getPathForExecptionMessage()); + return new NotDirectoryException(dir.getPathForExceptionMessage()); } // register with inotify (replaces existing mask if already registered) diff --git a/jdk/src/solaris/classes/sun/nio/fs/SolarisAclFileAttributeView.java b/jdk/src/solaris/classes/sun/nio/fs/SolarisAclFileAttributeView.java index b27f937b8d7..54023bf8265 100644 --- a/jdk/src/solaris/classes/sun/nio/fs/SolarisAclFileAttributeView.java +++ b/jdk/src/solaris/classes/sun/nio/fs/SolarisAclFileAttributeView.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -324,7 +324,7 @@ class SolarisAclFileAttributeView return decode(address, n); } catch (UnixException x) { if ((x.errno() == ENOSYS) || !isAclsEnabled(fd)) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, x.getMessage() + " (file system does not support NFSv4 ACLs)"); } x.rethrowAsIOException(file); @@ -355,7 +355,7 @@ class SolarisAclFileAttributeView facl(fd, ACE_SETACL, n, address); } catch (UnixException x) { if ((x.errno() == ENOSYS) || !isAclsEnabled(fd)) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, x.getMessage() + " (file system does not support NFSv4 ACLs)"); } if (x.errno() == EINVAL && (n < 3)) diff --git a/jdk/src/solaris/classes/sun/nio/fs/SolarisUserDefinedFileAttributeView.java b/jdk/src/solaris/classes/sun/nio/fs/SolarisUserDefinedFileAttributeView.java index c48ecef63b0..2412e04d987 100644 --- a/jdk/src/solaris/classes/sun/nio/fs/SolarisUserDefinedFileAttributeView.java +++ b/jdk/src/solaris/classes/sun/nio/fs/SolarisUserDefinedFileAttributeView.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -49,7 +49,7 @@ class SolarisUserDefinedFileAttributeView if (bytes.length <= 1 || (bytes.length == 2 && bytes[1] == '.')) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "'" + name + "' is not a valid name"); } } @@ -96,7 +96,7 @@ class SolarisUserDefinedFileAttributeView } return Collections.unmodifiableList(list); } catch (UnixException x) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Unable to get list of extended attributes: " + x.getMessage()); } @@ -126,7 +126,7 @@ class SolarisUserDefinedFileAttributeView close(afd); } } catch (UnixException x) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Unable to get size of extended attribute '" + name + "': " + x.getMessage()); } @@ -165,7 +165,7 @@ class SolarisUserDefinedFileAttributeView fc.close(); } } catch (UnixException x) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Unable to read extended attribute '" + name + "': " + x.getMessage()); } @@ -201,7 +201,7 @@ class SolarisUserDefinedFileAttributeView fc.close(); } } catch (UnixException x) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Unable to write extended attribute '" + name + "': " + x.getMessage()); } @@ -224,7 +224,7 @@ class SolarisUserDefinedFileAttributeView close(dfd); } } catch (UnixException x) { - throw new FileSystemException(file.getPathForExecptionMessage(), + throw new FileSystemException(file.getPathForExceptionMessage(), null, "Unable to delete extended attribute '" + name + "': " + x.getMessage()); } finally { diff --git a/jdk/src/solaris/classes/sun/nio/fs/SolarisWatchService.java b/jdk/src/solaris/classes/sun/nio/fs/SolarisWatchService.java index 171dbfe0de2..fb5c4301d73 100644 --- a/jdk/src/solaris/classes/sun/nio/fs/SolarisWatchService.java +++ b/jdk/src/solaris/classes/sun/nio/fs/SolarisWatchService.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -288,7 +288,7 @@ class SolarisWatchService return x.asIOException(dir); } if (!attrs.isDirectory()) { - return new NotDirectoryException(dir.getPathForExecptionMessage()); + return new NotDirectoryException(dir.getPathForExceptionMessage()); } // return existing watch key after updating events if already diff --git a/jdk/src/solaris/classes/sun/nio/fs/UnixCopyFile.java b/jdk/src/solaris/classes/sun/nio/fs/UnixCopyFile.java index 08aa82211dd..c35133b202a 100644 --- a/jdk/src/solaris/classes/sun/nio/fs/UnixCopyFile.java +++ b/jdk/src/solaris/classes/sun/nio/fs/UnixCopyFile.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -383,8 +383,8 @@ class UnixCopyFile { } catch (UnixException x) { if (x.errno() == EXDEV) { throw new AtomicMoveNotSupportedException( - source.getPathForExecptionMessage(), - target.getPathForExecptionMessage(), + source.getPathForExceptionMessage(), + target.getPathForExceptionMessage(), x.errorString()); } x.rethrowAsIOException(source, target); @@ -420,7 +420,7 @@ class UnixCopyFile { return; // nothing to do as files are identical if (!flags.replaceExisting) { throw new FileAlreadyExistsException( - target.getPathForExecptionMessage()); + target.getPathForExceptionMessage()); } // attempt to delete target @@ -436,7 +436,7 @@ class UnixCopyFile { (x.errno() == EEXIST || x.errno() == ENOTEMPTY)) { throw new DirectoryNotEmptyException( - target.getPathForExecptionMessage()); + target.getPathForExceptionMessage()); } x.rethrowAsIOException(target); } @@ -489,7 +489,7 @@ class UnixCopyFile { (x.errno() == EEXIST || x.errno() == ENOTEMPTY)) { throw new DirectoryNotEmptyException( - source.getPathForExecptionMessage()); + source.getPathForExceptionMessage()); } x.rethrowAsIOException(source); } @@ -542,7 +542,7 @@ class UnixCopyFile { return; // nothing to do as files are identical if (!flags.replaceExisting) throw new FileAlreadyExistsException( - target.getPathForExecptionMessage()); + target.getPathForExceptionMessage()); try { if (targetAttrs.isDirectory()) { rmdir(target); @@ -555,7 +555,7 @@ class UnixCopyFile { (x.errno() == EEXIST || x.errno() == ENOTEMPTY)) { throw new DirectoryNotEmptyException( - target.getPathForExecptionMessage()); + target.getPathForExceptionMessage()); } x.rethrowAsIOException(target); } diff --git a/jdk/src/solaris/classes/sun/nio/fs/UnixException.java b/jdk/src/solaris/classes/sun/nio/fs/UnixException.java index 48137b5ae4c..b4925c35da7 100644 --- a/jdk/src/solaris/classes/sun/nio/fs/UnixException.java +++ b/jdk/src/solaris/classes/sun/nio/fs/UnixException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -97,8 +97,8 @@ class UnixException extends Exception { } void rethrowAsIOException(UnixPath file, UnixPath other) throws IOException { - String a = (file == null) ? null : file.getPathForExecptionMessage(); - String b = (other == null) ? null : other.getPathForExecptionMessage(); + String a = (file == null) ? null : file.getPathForExceptionMessage(); + String b = (other == null) ? null : other.getPathForExceptionMessage(); IOException x = translateToIOException(a, b); throw x; } @@ -108,6 +108,6 @@ class UnixException extends Exception { } IOException asIOException(UnixPath file) { - return translateToIOException(file.getPathForExecptionMessage(), null); + return translateToIOException(file.getPathForExceptionMessage(), null); } } diff --git a/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java b/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java index ea9df0c1fdc..49f69a54648 100644 --- a/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java +++ b/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -238,7 +238,7 @@ public abstract class UnixFileSystemProvider // DirectoryNotEmptyException if not empty if (attrs != null && attrs.isDirectory() && (x.errno() == EEXIST || x.errno() == ENOTEMPTY)) - throw new DirectoryNotEmptyException(file.getPathForExecptionMessage()); + throw new DirectoryNotEmptyException(file.getPathForExceptionMessage()); x.rethrowAsIOException(file); return false; @@ -401,7 +401,7 @@ public abstract class UnixFileSystemProvider return new UnixDirectoryStream(dir, ptr, filter); } catch (UnixException x) { if (x.errno() == ENOTDIR) - throw new NotDirectoryException(dir.getPathForExecptionMessage()); + throw new NotDirectoryException(dir.getPathForExceptionMessage()); x.rethrowAsIOException(dir); } } @@ -421,7 +421,7 @@ public abstract class UnixFileSystemProvider if (dfd2 != -1) UnixNativeDispatcher.close(dfd2); if (x.errno() == UnixConstants.ENOTDIR) - throw new NotDirectoryException(dir.getPathForExecptionMessage()); + throw new NotDirectoryException(dir.getPathForExceptionMessage()); x.rethrowAsIOException(dir); } return new UnixSecureDirectoryStream(dir, dp, dfd2, filter); @@ -490,7 +490,7 @@ public abstract class UnixFileSystemProvider return new UnixPath(link.getFileSystem(), target); } catch (UnixException x) { if (x.errno() == UnixConstants.EINVAL) - throw new NotLinkException(link.getPathForExecptionMessage()); + throw new NotLinkException(link.getPathForExceptionMessage()); x.rethrowAsIOException(link); return null; // keep compiler happy } diff --git a/jdk/src/solaris/classes/sun/nio/fs/UnixPath.java b/jdk/src/solaris/classes/sun/nio/fs/UnixPath.java index 52b88416eb7..c0677434533 100644 --- a/jdk/src/solaris/classes/sun/nio/fs/UnixPath.java +++ b/jdk/src/solaris/classes/sun/nio/fs/UnixPath.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -179,7 +179,7 @@ class UnixPath } // use this message when throwing exceptions - String getPathForExecptionMessage() { + String getPathForExceptionMessage() { return toString(); } @@ -780,7 +780,7 @@ class UnixPath x.setError(ELOOP); if (x.errno() == ELOOP) - throw new FileSystemException(getPathForExecptionMessage(), null, + throw new FileSystemException(getPathForExceptionMessage(), null, x.getMessage() + " or unable to access attributes of symbolic link"); x.rethrowAsIOException(this); From 3e4ca7604b6fc4beaa8a3ba99ab9662b0b97eca4 Mon Sep 17 00:00:00 2001 From: Weijun Wang Date: Wed, 11 Jul 2012 17:10:34 +0800 Subject: [PATCH 078/160] 6966259: Make PrincipalName and Realm immutable Reviewed-by: xuelei --- .../auth/kerberos/KerberosPrincipal.java | 33 +- .../security/jgss/krb5/Krb5NameElement.java | 6 +- .../sun/security/krb5/Credentials.java | 3 +- .../classes/sun/security/krb5/KrbApReq.java | 14 +- .../sun/security/krb5/KrbAppMessage.java | 3 +- .../classes/sun/security/krb5/KrbAsRep.java | 3 +- .../classes/sun/security/krb5/KrbAsReq.java | 7 +- .../sun/security/krb5/KrbAsReqBuilder.java | 3 - .../classes/sun/security/krb5/KrbCred.java | 11 +- .../sun/security/krb5/KrbException.java | 4 + .../classes/sun/security/krb5/KrbKdcRep.java | 18 +- .../classes/sun/security/krb5/KrbPriv.java | 9 +- .../classes/sun/security/krb5/KrbSafe.java | 9 +- .../classes/sun/security/krb5/KrbTgsRep.java | 6 +- .../classes/sun/security/krb5/KrbTgsReq.java | 5 - .../sun/security/krb5/PrincipalName.java | 356 +++++++++--------- .../classes/sun/security/krb5/Realm.java | 47 +-- .../sun/security/krb5/RealmException.java | 3 + .../sun/security/krb5/ServiceName.java | 57 --- .../sun/security/krb5/internal/ASRep.java | 3 +- .../security/krb5/internal/Authenticator.java | 9 +- .../krb5/internal/CredentialsUtil.java | 27 +- .../security/krb5/internal/EncASRepPart.java | 2 - .../security/krb5/internal/EncKDCRepPart.java | 9 +- .../security/krb5/internal/EncTGSRepPart.java | 2 - .../security/krb5/internal/EncTicketPart.java | 9 +- .../sun/security/krb5/internal/KDCRep.java | 9 +- .../security/krb5/internal/KDCReqBody.java | 23 +- .../sun/security/krb5/internal/KRBError.java | 34 +- .../security/krb5/internal/KrbCredInfo.java | 29 +- .../sun/security/krb5/internal/TGSRep.java | 3 +- .../sun/security/krb5/internal/Ticket.java | 10 +- .../internal/ccache/CCacheInputStream.java | 15 +- .../krb5/internal/ccache/Credentials.java | 25 -- .../internal/ccache/CredentialsCache.java | 4 +- .../internal/ccache/FileCredentialsCache.java | 20 +- .../ccache/MemoryCredentialsCache.java | 2 +- .../krb5/internal/ktab/KeyTabInputStream.java | 3 +- .../krb5/KerberosClientKeyExchangeImpl.java | 6 +- .../security/krb5/internal/tools/Kinit.java | 4 +- .../krb5/internal/tools/KinitOptions.java | 45 +-- .../security/krb5/internal/tools/Ktab.java | 6 - .../native/sun/security/krb5/NativeCreds.c | 18 +- .../sun/security/krb5/ServiceNameClone.java | 41 -- jdk/test/sun/security/krb5/auto/KDC.java | 25 +- .../sun/security/krb5/name/Constructors.java | 135 +++++++ jdk/test/sun/security/krb5/name/empty.conf | 2 + jdk/test/sun/security/krb5/name/krb5.conf | 10 + 48 files changed, 481 insertions(+), 646 deletions(-) delete mode 100644 jdk/src/share/classes/sun/security/krb5/ServiceName.java delete mode 100644 jdk/test/sun/security/krb5/ServiceNameClone.java create mode 100644 jdk/test/sun/security/krb5/name/Constructors.java create mode 100644 jdk/test/sun/security/krb5/name/empty.conf create mode 100644 jdk/test/sun/security/krb5/name/krb5.conf diff --git a/jdk/src/share/classes/javax/security/auth/kerberos/KerberosPrincipal.java b/jdk/src/share/classes/javax/security/auth/kerberos/KerberosPrincipal.java index 99d6593d9ac..cd4266bf62b 100644 --- a/jdk/src/share/classes/javax/security/auth/kerberos/KerberosPrincipal.java +++ b/jdk/src/share/classes/javax/security/auth/kerberos/KerberosPrincipal.java @@ -26,7 +26,6 @@ package javax.security.auth.kerberos; import java.io.*; -import sun.security.krb5.Asn1Exception; import sun.security.krb5.KrbException; import sun.security.krb5.PrincipalName; import sun.security.krb5.Realm; @@ -81,14 +80,12 @@ public final class KerberosPrincipal public static final int KRB_NT_UID = 5; - private transient String fullName; private transient String realm; private transient int nameType; - private static final char NAME_REALM_SEPARATOR = '@'; /** * Constructs a KerberosPrincipal from the provided string input. The @@ -233,41 +230,35 @@ public final class KerberosPrincipal * realm in their DER-encoded form as specified in Section 5.2.2 of * RFC4120. */ - private void writeObject(ObjectOutputStream oos) - throws IOException { + throws IOException { - PrincipalName krb5Principal = null; + PrincipalName krb5Principal; try { - krb5Principal = new PrincipalName(fullName,nameType); + krb5Principal = new PrincipalName(fullName, nameType); oos.writeObject(krb5Principal.asn1Encode()); oos.writeObject(krb5Principal.getRealm().asn1Encode()); } catch (Exception e) { - IOException ioe = new IOException(e.getMessage()); - ioe.initCause(e); - throw ioe; + throw new IOException(e); } } /** * Reads this object from a stream (i.e., deserializes it) */ - private void readObject(ObjectInputStream ois) - throws IOException, ClassNotFoundException { + throws IOException, ClassNotFoundException { byte[] asn1EncPrincipal = (byte [])ois.readObject(); byte[] encRealm = (byte [])ois.readObject(); try { - PrincipalName krb5Principal = new PrincipalName(new - DerValue(asn1EncPrincipal)); - realm = (new Realm(new DerValue(encRealm))).toString(); - fullName = krb5Principal.toString() + NAME_REALM_SEPARATOR + - realm.toString(); + Realm realmObject = new Realm(new DerValue(encRealm)); + PrincipalName krb5Principal = new PrincipalName( + new DerValue(asn1EncPrincipal), realmObject); + realm = realmObject.toString(); + fullName = krb5Principal.toString(); nameType = krb5Principal.getNameType(); } catch (Exception e) { - IOException ioe = new IOException(e.getMessage()); - ioe.initCause(e); - throw ioe; + throw new IOException(e); } } @@ -288,9 +279,7 @@ public final class KerberosPrincipal * RFC4120. * * @return the name type. - * */ - public int getNameType() { return nameType; } diff --git a/jdk/src/share/classes/sun/security/jgss/krb5/Krb5NameElement.java b/jdk/src/share/classes/sun/security/jgss/krb5/Krb5NameElement.java index 1fb1bb0e689..e8b16765919 100644 --- a/jdk/src/share/classes/sun/security/jgss/krb5/Krb5NameElement.java +++ b/jdk/src/share/classes/sun/security/jgss/krb5/Krb5NameElement.java @@ -27,10 +27,8 @@ package sun.security.jgss.krb5; import org.ietf.jgss.*; import sun.security.jgss.spi.*; -import javax.security.auth.kerberos.*; import sun.security.krb5.PrincipalName; import sun.security.krb5.KrbException; -import sun.security.krb5.ServiceName; import java.io.UnsupportedEncodingException; import java.net.InetAddress; import java.net.UnknownHostException; @@ -119,8 +117,8 @@ public class Krb5NameElement hostName = components[1]; String principal = getHostBasedInstance(service, hostName); - principalName = new ServiceName(principal, - PrincipalName.KRB_NT_SRV_HST); + principalName = new PrincipalName(principal, + PrincipalName.KRB_NT_SRV_HST); } } diff --git a/jdk/src/share/classes/sun/security/krb5/Credentials.java b/jdk/src/share/classes/sun/security/krb5/Credentials.java index 1451910c5cf..bdb8f7c1045 100644 --- a/jdk/src/share/classes/sun/security/krb5/Credentials.java +++ b/jdk/src/share/classes/sun/security/krb5/Credentials.java @@ -464,8 +464,7 @@ public class Credentials { System.out.println(">>> DEBUG: ----Credentials----"); System.out.println("\tclient: " + c.client.toString()); System.out.println("\tserver: " + c.server.toString()); - System.out.println("\tticket: realm: " + c.ticket.realm.toString()); - System.out.println("\t sname: " + c.ticket.sname.toString()); + System.out.println("\tticket: sname: " + c.ticket.sname.toString()); if (c.startTime != null) { System.out.println("\tstartTime: " + c.startTime.getTime()); } diff --git a/jdk/src/share/classes/sun/security/krb5/KrbApReq.java b/jdk/src/share/classes/sun/security/krb5/KrbApReq.java index 4854cd3d825..52d62c83bea 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbApReq.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbApReq.java @@ -179,7 +179,6 @@ public class KrbApReq { KrbApReq(APOptions apOptions, Ticket ticket, EncryptionKey key, - Realm crealm, PrincipalName cname, Checksum cksum, KerberosTime ctime, @@ -189,7 +188,7 @@ public class KrbApReq { throws Asn1Exception, IOException, KdcErrException, KrbCryptoException { - init(apOptions, ticket, key, crealm, cname, + init(apOptions, ticket, key, cname, cksum, ctime, subKey, seqNumber, authorizationData, KeyUsage.KU_PA_TGS_REQ_AUTHENTICATOR); @@ -208,7 +207,6 @@ public class KrbApReq { init(options, tgs_creds.ticket, tgs_creds.key, - tgs_creds.client.getRealm(), tgs_creds.client, cksum, ctime, @@ -221,7 +219,6 @@ public class KrbApReq { private void init(APOptions apOptions, Ticket ticket, EncryptionKey key, - Realm crealm, PrincipalName cname, Checksum cksum, KerberosTime ctime, @@ -232,7 +229,7 @@ public class KrbApReq { throws Asn1Exception, IOException, KdcErrException, KrbCryptoException { - createMessage(apOptions, ticket, key, crealm, cname, + createMessage(apOptions, ticket, key, cname, cksum, ctime, subKey, seqNumber, authorizationData, usage); obuf = apReqMessg.asn1Encode(); @@ -289,9 +286,6 @@ public class KrbApReq { ctime = authenticator.ctime; cusec = authenticator.cusec; authenticator.ctime.setMicroSeconds(authenticator.cusec); - authenticator.cname.setRealm(authenticator.crealm); - apReqMessg.ticket.sname.setRealm(apReqMessg.ticket.realm); - enc_ticketPart.cname.setRealm(enc_ticketPart.crealm); if (!authenticator.cname.equals(enc_ticketPart.cname)) throw new KrbApErrException(Krb5.KRB_AP_ERR_BADMATCH); @@ -457,7 +451,6 @@ public class KrbApReq { private void createMessage(APOptions apOptions, Ticket ticket, EncryptionKey key, - Realm crealm, PrincipalName cname, Checksum cksum, KerberosTime ctime, @@ -474,8 +467,7 @@ public class KrbApReq { seqno = new Integer(seqNumber.current()); authenticator = - new Authenticator(crealm, - cname, + new Authenticator(cname, cksum, ctime.getMicroSeconds(), ctime, diff --git a/jdk/src/share/classes/sun/security/krb5/KrbAppMessage.java b/jdk/src/share/classes/sun/security/krb5/KrbAppMessage.java index 32c4e3b683a..cf19cf98242 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbAppMessage.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbAppMessage.java @@ -48,8 +48,7 @@ abstract class KrbAppMessage { HostAddress rAddress, boolean timestampRequired, boolean seqNumberRequired, - PrincipalName packetPrincipal, - Realm packetRealm) + PrincipalName packetPrincipal) throws KrbApErrException { if (!Krb5.AP_EMPTY_ADDRESSES_ALLOWED || sAddress != null) { diff --git a/jdk/src/share/classes/sun/security/krb5/KrbAsRep.java b/jdk/src/share/classes/sun/security/krb5/KrbAsRep.java index c2b0df30db4..4c7b9a7bdc8 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbAsRep.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbAsRep.java @@ -152,11 +152,10 @@ class KrbAsRep extends KrbKdcRep { DerValue encoding = new DerValue(enc_as_rep_part); EncASRepPart enc_part = new EncASRepPart(encoding); - rep.ticket.sname.setRealm(rep.ticket.realm); rep.encKDCRepPart = enc_part; ASReq req = asReq.getMessage(); - check(req, rep); + check(true, req, rep); creds = new Credentials( rep.ticket, diff --git a/jdk/src/share/classes/sun/security/krb5/KrbAsReq.java b/jdk/src/share/classes/sun/security/krb5/KrbAsReq.java index 1c2dfdf94db..95d2b0d32f3 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbAsReq.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbAsReq.java @@ -115,10 +115,8 @@ public class KrbAsReq { } if (sname == null) { - sname = new PrincipalName("krbtgt" + - PrincipalName.NAME_COMPONENT_SEPARATOR + - cname.getRealmAsString(), - PrincipalName.KRB_NT_SRV_INST); + String realm = cname.getRealmAsString(); + sname = PrincipalName.tgsService(realm, realm); } if (till == null) { @@ -128,7 +126,6 @@ public class KrbAsReq { // enc-authorization-data and additional-tickets never in AS-REQ KDCReqBody kdc_req_body = new KDCReqBody(options, cname, - cname.getRealm(), sname, from, till, diff --git a/jdk/src/share/classes/sun/security/krb5/KrbAsReqBuilder.java b/jdk/src/share/classes/sun/security/krb5/KrbAsReqBuilder.java index 23b4dd84f62..ece8dff29a1 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbAsReqBuilder.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbAsReqBuilder.java @@ -99,9 +99,6 @@ public final class KrbAsReqBuilder { // Called by other constructors private void init(PrincipalName cname) throws KrbException { - if (cname.getRealm() == null) { - cname.setRealm(Config.getInstance().getDefaultRealm()); - } this.cname = cname; state = State.INIT; } diff --git a/jdk/src/share/classes/sun/security/krb5/KrbCred.java b/jdk/src/share/classes/sun/security/krb5/KrbCred.java index e263640e99e..7e2c645eea7 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbCred.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbCred.java @@ -96,12 +96,11 @@ public class KrbCred { PrincipalName princ = delegatedCreds.getClient(); Realm realm = princ.getRealm(); PrincipalName tgService = delegatedCreds.getServer(); - Realm tgsRealm = tgService.getRealm(); - KrbCredInfo credInfo = new KrbCredInfo(sessionKey, realm, + KrbCredInfo credInfo = new KrbCredInfo(sessionKey, princ, delegatedCreds.flags, delegatedCreds.authTime, delegatedCreds.startTime, delegatedCreds.endTime, - delegatedCreds.renewTill, tgsRealm, tgService, + delegatedCreds.renewTill, tgService, delegatedCreds.cAddr); timeStamp = new KerberosTime(KerberosTime.NOW); @@ -138,19 +137,13 @@ public class KrbCred { KrbCredInfo credInfo = encPart.ticketInfo[0]; EncryptionKey credInfoKey = credInfo.key; - Realm prealm = credInfo.prealm; - // XXX PrincipalName can store realm + principalname or - // just principal name. PrincipalName pname = credInfo.pname; - pname.setRealm(prealm); TicketFlags flags = credInfo.flags; KerberosTime authtime = credInfo.authtime; KerberosTime starttime = credInfo.starttime; KerberosTime endtime = credInfo.endtime; KerberosTime renewTill = credInfo.renewTill; - Realm srealm = credInfo.srealm; PrincipalName sname = credInfo.sname; - sname.setRealm(srealm); HostAddresses caddr = credInfo.caddr; if (DEBUG) { diff --git a/jdk/src/share/classes/sun/security/krb5/KrbException.java b/jdk/src/share/classes/sun/security/krb5/KrbException.java index 5a0b0e730f0..28cff004b04 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbException.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbException.java @@ -45,6 +45,10 @@ public class KrbException extends Exception { super(s); } + public KrbException(Throwable cause) { + super(cause); + } + public KrbException(int i) { returnCode = i; } diff --git a/jdk/src/share/classes/sun/security/krb5/KrbKdcRep.java b/jdk/src/share/classes/sun/security/krb5/KrbKdcRep.java index 78ed1f7f2fb..1100aadf506 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbKdcRep.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbKdcRep.java @@ -35,28 +35,17 @@ import sun.security.krb5.internal.*; abstract class KrbKdcRep { static void check( + boolean isAsReq, KDCReq req, KDCRep rep ) throws KrbApErrException { - if (!req.reqBody.cname.equalsWithoutRealm(rep.cname)) { + if (isAsReq && !req.reqBody.cname.equals(rep.cname)) { rep.encKDCRepPart.key.destroy(); throw new KrbApErrException(Krb5.KRB_AP_ERR_MODIFIED); } - /**** XXX - if (!req.reqBody.crealm.equals(rep.crealm)) { - rep.encKDCRepPart.key.destroy(); - throw new KrbApErrException(Krb5.KRB_AP_ERR_MODIFIED); - } - *****/ - - if (!req.reqBody.sname.equalsWithoutRealm(rep.encKDCRepPart.sname)) { - rep.encKDCRepPart.key.destroy(); - throw new KrbApErrException(Krb5.KRB_AP_ERR_MODIFIED); - } - - if (!req.reqBody.crealm.equals(rep.encKDCRepPart.srealm)) { + if (!req.reqBody.sname.equals(rep.encKDCRepPart.sname)) { rep.encKDCRepPart.key.destroy(); throw new KrbApErrException(Krb5.KRB_AP_ERR_MODIFIED); } @@ -73,7 +62,6 @@ abstract class KrbKdcRep { throw new KrbApErrException(Krb5.KRB_AP_ERR_MODIFIED); } - for (int i = 1; i < 6; i++) { if (req.reqBody.kdcOptions.get(i) != rep.encKDCRepPart.flags.get(i)) { diff --git a/jdk/src/share/classes/sun/security/krb5/KrbPriv.java b/jdk/src/share/classes/sun/security/krb5/KrbPriv.java index bac278884e0..dc2cc0d69d9 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbPriv.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbPriv.java @@ -89,8 +89,7 @@ class KrbPriv extends KrbAppMessage { raddr, timestampRequired, seqNumberRequired, - creds.client, - creds.client.getRealm() + creds.client ); } @@ -151,8 +150,7 @@ class KrbPriv extends KrbAppMessage { HostAddress rAddress, boolean timestampRequired, boolean seqNumberRequired, - PrincipalName cname, - Realm crealm + PrincipalName cname ) throws Asn1Exception, KdcErrException, KrbApErrException, IOException, KrbCryptoException { @@ -172,8 +170,7 @@ class KrbPriv extends KrbAppMessage { rAddress, timestampRequired, seqNumberRequired, - cname, - crealm + cname ); return enc_part.userData; diff --git a/jdk/src/share/classes/sun/security/krb5/KrbSafe.java b/jdk/src/share/classes/sun/security/krb5/KrbSafe.java index addb5c1be42..18c52f361f6 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbSafe.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbSafe.java @@ -90,8 +90,7 @@ class KrbSafe extends KrbAppMessage { raddr, timestampRequired, seqNumberRequired, - creds.client, - creds.client.getRealm() + creds.client ); } @@ -154,8 +153,7 @@ class KrbSafe extends KrbAppMessage { HostAddress rAddress, boolean timestampRequired, boolean seqNumberRequired, - PrincipalName cname, - Realm crealm + PrincipalName cname ) throws Asn1Exception, KdcErrException, KrbApErrException, IOException, KrbCryptoException { @@ -177,8 +175,7 @@ class KrbSafe extends KrbAppMessage { rAddress, timestampRequired, seqNumberRequired, - cname, - crealm + cname ); return krb_safe.safeBody.userData; diff --git a/jdk/src/share/classes/sun/security/krb5/KrbTgsRep.java b/jdk/src/share/classes/sun/security/krb5/KrbTgsRep.java index 5812894de01..27fd55611d5 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbTgsRep.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbTgsRep.java @@ -82,12 +82,11 @@ public class KrbTgsRep extends KrbKdcRep { byte[] enc_tgs_rep_part = rep.encPart.reset(enc_tgs_rep_bytes); ref = new DerValue(enc_tgs_rep_part); EncTGSRepPart enc_part = new EncTGSRepPart(ref); - rep.ticket.sname.setRealm(rep.ticket.realm); rep.encKDCRepPart = enc_part; - check(req, rep); + check(false, req, rep); - creds = new Credentials(rep.ticket, + this.creds = new Credentials(rep.ticket, req.reqBody.cname, rep.ticket.sname, enc_part.key, @@ -99,7 +98,6 @@ public class KrbTgsRep extends KrbKdcRep { enc_part.caddr ); this.rep = rep; - this.creds = creds; this.secondTicket = tgsReq.getSecondTicket(); } diff --git a/jdk/src/share/classes/sun/security/krb5/KrbTgsReq.java b/jdk/src/share/classes/sun/security/krb5/KrbTgsReq.java index 1021a7b10bd..c154ccb7ca0 100644 --- a/jdk/src/share/classes/sun/security/krb5/KrbTgsReq.java +++ b/jdk/src/share/classes/sun/security/krb5/KrbTgsReq.java @@ -148,7 +148,6 @@ public class KrbTgsReq { asCreds.key, ctime, princName, - princName.getRealm(), servName, from, till, @@ -214,7 +213,6 @@ public class KrbTgsReq { EncryptionKey key, KerberosTime ctime, PrincipalName cname, - Realm crealm, PrincipalName sname, KerberosTime from, KerberosTime till, @@ -273,8 +271,6 @@ public class KrbTgsReq { KDCReqBody reqBody = new KDCReqBody( kdc_options, cname, - // crealm, - sname.getRealm(), // TO sname, from, req_till, @@ -315,7 +311,6 @@ public class KrbTgsReq { new APOptions(), ticket, key, - crealm, cname, cksum, ctime, diff --git a/jdk/src/share/classes/sun/security/krb5/PrincipalName.java b/jdk/src/share/classes/sun/security/krb5/PrincipalName.java index d03e2fe3044..2a1e4753729 100644 --- a/jdk/src/share/classes/sun/security/krb5/PrincipalName.java +++ b/jdk/src/share/classes/sun/security/krb5/PrincipalName.java @@ -38,15 +38,25 @@ import java.util.Vector; import java.util.Locale; import java.io.IOException; import java.math.BigInteger; +import java.util.Arrays; import sun.security.krb5.internal.ccache.CCacheOutputStream; import sun.security.krb5.internal.util.KerberosString; /** - * This class encapsulates a Kerberos principal. + * Implements the ASN.1 PrincipalName type and its realm in a single class. + * + * Realm ::= KerberosString + * + * PrincipalName ::= SEQUENCE { + * name-type [0] Int32, + * name-string [1] SEQUENCE OF KerberosString + * } + * + * This class is immutable. + * @see Realm */ -public class PrincipalName - implements Cloneable { +public class PrincipalName implements Cloneable { //name types @@ -80,8 +90,6 @@ public class PrincipalName */ public static final int KRB_NT_UID = 5; - - /** * TGS Name */ @@ -96,98 +104,109 @@ public class PrincipalName public static final String NAME_REALM_SEPARATOR_STR = "@"; public static final String REALM_COMPONENT_SEPARATOR_STR = "."; - private int nameType; - private String[] nameStrings; // Principal names don't mutate often + // Instance fields. - private Realm nameRealm; // optional; a null realm means use default - // Note: the nameRealm is not included in the default ASN.1 encoding + /** + * The name type, from PrincipalName's name-type field. + */ + private final int nameType; - // cached salt, might be changed by KDC info, not used in clone - private String salt = null; + /** + * The name strings, from PrincipalName's name-strings field. This field + * must be neither null nor empty. Each entry of it must also be neither + * null nor empty. Make sure to clone the field when it's passed in or out. + */ + private final String[] nameStrings; - protected PrincipalName() { + /** + * The realm this principal belongs to. + */ + private final Realm nameRealm; // not null + + // cached default salt, not used in clone + private transient String salt = null; + + // There are 3 basic constructors. All other constructors must call them. + // All basic constructors must call validateNameStrings. + // 1. From name components + // 2. From name + // 3. From DER encoding + + /** + * Creates a PrincipalName. + */ + public PrincipalName(int nameType, String[] nameStrings, Realm nameRealm) { + if (nameRealm == null) { + throw new IllegalArgumentException("Null realm not allowed"); + } + validateNameStrings(nameStrings); + this.nameType = nameType; + this.nameStrings = nameStrings.clone(); + this.nameRealm = nameRealm; + } + + // This method is called by Windows NativeCred.c + public PrincipalName(String[] nameParts, String realm) throws RealmException { + this(KRB_NT_UNKNOWN, nameParts, new Realm(realm)); } public PrincipalName(String[] nameParts, int type) - throws IllegalArgumentException, IOException { - if (nameParts == null) { - throw new IllegalArgumentException("Null input not allowed"); - } - nameStrings = new String[nameParts.length]; - System.arraycopy(nameParts, 0, nameStrings, 0, nameParts.length); - nameType = type; - nameRealm = null; + throws IllegalArgumentException, RealmException { + this(type, nameParts, Realm.getDefault()); } - public PrincipalName(String[] nameParts) throws IOException { - this(nameParts, KRB_NT_UNKNOWN); + // Validate a nameStrings argument + private static void validateNameStrings(String[] ns) { + if (ns == null) { + throw new IllegalArgumentException("Null nameStrings not allowed"); + } + if (ns.length == 0) { + throw new IllegalArgumentException("Empty nameStrings not allowed"); + } + for (String s: ns) { + if (s == null) { + throw new IllegalArgumentException("Null nameString not allowed"); + } + if (s.isEmpty()) { + throw new IllegalArgumentException("Empty nameString not allowed"); + } + } } public Object clone() { try { PrincipalName pName = (PrincipalName) super.clone(); - // Re-assign mutable fields - if (nameStrings != null) { - pName.nameStrings = nameStrings.clone(); - } - if (nameRealm != null) { - pName.nameRealm = (Realm)nameRealm.clone(); - } + UNSAFE.putObject(this, NAME_STRINGS_OFFSET, nameStrings.clone()); return pName; } catch (CloneNotSupportedException ex) { throw new AssertionError("Should never happen"); } } - /* - * Added to workaround a bug where the equals method that takes a - * PrincipalName is not being called but Object.equals(Object) is - * being called. - */ + private static final long NAME_STRINGS_OFFSET; + private static final sun.misc.Unsafe UNSAFE; + static { + try { + sun.misc.Unsafe unsafe = sun.misc.Unsafe.getUnsafe(); + NAME_STRINGS_OFFSET = unsafe.objectFieldOffset( + PrincipalName.class.getDeclaredField("nameStrings")); + UNSAFE = unsafe; + } catch (ReflectiveOperationException e) { + throw new Error(e); + } + } + + @Override public boolean equals(Object o) { - if (o instanceof PrincipalName) - return equals((PrincipalName)o); - else - return false; - } - - public boolean equals(PrincipalName other) { - - - if (!equalsWithoutRealm(other)) { - return false; + if (this == o) { + return true; } - - if ((nameRealm != null && other.nameRealm == null) || - (nameRealm == null && other.nameRealm != null)) { - return false; + if (o instanceof PrincipalName) { + PrincipalName other = (PrincipalName)o; + return nameRealm.equals(other.nameRealm) && + Arrays.equals(nameStrings, other.nameStrings); } - - if (nameRealm != null && other.nameRealm != null) { - if (!nameRealm.equals(other.nameRealm)) { - return false; - } - } - - return true; - } - - boolean equalsWithoutRealm(PrincipalName other) { - - if ((nameStrings != null && other.nameStrings == null) || - (nameStrings == null && other.nameStrings != null)) - return false; - - if (nameStrings != null && other.nameStrings != null) { - if (nameStrings.length != other.nameStrings.length) - return false; - for (int i = 0; i < nameStrings.length; i++) - if (!nameStrings[i].equals(other.nameStrings[i])) - return false; - } - - return true; - + return false; } /** @@ -208,20 +227,23 @@ public class PrincipalName * http://www.ietf.org/rfc/rfc4120.txt. * * @param encoding a Der-encoded data. + * @param realm the realm for this name * @exception Asn1Exception if an error occurs while decoding * an ASN1 encoded data. * @exception Asn1Exception if there is an ASN1 encoding error * @exception IOException if an I/O error occurs * @exception IllegalArgumentException if encoding is null * reading encoded data. - * */ - public PrincipalName(DerValue encoding) - throws Asn1Exception, IOException { - nameRealm = null; + public PrincipalName(DerValue encoding, Realm realm) + throws Asn1Exception, IOException { + if (realm == null) { + throw new IllegalArgumentException("Null realm not allowed"); + } + nameRealm = realm; DerValue der; if (encoding == null) { - throw new IllegalArgumentException("Null input not allowed"); + throw new IllegalArgumentException("Null encoding not allowed"); } if (encoding.getTag() != DerValue.tag_Sequence) { throw new Asn1Exception(Krb5.ASN1_BAD_ID); @@ -243,14 +265,12 @@ public class PrincipalName DerValue subSubDer; while(subDer.getData().available() > 0) { subSubDer = subDer.getData().getDerValue(); - v.addElement(new KerberosString(subSubDer).toString()); - } - if (v.size() > 0) { - nameStrings = new String[v.size()]; - v.copyInto(nameStrings); - } else { - nameStrings = new String[] {""}; + String namePart = new KerberosString(subSubDer).toString(); + v.addElement(namePart); } + nameStrings = new String[v.size()]; + v.copyInto(nameStrings); + validateNameStrings(nameStrings); } else { throw new Asn1Exception(Krb5.ASN1_BAD_ID); } @@ -267,32 +287,35 @@ public class PrincipalName * more marshaled value. * @param explicitTag tag number. * @param optional indicate if this data field is optional - * @return an instance of PrincipalName. - * + * @param realm the realm for the name + * @return an instance of PrincipalName, or null if the + * field is optional and missing. */ public static PrincipalName parse(DerInputStream data, byte explicitTag, boolean - optional) - throws Asn1Exception, IOException { + optional, + Realm realm) + throws Asn1Exception, IOException, RealmException { if ((optional) && (((byte)data.peekByte() & (byte)0x1F) != explicitTag)) return null; DerValue der = data.getDerValue(); - if (explicitTag != (der.getTag() & (byte)0x1F)) + if (explicitTag != (der.getTag() & (byte)0x1F)) { throw new Asn1Exception(Krb5.ASN1_BAD_ID); - else { + } else { DerValue subDer = der.getData().getDerValue(); - return new PrincipalName(subDer); + if (realm == null) { + realm = Realm.getDefault(); + } + return new PrincipalName(subDer, realm); } } - // This is protected because the definition of a principal - // string is fixed // XXX Error checkin consistent with MIT krb5_parse_name // Code repetition, realm parsed again by class Realm - protected static String[] parseName(String name) { + private static String[] parseName(String name) { Vector tempStrings = new Vector<>(); String temp = name; @@ -312,13 +335,13 @@ public class PrincipalName continue; } else { - if (componentStart < i) { + if (componentStart <= i) { component = temp.substring(componentStart, i); tempStrings.addElement(component); } componentStart = i + 1; } - } else + } else { if (temp.charAt(i) == NAME_REALM_SEPARATOR) { /* * If this separator is escaped then don't treat it @@ -337,11 +360,11 @@ public class PrincipalName break; } } + } i++; } - if (i == temp.length()) - if (componentStart < i) { + if (i == temp.length()) { component = temp.substring(componentStart, i); tempStrings.addElement(component); } @@ -351,30 +374,26 @@ public class PrincipalName return result; } - public PrincipalName(String name, int type) - throws RealmException { + /** + * Constructs a PrincipalName from a string. + * @param name the name + * @param type the type + * @param realm the realm, null if not known. Note that when realm is not + * null, it will be always used even if there is a realm part in name. When + * realm is null, will read realm part from name, or try to map a realm + * (for KRB_NT_SRV_HST), or use the default realm, or fail + * @throws RealmException + */ + public PrincipalName(String name, int type, String realm) + throws RealmException { if (name == null) { throw new IllegalArgumentException("Null name not allowed"); } String[] nameParts = parseName(name); - Realm tempRealm = null; - String realmString = Realm.parseRealmAtSeparator(name); - - if (realmString == null) { - try { - Config config = Config.getInstance(); - realmString = config.getDefaultRealm(); - } catch (KrbException e) { - RealmException re = - new RealmException(e.getMessage()); - re.initCause(e); - throw re; - } + validateNameStrings(nameParts); + if (realm == null) { + realm = Realm.parseRealmAtSeparator(name); } - - if (realmString != null) - tempRealm = new Realm(realmString); - switch (type) { case KRB_NT_SRV_HST: if (nameParts.length >= 2) { @@ -401,18 +420,22 @@ public class PrincipalName } nameStrings = nameParts; nameType = type; + + if (realm != null) { + nameRealm = new Realm(realm); + } else { // We will try to get realm name from the mapping in // the configuration. If it is not specified // we will use the default realm. This nametype does // not allow a realm to be specified. The name string must of // the form service@host and this is internally changed into // service/host by Kerberos - - String mapRealm = mapHostToRealm(nameParts[1]); - if (mapRealm != null) { - nameRealm = new Realm(mapRealm); - } else { - nameRealm = tempRealm; + String mapRealm = mapHostToRealm(nameParts[1]); + if (mapRealm != null) { + nameRealm = new Realm(mapRealm); + } else { + nameRealm = Realm.getDefault(); + } } break; case KRB_NT_UNKNOWN: @@ -422,20 +445,34 @@ public class PrincipalName case KRB_NT_UID: nameStrings = nameParts; nameType = type; - nameRealm = tempRealm; + if (realm != null) { + nameRealm = new Realm(realm); + } else { + nameRealm = Realm.getDefault(); + } break; default: throw new IllegalArgumentException("Illegal name type"); } } + public PrincipalName(String name, int type) throws RealmException { + this(name, type, (String)null); + } + public PrincipalName(String name) throws RealmException { this(name, KRB_NT_UNKNOWN); } public PrincipalName(String name, String realm) throws RealmException { - this(name, KRB_NT_UNKNOWN); - nameRealm = new Realm(realm); + this(name, KRB_NT_UNKNOWN, realm); + } + + public static PrincipalName tgsService(String r1, String r2) + throws KrbException { + return new PrincipalName(PrincipalName.KRB_NT_SRV_INST, + new String[] {PrincipalName.TGS_DEFAULT_SRV_NAME, r1}, + new Realm(r2)); } public String getRealmAsString() { @@ -475,29 +512,17 @@ public class PrincipalName } public String getRealmString() { - if (nameRealm != null) - return nameRealm.toString(); - return null; + return nameRealm.toString(); } public Realm getRealm() { return nameRealm; } - public void setRealm(Realm new_nameRealm) throws RealmException { - nameRealm = new_nameRealm; - } - - public void setRealm(String realmsString) throws RealmException { - nameRealm = new Realm(realmsString); - } - public String getSalt() { if (salt == null) { StringBuffer salt = new StringBuffer(); - if (nameRealm != null) { - salt.append(nameRealm.toString()); - } + salt.append(nameRealm.toString()); for (int i = 0; i < nameStrings.length; i++) { salt.append(nameStrings[i]); } @@ -513,11 +538,8 @@ public class PrincipalName str.append("/"); str.append(nameStrings[i]); } - if (nameRealm != null) { - str.append("@"); - str.append(nameRealm.toString()); - } - + str.append("@"); + str.append(nameRealm.toString()); return str.toString(); } @@ -532,7 +554,8 @@ public class PrincipalName } /** - * Encodes a PrincipalName object. + * Encodes a PrincipalName object. Note that only the type and + * names are encoded. To encode the realm, call getRealm().asn1Encode(). * @return the byte array of the encoded PrncipalName object. * @exception Asn1Exception if an error occurs while decoding an ASN1 encoded data. * @exception IOException if an I/O error occurs while reading encoded data. @@ -597,12 +620,10 @@ public class PrincipalName public void writePrincipal(CCacheOutputStream cos) throws IOException { cos.write32(nameType); cos.write32(nameStrings.length); - if (nameRealm != null) { - byte[] realmBytes = null; - realmBytes = nameRealm.toString().getBytes(); - cos.write32(realmBytes.length); - cos.write(realmBytes, 0, realmBytes.length); - } + byte[] realmBytes = null; + realmBytes = nameRealm.toString().getBytes(); + cos.write32(realmBytes.length); + cos.write(realmBytes, 0, realmBytes.length); byte[] bytes = null; for (int i = 0; i < nameStrings.length; i++) { bytes = nameStrings[i].getBytes(); @@ -611,31 +632,6 @@ public class PrincipalName } } - /** - * Creates a KRB_NT_SRV_INST name from the supplied - * name components and realm. - * @param primary the primary component of the name - * @param instance the instance component of the name - * @param realm the realm - * @throws KrbException - */ - protected PrincipalName(String primary, String instance, String realm, - int type) - throws KrbException { - - if (type != KRB_NT_SRV_INST) { - throw new KrbException(Krb5.KRB_ERR_GENERIC, "Bad name type"); - } - - String[] nParts = new String[2]; - nParts[0] = primary; - nParts[1] = instance; - - this.nameStrings = nParts; - this.nameRealm = new Realm(realm); - this.nameType = type; - } - /** * Returns the instance component of a name. * In a multi-component name such as a KRB_NT_SRV_INST diff --git a/jdk/src/share/classes/sun/security/krb5/Realm.java b/jdk/src/share/classes/sun/security/krb5/Realm.java index f148f868049..bfb43e757a4 100644 --- a/jdk/src/share/classes/sun/security/krb5/Realm.java +++ b/jdk/src/share/classes/sun/security/krb5/Realm.java @@ -46,24 +46,29 @@ import sun.security.krb5.internal.util.KerberosString; * * Realm ::= GeneralString * + * This class is immutable. */ public class Realm implements Cloneable { - private String realm; + private final String realm; // not null nor empty private static boolean DEBUG = Krb5.DEBUG; - private Realm() { - } - public Realm(String name) throws RealmException { realm = parseRealm(name); } - public Object clone() { - Realm new_realm = new Realm(); - if (realm != null) { - new_realm.realm = new String(realm); + public static Realm getDefault() throws RealmException { + try { + return new Realm(Config.getInstance().getDefaultRealm()); + } catch (RealmException re) { + throw re; + } catch (KrbException ke) { + throw new RealmException(ke); } - return new_realm; + } + + // Immutable class, no need to clone + public Object clone() { + return this; } public boolean equals(Object obj) { @@ -76,21 +81,11 @@ public class Realm implements Cloneable { } Realm that = (Realm)obj; - if (this.realm != null && that.realm != null ) { - return this.realm.equals(that.realm); - } else { - return (this.realm == null && that.realm == null); - } + return this.realm.equals(that.realm); } public int hashCode() { - int result = 17 ; - - if( realm != null ) { - result = 37 * result + realm.hashCode(); - } - - return result; + return realm.hashCode(); } /** @@ -116,6 +111,7 @@ public class Realm implements Cloneable { return realm; } + // Extract realm from a string like dummy@REALM public static String parseRealmAtSeparator(String name) throws RealmException { if (name == null) { @@ -128,8 +124,12 @@ public class Realm implements Cloneable { while (i < temp.length()) { if (temp.charAt(i) == PrincipalName.NAME_REALM_SEPARATOR) { if (i == 0 || temp.charAt(i - 1) != '\\') { - if (i + 1 < temp.length()) + if (i + 1 < temp.length()) { result = temp.substring(i + 1, temp.length()); + } else { + throw new IllegalArgumentException + ("empty realm part not allowed"); + } break; } } @@ -219,7 +219,8 @@ public class Realm implements Cloneable { * @return an instance of Realm. * */ - public static Realm parse(DerInputStream data, byte explicitTag, boolean optional) throws Asn1Exception, IOException, RealmException { + public static Realm parse(DerInputStream data, byte explicitTag, boolean optional) + throws Asn1Exception, IOException, RealmException { if ((optional) && (((byte)data.peekByte() & (byte)0x1F) != explicitTag)) { return null; } diff --git a/jdk/src/share/classes/sun/security/krb5/RealmException.java b/jdk/src/share/classes/sun/security/krb5/RealmException.java index ccd7a230258..13c6caed66c 100644 --- a/jdk/src/share/classes/sun/security/krb5/RealmException.java +++ b/jdk/src/share/classes/sun/security/krb5/RealmException.java @@ -47,4 +47,7 @@ public class RealmException extends KrbException { super(i,s); } + public RealmException(Throwable cause) { + super(cause); + } } diff --git a/jdk/src/share/classes/sun/security/krb5/ServiceName.java b/jdk/src/share/classes/sun/security/krb5/ServiceName.java deleted file mode 100644 index 7bbaff2c9d3..00000000000 --- a/jdk/src/share/classes/sun/security/krb5/ServiceName.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the "Classpath" exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * - * (C) Copyright IBM Corp. 1999 All Rights Reserved. - * Copyright 1997 The Open Group Research Institute. All rights reserved. - */ - -package sun.security.krb5; - -import java.net.InetAddress; -import java.net.UnknownHostException; - -public class ServiceName extends PrincipalName { - - public ServiceName(String name, int type) throws RealmException { - super(name, type); - - } - public ServiceName(String name) throws RealmException { - this(name, PrincipalName.KRB_NT_UNKNOWN); - } - - public ServiceName(String name, String realm) throws RealmException { - this(name, PrincipalName.KRB_NT_UNKNOWN); - setRealm(realm); - } - - public ServiceName (String service, String instance, String realm) - throws KrbException - { - super(service, instance, realm, PrincipalName.KRB_NT_SRV_INST); - } - -} diff --git a/jdk/src/share/classes/sun/security/krb5/internal/ASRep.java b/jdk/src/share/classes/sun/security/krb5/internal/ASRep.java index fd4d8cea0d2..063d2cc427c 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/ASRep.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/ASRep.java @@ -42,11 +42,10 @@ public class ASRep extends KDCRep { public ASRep( PAData[] new_pAData, - Realm new_crealm, PrincipalName new_cname, Ticket new_ticket, EncryptedData new_encPart) throws IOException { - super(new_pAData, new_crealm, new_cname, new_ticket, + super(new_pAData, new_cname, new_ticket, new_encPart, Krb5.KRB_AS_REP); } diff --git a/jdk/src/share/classes/sun/security/krb5/internal/Authenticator.java b/jdk/src/share/classes/sun/security/krb5/internal/Authenticator.java index 67f70387a99..622013553e0 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/Authenticator.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/Authenticator.java @@ -61,7 +61,6 @@ import java.math.BigInteger; public class Authenticator { public int authenticator_vno; - public Realm crealm; public PrincipalName cname; Checksum cksum; //optional public int cusec; @@ -71,7 +70,6 @@ public class Authenticator { public AuthorizationData authorizationData; //optional public Authenticator( - Realm new_crealm, PrincipalName new_cname, Checksum new_cksum, int new_cusec, @@ -80,7 +78,6 @@ public class Authenticator { Integer new_seqNumber, AuthorizationData new_authorizationData) { authenticator_vno = Krb5.AUTHNETICATOR_VNO; - crealm = new_crealm; cname = new_cname; cksum = new_cksum; cusec = new_cusec; @@ -131,8 +128,8 @@ public class Authenticator { if (authenticator_vno != 5) { throw new KrbApErrException(Krb5.KRB_AP_ERR_BADVERSION); } - crealm = Realm.parse(der.getData(), (byte) 0x01, false); - cname = PrincipalName.parse(der.getData(), (byte) 0x02, false); + Realm crealm = Realm.parse(der.getData(), (byte) 0x01, false); + cname = PrincipalName.parse(der.getData(), (byte) 0x02, false, crealm); cksum = Checksum.parse(der.getData(), (byte) 0x03, true); subDer = der.getData().getDerValue(); if ((subDer.getTag() & (byte) 0x1F) == 0x04) { @@ -180,7 +177,7 @@ public class Authenticator { DerOutputStream temp = new DerOutputStream(); temp.putInteger(BigInteger.valueOf(authenticator_vno)); v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte) 0x00), temp.toByteArray())); - v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte) 0x01), crealm.asn1Encode())); + v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte) 0x01), cname.getRealm().asn1Encode())); v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte) 0x02), cname.asn1Encode())); if (cksum != null) { v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte) 0x03), cksum.asn1Encode())); diff --git a/jdk/src/share/classes/sun/security/krb5/internal/CredentialsUtil.java b/jdk/src/share/classes/sun/security/krb5/internal/CredentialsUtil.java index 3b3dacb30ac..cb059ab22c5 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/CredentialsUtil.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/CredentialsUtil.java @@ -72,23 +72,9 @@ rs. public static Credentials acquireServiceCreds( String service, Credentials ccreds) throws KrbException, IOException { - ServiceName sname = new ServiceName(service); + PrincipalName sname = new PrincipalName(service); String serviceRealm = sname.getRealmString(); String localRealm = ccreds.getClient().getRealmString(); - String defaultRealm = Config.getInstance().getDefaultRealm(); - - if (localRealm == null) { - PrincipalName temp = null; - if ((temp = ccreds.getServer()) != null) - localRealm = temp.getRealmString(); - } - if (localRealm == null) { - localRealm = defaultRealm; - } - if (serviceRealm == null) { - serviceRealm = localRealm; - sname.setRealm(serviceRealm); - } /* if (!localRealm.equalsIgnoreCase(serviceRealm)) { //do cross-realm auth entication @@ -128,13 +114,12 @@ rs. int i = 0, k = 0; Credentials cTgt = null, newTgt = null, theTgt = null; - ServiceName tempService = null; + PrincipalName tempService = null; String realm = null, newTgtRealm = null, theTgtRealm = null; for (cTgt = ccreds, i = 0; i < realms.length;) { - tempService = new ServiceName(PrincipalName.TGS_DEFAULT_SRV_NAME, - serviceRealm, realms[i]); + tempService = PrincipalName.tgsService(serviceRealm, realms[i]); if (DEBUG) { @@ -164,9 +149,7 @@ rs. newTgt == null && k > i; k--) { - tempService = new ServiceName( - PrincipalName.TGS_DEFAULT_SRV_NAME, - realms[k], realms[i]); + tempService = PrincipalName.tgsService(realms[k], realms[i]); if (DEBUG) { System.out.println(">>> Credentials acquireServiceCreds: inner loop: [" + k +"] tempService=" + tempService); @@ -306,7 +289,7 @@ rs. * This method does the real job to request the service credential. */ private static Credentials serviceCreds( - ServiceName service, Credentials ccreds) + PrincipalName service, Credentials ccreds) throws KrbException, IOException { return new KrbTgsReq(ccreds, service).sendAndGetCreds(); } diff --git a/jdk/src/share/classes/sun/security/krb5/internal/EncASRepPart.java b/jdk/src/share/classes/sun/security/krb5/internal/EncASRepPart.java index 7a8f3446704..7e5d037de5d 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/EncASRepPart.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/EncASRepPart.java @@ -46,7 +46,6 @@ public class EncASRepPart extends EncKDCRepPart { KerberosTime new_starttime, KerberosTime new_endtime, KerberosTime new_renewTill, - Realm new_srealm, PrincipalName new_sname, HostAddresses new_caddr) { super( @@ -59,7 +58,6 @@ public class EncASRepPart extends EncKDCRepPart { new_starttime, new_endtime, new_renewTill, - new_srealm, new_sname, new_caddr, Krb5.KRB_ENC_AS_REP_PART diff --git a/jdk/src/share/classes/sun/security/krb5/internal/EncKDCRepPart.java b/jdk/src/share/classes/sun/security/krb5/internal/EncKDCRepPart.java index 244af0e64a6..943869d60b8 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/EncKDCRepPart.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/EncKDCRepPart.java @@ -74,7 +74,6 @@ public class EncKDCRepPart { public KerberosTime starttime; //optional public KerberosTime endtime; public KerberosTime renewTill; //optional - public Realm srealm; public PrincipalName sname; public HostAddresses caddr; //optional public int msgType; //not included in sequence @@ -89,7 +88,6 @@ public class EncKDCRepPart { KerberosTime new_starttime, KerberosTime new_endtime, KerberosTime new_renewTill, - Realm new_srealm, PrincipalName new_sname, HostAddresses new_caddr, int new_msgType) { @@ -102,7 +100,6 @@ public class EncKDCRepPart { starttime = new_starttime; endtime = new_endtime; renewTill = new_renewTill; - srealm = new_srealm; sname = new_sname; caddr = new_caddr; msgType = new_msgType; @@ -158,8 +155,8 @@ public class EncKDCRepPart { starttime = KerberosTime.parse(der.getData(), (byte) 0x06, true); endtime = KerberosTime.parse(der.getData(), (byte) 0x07, false); renewTill = KerberosTime.parse(der.getData(), (byte) 0x08, true); - srealm = Realm.parse(der.getData(), (byte) 0x09, false); - sname = PrincipalName.parse(der.getData(), (byte) 0x0A, false); + Realm srealm = Realm.parse(der.getData(), (byte) 0x09, false); + sname = PrincipalName.parse(der.getData(), (byte) 0x0A, false, srealm); if (der.getData().available() > 0) { caddr = HostAddresses.parse(der.getData(), (byte) 0x0B, true); } @@ -206,7 +203,7 @@ public class EncKDCRepPart { true, (byte) 0x08), renewTill.asn1Encode()); } bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, - true, (byte) 0x09), srealm.asn1Encode()); + true, (byte) 0x09), sname.getRealm().asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte) 0x0A), sname.asn1Encode()); if (caddr != null) { diff --git a/jdk/src/share/classes/sun/security/krb5/internal/EncTGSRepPart.java b/jdk/src/share/classes/sun/security/krb5/internal/EncTGSRepPart.java index 8770bc45a6e..cdca881ebe4 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/EncTGSRepPart.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/EncTGSRepPart.java @@ -45,7 +45,6 @@ public class EncTGSRepPart extends EncKDCRepPart { KerberosTime new_starttime, KerberosTime new_endtime, KerberosTime new_renewTill, - Realm new_srealm, PrincipalName new_sname, HostAddresses new_caddr) { super( @@ -58,7 +57,6 @@ public class EncTGSRepPart extends EncKDCRepPart { new_starttime, new_endtime, new_renewTill, - new_srealm, new_sname, new_caddr, Krb5.KRB_ENC_TGS_REP_PART); diff --git a/jdk/src/share/classes/sun/security/krb5/internal/EncTicketPart.java b/jdk/src/share/classes/sun/security/krb5/internal/EncTicketPart.java index 240e2d1f5b3..3b43f606214 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/EncTicketPart.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/EncTicketPart.java @@ -65,7 +65,6 @@ public class EncTicketPart { public TicketFlags flags; public EncryptionKey key; - public Realm crealm; public PrincipalName cname; public TransitedEncoding transited; public KerberosTime authtime; @@ -78,7 +77,6 @@ public class EncTicketPart { public EncTicketPart( TicketFlags new_flags, EncryptionKey new_key, - Realm new_crealm, PrincipalName new_cname, TransitedEncoding new_transited, KerberosTime new_authtime, @@ -89,7 +87,6 @@ public class EncTicketPart { AuthorizationData new_authorizationData) { flags = new_flags; key = new_key; - crealm = new_crealm; cname = new_cname; transited = new_transited; authtime = new_authtime; @@ -151,8 +148,8 @@ public class EncTicketPart { } flags = TicketFlags.parse(der.getData(), (byte) 0x00, false); key = EncryptionKey.parse(der.getData(), (byte) 0x01, false); - crealm = Realm.parse(der.getData(), (byte) 0x02, false); - cname = PrincipalName.parse(der.getData(), (byte) 0x03, false); + Realm crealm = Realm.parse(der.getData(), (byte) 0x02, false); + cname = PrincipalName.parse(der.getData(), (byte) 0x03, false, crealm); transited = TransitedEncoding.parse(der.getData(), (byte) 0x04, false); authtime = KerberosTime.parse(der.getData(), (byte) 0x05, false); starttime = KerberosTime.parse(der.getData(), (byte) 0x06, true); @@ -186,7 +183,7 @@ public class EncTicketPart { bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte) 0x01), key.asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, - true, (byte) 0x02), crealm.asn1Encode()); + true, (byte) 0x02), cname.getRealm().asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte) 0x03), cname.asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, diff --git a/jdk/src/share/classes/sun/security/krb5/internal/KDCRep.java b/jdk/src/share/classes/sun/security/krb5/internal/KDCRep.java index 5ff8da2e3aa..5c4ca1e8f0d 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/KDCRep.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/KDCRep.java @@ -61,7 +61,6 @@ import java.math.BigInteger; */ public class KDCRep { - public Realm crealm; public PrincipalName cname; public Ticket ticket; public EncryptedData encPart; @@ -73,7 +72,6 @@ public class KDCRep { public KDCRep( PAData[] new_pAData, - Realm new_crealm, PrincipalName new_cname, Ticket new_ticket, EncryptedData new_encPart, @@ -90,7 +88,6 @@ public class KDCRep { } } } - crealm = new_crealm; cname = new_cname; ticket = new_ticket; encPart = new_encPart; @@ -174,8 +171,8 @@ public class KDCRep { } else { pAData = null; } - crealm = Realm.parse(der.getData(), (byte) 0x03, false); - cname = PrincipalName.parse(der.getData(), (byte) 0x04, false); + Realm crealm = Realm.parse(der.getData(), (byte) 0x03, false); + cname = PrincipalName.parse(der.getData(), (byte) 0x04, false, crealm); ticket = Ticket.parse(der.getData(), (byte) 0x05, false); encPart = EncryptedData.parse(der.getData(), (byte) 0x06, false); if (der.getData().available() > 0) { @@ -212,7 +209,7 @@ public class KDCRep { true, (byte) 0x02), temp); } bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, - true, (byte) 0x03), crealm.asn1Encode()); + true, (byte) 0x03), cname.getRealm().asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte) 0x04), cname.asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, diff --git a/jdk/src/share/classes/sun/security/krb5/internal/KDCReqBody.java b/jdk/src/share/classes/sun/security/krb5/internal/KDCReqBody.java index a23d452885d..83178b6cc4c 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/KDCReqBody.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/KDCReqBody.java @@ -72,7 +72,6 @@ import java.math.BigInteger; public class KDCReqBody { public KDCOptions kdcOptions; public PrincipalName cname; //optional in ASReq only - public Realm crealm; public PrincipalName sname; //optional public KerberosTime from; //optional public KerberosTime till; @@ -87,7 +86,6 @@ public class KDCReqBody { public KDCReqBody( KDCOptions new_kdcOptions, PrincipalName new_cname, //optional in ASReq only - Realm new_crealm, PrincipalName new_sname, //optional KerberosTime new_from, //optional KerberosTime new_till, @@ -100,7 +98,6 @@ public class KDCReqBody { ) throws IOException { kdcOptions = new_kdcOptions; cname = new_cname; - crealm = new_crealm; sname = new_sname; from = new_from; till = new_till; @@ -142,12 +139,22 @@ public class KDCReqBody { throw new Asn1Exception(Krb5.ASN1_BAD_ID); } kdcOptions = KDCOptions.parse(encoding.getData(), (byte)0x00, false); - cname = PrincipalName.parse(encoding.getData(), (byte)0x01, true); + + // cname only appears in AS-REQ and it shares the realm field with + // sname. This is the only place where realm comes after the name. + // We first give cname a fake realm and reassign it the correct + // realm after the realm field is read. + cname = PrincipalName.parse(encoding.getData(), (byte)0x01, true, + new Realm("PLACEHOLDER")); if ((msgType != Krb5.KRB_AS_REQ) && (cname != null)) { throw new Asn1Exception(Krb5.ASN1_BAD_ID); } - crealm = Realm.parse(encoding.getData(), (byte)0x02, false); - sname = PrincipalName.parse(encoding.getData(), (byte)0x03, true); + Realm realm = Realm.parse(encoding.getData(), (byte)0x02, false); + if (cname != null) { + cname = new PrincipalName( + cname.getNameType(), cname.getNameStrings(), realm); + } + sname = PrincipalName.parse(encoding.getData(), (byte)0x03, true, realm); from = KerberosTime.parse(encoding.getData(), (byte)0x04, true); till = KerberosTime.parse(encoding.getData(), (byte)0x05, false); rtime = KerberosTime.parse(encoding.getData(), (byte)0x06, true); @@ -223,9 +230,11 @@ public class KDCReqBody { v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x01), cname.asn1Encode())); } } - v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x02), crealm.asn1Encode())); if (sname != null) { + v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x02), sname.getRealm().asn1Encode())); v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x03), sname.asn1Encode())); + } else if (cname != null) { + v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x02), cname.getRealm().asn1Encode())); } if (from != null) { v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x04), from.asn1Encode())); diff --git a/jdk/src/share/classes/sun/security/krb5/internal/KRBError.java b/jdk/src/share/classes/sun/security/krb5/internal/KRBError.java index a8b117ebc67..f22719a2f88 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/KRBError.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/KRBError.java @@ -90,9 +90,7 @@ public class KRBError implements java.io.Serializable { private KerberosTime sTime; private Integer suSec; private int errorCode; - private Realm crealm; //optional private PrincipalName cname; //optional - private Realm realm; private PrincipalName sname; private String eText; //optional private byte[] eData; //optional @@ -128,9 +126,7 @@ public class KRBError implements java.io.Serializable { KerberosTime new_sTime, Integer new_suSec, int new_errorCode, - Realm new_crealm, PrincipalName new_cname, - Realm new_realm, PrincipalName new_sname, String new_eText, byte[] new_eData @@ -142,9 +138,7 @@ public class KRBError implements java.io.Serializable { sTime = new_sTime; suSec = new_suSec; errorCode = new_errorCode; - crealm = new_crealm; cname = new_cname; - realm = new_realm; sname = new_sname; eText = new_eText; eData = new_eData; @@ -159,9 +153,7 @@ public class KRBError implements java.io.Serializable { KerberosTime new_sTime, Integer new_suSec, int new_errorCode, - Realm new_crealm, PrincipalName new_cname, - Realm new_realm, PrincipalName new_sname, String new_eText, byte[] new_eData, @@ -174,9 +166,7 @@ public class KRBError implements java.io.Serializable { sTime = new_sTime; suSec = new_suSec; errorCode = new_errorCode; - crealm = new_crealm; cname = new_cname; - realm = new_realm; sname = new_sname; eText = new_eText; eData = new_eData; @@ -359,10 +349,10 @@ public class KRBError implements java.io.Serializable { errorCode = subDer.getData().getBigInteger().intValue(); } else throw new Asn1Exception(Krb5.ASN1_BAD_ID); - crealm = Realm.parse(der.getData(), (byte)0x07, true); - cname = PrincipalName.parse(der.getData(), (byte)0x08, true); - realm = Realm.parse(der.getData(), (byte)0x09, false); - sname = PrincipalName.parse(der.getData(), (byte)0x0A, false); + Realm crealm = Realm.parse(der.getData(), (byte)0x07, true); + cname = PrincipalName.parse(der.getData(), (byte)0x08, true, crealm); + Realm realm = Realm.parse(der.getData(), (byte)0x09, false); + sname = PrincipalName.parse(der.getData(), (byte)0x0A, false, realm); eText = null; eData = null; eCksum = null; @@ -403,15 +393,9 @@ public class KRBError implements java.io.Serializable { System.out.println("\t suSec is " + suSec); System.out.println("\t error code is " + errorCode); System.out.println("\t error Message is " + Krb5.getErrorMessage(errorCode)); - if (crealm != null) { - System.out.println("\t crealm is " + crealm.toString()); - } if (cname != null) { System.out.println("\t cname is " + cname.toString()); } - if (realm != null) { - System.out.println("\t realm is " + realm.toString()); - } if (sname != null) { System.out.println("\t sname is " + sname.toString()); } @@ -458,14 +442,12 @@ public class KRBError implements java.io.Serializable { temp.putInteger(BigInteger.valueOf(errorCode)); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x06), temp); - if (crealm != null) { - bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x07), crealm.asn1Encode()); - } if (cname != null) { + bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x07), cname.getRealm().asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x08), cname.asn1Encode()); } - bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x09), realm.asn1Encode()); + bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x09), sname.getRealm().asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x0A), sname.asn1Encode()); if (eText != null) { @@ -506,9 +488,7 @@ public class KRBError implements java.io.Serializable { isEqual(sTime, other.sTime) && isEqual(suSec, other.suSec) && errorCode == other.errorCode && - isEqual(crealm, other.crealm) && isEqual(cname, other.cname) && - isEqual(realm, other.realm) && isEqual(sname, other.sname) && isEqual(eText, other.eText) && java.util.Arrays.equals(eData, other.eData) && @@ -528,9 +508,7 @@ public class KRBError implements java.io.Serializable { if (sTime != null) result = 37 * result + sTime.hashCode(); if (suSec != null) result = 37 * result + suSec.hashCode(); result = 37 * result + errorCode; - if (crealm != null) result = 37 * result + crealm.hashCode(); if (cname != null) result = 37 * result + cname.hashCode(); - if (realm != null) result = 37 * result + realm.hashCode(); if (sname != null) result = 37 * result + sname.hashCode(); if (eText != null) result = 37 * result + eText.hashCode(); result = 37 * result + Arrays.hashCode(eData); diff --git a/jdk/src/share/classes/sun/security/krb5/internal/KrbCredInfo.java b/jdk/src/share/classes/sun/security/krb5/internal/KrbCredInfo.java index 63ebe03d3c6..4acf451cc6c 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/KrbCredInfo.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/KrbCredInfo.java @@ -63,14 +63,12 @@ import java.io.IOException; public class KrbCredInfo { public EncryptionKey key; - public Realm prealm; //optional public PrincipalName pname; //optional public TicketFlags flags; //optional public KerberosTime authtime; //optional public KerberosTime starttime; //optional public KerberosTime endtime; //optional public KerberosTime renewTill; //optional - public Realm srealm; //optional public PrincipalName sname; //optional public HostAddresses caddr; //optional @@ -79,26 +77,22 @@ public class KrbCredInfo { public KrbCredInfo( EncryptionKey new_key, - Realm new_prealm, PrincipalName new_pname, TicketFlags new_flags, KerberosTime new_authtime, KerberosTime new_starttime, KerberosTime new_endtime, KerberosTime new_renewTill, - Realm new_srealm, PrincipalName new_sname, HostAddresses new_caddr ) { key = new_key; - prealm = new_prealm; pname = new_pname; flags = new_flags; authtime = new_authtime; starttime = new_starttime; endtime = new_endtime; renewTill = new_renewTill; - srealm = new_srealm; sname = new_sname; caddr = new_caddr; } @@ -115,21 +109,20 @@ public class KrbCredInfo { if (encoding.getTag() != DerValue.tag_Sequence) { throw new Asn1Exception(Krb5.ASN1_BAD_ID); } - prealm = null; pname = null; flags = null; authtime = null; starttime = null; endtime = null; renewTill = null; - srealm = null; sname = null; caddr = null; key = EncryptionKey.parse(encoding.getData(), (byte)0x00, false); + Realm prealm = null, srealm = null; if (encoding.getData().available() > 0) prealm = Realm.parse(encoding.getData(), (byte)0x01, true); if (encoding.getData().available() > 0) - pname = PrincipalName.parse(encoding.getData(), (byte)0x02, true); + pname = PrincipalName.parse(encoding.getData(), (byte)0x02, true, prealm); if (encoding.getData().available() > 0) flags = TicketFlags.parse(encoding.getData(), (byte)0x03, true); if (encoding.getData().available() > 0) @@ -143,7 +136,7 @@ public class KrbCredInfo { if (encoding.getData().available() > 0) srealm = Realm.parse(encoding.getData(), (byte)0x08, true); if (encoding.getData().available() > 0) - sname = PrincipalName.parse(encoding.getData(), (byte)0x09, true); + sname = PrincipalName.parse(encoding.getData(), (byte)0x09, true, srealm); if (encoding.getData().available() > 0) caddr = HostAddresses.parse(encoding.getData(), (byte)0x0A, true); if (encoding.getData().available() > 0) @@ -159,10 +152,10 @@ public class KrbCredInfo { public byte[] asn1Encode() throws Asn1Exception, IOException { Vector v = new Vector<>(); v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x00), key.asn1Encode())); - if (prealm != null) - v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x01), prealm.asn1Encode())); - if (pname != null) + if (pname != null) { + v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x01), pname.getRealm().asn1Encode())); v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x02), pname.asn1Encode())); + } if (flags != null) v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x03), flags.asn1Encode())); if (authtime != null) @@ -173,10 +166,10 @@ public class KrbCredInfo { v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x06), endtime.asn1Encode())); if (renewTill != null) v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x07), renewTill.asn1Encode())); - if (srealm != null) - v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x08), srealm.asn1Encode())); - if (sname != null) + if (sname != null) { + v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x08), sname.getRealm().asn1Encode())); v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x09), sname.asn1Encode())); + } if (caddr != null) v.addElement(new DerValue(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x0A), caddr.asn1Encode())); DerValue der[] = new DerValue[v.size()]; @@ -190,8 +183,6 @@ public class KrbCredInfo { KrbCredInfo kcred = new KrbCredInfo(); kcred.key = (EncryptionKey)key.clone(); // optional fields - if (prealm != null) - kcred.prealm = (Realm)prealm.clone(); if (pname != null) kcred.pname = (PrincipalName)pname.clone(); if (flags != null) @@ -204,8 +195,6 @@ public class KrbCredInfo { kcred.endtime = (KerberosTime)endtime.clone(); if (renewTill != null) kcred.renewTill = (KerberosTime)renewTill.clone(); - if (srealm != null) - kcred.srealm = (Realm)srealm.clone(); if (sname != null) kcred.sname = (PrincipalName)sname.clone(); if (caddr != null) diff --git a/jdk/src/share/classes/sun/security/krb5/internal/TGSRep.java b/jdk/src/share/classes/sun/security/krb5/internal/TGSRep.java index 62bb06ed15c..3defc39ad95 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/TGSRep.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/TGSRep.java @@ -42,12 +42,11 @@ public class TGSRep extends KDCRep { public TGSRep( PAData[] new_pAData, - Realm new_crealm, PrincipalName new_cname, Ticket new_ticket, EncryptedData new_encPart ) throws IOException { - super(new_pAData, new_crealm, new_cname, new_ticket, + super(new_pAData, new_cname, new_ticket, new_encPart, Krb5.KRB_TGS_REP); } diff --git a/jdk/src/share/classes/sun/security/krb5/internal/Ticket.java b/jdk/src/share/classes/sun/security/krb5/internal/Ticket.java index cadb334d0ae..0f1c3d9af15 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/Ticket.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/Ticket.java @@ -60,7 +60,6 @@ import java.math.BigInteger; public class Ticket implements Cloneable { public int tkt_vno; - public Realm realm; public PrincipalName sname; public EncryptedData encPart; @@ -69,7 +68,6 @@ public class Ticket implements Cloneable { public Object clone() { Ticket new_ticket = new Ticket(); - new_ticket.realm = (Realm)realm.clone(); new_ticket.sname = (PrincipalName)sname.clone(); new_ticket.encPart = (EncryptedData)encPart.clone(); new_ticket.tkt_vno = tkt_vno; @@ -77,12 +75,10 @@ public class Ticket implements Cloneable { } public Ticket( - Realm new_realm, PrincipalName new_sname, EncryptedData new_encPart ) { tkt_vno = Krb5.TICKET_VNO; - realm = new_realm; sname = new_sname; encPart = new_encPart; } @@ -123,8 +119,8 @@ public class Ticket implements Cloneable { tkt_vno = subDer.getData().getBigInteger().intValue(); if (tkt_vno != Krb5.TICKET_VNO) throw new KrbApErrException(Krb5.KRB_AP_ERR_BADVERSION); - realm = Realm.parse(der.getData(), (byte)0x01, false); - sname = PrincipalName.parse(der.getData(), (byte)0x02, false); + Realm srealm = Realm.parse(der.getData(), (byte)0x01, false); + sname = PrincipalName.parse(der.getData(), (byte)0x02, false, srealm); encPart = EncryptedData.parse(der.getData(), (byte)0x03, false); if (der.getData().available() > 0) throw new Asn1Exception(Krb5.ASN1_BAD_ID); @@ -142,7 +138,7 @@ public class Ticket implements Cloneable { DerValue der[] = new DerValue[4]; temp.putInteger(BigInteger.valueOf(tkt_vno)); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x00), temp); - bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x01), realm.asn1Encode()); + bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x01), sname.getRealm().asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x02), sname.asn1Encode()); bytes.write(DerValue.createTag(DerValue.TAG_CONTEXT, true, (byte)0x03), encPart.asn1Encode()); temp = new DerOutputStream(); diff --git a/jdk/src/share/classes/sun/security/krb5/internal/ccache/CCacheInputStream.java b/jdk/src/share/classes/sun/security/krb5/internal/ccache/CCacheInputStream.java index ef7088f371b..2f35f894cf2 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/ccache/CCacheInputStream.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/ccache/CCacheInputStream.java @@ -114,7 +114,6 @@ public class CCacheInputStream extends KrbDataInputStream implements FileCCacheC // made public for KinitOptions to call directly public PrincipalName readPrincipal(int version) throws IOException, RealmException { int type, length, namelength, kret; - PrincipalName p; String[] pname = null; String realm; /* Read principal type */ @@ -144,11 +143,13 @@ public class CCacheInputStream extends KrbDataInputStream implements FileCCacheC realm = result[0]; pname = new String[length]; System.arraycopy(result, 1, pname, 0, length); - p = new PrincipalName(pname, type); - p.setRealm(realm); + return new PrincipalName(type, pname, new Realm(realm)); + } + try { + return new PrincipalName(result, type); + } catch (RealmException re) { + return null; } - else p = new PrincipalName(result, type); - return p; } /* @@ -342,10 +343,10 @@ public class CCacheInputStream extends KrbDataInputStream implements FileCCacheC Credentials readCred(int version) throws IOException,RealmException, KrbApErrException, Asn1Exception { PrincipalName cpname = readPrincipal(version); if (DEBUG) - System.out.println(">>>DEBUG client principal is " + cpname.toString()); + System.out.println(">>>DEBUG client principal is " + cpname); PrincipalName spname = readPrincipal(version); if (DEBUG) - System.out.println(">>>DEBUG server principal is " + spname.toString()); + System.out.println(">>>DEBUG server principal is " + spname); EncryptionKey key = readKey(version); if (DEBUG) System.out.println(">>>DEBUG key type: " + key.getEType()); diff --git a/jdk/src/share/classes/sun/security/krb5/internal/ccache/Credentials.java b/jdk/src/share/classes/sun/security/krb5/internal/ccache/Credentials.java index e040788c68e..f27a1588ec3 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/ccache/Credentials.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/ccache/Credentials.java @@ -36,9 +36,7 @@ import sun.security.krb5.internal.*; public class Credentials { PrincipalName cname; - Realm crealm; PrincipalName sname; - Realm srealm; EncryptionKey key; KerberosTime authtime; KerberosTime starttime;//optional @@ -67,15 +65,7 @@ public class Credentials { Ticket new_ticket, Ticket new_secondTicket) { cname = (PrincipalName) new_cname.clone(); - if (new_cname.getRealm() != null) { - crealm = (Realm) new_cname.getRealm().clone(); - } - sname = (PrincipalName) new_sname.clone(); - if (new_sname.getRealm() != null) { - srealm = (Realm) new_sname.getRealm().clone(); - } - key = (EncryptionKey) new_key.clone(); authtime = (KerberosTime) new_authtime.clone(); @@ -110,7 +100,6 @@ public class Credentials { { return; } - crealm = (Realm) kdcRep.crealm.clone(); cname = (PrincipalName) kdcRep.cname.clone(); ticket = (Ticket) kdcRep.ticket.clone(); key = (EncryptionKey) kdcRep.encKDCRepPart.key.clone(); @@ -123,7 +112,6 @@ public class Credentials { if (kdcRep.encKDCRepPart.renewTill != null) { renewTill = (KerberosTime) kdcRep.encKDCRepPart.renewTill.clone(); } - srealm = (Realm) kdcRep.encKDCRepPart.srealm.clone(); sname = (PrincipalName) kdcRep.encKDCRepPart.sname.clone(); caddr = (HostAddresses) kdcRep.encKDCRepPart.caddr.clone(); secondTicket = (Ticket) new_secondTicket.clone(); @@ -138,17 +126,7 @@ public class Credentials { public Credentials(KDCRep kdcRep, Ticket new_ticket) { sname = (PrincipalName) kdcRep.encKDCRepPart.sname.clone(); - srealm = (Realm) kdcRep.encKDCRepPart.srealm.clone(); - try { - sname.setRealm(srealm); - } catch (RealmException e) { - } cname = (PrincipalName) kdcRep.cname.clone(); - crealm = (Realm) kdcRep.crealm.clone(); - try { - cname.setRealm(crealm); - } catch (RealmException e) { - } key = (EncryptionKey) kdcRep.encKDCRepPart.key.clone(); authtime = (KerberosTime) kdcRep.encKDCRepPart.authtime.clone(); if (kdcRep.encKDCRepPart.starttime != null) { @@ -202,9 +180,6 @@ public class Credentials { } public PrincipalName getServicePrincipal() throws RealmException { - if (sname.getRealm() == null) { - sname.setRealm(srealm); - } return sname; } diff --git a/jdk/src/share/classes/sun/security/krb5/internal/ccache/CredentialsCache.java b/jdk/src/share/classes/sun/security/krb5/internal/ccache/CredentialsCache.java index 3d0511071b3..8c61ed395c0 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/ccache/CredentialsCache.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/ccache/CredentialsCache.java @@ -120,6 +120,6 @@ public abstract class CredentialsCache { public abstract void save() throws IOException, KrbException; public abstract Credentials[] getCredsList(); public abstract Credentials getDefaultCreds(); - public abstract Credentials getCreds(PrincipalName sname, Realm srealm) ; - public abstract Credentials getCreds(LoginOptions options, PrincipalName sname, Realm srealm) ; + public abstract Credentials getCreds(PrincipalName sname); + public abstract Credentials getCreds(LoginOptions options, PrincipalName sname); } diff --git a/jdk/src/share/classes/sun/security/krb5/internal/ccache/FileCredentialsCache.java b/jdk/src/share/classes/sun/security/krb5/internal/ccache/FileCredentialsCache.java index 803d0ae1436..c985887a1ef 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/ccache/FileCredentialsCache.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/ccache/FileCredentialsCache.java @@ -59,7 +59,6 @@ public class FileCredentialsCache extends CredentialsCache public int version; public Tag tag; // optional public PrincipalName primaryPrincipal; - public Realm primaryRealm; private Vector credentialsList; private static String dir; private static boolean DEBUG = Krb5.DEBUG; @@ -79,7 +78,6 @@ public class FileCredentialsCache extends CredentialsCache } if (principal != null) { fcc.primaryPrincipal = principal; - fcc.primaryRealm = principal.getRealm(); } fcc.load(cacheName); return fcc; @@ -153,7 +151,6 @@ public class FileCredentialsCache extends CredentialsCache synchronized void init(PrincipalName principal, String name) throws IOException, KrbException { primaryPrincipal = principal; - primaryRealm = principal.getRealm(); CCacheOutputStream cos = new CCacheOutputStream(new FileOutputStream(name)); version = KRB5_FCC_FVNO_3; @@ -183,7 +180,6 @@ public class FileCredentialsCache extends CredentialsCache } } else primaryPrincipal = p; - primaryRealm = primaryPrincipal.getRealm(); credentialsList = new Vector (); while (cis.available() > 0) { Credentials cred = cis.readCred(version); @@ -291,18 +287,16 @@ public class FileCredentialsCache extends CredentialsCache } - public Credentials getCreds(LoginOptions options, - PrincipalName sname, Realm srealm) { + public Credentials getCreds(LoginOptions options, PrincipalName sname) { if (options == null) { - return getCreds(sname, srealm); + return getCreds(sname); } else { Credentials[] list = getCredsList(); if (list == null) { return null; } else { for (int i = 0; i < list.length; i++) { - if (sname.match(list[i].sname) && - (srealm.toString().equals(list[i].srealm.toString()))) { + if (sname.match(list[i].sname)) { if (list[i].flags.match(options)) { return list[i]; } @@ -317,16 +311,14 @@ public class FileCredentialsCache extends CredentialsCache /** * Gets a credentials for a specified service. * @param sname service principal name. - * @param srealm the realm that the service belongs to. */ - public Credentials getCreds(PrincipalName sname, Realm srealm) { + public Credentials getCreds(PrincipalName sname) { Credentials[] list = getCredsList(); if (list == null) { return null; } else { for (int i = 0; i < list.length; i++) { - if (sname.match(list[i].sname) && - (srealm.toString().equals(list[i].srealm.toString()))) { + if (sname.match(list[i].sname)) { return list[i]; } } @@ -343,7 +335,7 @@ public class FileCredentialsCache extends CredentialsCache if (list[i].sname.toString().startsWith("krbtgt")) { String[] nameStrings = list[i].sname.getNameStrings(); // find the TGT for the current realm krbtgt/realm@realm - if (nameStrings[1].equals(list[i].srealm.toString())) { + if (nameStrings[1].equals(list[i].sname.getRealm().toString())) { return list[i]; } } diff --git a/jdk/src/share/classes/sun/security/krb5/internal/ccache/MemoryCredentialsCache.java b/jdk/src/share/classes/sun/security/krb5/internal/ccache/MemoryCredentialsCache.java index c01260a61a4..2f1f37926b1 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/ccache/MemoryCredentialsCache.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/ccache/MemoryCredentialsCache.java @@ -64,7 +64,7 @@ public abstract class MemoryCredentialsCache extends CredentialsCache { public abstract Credentials[] getCredsList(); - public abstract Credentials getCreds(PrincipalName sname, Realm srealm) ; + public abstract Credentials getCreds(PrincipalName sname) ; public abstract PrincipalName getPrimaryPrincipal(); diff --git a/jdk/src/share/classes/sun/security/krb5/internal/ktab/KeyTabInputStream.java b/jdk/src/share/classes/sun/security/krb5/internal/ktab/KeyTabInputStream.java index a0bbd1eb641..5f42242496f 100644 --- a/jdk/src/share/classes/sun/security/krb5/internal/ktab/KeyTabInputStream.java +++ b/jdk/src/share/classes/sun/security/krb5/internal/ktab/KeyTabInputStream.java @@ -83,8 +83,7 @@ public class KeyTabInputStream extends KrbDataInputStream implements KeyTabConst } int nameType = read(4); index -= 4; - PrincipalName service = new PrincipalName(nameParts, nameType); - service.setRealm(realm); + PrincipalName service = new PrincipalName(nameType, nameParts, realm); KerberosTime timeStamp = readTimeStamp(); int keyVersion = read() & 0xff; diff --git a/jdk/src/share/classes/sun/security/ssl/krb5/KerberosClientKeyExchangeImpl.java b/jdk/src/share/classes/sun/security/ssl/krb5/KerberosClientKeyExchangeImpl.java index 7e220bc06eb..cde473fcf1d 100644 --- a/jdk/src/share/classes/sun/security/ssl/krb5/KerberosClientKeyExchangeImpl.java +++ b/jdk/src/share/classes/sun/security/ssl/krb5/KerberosClientKeyExchangeImpl.java @@ -163,7 +163,7 @@ public final class KerberosClientKeyExchangeImpl EncryptedData encPart = t.encPart; PrincipalName ticketSname = t.sname; - Realm ticketRealm = t.realm; + Realm ticketRealm = t.sname.getRealm(); String serverPrincipal = serverKeys[0].getPrincipal().getName(); @@ -175,8 +175,7 @@ public final class KerberosClientKeyExchangeImpl */ // Check that ticket Sname matches serverPrincipal - String ticketPrinc = ticketSname.toString().concat("@" + - ticketRealm.toString()); + String ticketPrinc = ticketSname.toString(); if (!ticketPrinc.equals(serverPrincipal)) { if (debug != null && Debug.isOn("handshake")) System.out.println("Service principal in Ticket does not" @@ -224,7 +223,6 @@ public final class KerberosClientKeyExchangeImpl if (debug != null && Debug.isOn("handshake")) { System.out.println("server principal: " + serverPrincipal); - System.out.println("realm: " + encTicketPart.crealm.toString()); System.out.println("cname: " + encTicketPart.cname.toString()); } } catch (IOException e) { diff --git a/jdk/src/windows/classes/sun/security/krb5/internal/tools/Kinit.java b/jdk/src/windows/classes/sun/security/krb5/internal/tools/Kinit.java index 41354c88a74..eb748684557 100644 --- a/jdk/src/windows/classes/sun/security/krb5/internal/tools/Kinit.java +++ b/jdk/src/windows/classes/sun/security/krb5/internal/tools/Kinit.java @@ -206,9 +206,7 @@ public class Kinit { System.out.println(">>> Kinit realm name is " + realm); } - PrincipalName sname = new PrincipalName("krbtgt" + "/" + realm, - PrincipalName.KRB_NT_SRV_INST); - sname.setRealm(realm); + PrincipalName sname = PrincipalName.tgsService(realm, realm); builder.setTarget(sname); if (DEBUG) { diff --git a/jdk/src/windows/classes/sun/security/krb5/internal/tools/KinitOptions.java b/jdk/src/windows/classes/sun/security/krb5/internal/tools/KinitOptions.java index 05b674bf950..abde927cda6 100644 --- a/jdk/src/windows/classes/sun/security/krb5/internal/tools/KinitOptions.java +++ b/jdk/src/windows/classes/sun/security/krb5/internal/tools/KinitOptions.java @@ -146,15 +146,6 @@ class KinitOptions { "Principal name: " + p + e.getMessage()); } - if (principal.getRealm() == null) { - String realm = - Config.getInstance().getDefault("default_realm", - "libdefaults"); - if (realm != null) { - principal.setRealm(realm); - } else throw new IllegalArgumentException("invalid " + - "Realm name"); - } } else if (this.password == null) { // Have already processed a Principal, this must be a password password = args[i].toCharArray(); @@ -175,16 +166,6 @@ class KinitOptions { } PrincipalName getDefaultPrincipal() { - String cname; - String realm = null; - try { - realm = Config.getInstance().getDefaultRealm(); - } catch (KrbException e) { - System.out.println ("Can not get default realm " + - e.getMessage()); - e.printStackTrace(); - return null; - } // get default principal name from the cachename if it is // available. @@ -204,10 +185,6 @@ class KinitOptions { } PrincipalName p = cis.readPrincipal(version); cis.close(); - String temp = p.getRealmString(); - if (temp == null) { - p.setRealm(realm); - } if (DEBUG) { System.out.println(">>>KinitOptions principal name from "+ "the cache is :" + p); @@ -230,19 +207,15 @@ class KinitOptions { System.out.println(">>>KinitOptions default username is :" + username); } - if (realm != null) { - try { - PrincipalName p = new PrincipalName(username); - if (p.getRealm() == null) - p.setRealm(realm); - return p; - } catch (RealmException e) { - // ignore exception , return null - if (DEBUG) { - System.out.println ("Exception in getting principal " + - "name " + e.getMessage()); - e.printStackTrace(); - } + try { + PrincipalName p = new PrincipalName(username); + return p; + } catch (RealmException e) { + // ignore exception , return null + if (DEBUG) { + System.out.println ("Exception in getting principal " + + "name " + e.getMessage()); + e.printStackTrace(); } } return null; diff --git a/jdk/src/windows/classes/sun/security/krb5/internal/tools/Ktab.java b/jdk/src/windows/classes/sun/security/krb5/internal/tools/Ktab.java index fe29462add5..9feacdf4d63 100644 --- a/jdk/src/windows/classes/sun/security/krb5/internal/tools/Ktab.java +++ b/jdk/src/windows/classes/sun/security/krb5/internal/tools/Ktab.java @@ -273,9 +273,6 @@ public class Ktab { PrincipalName pname = null; try { pname = new PrincipalName(principal); - if (pname.getRealm() == null) { - pname.setRealm(Config.getInstance().getDefaultRealm()); - } } catch (KrbException e) { System.err.println("Failed to add " + principal + " to keytab."); @@ -382,9 +379,6 @@ public class Ktab { PrincipalName pname = null; try { pname = new PrincipalName(principal); - if (pname.getRealm() == null) { - pname.setRealm(Config.getInstance().getDefaultRealm()); - } if (!forced) { String answer; BufferedReader cis = diff --git a/jdk/src/windows/native/sun/security/krb5/NativeCreds.c b/jdk/src/windows/native/sun/security/krb5/NativeCreds.c index 91ed2cb84bb..72e5d5acb49 100644 --- a/jdk/src/windows/native/sun/security/krb5/NativeCreds.c +++ b/jdk/src/windows/native/sun/security/krb5/NativeCreds.c @@ -67,7 +67,6 @@ jmethodID encryptionKeyConstructor = 0; jmethodID ticketFlagsConstructor = 0; jmethodID kerberosTimeConstructor = 0; jmethodID krbcredsConstructor = 0; -jmethodID setRealmMethod = 0; /* * Function prototypes for internal routines @@ -279,7 +278,7 @@ JNIEXPORT jint JNICALL JNI_OnLoad( } principalNameConstructor = (*env)->GetMethodID(env, principalNameClass, - "", "([Ljava/lang/String;)V"); + "", "([Ljava/lang/String;Ljava/lang/String;)V"); if (principalNameConstructor == 0) { printf("LSA: Couldn't find PrincipalName constructor\n"); return JNI_ERR; @@ -318,14 +317,6 @@ JNIEXPORT jint JNICALL JNI_OnLoad( printf("LSA: Found KerberosTime constructor\n"); } - // load the setRealm method in PrincipalName - setRealmMethod = (*env)->GetMethodID(env, principalNameClass, - "setRealm", "(Ljava/lang/String;)V"); - if (setRealmMethod == 0) { - printf("LSA: Couldn't find setRealm in PrincipalName\n"); - return JNI_ERR; - } - if (native_debug) { printf("LSA: Finished OnLoad processing\n"); } @@ -952,13 +943,12 @@ jobject BuildPrincipal(JNIEnv *env, PKERB_EXTERNAL_NAME principalName, // Do I have to worry about storage reclamation here? } - principal = (*env)->NewObject(env, principalNameClass, - principalNameConstructor, stringArray); - // now set the realm in the principal realmLen = (ULONG)wcslen((PWCHAR)realm); realmStr = (*env)->NewString(env, (PWCHAR)realm, (USHORT)realmLen); - (*env)->CallVoidMethod(env, principal, setRealmMethod, realmStr); + + principal = (*env)->NewObject(env, principalNameClass, + principalNameConstructor, stringArray, realmStr); // free local resources LocalFree(realm); diff --git a/jdk/test/sun/security/krb5/ServiceNameClone.java b/jdk/test/sun/security/krb5/ServiceNameClone.java deleted file mode 100644 index 81b3b038537..00000000000 --- a/jdk/test/sun/security/krb5/ServiceNameClone.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -/* - * @test - * @bug 6856069 - * @summary PrincipalName.clone() does not invoke super.clone() - */ - -import sun.security.krb5.ServiceName; - -public class ServiceNameClone { - public static void main(String[] args) throws Exception { - ServiceName sn = new ServiceName("me@HERE"); - if (sn.clone().getClass() != ServiceName.class) { - throw new Exception("ServiceName's clone is not a ServiceName"); - } - if (!sn.clone().equals(sn)) { - throw new Exception("ServiceName's clone changed"); - } - } -} diff --git a/jdk/test/sun/security/krb5/auto/KDC.java b/jdk/test/sun/security/krb5/auto/KDC.java index 05efabdcb09..716e2fa0e07 100644 --- a/jdk/test/sun/security/krb5/auto/KDC.java +++ b/jdk/test/sun/security/krb5/auto/KDC.java @@ -606,9 +606,8 @@ public class KDC { TGSReq tgsReq = new TGSReq(in); PrincipalName service = tgsReq.reqBody.sname; if (options.containsKey(KDC.Option.RESP_NT)) { - service = new PrincipalName(service.getNameStrings(), - (int)options.get(KDC.Option.RESP_NT)); - service.setRealm(service.getRealm()); + service = new PrincipalName((int)options.get(KDC.Option.RESP_NT), + service.getNameStrings(), service.getRealm()); } try { System.out.println(realm + "> " + tgsReq.reqBody.cname + @@ -632,7 +631,6 @@ public class KDC { EncryptedData ed = apReq.authenticator; tkt = apReq.ticket; int te = tkt.encPart.getEType(); - tkt.sname.setRealm(tkt.realm); EncryptionKey kkey = keyForUser(tkt.sname, te, true); byte[] bb = tkt.encPart.decrypt(kkey, KeyUsage.KU_TICKET); DerInputStream derIn = new DerInputStream(bb); @@ -693,7 +691,6 @@ public class KDC { EncTicketPart enc = new EncTicketPart( tFlags, key, - etp.crealm, etp.cname, new TransitedEncoding(1, new byte[0]), // TODO new KerberosTime(new Date()), @@ -709,7 +706,6 @@ public class KDC { throw new KrbException(Krb5.KDC_ERR_SUMTYPE_NOSUPP); // TODO } Ticket t = new Ticket( - body.crealm, service, new EncryptedData(skey, enc.asn1Encode(), KeyUsage.KU_TICKET) ); @@ -725,7 +721,6 @@ public class KDC { new KerberosTime(new Date()), body.from, till, body.rtime, - body.crealm, service, body.addresses != null // always set caddr ? body.addresses @@ -734,7 +729,6 @@ public class KDC { ); EncryptedData edata = new EncryptedData(ckey, enc_part.asn1Encode(), KeyUsage.KU_ENC_TGS_REP_PART_SESSKEY); TGSRep tgsRep = new TGSRep(null, - etp.crealm, etp.cname, t, edata); @@ -756,8 +750,8 @@ public class KDC { new KerberosTime(new Date()), 0, ke.returnCode(), - body.crealm, body.cname, - new Realm(getRealm()), service, + body.cname, + service, KrbException.errorMessage(ke.returnCode()), null); } @@ -780,7 +774,6 @@ public class KDC { if (options.containsKey(KDC.Option.RESP_NT)) { service = new PrincipalName(service.getNameStrings(), (int)options.get(KDC.Option.RESP_NT)); - service.setRealm(service.getRealm()); } try { System.out.println(realm + "> " + asReq.reqBody.cname + @@ -788,7 +781,6 @@ public class KDC { service); KDCReqBody body = asReq.reqBody; - body.cname.setRealm(getRealm()); eTypes = KDCReqBodyDotEType(body); int eType = eTypes[0]; @@ -971,7 +963,6 @@ public class KDC { EncTicketPart enc = new EncTicketPart( tFlags, key, - body.crealm, body.cname, new TransitedEncoding(1, new byte[0]), new KerberosTime(new Date()), @@ -980,7 +971,6 @@ public class KDC { body.addresses, null); Ticket t = new Ticket( - body.crealm, service, new EncryptedData(skey, enc.asn1Encode(), KeyUsage.KU_TICKET) ); @@ -996,14 +986,12 @@ public class KDC { new KerberosTime(new Date()), body.from, till, body.rtime, - body.crealm, service, body.addresses ); EncryptedData edata = new EncryptedData(ckey, enc_part.asn1Encode(), KeyUsage.KU_ENC_AS_REP_PART); ASRep asRep = new ASRep( outPAs.toArray(new PAData[outPAs.size()]), - body.crealm, body.cname, t, edata); @@ -1024,7 +1012,6 @@ public class KDC { asRep.encKDCRepPart = enc_part; sun.security.krb5.internal.ccache.Credentials credentials = new sun.security.krb5.internal.ccache.Credentials(asRep); - asReq.reqBody.cname.setRealm(getRealm()); CredentialsCache cache = CredentialsCache.create(asReq.reqBody.cname, ccache); if (cache == null) { @@ -1059,8 +1046,8 @@ public class KDC { new KerberosTime(new Date()), 0, ke.returnCode(), - body.crealm, body.cname, - new Realm(getRealm()), service, + body.cname, + service, KrbException.errorMessage(ke.returnCode()), eData); } diff --git a/jdk/test/sun/security/krb5/name/Constructors.java b/jdk/test/sun/security/krb5/name/Constructors.java new file mode 100644 index 00000000000..71243e71c32 --- /dev/null +++ b/jdk/test/sun/security/krb5/name/Constructors.java @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +/* + * @test + * @bug 6966259 + * @summary Make PrincipalName and Realm immutable + * @run main/othervm Constructors + */ + +import java.util.Arrays; +import sun.security.krb5.*; + +public class Constructors { + public static void main(String[] args) throws Exception { + + int type; + boolean testNoDefaultDomain; + + // Part 1: on format + + // Good ones + type = PrincipalName.KRB_NT_UNKNOWN; + checkName("a", type, "R", "R", "a"); + checkName("a@R2", type, "R", "R", "a"); + checkName("a/b", type, "R", "R", "a", "b"); + checkName("a/b@R2", type, "R", "R", "a", "b"); + checkName("a/b/c", type, "R", "R", "a", "b", "c"); + checkName("a/b/c@R2", type, "R", "R", "a", "b", "c"); + // Weird ones + checkName("a\\/b", type, "R", "R", "a/b"); + checkName("a\\/b\\/c", type, "R", "R", "a/b/c"); + checkName("a\\/b\\@R2", type, "R", "R", "a/b@R2"); + // Bad ones + checkName("a", type, "", null); + checkName("a/", type, "R", null); + checkName("/a", type, "R", null); + checkName("a//b", type, "R", null); + checkName("a@", type, null, null); + type = PrincipalName.KRB_NT_SRV_HST; + + // Part 2: on realm choices + + // When there is no default realm + System.setProperty("java.security.krb5.conf", + System.getProperty("test.src", ".") + "/empty.conf"); + Config.refresh(); + + // A Windows client login to AD always has a default realm + try { + Realm r = Realm.getDefault(); + System.out.println("testNoDefaultDomain = false. Realm is " + r); + testNoDefaultDomain = false; + } catch (RealmException re) { + // Great. This is what we expected + testNoDefaultDomain = true; + } + + if (testNoDefaultDomain) { + type = PrincipalName.KRB_NT_UNKNOWN; + checkName("a", type, "R1", "R1", "a"); // arg + checkName("a@R1", type, null, "R1", "a"); // or r in name + checkName("a@R2", type, "R1", "R1", "a"); // arg over r + checkName("a", type, null, null); // fail if none + checkName("a/b@R1", type, null, "R1", "a", "b"); + type = PrincipalName.KRB_NT_SRV_HST; + // Let's pray "b.h" won't be canonicalized + checkName("a/b.h", type, "R1", "R1", "a", "b.h"); // arg + checkName("a/b.h@R1", type, null, "R1", "a", "b.h"); // or r in name + checkName("a/b.h@R1", type, "R2", "R2", "a", "b.h"); // arg over r + checkName("a/b.h", type, null, null); // fail if none + } + + // When there is default realm + System.setProperty("java.security.krb5.conf", + System.getProperty("test.src", ".") + "/krb5.conf"); + Config.refresh(); + + type = PrincipalName.KRB_NT_UNKNOWN; + checkName("a", type, "R1", "R1", "a"); // arg + checkName("a@R1", type, null, "R1", "a"); // or r in name + checkName("a@R2", type, "R1", "R1", "a"); // arg over r + checkName("a", type, null, "R", "a"); // default + checkName("a/b", type, null, "R", "a", "b"); + type = PrincipalName.KRB_NT_SRV_HST; + checkName("a/b.h3", type, "R1", "R1", "a", "b.h3"); // arg + checkName("a/b.h@R1", type, null, "R1", "a", "b.h"); // or r in name + checkName("a/b.h3@R2", type, "R1", "R1", "a", "b.h3"); // arg over r + checkName("a/b.h2", type, "R1", "R1", "a", "b.h2"); // arg over map + checkName("a/b.h2@R1", type, null, "R1", "a", "b.h2"); // r over map + checkName("a/b.h2", type, null, "R2", "a", "b.h2"); // map + checkName("a/b.h", type, null, "R", "a", "b.h"); // default + } + + // Check if the creation matches the expected output. + // Note: realm == null means creation failure + static void checkName(String n, int t, String s, + String realm, String... parts) + throws Exception { + PrincipalName pn = null; + try { + pn = new PrincipalName(n, t, s); + } catch (Exception e) { + if (realm == null) { + return; // This is expected + } else { + throw e; + } + } + if (!pn.getRealmAsString().equals(realm) + || !Arrays.equals(pn.getNameStrings(), parts)) { + throw new Exception(pn.toString() + " vs " + + Arrays.toString(parts) + "@" + realm); + } + } +} diff --git a/jdk/test/sun/security/krb5/name/empty.conf b/jdk/test/sun/security/krb5/name/empty.conf new file mode 100644 index 00000000000..e11f6e345a0 --- /dev/null +++ b/jdk/test/sun/security/krb5/name/empty.conf @@ -0,0 +1,2 @@ +[libdefaults] +dns_fallback = false diff --git a/jdk/test/sun/security/krb5/name/krb5.conf b/jdk/test/sun/security/krb5/name/krb5.conf new file mode 100644 index 00000000000..e9c34054987 --- /dev/null +++ b/jdk/test/sun/security/krb5/name/krb5.conf @@ -0,0 +1,10 @@ +[libdefaults] +default_realm = R + +[realms] +R = { + kdc = kdc +} + +[domain_realm] +.h2 = R2 From 3571ee23dc321004940ce0b4b24e5c2f96514ae3 Mon Sep 17 00:00:00 2001 From: Bengt Rutisson Date: Wed, 11 Jul 2012 22:47:38 +0200 Subject: [PATCH 079/160] 7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause Also reviewed by: vitalyd@gmail.com. Move the timing out of G1CollectorPolicy into the G1GCPhaseTimes class Reviewed-by: johnc --- .../g1/concurrentG1Refine.cpp | 16 +- .../gc_implementation/g1/concurrentMark.cpp | 3 - .../gc_implementation/g1/g1CollectedHeap.cpp | 86 +-- .../g1/g1CollectorPolicy.cpp | 508 +++--------------- .../g1/g1CollectorPolicy.hpp | 176 +----- .../gc_implementation/g1/g1GCPhaseTimes.cpp | 379 +++++++++++++ .../gc_implementation/g1/g1GCPhaseTimes.hpp | 216 ++++++++ .../vm/gc_implementation/g1/g1RemSet.cpp | 11 +- 8 files changed, 732 insertions(+), 663 deletions(-) create mode 100644 hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp create mode 100644 hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.hpp diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp index a7b24607064..0a775a12941 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,6 +27,7 @@ #include "gc_implementation/g1/concurrentG1RefineThread.hpp" #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" #include "gc_implementation/g1/g1CollectorPolicy.hpp" +#include "gc_implementation/g1/g1GCPhaseTimes.hpp" #include "gc_implementation/g1/g1RemSet.hpp" #include "gc_implementation/g1/heapRegionSeq.inline.hpp" #include "memory/space.inline.hpp" @@ -500,11 +501,11 @@ bool ConcurrentG1Refine::expand_card_count_cache(int cache_size_idx) { } void ConcurrentG1Refine::clear_and_record_card_counts() { - if (G1ConcRSLogCacheSize == 0) return; + if (G1ConcRSLogCacheSize == 0) { + return; + } -#ifndef PRODUCT double start = os::elapsedTime(); -#endif if (_expand_card_counts) { int new_idx = _cache_size_index + 1; @@ -523,11 +524,8 @@ void ConcurrentG1Refine::clear_and_record_card_counts() { assert((this_epoch+1) <= max_jint, "to many periods"); // Update epoch _n_periods++; - -#ifndef PRODUCT - double elapsed = os::elapsedTime() - start; - _g1h->g1_policy()->record_cc_clear_time(elapsed * 1000.0); -#endif + double cc_clear_time_ms = (os::elapsedTime() - start) * 1000; + _g1h->g1_policy()->phase_times()->record_cc_clear_time_ms(cc_clear_time_ms); } void ConcurrentG1Refine::print_worker_threads_on(outputStream* st) const { diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp index fd228964f7d..5cd843413a1 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp @@ -3153,9 +3153,6 @@ bool ConcurrentMark::do_yield_check(uint worker_id) { _g1h->g1_policy()->record_concurrent_pause(); } cmThread()->yield(); - if (worker_id == 0) { - _g1h->g1_policy()->record_concurrent_pause_end(); - } return true; } else { return false; diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp index 99f95cbb93b..3ea512faa16 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @@ -33,6 +33,7 @@ #include "gc_implementation/g1/g1CollectorPolicy.hpp" #include "gc_implementation/g1/g1ErgoVerbose.hpp" #include "gc_implementation/g1/g1EvacFailure.hpp" +#include "gc_implementation/g1/g1GCPhaseTimes.hpp" #include "gc_implementation/g1/g1Log.hpp" #include "gc_implementation/g1/g1MarkSweep.hpp" #include "gc_implementation/g1/g1OopClosures.inline.hpp" @@ -2274,7 +2275,7 @@ void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl, while (dcqs.apply_closure_to_completed_buffer(cl, worker_i, 0, true)) { n_completed_buffers++; } - g1_policy()->record_update_rs_processed_buffers(worker_i, + g1_policy()->phase_times()->record_update_rs_processed_buffers(worker_i, (double) n_completed_buffers); dcqs.clear_n_completed_buffers(); assert(!dcqs.completed_buffers_exist_dirty(), "Completed buffers exist!"); @@ -3633,10 +3634,10 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); - GCCauseString gc_cause_str = GCCauseString("GC pause", gc_cause()) - .append(g1_policy()->gcs_are_young() ? " (young)" : " (mixed)") - .append(g1_policy()->during_initial_mark_pause() ? " (initial-mark)" : ""); - TraceTime t(gc_cause_str, G1Log::fine() && !G1Log::finer(), true, gclog_or_tty); + int active_workers = (G1CollectedHeap::use_parallel_gc_threads() ? + workers()->active_workers() : 1); + g1_policy()->phase_times()->note_gc_start(os::elapsedTime(), active_workers, + g1_policy()->gcs_are_young(), g1_policy()->during_initial_mark_pause(), gc_cause()); TraceCollectorStats tcs(g1mm()->incremental_collection_counters()); TraceMemoryManagerStats tms(false /* fullGC */, gc_cause()); @@ -3699,9 +3700,15 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { // before the start GC event. _hr_printer.start_gc(false /* full */, (size_t) total_collections()); + // This timing is only used by the ergonomics to handle our pause target. + // It is unclear why this should not include the full pause. We will + // investigate this in CR 7178365. + // + // Preserving the old comment here if that helps the investigation: + // // The elapsed time induced by the start time below deliberately elides // the possible verification above. - double start_time_sec = os::elapsedTime(); + double sample_start_time_sec = os::elapsedTime(); size_t start_used_bytes = used(); #if YOUNG_LIST_VERBOSE @@ -3710,7 +3717,7 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty); #endif // YOUNG_LIST_VERBOSE - g1_policy()->record_collection_pause_start(start_time_sec, + g1_policy()->record_collection_pause_start(sample_start_time_sec, start_used_bytes); double scan_wait_start = os::elapsedTime(); @@ -3719,11 +3726,12 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { // objects on them have been correctly scanned before we start // moving them during the GC. bool waited = _cm->root_regions()->wait_until_scan_finished(); + double wait_time_ms = 0.0; if (waited) { double scan_wait_end = os::elapsedTime(); - double wait_time_ms = (scan_wait_end - scan_wait_start) * 1000.0; - g1_policy()->record_root_region_scan_wait_time(wait_time_ms); + wait_time_ms = (scan_wait_end - scan_wait_start) * 1000.0; } + g1_policy()->phase_times()->record_root_region_scan_wait_time(wait_time_ms); #if YOUNG_LIST_VERBOSE gclog_or_tty->print_cr("\nAfter recording pause start.\nYoung_list:"); @@ -3877,12 +3885,16 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { true /* verify_fingers */); _cm->note_end_of_gc(); - double end_time_sec = os::elapsedTime(); - double pause_time_ms = (end_time_sec - start_time_sec) * MILLIUNITS; - g1_policy()->record_pause_time_ms(pause_time_ms); - int active_workers = (G1CollectedHeap::use_parallel_gc_threads() ? - workers()->active_workers() : 1); - g1_policy()->record_collection_pause_end(active_workers); + // Collect thread local data to allow the ergonomics to use + // the collected information + g1_policy()->phase_times()->collapse_par_times(); + + // This timing is only used by the ergonomics to handle our pause target. + // It is unclear why this should not include the full pause. We will + // investigate this in CR 7178365. + double sample_end_time_sec = os::elapsedTime(); + double pause_time_ms = (sample_end_time_sec - sample_start_time_sec) * MILLIUNITS; + g1_policy()->record_collection_pause_end(pause_time_ms); MemoryService::track_memory_usage(); @@ -3929,9 +3941,6 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { // RETIRE events are generated before the end GC event. _hr_printer.end_gc(false /* full */, (size_t) total_collections()); - // We have to do this after we decide whether to expand the heap or not. - g1_policy()->print_heap_transition(); - if (mark_in_progress()) { concurrent_mark()->update_g1_committed(); } @@ -3941,13 +3950,14 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { #endif gc_epilogue(false); + + g1_policy()->phase_times()->note_gc_end(os::elapsedTime()); + + // We have to do this after we decide whether to expand the heap or not. + g1_policy()->print_heap_transition(); } - // The closing of the inner scope, immediately above, will complete - // logging at the "fine" level. The record_collection_pause_end() call - // above will complete logging at the "finer" level. - // - // It is not yet to safe, however, to tell the concurrent mark to + // It is not yet to safe to tell the concurrent mark to // start as we have some optional output below. We don't want the // output from the concurrent mark thread interfering with this // logging output either. @@ -4695,7 +4705,7 @@ public: if (worker_id >= _n_workers) return; // no work needed this round double start_time_ms = os::elapsedTime() * 1000.0; - _g1h->g1_policy()->record_gc_worker_start_time(worker_id, start_time_ms); + _g1h->g1_policy()->phase_times()->record_gc_worker_start_time(worker_id, start_time_ms); { ResourceMark rm; @@ -4744,8 +4754,8 @@ public: evac.do_void(); double elapsed_ms = (os::elapsedTime()-start)*1000.0; double term_ms = pss.term_time()*1000.0; - _g1h->g1_policy()->record_obj_copy_time(worker_id, elapsed_ms-term_ms); - _g1h->g1_policy()->record_termination(worker_id, term_ms, pss.term_attempts()); + _g1h->g1_policy()->phase_times()->record_obj_copy_time(worker_id, elapsed_ms-term_ms); + _g1h->g1_policy()->phase_times()->record_termination(worker_id, term_ms, pss.term_attempts()); } _g1h->g1_policy()->record_thread_age_table(pss.age_table()); _g1h->update_surviving_young_words(pss.surviving_young_words()+1); @@ -4763,7 +4773,7 @@ public: } double end_time_ms = os::elapsedTime() * 1000.0; - _g1h->g1_policy()->record_gc_worker_end_time(worker_id, end_time_ms); + _g1h->g1_policy()->phase_times()->record_gc_worker_end_time(worker_id, end_time_ms); } }; @@ -4874,15 +4884,15 @@ g1_process_strong_roots(bool collecting_perm_gen, double ext_roots_end = os::elapsedTime(); - g1_policy()->reset_obj_copy_time(worker_i); + g1_policy()->phase_times()->reset_obj_copy_time(worker_i); double obj_copy_time_sec = buf_scan_perm.closure_app_seconds() + buf_scan_non_heap_roots.closure_app_seconds(); - g1_policy()->record_obj_copy_time(worker_i, obj_copy_time_sec * 1000.0); + g1_policy()->phase_times()->record_obj_copy_time(worker_i, obj_copy_time_sec * 1000.0); double ext_root_time_ms = ((ext_roots_end - ext_roots_start) - obj_copy_time_sec) * 1000.0; - g1_policy()->record_ext_root_scan_time(worker_i, ext_root_time_ms); + g1_policy()->phase_times()->record_ext_root_scan_time(worker_i, ext_root_time_ms); // During conc marking we have to filter the per-thread SATB buffers // to make sure we remove any oops into the CSet (which will show up @@ -4893,7 +4903,7 @@ g1_process_strong_roots(bool collecting_perm_gen, } } double satb_filtering_ms = (os::elapsedTime() - ext_roots_end) * 1000.0; - g1_policy()->record_satb_filtering_time(worker_i, satb_filtering_ms); + g1_policy()->phase_times()->record_satb_filtering_time(worker_i, satb_filtering_ms); // Now scan the complement of the collection set. if (scan_rs != NULL) { @@ -5393,7 +5403,7 @@ void G1CollectedHeap::process_discovered_references() { assert(pss.refs()->is_empty(), "both queue and overflow should be empty"); double ref_proc_time = os::elapsedTime() - ref_proc_start; - g1_policy()->record_ref_proc_time(ref_proc_time * 1000.0); + g1_policy()->phase_times()->record_ref_proc_time(ref_proc_time * 1000.0); } // Weak Reference processing during an evacuation pause (part 2). @@ -5430,7 +5440,7 @@ void G1CollectedHeap::enqueue_discovered_references() { // and could signicantly increase the pause time. double ref_enq_time = os::elapsedTime() - ref_enq_start; - g1_policy()->record_ref_enq_time(ref_enq_time * 1000.0); + g1_policy()->phase_times()->record_ref_enq_time(ref_enq_time * 1000.0); } void G1CollectedHeap::evacuate_collection_set() { @@ -5493,11 +5503,11 @@ void G1CollectedHeap::evacuate_collection_set() { } double par_time_ms = (end_par_time_sec - start_par_time_sec) * 1000.0; - g1_policy()->record_par_time(par_time_ms); + g1_policy()->phase_times()->record_par_time(par_time_ms); double code_root_fixup_time_ms = (os::elapsedTime() - end_par_time_sec) * 1000.0; - g1_policy()->record_code_root_fixup_time(code_root_fixup_time_ms); + g1_policy()->phase_times()->record_code_root_fixup_time(code_root_fixup_time_ms); set_par_threads(0); @@ -5759,7 +5769,7 @@ void G1CollectedHeap::cleanUpCardTable() { } double elapsed = os::elapsedTime() - start; - g1_policy()->record_clear_ct_time(elapsed * 1000.0); + g1_policy()->phase_times()->record_clear_ct_time(elapsed * 1000.0); } void G1CollectedHeap::free_collection_set(HeapRegion* cs_head) { @@ -5868,8 +5878,8 @@ void G1CollectedHeap::free_collection_set(HeapRegion* cs_head) { NULL /* old_proxy_set */, NULL /* humongous_proxy_set */, false /* par */); - policy->record_young_free_cset_time_ms(young_time_ms); - policy->record_non_young_free_cset_time_ms(non_young_time_ms); + policy->phase_times()->record_young_free_cset_time_ms(young_time_ms); + policy->phase_times()->record_non_young_free_cset_time_ms(non_young_time_ms); } // This routine is similar to the above but does not record diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp index b91d04a0915..f07b14824d0 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @@ -29,6 +29,7 @@ #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" #include "gc_implementation/g1/g1CollectorPolicy.hpp" #include "gc_implementation/g1/g1ErgoVerbose.hpp" +#include "gc_implementation/g1/g1GCPhaseTimes.hpp" #include "gc_implementation/g1/g1Log.hpp" #include "gc_implementation/g1/heapRegionRemSet.hpp" #include "gc_implementation/shared/gcPolicyCounters.hpp" @@ -77,57 +78,6 @@ static double non_young_other_cost_per_region_ms_defaults[] = { 1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30 }; -// Help class for avoiding interleaved logging -class LineBuffer: public StackObj { - -private: - static const int BUFFER_LEN = 1024; - static const int INDENT_CHARS = 3; - char _buffer[BUFFER_LEN]; - int _indent_level; - int _cur; - - void vappend(const char* format, va_list ap) { - int res = vsnprintf(&_buffer[_cur], BUFFER_LEN - _cur, format, ap); - if (res != -1) { - _cur += res; - } else { - DEBUG_ONLY(warning("buffer too small in LineBuffer");) - _buffer[BUFFER_LEN -1] = 0; - _cur = BUFFER_LEN; // vsnprintf above should not add to _buffer if we are called again - } - } - -public: - explicit LineBuffer(int indent_level): _indent_level(indent_level), _cur(0) { - for (; (_cur < BUFFER_LEN && _cur < (_indent_level * INDENT_CHARS)); _cur++) { - _buffer[_cur] = ' '; - } - } - -#ifndef PRODUCT - ~LineBuffer() { - assert(_cur == _indent_level * INDENT_CHARS, "pending data in buffer - append_and_print_cr() not called?"); - } -#endif - - void append(const char* format, ...) { - va_list ap; - va_start(ap, format); - vappend(format, ap); - va_end(ap); - } - - void append_and_print_cr(const char* format, ...) { - va_list ap; - va_start(ap, format); - vappend(format, ap); - va_end(ap); - gclog_or_tty->print_cr("%s", _buffer); - _cur = _indent_level * INDENT_CHARS; - } -}; - G1CollectorPolicy::G1CollectorPolicy() : _parallel_gc_threads(G1CollectedHeap::use_parallel_gc_threads() ? ParallelGCThreads : 1), @@ -135,20 +85,6 @@ G1CollectorPolicy::G1CollectorPolicy() : _recent_gc_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), _stop_world_start(0.0), - _cur_clear_ct_time_ms(0.0), - _root_region_scan_wait_time_ms(0.0), - - _cur_ref_proc_time_ms(0.0), - _cur_ref_enq_time_ms(0.0), - -#ifndef PRODUCT - _min_clear_cc_time_ms(-1.0), - _max_clear_cc_time_ms(-1.0), - _cur_clear_cc_time_ms(0.0), - _cum_clear_cc_time_ms(0.0), - _num_cc_clears(0L), -#endif - _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), @@ -257,30 +193,9 @@ G1CollectorPolicy::G1CollectorPolicy() : _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; - _par_last_gc_worker_start_times_ms = new double[_parallel_gc_threads]; - _par_last_ext_root_scan_times_ms = new double[_parallel_gc_threads]; - _par_last_satb_filtering_times_ms = new double[_parallel_gc_threads]; + _phase_times = new G1GCPhaseTimes(_parallel_gc_threads); - _par_last_update_rs_times_ms = new double[_parallel_gc_threads]; - _par_last_update_rs_processed_buffers = new double[_parallel_gc_threads]; - - _par_last_scan_rs_times_ms = new double[_parallel_gc_threads]; - - _par_last_obj_copy_times_ms = new double[_parallel_gc_threads]; - - _par_last_termination_times_ms = new double[_parallel_gc_threads]; - _par_last_termination_attempts = new double[_parallel_gc_threads]; - _par_last_gc_worker_end_times_ms = new double[_parallel_gc_threads]; - _par_last_gc_worker_times_ms = new double[_parallel_gc_threads]; - _par_last_gc_worker_other_times_ms = new double[_parallel_gc_threads]; - - int index; - if (ParallelGCThreads == 0) - index = 0; - else if (ParallelGCThreads > 8) - index = 7; - else - index = ParallelGCThreads - 1; + int index = MIN2(_parallel_gc_threads - 1, 7); _pending_card_diff_seq->add(0.0); _rs_length_diff_seq->add(rs_length_diff_defaults[index]); @@ -824,7 +739,7 @@ G1CollectorPolicy::verify_young_ages(HeapRegion* head, #endif // PRODUCT void G1CollectorPolicy::record_full_collection_start() { - _cur_collection_start_sec = os::elapsedTime(); + _full_collection_start_sec = os::elapsedTime(); // Release the future to-space so that it is available for compaction into. _g1->set_full_collection(); } @@ -833,7 +748,7 @@ void G1CollectorPolicy::record_full_collection_end() { // Consider this like a collection pause for the purposes of allocation // since last pause. double end_sec = os::elapsedTime(); - double full_gc_time_sec = end_sec - _cur_collection_start_sec; + double full_gc_time_sec = end_sec - _full_collection_start_sec; double full_gc_time_ms = full_gc_time_sec * 1000.0; _trace_gen1_time_data.record_full_collection(full_gc_time_ms); @@ -869,12 +784,6 @@ void G1CollectorPolicy::record_stop_world_start() { void G1CollectorPolicy::record_collection_pause_start(double start_time_sec, size_t start_used) { - if (G1Log::finer()) { - gclog_or_tty->stamp(PrintGCTimeStamps); - gclog_or_tty->print("[%s", (const char*)GCCauseString("GC pause", _g1->gc_cause()) - .append(gcs_are_young() ? " (young)" : " (mixed)")); - } - // We only need to do this here as the policy will only be applied // to the GC we're about to start. so, no point is calculating this // every time we calculate / recalculate the target young length. @@ -888,7 +797,7 @@ void G1CollectorPolicy::record_collection_pause_start(double start_time_sec, _trace_gen0_time_data.record_start_collection(s_w_t_ms); _stop_world_start = 0.0; - _cur_collection_start_sec = start_time_sec; + phase_times()->_cur_collection_start_sec = start_time_sec; _cur_collection_pause_used_at_start_bytes = start_used; _cur_collection_pause_used_regions_at_start = _g1->used_regions(); _pending_cards = _g1->pending_card_num(); @@ -902,30 +811,6 @@ void G1CollectorPolicy::record_collection_pause_start(double start_time_sec, _survivor_bytes_before_gc = young_list->survivor_used_bytes(); _capacity_before_gc = _g1->capacity(); -#ifdef DEBUG - // initialise these to something well known so that we can spot - // if they are not set properly - - for (int i = 0; i < _parallel_gc_threads; ++i) { - _par_last_gc_worker_start_times_ms[i] = -1234.0; - _par_last_ext_root_scan_times_ms[i] = -1234.0; - _par_last_satb_filtering_times_ms[i] = -1234.0; - _par_last_update_rs_times_ms[i] = -1234.0; - _par_last_update_rs_processed_buffers[i] = -1234.0; - _par_last_scan_rs_times_ms[i] = -1234.0; - _par_last_obj_copy_times_ms[i] = -1234.0; - _par_last_termination_times_ms[i] = -1234.0; - _par_last_termination_attempts[i] = -1234.0; - _par_last_gc_worker_end_times_ms[i] = -1234.0; - _par_last_gc_worker_times_ms[i] = -1234.0; - _par_last_gc_worker_other_times_ms[i] = -1234.0; - } -#endif - - // This is initialized to zero here and is set during the evacuation - // pause if we actually waited for the root region scanning to finish. - _root_region_scan_wait_time_ms = 0.0; - _last_gc_was_young = false; // do that for any other surv rate groups @@ -974,127 +859,6 @@ void G1CollectorPolicy::record_concurrent_pause() { } } -void G1CollectorPolicy::record_concurrent_pause_end() { -} - -template -T sum_of(T* sum_arr, int start, int n, int N) { - T sum = (T)0; - for (int i = 0; i < n; i++) { - int j = (start + i) % N; - sum += sum_arr[j]; - } - return sum; -} - -void G1CollectorPolicy::print_par_stats(int level, - const char* str, - double* data, - bool showDecimals) { - double min = data[0], max = data[0]; - double total = 0.0; - LineBuffer buf(level); - buf.append("[%s (ms):", str); - for (uint i = 0; i < no_of_gc_threads(); ++i) { - double val = data[i]; - if (val < min) - min = val; - if (val > max) - max = val; - total += val; - if (G1Log::finest()) { - if (showDecimals) { - buf.append(" %.1lf", val); - } else { - buf.append(" %d", (int)val); - } - } - } - - if (G1Log::finest()) { - buf.append_and_print_cr(""); - } - double avg = total / (double) no_of_gc_threads(); - if (showDecimals) { - buf.append_and_print_cr(" Min: %.1lf, Avg: %.1lf, Max: %.1lf, Diff: %.1lf, Sum: %.1lf]", - min, avg, max, max - min, total); - } else { - buf.append_and_print_cr(" Min: %d, Avg: %d, Max: %d, Diff: %d, Sum: %d]", - (int)min, (int)avg, (int)max, (int)max - (int)min, (int)total); - } -} - -void G1CollectorPolicy::print_stats(int level, - const char* str, - double value) { - LineBuffer(level).append_and_print_cr("[%s: %.1lf ms]", str, value); -} - -void G1CollectorPolicy::print_stats(int level, - const char* str, - double value, - int workers) { - LineBuffer(level).append_and_print_cr("[%s: %.1lf ms, GC Workers: %d]", str, value, workers); -} - -void G1CollectorPolicy::print_stats(int level, - const char* str, - int value) { - LineBuffer(level).append_and_print_cr("[%s: %d]", str, value); -} - -double G1CollectorPolicy::avg_value(double* data) { - if (G1CollectedHeap::use_parallel_gc_threads()) { - double ret = 0.0; - for (uint i = 0; i < no_of_gc_threads(); ++i) { - ret += data[i]; - } - return ret / (double) no_of_gc_threads(); - } else { - return data[0]; - } -} - -double G1CollectorPolicy::max_value(double* data) { - if (G1CollectedHeap::use_parallel_gc_threads()) { - double ret = data[0]; - for (uint i = 1; i < no_of_gc_threads(); ++i) { - if (data[i] > ret) { - ret = data[i]; - } - } - return ret; - } else { - return data[0]; - } -} - -double G1CollectorPolicy::sum_of_values(double* data) { - if (G1CollectedHeap::use_parallel_gc_threads()) { - double sum = 0.0; - for (uint i = 0; i < no_of_gc_threads(); i++) { - sum += data[i]; - } - return sum; - } else { - return data[0]; - } -} - -double G1CollectorPolicy::max_sum(double* data1, double* data2) { - double ret = data1[0] + data2[0]; - - if (G1CollectedHeap::use_parallel_gc_threads()) { - for (uint i = 1; i < no_of_gc_threads(); ++i) { - double data = data1[i] + data2[i]; - if (data > ret) { - ret = data; - } - } - } - return ret; -} - bool G1CollectorPolicy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) { if (_g1->concurrent_mark()->cmThread()->during_cycle()) { return false; @@ -1142,10 +906,8 @@ bool G1CollectorPolicy::need_to_start_conc_mark(const char* source, size_t alloc // Anything below that is considered to be zero #define MIN_TIMER_GRANULARITY 0.0000001 -void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { +void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms) { double end_time_sec = os::elapsedTime(); - double elapsed_ms = _last_pause_time_ms; - bool parallel = G1CollectedHeap::use_parallel_gc_threads(); assert(_cur_collection_pause_used_regions_at_start >= cset_region_length(), "otherwise, the subtraction below does not make sense"); size_t rs_size = @@ -1154,7 +916,6 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); bool last_pause_included_initial_mark = false; bool update_stats = !_g1->evacuation_failed(); - set_no_of_gc_threads(no_of_gc_threads); #ifndef PRODUCT if (G1YoungSurvRateVerbose) { @@ -1174,7 +935,7 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { set_initiate_conc_mark_if_possible(); } - _mmu_tracker->add_pause(end_time_sec - elapsed_ms/1000.0, + _mmu_tracker->add_pause(end_time_sec - pause_time_ms/1000.0, end_time_sec, false); size_t freed_bytes = @@ -1185,58 +946,11 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { (double)surviving_bytes/ (double)_collection_set_bytes_used_before; - // These values are used to update the summary information that is - // displayed when TraceGen0Time is enabled, and are output as part - // of the "finer" output, in the non-parallel case. - - double ext_root_scan_time = avg_value(_par_last_ext_root_scan_times_ms); - double satb_filtering_time = avg_value(_par_last_satb_filtering_times_ms); - double update_rs_time = avg_value(_par_last_update_rs_times_ms); - double update_rs_processed_buffers = - sum_of_values(_par_last_update_rs_processed_buffers); - double scan_rs_time = avg_value(_par_last_scan_rs_times_ms); - double obj_copy_time = avg_value(_par_last_obj_copy_times_ms); - double termination_time = avg_value(_par_last_termination_times_ms); - - double known_time = ext_root_scan_time + - satb_filtering_time + - update_rs_time + - scan_rs_time + - obj_copy_time; - - double other_time_ms = elapsed_ms; - - // Subtract the root region scanning wait time. It's initialized to - // zero at the start of the pause. - other_time_ms -= _root_region_scan_wait_time_ms; - - if (parallel) { - other_time_ms -= _cur_collection_par_time_ms; - } else { - other_time_ms -= known_time; - } - - // Now subtract the time taken to fix up roots in generated code - other_time_ms -= _cur_collection_code_root_fixup_time_ms; - - // Subtract the time taken to clean the card table from the - // current value of "other time" - other_time_ms -= _cur_clear_ct_time_ms; - - // TraceGen0Time and TraceGen1Time summary info updating. - if (update_stats) { - double parallel_known_time = known_time + termination_time; - double parallel_other_time = _cur_collection_par_time_ms - parallel_known_time; - - _trace_gen0_time_data.record_end_collection( - elapsed_ms, other_time_ms, _root_region_scan_wait_time_ms, _cur_collection_par_time_ms, - ext_root_scan_time, satb_filtering_time, update_rs_time, scan_rs_time, obj_copy_time, - termination_time, parallel_other_time, _cur_clear_ct_time_ms); - + _trace_gen0_time_data.record_end_collection(pause_time_ms, phase_times()); // this is where we update the allocation rate of the application double app_time_ms = - (_cur_collection_start_sec * 1000.0 - _prev_collection_pause_end_ms); + (phase_times()->_cur_collection_start_sec * 1000.0 - _prev_collection_pause_end_ms); if (app_time_ms < MIN_TIMER_GRANULARITY) { // This usually happens due to the timer not having the required // granularity. Some Linuxes are the usual culprits. @@ -1257,7 +971,7 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { double interval_ms = (end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0; - update_recent_gc_times(end_time_sec, elapsed_ms); + update_recent_gc_times(end_time_sec, pause_time_ms); _recent_avg_pause_time_ratio = _recent_gc_times_ms->sum()/interval_ms; if (recent_avg_pause_time_ratio() < 0.0 || (recent_avg_pause_time_ratio() - 1.0 > 0.0)) { @@ -1284,90 +998,6 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { } } } - - if (G1Log::finer()) { - bool print_marking_info = - _g1->mark_in_progress() && !last_pause_included_initial_mark; - - gclog_or_tty->print_cr("%s, %1.8lf secs]", - (last_pause_included_initial_mark) ? " (initial-mark)" : "", - elapsed_ms / 1000.0); - - if (_root_region_scan_wait_time_ms > 0.0) { - print_stats(1, "Root Region Scan Waiting", _root_region_scan_wait_time_ms); - } - if (parallel) { - print_stats(1, "Parallel Time", _cur_collection_par_time_ms, no_of_gc_threads); - print_par_stats(2, "GC Worker Start", _par_last_gc_worker_start_times_ms); - print_par_stats(2, "Ext Root Scanning", _par_last_ext_root_scan_times_ms); - if (print_marking_info) { - print_par_stats(2, "SATB Filtering", _par_last_satb_filtering_times_ms); - } - print_par_stats(2, "Update RS", _par_last_update_rs_times_ms); - if (G1Log::finest()) { - print_par_stats(3, "Processed Buffers", _par_last_update_rs_processed_buffers, - false /* showDecimals */); - } - print_par_stats(2, "Scan RS", _par_last_scan_rs_times_ms); - print_par_stats(2, "Object Copy", _par_last_obj_copy_times_ms); - print_par_stats(2, "Termination", _par_last_termination_times_ms); - if (G1Log::finest()) { - print_par_stats(3, "Termination Attempts", _par_last_termination_attempts, - false /* showDecimals */); - } - - for (int i = 0; i < _parallel_gc_threads; i++) { - _par_last_gc_worker_times_ms[i] = _par_last_gc_worker_end_times_ms[i] - - _par_last_gc_worker_start_times_ms[i]; - - double worker_known_time = _par_last_ext_root_scan_times_ms[i] + - _par_last_satb_filtering_times_ms[i] + - _par_last_update_rs_times_ms[i] + - _par_last_scan_rs_times_ms[i] + - _par_last_obj_copy_times_ms[i] + - _par_last_termination_times_ms[i]; - - _par_last_gc_worker_other_times_ms[i] = _par_last_gc_worker_times_ms[i] - - worker_known_time; - } - - print_par_stats(2, "GC Worker Other", _par_last_gc_worker_other_times_ms); - print_par_stats(2, "GC Worker Total", _par_last_gc_worker_times_ms); - print_par_stats(2, "GC Worker End", _par_last_gc_worker_end_times_ms); - } else { - print_stats(1, "Ext Root Scanning", ext_root_scan_time); - if (print_marking_info) { - print_stats(1, "SATB Filtering", satb_filtering_time); - } - print_stats(1, "Update RS", update_rs_time); - if (G1Log::finest()) { - print_stats(2, "Processed Buffers", (int)update_rs_processed_buffers); - } - print_stats(1, "Scan RS", scan_rs_time); - print_stats(1, "Object Copying", obj_copy_time); - } - print_stats(1, "Code Root Fixup", _cur_collection_code_root_fixup_time_ms); - print_stats(1, "Clear CT", _cur_clear_ct_time_ms); -#ifndef PRODUCT - print_stats(1, "Cur Clear CC", _cur_clear_cc_time_ms); - print_stats(1, "Cum Clear CC", _cum_clear_cc_time_ms); - print_stats(1, "Min Clear CC", _min_clear_cc_time_ms); - print_stats(1, "Max Clear CC", _max_clear_cc_time_ms); - if (_num_cc_clears > 0) { - print_stats(1, "Avg Clear CC", _cum_clear_cc_time_ms / ((double)_num_cc_clears)); - } -#endif - print_stats(1, "Other", other_time_ms); - print_stats(2, "Choose CSet", - (_recorded_young_cset_choice_time_ms + - _recorded_non_young_cset_choice_time_ms)); - print_stats(2, "Ref Proc", _cur_ref_proc_time_ms); - print_stats(2, "Ref Enq", _cur_ref_enq_time_ms); - print_stats(2, "Free CSet", - (_recorded_young_free_cset_time_ms + - _recorded_non_young_free_cset_time_ms)); - } - bool new_in_marking_window = _in_marking_window; bool new_in_marking_window_im = false; if (during_initial_mark_pause()) { @@ -1406,8 +1036,6 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { // do that for any other surv rate groupsx if (update_stats) { - double pause_time_ms = elapsed_ms; - size_t diff = 0; if (_max_pending_cards >= _pending_cards) { diff = _max_pending_cards - _pending_cards; @@ -1416,7 +1044,7 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { double cost_per_card_ms = 0.0; if (_pending_cards > 0) { - cost_per_card_ms = update_rs_time / (double) _pending_cards; + cost_per_card_ms = phase_times()->_update_rs_time / (double) _pending_cards; _cost_per_card_ms_seq->add(cost_per_card_ms); } @@ -1424,7 +1052,7 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { double cost_per_entry_ms = 0.0; if (cards_scanned > 10) { - cost_per_entry_ms = scan_rs_time / (double) cards_scanned; + cost_per_entry_ms = phase_times()->_scan_rs_time / (double) cards_scanned; if (_last_gc_was_young) { _cost_per_entry_ms_seq->add(cost_per_entry_ms); } else { @@ -1464,7 +1092,7 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { size_t copied_bytes = surviving_bytes; double cost_per_byte_ms = 0.0; if (copied_bytes > 0) { - cost_per_byte_ms = obj_copy_time / (double) copied_bytes; + cost_per_byte_ms = phase_times()->_obj_copy_time / (double) copied_bytes; if (_in_marking_window) { _cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms); } else { @@ -1473,21 +1101,21 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { } double all_other_time_ms = pause_time_ms - - (update_rs_time + scan_rs_time + obj_copy_time + termination_time); + (phase_times()->_update_rs_time + phase_times()->_scan_rs_time + phase_times()->_obj_copy_time + phase_times()->_termination_time); double young_other_time_ms = 0.0; if (young_cset_region_length() > 0) { young_other_time_ms = - _recorded_young_cset_choice_time_ms + - _recorded_young_free_cset_time_ms; + phase_times()->_recorded_young_cset_choice_time_ms + + phase_times()->_recorded_young_free_cset_time_ms; _young_other_cost_per_region_ms_seq->add(young_other_time_ms / (double) young_cset_region_length()); } double non_young_other_time_ms = 0.0; if (old_cset_region_length() > 0) { non_young_other_time_ms = - _recorded_non_young_cset_choice_time_ms + - _recorded_non_young_free_cset_time_ms; + phase_times()->_recorded_non_young_cset_choice_time_ms + + phase_times()->_recorded_non_young_free_cset_time_ms; _non_young_other_cost_per_region_ms_seq->add(non_young_other_time_ms / (double) old_cset_region_length()); @@ -1514,7 +1142,7 @@ void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { // Note that _mmu_tracker->max_gc_time() returns the time in seconds. double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; - adjust_concurrent_refinement(update_rs_time, update_rs_processed_buffers, update_rs_time_goal_ms); + adjust_concurrent_refinement(phase_times()->_update_rs_time, phase_times()->_update_rs_processed_buffers, update_rs_time_goal_ms); _collectionSetChooser->verify(); } @@ -2323,7 +1951,7 @@ void G1CollectorPolicy::finalize_cset(double target_pause_time_ms) { set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths); double young_end_time_sec = os::elapsedTime(); - _recorded_young_cset_choice_time_ms = + phase_times()->_recorded_young_cset_choice_time_ms = (young_end_time_sec - young_start_time_sec) * 1000.0; // We are doing young collections so reset this. @@ -2439,7 +2067,7 @@ void G1CollectorPolicy::finalize_cset(double target_pause_time_ms) { predicted_pause_time_ms, target_pause_time_ms); double non_young_end_time_sec = os::elapsedTime(); - _recorded_non_young_cset_choice_time_ms = + phase_times()->_recorded_non_young_cset_choice_time_ms = (non_young_end_time_sec - non_young_start_time_sec) * 1000.0; } @@ -2455,33 +2083,29 @@ void TraceGen0TimeData::record_yield_time(double yield_time_ms) { } } -void TraceGen0TimeData::record_end_collection( - double total_ms, - double other_ms, - double root_region_scan_wait_ms, - double parallel_ms, - double ext_root_scan_ms, - double satb_filtering_ms, - double update_rs_ms, - double scan_rs_ms, - double obj_copy_ms, - double termination_ms, - double parallel_other_ms, - double clear_ct_ms) -{ +void TraceGen0TimeData::record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times) { if(TraceGen0Time) { - _total.add(total_ms); - _other.add(other_ms); - _root_region_scan_wait.add(root_region_scan_wait_ms); - _parallel.add(parallel_ms); - _ext_root_scan.add(ext_root_scan_ms); - _satb_filtering.add(satb_filtering_ms); - _update_rs.add(update_rs_ms); - _scan_rs.add(scan_rs_ms); - _obj_copy.add(obj_copy_ms); - _termination.add(termination_ms); - _parallel_other.add(parallel_other_ms); - _clear_ct.add(clear_ct_ms); + _total.add(pause_time_ms); + _other.add(pause_time_ms - phase_times->accounted_time_ms()); + _root_region_scan_wait.add(phase_times->_root_region_scan_wait_time_ms); + _parallel.add(phase_times->_cur_collection_par_time_ms); + _ext_root_scan.add(phase_times->_ext_root_scan_time); + _satb_filtering.add(phase_times->_satb_filtering_time); + _update_rs.add(phase_times->_update_rs_time); + _scan_rs.add(phase_times->_scan_rs_time); + _obj_copy.add(phase_times->_obj_copy_time); + _termination.add(phase_times->_termination_time); + + double parallel_known_time = phase_times->_ext_root_scan_time + + phase_times->_satb_filtering_time + + phase_times->_update_rs_time + + phase_times->_scan_rs_time + + phase_times->_obj_copy_time + + + phase_times->_termination_time; + + double parallel_other_time = phase_times->_cur_collection_par_time_ms - parallel_known_time; + _parallel_other.add(parallel_other_time); + _clear_ct.add(phase_times->_cur_clear_ct_time_ms); } } @@ -2497,20 +2121,18 @@ void TraceGen0TimeData::increment_mixed_collection_count() { } } -void TraceGen0TimeData::print_summary(int level, - const char* str, +void TraceGen0TimeData::print_summary(const char* str, const NumberSeq* seq) const { double sum = seq->sum(); - LineBuffer(level + 1).append_and_print_cr("%-24s = %8.2lf s (avg = %8.2lf ms)", + gclog_or_tty->print_cr("%-27s = %8.2lf s (avg = %8.2lf ms)", str, sum / 1000.0, seq->avg()); } -void TraceGen0TimeData::print_summary_sd(int level, - const char* str, +void TraceGen0TimeData::print_summary_sd(const char* str, const NumberSeq* seq) const { - print_summary(level, str, seq); - LineBuffer(level + 6).append_and_print_cr("(num = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", - seq->num(), seq->sd(), seq->maximum()); + print_summary(str, seq); + gclog_or_tty->print_cr("%+45s = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", + "(num", seq->num(), seq->sd(), seq->maximum()); } void TraceGen0TimeData::print() const { @@ -2519,7 +2141,7 @@ void TraceGen0TimeData::print() const { } gclog_or_tty->print_cr("ALL PAUSES"); - print_summary_sd(0, "Total", &_total); + print_summary_sd(" Total", &_total); gclog_or_tty->print_cr(""); gclog_or_tty->print_cr(""); gclog_or_tty->print_cr(" Young GC Pauses: %8d", _young_pause_num); @@ -2531,24 +2153,24 @@ void TraceGen0TimeData::print() const { if (_young_pause_num == 0 && _mixed_pause_num == 0) { gclog_or_tty->print_cr("none"); } else { - print_summary_sd(0, "Evacuation Pauses", &_total); - print_summary(1, "Root Region Scan Wait", &_root_region_scan_wait); - print_summary(1, "Parallel Time", &_parallel); - print_summary(2, "Ext Root Scanning", &_ext_root_scan); - print_summary(2, "SATB Filtering", &_satb_filtering); - print_summary(2, "Update RS", &_update_rs); - print_summary(2, "Scan RS", &_scan_rs); - print_summary(2, "Object Copy", &_obj_copy); - print_summary(2, "Termination", &_termination); - print_summary(2, "Parallel Other", &_parallel_other); - print_summary(1, "Clear CT", &_clear_ct); - print_summary(1, "Other", &_other); + print_summary_sd(" Evacuation Pauses", &_total); + print_summary(" Root Region Scan Wait", &_root_region_scan_wait); + print_summary(" Parallel Time", &_parallel); + print_summary(" Ext Root Scanning", &_ext_root_scan); + print_summary(" SATB Filtering", &_satb_filtering); + print_summary(" Update RS", &_update_rs); + print_summary(" Scan RS", &_scan_rs); + print_summary(" Object Copy", &_obj_copy); + print_summary(" Termination", &_termination); + print_summary(" Parallel Other", &_parallel_other); + print_summary(" Clear CT", &_clear_ct); + print_summary(" Other", &_other); } gclog_or_tty->print_cr(""); gclog_or_tty->print_cr("MISC"); - print_summary_sd(0, "Stop World", &_all_stop_world_times_ms); - print_summary_sd(0, "Yields", &_all_yield_times_ms); + print_summary_sd(" Stop World", &_all_stop_world_times_ms); + print_summary_sd(" Yields", &_all_yield_times_ms); } void TraceGen1TimeData::record_full_collection(double full_gc_time_ms) { diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp index b3b839752b9..5965f2240a7 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp @@ -36,6 +36,7 @@ class HeapRegion; class CollectionSetChooser; +class G1GCPhaseTimes; // TraceGen0Time collects data on _both_ young and mixed evacuation pauses // (the latter may contain non-young regions - i.e. regions that are @@ -61,26 +62,14 @@ class TraceGen0TimeData : public CHeapObj { NumberSeq _parallel_other; NumberSeq _clear_ct; - void print_summary (int level, const char* str, const NumberSeq* seq) const; - void print_summary_sd (int level, const char* str, const NumberSeq* seq) const; + void print_summary(const char* str, const NumberSeq* seq) const; + void print_summary_sd(const char* str, const NumberSeq* seq) const; public: TraceGen0TimeData() : _young_pause_num(0), _mixed_pause_num(0) {}; void record_start_collection(double time_to_stop_the_world_ms); void record_yield_time(double yield_time_ms); - void record_end_collection( - double total_ms, - double other_ms, - double root_region_scan_wait_ms, - double parallel_ms, - double ext_root_scan_ms, - double satb_filtering_ms, - double update_rs_ms, - double scan_rs_ms, - double obj_copy_ms, - double termination_ms, - double parallel_other_ms, - double clear_ct_ms); + void record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times); void increment_young_collection_count(); void increment_mixed_collection_count(); void print() const; @@ -186,25 +175,9 @@ private: CollectionSetChooser* _collectionSetChooser; - double _cur_collection_start_sec; + double _full_collection_start_sec; size_t _cur_collection_pause_used_at_start_bytes; uint _cur_collection_pause_used_regions_at_start; - double _cur_collection_par_time_ms; - - double _cur_collection_code_root_fixup_time_ms; - - double _cur_clear_ct_time_ms; - double _cur_ref_proc_time_ms; - double _cur_ref_enq_time_ms; - -#ifndef PRODUCT - // Card Table Count Cache stats - double _min_clear_cc_time_ms; // min - double _max_clear_cc_time_ms; // max - double _cur_clear_cc_time_ms; // clearing time during current pause - double _cum_clear_cc_time_ms; // cummulative clearing time - jlong _num_cc_clears; // number of times the card count cache has been cleared -#endif // These exclude marking times. TruncatedSeq* _recent_gc_times_ms; @@ -217,23 +190,6 @@ private: double _stop_world_start; - double* _par_last_gc_worker_start_times_ms; - double* _par_last_ext_root_scan_times_ms; - double* _par_last_satb_filtering_times_ms; - double* _par_last_update_rs_times_ms; - double* _par_last_update_rs_processed_buffers; - double* _par_last_scan_rs_times_ms; - double* _par_last_obj_copy_times_ms; - double* _par_last_termination_times_ms; - double* _par_last_termination_attempts; - double* _par_last_gc_worker_end_times_ms; - double* _par_last_gc_worker_times_ms; - - // Each workers 'other' time i.e. the elapsed time of the parallel - // code executed by a worker minus the sum of the individual sub-phase - // times for that worker thread. - double* _par_last_gc_worker_other_times_ms; - // indicates whether we are in young or mixed GC mode bool _gcs_are_young; @@ -306,10 +262,6 @@ private: size_t _recorded_rs_lengths; size_t _max_rs_lengths; - - double _recorded_young_free_cset_time_ms; - double _recorded_non_young_free_cset_time_ms; - double _sigma; size_t _rs_lengths_prediction; @@ -341,8 +293,7 @@ private: void set_no_of_gc_threads(uintx v) { _no_of_gc_threads = v; } double _pause_time_target_ms; - double _recorded_young_cset_choice_time_ms; - double _recorded_non_young_cset_choice_time_ms; + size_t _pending_cards; size_t _max_pending_cards; @@ -497,14 +448,6 @@ public: uint young_cset_region_length() { return eden_cset_region_length() + survivor_cset_region_length(); } - void record_young_free_cset_time_ms(double time_ms) { - _recorded_young_free_cset_time_ms = time_ms; - } - - void record_non_young_free_cset_time_ms(double time_ms) { - _recorded_non_young_free_cset_time_ms = time_ms; - } - double predict_survivor_regions_evac_time(); void cset_regions_freed() { @@ -552,19 +495,6 @@ public: } private: - void print_stats(int level, const char* str, double value); - void print_stats(int level, const char* str, double value, int workers); - void print_stats(int level, const char* str, int value); - - void print_par_stats(int level, const char* str, double* data, bool showDecimals = true); - - double avg_value (double* data); - double max_value (double* data); - double sum_of_values (double* data); - double max_sum (double* data1, double* data2); - - double _last_pause_time_ms; - size_t _bytes_in_collection_set_before_gc; size_t _bytes_copied_during_gc; @@ -638,6 +568,8 @@ private: // Stash a pointer to the g1 heap. G1CollectedHeap* _g1; + G1GCPhaseTimes* _phase_times; + // The ratio of gc time to elapsed time, computed over recent pauses. double _recent_avg_pause_time_ratio; @@ -677,7 +609,6 @@ private: double _cur_mark_stop_world_time_ms; double _mark_remark_start_sec; double _mark_cleanup_start_sec; - double _root_region_scan_wait_time_ms; // Update the young list target length either by setting it to the // desired fixed value or by calculating it using G1's pause @@ -728,6 +659,8 @@ public: return CollectorPolicy::G1CollectorPolicyKind; } + G1GCPhaseTimes* phase_times() const { return _phase_times; } + // Check the current value of the young list RSet lengths and // compare it against the last prediction. If the current value is // higher, recalculate the young list target length prediction. @@ -772,10 +705,6 @@ public: void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms); - void record_root_region_scan_wait_time(double time_ms) { - _root_region_scan_wait_time_ms = time_ms; - } - void record_concurrent_mark_remark_start(); void record_concurrent_mark_remark_end(); @@ -784,97 +713,14 @@ public: void record_concurrent_mark_cleanup_completed(); void record_concurrent_pause(); - void record_concurrent_pause_end(); - void record_collection_pause_end(int no_of_gc_threads); + void record_collection_pause_end(double pause_time); void print_heap_transition(); // Record the fact that a full collection occurred. void record_full_collection_start(); void record_full_collection_end(); - void record_gc_worker_start_time(int worker_i, double ms) { - _par_last_gc_worker_start_times_ms[worker_i] = ms; - } - - void record_ext_root_scan_time(int worker_i, double ms) { - _par_last_ext_root_scan_times_ms[worker_i] = ms; - } - - void record_satb_filtering_time(int worker_i, double ms) { - _par_last_satb_filtering_times_ms[worker_i] = ms; - } - - void record_update_rs_time(int thread, double ms) { - _par_last_update_rs_times_ms[thread] = ms; - } - - void record_update_rs_processed_buffers (int thread, - double processed_buffers) { - _par_last_update_rs_processed_buffers[thread] = processed_buffers; - } - - void record_scan_rs_time(int thread, double ms) { - _par_last_scan_rs_times_ms[thread] = ms; - } - - void reset_obj_copy_time(int thread) { - _par_last_obj_copy_times_ms[thread] = 0.0; - } - - void reset_obj_copy_time() { - reset_obj_copy_time(0); - } - - void record_obj_copy_time(int thread, double ms) { - _par_last_obj_copy_times_ms[thread] += ms; - } - - void record_termination(int thread, double ms, size_t attempts) { - _par_last_termination_times_ms[thread] = ms; - _par_last_termination_attempts[thread] = (double) attempts; - } - - void record_gc_worker_end_time(int worker_i, double ms) { - _par_last_gc_worker_end_times_ms[worker_i] = ms; - } - - void record_pause_time_ms(double ms) { - _last_pause_time_ms = ms; - } - - void record_clear_ct_time(double ms) { - _cur_clear_ct_time_ms = ms; - } - - void record_par_time(double ms) { - _cur_collection_par_time_ms = ms; - } - - void record_code_root_fixup_time(double ms) { - _cur_collection_code_root_fixup_time_ms = ms; - } - - void record_ref_proc_time(double ms) { - _cur_ref_proc_time_ms = ms; - } - - void record_ref_enq_time(double ms) { - _cur_ref_enq_time_ms = ms; - } - -#ifndef PRODUCT - void record_cc_clear_time(double ms) { - if (_min_clear_cc_time_ms < 0.0 || ms <= _min_clear_cc_time_ms) - _min_clear_cc_time_ms = ms; - if (_max_clear_cc_time_ms < 0.0 || ms >= _max_clear_cc_time_ms) - _max_clear_cc_time_ms = ms; - _cur_clear_cc_time_ms = ms; - _cum_clear_cc_time_ms += ms; - _num_cc_clears++; - } -#endif - // Record how much space we copied during a GC. This is typically // called when a GC alloc region is being retired. void record_bytes_copied_during_gc(size_t bytes) { diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp new file mode 100644 index 00000000000..8bb9e552492 --- /dev/null +++ b/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp @@ -0,0 +1,379 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + + +#include "precompiled.hpp" +#include "gc_implementation/g1/g1CollectedHeap.inline.hpp" +#include "gc_implementation/g1/g1GCPhaseTimes.hpp" +#include "gc_implementation/g1/g1Log.hpp" + +// Helper class for avoiding interleaved logging +class LineBuffer: public StackObj { + +private: + static const int BUFFER_LEN = 1024; + static const int INDENT_CHARS = 3; + char _buffer[BUFFER_LEN]; + int _indent_level; + int _cur; + + void vappend(const char* format, va_list ap) { + int res = vsnprintf(&_buffer[_cur], BUFFER_LEN - _cur, format, ap); + if (res != -1) { + _cur += res; + } else { + DEBUG_ONLY(warning("buffer too small in LineBuffer");) + _buffer[BUFFER_LEN -1] = 0; + _cur = BUFFER_LEN; // vsnprintf above should not add to _buffer if we are called again + } + } + +public: + explicit LineBuffer(int indent_level): _indent_level(indent_level), _cur(0) { + for (; (_cur < BUFFER_LEN && _cur < (_indent_level * INDENT_CHARS)); _cur++) { + _buffer[_cur] = ' '; + } + } + +#ifndef PRODUCT + ~LineBuffer() { + assert(_cur == _indent_level * INDENT_CHARS, "pending data in buffer - append_and_print_cr() not called?"); + } +#endif + + void append(const char* format, ...) { + va_list ap; + va_start(ap, format); + vappend(format, ap); + va_end(ap); + } + + void append_and_print_cr(const char* format, ...) { + va_list ap; + va_start(ap, format); + vappend(format, ap); + va_end(ap); + gclog_or_tty->print_cr("%s", _buffer); + _cur = _indent_level * INDENT_CHARS; + } +}; + +G1GCPhaseTimes::G1GCPhaseTimes(uint max_gc_threads) : + _max_gc_threads(max_gc_threads), + _min_clear_cc_time_ms(-1.0), + _max_clear_cc_time_ms(-1.0), + _cur_clear_cc_time_ms(0.0), + _cum_clear_cc_time_ms(0.0), + _num_cc_clears(0L) +{ + assert(max_gc_threads > 0, "Must have some GC threads"); + _par_last_gc_worker_start_times_ms = new double[_max_gc_threads]; + _par_last_ext_root_scan_times_ms = new double[_max_gc_threads]; + _par_last_satb_filtering_times_ms = new double[_max_gc_threads]; + _par_last_update_rs_times_ms = new double[_max_gc_threads]; + _par_last_update_rs_processed_buffers = new double[_max_gc_threads]; + _par_last_scan_rs_times_ms = new double[_max_gc_threads]; + _par_last_obj_copy_times_ms = new double[_max_gc_threads]; + _par_last_termination_times_ms = new double[_max_gc_threads]; + _par_last_termination_attempts = new double[_max_gc_threads]; + _par_last_gc_worker_end_times_ms = new double[_max_gc_threads]; + _par_last_gc_worker_times_ms = new double[_max_gc_threads]; + _par_last_gc_worker_other_times_ms = new double[_max_gc_threads]; +} + +void G1GCPhaseTimes::note_gc_start(double pause_start_time_sec, uint active_gc_threads, + bool is_young_gc, bool is_initial_mark_gc, GCCause::Cause gc_cause) { + assert(active_gc_threads > 0, "The number of threads must be > 0"); + assert(active_gc_threads <= _max_gc_threads, "The number of active threads must be <= the max nubmer of threads"); + _active_gc_threads = active_gc_threads; + _pause_start_time_sec = pause_start_time_sec; + _is_young_gc = is_young_gc; + _is_initial_mark_gc = is_initial_mark_gc; + _gc_cause = gc_cause; + +#ifdef ASSERT + // initialise the timing data to something well known so that we can spot + // if something is not set properly + + for (uint i = 0; i < _max_gc_threads; ++i) { + _par_last_gc_worker_start_times_ms[i] = -1234.0; + _par_last_ext_root_scan_times_ms[i] = -1234.0; + _par_last_satb_filtering_times_ms[i] = -1234.0; + _par_last_update_rs_times_ms[i] = -1234.0; + _par_last_update_rs_processed_buffers[i] = -1234.0; + _par_last_scan_rs_times_ms[i] = -1234.0; + _par_last_obj_copy_times_ms[i] = -1234.0; + _par_last_termination_times_ms[i] = -1234.0; + _par_last_termination_attempts[i] = -1234.0; + _par_last_gc_worker_end_times_ms[i] = -1234.0; + _par_last_gc_worker_times_ms[i] = -1234.0; + _par_last_gc_worker_other_times_ms[i] = -1234.0; + } +#endif +} + +void G1GCPhaseTimes::note_gc_end(double pause_end_time_sec) { + if (G1Log::fine()) { + double pause_time_ms = (pause_end_time_sec - _pause_start_time_sec) * MILLIUNITS; + + for (uint i = 0; i < _active_gc_threads; i++) { + _par_last_gc_worker_times_ms[i] = _par_last_gc_worker_end_times_ms[i] - + _par_last_gc_worker_start_times_ms[i]; + + double worker_known_time = _par_last_ext_root_scan_times_ms[i] + + _par_last_satb_filtering_times_ms[i] + + _par_last_update_rs_times_ms[i] + + _par_last_scan_rs_times_ms[i] + + _par_last_obj_copy_times_ms[i] + + _par_last_termination_times_ms[i]; + + _par_last_gc_worker_other_times_ms[i] = _par_last_gc_worker_times_ms[i] - + worker_known_time; + } + + print(pause_time_ms); + } + +} + +void G1GCPhaseTimes::print_par_stats(int level, + const char* str, + double* data, + bool showDecimals) { + double min = data[0], max = data[0]; + double total = 0.0; + LineBuffer buf(level); + buf.append("[%s (ms):", str); + for (uint i = 0; i < _active_gc_threads; ++i) { + double val = data[i]; + if (val < min) + min = val; + if (val > max) + max = val; + total += val; + if (G1Log::finest()) { + if (showDecimals) { + buf.append(" %.1lf", val); + } else { + buf.append(" %d", (int)val); + } + } + } + + if (G1Log::finest()) { + buf.append_and_print_cr(""); + } + double avg = total / (double) _active_gc_threads; + if (showDecimals) { + buf.append_and_print_cr(" Min: %.1lf, Avg: %.1lf, Max: %.1lf, Diff: %.1lf, Sum: %.1lf]", + min, avg, max, max - min, total); + } else { + buf.append_and_print_cr(" Min: %d, Avg: %d, Max: %d, Diff: %d, Sum: %d]", + (int)min, (int)avg, (int)max, (int)max - (int)min, (int)total); + } +} + +void G1GCPhaseTimes::print_stats(int level, const char* str, double value) { + LineBuffer(level).append_and_print_cr("[%s: %.1lf ms]", str, value); +} + +void G1GCPhaseTimes::print_stats(int level, const char* str, double value, int workers) { + LineBuffer(level).append_and_print_cr("[%s: %.1lf ms, GC Workers: %d]", str, value, workers); +} + +void G1GCPhaseTimes::print_stats(int level, const char* str, int value) { + LineBuffer(level).append_and_print_cr("[%s: %d]", str, value); +} + +double G1GCPhaseTimes::avg_value(double* data) { + if (G1CollectedHeap::use_parallel_gc_threads()) { + double ret = 0.0; + for (uint i = 0; i < _active_gc_threads; ++i) { + ret += data[i]; + } + return ret / (double) _active_gc_threads; + } else { + return data[0]; + } +} + +double G1GCPhaseTimes::max_value(double* data) { + if (G1CollectedHeap::use_parallel_gc_threads()) { + double ret = data[0]; + for (uint i = 1; i < _active_gc_threads; ++i) { + if (data[i] > ret) { + ret = data[i]; + } + } + return ret; + } else { + return data[0]; + } +} + +double G1GCPhaseTimes::sum_of_values(double* data) { + if (G1CollectedHeap::use_parallel_gc_threads()) { + double sum = 0.0; + for (uint i = 0; i < _active_gc_threads; i++) { + sum += data[i]; + } + return sum; + } else { + return data[0]; + } +} + +double G1GCPhaseTimes::max_sum(double* data1, double* data2) { + double ret = data1[0] + data2[0]; + + if (G1CollectedHeap::use_parallel_gc_threads()) { + for (uint i = 1; i < _active_gc_threads; ++i) { + double data = data1[i] + data2[i]; + if (data > ret) { + ret = data; + } + } + } + return ret; +} + +void G1GCPhaseTimes::collapse_par_times() { + _ext_root_scan_time = avg_value(_par_last_ext_root_scan_times_ms); + _satb_filtering_time = avg_value(_par_last_satb_filtering_times_ms); + _update_rs_time = avg_value(_par_last_update_rs_times_ms); + _update_rs_processed_buffers = + sum_of_values(_par_last_update_rs_processed_buffers); + _scan_rs_time = avg_value(_par_last_scan_rs_times_ms); + _obj_copy_time = avg_value(_par_last_obj_copy_times_ms); + _termination_time = avg_value(_par_last_termination_times_ms); +} + +double G1GCPhaseTimes::accounted_time_ms() { + // Subtract the root region scanning wait time. It's initialized to + // zero at the start of the pause. + double misc_time_ms = _root_region_scan_wait_time_ms; + + misc_time_ms += _cur_collection_par_time_ms; + + // Now subtract the time taken to fix up roots in generated code + misc_time_ms += _cur_collection_code_root_fixup_time_ms; + + // Subtract the time taken to clean the card table from the + // current value of "other time" + misc_time_ms += _cur_clear_ct_time_ms; + + return misc_time_ms; +} + +void G1GCPhaseTimes::print(double pause_time_ms) { + + if (PrintGCTimeStamps) { + gclog_or_tty->stamp(); + gclog_or_tty->print(": "); + } + + GCCauseString gc_cause_str = GCCauseString("GC pause", _gc_cause) + .append(_is_young_gc ? " (young)" : " (mixed)") + .append(_is_initial_mark_gc ? " (initial-mark)" : ""); + gclog_or_tty->print_cr("[%s, %3.7f secs]", (const char*)gc_cause_str, pause_time_ms / 1000.0); + + if (!G1Log::finer()) { + return; + } + + if (_root_region_scan_wait_time_ms > 0.0) { + print_stats(1, "Root Region Scan Waiting", _root_region_scan_wait_time_ms); + } + if (G1CollectedHeap::use_parallel_gc_threads()) { + print_stats(1, "Parallel Time", _cur_collection_par_time_ms, _active_gc_threads); + print_par_stats(2, "GC Worker Start", _par_last_gc_worker_start_times_ms); + print_par_stats(2, "Ext Root Scanning", _par_last_ext_root_scan_times_ms); + if (_satb_filtering_time > 0.0) { + print_par_stats(2, "SATB Filtering", _par_last_satb_filtering_times_ms); + } + print_par_stats(2, "Update RS", _par_last_update_rs_times_ms); + if (G1Log::finest()) { + print_par_stats(3, "Processed Buffers", _par_last_update_rs_processed_buffers, + false /* showDecimals */); + } + print_par_stats(2, "Scan RS", _par_last_scan_rs_times_ms); + print_par_stats(2, "Object Copy", _par_last_obj_copy_times_ms); + print_par_stats(2, "Termination", _par_last_termination_times_ms); + if (G1Log::finest()) { + print_par_stats(3, "Termination Attempts", _par_last_termination_attempts, + false /* showDecimals */); + } + print_par_stats(2, "GC Worker Other", _par_last_gc_worker_other_times_ms); + print_par_stats(2, "GC Worker Total", _par_last_gc_worker_times_ms); + print_par_stats(2, "GC Worker End", _par_last_gc_worker_end_times_ms); + } else { + print_stats(1, "Ext Root Scanning", _ext_root_scan_time); + if (_satb_filtering_time > 0.0) { + print_stats(1, "SATB Filtering", _satb_filtering_time); + } + print_stats(1, "Update RS", _update_rs_time); + if (G1Log::finest()) { + print_stats(2, "Processed Buffers", (int)_update_rs_processed_buffers); + } + print_stats(1, "Scan RS", _scan_rs_time); + print_stats(1, "Object Copying", _obj_copy_time); + } + print_stats(1, "Code Root Fixup", _cur_collection_code_root_fixup_time_ms); + print_stats(1, "Clear CT", _cur_clear_ct_time_ms); + if (Verbose && G1Log::finest()) { + print_stats(1, "Cur Clear CC", _cur_clear_cc_time_ms); + print_stats(1, "Cum Clear CC", _cum_clear_cc_time_ms); + print_stats(1, "Min Clear CC", _min_clear_cc_time_ms); + print_stats(1, "Max Clear CC", _max_clear_cc_time_ms); + if (_num_cc_clears > 0) { + print_stats(1, "Avg Clear CC", _cum_clear_cc_time_ms / ((double)_num_cc_clears)); + } + } + double misc_time_ms = pause_time_ms - accounted_time_ms(); + print_stats(1, "Other", misc_time_ms); + print_stats(2, "Choose CSet", + (_recorded_young_cset_choice_time_ms + + _recorded_non_young_cset_choice_time_ms)); + print_stats(2, "Ref Proc", _cur_ref_proc_time_ms); + print_stats(2, "Ref Enq", _cur_ref_enq_time_ms); + print_stats(2, "Free CSet", + (_recorded_young_free_cset_time_ms + + _recorded_non_young_free_cset_time_ms)); +} + +void G1GCPhaseTimes::record_cc_clear_time_ms(double ms) { + if (!(Verbose && G1Log::finest())) { + return; + } + + if (_min_clear_cc_time_ms < 0.0 || ms <= _min_clear_cc_time_ms) { + _min_clear_cc_time_ms = ms; + } + if (_max_clear_cc_time_ms < 0.0 || ms >= _max_clear_cc_time_ms) { + _max_clear_cc_time_ms = ms; + } + _cur_clear_cc_time_ms = ms; + _cum_clear_cc_time_ms += ms; + _num_cc_clears++; +} diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.hpp new file mode 100644 index 00000000000..abdfe9f7baa --- /dev/null +++ b/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.hpp @@ -0,0 +1,216 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1GCPHASETIMESLOG_HPP +#define SHARE_VM_GC_IMPLEMENTATION_G1_G1GCPHASETIMESLOG_HPP + +#include "memory/allocation.hpp" +#include "gc_interface/gcCause.hpp" + +class G1GCPhaseTimes : public CHeapObj { + friend class G1CollectorPolicy; + friend class TraceGen0TimeData; + + private: + uint _active_gc_threads; + uint _max_gc_threads; + + GCCause::Cause _gc_cause; + bool _is_young_gc; + bool _is_initial_mark_gc; + + double _pause_start_time_sec; + + double* _par_last_gc_worker_start_times_ms; + double* _par_last_ext_root_scan_times_ms; + double* _par_last_satb_filtering_times_ms; + double* _par_last_update_rs_times_ms; + double* _par_last_update_rs_processed_buffers; + double* _par_last_scan_rs_times_ms; + double* _par_last_obj_copy_times_ms; + double* _par_last_termination_times_ms; + double* _par_last_termination_attempts; + double* _par_last_gc_worker_end_times_ms; + double* _par_last_gc_worker_times_ms; + double* _par_last_gc_worker_other_times_ms; + + double _cur_collection_par_time_ms; + + double _cur_collection_code_root_fixup_time_ms; + + double _cur_clear_ct_time_ms; + double _cur_ref_proc_time_ms; + double _cur_ref_enq_time_ms; + + // Helper methods for detailed logging + void print_par_stats(int level, const char* str, double* data, bool showDecimals = true); + void print_stats(int level, const char* str, double value); + void print_stats(int level, const char* str, double value, int workers); + void print_stats(int level, const char* str, int value); + double avg_value(double* data); + double max_value(double* data); + double sum_of_values(double* data); + double max_sum(double* data1, double* data2); + double accounted_time_ms(); + + // Card Table Count Cache stats + double _min_clear_cc_time_ms; // min + double _max_clear_cc_time_ms; // max + double _cur_clear_cc_time_ms; // clearing time during current pause + double _cum_clear_cc_time_ms; // cummulative clearing time + jlong _num_cc_clears; // number of times the card count cache has been cleared + + // The following insance variables are directly accessed by G1CollectorPolicy + // and TraceGen0TimeData. This is why those classes are declared friends. + // An alternative is to add getters and setters for all of these fields. + // It might also be possible to restructure the code to reduce these + // dependencies. + double _ext_root_scan_time; + double _satb_filtering_time; + double _update_rs_time; + double _update_rs_processed_buffers; + double _scan_rs_time; + double _obj_copy_time; + double _termination_time; + + double _cur_collection_start_sec; + double _root_region_scan_wait_time_ms; + + double _recorded_young_cset_choice_time_ms; + double _recorded_non_young_cset_choice_time_ms; + + double _recorded_young_free_cset_time_ms; + double _recorded_non_young_free_cset_time_ms; + + void print(double pause_time_ms); + + public: + G1GCPhaseTimes(uint max_gc_threads); + void note_gc_start(double pause_start_time_sec, uint active_gc_threads, + bool is_young_gc, bool is_initial_mark_gc, GCCause::Cause gc_cause); + void note_gc_end(double pause_end_time_sec); + void collapse_par_times(); + + void record_gc_worker_start_time(uint worker_i, double ms) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_gc_worker_start_times_ms[worker_i] = ms; + } + + void record_ext_root_scan_time(uint worker_i, double ms) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_ext_root_scan_times_ms[worker_i] = ms; + } + + void record_satb_filtering_time(uint worker_i, double ms) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_satb_filtering_times_ms[worker_i] = ms; + } + + void record_update_rs_time(uint worker_i, double ms) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_update_rs_times_ms[worker_i] = ms; + } + + void record_update_rs_processed_buffers (uint worker_i, + double processed_buffers) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_update_rs_processed_buffers[worker_i] = processed_buffers; + } + + void record_scan_rs_time(uint worker_i, double ms) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_scan_rs_times_ms[worker_i] = ms; + } + + void reset_obj_copy_time(uint worker_i) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_obj_copy_times_ms[worker_i] = 0.0; + } + + void reset_obj_copy_time() { + reset_obj_copy_time(0); + } + + void record_obj_copy_time(uint worker_i, double ms) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_obj_copy_times_ms[worker_i] += ms; + } + + void record_termination(uint worker_i, double ms, size_t attempts) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_termination_times_ms[worker_i] = ms; + _par_last_termination_attempts[worker_i] = (double) attempts; + } + + void record_gc_worker_end_time(uint worker_i, double ms) { + assert(worker_i >= 0, "worker index must be > 0"); + assert(worker_i < _active_gc_threads, "worker index out of bounds"); + _par_last_gc_worker_end_times_ms[worker_i] = ms; + } + + void record_clear_ct_time(double ms) { + _cur_clear_ct_time_ms = ms; + } + + void record_par_time(double ms) { + _cur_collection_par_time_ms = ms; + } + + void record_code_root_fixup_time(double ms) { + _cur_collection_code_root_fixup_time_ms = ms; + } + + void record_ref_proc_time(double ms) { + _cur_ref_proc_time_ms = ms; + } + + void record_ref_enq_time(double ms) { + _cur_ref_enq_time_ms = ms; + } + + void record_root_region_scan_wait_time(double time_ms) { + _root_region_scan_wait_time_ms = time_ms; + } + + void record_cc_clear_time_ms(double ms); + + void record_young_free_cset_time_ms(double time_ms) { + _recorded_young_free_cset_time_ms = time_ms; + } + + void record_non_young_free_cset_time_ms(double time_ms) { + _recorded_non_young_free_cset_time_ms = time_ms; + } +}; + +#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1GCPHASETIMESLOG_HPP diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp index 1f366c8c676..3ca18090e74 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp @@ -29,6 +29,7 @@ #include "gc_implementation/g1/g1BlockOffsetTable.inline.hpp" #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" #include "gc_implementation/g1/g1CollectorPolicy.hpp" +#include "gc_implementation/g1/g1GCPhaseTimes.hpp" #include "gc_implementation/g1/g1OopClosures.inline.hpp" #include "gc_implementation/g1/g1RemSet.inline.hpp" #include "gc_implementation/g1/heapRegionSeq.inline.hpp" @@ -224,7 +225,7 @@ void G1RemSet::scanRS(OopsInHeapRegionClosure* oc, int worker_i) { assert( _cards_scanned != NULL, "invariant" ); _cards_scanned[worker_i] = scanRScl.cards_done(); - _g1p->record_scan_rs_time(worker_i, scan_rs_time_sec * 1000.0); + _g1p->phase_times()->record_scan_rs_time(worker_i, scan_rs_time_sec * 1000.0); } // Closure used for updating RSets and recording references that @@ -276,7 +277,7 @@ void G1RemSet::updateRS(DirtyCardQueue* into_cset_dcq, int worker_i) { guarantee(cl.n() == 0, "Card table should be clean."); } - _g1p->record_update_rs_time(worker_i, (os::elapsedTime() - start) * 1000.0); + _g1p->phase_times()->record_update_rs_time(worker_i, (os::elapsedTime() - start) * 1000.0); } class CountRSSizeClosure: public HeapRegionClosure { @@ -390,13 +391,13 @@ void G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc, if (G1UseParallelRSetUpdating || (worker_i == 0)) { updateRS(&into_cset_dcq, worker_i); } else { - _g1p->record_update_rs_processed_buffers(worker_i, 0.0); - _g1p->record_update_rs_time(worker_i, 0.0); + _g1p->phase_times()->record_update_rs_processed_buffers(worker_i, 0.0); + _g1p->phase_times()->record_update_rs_time(worker_i, 0.0); } if (G1UseParallelRSetScanning || (worker_i == 0)) { scanRS(oc, worker_i); } else { - _g1p->record_scan_rs_time(worker_i, 0.0); + _g1p->phase_times()->record_scan_rs_time(worker_i, 0.0); } // We now clear the cached values of _cset_rs_update_cl for this worker From e2fc7f742cf07dffb0a9c65c6cccfb07068677a0 Mon Sep 17 00:00:00 2001 From: Vlaidmir Ivanov Date: Wed, 11 Jul 2012 14:50:30 -0700 Subject: [PATCH 080/160] 7181658: CTW: assert(t->meet(t0) == t) failed: Not monotonic Use uncast node equivalence checks in CmpUNode::sub. Reviewed-by: kvn, twisti --- hotspot/src/share/vm/opto/subnode.cpp | 14 ++++++++------ hotspot/src/share/vm/opto/subnode.hpp | 1 + 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/hotspot/src/share/vm/opto/subnode.cpp b/hotspot/src/share/vm/opto/subnode.cpp index 4fbf5435394..02a6a64953c 100644 --- a/hotspot/src/share/vm/opto/subnode.cpp +++ b/hotspot/src/share/vm/opto/subnode.cpp @@ -554,9 +554,7 @@ const Type *CmpUNode::sub( const Type *t1, const Type *t2 ) const { return TypeInt::CC_GE; } else if (hi0 <= lo1) { // Check for special case in Hashtable::get. (See below.) - if ((jint)lo0 >= 0 && (jint)lo1 >= 0 && - in(1)->Opcode() == Op_ModI && - in(1)->in(2) == in(2) ) + if ((jint)lo0 >= 0 && (jint)lo1 >= 0 && is_index_range_check()) return TypeInt::CC_LT; return TypeInt::CC_LE; } @@ -567,13 +565,17 @@ const Type *CmpUNode::sub( const Type *t1, const Type *t2 ) const { // to be positive. // (This is a gross hack, since the sub method never // looks at the structure of the node in any other case.) - if ((jint)lo0 >= 0 && (jint)lo1 >= 0 && - in(1)->Opcode() == Op_ModI && - in(1)->in(2)->uncast() == in(2)->uncast()) + if ((jint)lo0 >= 0 && (jint)lo1 >= 0 && is_index_range_check()) return TypeInt::CC_LT; return TypeInt::CC; // else use worst case results } +bool CmpUNode::is_index_range_check() const { + // Check for the "(X ModI Y) CmpU Y" shape + return (in(1)->Opcode() == Op_ModI && + in(1)->in(2)->eqv_uncast(in(2))); +} + //------------------------------Idealize--------------------------------------- Node *CmpINode::Ideal( PhaseGVN *phase, bool can_reshape ) { if (phase->type(in(2))->higher_equal(TypeInt::ZERO)) { diff --git a/hotspot/src/share/vm/opto/subnode.hpp b/hotspot/src/share/vm/opto/subnode.hpp index bacd1065a0c..2b33e90f9e5 100644 --- a/hotspot/src/share/vm/opto/subnode.hpp +++ b/hotspot/src/share/vm/opto/subnode.hpp @@ -158,6 +158,7 @@ public: CmpUNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} virtual int Opcode() const; virtual const Type *sub( const Type *, const Type * ) const; + bool is_index_range_check() const; }; //------------------------------CmpPNode--------------------------------------- From e0cf9c652d68dd6b295f5de06539b8e2f269ac8d Mon Sep 17 00:00:00 2001 From: Michael Haupt Date: Thu, 12 Jul 2012 00:39:53 -0700 Subject: [PATCH 081/160] 6711908: JVM needs direct access to some annotations Add annotation extraction code to class file parser. Reviewed-by: twisti, jrose, kvn --- hotspot/src/share/vm/c1/c1_GraphBuilder.cpp | 6 +- hotspot/src/share/vm/ci/ciMethod.hpp | 2 + .../share/vm/classfile/classFileParser.cpp | 245 ++++++++++++++++-- .../share/vm/classfile/classFileParser.hpp | 97 ++++++- hotspot/src/share/vm/classfile/vmSymbols.hpp | 1 + hotspot/src/share/vm/oops/methodOop.hpp | 8 +- 6 files changed, 316 insertions(+), 43 deletions(-) diff --git a/hotspot/src/share/vm/c1/c1_GraphBuilder.cpp b/hotspot/src/share/vm/c1/c1_GraphBuilder.cpp index d59f87c7e9e..e649453c3c0 100644 --- a/hotspot/src/share/vm/c1/c1_GraphBuilder.cpp +++ b/hotspot/src/share/vm/c1/c1_GraphBuilder.cpp @@ -3505,8 +3505,10 @@ bool GraphBuilder::try_inline_full(ciMethod* callee, bool holder_known, BlockBeg } // now perform tests that are based on flag settings - if (callee->should_inline()) { + if (callee->force_inline() || callee->should_inline()) { // ignore heuristic controls on inlining + if (callee->force_inline()) + CompileTask::print_inlining(callee, scope()->level(), bci(), "force inline by annotation"); } else { if (inline_level() > MaxInlineLevel ) INLINE_BAILOUT("too-deep inlining"); if (recursive_inline_level(callee) > MaxRecursiveInlineLevel) INLINE_BAILOUT("too-deep recursive inlining"); @@ -3531,7 +3533,7 @@ bool GraphBuilder::try_inline_full(ciMethod* callee, bool holder_known, BlockBeg } #ifndef PRODUCT - // printing + // printing if (PrintInlining) { print_inline_result(callee, true); } diff --git a/hotspot/src/share/vm/ci/ciMethod.hpp b/hotspot/src/share/vm/ci/ciMethod.hpp index 98571ae2873..de28a858669 100644 --- a/hotspot/src/share/vm/ci/ciMethod.hpp +++ b/hotspot/src/share/vm/ci/ciMethod.hpp @@ -160,6 +160,8 @@ class ciMethod : public ciObject { // Code size for inlining decisions. int code_size_for_inlining(); + bool force_inline() { return get_methodOop()->force_inline(); } + int comp_level(); int highest_osr_comp_level(); diff --git a/hotspot/src/share/vm/classfile/classFileParser.cpp b/hotspot/src/share/vm/classfile/classFileParser.cpp index b2330e61e37..8da25f09ff7 100644 --- a/hotspot/src/share/vm/classfile/classFileParser.cpp +++ b/hotspot/src/share/vm/classfile/classFileParser.cpp @@ -318,6 +318,13 @@ class ConstantPoolCleaner : public StackObj { bool inline valid_cp_range(int index, int length) { return (index > 0 && index < length); } +inline Symbol* check_symbol_at(constantPoolHandle cp, int index) { + if (valid_cp_range(index, cp->length()) && cp->tag_at(index).is_utf8()) + return cp->symbol_at(index); + else + return NULL; +} + constantPoolHandle ClassFileParser::parse_constant_pool(Handle class_loader, TRAPS) { ClassFileStream* cfs = stream(); constantPoolHandle nullHandle; @@ -902,6 +909,7 @@ void ClassFileParser::parse_field_attributes(constantPoolHandle cp, bool* is_synthetic_addr, u2* generic_signature_index_addr, typeArrayHandle* field_annotations, + ClassFileParser::FieldAnnotationCollector* parsed_annotations, TRAPS) { ClassFileStream* cfs = stream(); assert(attributes_count > 0, "length should be greater than 0"); @@ -1142,12 +1150,14 @@ typeArrayHandle ClassFileParser::parse_fields(Symbol* class_name, bool is_synthetic = false; u2 generic_signature_index = 0; bool is_static = access_flags.is_static(); + FieldAnnotationCollector parsed_annotations; u2 attributes_count = cfs->get_u2_fast(); if (attributes_count > 0) { parse_field_attributes(cp, attributes_count, is_static, signature_index, &constantvalue_index, &is_synthetic, &generic_signature_index, &field_annotations, + &parsed_annotations, CHECK_(nullHandle)); if (field_annotations.not_null()) { if (fields_annotations->is_null()) { @@ -1173,6 +1183,8 @@ typeArrayHandle ClassFileParser::parse_fields(Symbol* class_name, signature_index, constantvalue_index, 0); + if (parsed_annotations.has_any_annotations()) + parsed_annotations.apply_to(field); BasicType type = cp->basic_type_for_signature_at(signature_index); @@ -1638,12 +1650,158 @@ void ClassFileParser::throwIllegalSignature( name->as_C_string(), _class_name->as_C_string(), sig->as_C_string()); } +// Skip an annotation. Return >=limit if there is any problem. +int ClassFileParser::skip_annotation(u1* buffer, int limit, int index) { + // annotation := atype:u2 do(nmem:u2) {member:u2 value} + // value := switch (tag:u1) { ... } + index += 2; // skip atype + if ((index += 2) >= limit) return limit; // read nmem + int nmem = Bytes::get_Java_u2(buffer+index-2); + while (--nmem >= 0 && index < limit) { + index += 2; // skip member + index = skip_annotation_value(buffer, limit, index); + } + return index; +} + +// Skip an annotation value. Return >=limit if there is any problem. +int ClassFileParser::skip_annotation_value(u1* buffer, int limit, int index) { + // value := switch (tag:u1) { + // case B, C, I, S, Z, D, F, J, c: con:u2; + // case e: e_class:u2 e_name:u2; + // case s: s_con:u2; + // case [: do(nval:u2) {value}; + // case @: annotation; + // case s: s_con:u2; + // } + if ((index += 1) >= limit) return limit; // read tag + u1 tag = buffer[index-1]; + switch (tag) { + case 'B': case 'C': case 'I': case 'S': case 'Z': + case 'D': case 'F': case 'J': case 'c': case 's': + index += 2; // skip con or s_con + break; + case 'e': + index += 4; // skip e_class, e_name + break; + case '[': + { + if ((index += 2) >= limit) return limit; // read nval + int nval = Bytes::get_Java_u2(buffer+index-2); + while (--nval >= 0 && index < limit) { + index = skip_annotation_value(buffer, limit, index); + } + } + break; + case '@': + index = skip_annotation(buffer, limit, index); + break; + default: + assert(false, "annotation tag"); + return limit; // bad tag byte + } + return index; +} + +// Sift through annotations, looking for those significant to the VM: +void ClassFileParser::parse_annotations(u1* buffer, int limit, + constantPoolHandle cp, + ClassFileParser::AnnotationCollector* coll, + TRAPS) { + // annotations := do(nann:u2) {annotation} + int index = 0; + if ((index += 2) >= limit) return; // read nann + int nann = Bytes::get_Java_u2(buffer+index-2); + enum { // initial annotation layout + atype_off = 0, // utf8 such as 'Ljava/lang/annotation/Retention;' + count_off = 2, // u2 such as 1 (one value) + member_off = 4, // utf8 such as 'value' + tag_off = 6, // u1 such as 'c' (type) or 'e' (enum) + e_tag_val = 'e', + e_type_off = 7, // utf8 such as 'Ljava/lang/annotation/RetentionPolicy;' + e_con_off = 9, // utf8 payload, such as 'SOURCE', 'CLASS', 'RUNTIME' + e_size = 11, // end of 'e' annotation + c_tag_val = 'c', + c_con_off = 7, // utf8 payload, such as 'I' or 'Ljava/lang/String;' + c_size = 9, // end of 'c' annotation + min_size = 6 // smallest possible size (zero members) + }; + while ((--nann) >= 0 && (index-2 + min_size <= limit)) { + int index0 = index; + index = skip_annotation(buffer, limit, index); + u1* abase = buffer + index0; + int atype = Bytes::get_Java_u2(abase + atype_off); + int count = Bytes::get_Java_u2(abase + count_off); + Symbol* aname = check_symbol_at(cp, atype); + if (aname == NULL) break; // invalid annotation name + Symbol* member = NULL; + if (count >= 1) { + int member_index = Bytes::get_Java_u2(abase + member_off); + member = check_symbol_at(cp, member_index); + if (member == NULL) break; // invalid member name + } + + // Here is where parsing particular annotations will take place. + AnnotationCollector::ID id = coll->annotation_index(aname); + if (id == AnnotationCollector::_unknown) continue; + coll->set_annotation(id); + // If there are no values, just set the bit and move on: + if (count == 0) continue; + + // For the record, here is how annotation payloads can be collected. + // Suppose we want to capture @Retention.value. Here is how: + //if (id == AnnotationCollector::_class_Retention) { + // Symbol* payload = NULL; + // if (count == 1 + // && e_size == (index0 - index) // match size + // && e_tag_val == *(abase + tag_off) + // && (check_symbol_at(cp, Bytes::get_Java_u2(abase + e_type_off)) + // == vmSymbols::RetentionPolicy_signature()) + // && member == vmSymbols::value_name()) { + // payload = check_symbol_at(cp, Bytes::get_Java_u2(abase + e_con_off)); + // } + // check_property(payload != NULL, + // "Invalid @Retention annotation at offset %u in class file %s", + // index0, CHECK); + // if (payload != NULL) { + // payload->increment_refcount(); + // coll->_class_RetentionPolicy = payload; + // } + //} + } +} + +ClassFileParser::AnnotationCollector::ID ClassFileParser::AnnotationCollector::annotation_index(Symbol* name) { + vmSymbols::SID sid = vmSymbols::find_sid(name); + switch (sid) { + case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_ForceInline_signature): + if (_location != _in_method) break; // only allow for methods + return _method_ForceInline; + default: break; + } + return AnnotationCollector::_unknown; +} + +void ClassFileParser::FieldAnnotationCollector::apply_to(FieldInfo* f) { + fatal("no field annotations yet"); +} + +void ClassFileParser::MethodAnnotationCollector::apply_to(methodHandle m) { + if (has_annotation(_method_ForceInline)) + m->set_force_inline(true); +} + +void ClassFileParser::ClassAnnotationCollector::apply_to(instanceKlassHandle k) { + fatal("no class annotations yet"); +} + + #define MAX_ARGS_SIZE 255 #define MAX_CODE_SIZE 65535 #define INITIAL_MAX_LVT_NUMBER 256 // Note: the parse_method below is big and clunky because all parsing of the code and exceptions -// attribute is inlined. This is curbersome to avoid since we inline most of the parts in the +// attribute is inlined. This is cumbersome to avoid since we inline most of the parts in the // methodOop to save footprint, so we only know the size of the resulting methodOop when the // entire method attribute is parsed. // @@ -1733,6 +1891,7 @@ methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interf // stackmap attribute - JDK1.5 typeArrayHandle stackmap_data; u2 generic_signature_index = 0; + MethodAnnotationCollector parsed_annotations; u1* runtime_visible_annotations = NULL; int runtime_visible_annotations_length = 0; u1* runtime_invisible_annotations = NULL; @@ -1959,6 +2118,7 @@ methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interf runtime_visible_annotations_length = method_attribute_length; runtime_visible_annotations = cfs->get_u1_buffer(); assert(runtime_visible_annotations != NULL, "null visible annotations"); + parse_annotations(runtime_visible_annotations, runtime_visible_annotations_length, cp, &parsed_annotations, CHECK_(nullHandle)); cfs->skip_u1(runtime_visible_annotations_length, CHECK_(nullHandle)); } else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_annotations()) { runtime_invisible_annotations_length = method_attribute_length; @@ -2136,6 +2296,8 @@ methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interf clear_hashtable(lvt_Hash); } + if (parsed_annotations.has_any_annotations()) + parsed_annotations.apply_to(m); *method_annotations = assemble_annotations(runtime_visible_annotations, runtime_visible_annotations_length, runtime_invisible_annotations, @@ -2314,7 +2476,7 @@ typeArrayHandle ClassFileParser::sort_methods(objArrayHandle methods, } -void ClassFileParser::parse_classfile_sourcefile_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) { +void ClassFileParser::parse_classfile_sourcefile_attribute(constantPoolHandle cp, TRAPS) { ClassFileStream* cfs = stream(); cfs->guarantee_more(2, CHECK); // sourcefile_index u2 sourcefile_index = cfs->get_u2_fast(); @@ -2323,13 +2485,12 @@ void ClassFileParser::parse_classfile_sourcefile_attribute(constantPoolHandle cp cp->tag_at(sourcefile_index).is_utf8(), "Invalid SourceFile attribute at constant pool index %u in class file %s", sourcefile_index, CHECK); - k->set_source_file_name(cp->symbol_at(sourcefile_index)); + set_class_sourcefile(cp->symbol_at(sourcefile_index)); } void ClassFileParser::parse_classfile_source_debug_extension_attribute(constantPoolHandle cp, - instanceKlassHandle k, int length, TRAPS) { ClassFileStream* cfs = stream(); u1* sde_buffer = cfs->get_u1_buffer(); @@ -2340,9 +2501,9 @@ void ClassFileParser::parse_classfile_source_debug_extension_attribute(constantP // Optimistically assume that only 1 byte UTF format is used // (common case) TempNewSymbol sde_symbol = SymbolTable::new_symbol((const char*)sde_buffer, length, CHECK); - k->set_source_debug_extension(sde_symbol); // Note that set_source_debug_extension() increments the reference count // for its copy of the Symbol*, so use a TempNewSymbol here. + set_class_sde_symbol(sde_symbol); } // Got utf8 string, set stream position forward cfs->skip_u1(length, CHECK); @@ -2358,7 +2519,7 @@ u2 ClassFileParser::parse_classfile_inner_classes_attribute(u1* inner_classes_at u2 enclosing_method_class_index, u2 enclosing_method_method_index, constantPoolHandle cp, - instanceKlassHandle k, TRAPS) { + TRAPS) { ClassFileStream* cfs = stream(); u1* current_mark = cfs->current(); u2 length = 0; @@ -2449,7 +2610,7 @@ u2 ClassFileParser::parse_classfile_inner_classes_attribute(u1* inner_classes_at assert(index == size, "wrong size"); // Update instanceKlass with inner class info. - k->set_inner_classes(inner_classes()); + set_class_inner_classes(inner_classes); // Restore buffer's current position. cfs->set_current(current_mark); @@ -2457,11 +2618,11 @@ u2 ClassFileParser::parse_classfile_inner_classes_attribute(u1* inner_classes_at return length; } -void ClassFileParser::parse_classfile_synthetic_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) { - k->set_is_synthetic(); +void ClassFileParser::parse_classfile_synthetic_attribute(constantPoolHandle cp, TRAPS) { + set_class_synthetic_flag(true); } -void ClassFileParser::parse_classfile_signature_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) { +void ClassFileParser::parse_classfile_signature_attribute(constantPoolHandle cp, TRAPS) { ClassFileStream* cfs = stream(); u2 signature_index = cfs->get_u2(CHECK); check_property( @@ -2469,10 +2630,10 @@ void ClassFileParser::parse_classfile_signature_attribute(constantPoolHandle cp, cp->tag_at(signature_index).is_utf8(), "Invalid constant pool index %u in Signature attribute in class file %s", signature_index, CHECK); - k->set_generic_signature(cp->symbol_at(signature_index)); + set_class_generic_signature(cp->symbol_at(signature_index)); } -void ClassFileParser::parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp, instanceKlassHandle k, +void ClassFileParser::parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp, u4 attribute_byte_length, TRAPS) { ClassFileStream* cfs = stream(); u1* current_start = cfs->current(); @@ -2544,10 +2705,12 @@ void ClassFileParser::parse_classfile_bootstrap_methods_attribute(constantPoolHa } -void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instanceKlassHandle k, TRAPS) { +void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, + ClassFileParser::ClassAnnotationCollector* parsed_annotations, + TRAPS) { ClassFileStream* cfs = stream(); // Set inner classes attribute to default sentinel - k->set_inner_classes(Universe::the_empty_short_array()); + set_class_inner_classes(typeArrayHandle(THREAD, Universe::the_empty_short_array())); cfs->guarantee_more(2, CHECK); // attributes_count u2 attributes_count = cfs->get_u2_fast(); bool parsed_sourcefile_attribute = false; @@ -2583,10 +2746,10 @@ void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instance } else { parsed_sourcefile_attribute = true; } - parse_classfile_sourcefile_attribute(cp, k, CHECK); + parse_classfile_sourcefile_attribute(cp, CHECK); } else if (tag == vmSymbols::tag_source_debug_extension()) { // Check for SourceDebugExtension tag - parse_classfile_source_debug_extension_attribute(cp, k, (int)attribute_length, CHECK); + parse_classfile_source_debug_extension_attribute(cp, (int)attribute_length, CHECK); } else if (tag == vmSymbols::tag_inner_classes()) { // Check for InnerClasses tag if (parsed_innerclasses_attribute) { @@ -2605,7 +2768,7 @@ void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instance "Invalid Synthetic classfile attribute length %u in class file %s", attribute_length, CHECK); } - parse_classfile_synthetic_attribute(cp, k, CHECK); + parse_classfile_synthetic_attribute(cp, CHECK); } else if (tag == vmSymbols::tag_deprecated()) { // Check for Deprecatd tag - 4276120 if (attribute_length != 0) { @@ -2620,11 +2783,16 @@ void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instance "Wrong Signature attribute length %u in class file %s", attribute_length, CHECK); } - parse_classfile_signature_attribute(cp, k, CHECK); + parse_classfile_signature_attribute(cp, CHECK); } else if (tag == vmSymbols::tag_runtime_visible_annotations()) { runtime_visible_annotations_length = attribute_length; runtime_visible_annotations = cfs->get_u1_buffer(); assert(runtime_visible_annotations != NULL, "null visible annotations"); + parse_annotations(runtime_visible_annotations, + runtime_visible_annotations_length, + cp, + parsed_annotations, + CHECK); cfs->skip_u1(runtime_visible_annotations_length, CHECK); } else if (PreserveAllAnnotations && tag == vmSymbols::tag_runtime_invisible_annotations()) { runtime_invisible_annotations_length = attribute_length; @@ -2658,7 +2826,7 @@ void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instance if (parsed_bootstrap_methods_attribute) classfile_parse_error("Multiple BootstrapMethods attributes in class file %s", CHECK); parsed_bootstrap_methods_attribute = true; - parse_classfile_bootstrap_methods_attribute(cp, k, attribute_length, CHECK); + parse_classfile_bootstrap_methods_attribute(cp, attribute_length, CHECK); } else { // Unknown attribute cfs->skip_u1(attribute_length, CHECK); @@ -2673,7 +2841,7 @@ void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instance runtime_invisible_annotations, runtime_invisible_annotations_length, CHECK); - k->set_class_annotations(annotations()); + set_class_annotations(annotations); if (parsed_innerclasses_attribute || parsed_enclosingmethod_attribute) { u2 num_of_classes = parse_classfile_inner_classes_attribute( @@ -2681,7 +2849,7 @@ void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instance parsed_innerclasses_attribute, enclosing_method_class_index, enclosing_method_method_index, - cp, k, CHECK); + cp, CHECK); if (parsed_innerclasses_attribute &&_need_verify && _major_version >= JAVA_1_5_VERSION) { guarantee_property( inner_classes_attribute_length == sizeof(num_of_classes) + 4 * sizeof(u2) * num_of_classes, @@ -2695,6 +2863,21 @@ void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instance } } +void ClassFileParser::apply_parsed_class_attributes(instanceKlassHandle k) { + if (_synthetic_flag) + k->set_is_synthetic(); + if (_sourcefile != NULL) { + _sourcefile->increment_refcount(); + k->set_source_file_name(_sourcefile); + } + if (_generic_signature != NULL) { + _generic_signature->increment_refcount(); + k->set_generic_signature(_generic_signature); + } + k->set_source_debug_extension(_sde_symbol); // increment_refcount inside + k->set_inner_classes(_inner_classes()); + k->set_class_annotations(_annotations()); +} typeArrayHandle ClassFileParser::assemble_annotations(u1* runtime_visible_annotations, int runtime_visible_annotations_length, @@ -2745,8 +2928,7 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name, jt->get_thread_stat()->perf_timers_addr(), PerfClassTraceTime::PARSE_CLASS); - _has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false; - _max_bootstrap_specifier_index = -1; + init_parsed_class_attributes(); if (JvmtiExport::should_post_class_file_load_hook()) { // Get the cached class file bytes (if any) from the class that @@ -2979,6 +3161,13 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name, objArrayHandle methods_parameter_annotations(THREAD, methods_parameter_annotations_oop); objArrayHandle methods_default_annotations(THREAD, methods_default_annotations_oop); + // Additional attributes + ClassAnnotationCollector parsed_annotations; + parse_classfile_attributes(cp, &parsed_annotations, CHECK_(nullHandle)); + + // Make sure this is the end of class file stream + guarantee_property(cfs->at_eos(), "Extra bytes at the end of class file %s", CHECK_(nullHandle)); + // We check super class after class file is parsed and format is checked if (super_class_index > 0 && super_klass.is_null()) { Symbol* sk = cp->klass_name_at(super_class_index); @@ -3467,11 +3656,10 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name, this_klass->set_has_miranda_methods(); // then set a flag } - // Additional attributes - parse_classfile_attributes(cp, this_klass, CHECK_(nullHandle)); - - // Make sure this is the end of class file stream - guarantee_property(cfs->at_eos(), "Extra bytes at the end of class file %s", CHECK_(nullHandle)); + // Fill in field values obtained by parse_classfile_attributes + if (parsed_annotations.has_any_annotations()) + parsed_annotations.apply_to(this_klass); + apply_parsed_class_attributes(this_klass); // VerifyOops believes that once this has been set, the object is completely loaded. // Compute transitive closure of interfaces this class implements @@ -3486,6 +3674,7 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name, // Do final class setup fill_oop_maps(this_klass, nonstatic_oop_map_count, nonstatic_oop_offsets, nonstatic_oop_counts); + // Fill in has_finalizer, has_vanilla_constructor, and layout_helper set_precomputed_flags(this_klass); // reinitialize modifiers, using the InnerClasses attribute diff --git a/hotspot/src/share/vm/classfile/classFileParser.hpp b/hotspot/src/share/vm/classfile/classFileParser.hpp index de781b2fb1f..9edf5b99852 100644 --- a/hotspot/src/share/vm/classfile/classFileParser.hpp +++ b/hotspot/src/share/vm/classfile/classFileParser.hpp @@ -31,8 +31,8 @@ #include "oops/typeArrayOop.hpp" #include "runtime/handles.inline.hpp" #include "utilities/accessFlags.hpp" +#include "classfile/symbolTable.hpp" -class TempNewSymbol; class FieldAllocationCount; @@ -50,11 +50,77 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC { KlassHandle _host_klass; GrowableArray* _cp_patches; // overrides for CP entries + // precomputed flags bool _has_finalizer; bool _has_empty_finalizer; bool _has_vanilla_constructor; + int _max_bootstrap_specifier_index; // detects BSS values - int _max_bootstrap_specifier_index; + // class attributes parsed before the instance klass is created: + bool _synthetic_flag; + Symbol* _sourcefile; + Symbol* _generic_signature; + TempNewSymbol _sde_symbol; + typeArrayHandle _inner_classes; + typeArrayHandle _annotations; + + void set_class_synthetic_flag(bool x) { _synthetic_flag = x; } + void set_class_sourcefile(Symbol* x) { _sourcefile = x; } + void set_class_generic_signature(Symbol* x) { _generic_signature = x; } + void set_class_sde_symbol(Symbol* x) { _sde_symbol = x; } + void set_class_inner_classes(typeArrayHandle x) { _inner_classes = x; } + void set_class_annotations(typeArrayHandle x) { _annotations = x; } + void init_parsed_class_attributes() { + _synthetic_flag = false; + _sourcefile = NULL; + _generic_signature = NULL; + // initialize the other flags too: + _has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false; + _max_bootstrap_specifier_index = -1; + } + void apply_parsed_class_attributes(instanceKlassHandle k); // update k + + class AnnotationCollector { + public: + enum Location { _in_field, _in_method, _in_class }; + enum ID { + _unknown = 0, + _method_ForceInline, + _annotation_LIMIT + }; + const Location _location; + int _annotations_present; + AnnotationCollector(Location location) + : _location(location), _annotations_present(0) + { + assert((int)_annotation_LIMIT <= (int)sizeof(_annotations_present) * BitsPerByte, ""); + } + // If this annotation name has an ID, report it (or _none). + ID annotation_index(Symbol* name); + // Set the annotation name: + void set_annotation(ID id) { + assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob"); + _annotations_present |= nth_bit((int)id); + } + // Report if the annotation is present. + bool has_any_annotations() { return _annotations_present != 0; } + bool has_annotation(ID id) { return (nth_bit((int)id) & _annotations_present) != 0; } + }; + class FieldAnnotationCollector: public AnnotationCollector { + public: + FieldAnnotationCollector() : AnnotationCollector(_in_field) { } + void apply_to(FieldInfo* f); + }; + class MethodAnnotationCollector: public AnnotationCollector { + public: + MethodAnnotationCollector() : AnnotationCollector(_in_method) { } + void apply_to(methodHandle m); + }; + class ClassAnnotationCollector: public AnnotationCollector { + public: + ClassAnnotationCollector() : AnnotationCollector(_in_class) { } + void apply_to(instanceKlassHandle k); + }; enum { fixed_buffer_size = 128 }; u_char linenumbertable_buffer[fixed_buffer_size]; @@ -87,7 +153,9 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC { u2* constantvalue_index_addr, bool* is_synthetic_addr, u2* generic_signature_index_addr, - typeArrayHandle* field_annotations, TRAPS); + typeArrayHandle* field_annotations, + FieldAnnotationCollector* parsed_annotations, + TRAPS); typeArrayHandle parse_fields(Symbol* class_name, constantPoolHandle cp, bool is_interface, FieldAllocationCount *fac, @@ -128,25 +196,32 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC { typeArrayOop parse_stackmap_table(u4 code_attribute_length, TRAPS); // Classfile attribute parsing - void parse_classfile_sourcefile_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS); - void parse_classfile_source_debug_extension_attribute(constantPoolHandle cp, - instanceKlassHandle k, int length, TRAPS); + void parse_classfile_sourcefile_attribute(constantPoolHandle cp, TRAPS); + void parse_classfile_source_debug_extension_attribute(constantPoolHandle cp, int length, TRAPS); u2 parse_classfile_inner_classes_attribute(u1* inner_classes_attribute_start, bool parsed_enclosingmethod_attribute, u2 enclosing_method_class_index, u2 enclosing_method_method_index, constantPoolHandle cp, - instanceKlassHandle k, TRAPS); - void parse_classfile_attributes(constantPoolHandle cp, instanceKlassHandle k, TRAPS); - void parse_classfile_synthetic_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS); - void parse_classfile_signature_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS); - void parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp, instanceKlassHandle k, u4 attribute_length, TRAPS); + TRAPS); + void parse_classfile_attributes(constantPoolHandle cp, + ClassAnnotationCollector* parsed_annotations, + TRAPS); + void parse_classfile_synthetic_attribute(constantPoolHandle cp, TRAPS); + void parse_classfile_signature_attribute(constantPoolHandle cp, TRAPS); + void parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp, u4 attribute_length, TRAPS); // Annotations handling typeArrayHandle assemble_annotations(u1* runtime_visible_annotations, int runtime_visible_annotations_length, u1* runtime_invisible_annotations, int runtime_invisible_annotations_length, TRAPS); + int skip_annotation(u1* buffer, int limit, int index); + int skip_annotation_value(u1* buffer, int limit, int index); + void parse_annotations(u1* buffer, int limit, constantPoolHandle cp, + /* Results (currently, only one result is supported): */ + AnnotationCollector* result, + TRAPS); // Final setup unsigned int compute_oop_map_count(instanceKlassHandle super, diff --git a/hotspot/src/share/vm/classfile/vmSymbols.hpp b/hotspot/src/share/vm/classfile/vmSymbols.hpp index 4f926c7a8d2..6efa393ceac 100644 --- a/hotspot/src/share/vm/classfile/vmSymbols.hpp +++ b/hotspot/src/share/vm/classfile/vmSymbols.hpp @@ -257,6 +257,7 @@ template(java_lang_invoke_BoundMethodHandle, "java/lang/invoke/BoundMethodHandle") \ template(java_lang_invoke_DirectMethodHandle, "java/lang/invoke/DirectMethodHandle") \ template(java_lang_invoke_CountingMethodHandle, "java/lang/invoke/CountingMethodHandle") \ + template(java_lang_invoke_ForceInline_signature, "Ljava/lang/invoke/ForceInline;") \ /* internal up-calls made only by the JVM, via class sun.invoke.MethodHandleNatives: */ \ template(findMethodHandleType_name, "findMethodHandleType") \ template(findMethodHandleType_signature, "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/invoke/MethodType;") \ diff --git a/hotspot/src/share/vm/oops/methodOop.hpp b/hotspot/src/share/vm/oops/methodOop.hpp index de10b7c96f0..11a70dcc0f5 100644 --- a/hotspot/src/share/vm/oops/methodOop.hpp +++ b/hotspot/src/share/vm/oops/methodOop.hpp @@ -122,8 +122,9 @@ class methodOopDesc : public oopDesc { u2 _max_locals; // Number of local variables used by this method u2 _size_of_parameters; // size of the parameter block (receiver + arguments) in words u1 _intrinsic_id; // vmSymbols::intrinsic_id (0 == _none) - u1 _jfr_towrite : 1, // Flags - : 7; + u1 _jfr_towrite : 1, // Flags + _force_inline : 1, + : 6; u2 _interpreter_throwout_count; // Count of times method was exited via exception while interpreting u2 _number_of_breakpoints; // fullspeed debugging support InvocationCounter _invocation_counter; // Incremented before each activation of the method - used to trigger frequency-based optimizations @@ -655,6 +656,9 @@ class methodOopDesc : public oopDesc { bool jfr_towrite() { return _jfr_towrite; } void set_jfr_towrite(bool towrite) { _jfr_towrite = towrite; } + bool force_inline() { return _force_inline; } + void set_force_inline(bool fi) { _force_inline = fi; } + // On-stack replacement support bool has_osr_nmethod(int level, bool match_level) { return instanceKlass::cast(method_holder())->lookup_osr_nmethod(this, InvocationEntryBci, level, match_level) != NULL; From d0b5b673e8e56037bf04471b2e41906e5a58b490 Mon Sep 17 00:00:00 2001 From: Pavel Tisnovsky Date: Thu, 12 Jul 2012 16:54:47 +0200 Subject: [PATCH 082/160] 7022041: TitleBorder Null Pointer Exception Added check if getTitleFont() and getTitleColor() don't return null Reviewed-by: alexsch --- .../javax/swing/border/TitledBorder.java | 12 +- jdk/test/javax/swing/border/Test7022041.java | 133 ++++++++++++++++++ 2 files changed, 135 insertions(+), 10 deletions(-) create mode 100644 jdk/test/javax/swing/border/Test7022041.java diff --git a/jdk/src/share/classes/javax/swing/border/TitledBorder.java b/jdk/src/share/classes/javax/swing/border/TitledBorder.java index 6b5fdf543ca..244a45bc8de 100644 --- a/jdk/src/share/classes/javax/swing/border/TitledBorder.java +++ b/jdk/src/share/classes/javax/swing/border/TitledBorder.java @@ -440,7 +440,7 @@ public class TitledBorder extends AbstractBorder * @return the title-font of the titled border */ public Font getTitleFont() { - return titleFont; + return titleFont == null ? UIManager.getFont("TitledBorder.font") : titleFont; } /** @@ -449,7 +449,7 @@ public class TitledBorder extends AbstractBorder * @return the title-color of the titled border */ public Color getTitleColor() { - return titleColor; + return titleColor == null ? UIManager.getColor("TitledBorder.titleColor") : titleColor; } @@ -681,10 +681,6 @@ public class TitledBorder extends AbstractBorder if (font != null) { return font; } - font = UIManager.getFont("TitledBorder.font"); - if (font != null) { - return font; - } if (c != null) { font = c.getFont(); if (font != null) { @@ -699,10 +695,6 @@ public class TitledBorder extends AbstractBorder if (color != null) { return color; } - color = UIManager.getColor("TitledBorder.titleColor"); - if (color != null) { - return color; - } return (c != null) ? c.getForeground() : null; diff --git a/jdk/test/javax/swing/border/Test7022041.java b/jdk/test/javax/swing/border/Test7022041.java new file mode 100644 index 00000000000..cccd90ed1ec --- /dev/null +++ b/jdk/test/javax/swing/border/Test7022041.java @@ -0,0 +1,133 @@ +/* + * Copyright 2012 Red Hat, Inc. All Rights Reserved. + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +import java.awt.Color; +import java.awt.Font; + +import javax.swing.border.EmptyBorder; +import javax.swing.border.TitledBorder; +import javax.swing.UIManager; +import javax.swing.UnsupportedLookAndFeelException; + +/* @test + * @bug 7022041 + * @summary This test check the behaviour of getTitleFont() and getTitleColor() + * methods of the TitledBorder class. + * @author Pavel Tisnovsky + */ +public class Test7022041 { + + public static void main(String[] args) throws Exception { + UIManager.LookAndFeelInfo[] installedLookAndFeels = UIManager.getInstalledLookAndFeels(); + // try to test all installed Look and Feels + for (UIManager.LookAndFeelInfo lookAndFeel : installedLookAndFeels) { + String name = lookAndFeel.getName(); + System.out.println("Testing " + name); + // Some Look and Feels work only when test is run in a GUI environment + // (GTK+ LAF is an example) + try { + UIManager.setLookAndFeel(lookAndFeel.getClassName()); + checkTitleColor(); + System.out.println(" titleColor test ok"); + checkTitleFont(); + System.out.println(" titleFont test ok"); + } + catch (UnsupportedLookAndFeelException e) { + System.out.println(" Note: LookAndFeel " + name + + " is not supported on this configuration"); + } + } + } + + /** + * Check behaviour of method TitledBorder.getTitleColor() + */ + private static void checkTitleColor() { + TitledBorder titledBorder = new TitledBorder(new EmptyBorder(1, 1, 1, 1)); + Color defaultColor = UIManager.getLookAndFeelDefaults().getColor("TitledBorder.titleColor"); + Color titledBorderColor = titledBorder.getTitleColor(); + + // check default configuration + if (defaultColor == null) { + if (titledBorderColor == null) { + return; + } + else { + throw new RuntimeException("TitledBorder default color should be null"); + } + } + if (!defaultColor.equals(titledBorderColor)) { + throw new RuntimeException("L&F default color " + defaultColor.toString() + + " differs from TitledBorder color " + titledBorderColor.toString()); + } + + // title color is explicitly specified + Color color = Color.green; + titledBorder.setTitleColor(color); + if (!color.equals(titledBorder.getTitleColor())) { + throw new RuntimeException("TitledBorder color should be " + color.toString()); + } + + // title color is unspecified + titledBorder.setTitleColor(null); + if (!defaultColor.equals(titledBorder.getTitleColor())) { + throw new RuntimeException("L&F default color " + defaultColor.toString() + + " differs from TitledBorder color " + titledBorderColor.toString()); + } + } + + /** + * Check behaviour of method TitledBorder.getTitleFont() + */ + private static void checkTitleFont() { + TitledBorder titledBorder = new TitledBorder(new EmptyBorder(1, 1, 1, 1)); + Font defaultFont = UIManager.getLookAndFeelDefaults().getFont("TitledBorder.font"); + Font titledBorderFont = titledBorder.getTitleFont(); + + // check default configuration + if (defaultFont == null) { + if (titledBorderFont == null) { + return; + } + else { + throw new RuntimeException("TitledBorder default font should be null"); + } + } + if (!defaultFont.equals(titledBorderFont)) { + throw new RuntimeException("L&F default font " + defaultFont.toString() + + " differs from TitledBorder font " + titledBorderFont.toString()); + } + + // title font is explicitly specified + Font font = new Font("Dialog", Font.PLAIN, 10); + titledBorder.setTitleFont(font); + if (!font.equals(titledBorder.getTitleFont())) { + throw new RuntimeException("TitledBorder font should be " + font.toString()); + } + + // title Font is unspecified + titledBorder.setTitleFont(null); + if (!defaultFont.equals(titledBorder.getTitleFont())) { + throw new RuntimeException("L&F default font " + defaultFont.toString() + + " differs from TitledBorder font " + titledBorderFont.toString()); + } + } +} + From 53cbbbb036c0d2f897da72b55d0589071f5a7d0a Mon Sep 17 00:00:00 2001 From: Phil Race Date: Thu, 12 Jul 2012 16:24:56 -0700 Subject: [PATCH 083/160] 7183458: Metrics of space character in algorithmically emboldened font have changed in JDK 7 Reviewed-by: igor, jgodinez --- .../awt/FontMetrics/StyledSpaceAdvance.java | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 jdk/test/java/awt/FontMetrics/StyledSpaceAdvance.java diff --git a/jdk/test/java/awt/FontMetrics/StyledSpaceAdvance.java b/jdk/test/java/awt/FontMetrics/StyledSpaceAdvance.java new file mode 100644 index 00000000000..cc5b0a3a207 --- /dev/null +++ b/jdk/test/java/awt/FontMetrics/StyledSpaceAdvance.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7183458 + * @summary Verify advance of space is not overly widened by bold styling. + * @run main StyledSpaceAdvance + */ +import java.awt.Font; +import java.awt.font.FontRenderContext; +import java.awt.geom.Rectangle2D; +import java.util.Locale; + +public class StyledSpaceAdvance { + + static String name = "Gulim"; + + public static void main(String args[]) { + for (int sz=9;sz<18;sz++) { + test(sz); + } + } + + static void test(int sz) { + Font reg = new Font(name, Font.PLAIN, sz); + Font bold = new Font(name, Font.BOLD, sz); + //System.out.println("reg="+reg); + //System.out.println("bold="+bold); + FontRenderContext frc = new FontRenderContext(null, false, false); + if (reg.getFontName(Locale.ENGLISH).equals(name) && + bold.getFontName(Locale.ENGLISH).equals(name)) { + Rectangle2D rb = reg.getStringBounds(" ", frc); + Rectangle2D bb = bold.getStringBounds(" ", frc); + if (bb.getWidth() > rb.getWidth() + 1.01f) { + System.err.println("reg="+reg+" bds = " + rb); + System.err.println("bold="+bold+" bds = " + bb); + throw new RuntimeException("Advance difference too great."); + } + } else { + System.out.println("Skipping test because fonts aren't as expected"); + } + } +} From 9564f9eeb195b74baa453f4248bfba2d340f4388 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 12 Jul 2012 16:47:51 -0700 Subject: [PATCH 084/160] Added tag jdk8-b47 for changeset 89d0de913efd --- .hgtags-top-repo | 1 + 1 file changed, 1 insertion(+) diff --git a/.hgtags-top-repo b/.hgtags-top-repo index 8725f6d1dc1..3cced1f6f86 100644 --- a/.hgtags-top-repo +++ b/.hgtags-top-repo @@ -168,3 +168,4 @@ a2b2d435f1d275fa8010774c653197c64e326d3a jdk8-b40 e4f81a817447c3a4f6868f083c81c2fb1b15d44c jdk8-b44 633f2378c904c92bb922a6e19e9f62fe8eac14af jdk8-b45 27fa766a2298ba8347dc198f0cf85ba6618e17db jdk8-b46 +1dcb4b7b9373e64e135c12fe1f8699f1f80e51e8 jdk8-b47 From 079b7a5e8ab78bbbd6a77409e6b0f478bc46bb5b Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 12 Jul 2012 16:47:53 -0700 Subject: [PATCH 085/160] Added tag jdk8-b47 for changeset 89587a8ac2f4 --- corba/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/corba/.hgtags b/corba/.hgtags index 796079e90ac..d1482b49a69 100644 --- a/corba/.hgtags +++ b/corba/.hgtags @@ -168,3 +168,4 @@ cd879aff5d3cc1f58829aab3116880aa19525b78 jdk8-b43 439d9bf8e4ff204cc89c9974c1515a508b2cc6ff jdk8-b44 747dad9e9d37d244a5c765a1afe9194f7ddae118 jdk8-b45 30141e598d72a6146126cb86b034ed6d0bd191b3 jdk8-b46 +21e46ea21c6a26246fb7a1926ac7fe8d580d0518 jdk8-b47 From 32a0fe5fa49d557ec14152e668082df7e50f7c9c Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 12 Jul 2012 16:48:00 -0700 Subject: [PATCH 086/160] Added tag jdk8-b47 for changeset a655fb35e798 --- hotspot/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/hotspot/.hgtags b/hotspot/.hgtags index d850f6b9e1c..8f25ddeb1b7 100644 --- a/hotspot/.hgtags +++ b/hotspot/.hgtags @@ -259,3 +259,4 @@ e77b8e0ed1f84e3e268239e276c7ab64fa573baa jdk8-b43 9d5f20961bc5846fa8d098d534effafbbdae0a58 jdk8-b45 40e5a3f2907ed02b335c7caa8ecf068cc801380d hs24-b15 cf37a594c38db2ea926954154636f9f81da2e032 jdk8-b46 +0c7bb1f4f9c8062b5c5bfa56b3bdca44839b4109 jdk8-b47 From ebbf572261fb87ce982cf3cd9b18452acaa18bbe Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 12 Jul 2012 16:48:13 -0700 Subject: [PATCH 087/160] Added tag jdk8-b47 for changeset 6ab81ecbfa0d --- jaxp/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/jaxp/.hgtags b/jaxp/.hgtags index a131128f979..1c32f37a89c 100644 --- a/jaxp/.hgtags +++ b/jaxp/.hgtags @@ -168,3 +168,4 @@ eff4ece9c8bc43b3ce2b3758574c4c20147f0689 jdk8-b43 0b3f3a4ce13930430b32b616a717dfc7fe385b28 jdk8-b44 57476f66e13c55eea2f2fe2b858369a4c64b9936 jdk8-b45 300f45e990643af230d6cca39477ff62c44a9a54 jdk8-b46 +404521944ac9383afda7d55d60713b212c730646 jdk8-b47 From f4018d1d357fe224c864a569fe0cdeb3a9cf49b3 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 12 Jul 2012 16:48:15 -0700 Subject: [PATCH 088/160] Added tag jdk8-b47 for changeset eb447c603031 --- jaxws/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/jaxws/.hgtags b/jaxws/.hgtags index b4afc8cdd27..d0eb26e7c0d 100644 --- a/jaxws/.hgtags +++ b/jaxws/.hgtags @@ -168,3 +168,4 @@ f00c12994562c2f68d348a7c3e829374a89294e2 jdk8-b43 f6a417540ef124c9b4123d07da5e26f2ab909949 jdk8-b44 e80ac58b5ba904f24e125c742c30d0d740f05f86 jdk8-b45 ae368a83c2404b65c9e38c65e2aa081f2201ca74 jdk8-b46 +fe6a060afc404dcf0921708a740de770666b781f jdk8-b47 From 9805e67718e645a50bdb42d5fb144925ddaf1747 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 12 Jul 2012 16:48:24 -0700 Subject: [PATCH 089/160] Added tag jdk8-b47 for changeset 2bfc7517a106 --- jdk/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/jdk/.hgtags b/jdk/.hgtags index ed858014f63..4d90ecebac3 100644 --- a/jdk/.hgtags +++ b/jdk/.hgtags @@ -168,3 +168,4 @@ b3246687c3695dff6f461bb407f9db88f7d072e7 jdk8-b43 db471a7af03168e4441c245b1d9976f720a7cb77 jdk8-b44 b92353a01aa049bc508fc56f0347d5934b7c4390 jdk8-b45 8d2ed9d58453c8049715a72a6d26b6b66b37a94c jdk8-b46 +00b22b23269a57d0bb46c57753be2fe9a9d2c1a3 jdk8-b47 From e351ad6287820910dc843f7c2e83f8594d7e5d10 Mon Sep 17 00:00:00 2001 From: David Katleman Date: Thu, 12 Jul 2012 16:48:37 -0700 Subject: [PATCH 090/160] Added tag jdk8-b47 for changeset f0b04f0fc310 --- langtools/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/langtools/.hgtags b/langtools/.hgtags index 13843bea9da..a7894632690 100644 --- a/langtools/.hgtags +++ b/langtools/.hgtags @@ -168,3 +168,4 @@ f8c64d835b2806293b8e924b44f0e32b20657ed3 jdk8-b43 59cbead12ff46dbb397120bd26635bcd7d41ff21 jdk8-b44 e111e4587ccada8eb93f72e834e378c76256f4b7 jdk8-b45 4ca5994971724731233735f055f33d4936fd11d3 jdk8-b46 +7e6be2f239c9a4ac6dec280bd18ec296dd78e464 jdk8-b47 From fec1de491bde654c9796649f1cf31ea18edf8032 Mon Sep 17 00:00:00 2001 From: Joe Wang Date: Thu, 12 Jul 2012 21:06:52 -0700 Subject: [PATCH 091/160] 7183760: DocumentBuilder.parse(String uri) is not IPv6 enabled Removing the hack of using escapeNonUSAscii. this is the same patch as 7166896 for 7u8. Reviewed-by: psandoz, lancea --- .../internal/impl/XMLEntityManager.java | 72 +------------------ 1 file changed, 1 insertion(+), 71 deletions(-) diff --git a/jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java b/jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java index 58c1b34018d..84e2c81634a 100644 --- a/jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java +++ b/jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java @@ -602,7 +602,7 @@ protected static final String PARSER_SETTINGS = if (reader == null) { stream = xmlInputSource.getByteStream(); if (stream == null) { - URL location = new URL(escapeNonUSAscii(expandedSystemId)); + URL location = new URL(expandedSystemId); URLConnection connect = location.openConnection(); if (!(connect instanceof HttpURLConnection)) { stream = connect.getInputStream(); @@ -2586,76 +2586,6 @@ protected static final String PARSER_SETTINGS = } // fixURI(String):String - /** - * Escape invalid URI characters. - * - * Passed a URI that contains invalid characters (like spaces, non-ASCII Unicode characters, and the like), - * this function percent encodes the invalid characters per the URI specification (i.e., as a sequence of - * %-encoded UTF-8 octets). - * - * N.B. There are two problems. If the URI contains a '%' character, that might be an indication that - * the URI has already been escaped by the author, or it might be an invalid '%'. In the former case, - * it's important not to escape it, or we'll wind up with invalid, doubly-escaped '%'s. In the latter, - * the URI is broken if we don't encode it. Similarly, a '#' character might be the start of a fragment - * identifier or it might be an invalid '#'. - * - * Given that the former is vastly more likely than the latter in each case (most users are familiar with - * the magic status of '%' and '#' and they occur relatively infrequently in filenames, and if the user parses - * a proper Java File, we will already have %-escaped the URI), we simply assume that %'s and #'s are legit. - * - * Very rarely, we may be wrong. If so, tell the user to fix the clearly broken URI. - */ - protected static String escapeNonUSAscii(String str) { - if (str == null) { - return str; - } - int len = str.length(), i=0, ch; - for (; i < len; i++) { - ch = str.charAt(i); - // if it's not an ASCII 7 character, break here, and use UTF-8 encoding - if (ch >= 128) - break; - } - - // we saw no non-ascii-7 character - if (i == len) { - return str; - } - - // get UTF-8 bytes for the string - StringBuffer buffer = new StringBuffer(); - byte[] bytes = null; - byte b; - try { - bytes = str.getBytes("UTF-8"); - } catch (java.io.UnsupportedEncodingException e) { - // should never happen - return str; - } - - len = bytes.length; - - // for each byte - for (i = 0; i < len; i++) { - b = bytes[i]; - // for non-ascii character: make it positive, then escape - if (b < 0) { - ch = b + 256; - buffer.append('%'); - buffer.append(gHexChs[ch >> 4]); - buffer.append(gHexChs[ch & 0xf]); - } - else if (b != '%' && b != '#' && gNeedEscaping[b]) { - buffer.append('%'); - buffer.append(gAfterEscaping1[b]); - buffer.append(gAfterEscaping2[b]); - } - else { - buffer.append((char)b); - } - } - return buffer.toString(); - } // // Package visible methods From 340f4947e50e80e1a7d78f90ab3f44976148a299 Mon Sep 17 00:00:00 2001 From: Maurizio Cimadamore Date: Fri, 13 Jul 2012 12:58:50 +0100 Subject: [PATCH 092/160] 7181578: javac reports uninitialized variable with nested try...finally blocks Regression introduced in refactoring of Flow.java Reviewed-by: jjg --- .../com/sun/tools/javac/comp/Flow.java | 2 +- .../javac/DefiniteAssignment/T7181578.java | 46 +++++++++++++++++++ 2 files changed, 47 insertions(+), 1 deletion(-) create mode 100644 langtools/test/tools/javac/DefiniteAssignment/T7181578.java diff --git a/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java b/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java index 31c8be9f789..27d7ff914de 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java @@ -746,6 +746,7 @@ public class Flow { pendingExits = prevPendingExits; alive = true; scanStat(tree.finalizer); + tree.finallyCanCompleteNormally = alive; if (!alive) { // discard exits and exceptions from try and finally thrown = chk.union(thrown, thrownPrev); @@ -764,7 +765,6 @@ public class Flow { } alive = aliveEnd; } - tree.finallyCanCompleteNormally = alive; } else { thrown = chk.union(thrown, chk.diff(thrownInTry, caughtInTry)); alive = aliveEnd; diff --git a/langtools/test/tools/javac/DefiniteAssignment/T7181578.java b/langtools/test/tools/javac/DefiniteAssignment/T7181578.java new file mode 100644 index 00000000000..d25d0d19733 --- /dev/null +++ b/langtools/test/tools/javac/DefiniteAssignment/T7181578.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7181578 + * @summary javac reports uninitialized variable with nested try...finally blocks + * + * @compile T7181578.java + */ +class T7181578 { + String test(boolean cond) { + final String s; + try { + if (cond) { + try { + s = ""; + return s; + } finally { } + } else { + s = ""; + } + return s; // bug occurs here: mapping is always initialized + } finally { } + } +} From 8aaf8673f1ad519e179d6b3cf46909d90bdfc89c Mon Sep 17 00:00:00 2001 From: Alejandro Murillo Date: Fri, 13 Jul 2012 14:06:34 -0700 Subject: [PATCH 093/160] Added tag hs24-b16 for changeset 3db9eaf7c6ab --- hotspot/.hgtags | 1 + 1 file changed, 1 insertion(+) diff --git a/hotspot/.hgtags b/hotspot/.hgtags index 8f25ddeb1b7..1dff0320d87 100644 --- a/hotspot/.hgtags +++ b/hotspot/.hgtags @@ -260,3 +260,4 @@ e77b8e0ed1f84e3e268239e276c7ab64fa573baa jdk8-b43 40e5a3f2907ed02b335c7caa8ecf068cc801380d hs24-b15 cf37a594c38db2ea926954154636f9f81da2e032 jdk8-b46 0c7bb1f4f9c8062b5c5bfa56b3bdca44839b4109 jdk8-b47 +66b0450071c1534e014b131892cc86b63f1d009c hs24-b16 From b5cfc76c1e0b5382494ef7c79fa28169d4d23cbe Mon Sep 17 00:00:00 2001 From: Alejandro Murillo Date: Fri, 13 Jul 2012 14:16:21 -0700 Subject: [PATCH 094/160] 7184050: new hotspot build - hs24-b17 Reviewed-by: jcoomes --- hotspot/make/hotspot_version | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hotspot/make/hotspot_version b/hotspot/make/hotspot_version index 89e73aff4d8..90a6812ee2f 100644 --- a/hotspot/make/hotspot_version +++ b/hotspot/make/hotspot_version @@ -35,7 +35,7 @@ HOTSPOT_VM_COPYRIGHT=Copyright 2012 HS_MAJOR_VER=24 HS_MINOR_VER=0 -HS_BUILD_NUMBER=16 +HS_BUILD_NUMBER=17 JDK_MAJOR_VER=1 JDK_MINOR_VER=8 From 29739d16eeb75dea3b62821b7c3db6be3a44d1bf Mon Sep 17 00:00:00 2001 From: Kurchi Subhra Hazra Date: Fri, 13 Jul 2012 16:02:26 -0700 Subject: [PATCH 095/160] 7160252: (prefs) NodeAddedEvent was not delivered when new node add when new Node Change native code to convey to Java code whether a new node was added Reviewed-by: alanb, chegar --- .../java/util/prefs/MacOSXPreferences.java | 68 +++++++------- .../util/prefs/MacOSXPreferencesFile.java | 6 +- .../native/java/util/MacOSXPreferencesFile.m | 11 ++- .../util/prefs/AddNodeChangeListener.java | 94 +++++++++++++++++++ 4 files changed, 141 insertions(+), 38 deletions(-) create mode 100644 jdk/test/java/util/prefs/AddNodeChangeListener.java diff --git a/jdk/src/macosx/classes/java/util/prefs/MacOSXPreferences.java b/jdk/src/macosx/classes/java/util/prefs/MacOSXPreferences.java index cba98be1b2a..a4ec19a6803 100644 --- a/jdk/src/macosx/classes/java/util/prefs/MacOSXPreferences.java +++ b/jdk/src/macosx/classes/java/util/prefs/MacOSXPreferences.java @@ -35,16 +35,16 @@ class MacOSXPreferences extends AbstractPreferences { private static final String defaultAppName = "com.apple.java.util.prefs"; // true if this node is a child of userRoot or is userRoot - private boolean isUser; + private final boolean isUser; // true if this node is userRoot or systemRoot - private boolean isRoot; + private final boolean isRoot; // CF's storage location for this node and its keys - private MacOSXPreferencesFile file; + private final MacOSXPreferencesFile file; // absolutePath() + "/" - private String path; + private final String path; // User root and system root nodes private static MacOSXPreferences userRoot = null; @@ -73,36 +73,40 @@ class MacOSXPreferences extends AbstractPreferences { // Create a new root node. Called by getUserRoot() and getSystemRoot() // Synchronization is provided by the caller. - private MacOSXPreferences(boolean newIsUser) - { - super(null, ""); - isUser = newIsUser; - isRoot = true; - - initFields(); + private MacOSXPreferences(boolean newIsUser) { + this(null, "", false, true, newIsUser); } // Create a new non-root node with the given parent. // Called by childSpi(). - private MacOSXPreferences(MacOSXPreferences parent, String name) + private MacOSXPreferences(MacOSXPreferences parent, String name) { + this(parent, name, false, false, false); + } + + private MacOSXPreferences(MacOSXPreferences parent, String name, + boolean isNew) + { + this(parent, name, isNew, false, false); + } + + private MacOSXPreferences(MacOSXPreferences parent, String name, + boolean isNew, boolean isRoot, boolean isUser) { super(parent, name); - isUser = isUserNode(); - isRoot = false; - - initFields(); - } - - - private void initFields() - { + this.isRoot = isRoot; + if (isRoot) + this.isUser = isUser; + else + this.isUser = isUserNode(); path = isRoot ? absolutePath() : absolutePath() + "/"; file = cfFileForNode(isUser); - newNode = file.addNode(path); + if (isNew) + newNode = isNew; + else + newNode = file.addNode(path); } - // Create and return the MacOSXPreferencesFile for this node. // Does not write anything to the file. private MacOSXPreferencesFile cfFileForNode(boolean isUser) @@ -160,7 +164,7 @@ class MacOSXPreferences extends AbstractPreferences { // AbstractPreferences implementation @Override protected void removeNodeSpi() - throws BackingStoreException + throws BackingStoreException { // Disallow flush or sync between these two operations // (they may be manipulating two different files) @@ -180,7 +184,7 @@ class MacOSXPreferences extends AbstractPreferences { // AbstractPreferences implementation @Override protected String[] childrenNamesSpi() - throws BackingStoreException + throws BackingStoreException { String[] result = file.getChildrenForNode(path); if (result == null) throw new BackingStoreException("Couldn't get list of children for node '" + path + "'"); @@ -190,7 +194,7 @@ class MacOSXPreferences extends AbstractPreferences { // AbstractPreferences implementation @Override protected String[] keysSpi() - throws BackingStoreException + throws BackingStoreException { String[] result = file.getKeysForNode(path); if (result == null) throw new BackingStoreException("Couldn't get list of keys for node '" + path + "'"); @@ -204,15 +208,15 @@ class MacOSXPreferences extends AbstractPreferences { // Add to parent's child list here and disallow sync // because parent and child might be in different files. synchronized(MacOSXPreferencesFile.class) { - file.addChildToNode(path, name); - return new MacOSXPreferences(this, name); + boolean isNew = file.addChildToNode(path, name); + return new MacOSXPreferences(this, name, isNew); } } // AbstractPreferences override @Override public void flush() - throws BackingStoreException + throws BackingStoreException { // Flush should *not* check for removal, unlike sync, but should // prevent simultaneous removal. @@ -227,7 +231,7 @@ class MacOSXPreferences extends AbstractPreferences { // AbstractPreferences implementation @Override protected void flushSpi() - throws BackingStoreException + throws BackingStoreException { // nothing here - overridden flush() doesn't call this } @@ -235,7 +239,7 @@ class MacOSXPreferences extends AbstractPreferences { // AbstractPreferences override @Override public void sync() - throws BackingStoreException + throws BackingStoreException { synchronized(lock) { if (isRemoved()) @@ -256,7 +260,7 @@ class MacOSXPreferences extends AbstractPreferences { // AbstractPreferences implementation @Override protected void syncSpi() - throws BackingStoreException + throws BackingStoreException { // nothing here - overridden sync() doesn't call this } diff --git a/jdk/src/macosx/classes/java/util/prefs/MacOSXPreferencesFile.java b/jdk/src/macosx/classes/java/util/prefs/MacOSXPreferencesFile.java index 31355b5be46..e27ac0f1532 100644 --- a/jdk/src/macosx/classes/java/util/prefs/MacOSXPreferencesFile.java +++ b/jdk/src/macosx/classes/java/util/prefs/MacOSXPreferencesFile.java @@ -360,11 +360,11 @@ class MacOSXPreferencesFile { } } - void addChildToNode(String path, String child) + boolean addChildToNode(String path, String child) { synchronized(MacOSXPreferencesFile.class) { markChanged(); - addChildToNode(path, child+"/", appName, user, host); + return addChildToNode(path, child+"/", appName, user, host); } } @@ -433,7 +433,7 @@ class MacOSXPreferencesFile { addNode(String path, String name, long user, long host); private static final native void removeNode(String path, String name, long user, long host); - private static final native void + private static final native boolean addChildToNode(String path, String child, String name, long user, long host); private static final native void diff --git a/jdk/src/macosx/native/java/util/MacOSXPreferencesFile.m b/jdk/src/macosx/native/java/util/MacOSXPreferencesFile.m index a564e4bce38..d8bef393ad6 100644 --- a/jdk/src/macosx/native/java/util/MacOSXPreferencesFile.m +++ b/jdk/src/macosx/native/java/util/MacOSXPreferencesFile.m @@ -641,7 +641,7 @@ Java_java_util_prefs_MacOSXPreferencesFile_removeNode // child must end with '/' -JNIEXPORT void JNICALL +JNIEXPORT Boolean JNICALL Java_java_util_prefs_MacOSXPreferencesFile_addChildToNode (JNIEnv *env, jobject klass, jobject jpath, jobject jchild, jobject jname, jlong juser, jlong jhost) @@ -656,6 +656,7 @@ Java_java_util_prefs_MacOSXPreferencesFile_addChildToNode CFDictionaryRef node; CFStringRef topKey; CFMutableDictionaryRef topValue; + Boolean beforeAdd = false; if (!path || !child || !name) goto badparams; @@ -665,9 +666,12 @@ Java_java_util_prefs_MacOSXPreferencesFile_addChildToNode // copyMutableNode creates the node if necessary parent = copyMutableNode(path, name, user, host, &topKey, &topValue); throwIfNull(parent, "copyMutableNode failed"); - + beforeAdd = CFDictionaryContainsKey(parent, child); CFDictionaryAddValue(parent, child, node); - + if (!beforeAdd) + beforeAdd = CFDictionaryContainsKey(parent, child); + else + beforeAdd = false; CFPreferencesSetValue(topKey, topValue, name, user, host); CFRelease(parent); @@ -680,6 +684,7 @@ Java_java_util_prefs_MacOSXPreferencesFile_addChildToNode if (path) CFRelease(path); if (child) CFRelease(child); if (name) CFRelease(name); + return beforeAdd; } diff --git a/jdk/test/java/util/prefs/AddNodeChangeListener.java b/jdk/test/java/util/prefs/AddNodeChangeListener.java new file mode 100644 index 00000000000..8b506dc7e18 --- /dev/null +++ b/jdk/test/java/util/prefs/AddNodeChangeListener.java @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + + /* @test + * @bug 7160252 + * @summary Checks if events are delivered to a listener + * when a child node is added or removed + */ + +import java.util.prefs.*; + + public class AddNodeChangeListener { + + private static boolean failed = false; + private static Preferences userRoot, N2; + private static NodeChangeListenerAdd ncla; + + public static void main(String[] args) + throws BackingStoreException, InterruptedException + { + userRoot = Preferences.userRoot(); + ncla = new NodeChangeListenerAdd(); + userRoot.addNodeChangeListener(ncla); + //Should initiate a node added event + addNode(); + // Should not initiate a node added event + addNode(); + //Should initate a child removed event + removeNode(); + + if (failed) + throw new RuntimeException("Failed"); + } + + private static void addNode() + throws BackingStoreException, InterruptedException + { + N2 = userRoot.node("N2"); + userRoot.flush(); + Thread.sleep(3000); + if (ncla.getAddNumber() != 1) + failed = true; + } + + private static void removeNode() + throws BackingStoreException, InterruptedException + { + N2.removeNode(); + userRoot.flush(); + Thread.sleep(3000); + if (ncla.getAddNumber() != 0) + failed = true; + } + + private static class NodeChangeListenerAdd implements NodeChangeListener { + private int totalNode = 0; + + @Override + public void childAdded(NodeChangeEvent evt) { + totalNode++; + } + + @Override + public void childRemoved(NodeChangeEvent evt) { + totalNode--; + } + + public int getAddNumber(){ + return totalNode; + } + } + } From 27e9d6f36d59993a1721af028f6813d4f48deba4 Mon Sep 17 00:00:00 2001 From: Vladimir Kozlov Date: Fri, 13 Jul 2012 17:48:26 -0700 Subject: [PATCH 096/160] 7123926: Some CTW test crash: !_control.contains(ctrl) Don't eliminate Integer::toString() call node during String concatenation optimization if it has several uses. Reviewed-by: twisti --- hotspot/src/share/vm/opto/stringopts.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/hotspot/src/share/vm/opto/stringopts.cpp b/hotspot/src/share/vm/opto/stringopts.cpp index d606a7fdad6..803b1389932 100644 --- a/hotspot/src/share/vm/opto/stringopts.cpp +++ b/hotspot/src/share/vm/opto/stringopts.cpp @@ -533,7 +533,17 @@ StringConcat* PhaseStringOpts::build_candidate(CallStaticJavaNode* call) { if (arg->is_Proj() && arg->in(0)->is_CallStaticJava()) { CallStaticJavaNode* csj = arg->in(0)->as_CallStaticJava(); if (csj->method() != NULL && - csj->method()->intrinsic_id() == vmIntrinsics::_Integer_toString) { + csj->method()->intrinsic_id() == vmIntrinsics::_Integer_toString && + arg->outcnt() == 1) { + // _control is the list of StringBuilder calls nodes which + // will be replaced by new String code after this optimization. + // Integer::toString() call is not part of StringBuilder calls + // chain. It could be eliminated only if its result is used + // only by this SB calls chain. + // Another limitation: it should be used only once because + // it is unknown that it is used only by this SB calls chain + // until all related SB calls nodes are collected. + assert(arg->unique_out() == cnode, "sanity"); sc->add_control(csj); sc->push_int(csj->in(TypeFunc::Parms)); continue; From 3c9f53969abf296f133cb46b05914c4954bd481f Mon Sep 17 00:00:00 2001 From: Kumar Srinivasan Date: Sat, 14 Jul 2012 18:00:42 -0700 Subject: [PATCH 097/160] 7184145: (pack200) pack200 --repack throws NullPointerException when JAR file specified without path Reviewed-by: alanb, sherman --- .../com/sun/java/util/jar/pack/Driver.java | 12 ++- jdk/test/tools/pack200/RepackTest.java | 74 +++++++++++++++++++ 2 files changed, 82 insertions(+), 4 deletions(-) create mode 100644 jdk/test/tools/pack200/RepackTest.java diff --git a/jdk/src/share/classes/com/sun/java/util/jar/pack/Driver.java b/jdk/src/share/classes/com/sun/java/util/jar/pack/Driver.java index 960e2d40432..7ecbca05ef2 100644 --- a/jdk/src/share/classes/com/sun/java/util/jar/pack/Driver.java +++ b/jdk/src/share/classes/com/sun/java/util/jar/pack/Driver.java @@ -36,6 +36,7 @@ import java.io.OutputStream; import java.io.PrintStream; import java.text.MessageFormat; import java.nio.file.Files; +import java.nio.file.Path; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; @@ -381,12 +382,15 @@ class Driver { String prefix = base.getName(); if (prefix.length() < 3) prefix += "tmp"; - File where = base.getParentFile(); + File where = (base.getParentFile() == null && suffix.equals(".bak")) + ? new File(".").getAbsoluteFile() + : base.getParentFile(); - if ( base.getParentFile() == null && suffix.equals(".bak")) - where = new File(".").getAbsoluteFile(); + Path tmpfile = (where == null) + ? Files.createTempFile(prefix, suffix) + : Files.createTempFile(where.toPath(), prefix, suffix); - return Files.createTempFile(where.toPath(), prefix, suffix).toFile(); + return tmpfile.toFile(); } static private diff --git a/jdk/test/tools/pack200/RepackTest.java b/jdk/test/tools/pack200/RepackTest.java new file mode 100644 index 00000000000..774e0d66eb3 --- /dev/null +++ b/jdk/test/tools/pack200/RepackTest.java @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +/* + * @test + * @bug 7184145 + * @summary tests repacking of a simple named jarfile. + * @compile -XDignore.symbol.file Utils.java RepackTest.java + * @run main RepackTest + * @author ksrini + */ +public class RepackTest { + + public static void main(String... args) throws Exception { + testRepack(); + } + + /* + * there are two cases we need to test, where the file in question is + * orpaned, ie. without a parent ie. not qualified by a parent path + * relative nor absolute + * case 1: src and dest are the same + * case 2: src and dest are different + */ + static void testRepack() throws IOException { + + // make a copy of the test specimen to local directory + File testFile = new File("src_tools.jar"); + Utils.copyFile(Utils.locateJar("golden.jar"), testFile); + List cmdsList = new ArrayList<>(); + + // case 1: + cmdsList.add(Utils.getPack200Cmd()); + cmdsList.add("--repack"); + cmdsList.add(testFile.getName()); + Utils.runExec(cmdsList); + + // case 2: + File dstFile = new File("dst_tools.jar"); + cmdsList.clear(); + cmdsList.add(Utils.getPack200Cmd()); + cmdsList.add("--repack"); + cmdsList.add(dstFile.getName()); + cmdsList.add(testFile.getName()); + Utils.runExec(cmdsList); + + // tidy up + testFile.delete(); + dstFile.delete(); + } +} From 5ef289c76b743bc65fcc5def7f377565c78054a7 Mon Sep 17 00:00:00 2001 From: Sergey Bylokhov Date: Mon, 16 Jul 2012 14:00:36 +0400 Subject: [PATCH 098/160] 7181438: [OGL] Incorrect alpha used, during blit from SW to the texture Reviewed-by: prr, campbell --- .../native/sun/java2d/opengl/OGLBlitLoops.c | 14 ++++ jdk/test/sun/java2d/OpenGL/bug7181438.java | 83 +++++++++++++++++++ 2 files changed, 97 insertions(+) create mode 100644 jdk/test/sun/java2d/OpenGL/bug7181438.java diff --git a/jdk/src/share/native/sun/java2d/opengl/OGLBlitLoops.c b/jdk/src/share/native/sun/java2d/opengl/OGLBlitLoops.c index e27604a08eb..539143430a4 100644 --- a/jdk/src/share/native/sun/java2d/opengl/OGLBlitLoops.c +++ b/jdk/src/share/native/sun/java2d/opengl/OGLBlitLoops.c @@ -393,7 +393,16 @@ OGLBlitSwToTexture(SurfaceDataRasInfo *srcInfo, OGLPixelFormat *pf, OGLSDOps *dstOps, jint dx1, jint dy1, jint dx2, jint dy2) { + jboolean adjustAlpha = (pf != NULL && !pf->hasAlpha); j2d_glBindTexture(dstOps->textureTarget, dstOps->textureID); + + if (adjustAlpha) { + // if the source surface does not have an alpha channel, + // we need to ensure that the alpha values are forced to 1.0f + j2d_glPixelTransferf(GL_ALPHA_SCALE, 0.0f); + j2d_glPixelTransferf(GL_ALPHA_BIAS, 1.0f); + } + // in case pixel stride is not a multiple of scanline stride the copy // has to be done line by line (see 6207877) if (srcInfo->scanStride % srcInfo->pixelStride != 0) { @@ -413,6 +422,11 @@ OGLBlitSwToTexture(SurfaceDataRasInfo *srcInfo, OGLPixelFormat *pf, dx1, dy1, dx2-dx1, dy2-dy1, pf->format, pf->type, srcInfo->rasBase); } + if (adjustAlpha) { + // restore scale/bias to their original values + j2d_glPixelTransferf(GL_ALPHA_SCALE, 1.0f); + j2d_glPixelTransferf(GL_ALPHA_BIAS, 0.0f); + } } /** diff --git a/jdk/test/sun/java2d/OpenGL/bug7181438.java b/jdk/test/sun/java2d/OpenGL/bug7181438.java new file mode 100644 index 00000000000..3aa67387bf8 --- /dev/null +++ b/jdk/test/sun/java2d/OpenGL/bug7181438.java @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.GraphicsConfiguration; +import java.awt.GraphicsEnvironment; +import java.awt.Transparency; +import java.awt.image.BufferedImage; +import java.awt.image.VolatileImage; + +/** + * @test + * @bug 7181438 + * @summary Verifies that we get correct alpha, when we draw opaque + * BufferedImage to non opaque VolatileImage via intermediate opaque texture. + * @author Sergey Bylokhov + * @run main/othervm -Dsun.java2d.accthreshold=0 bug7181438 + */ +public final class bug7181438 { + + private static final int SIZE = 500; + + public static void main(final String[] args) { + + final BufferedImage bi = createBufferedImage(); + final VolatileImage vi = createVolatileImage(); + final Graphics s2dVi = vi.getGraphics(); + + //sw->texture->surface blit + s2dVi.drawImage(bi, 0, 0, null); + + final BufferedImage results = vi.getSnapshot(); + for (int i = 0; i < SIZE; ++i) { + for (int j = 0; j < SIZE; ++j) { + //Image should be opaque: (black color and alpha = 255) + if (results.getRGB(i, j) != 0xFF000000) { + throw new RuntimeException("Failed: Wrong alpha"); + } + } + } + System.out.println("Passed"); + } + + + private static VolatileImage createVolatileImage() { + final GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); + final GraphicsConfiguration gc = ge.getDefaultScreenDevice().getDefaultConfiguration(); + return gc.createCompatibleVolatileImage(SIZE, SIZE, + Transparency.TRANSLUCENT); + } + + private static BufferedImage createBufferedImage() { + final BufferedImage bi = new BufferedImage(SIZE, SIZE, + BufferedImage.TYPE_INT_RGB); + final Graphics bg = bi.getGraphics(); + //Black color and alpha = 0 + bg.setColor(new Color(0, 0, 0, 0)); + bg.fillRect(0, 0, SIZE, SIZE); + bg.dispose(); + return bi; + } +} From 6261447205436871f49fac9a83626c5490a0fa59 Mon Sep 17 00:00:00 2001 From: Sergey Bylokhov Date: Mon, 16 Jul 2012 14:04:03 +0400 Subject: [PATCH 099/160] 7170657: [macosx] There seems to be no keyboard/mouse action to select non-contiguous items in List Reviewed-by: rupashka --- .../classes/javax/swing/SwingUtilities.java | 9 ++- .../SwingUtilities/7170657/bug7170657.java | 78 +++++++++++++++++++ 2 files changed, 84 insertions(+), 3 deletions(-) create mode 100644 jdk/test/javax/swing/SwingUtilities/7170657/bug7170657.java diff --git a/jdk/src/share/classes/javax/swing/SwingUtilities.java b/jdk/src/share/classes/javax/swing/SwingUtilities.java index ecbe32e293f..956bb838be7 100644 --- a/jdk/src/share/classes/javax/swing/SwingUtilities.java +++ b/jdk/src/share/classes/javax/swing/SwingUtilities.java @@ -319,7 +319,8 @@ public class SwingUtilities implements SwingConstants newEvent = new MouseWheelEvent(newSource, sourceWheelEvent.getID(), sourceWheelEvent.getWhen(), - sourceWheelEvent.getModifiers(), + sourceWheelEvent.getModifiers() + | sourceWheelEvent.getModifiersEx(), p.x,p.y, sourceWheelEvent.getXOnScreen(), sourceWheelEvent.getYOnScreen(), @@ -334,7 +335,8 @@ public class SwingUtilities implements SwingConstants newEvent = new MenuDragMouseEvent(newSource, sourceMenuDragEvent.getID(), sourceMenuDragEvent.getWhen(), - sourceMenuDragEvent.getModifiers(), + sourceMenuDragEvent.getModifiers() + | sourceMenuDragEvent.getModifiersEx(), p.x,p.y, sourceMenuDragEvent.getXOnScreen(), sourceMenuDragEvent.getYOnScreen(), @@ -347,7 +349,8 @@ public class SwingUtilities implements SwingConstants newEvent = new MouseEvent(newSource, sourceEvent.getID(), sourceEvent.getWhen(), - sourceEvent.getModifiers(), + sourceEvent.getModifiers() + | sourceEvent.getModifiersEx(), p.x,p.y, sourceEvent.getXOnScreen(), sourceEvent.getYOnScreen(), diff --git a/jdk/test/javax/swing/SwingUtilities/7170657/bug7170657.java b/jdk/test/javax/swing/SwingUtilities/7170657/bug7170657.java new file mode 100644 index 00000000000..e28ce7ab9b9 --- /dev/null +++ b/jdk/test/javax/swing/SwingUtilities/7170657/bug7170657.java @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import java.awt.Frame; +import java.awt.event.InputEvent; +import java.awt.event.MouseEvent; +import java.awt.event.MouseWheelEvent; + +import javax.swing.SwingUtilities; +import javax.swing.event.MenuDragMouseEvent; + +/** + * @test + * @bug 7170657 + * @author Sergey Bylokhov + */ +public final class bug7170657 { + + private static boolean FAILED; + + public static void main(final String[] args) { + final int mask = InputEvent.META_DOWN_MASK | InputEvent.CTRL_MASK; + + Frame f = new Frame(); + + MouseEvent mwe = new MouseWheelEvent(f, 1, 1, mask, 1, 1, 1, 1, 1, true, + 1, 1, 1); + MouseEvent mdme = new MenuDragMouseEvent(f, 1, 1, mask, 1, 1, 1, 1, 1, + true, null, null); + MouseEvent me = new MouseEvent(f, 1, 1, mask, 1, 1, 1, 1, 1, true, + MouseEvent.NOBUTTON); + + test(f, mwe); + test(f, mdme); + test(f, me); + + if (FAILED) { + throw new RuntimeException("Wrong mouse event"); + } + } + + + private static void test(final Frame frame, final MouseEvent me) { + MouseEvent newme = SwingUtilities.convertMouseEvent(frame, me, frame); + if (me.getModifiersEx() != newme.getModifiersEx() + || me.getModifiers() != newme.getModifiers()) { + fail(me, newme); + } + } + + private static void fail(final MouseEvent exp, final MouseEvent act) { + System.err.println("Expected: " + exp); + System.err.println("Actual: " + act); + FAILED = true; + } +} From c0a96ff2a4b1e218b8de997d9be981aa1f178469 Mon Sep 17 00:00:00 2001 From: Frederic Parain Date: Mon, 16 Jul 2012 04:06:44 -0700 Subject: [PATCH 100/160] 7183754: Test runtime/6294277/Test6294277.sh runs wrong JVM Reviewed-by: kamg, coleenp, ctornqvi --- .../runtime/6294277/SourceDebugExtension.java | 1 + hotspot/test/runtime/6294277/Test6294277.sh | 92 ------------------- 2 files changed, 1 insertion(+), 92 deletions(-) delete mode 100644 hotspot/test/runtime/6294277/Test6294277.sh diff --git a/hotspot/test/runtime/6294277/SourceDebugExtension.java b/hotspot/test/runtime/6294277/SourceDebugExtension.java index 70b12969ce1..e8cc8a8bb50 100644 --- a/hotspot/test/runtime/6294277/SourceDebugExtension.java +++ b/hotspot/test/runtime/6294277/SourceDebugExtension.java @@ -25,6 +25,7 @@ * @test * @bug 6294277 * @summary java -Xdebug crashes on SourceDebugExtension attribute larger than 64K + * @run main/othervm -Xdebug -Xrunjdwp:transport=dt_socket,address=8888,server=y,suspend=n SourceDebugExtension */ import java.io.*; diff --git a/hotspot/test/runtime/6294277/Test6294277.sh b/hotspot/test/runtime/6294277/Test6294277.sh deleted file mode 100644 index 1ee2fdc6d37..00000000000 --- a/hotspot/test/runtime/6294277/Test6294277.sh +++ /dev/null @@ -1,92 +0,0 @@ -# -# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# This code is free software; you can redistribute it and/or modify it -# under the terms of the GNU General Public License version 2 only, as -# published by the Free Software Foundation. -# -# This code is distributed in the hope that it will be useful, but WITHOUT -# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -# version 2 for more details (a copy is included in the LICENSE file that -# accompanied this code). -# -# You should have received a copy of the GNU General Public License version -# 2 along with this work; if not, write to the Free Software Foundation, -# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. -# -# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA -# or visit www.oracle.com if you need additional information or have any -# questions. -# - - -# @test Test6294277.sh -# @bug 6294277 -# @summary java -Xdebug crashes on SourceDebugExtension attribute larger than 64K -# @run shell Test6294277.sh -# - - -if [ "${TESTSRC}" = "" ] -then TESTSRC=. -fi - -if [ "${TESTJAVA}" = "" ] -then - PARENT=`dirname \`which java\`` - TESTJAVA=`dirname ${PARENT}` - echo "TESTJAVA not set, selecting " ${TESTJAVA} - echo "If this is incorrect, try setting the variable manually." -fi - -BIT_FLAG="" - -# set platform-dependent variables -OS=`uname -s` -case "$OS" in - SunOS | Linux ) - NULL=/dev/null - PS=":" - FS="/" - ## for solaris, linux it's HOME - FILE_LOCATION=$HOME - if [ -f ${FILE_LOCATION}${FS}JDK64BIT -a ${OS} = "SunOS" -a `uname -p`='sparc' ] - then - BIT_FLAG="-d64" - fi - ;; - Windows_* | Darwin ) - NULL=NUL - PS=";" - FS="\\" - echo "Test skipped" - exit 0 - ;; - * ) - echo "Unrecognized system!" - exit 1; - ;; -esac - -cp ${TESTSRC}${FS}*.java . - -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -fullversion - -${TESTJAVA}${FS}bin${FS}javac *.java - -${TESTJAVA}${FS}bin${FS}java ${BIT_FLAG} -classpath . -Xdebug -Xrunjdwp:transport=dt_socket,address=8888,server=y,suspend=n SourceDebugExtension > test.out 2>&1 & - -P_PID=$! - -sleep 60 -STATUS=1 - -grep "Test PASSES" test.out > ${NULL} -if [ $? = 0 ]; then - cat test.out - STATUS=0 -fi - -exit $STATUS From 1bb1a8008c60aa81df33ca7d768147881fbe485c Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Mon, 16 Jul 2012 14:05:34 -0400 Subject: [PATCH 101/160] 7181989: NMT ON: Assertion failure when NMT checks thread's native stack base address Assertion on stack base is not necessary Reviewed-by: coleenp, dholmes, kvn --- hotspot/src/share/vm/services/memTracker.cpp | 6 ------ 1 file changed, 6 deletions(-) diff --git a/hotspot/src/share/vm/services/memTracker.cpp b/hotspot/src/share/vm/services/memTracker.cpp index 55c98596584..9a0f8796399 100644 --- a/hotspot/src/share/vm/services/memTracker.cpp +++ b/hotspot/src/share/vm/services/memTracker.cpp @@ -351,12 +351,6 @@ void MemTracker::create_memory_record(address addr, MEMFLAGS flags, } if (thread != NULL) { -#ifdef ASSERT - // cause assertion on stack base. This ensures that threads call - // Thread::record_stack_base_and_size() method, which will create - // thread native stack records. - thread->stack_base(); -#endif // for a JavaThread, if it is running in native state, we need to transition it to // VM state, so it can stop at safepoint. JavaThread running in VM state does not // need lock to write records. From 196abe25233a58bf36b523225de4d7980434d726 Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Mon, 16 Jul 2012 14:10:34 -0400 Subject: [PATCH 102/160] 7181986: NMT ON: Assertion failure when running jdi ExpiredRequestDeletionTest Changed _query_lock to heap object from static object. Also fixed _query_lock and snapshot lock ranks, so they can participate deadlock detection. Reviewed-by: coleenp, dholmes, kvn --- hotspot/src/share/vm/services/memSnapshot.cpp | 2 +- hotspot/src/share/vm/services/memTracker.cpp | 16 +++++++++++----- hotspot/src/share/vm/services/memTracker.hpp | 4 +++- 3 files changed, 15 insertions(+), 7 deletions(-) diff --git a/hotspot/src/share/vm/services/memSnapshot.cpp b/hotspot/src/share/vm/services/memSnapshot.cpp index 4c2a6c2664b..30288e546d4 100644 --- a/hotspot/src/share/vm/services/memSnapshot.cpp +++ b/hotspot/src/share/vm/services/memSnapshot.cpp @@ -173,7 +173,7 @@ MemSnapshot::MemSnapshot() { _staging_area = new (std::nothrow)MemPointerArrayImpl(); } - _lock = new (std::nothrow) Mutex(Monitor::native, "memSnapshotLock"); + _lock = new (std::nothrow) Mutex(Monitor::max_nonleaf - 1, "memSnapshotLock"); NOT_PRODUCT(_untracked_count = 0;) } diff --git a/hotspot/src/share/vm/services/memTracker.cpp b/hotspot/src/share/vm/services/memTracker.cpp index 55c98596584..c74ed41d395 100644 --- a/hotspot/src/share/vm/services/memTracker.cpp +++ b/hotspot/src/share/vm/services/memTracker.cpp @@ -54,7 +54,7 @@ void SyncThreadRecorderClosure::do_thread(Thread* thread) { MemRecorder* MemTracker::_global_recorder = NULL; MemSnapshot* MemTracker::_snapshot = NULL; MemBaseline MemTracker::_baseline; -Mutex MemTracker::_query_lock(Monitor::native, "NMT_queryLock"); +Mutex* MemTracker::_query_lock = NULL; volatile MemRecorder* MemTracker::_merge_pending_queue = NULL; volatile MemRecorder* MemTracker::_pooled_recorders = NULL; MemTrackWorker* MemTracker::_worker_thread = NULL; @@ -89,6 +89,12 @@ void MemTracker::bootstrap_single_thread() { return; } + _query_lock = new (std::nothrow) Mutex(Monitor::max_nonleaf, "NMT_queryLock"); + if (_query_lock == NULL) { + shutdown(NMT_out_of_memory); + return; + } + debug_only(_main_thread_tid = os::current_thread_id();) _state = NMT_bootstrapping_single_thread; NMT_track_callsite = (_tracking_level == NMT_detail && can_walk_stack()); @@ -164,7 +170,7 @@ void MemTracker::final_shutdown() { { // shared baseline and snapshot are the only objects needed to // create query results - MutexLockerEx locker(&_query_lock, true); + MutexLockerEx locker(_query_lock, true); // cleanup baseline data and snapshot _baseline.clear(); delete _snapshot; @@ -534,7 +540,7 @@ void MemTracker::thread_exiting(JavaThread* thread) { // baseline current memory snapshot bool MemTracker::baseline() { - MutexLockerEx lock(&_query_lock, true); + MutexLockerEx lock(_query_lock, true); MemSnapshot* snapshot = get_snapshot(); if (snapshot != NULL) { return _baseline.baseline(*snapshot, false); @@ -545,7 +551,7 @@ bool MemTracker::baseline() { // print memory usage from current snapshot bool MemTracker::print_memory_usage(BaselineOutputer& out, size_t unit, bool summary_only) { MemBaseline baseline; - MutexLockerEx lock(&_query_lock, true); + MutexLockerEx lock(_query_lock, true); MemSnapshot* snapshot = get_snapshot(); if (snapshot != NULL && baseline.baseline(*snapshot, summary_only)) { BaselineReporter reporter(out, unit); @@ -557,7 +563,7 @@ bool MemTracker::print_memory_usage(BaselineOutputer& out, size_t unit, bool sum // compare memory usage between current snapshot and baseline bool MemTracker::compare_memory_usage(BaselineOutputer& out, size_t unit, bool summary_only) { - MutexLockerEx lock(&_query_lock, true); + MutexLockerEx lock(_query_lock, true); if (_baseline.baselined()) { MemBaseline baseline; MemSnapshot* snapshot = get_snapshot(); diff --git a/hotspot/src/share/vm/services/memTracker.hpp b/hotspot/src/share/vm/services/memTracker.hpp index b5607c1a0f8..63e65cfb71c 100644 --- a/hotspot/src/share/vm/services/memTracker.hpp +++ b/hotspot/src/share/vm/services/memTracker.hpp @@ -126,6 +126,8 @@ class MemTracker : AllStatic { return "Native memory tracking has been shutdown by user"; case NMT_normal: return "Native memory tracking has been shutdown due to process exiting"; + case NMT_out_of_memory: + return "Native memory tracking has been shutdown due to out of native memory"; case NMT_initialization: return "Native memory tracking failed to initialize"; case NMT_error_reporting: @@ -336,7 +338,7 @@ class MemTracker : AllStatic { static MemBaseline _baseline; // query lock - static Mutex _query_lock; + static Mutex* _query_lock; // a thread can start to allocate memory before it is attached // to VM 'Thread', those memory activities are recorded here. From 19ea8f720f9b087cf91c81560a5971e0c7c24d91 Mon Sep 17 00:00:00 2001 From: Christian Thalinger Date: Mon, 16 Jul 2012 11:14:41 -0700 Subject: [PATCH 103/160] 7087357: JSR 292: remove obsolete code after 7085860 Reviewed-by: kvn, never --- .../src/share/vm/classfile/javaClasses.cpp | 11 ------ .../vm/interpreter/interpreterRuntime.cpp | 17 --------- hotspot/src/share/vm/prims/methodHandles.cpp | 8 ++-- hotspot/src/share/vm/prims/unsafe.cpp | 38 +++++-------------- 4 files changed, 13 insertions(+), 61 deletions(-) diff --git a/hotspot/src/share/vm/classfile/javaClasses.cpp b/hotspot/src/share/vm/classfile/javaClasses.cpp index 5d9ee6c747c..c6971302107 100644 --- a/hotspot/src/share/vm/classfile/javaClasses.cpp +++ b/hotspot/src/share/vm/classfile/javaClasses.cpp @@ -2738,17 +2738,6 @@ void java_lang_invoke_CallSite::compute_offsets() { if (k != NULL) { compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_lang_invoke_MethodHandle_signature()); } - - // Disallow compilation of CallSite.setTargetNormal and CallSite.setTargetVolatile - // (For C2: keep this until we have throttling logic for uncommon traps.) - if (k != NULL) { - instanceKlass* ik = instanceKlass::cast(k); - methodOop m_normal = ik->lookup_method(vmSymbols::setTargetNormal_name(), vmSymbols::setTarget_signature()); - methodOop m_volatile = ik->lookup_method(vmSymbols::setTargetVolatile_name(), vmSymbols::setTarget_signature()); - guarantee(m_normal != NULL && m_volatile != NULL, "must exist"); - m_normal->set_not_compilable_quietly(); - m_volatile->set_not_compilable_quietly(); - } } diff --git a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp index 6f5511f9fcc..cb17be839b5 100644 --- a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp +++ b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp @@ -547,23 +547,6 @@ IRT_ENTRY(void, InterpreterRuntime::resolve_get_put(JavaThread* thread, Bytecode } } - if (is_put && !is_static && klass->is_subclass_of(SystemDictionary::CallSite_klass()) && (info.name() == vmSymbols::target_name())) { - const jint direction = frame::interpreter_frame_expression_stack_direction(); - Handle call_site (THREAD, *((oop*) thread->last_frame().interpreter_frame_tos_at(-1 * direction))); - Handle method_handle(THREAD, *((oop*) thread->last_frame().interpreter_frame_tos_at( 0 * direction))); - assert(call_site ->is_a(SystemDictionary::CallSite_klass()), "must be"); - assert(method_handle->is_a(SystemDictionary::MethodHandle_klass()), "must be"); - - { - // Walk all nmethods depending on this call site. - MutexLocker mu(Compile_lock, thread); - Universe::flush_dependents_on(call_site, method_handle); - } - - // Don't allow fast path for setting CallSite.target and sub-classes. - put_code = (Bytecodes::Code) 0; - } - cache_entry(thread)->set_field( get_code, put_code, diff --git a/hotspot/src/share/vm/prims/methodHandles.cpp b/hotspot/src/share/vm/prims/methodHandles.cpp index 552fbe6a803..0501496fdc0 100644 --- a/hotspot/src/share/vm/prims/methodHandles.cpp +++ b/hotspot/src/share/vm/prims/methodHandles.cpp @@ -3180,17 +3180,15 @@ JVM_ENTRY(void, JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass MHN_class)) jclass MH_class = env->FindClass(MH_name); status = env->RegisterNatives(MH_class, invoke_methods, sizeof(invoke_methods)/sizeof(JNINativeMethod)); } + if (!env->ExceptionOccurred()) { + status = env->RegisterNatives(MHN_class, call_site_methods, sizeof(call_site_methods)/sizeof(JNINativeMethod)); + } if (env->ExceptionOccurred()) { warning("JSR 292 method handle code is mismatched to this JVM. Disabling support."); enable_MH = false; env->ExceptionClear(); } - status = env->RegisterNatives(MHN_class, call_site_methods, sizeof(call_site_methods)/sizeof(JNINativeMethod)); - if (env->ExceptionOccurred()) { - // Exception is okay until 7087357 - env->ExceptionClear(); - } } if (enable_MH) { diff --git a/hotspot/src/share/vm/prims/unsafe.cpp b/hotspot/src/share/vm/prims/unsafe.cpp index 19f77a5f160..0ef374cffd3 100644 --- a/hotspot/src/share/vm/prims/unsafe.cpp +++ b/hotspot/src/share/vm/prims/unsafe.cpp @@ -178,17 +178,6 @@ jint Unsafe_invocation_key_to_method_slot(jint key) { v = *(oop*)index_oop_from_field_offset_long(p, offset); \ } -#define GET_OOP_FIELD_VOLATILE(obj, offset, v) \ - oop p = JNIHandles::resolve(obj); \ - volatile oop v; \ - if (UseCompressedOops) { \ - volatile narrowOop n = *(volatile narrowOop*)index_oop_from_field_offset_long(p, offset); \ - v = oopDesc::decode_heap_oop(n); \ - } else { \ - v = *(volatile oop*)index_oop_from_field_offset_long(p, offset); \ - } \ - OrderAccess::acquire(); - // Get/SetObject must be special-cased, since it works with handles. @@ -296,28 +285,21 @@ UNSAFE_END UNSAFE_ENTRY(jobject, Unsafe_GetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) UnsafeWrapper("Unsafe_GetObjectVolatile"); - GET_OOP_FIELD_VOLATILE(obj, offset, v) + oop p = JNIHandles::resolve(obj); + void* addr = index_oop_from_field_offset_long(p, offset); + volatile oop v; + if (UseCompressedOops) { + volatile narrowOop n = *(volatile narrowOop*) addr; + v = oopDesc::decode_heap_oop(n); + } else { + v = *(volatile oop*) addr; + } + OrderAccess::acquire(); return JNIHandles::make_local(env, v); UNSAFE_END UNSAFE_ENTRY(void, Unsafe_SetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) UnsafeWrapper("Unsafe_SetObjectVolatile"); - { - // Catch VolatileCallSite.target stores (via - // CallSite.setTargetVolatile) and check call site dependencies. - oop p = JNIHandles::resolve(obj); - if ((offset == java_lang_invoke_CallSite::target_offset_in_bytes()) && p->is_a(SystemDictionary::CallSite_klass())) { - Handle call_site (THREAD, p); - Handle method_handle(THREAD, JNIHandles::resolve(x_h)); - assert(call_site ->is_a(SystemDictionary::CallSite_klass()), "must be"); - assert(method_handle->is_a(SystemDictionary::MethodHandle_klass()), "must be"); - { - // Walk all nmethods depending on this call site. - MutexLocker mu(Compile_lock, thread); - Universe::flush_dependents_on(call_site(), method_handle()); - } - } - } oop x = JNIHandles::resolve(x_h); oop p = JNIHandles::resolve(obj); void* addr = index_oop_from_field_offset_long(p, offset); From 889ba6136979f29fc1670f888cbcca6d1409e54e Mon Sep 17 00:00:00 2001 From: Kelly O'Hair Date: Mon, 16 Jul 2012 11:43:23 -0700 Subject: [PATCH 104/160] 7184406: Adjust get_source/hgforest script to allow for trailing // characters Reviewed-by: tbell --- make/scripts/hgforest.sh | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/make/scripts/hgforest.sh b/make/scripts/hgforest.sh index aa67490c351..5906f721c87 100644 --- a/make/scripts/hgforest.sh +++ b/make/scripts/hgforest.sh @@ -98,7 +98,8 @@ for i in ${repos} ; do ( ( if [ "${command}" = "clone" -o "${command}" = "fclone" ] ; then - cline="hg clone ${pull_default}/${i} ${i}" + pull_newrepo="`echo ${pull_default}/${i} | sed -e 's@\([^:]/\)//*@\1@g'`" + cline="hg clone ${pull_newrepo} ${i}" echo "# ${cline}" ( eval "${cline}" ) else @@ -121,7 +122,8 @@ if [ "${repos_extra}" != "" ] ; then n=`expr ${n} '+' 1` ( ( - cline="hg clone ${pull_extra}/${i} ${i}" + pull_newextrarepo="`echo ${pull_extra}/${i} | sed -e 's@\([^:]/\)//*@\1@g'`" + cline="hg clone ${pull_newextrarepo} ${i}" echo "# ${cline}" ( eval "${cline}" ) echo "# exit code $?" From 62ce00b4ca9d56c080d744143b4ae648dbc16ebd Mon Sep 17 00:00:00 2001 From: Dean Long Date: Mon, 16 Jul 2012 15:31:18 -0400 Subject: [PATCH 105/160] 7147464: Java crashed while executing method with over 8k of dneg operations Replace recursive method with iterative Reviewed-by: kvn, twisti --- hotspot/src/share/vm/opto/phaseX.cpp | 103 +++++++++++++++++---------- hotspot/src/share/vm/opto/phaseX.hpp | 6 +- 2 files changed, 70 insertions(+), 39 deletions(-) diff --git a/hotspot/src/share/vm/opto/phaseX.cpp b/hotspot/src/share/vm/opto/phaseX.cpp index 99b7393b4cf..0fbcf4d09e1 100644 --- a/hotspot/src/share/vm/opto/phaseX.cpp +++ b/hotspot/src/share/vm/opto/phaseX.cpp @@ -757,6 +757,7 @@ void PhaseGVN::dead_loop_check( Node *n ) { //------------------------------PhaseIterGVN----------------------------------- // Initialize hash table to fresh and clean for +VerifyOpto PhaseIterGVN::PhaseIterGVN( PhaseIterGVN *igvn, const char *dummy ) : PhaseGVN(igvn,dummy), _worklist( ), + _stack(C->unique() >> 1), _delay_transform(false) { } @@ -764,6 +765,7 @@ PhaseIterGVN::PhaseIterGVN( PhaseIterGVN *igvn, const char *dummy ) : PhaseGVN(i // Initialize with previous PhaseIterGVN info; used by PhaseCCP PhaseIterGVN::PhaseIterGVN( PhaseIterGVN *igvn ) : PhaseGVN(igvn), _worklist( igvn->_worklist ), + _stack( igvn->_stack ), _delay_transform(igvn->_delay_transform) { } @@ -772,6 +774,7 @@ PhaseIterGVN::PhaseIterGVN( PhaseIterGVN *igvn ) : PhaseGVN(igvn), // Initialize with previous PhaseGVN info from Parser PhaseIterGVN::PhaseIterGVN( PhaseGVN *gvn ) : PhaseGVN(gvn), _worklist(*C->for_igvn()), + _stack(C->unique() >> 1), _delay_transform(false) { uint max; @@ -1138,51 +1141,77 @@ const Type* PhaseIterGVN::saturate(const Type* new_type, const Type* old_type, // Kill a globally dead Node. All uses are also globally dead and are // aggressively trimmed. void PhaseIterGVN::remove_globally_dead_node( Node *dead ) { - assert(dead != C->root(), "killing root, eh?"); - if (dead->is_top()) return; - NOT_PRODUCT( set_progress(); ) - // Remove from iterative worklist - _worklist.remove(dead); - if (!dead->is_Con()) { // Don't kill cons but uses - // Remove from hash table - _table.hash_delete( dead ); - // Smash all inputs to 'dead', isolating him completely - for( uint i = 0; i < dead->req(); i++ ) { - Node *in = dead->in(i); - if( in ) { // Points to something? - dead->set_req(i,NULL); // Kill the edge - if (in->outcnt() == 0 && in != C->top()) {// Made input go dead? - remove_dead_node(in); // Recursively remove - } else if (in->outcnt() == 1 && - in->has_special_unique_user()) { - _worklist.push(in->unique_out()); - } else if (in->outcnt() <= 2 && dead->is_Phi()) { - if( in->Opcode() == Op_Region ) - _worklist.push(in); - else if( in->is_Store() ) { - DUIterator_Fast imax, i = in->fast_outs(imax); - _worklist.push(in->fast_out(i)); - i++; - if(in->outcnt() == 2) { - _worklist.push(in->fast_out(i)); - i++; + enum DeleteProgress { + PROCESS_INPUTS, + PROCESS_OUTPUTS + }; + assert(_stack.is_empty(), "not empty"); + _stack.push(dead, PROCESS_INPUTS); + + while (_stack.is_nonempty()) { + dead = _stack.node(); + uint progress_state = _stack.index(); + assert(dead != C->root(), "killing root, eh?"); + assert(!dead->is_top(), "add check for top when pushing"); + NOT_PRODUCT( set_progress(); ) + if (progress_state == PROCESS_INPUTS) { + // After following inputs, continue to outputs + _stack.set_index(PROCESS_OUTPUTS); + // Remove from iterative worklist + _worklist.remove(dead); + if (!dead->is_Con()) { // Don't kill cons but uses + bool recurse = false; + // Remove from hash table + _table.hash_delete( dead ); + // Smash all inputs to 'dead', isolating him completely + for( uint i = 0; i < dead->req(); i++ ) { + Node *in = dead->in(i); + if( in ) { // Points to something? + dead->set_req(i,NULL); // Kill the edge + if (in->outcnt() == 0 && in != C->top()) {// Made input go dead? + _stack.push(in, PROCESS_INPUTS); // Recursively remove + recurse = true; + } else if (in->outcnt() == 1 && + in->has_special_unique_user()) { + _worklist.push(in->unique_out()); + } else if (in->outcnt() <= 2 && dead->is_Phi()) { + if( in->Opcode() == Op_Region ) + _worklist.push(in); + else if( in->is_Store() ) { + DUIterator_Fast imax, i = in->fast_outs(imax); + _worklist.push(in->fast_out(i)); + i++; + if(in->outcnt() == 2) { + _worklist.push(in->fast_out(i)); + i++; + } + assert(!(i < imax), "sanity"); + } } - assert(!(i < imax), "sanity"); } } + + if (dead->is_macro()) { + C->remove_macro_node(dead); + } + + if (recurse) { + continue; + } } } - if (dead->is_macro()) { - C->remove_macro_node(dead); + // Aggressively kill globally dead uses + // (Rather than pushing all the outs at once, we push one at a time, + // plus the parent to resume later, because of the indefinite number + // of edge deletions per loop trip.) + if (dead->outcnt() > 0) { + // Recursively remove + _stack.push(dead->raw_out(0), PROCESS_INPUTS); + } else { + _stack.pop(); } } - // Aggressively kill globally dead uses - // (Cannot use DUIterator_Last because of the indefinite number - // of edge deletions per loop trip.) - while (dead->outcnt() > 0) { - remove_globally_dead_node(dead->raw_out(0)); - } } //------------------------------subsume_node----------------------------------- diff --git a/hotspot/src/share/vm/opto/phaseX.hpp b/hotspot/src/share/vm/opto/phaseX.hpp index 1affa5c15b6..8a58a9d8927 100644 --- a/hotspot/src/share/vm/opto/phaseX.hpp +++ b/hotspot/src/share/vm/opto/phaseX.hpp @@ -403,6 +403,8 @@ class PhaseIterGVN : public PhaseGVN { // Subsume users of node 'old' into node 'nn' void subsume_node( Node *old, Node *nn ); + Node_Stack _stack; // Stack used to avoid recursion + protected: // Idealize new Node 'n' with respect to its inputs and its value @@ -438,8 +440,8 @@ public: // It is significant only for debugging and profiling. Node* register_new_node_with_optimizer(Node* n, Node* orig = NULL); - // Kill a globally dead Node. It is allowed to have uses which are - // assumed dead and left 'in limbo'. + // Kill a globally dead Node. All uses are also globally dead and are + // aggressively trimmed. void remove_globally_dead_node( Node *dead ); // Kill all inputs to a dead node, recursively making more dead nodes. From b530224aad877153e8c3c5e85f1ceeab97a51e30 Mon Sep 17 00:00:00 2001 From: Vinnie Ryan Date: Mon, 16 Jul 2012 22:38:49 +0100 Subject: [PATCH 106/160] 6880559: Enable PKCS11 64-bit windows builds Reviewed-by: valeriep --- jdk/THIRD_PARTY_README | 394 ++++++++++++++++++ jdk/make/sun/security/Makefile | 11 +- jdk/test/sun/security/pkcs11/PKCS11Test.java | 4 + .../pkcs11/nss/lib/windows-amd64/freebl3.chk | Bin 0 -> 478 bytes .../pkcs11/nss/lib/windows-amd64/freebl3.dll | Bin 0 -> 445440 bytes .../pkcs11/nss/lib/windows-amd64/libnspr4.dll | Bin 0 -> 241664 bytes .../pkcs11/nss/lib/windows-amd64/libnspr4.lib | Bin 0 -> 86162 bytes .../pkcs11/nss/lib/windows-amd64/libplc4.dll | Bin 0 -> 17408 bytes .../pkcs11/nss/lib/windows-amd64/libplc4.lib | Bin 0 -> 9104 bytes .../pkcs11/nss/lib/windows-amd64/libplds4.dll | Bin 0 -> 14336 bytes .../pkcs11/nss/lib/windows-amd64/libplds4.lib | Bin 0 -> 6920 bytes .../pkcs11/nss/lib/windows-amd64/nss3.dll | Bin 0 -> 1052160 bytes .../pkcs11/nss/lib/windows-amd64/nss3.lib | Bin 0 -> 178038 bytes .../pkcs11/nss/lib/windows-amd64/nssckbi.dll | Bin 0 -> 435200 bytes .../pkcs11/nss/lib/windows-amd64/nssdbm3.chk | Bin 0 -> 478 bytes .../pkcs11/nss/lib/windows-amd64/nssdbm3.dll | Bin 0 -> 142336 bytes .../pkcs11/nss/lib/windows-amd64/nssutil3.dll | Bin 0 -> 120320 bytes .../pkcs11/nss/lib/windows-amd64/nssutil3.lib | Bin 0 -> 41542 bytes .../pkcs11/nss/lib/windows-amd64/softokn3.chk | Bin 0 -> 478 bytes .../pkcs11/nss/lib/windows-amd64/softokn3.dll | Bin 0 -> 263168 bytes .../pkcs11/nss/lib/windows-amd64/sqlite3.dll | Bin 0 -> 562688 bytes .../pkcs11/nss/lib/windows-amd64/ssl3.dll | Bin 0 -> 241152 bytes .../pkcs11/nss/lib/windows-amd64/ssl3.lib | Bin 0 -> 17208 bytes .../pkcs11/nss/lib/windows-i586/freebl3.chk | Bin 0 -> 478 bytes .../pkcs11/nss/lib/windows-i586/freebl3.dll | Bin 0 -> 307351 bytes .../pkcs11/nss/lib/windows-i586/libnspr4.dll | Bin 0 -> 213116 bytes .../pkcs11/nss/lib/windows-i586/libnspr4.lib | Bin 0 -> 88388 bytes .../pkcs11/nss/lib/windows-i586/libplc4.dll | Bin 0 -> 28801 bytes .../pkcs11/nss/lib/windows-i586/libplc4.lib | Bin 0 -> 9534 bytes .../pkcs11/nss/lib/windows-i586/libplds4.dll | Bin 0 -> 24700 bytes .../pkcs11/nss/lib/windows-i586/libplds4.lib | Bin 0 -> 7266 bytes .../pkcs11/nss/lib/windows-i586/nss3.dll | Bin 0 -> 774270 bytes .../pkcs11/nss/lib/windows-i586/nss3.lib | Bin 0 -> 182040 bytes .../pkcs11/nss/lib/windows-i586/nssckbi.dll | Bin 0 -> 381067 bytes .../pkcs11/nss/lib/windows-i586/nssdbm3.chk | Bin 0 -> 478 bytes .../pkcs11/nss/lib/windows-i586/nssdbm3.dll | Bin 0 -> 114831 bytes .../pkcs11/nss/lib/windows-i586/nssutil3.dll | Bin 0 -> 102531 bytes .../pkcs11/nss/lib/windows-i586/nssutil3.lib | Bin 0 -> 42550 bytes .../pkcs11/nss/lib/windows-i586/softokn3.chk | Bin 0 -> 478 bytes .../pkcs11/nss/lib/windows-i586/softokn3.dll | Bin 0 -> 204935 bytes .../pkcs11/nss/lib/windows-i586/sqlite3.dll | Bin 0 -> 331908 bytes .../pkcs11/nss/lib/windows-i586/ssl3.dll | Bin 0 -> 204926 bytes .../pkcs11/nss/lib/windows-i586/ssl3.lib | Bin 0 -> 17760 bytes jdk/test/sun/security/pkcs11/nss/src/MD5SUMS | 1 + jdk/test/sun/security/pkcs11/nss/src/SHA1SUMS | 1 + .../security/pkcs11/nss/src/nss-3.13.1.tar.gz | Bin 0 -> 5985329 bytes 46 files changed, 402 insertions(+), 9 deletions(-) create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/freebl3.chk create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/freebl3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libnspr4.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libnspr4.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplc4.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplc4.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplds4.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplds4.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nss3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nss3.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nssckbi.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nssdbm3.chk create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nssdbm3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nssutil3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nssutil3.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/softokn3.chk create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/softokn3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/sqlite3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/ssl3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/ssl3.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/freebl3.chk create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/freebl3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libnspr4.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libnspr4.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libplc4.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libplc4.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libplds4.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libplds4.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nss3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nss3.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssckbi.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssdbm3.chk create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssdbm3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssutil3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssutil3.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/softokn3.chk create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/softokn3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/sqlite3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/ssl3.dll create mode 100644 jdk/test/sun/security/pkcs11/nss/lib/windows-i586/ssl3.lib create mode 100644 jdk/test/sun/security/pkcs11/nss/src/MD5SUMS create mode 100644 jdk/test/sun/security/pkcs11/nss/src/SHA1SUMS create mode 100644 jdk/test/sun/security/pkcs11/nss/src/nss-3.13.1.tar.gz diff --git a/jdk/THIRD_PARTY_README b/jdk/THIRD_PARTY_README index ee5463a922e..759733bfceb 100644 --- a/jdk/THIRD_PARTY_README +++ b/jdk/THIRD_PARTY_README @@ -3383,3 +3383,397 @@ included with JRE 7, JDK 7, and OpenJDK 7, except where noted: ------------------------------------------------------------------------------- +%% This notice is provided with respect to Mozilla Network Security +Services (NSS), which is supplied with the JDK test suite in the OpenJDK +source code repository. It is licensed under Mozilla Public License (MPL), +version 2.0. + +The NSS libraries are supplied in executable form, built from unmodified +NSS source code labeled with the "NSS_3.13.1_RTM" release tag. + +The NSS source code is available in the OpenJDK source code repository at: + jdk/test/sun/security/pkcs11/nss/src + +The NSS libraries are available in the OpenJDK source code repository at: + jdk/test/sun/security/pkcs11/nss/lib + +--- begin of LICENSE --- + +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. + +--- end of LICENSE --- + +------------------------------------------------------------------------------- + diff --git a/jdk/make/sun/security/Makefile b/jdk/make/sun/security/Makefile index 217a7ef1bc0..50720320121 100644 --- a/jdk/make/sun/security/Makefile +++ b/jdk/make/sun/security/Makefile @@ -1,5 +1,5 @@ # -# Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1996, 2012, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -44,15 +44,8 @@ ifneq ($(PLATFORM), windows) JGSS_WRAPPER = jgss/wrapper endif -# Build PKCS#11 on all platforms except 64-bit Windows. -# We exclude windows-amd64 because we don't have any -# 64-bit PKCS#11 implementations to test with on that platform. +# Build PKCS#11 on all platforms PKCS11 = pkcs11 -ifeq ($(ARCH_DATA_MODEL), 64) - ifeq ($(PLATFORM), windows) - PKCS11 = - endif -endif # Build Microsoft CryptoAPI provider only on Windows platform. MSCAPI = diff --git a/jdk/test/sun/security/pkcs11/PKCS11Test.java b/jdk/test/sun/security/pkcs11/PKCS11Test.java index d47c30e6cac..3fc5d86f423 100644 --- a/jdk/test/sun/security/pkcs11/PKCS11Test.java +++ b/jdk/test/sun/security/pkcs11/PKCS11Test.java @@ -245,6 +245,10 @@ public abstract class PKCS11Test { osMap.put("SunOS-amd64-64", "/usr/lib/mps/64/"); osMap.put("Linux-i386-32", "/usr/lib/"); osMap.put("Linux-amd64-64", "/usr/lib64/"); + osMap.put("Windows-x86-32", + PKCS11_BASE + "/nss/lib/windows-i586/".replace('/', SEP)); + osMap.put("Windows-amd64-64", + PKCS11_BASE + "/nss/lib/windows-amd64/".replace('/', SEP)); } private final static char[] hexDigits = "0123456789abcdef".toCharArray(); diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/freebl3.chk b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/freebl3.chk new file mode 100644 index 0000000000000000000000000000000000000000..f661c20fec9f5b4b5a9450c4a418bc87e35b347c GIT binary patch literal 478 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 z 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 z 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 {$QdAWKBQ!;wtFYtmxB6!*#`RQ7c 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

F!t4N}ytN0jn!R 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 Cspv)k literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplc4.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplc4.dll new file mode 100644 index 0000000000000000000000000000000000000000..dbf13dafab9411ef7b6796c560fa5bb4ba38d81a GIT binary patch literal 17408 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 literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplc4.lib b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplc4.lib new file mode 100644 index 0000000000000000000000000000000000000000..145179e605c341768681a7a1345f63e21226f1c6 GIT binary patch literal 9104 zcmcIqNpDm~5dJVEfZ4q7%Xnc8BG?`SmQZBCBp{5jjNyPR4Q6J*7UqpL9;84da`TA; zQvL$DaY6_w5(mUNk#b0Gdi z#q82|_1~t#zmc)g(Zi!7>4}Lj|FByfIXdbVuhs*&1nhVRGzUe9YcRQe|#4o9H!KD}cl6qenYU=?Mbv-cD_J(yu>xR0Q07YHz4Ye--in{+Y)Xu&X zbx>bX&qG5U9G9X2_M@ohxS{@gfTGk>Lj!$mC-prt)ZfB((%@x71FzXmO3fJRf5mpv z;4?$bDL_%v6GJU80Y$Bk4K?3qJE>*GQ0p1;NzES=Win^a&t90D&rF@ZcxvwK?EHnf z%*yh$)s<`-nas?k>FKBdes(2H`}~C+1I3WBJyq(!ZQ9t}Pdw*}}3@f?c1T z&a9P+D|yG259+4m*iD*Y+On&6LRzZsYS~Rrxb1F8Pc`0kHFLLDLv5;V`n+Du=R-}J z;o{k9PN0`vT+3%~g?sgQ-e_Y)oUn|l(NLiQcs$dKsuklzG*ckiG8#!Sg-oO)EhKu% zE|#pZlmh*56IH!7mck3I8SeOP8?o+<$ZB$wJzcFO%O3T@ z!MSl^wREw>a+Pmw;>AF=-y)-MkNuUVfV{}t=cSWh(rPnw9u6Y6m* zaG&)Rmd~*Kfn^@j*n{2JkApaXz4!+EumcU)g=Vy(18vxhdThg2*oh`Iq6J-O#};hG zc6^OK^rIU?7(@?x(TM@1FpLeTt9hTBun8O0?l(Rhc&F{t@xElOa*TJ8W%+d2f5P5O z&y2=?u{G_m9}2F7Qu=;06OqzC9fPw;9AWC5HOkh>V@G~nSE0j~_68t>Xn-3zdR@I> z6yiva35l+_n3E%nAp)9+rY4vgO`$0Cf(dw$?lW>9lj0C22%`5bVkljXl zwaw&hk#Z9HPu>UId%~gI%8EV+|L?|^o)~lQepl;r>l^V?@%Nc+8^H6y{0`;v*KXe! zzUWqQf(2e}Lcd8goIJFgTP!UOk9rL}pzsIjUzf3w-$@*P?#dl;**t@Qk0eh{@h6db zUdL|}&nWfVCMLBP%?+E$`%||-OZ3e(onOut3u}ezrPRK;{i*4*Gw0m)&_{u(fhYox zBUR!_&!bV51PUgzgsK}f0B%p`8Q&sY@{}*)0p+YKb2{4k6BqG{t#<54WPklb0JF&PR!i7l`flph~N|~xc8;PGEuRFxjXm%nd;VO<> z>7(&@yqYoaYdo3XRfpwmcFU5y4)U(0u|(P^p+vbnk4!+?Y>-4UDtfQn_Y;t|7$lvQ zn)kP=kP=pEYY0i_QWC0iuSl3xeF#gXX%b45%Uh|@c>m*50dM8nC$#-(S8Eu{4m*{vRDwseNvv?-sVPpoz_CI?O>sH|PSyU9V7E?zV}*sv=ktj?k59yW zq4grRdG`>0CY`-JpG%lecYtFDpvvcyfYTG;*rB0voCLe|1~~eOrYgIQ$DiAL_UEg) zzdq*WM*`J!M*RVjeo>M@qFkOQBv>vbaO}`iF;0Rf3-kSFXT N4*RzM2gA?i{{!{KG`j!* literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplds4.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplds4.dll new file mode 100644 index 0000000000000000000000000000000000000000..6d44edb6766a8b52973fae42ae0b21dd2e8f4a11 GIT binary patch literal 14336 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 literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplds4.lib b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/libplds4.lib new file mode 100644 index 0000000000000000000000000000000000000000..9c552e4360398cfc9d3dabb4d60b2cd48b1aeabd GIT binary patch literal 6920 zcmcIo%}*Og6n{Vyi1~=Ye1}p;P1UrDC>WbURUrtZ4GM9PAyICQ!P{Wfc&TlQdP$=k zIQ7;`ls}-#F~_KfD5spNic=3c^pHOw$6V9j?9A@Y%+4-$Ojmjy&zs-OZ$938^KtRp zLUm_%G4@qb{bpuUsp-^AdVWFGPmAo#?7aAUFGfTeqV60~??a-#=R{*KxWosE9C?cr z(*H`xU8Io2J0V9%Ap>(<;*Wrbj9=k0v`EBc1Z^-G-R3g#0C~vZF_+QT&_l+uT!tSL zF&XLNGCYYqWat@}!6NEG2A*w7p+0 z*3y*EXK$~s2NCqE3*msR>$kHv@~g{R%d`P_rBq+8T9v|vZI{tTX>UItP($Hhmdj;( zr%<cU#I?z}Iv_R}0j4Rm(Cor>YsQR4LVVO-QYP z_0itjFYK76B~aq_lQ*x8StxtXj2t)&9kAE>I$)bA`io z+y3!j-+=eaj5Sv5O06DMjRUm0%f+I(4l9tcW}uEjA9L28{j)SP-gx~ox!rI$Z%4+4 zPK_uCV#6kdR|w9?waUSsRfStztJJF{t7e#+07Pb8J=ilXoud}GO*CA&uQn`nKsZ)e zwYWl}*YrN}PN94t_fr5BHG;++t6D4Bl?}U8sgs^>K0Ysa@p%FPI@e9~u$Sn0AJL03 zM7=oCTga<^qPviH38Ev&+yK!d=&y_uEe-)QLbQ#D_yFlKqWNq5&!Yb0VWKYRCXqe^ zu86Xys5^=_o}ex^1Uf@Kbe6iPle%e~E>Mil(HIR-AC1xo4bd?5(|L+hf(Gd$>ZLYn zZ@SI|O;88(0&{5eV}euehD9eMg|%QfG=-j%78t$I;~rBfArlJbZN4>mzNh=C8L?;D{REej8;0ZS{0+r2tql<=6s;E{)V&WFB_My;X6x;s>hh~<<8EQtG+l%6 zYHMcU>!Ww9@YtZZJZ3;Q7mqS%;io(xofG0zv0P?R`=pa}dSPCisqe*#M;-K2 z^{;GS8=@;BDEp?0*7m{uOPf4LbQOPob2B1cqWIORQn64kTuQk`2*~s|Z9-Xgq= z9dDeEc`5TU`CFnT*UQqbp5gv+Ga_ZU)1Ti)<`!4rhi8aS;RfVM;AD7x5(&*Ny7-wN{s$ltwp{F zALvy0#2HYblQWI@Kqh6L&m`uvi?iuROPQi+pNsPFbAnH~=Cs6?{@Ogc3m9FDvq=YG zg{o;!NJscxx6kDruv=rxMEF6E#^xT}TV#x|%U+$4y^JVya;6cxoC~qbFR^lc8e8C= zA(JWHXoNY+BhG8g;`-7WUx&1%N%iJxMW z13^C1#5O&~xe$xJ49-Ltr(tqWbFA!rN_o`q-cV&0YI>|u>p7%z@`n_KP|h^8o*{F~ qPHMxPPrV|`1Wo&7RBRpLY|71BA!~Xrqu55lhSv2LR_~rpvHt)*d>5_& literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nss3.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nss3.dll new file mode 100644 index 0000000000000000000000000000000000000000..67423e79cd178593c22fa7a6e260cc12558c6de4 GIT binary patch literal 1052160 zcmeFad3;pW89zKBi3G?nVHpidWYD2RS&WTnLWs`51n!gxMiD_pK(Q9BRfHLhvItJ1 zjEAXcwRLNyR=e4%wH6I74FpLL0*DJBF3`H17*W)Ufa3jqzt6doOa|<)@B4ZGeEE>M z_nh;b=WNe*p0nKQi&wa^T`pG+{%qUjdJa$i3&`((|ItY9J!o}r*E2m@2S1k;X&rpQ zoU7*h=FYqBC-W}*nQ!)G*Is*F)OY!hee+`1`mVax7dm&c?`PLt@#B$hcTc~A`lE9` zT>QHk%SNRB>hAk;#BULPF~4ZUBl665!Y7RQqrfFb+&z=&y+&k7`tc6jK<7C?p66dR zdk%4?T2NEva$RxTF|K%Y)1*|~KG#XUUfp`QTrcIjToLwy%k@+<-V5Y)NfsY`@8)vl z@(2G?Pge~R&}oIY7a%2o6q70SI5KQveDC*m1uu8GHvO}=YdH~?6u265@m%6@O@ERR z&c8r`YYFf#*_rPen2P&fo?G)>HE7cJ{TmtmacvZdSuZ;6WZOCTY5#mK*Q}BAuDC3E znag$A4QMxTx@z%Ui)Y%u0LWyd0dtj{ii8>u2m;U1c&7aexLl1R=Ndq1BiibE3INs- zaDkEY=FgjrBTJFLF>;t5OTF4>UpvJw+)&#K%- zcwIK3due0+uIQNh#@Ml?jesKX7f*Pe%{?Ea@ zQR?1k<&nAGM*5MZKH}s;wH`JAsCImzzs41va3qfVj*4Tvg9Du~&b)R;#URynkb1{9CR1{Q`TXz^=E{cH28P4fgC#*xy#yzb~-I1GZYN z6WC+ZVEcB!dg`vXZQH^ivL3IXY94|OWs)zPhAl35f$>+RM$5~2O(38 zUC7!zla}MDv>YBM$Fx+AlT$fvP0O)3Eyp|GnKEXja=g0UDWfJWM->7QB8je0(xiQGq+pxnQ3(vPvdC8#{`{Za5$-i(AqZk<3)_s>H0Ye2@RDGGI8 z>g4KUdk;aQS5m%c0A8&Mxagnj+0mAoE=w=LS2X_h)9k&)zOc6)Y6ePF4|hoB2hJ_B!W z2xf0ehEDGmnSCIvw&=NkVkeNHJaz9&L)o_3?}pWz!b~l?=CAp#B?~L;)1t?$@g z2G_X918ZdVegIj+UbV8fUwNfxP@Oc_vntE7*DMS5wCfsUUsTn%x(&+H}o0= zE#+NT?r|k^N+YuyBg584vS02jznf*R4K526umYc3LYxT&(|MysYKdA2qcJ#id zq2F%X*7XRrHNvn0mCu4G4XNe+Y4WV|*Wjt{@mqW>_XqF*Q5FNR%)I*ac?ZxFh^!Uj zxd~`2K<-9uf=`|F^ibWW5DiQ?{7Cw`133voyWN0%dK^J0KbU^ClfJJbeKXP{4s}MH z)B_!V4n-%Z>?SDv~8CpE7lH7a>Yb)LE}fRXhgl*xOcr0$l~*PYbD zj?^;2Y|35br20BikC#-#Q5>513;sDsL%Ede!z`xEiS#5|NjvN3CA?7-CYWK^dUI7X1^6G{a(IrXZ%8BubfKNnk$%n{@?Y zq56=qRgaVu1i@>E%MEIKW+4fFi=0xtD<0$(Z zV|now8|+mKz0_iR%T40lO#FJs35{Rxuv;XRDoNyfyz)^bx?j> zwZ%4c;`c#B&Ig3;ZG8?2&AFE|JN~80ZO)yBn4XAf&OP5rqiuPFI@m;0*mogn;ZwQ8 z0a?121W=~FQitms7f+6KTyEog78Z&bM- zkM+2Mo~r-Y%~rgrpyI&7tr3O1j(T=)L2_cm%kuj?e)Wvsq58`G2fS0}m05`qkMkY+ z6Z&!AvuyQyR6*piuG(z6m<^(jXDg>8-r-$s5SVt5~E(?1C1Hjp}#COAaQ-3{xQH| z8^CCY?aeS=6#A~yf_3!&C?JA`1mWf?Oi75_5_ITBmJ}}9`{BBY1Yn0BCTCyPp6v>`^g7!k19L_@X}qj zcR0Yyi++hv)PE)ZrSv60?nk7QS12&^5R5@E+OdN2BBn)$C5rCCvwa4Dm*WNEs-6#Y zT!B@wB?=SlRZI0iIJOTUry$MtHvJ>j>OsFXtris*``vShsurkBQyrz4nmphculx!yu9(}3SAHgM*`+hm7 z2YUvET*#0;E}8$RWjBSAS6Ev;FZHs$yPqaN?ENJbBR%!M1XFunng}bX$@Z?76!v(k zzmY$gzY2-TsFV8cHh>PVDVWR-rv&CwD)E$eYh6140AOD(iwmUQz z3{YrFS`nDZdg^G-#Luqr#1jB($fbyRny^rlXpe^sdc1ysG0oip0S*3svIx-Hf6+7m6s;WDC#T2xoS`8lM+YlZqp1JY>*? zg_fFB00SmqsqrPw>}@;@YFH+S3Gk&DFHkKZzfbS|jFZ;gRML)(y5}L-sHe*8_lCld zTAb7Fji@1eE2!f}eTqj&RemOqzZhfn88KFAF42y((8;tnK~U(_dmACt9s36Ww0Ru^ z6`>l2V9w%|Hf{()V=iRI9K_9{i9{1GMC*(C7SGIlNq@B zYXg2P1Bd;&Xkv@b9hl>)V&*@iHXx1qNAN8Fi&*oX`g;-3C%q;Lv!1qJRkA7v40Rff z8MV>&_J&6dU49I#f}Hk?k>W;5@HzTrCH+&(0Xx!1BmD!|HNoddRFb~AGrfEJ@koDB z(mV1$A?eT-n1uJ@tP#`hyT3sFe|A1}_Z+D8NV2G$Q`MxI*#{f4fja`>U0k{ilPk5x z^wr@%b_aQ*UkW+3Pr55nj_sWa^yCiDk}_AcX9N1rrGN1Z>*jt4^F-S_@<{^NvHa%T zCPWaReXymvHwW?t{;6Mo_^_TqG+8E*g=m;^k4o6Rh}qpU`Rm<@P6EasN#K11;DFNK z+IE^Y+O#P!c?x75O;J%PkPeh?8yJ@X!p^;ezuti?)s79-ulE)?^5CN4NM>e#I zRMc!{B*Y3{sTF>?#y_VS{33B7s0@`m78y8r&>^{J^F8T35el7A5CfbR;|J`20hk0o z#gU}@VHhG2wH8#u7@z)npCS1Hr~$aRem&6Z-S-&|$zdHoILUCx*G#b-hWeO+U4spW z{JRj=<%wGj51fjWP;vr!U>M308t(ac8ja6DN)M!@@xaIM-E{E4*+}1mR;2O3E1l`x z+fPJ#gQR!xz@H`EQ}+Z1p?;UA?lHVXlFR)q@~rbWG9l@Ggq_2dKjRmbiOwbjwHYDQ zS9-@@kd1oCWB^Ce3$Y0*E9HfFO<%YdY<2n;@j^i5N`5GX!Ei-*0sL?p@OFI)fa!U- z{#Pv6DHUijRokeiBT_d{0=l)Z(ZQv^IFmzICuIG7TsrkJ;nLVODC@yz$f5tBn~5A6 zC@W5J=;vr2sPWJ!(&2LSJ_2rFx80v1syTN6-Z4%{oM{rb3gp!iF#OPkpOpJa0SFrC zwG6l)m8fG))SVJIB@ICrW+NkiAOEgE)+6}$;m?JCEkSF>_elOd9;u!D`zWZOe8gD9 z3IA5|MfmrdGaUZyi74UU1VHsbh=@%7Z2_pA`wD-((@9n2-+reVmi-&q;ljx#@F)ZK zpJDj-R|u%wCS?2X{0lyw1?D90-Ui?l@7~Jyr1x@K2LFY3{|#dzop&ohtdt&Ic-Mb# z8tCyAQO1*C@16~W zws$Lf54?LG1MX7%Hs@Z7U&Fh!HSIDe_;ybN9>sC77LzS)$elJ@>5h z2QW1p6Oh2m{v6C$#^gw#8S@u^w=vxSv_4*WJu2slaz!c#y9M-BPZ6DTkCaNU5bBB2 z>(n-w>B^mp1PX<%DAe}e34nOza3YDFfr;!7zVG8{bB2!m@W491*m0+%sxONo&T7a#!ZG1deAdd>%< zy+aD~zt@BC;yphR^ATA38Z|{vEn_#~AKcw)eMGhTePevmA&q{xnL>^=P3wC%pvL5R z?pa&9L9K@xucaxz1Cg|$=Z0um`?JPmsoc|1UC%vh;Pp(29S>qsVy741sSar_By;~w z_dnhP{Etv+R_i>C9r>efn!MTZ0;JA$Zxi2&IdwhB1{M)C^Q-C3iV0YjL)&41$G>f9gTtQT{c%yBUQ z#R236dxq8Lp4A`asphcK5%sSs^)8k|s??iRYI7AxR=w-FyUD*~%#y@Iva+a}!OKnb z`MfzM5JDuYAdzdaB&{}&@r4ri2>nas8h_rHybxAgmH-SUFDLZyt=`k9nj>&ugB<7j zbFdB!dC?3e@OJ|X%z?a6>p|;*B_Cyl)$1hrz!Dp;t;mQh(7DdE6@eO>Su24xMf)Go zh(f~AY5&$wF?CKpBt~O>W5g4BMly%hCBCrwX>nN1FA1v!Wnr~Gtp05lztF4yi@fBd zwyV5k4FCPVm6yTcDS3Ihk(X1zxS+)EhLIX(!C?qnQRL-VBQM`TLZ`f(NsnUXw}>TA1N;v1H#T-!e4J+mP&cKVTcitcTz;=|HuSxW#HUl zMqbALi@a3h|G$=(MoRWVB|9Z&S9$r~sh#q27vEFz64XQ|gdrLPQXYu1bPt61Cde}c z6W;^{2LnF6=-)>Xs8^~qf%;Q#nn2zBVVXd_tiKVcSM~b82-Ib3j}WN$%Azm?Y82k9 zE&_EvQqlzK1?lM&s1qf(J z`|lH|v+wH^sDFT!Vtd!Xg_9{z5C0B53;PBLZSQ@*q1JE@V8H!NF$L-nypy+V?@vwQ z+laQkHz42$)Qu8xsY!j80e7QB{m?``E`cfp{wIOzI4k0nPaq!^JhdMGMSF@5_CCDQ z_xjBH!l0K5_J5jA>(yz2(NS?a(kw@A+TP~@6R(^`tg#=$ra52Uic5FJD?NM_4m}ZX z!lAzgv@U@VP&>f+uxOrVF97M=L(#(Aclqm`%VKwdLx-MZn6e%~`s(o}Kmn}(I@ECJ zPZ3bL+mS8JX2I(cU?t|1z{Yc~6Q*Ytrki^y*77o37`FgVL~V!|FBBaaF~o4y155%Z z1{U%819K!oCq@KZgdd+i2Oe3@ecl0P%=qh<XnE7ryq#T$Eu)dp+!R%^|_a&&jpEuy#|AT|m0_e-s=MXiLb zJDOI%q4r)R=SuRqNN&jDGQi{YnSfRGyK3(a&u(fzDW3bTAB)c+<=urRe4RV+2+v*{ zwAY3b-e$%r_cMHCH--}f*Mt)b*W}sWFYYH9pkNHU^r{RRSJeuf@xl%h_i)LM@p>NM z;C}?oc%3hA9IqaD!+Ji_&3M^$PFG#ujBu}v@Q{q~2l1}>_GE;= z$q0X*5&kG6{7y#rwT$qFjPO4*!vDw!Kb{f(ZASQ48R29`INmjkwOAMR6lkFgjPeO>l_iiwNPwxr{YH2z#>-p*J==g&S~{BTD2-i)xy2rtbD-rM@X(BKQAW65Mz}{t*k0OoJif{Zw`YX+WQ4b8gj+MhO&Q^a zjPR2g;m0z<4`zh#$_U?{5nhxLo}UrEs%x11)4?^9ktSTzDUjN#y27_rWQ0%82oKE& z7iEO|WrTZVgzY66w& z=PWX6Io@Sc8eDJ*7*U=6m}KtGj4DY zPss?Mo)Iq32nRF5;f(M_UBa+Y%zj}NEKrAFw8CIJ7H0P!043&ym^5v@7v{T?`2p?1 z6K7WW68b;CNpwMOTR^{mRt zi|_FSmyP?5?>+EhBS*9VD}3F9>$69P?Iwih$@ZNRM8GIoYYZ#+&v24q=_f6)?6J)< zG3|hrn6uAH%+*$+c6TH(Yeyt8XKN%ew!qyUoL@dqjQFxk@Vwvlbj; zyMc;Nji)+<&H8Zi;uVjrOi>@h^@gT;>OMm7$`zI>3CEkUw0NSdfzokJZ$*54o?iN^ z99O(?Py9g0bNhpgPkP^d9<$E-Jge%utq24C@>}QNVP(H!@2TcyhnPT3EY#~)Vrt~< z_5Bw-M%lFmZPS>D&9|(e%Tpgt!9D<33w~;;I4hQPG7Oar3;o4_J|P8tjX={cLePsG z&~Jf~+q-=L6=z8jl?XbZJ^>x#fWGR0mH_l+z7zCV2ed>$KZiSsHU7PTz93x*=wGFv z^~0vd>|)9AtjW+`YsC-uUo=lpHVIJZlYl@hHxPE642EUD+#U(XzwN(hyukhnus=%F zy}z3!uw7gLKn(!SK?~dK+KZ~OR$M61R{=VL?d$|R$pAXTS0BV46i^0}>QBNu7Nt4( z$vc+-v+jQrSpeikPd#%FM{aE9#n?qps!~-2VKoJm(4zN(DS~QIftCH86>rXIp78CM z%jcbq8W3zez%B&X7QG%|Rcb~-I2$LkI>3_SY-{$u`o`MRJ%a*3Km9)e0F#p}H91e; zg-juJNh*^S|1`_Nf75GRL^qv^BSfhjENObzOil*F&R7}m0$XxaSge?^E0a}D<<9a9 zVxORX5B+DiJUgrS>4NXA;#QVf{2VZ0pms$Eq*wCU&TO2MU?b>D!+i$M582ZF%EVdd zrf%t3>bhoexEJR~Mt8|D7F~C~bopdtp#4o|38`tRUUWKSeRo&;<;dByxjP4pgTknD zoyND1PrX#8Ud~9p3`@P7lzJJEdMQY~ba!4zFUPKCA8=dw>Kk!BB$X6_yMGx{xF_vC zc|Pi2i6>VQ{wPoEXTX!RP*%J> z>!x=0fWv$a7EGw^pO{#N7f1N@zh z_yYW0jlWg+bM;95%j%Y$lY30}yj1vqe|E7alDVh+GF_izcR>N228A74aaCJ`E01IQ zd9^Im=o4dXusK1om3^f}ZnV%J5YYLOx&xgN^YEy^7VSbz+e!dh$rY5waujDv^Ahe} zLh~W*%k)VY737Fn$zS9l4(prDnQvleBDMyx)ja06Mel$j0&Ezuvm{nvA3089OC!ng zKBSP^2>iGK9*F1?L>r>pqWiCQ+)-=MiBLnW+;vB- zmAGpOs@!S+s6IF=0=K%|cHZC|7xt%c_cDEB^&32Om8?X(+~uh&mFg^IUapA+&^?~I zK9XF9!qIR=e`|(f!DhM=mHldD}G&S@k zE(~6Y{$M_b2Rp>gL5jB9S*Gf>x= zEjScg^{Yq+#`6)AtSQhxAb4VYA)#={#fL4Tg{2#;gq3G0L1-mPI^L|jlv4&hThdv3 zr|NRn>Hc|Q&bDtSC_BhBOE%3eGHE6%%^1cjX)fj8qIJhTwF`LS?gmSl-bMv4rH3y% z)l#T3Pj0EXsQ3O@k?}GP0(Lpk<#_HK*Aa(97h(TKMD><#K)rC_P4Z87{7Y@OqZ zIJpeUP1h48pq%mPdY%?X2Rn|?3Tw&f*^l*l$wfsTLy6NJ@|%tmaI2TesDQ)JGy2a0 zNB)cTk;6FpH;BRJhAT(|$(lT2u+2PrWMLTedKo%T{b`as)h7oBH|x9ZF^>5{6OD1f zKyTKEUNSEFEJS0Z8CA{#6StE#P^hQwL%d+GvZwAfyoBRp{GedE%MC#xLmo1u?7apg z2zBZR(J(&^sfcRCaY16g5z&aPUxC=tU2x%+=li35!)l$_3-QK0cx~au{VEy6-cR`Z z=zq=DkIlt_tVER%;6>r`f&S=dWU&;Kfz){fu!dE2p_RxvC9D7!A5-j#o`#M0R&qEU z{;c?LoLtNq9)r~_jf*58;+xw~DBWcx3i;N@*`?hb3^*DEmNrI=Y#@Pl8KD$aLOwhN z+*a~DFhY+YHH@pR3KZr5SRyapq`Vkh1bJa4&MWBtE5Q5S_5=cOWQZtIh;by zbPTGTx<~m3!EkDA^1KKlGlxQIC{JgBc>_F;%lTM`QyNJ-OE;7@ay2H^2w9~G2w&hxIgQg2{#g1C zDATB&n4Bs=|IcDEbATF0eJwSyL|VOiCb~eEo{)noqwyuuq|Imn&x=AeU^lDNtSzXh zz~oyMf!zG-&5KXenNpb4C-T z0{rmweBng#Ba*{CS;`r8kCgL!Cc!?htw+}^;Sr2Q->CgOpg2RRc$w_mgE>$$N8C{XB8N$v0Es+1+M`+l)b}>w`IjX zs`zGpPL*dBcym(CxMWVRkeW0tl)W_=KiEyZr49k@!s1{uC@4d!F_awWBLDNea(qp< z>>Zv}K|A|EIIgo|?Nt>!=O2R< zD>)hapw6}QJtkr>B4#0CmX4c<0+9(U###L``ojr0{Lx{A(V74|V~Gu{qSyX3KP6kSAVS$fX~%+y7c% za`YdFBXu1F>5H5N=;lBn*a{fra6lEnvEaSc@U!$sP`N}r97=SnQh8P2n$baYZWK## zHF^3sX*E3yJI>ambwITWpvP1F(RNTKt;lmV3)z6Sv5B6loku%kmOdUlPdEJ=;TPNc z_+m6SehZqIVD#mqvi1y;-~h*@;rOa%)~Eo>iyccws8qO=Jpt|qVDCty9S z#JK?KLp_5u+D<^oSDe3_jFIYxdfg!i0OHtn!%!(Q_?@iS!oz zLs2O13IN#NBvb#N^iGaso55_#{q;e1LRyu^cU0+U^lK#9TFLZrDGpA044S79V|%-q z!0!-H@0Axlj;H4#oXz_J^L8u+pJ>tidPAQe`rS})tuZJVEtY0sX{4nq~>O2sjr7(P|m;N(o(B`0=>!Tu|A#nN}mIV4y%Q#g@ zMISHG?p+5m`sP$1?ij8v`r;{oqWwq@siMClfHmO7w}i?s$-Chuk?EKhqKXN@xS-JX zZkO4<)bR?rI>XfQm?P_${K--4c!NZ{&ys@g5@$ovXard1jrTa3!ClA#sguA2*8r%q z_OL(9eHveV&8km8V!W~d;4aT?C$lf0-Jz}Fc*EXUv;MB!8vtvmqC=9Uzcj)94+(Ua zfZ?Gttnvy-ql%(!NWz5-6-8_K(%VW@K8F`P8u(D|oAI!{uip%VV=|zAM<|R1m?rmE z0$7{Z{sSc3%7lC?;l4>?%a6)r3&3R1i0&bPvAwqdsih_ZoBIqz=)Yct!FQj|{Ayz7 z_+LpVy05y9zeKxt?I)&Dz*JuOHQqh9Q=YMFeGYlLpA(S201*w`<%*F^{^9OuGow5h zZl?4?(e4|8z|6&Qju%e6Fq|YpieQR|f6VZ539qgZc&%#@=~#GG@FJt?9faD9F%AQQxv-Sj zWm47@Q4@-xb&Kf)ntl*oPk0}rLpX#eWPVy9I1t};K8Lx%RCoy{2Aao}u@?FwG!S!> zdm5LG8v~JGQJbC&085|KnNmp&-n9y>d1st4v}6+4=^s$;r~bok>sHJCKmUQJW66Rs zF6Dj#u~>nK_7ADt-{ZaNs>T3L+efm;1=`&qwWcH7xMV@4i^6c66|TUB(n#Y~8wjb^ zgtMC>CMJ>?2i4~u4?HQ3egGwPax~`?1-!||7#g3$*5HDGI#><8c7mDBes{Suu$)gq zF7Q^CreHItHfW@~?Mt%fbbrA1o(bI8H%oQ%B|4rY2h)8T2kM8k&8Inu$I1b6j0zN= z`%lPkd$W-hz8H8Mru(NgA4BB4wqk@(+D5&OIXI3mYJ@aPdDvLFuaV5_;ZalT+lT5! zsA^(d8KwB$!ggEq9R_fm0R9?)#@-4T5=}KH)gxwnuu8O{c0~MO)-50+cb;UuSiE-b zZ@%d5N)(NfsB;ZAipnO_Rj*xUx=Nym)8XgTCY+!;puSK$gB4qEoEJZ6FZ>zX4~(|= z8~AscbLAas4Le(oNfbSdl!{Tm#_znmipu-(oS&<2Hm9tAfly-9QvO!nf?xfJbh!Hx zyyH9 ziOSu8PE@WX&O~LCd90I1?qhhg_c0To>t?b3xpy-~xqr$Bs!;Ww?fqwzDX0Q0#rV1s z?n-y`Rh2-&BbQ`FL99O8n*cOs`sGCy5~GEBu<5|j2UV~_ivpCL*o=Ea6^n9{Zr<6!z1^80v8 zB~sQV2VJouA90=TFRs|dq!rX5B(#I$mik1v>irYU|j!La}fCm@_oTl8Xt+b;{j zBWQdUy9M12qS;|#!cv7(@zppfPy7dJv*<->WPXTS$sZDYyDU%WUAmA5aCY4nv`7){s1>i4c|Rtz`d{rEcZ=O%;}%>9q+bP^nurVye}v;RNSKx9&qo z+!qKJa809Ht&KN!531MJ=xn-3^xrA&;_Ivw<2w9{UbK*(n^C*sr=O@3|8od+;0JCX z)|VX(qa)8U#tWqcFiJ*q=z*7FmRf)sqoXlI`p|R^75mmxcO4r_ztvVGRwaWudJLeE zQa=SLp=1CZ{3b6Xntwj?n^n!xg6rpOgvB0;B*($ZM8Eu;tuSsKnLYiS?O2^dxP(=} zaejz)G7J8ck!oC7B&k;5HTWFof>uI&)oNV8kU=6&N2_jT%bAJ3OJrcd#+Bz#%kNVF z_X)s6E4Aa@_`ghQ6mGY1HORh0vODFqAfU!gOO>}3LH)Ib2;0Q@z+giieH5e@7{(Z-?SBuZjDN zk(!z~l2qaUEJ!C=mX9g1!nVcMrwN`Z$e6oWW{|D=m)+S-n%qAUJ7}iDEe9fn z%v;TyJ1o^oGY0#`dl0Nu9nc^2gk#nAgbrBo1qC$1k`r;fPQN6mH|q5lv8t#GyQ$-j z7N{gTQ&M50c@gEXsyw>#7w&1nO@p!$m%3-LiWkLwfg9uWKTt?S9gF+d;Fhj<(^K~> z>RPS(+6=|^lYSpVjNJ%!N_ow%l00mvr;enKjRH71RPk=~a(GthZ(Ci6Sn^*Ln_w>M!b4DyoSOp-5`+%Shu08 z15z3eTo&rzG9HnA#Rq6;E#*`cZoCZushXe{L26>}lTF}qbpM@PBP_X-C zN6?;VZ?nlPTM)F@u$lpVuCR+pfFD{a59jFMbL2TWVAAs__2|D!1dAc~=wB@6{9W|| zV;sJa6=}~#H<1AXY4bxzA(j{k)LB2rsmKap5NQkzG^+eM!9@%hAo9Dk4D*%fKvU^S zM+IOLO7wE6r8HqAnh=sE@M6d~ZVLI{>Yv@U`VdQ93-9D$OMxd6H63d@I8|66Oe_ca zCYw7$L7p`Nh;u9@q#lSREJ|WoVh`6PPckb&e?xEUZ@W?C7&VCN*Lf!q`8Fsw9tG7q zOAo~n#JU!g0`(dWE*$7`e;C)#nwFLkD)xni0?Y8`N{-92W@EeBo^0KF3JD(-5uw2Q zY2ZCz8Tuil1S{UbWR%+*aE)Ez;_)0G%bMMuDlby8H>?gXI>ky(I}lQPSC9bWO?i42 zvEmxLio>1Rryn@5@I7bbfiFC}6*{9ir-c>5TI*$?H5x!A5WTB!LmXH8MD8}Hq&XxC zPw-%n*+!R3YH3vkFIC!CmH28Kw3>l`{G ze}Q|tvxZOUh6Uxus1K&H&y@NJPU;JF!+16^Z{8nH1=sGYvgr3kwJ@VBG7q%be8tL<=yT!HqY zxdFZFye^e`1VOoQ2{+5)l`WHH&1+zmp?P!J&{{Mq;G77qMk5Qcp6&Cj!Y0!}9G89^ zm+qP4hEY2%{*4USs5?;)j?<|1H=1!8b@&Ff$R}g6MPH19jrHTHn~UzPPF5F2=o{Ng z#rS7wl&5|yQs4^2oRfMr>xHzNtddqrw^pOSgKc%$l3YgFS{ z{q4D_;jJXiH6hquO6yQ>LvA=N0oBjZg6KzcYhQq7A^nwG^d>Q#qVLFLTdzlUw#q~e0CS_U&73$wI8 z$M~W-V|v62>R_N=kLWwb?2O_~yC&4m3Z#90w_b(KEAK^tsh3 zLXM8Xz2Kd-EkkW_Avov`{wu zyZGadZo_avkz+qUTZ3DpQN9>PG~WW~H_SR5JFaxEzC#RG*um)4`rS;#8Sj!IuzfvswDV{r%n2-mL3d@`u89tS#u@>UmYf1r5%F6Xxh?Ql!iyEe zCU4%54(AEtK|Q~pPc~Uk+4q|$skNybkp;|gN?Sw zcWxL*9>x1dVSLSg4HhZ* zBQy+0P2Zqcv%PPN*Q&N>v>p}mH$DTqMiR;RAF z#K%8@Q;=T|;GL_<%5KuXIMneTz6y}6Y@f$5_zc}yr9QH3c+NQt^6?XXW57g|B`t8% z6{r_ekn69=6;k_X+Ltzd@k9vM89j$l=kqC&M@P;;+I_>prRxlDZ481JAYr!ZqA>f@ zaBUHc#Gt~S`LCS)@(wG`-cF}pHavH&p<&Hd_G`R92;KA#@lDnCj`q(!u+%2zg{|#* zT+X`=b|#)b{|TPF%xDWFdp2r343rH@KDQ&F5_c74@C^(l|X%fHMsO!mk)|1$r}hmAeWN16JeF0oZnr~7J>eL4wQH? zww$N#UFZ<8ibBiEaIRSr_ldMxgA{&91ER${#pKr2;C1rcV@QK0NY?m75sYOvO1LEB zla(g{yn!xBApP?9p86XQ9hnWLt6FyU#AI}ci_^7^{Zp$)15)rDq63C_ssvAM)_Rv~ z$vHkx{U|A~88z88m(>T8(%P z$qPogtcow@EyW%3o;tZvKj|$83SKAwQwPP1QZuldY6=cpKWt65hT~!Os}T$lHf?6V zX?xE_HRMFa*Y_{|mkm<#L1&_`D>95oL{%wNU>d zR2}un4OV=*D7@6p^0{1#f=inng0yCD*LRI)iw!N_g>2UBH>y;tLxkDT2b=WqkcVL2 z9@)B*85jK(7iW#7IDvrPsD}eV!;MgJa*gWv>xgc%UIr3pFY%i!(xFMXaMS^uLSo(8 zS|xh9eoJO@!<9RZ--PzTP zeYbOw<0dI*LY`GVtt>i#mb^aeKRi#st$!C$w$|g;FjUE1g55xvd&~aVe4#_bSTszr zw%F%&j51si=a^;J17q0>ud&}I;EH3%T@GUvT(?>KW$_fka({FZEzY@M4VVLovi6AW z9R$w~5H`NXoee|Q;9-0FA&z3`FINV!fjlerXc%S=T#6g3=~CRRv$?LI_O<`D!?wDN z7id9@qxt9xo+5y0${qs$nX^M=@Cpt9rc43u9)JY_191twcjn^<#Tj3d;rui;HRShX zV9&7UYmygEhr!CUVm-Q@w;#oDcM*0E>xaaxL&lGS`lo@E#brE@Q^zaOLzO%g7_Bl6 z(55^Ji1!;-koukrvKGQLoX~-Ka`kT*m$DrP1GU+a0$YHarC$Q~x!O0TPxoX#jj0tp z9kOX-=_e~?uyP0PcC1I^2Baqu^@Z&iLRn-OXOXdVzr`z*WqFZXZ^VT!%ZuQrlKw=N zz(HB4r{tuZ_{*3|y}M>FcH1vQ0@{pr;tF6+G{<0h6*=agYn-xg1&ral+;|~jcAXE3 zBHgosAo>zqa)!&z{wu8QSlW>=gH<2m+#~*=fIk3SQmL2})bZ|jHXw2D807N=BEH_4G!dFVcuZoHV4_tc-mR5q9OjUyW)Ba-ER ztSP8mZq1H2cVF{awmvRZ(>p{l9Z}P(5S>=joV1!wlN=p2-C{1|KGvz}y-ZEjbmuv& zX~1*udbPfdr$E8FC3q?K0a$yg*--vyZCF(+%PXuHjCX|tQ zOUzJA2$<;_DUNiiCgovKo6a;4V==nWh1G3YrvL@l=vj?072zC&o8{iK!D>ChR``C% zugP5(BZBPz33j5uWQPEN?8c?nyfAqQ5P_p+(Q|T?`upIS3MXsOj014g%)*pvCy;TB zHX~#Fmf~)n+t(2VkN<4cFGwQp%raZWO7!Cn^h&}cu}6&C!+z;Ra$`(#PF9;EuJu^N zht!TB&MijE@Y^kVQjl&sPs1^6#xE*m-ratYmHd07;G0;>%c}prLjtmN-QFAFeJ1=z zJ|J_4vNn3KsTyXis0CzbAB0t_EES+Rp;pz#X%UxS(KTh9(g)BlzI2ZgM>?*-H0;n49+=@`Z~1^I7KYZO*|RuLZmBmw`1ssFo?Z+pflZ2;ml@ zIS**)UqkI={|~BX&i_N&A=}#@W@Pi2Y{xSjgv^k5g)8dALQo+Wg+|I%qS61pWxtDj z#{JY6I!m>I()}rC7u+%*>&w2U=!Yvz(WjP|a#IdUhHfZAujwaoHvpxdIWYj8Kx>kQ zB+PQM#avnjwfa*cP)Q2CklHOfBrNWZNE)HXZRJTL^sEAoeo$?SH+5gro~<|EO7dxp zRzg~c8L(4OiF!MQk{D{E28(1Hkwt%w9U35`x?iIlIUY-g$0o_p%Fk>p0WF5qr}|I0 z(w=a*Xc2z8UWgUnaI0QfLMGBE&{KB`5-qhPC8&KO9O^rzbbW`E?o#0*r^4l_3Kw@) zct~c215)8=K}Tf=3GjE8su#YYLO12o$~PjZp0gEd2e$ahrFcj8RHRBR@_qy=u~+d^^*dQ!Ee=P1W0#w^h^?&KP(K2uloT2?;!Y%^^Mp!^s=6T z7z*8c)_2tUDq`tk<4i>iza~-lZ&a2a8rg-XQGoB@Erq==z*1Q7C8u|BeX1Tv{J7lS z5>#QjX=kn$mZw|Ou9P`%0W^a{Sm?k zuGCv>#;hPtltqUJ;|H*i*07Xx=0UCK`xXsibknz^(xNPdvz?F~CAtEgirSvokk5SE z0R#nE4uR!)xKX}Q2Ni@EM-_>laQd^;_2?`$`mp+o>3kK{?H95PgLRP&=oae2Sy1tw zy5|wXE(cHD(|8Fc%1yVSr{=6@PeCuk-$u7W(tQJCu!Zm1O*Dr|ve9b*cn+d%?_Geg zy>W3sxQ8Q(n_#O7JrCp1%_78N;LgEftIvfEmC0&cO#G%^kD&=Ba&T=$w7VXFcH)$z z-9CVKl6&HnLxCeJhL~Vtj9*okC9rDbe(hzJH9|^3)j*c!`$uPR$ft8&3lAwRwXXXi z&G;byFC_m57Qx-OAyB%jyyzu7A;oO(8;I{z@@X0v^JjBlLe?DI)yM#XE!}T>A3&D! zQ4wNTzKz-kmG5gRRfI~#H`{GoLruh3pqKeT`T?1P+uln}J-%Bi6S9H5_}ymA8qvA)Q#LSjEg zY};X>1ovWz*(&}BOy^;e;n>VsJT_DLAami^OywPX!LgZ9OYwrot$Zl=I6Q3cuaT9< zW-6~CRDp%NVG_Bs1aPh#o2i`0gnS&E87r};^Vkf4XhfhyzG7$8jc_HL1*D%g5ve8h zaqp2pDFP8yl+WBM_b}qB>vu&wq4y$*qOTE>txC+COL$TyEPMzB_al;6xe*WB`<3|D z+&`CqHi4xGh%3bQzR4K4D(mI;9_7AL;GRQlSp7Or`gEhd_lFE78B9*a?ttC;dc>qu z)<@{kNMa7Uz-rSNz-El`5hJz7BS5r2<+gamF!0QBGf zWY_iji_kd-E$5sEEbQKtiZXowW-eLF$t}1swwJKJ6Jdtasj)#q8}%A_Zn2st6rfQq z{Wl3iIvSB^W*q@%Z~8$!c9)|}9N9awsi6?rWPYJ1?^x`QvEhhU7@_dD4`pj z2T-V&^omMqXfkr_c;lOx0f(s*Be$bJ!UiZ<$5&vH>haUqOI&QwE9F(o9SXl73`x$o z-8Sn1I2~d1Sq$#G&3Y$O{!75p;|Gyn@3+n=A$+VPXN?_Aljdd>9p-Nl!AoV*zg3 zq=O8b(P0#TTtj{mm`ne5j9d{j-1-_&GqIEq9c(4$7wUuSIRYr5Ih)+dR$D^SXidXI ztW@g=c806~BCVrlR8t-FPT}qJ$8P}c^w`WMJ$i?9L<}E$GhBw|kYaafpGoPQ@)nu7 z>kJlmRQ@a^NA|@YRdSL`KUs>qsz;;x&OzudoM4nFn4nml=R*hMYbmHfaT9llUCW=T z{0YQA?iM|T8^-!JEMi;t3{O?QxT#?wW45HnEMUxw=`lAm=JE6xS#P*MJw{e3ZcmHp z(D3XF5H{^mXIlwsJS(CuM+a47n}PGOh$_|JFQ3=`Mz!Ob=jfmytK7#Jcq4%rx2607 zqo=+M$Jgbx_YhZWBzZa9@|MM|q+`SIW%QQIp|OGTWx0TaWy7OtK6KA9!CKJjp6FP- z7n6p3I*D(3ftTxjzzw&|e6y){?=aE>rI)9UODb4s@6Y{j@U#W0u{j&Q;}FIWRC%&~ z9~2k$J&qh zM@|PEJw}7ePo$IK29U`9D88^Khc158#;JQW7lNk!I9}^@Jd`56mh~n9yP#WjkH;xQ z4`2-#DmYe-z1@q>u+%;Bkq*FGs{dPhih&2-6^-5IXSjP0WGXbS0&eA*ys2OKU` zbOm}=cKKlsJ5B>c;dZ&+tWZ$C(0bQd$Wl2U)a|L~jO%}fWy2j)Q#@F=Z zdXPhV!BLKTG~X;ZOhDo7{qTXyYK41oUL)GG@pUV8KzboNv0yqz;Y9r-fF;JwA{oH@ zv{~PQZz@oD)nZk07zADoC4N3r3jSpJDV6FruGja99p&q+anVmDhnr?%CYiG5aqjHA z;`r#S7%V?rU5BnH(chwEbY34beYy{5Wb$-Nf4vItm7G+?cykowAkJ6TQEtq4%91D& z1nI$mGPBpk@Z7-5lnCw=o zVom!S4RJPm;ZUcGIZa0mW}#28odisARC(yL)Y#(Ez3@K5eOHDhLM{iXn+q)^ESn46 z-aZjdVj;i;kn(aM|pzJfW|l zdtfTca_OXEeLp@C$6n{gRZv(pOxE?!(rPY53(H5mg7<~T!KQr`FA;?ewLtlXp5KIA z8n6!t?0?{=ieT5z67;`nf_06nQxn75yJ6A?tyPoi1Uf7(m5y*Ug!G5(wU?bXQ&L(2 zpE!zgHPL|-U59%t8Z|KSOwraJ#hq;Yuz3t!t|S47lqqasGj;TaUcF89>e35s(; zvgegq>S{=?y;wWJ09|M$r(l4VOGWk8A2?%l4skD&Ow~0&t$)N%^T-_ESFydmQ{m^V{j8IU7xPlF~RuRF6@|4?t)buwaej; zi&yr;yKCVf;udEqFi0hm?w&{i&FH7supaJR|6rz3$kbsrmJOpSa(3zulYkuspH3*I zAqJ{6`%=?)&*u^fM~kQ$Xt(*%dW?LUgmJz-g?$xW_p{=>BSZ$2G1i#GH_NqX(ao=N zqg>_*Nz#jtdl~YeRPdE5p_5t02NRa1?P{EbR~mx&0(Oty1q<5gZZYw1gE&XC-+ueOeHQ%9%Wze5t{z3>g#-jBpX z;9h|!?DN1ft8vckrn_lZbYd9$3*en84uiU&``*w)p*v)wR}Gc7u00urp|7a3;HDW7 zudD~AtQZz=Q<0_nX(G47%V1(SCopelOQBR{9!ld@ot3}>J%0*Jh#^==kl8hcg{OLk zq9E)iU2M$y?I%fSuBx|gx55dp6B)P2jLPE6Z@`>qX{x=~-Sfn?8_lc(+jfmv=o zTMI!zxnU_N-1Yn>w@=Rji^!>;@p+NNG)T7bdFC(}rn5X7zR$;&Y}709RLyN%v!_7b zN;IGms9~rzFtFG*f|5@E7AfV;(hVRj{l?p=>O?Cj5E~^iRTW1@(Ipz<)SDD$!~yck z4jTPB_N%~#rPimA$<^6(l|o4M!qIISJ6}4L{AQ3;@=d5aL+1M=0#~=Db&sQb@NiTQ zbdEatxRDMzT_@?11f zmLb$CNzA#SPP=J z_fEuuEUj>P%oiORcAULCp-_}2=ZZ8r741#2mims;RGfF=`13__|1OT_9>MdMXN?B8C0|KD+W!3A`g}EFN4}!*{(9{q?&i>}t=U!vgXq zqK!g5miWuo5Mv${g`2Z4oMrP&Y_pLl)Z~{6dm*Xmyq3=-(y%wi+V~6_1i`m zSo%kNMNbb0kKicr5S%}LmNSd;?y&(niD9*js1Ywshczs7xgP_uM0a5Cu(#98KRdmA z{Z_M-M=M~XUIaTAQbyj_Fd^w4&B7BMc6Ubm*wY2F6ckaf$dR7UBf~ae&EMG%9K!v7 zxb?n&UTD}_taI6o@FZXcj=O+^$pC~}$6Acp=*rH(ePD1}IU8TuCARlFar)r8e2T#C z?L~a_McY%3sxpiLFFqs(ziVMqWDVP4&RgJyLC>oE!eOtP!Z*Y|?aWk)%HS#=lh2W~zg2Noe?#ex||Hb`ykADd$RJd##{88{HUi$?}Tm&`5x*Ts_a0*A3 zQD*%{Ouz`72FzQ!4YF&){j#d>VgDE5OKGLMLDOGE!(Jf{$1i{;<{k697G&AqI3hApRT?%j{2B z-99eBU{-rjUsoffXV$H;!qm-EzY{g)0xi3M(B_|I+^e4$?R(d4k!WI^V&{Nhnyr^#1B% zp^z5#eSl7|m>P~oqU%83q6+hUHA#SOIBgf%xW0l!dUZeb`f%a@qz*H7bxCDF^nDsQz9eW9;FZij1Sm)ei4*|*V#agOrK zm0944zm32{?K+w_g>*GA)!nzS9a|ZMw(WdDE++)tS&FEX=@ZA%%qac#ZX@RYV&3gUuY}M}p8g&;NL>eHP132k?5)smVT|F&t^{$trNA>Y2HVb3524g0<}ZIld#YVSrzW3wv0 zj|hU4Z4p}y-4=p$LAM2ZX*>O5v1_c^RYLF0Q zU^1qW9A1oxIv7&zv;(}xs#)btwLW<1Od5DtNhP6ItcmvR{QiIo?$L@hvHjAA6b}Je z^wfVu?vw@2-GnKc&<{!i=?C|<&&I_NB?;_HPWFf2X|oLb%>WSh1Edpx&au=WtKz-r z4|%>29aDgV_(8b1kt4jc(O7Mp!^!@y>vxb5n_{AnkS8Dq<>$+W1~%(qNONe^S%zd& zL?)qa4!1h{Edm7Gi5sGd!IsIIsm?}g*lslQ^|Ce8K2c+G1lTdSPX*g$wLOiR50hMQ ztDe`N?dQfmfOOzL3jafQ<1{09{|i0i2h>||yJ8C)Sd5dMW)unWhjM8P(3t&ev!VqdDWpfL%rY#j3BSVi z)Y`F_R_EMKL1{WN*8(iXhO^LkQ(q4JHPoXU^(Te2 zUNDKk#CWrQ7a?|K{XZZiFuF-N1Ui=v=387oNI8m{;0k%M!wvN)a&k%zVX#sE3IQtr ze{R}@%C{8*S&G1dvO&7dn~LK8PCA;+DV(6%XD(*;KFH>2T_jIgz<8Kn;rKMAghzNf9mRy<$3p`CaK6rup!90YlUD?n@-}XeaMk*e*$p?6}DTLBXL-{ih4WGm*D_7?gNRGm&Lwna20S)`4@5M=`eDq zw#IRldvzfS<^Y{331()wpK%Z|6cvteIS$FVho4O~hk7IG$8`O9>SSRX=v$D9Ye-pt zVU4K{%w?XWG#nnnDPfS(+%Q73(BN5shUi98cs9-ivY=`Zd;eEappKw0OVtU=AU4mb zSuigep$<$Gij8?f<$q`ddCAs6PiPjfMu+aFMmD$$jiiXLQ@%KdRD2!x7d!xT#)gSr(lJy@BH6>y z)a5}N^$mCp?4tfU(p)lqS9e(cN zDajyB3&OJW2Vn^T-I=&Cd3gGK09L5%({I&2)DjIWvhnq@=0aQxP*}g~mfhIw*zVZU zL#0)FO{-e<#RyVQNxM1>cFZ`9R>Rp{{^QID2IvR?OPIp1ke3|rn;snwWDBAnvH|8i zZZNdH$H84mPvS~+bP$>it5U5nB5`w<{+63PfTKj%f@eeNAPA^hd@asXcfN!jueX|3 zSZ^=BigK|ZRU{n0pJD^BGmAk~KN{`d98X#lyKqD#c^lPvHJwge#+5_4`cEekq6Iyz zH$O&IvswSLUyjS(!i#(A?OT2WU)&00bF>CzIk|W8qtr2;`ad9rYUW8ixh7c>nO$2D z!53A2l+1q-aqy7ma~Q=QSrk@d{NajkqgSWwoBu=GyTHd;RR90Ew&{%xrKRN_AZU&)t=U?d~vYl|4Q?(Tn@LSiH*1Xx0Fvig7W2PQHLSi?vP*_aGI?Q-8QFUgNg^frFi ztfh!bOnEn5&M!5kzb7P22ZVgJHXzuse$rh;4mu*zZ%QKIRtWCra2JqJ3WB(dVA&gp zW{bkELP4L?H}+ICf{_sf@bnQh!Sost zk($|EW(t@_ljcVv0o-sAmAO43QobF!)rU*d2lzuKM~;Z}QS*A1e-~|^+qWpj$hz<^ zly8doPcnFdO;xu?tD0j2@)Nc(4oWt-511$ECce)_cJq3IdM`(t(BIErLY37ndm)u_Zy8Lze67>Ui?C!zULKFHA)a-(H7eMufAjROg>~p`#V0j8mp7t8ntQ+P zj3q+TDHxQfxH%EL03Ud*L-%I=qIMfNCBq)r62&@Z5A~vKvkHoLZk^wj`EbZhvCM~6 zso|Lqhuw5u=ED&;&*9&-%_yR7nZY*1ZNF{nrc-sJs763L#pP!LOMQNZ!lJ4Ci3%rz zxALFV%Ogfthuf=YD}SKX{R(Fc^1IpV)4Uo4`bWlpYT!(Sm52~*#7RQEmsDPjanulK zgm{Jt@pmX*aJYX}`uG-$zk&D!i@D%k*(F1Xwr-#$UNHuUVAB%<-{p{Y$*5 zWRws&bt`dmIo=rSIEpByR?dYCy3`b1!;ag1!0TT;P(<_MrlAJCQD z!(BwsKr0bw8A8*#PA*0Fo!@`Cj)uDFQG!2Lkl+hSV6X!?LP9_6Yh;muSTEUy(5-Q^*eXQ_Z!2!&t{ zE+8Q=<}RpRU?ZxtZ~pO<8HYDbTz-g(xh^VZw2HZNhhm`R8uy|3y4M~H_!DY{Vs(iL zaVWIV4oPa*`jS8GbU?%nit%i%{RLwu|MASW57UV#O#(%3BMY;MgA%7|-4KDZQ@Xee zh;%Y+ViUw6tt=Z4{sKj-_R(;la%nc7ip3%+iX~ zkl@o3-ptnpH&^*_zCYG76~U+TduBdhoRKs?GV?*1-l}k3*hj_nLGQsUrmXM|XX0CX zt88J|7@M{&-mxv#F&tJ%?C4mhnBwv=LiKKCVUPV3c-u8AXetdG@h56>7ZBP>BQ{{i)VC`0 zLHUA3lFTL{na4VRK%-cgvk4*rALfj6>XLLq77|vQcr1F&r@H5OD;_bLWNX}~aIBG^=sR#xn6}0(<*mT2gw_H+ z+$i(JLERkR5RcbfQ6d-M@(%O=Kjr%;Q#kKFQ?WVzzHX>4; zu^L+5rY`#54?X<1xiNwX%(oQ)11Q0ky8x2%tzGR?$2!g>%Ke2F%>ET&c^sDzl@}AZUEm&BXAFp>CEum$pxH#e> z-WrK%=T{VC?D8%PAX*__6UU+=^r#D8Gp2d!(Xd1WbZB4Slpc2_h5U;N%Uc-VS@HNK zmo&>NE2=A4ZzY{cgEih-wIG?NSDQx}vhNrLK z|A=d6Aam{ZslL9c!EFz2TM1$$bUoBghWuF%RqN-o51G7ml7$k%oB0NN>$>!v{N(WM zU-_e`H2pEmsWhSAJ;)%-bf8#&Z%zG=Knnhh@WsSCTg+hePmLKI?Uw&%L^$!*DCPZb zDG{uDWaklV(41>yWi)q*GzS07Ph^&yoj%e}wx^MlOtFp|L~>W`G~tO;>ok&}l)hm`U)0d*f|&m0uuyf-=>!Ye96WvkG2?kENRM!;sRx@gv#SD3Zt!OVky2CEM4nbH&Mc#xFwt*gRGB6ycc zYfHStrH&(Vbh>`|SPjYZRFPVoC3Wy8cLU*p$eIIVd5u#;+8yYWIs%RPAnv|L#N9zC zyuAe*^Hn8iSph{UibYS@~P%wymRHXMp|kcu;WLEq_}Tj;};ewzM=g0y$?a7b=wk73*Ff zxpiq-`W*_>D%i*TZRzOr=0eQWiaghhOs&d4%Gb>1@h6N=JxsX5zy3y_{OeDA?uwdw5=VP5 zbw@1=_TJi4n%bXki*@cv+T2zE@R7q5X*WklxJNK+DaG3$RL|>dUf1&KzRX<1gxv*2 z_zR{rW2@6?b~is7!=@CQJx!j%I2{*GxSRM`bR6b~hf=@Hi+ugrtv#d7)HL{9MeYnW z>2p=NllAKdPpsntYLCWGtm8}z`5_eRXi~@;S4lakgD6BTwZK?PA`t61n9}$f>)e|c z-y_DNAN{xW2u@F6pSjEUCk|z8p=rjcXhU4=D{6yzTAf{Jnx}a$mv|f7F?1huSLX|` zD-6Wvq!)3%?G$a|=eVpGX00oWQbSgE)OvS2rh<*ZkHwl$m!+jHJ2q684No10rYwElgLJPcorlIzI{Ot(;@y=Br9YQg z_@rL)r-s6!S1V(MxWP4CX`BO{CeYkYPfmCy%uVOD!kIb+D zR)a)dKTV4xw$QL1=dgk-J=`sbk#uJzZBCua7q{?kbnhPyPsKIXuu8YFHo-g^A_^AUG^N$FsCLm>%}MTSAtUsTK%MlKWS9E9pw=`gp=us`2L?%RrU|CZe0tZRFTTYv^Y=aD9C_2Q`2 zk|VwS1!ChDbJ}e5Q9ZmZW#(hQf3-&W3X}H{y}t1v zXQu>uXb}MU&z5UY?nzYNs{FJa;ElQ>{|SwXd@WOi4I!J~chPM)=cY?;9`0xKef*5B z&7frhD4Nl|HPqtY;$v}F&oGEPdXz@*OE>!GA%36Xc`bal@_Ph08Ok#?{8iZ2Cw@|w zeFo~GR?Gu&vt*}&bA4lPKr1 zb#Cd!swcf4#H=_~_53Bqe-86g?dACqcAx~IqMZcMiFr=KTv{)aH*E6H>FGqg#;vh& zn-j>8U$2^2cR*kMkaG*V4b7Y*{g51|L`$K@StaSKB(N-@Y-#D@{MySTdtnCD6-`Lr z-f&VAR~?gNjl055lf*h(p(Y6kSKP^r2r_C#y$6KUJB~BIGbQ55=+b7ySSJIVSub}O zKgEknTVJ9DJ53JVq}r>Sro)(<<)P(8&T`y78XDKa9a@H<17r1_){m{A9c%PjaJf}0q6BjoHWix}G=EJ(f z`HJ%;9B;u*ec^z~o06y#eQTRCk5^6WTzm6+Qy$T{jqcZf79Kbt-pkz_gpb-HNpL%( zEd5RC|5_BeH<8k{97;c9(By{ShtHUasT?K@{%Xdv76)6yiTS8gale9 z3zk-MjVxW_Z1$NmE9;P(=U{KR13p9l8SFjlybDOJ!F_`F-wIZ_FXIErCEZ5*+@E=Y z(c%$;c}z0+$|Bgjd({cen{wL3O9tOmoOE5s` z{+P_Rvf{57+SgTmW6#ppG0Cp6lVtGOHR=d{`o=a88`+tNJ&iZO*15F?0|r5x+-zR+ z*#G=l-`V`^VXLKExPmQ51|ML={G8$+%=-y||9e|BGZlW_HBpG)s!R_z^oc>)@p>#T z+5Cg6xo1F4iYFeQ@ z?$oL_7Y|Zcy8T&Of~?RUGlc<&KYOvN`0Pb8xEui9N;3rQ@P#sdp892-sJ4N#*+yy2 zkX21TE{u}IPmwp73e48(rfo z)^e5bq~Co=Qi8mG(GM|YGViB~^Lo(MJt$=6$ATJN zDW#=#{83Q!-~j}zUccyf$LvYHtgLK`Mym0i2t0l0MkGwcH!Dj}Isbb`5s(33<6i?) zW@tdPav@(JflYLD6~S|Ta1B9`%WQ&bS)8y4rp15mCMbew^1)>UMKDu+5IYbfnkhbb zA3+h$L?2vAP{eb@C=rkBo1mUVZ^I%_K@iTLh6?8UYqbe$B=sZ_NFp_axn_csF^^;E zcEMLYC84nGPL1)M*QVtPsWk8lKAlI_I!nC3m2Ej#L=G6jj9A2Dvz~qTh7PLSEvS=K+ z#uta~m<374*Yasz`r-PzU#o?~)?Eh)?oiwH5p7ir%BtEtD!w{xCk;c=^Hn}c0fj2z zSKXFxqr3OIVLR4#bJS> z=UoL#2?x#C8AZ6?J>+)_Ld@hZ9i03d$(xe2T%m&&d~^}N>@VUn`Wz^h?9i6UA6>*H{Y7|vv9v|v z3SO`o$I_jFkkUZlw@tE5qU%&#Jwqd*Xmh4I7}2JhMA!mtCTZknDUxr(gN_I}iv?g% zdB>f*!B045{whN0A|k#_1XA%LBo4_o83j%Dm1uJ#A$;}mO@hs}_U$b~HH5CzH!TYY zOR%}vzH*O?$u)Bc&CFh1Lr`+f9D>uboF?~jO&a@5)vuO$k>;87z68z>o7<}9&J5Nh zx=ueJ_oN`_m|Qo%Gj(EZ6(7CL@06Fcc#xHUtkc`~k2?Nlq%r#P0GTs#4^{Vr$1_5; zzA?r^))II7qeF$%LT#1;YYVfoTJPR{QKe#&sB$V@&1UgFzZDl*p6Ck#?;qW19iG-u z$cF-NJhYL`4y!W!ur9qn+{W8zeXA~vhh6w}Q2||OgM8sibyC48U*W*jc?QoWYDmZN zkTUzG!7ZG#c{fN$51(CN*M= zI_AM!cGWRkh7RhOzSUF0_S~X7g_>D_CY!iJIe$Lbetp4z$M&Zl-Vxh*{G}Q4Zld8J z^s@Y(VMM2}sfbFesc~|u_I&xdd^tT<@AJ~THG|)Fva!&Uy^I!$pVtf0as!f5?py)` zmcv}zqWkBnSu2d^?(`b1YL-v{BkzY_1^(b2uAEz%%$5=HEsJ2Y0D@8tB3%BJ7Q2hdQL2QwE8DJW%FIu4%G7eawMr?es=&|eW z+9lM_As!C!Tw22+9@NDBhj`Fp%m=T}e??CGo)Qjfni#i1QtHktkIbuFwj&@!t`I4{R9&gK4D6*rZGGGzpmG322X@c@#Y~g#mvh2{py^M zzGY_#WvinAb>`!UV-~>)v@4)Po6UZ&7{5yYEw3CV^fTEn3CQKBpUHlzP?np@ z{Y19JXA)w*>tBVKZ~IpvCWiVtROz((+3U?TMhywsGFl%)wsvgIjd;GlsPxT} zizNGnx~4A{L7zTd1I+|O$m5ez0)6^M&wAr(++ImWEzBMz)l)8AM$gieIA!tT*W`Nd z>zxw9cFUEp;QYRxSGL?oL-QlTK*%^b`8}w@4GVTvVa2X04A&bTHZIX^+1*uD__=tA zU|YDdou5dY68)VPx+Cl+9(wr9Z5nt?7H_M8E!_OMiJL#4@(QD4`8YFs=^7|X!}3T4 zgUy6AGV2KS3snaxgmeN=O4RUmZ^C$+2x)PQa%OK3J&PVkg^A;YMU<8Pb0k)M1Cviu zj~8W`BZ7KZ?oyE`76s`h#%H<-t~c%)4V+MJq|^49)|DLnpm@_jws+C*2eLh-$Q{H# z4fM035_D1VX5j?JfcIHk60LPJbibv#FYiPQ>`=! za{YC?S20K~&LvXQHku%TG}}I>+)|J2VY&SWKUdF|7;2=B=FL{{n!HT#1T4H-8(8<9 zKNu_%1lo>_3jQrGl3p;6^LAKdbgzGBV6JHOdH^~lfswS^*-D>ZWGx&B@r z=Ayr&(_1JTlqIpDAaj|bE~+S$Qx;%K1Z<35?oCZ{M+{al6-k_DO7!(@_ubNnL3b*> zr{tF1^*%p6ycq@~5mxt4hDB7mSD!`Y;u?AY3ijM=qdV8ap;MY4-XIH^Ikl~F z<6L|K`vwVcx=UVvss$z3>7o=jlTS& zyY_LY*GDorLLdTIaJcoW3t#rPNF}ek+BZo{ci-x_^K472u&708;e?p}HqJFHg>6iR zZ9Io5C2V5@-^q}4ZEFRg-R>hdu|;juYdqZEu9v=WwwzwfeO>$4t(dQ>J@d>7?H17^ z2fNQ_ar5mJYQi>P4J})sD2`CQ!m{J0#A2NEe3u!PPG$$+?RJO2R@yYq4Z@zEr!Om4 z^_SAAaUd^de_GJ3M$Xegn$rx2meokZB0s!R9ZRBZ&9O!xvTbK&p*CRFMskFq7hEDl z>%0()FSw%=ll_ZTImk!+}@gVclOwU?~rys;wG>IVMA8h;`KYH_X%IJBhfm z)RC|%ykqHN$VYmy*WrG#$4M2uz|=GO^s3mMkGsdlqxTKA<$g{)zTa8iyooa+GTats zz`zLP8x=n5-hQkf#q%u(bLW%~{HAT>Uxn2IYM5|FzTzqdJbiVcP|5h`Yjd-F{yXYw^VRb<0}VSyri!)>)~*hc71;fH~?` zZzYqAJ-B%|hq7W*|2=tT$u;NTuxUK$Qu|^cfdDx+wBMOrpBmn`0;f?GQ=Yhr1A^0F zo*bW)QGI=5V4SoL5wAwA7f?(S7}mM5bNk_v8*q-3OuoG2nz>Oe<9sdEiyPUx=&#^y zRnW*C@|?X&Rd9g1tiLwn$pfmAF~c9-&x=s-RjX?9%(`nnPf78xJ(E7FJq&!>L$`cX zbEX&7aYWRdI&O6fKFsY$II3*V;B-}nPp!eNqV&P7Qk}bM)br;V{&L-74Z&xs7{ciq z(J7p+$Nltk?7>;Dr|J?9S250Vx<T*b(i{M_jp4$0(r0MLGe03O8_HIU=Icr61R%=dVVt zbQk$hy@0KBXZes}tJ0lhA@rI0&2V$fzY293KCnELdrWDoaemwHuhDO0$Vt0vMnke0 z`r`%}lcsXg4|2p`>ddxwp1XL~@N_o^YfNW>B55Ml`7vW> zXbaVWKfWsZkn$H}=0+AiQ`sa}Q7zirWSq`#?E-?G565emVmmf7PMgsRQl3_PEM^ve ztUu4=8pR0vC!?H6m!xJSgHD(}+{{S|an?&wlyEgI zE>gQH9z%1yijmm3swCYb>5>NMutNvZSL816j2$33!v>^>-W!2La0-JU7(U{e92EzGBcX`b6X|QvQL&-VZ~2a3!A`Nb8V_Ftfi^CDR|nA(TO5* zv6*ZnxW>J6@o;cU;bEVyb(@Lt#66KuB#;ep1NypK^++_PV;w)^1MoCvYmzHoEq6b+PwRCbfMzVrLC!kxUg{$w;+x$N$t*0eF^3Q|AF^U9U9E-IxqbPa(CryH6B&HO1Ufl-f_X-(Oq)vVpYQ?a#A&%W9BcLH{$li% zwsmT^P5ouUn{L~~LdOaK}6}pk7&#l6vWR>9WoT+WS zu2FAM@XTPPd0FIMK5$BlReNJTz+EVfmb<|XZtFwB$z@tqvf`AWA&rC(ZP!@!EI&vi z|8`Q5KfhY@cM-msagFrI{nCR~LJ0mXzDwfJZn+9};cc=R9t;$UU+?y!8|Ei@4WYaYp-n1DrJB1=0`-+gVkT@N$a;52ly$FQ zgu3ZiosDev4Osu6u`V^TRZX0yHn(9~3!6iq*A#1%v&9yu3pDd_z5BQCv8p8g6#L%& zbLO9=X@v9}=9i>kPYrN(iR9`ZnN2p#*R)ZCs+!);vQDVK@AJnMn zvCgYBqXnnYfvf~nU#G8+E`~y8+1GRE)z!XNhZ2$d6#t%l^6`Pk-JeYKQXNN0qY+`g zsd8Uh6D2c$cDZZ%!)RGcau@c8k7csVozWkDOy8&Xhr1O%u0Om&;g1!<_}EK!jrxXc zn^$Zek}O|QfW$*2d2iu+D)i=0azd1j*;n%2D9Lw|x)NpJy{<mk1DfznfLh!_ zlhT>F$Xt_oFU7T)LqwMEVg(4Rux!|bhS_jc7QSJ*>E9yU=-1$}TNG0>Rp6)eFDhC$ za$3=M7Zt4r`%1bCZ)%T^6Z-sH0p8;3tUmWH+eomT=myi|U7&34YXy{9{xFx|bG<%& z1qSKWmiV}$#Eki&fv+=ceQ|}#pLuWSwR`%G`QUH9mVmntgec#reEx6fQu3qv>W}RaQBKgnIJO-PU0@fZvUesFr31P(Ni zf{M055m=1$wbV4@8lN{i7W+b??=-|NicXZAeQQRlo#$c3F-c9Z~{CO7qG~7@ye|kKNLv_ojNK z(5ktwd&-*Ft-s<;EN*zBeKP64Pml&Kui;k%Xtw*`*P>SH#&BZPt*yfRJTM;DR0L4< z+{P=#f#vg!r-VX-HA%L(7rozsXy^1Mx=isu~!F89=~ptTj*UAlA_i#Ddg}eoLyfDaU!X zl@BUy*rO#SC=&0mF`%Bi{l3y55tnoh~pxTCtY&nAWn=;+7^T*+4 zZ@W84PO;MvL)d0Dv4ne6O)QBQi6srmewk!LkxcSspM6MhQZjo=QfLBK+Io`ox9z2M&d4ftS2c$IrgGTRoU4#{l0kqLX-O{slOe1yJ9 zjX4pqp(Hg5vZ5ZlGwa-*%tPRXvs15U9?}`AlJpPNS}x(bYSjqbTaO?LU4q!t+dmN> zG&V0FSyUDg;F~}re8`n4`Mdp-(mzZ{9-DXQF zww>Nx)9pt095I}PenJUxvfL}C4SmJO>xbK!jOV~_eo?zf5#l@3#hS=#TXq|{sHBYMXk~N?6?IM9a-ycv*sY&bwOwO};;=4xmuRdFTNP+* z4nN)rb3+wLxGAg7=)EDXpJ+@x^~#8n+&x7R8~-FsNMqgGAR9FDwb=kUBdq;tOFX?M zRBNA$b&r60kZ6R7oT=}^0e9H{6qO}f9tZ>Xs$0qbp{-z({cTF6xp3EwZmf^I(3Fo1 z-f@Mp+>`#(NjeLQH$`Q_Ue5s5Q0Z-$#Qzfa>@TcXHlR<7doEA0kNU`%@{UV!L5CVH4F(F$1Y#ag5{Z$MP)Xd6VZ*83tASfBg3m1(yC_S5-DJM^ORg z;i$>w>BFKC6v_8?A7#j-fA#ZlImET@Ou)my6<2%ezFi`~58JkYvxX z;N&8nD|ucUQ(E#K&nVtc@=J`BN zC(j>vp6B5Ywq90VUQtn5Sy?h<2^bk;KKRsM6jC74XFeiEtcN@PW9elCSA3LK6nY4LK_S41> z3UU3k@xww~KW#i(h?9`!OA({vM;5d){Y-YYrpwPf!3~IU`Eec-lOMP z-rr=1zRNR$_pv;O7Cp+7;pyU0+8F)!NuCM3pBO$$KZEB~p0mUE3;4Z`=U$%Q^E_7c z{wLnI^Hfrfo+Efl3F|o^e4_I8t8(;wljjFKD)S#aZ}aR$-h+7(;Zwv8y*$C1<(lBs zs?6)9sWbHNxXkNislDVV{9I&>8aI?(3_pK^%sP|}2~#~!ZJ)#{cwTyXpUEMLpRWbL zCltT1ot{n~*8izqpJJ9}QhJXtetDh7`w>45`+%~MZ_L{MrbF5Ix@lZyTSaPgX4{bT z-hxEc=dNR?+%>{XS8Ogfczhx5opgZ0WG z32XtHp7Sh`BsCl)X6sSo_>(}@?t-PPWwSG?ZDBe#T0)-kY-ve$#(0uX&JW>6N#277 zOj0R6JA>bb8uHYzcbJ_~7p{bDxpH=ocY5*rAAvI42zZk>EtDr&W?T0IonOOzMX7`k zVp#w8U%eCF7y5n6YwNP`zR=J69KaE-j`{^nRDte#%V1LG$9(l)B*ueukbNVSq?JN` zA!9}r+f-&w1i2my3511IFz|Y*D)CIr5)a>q+8AKlJj_v0Jp(91KPBic4MN6j;=SC@c!VKSmQH=iCt2A|NpeIJ z^Ij+_b7NI$x+ypvrOZsW+Zxc9ZcHqz(ZnIa&K=fcYMYPur-)mMg9<5z`4qPA8QvZI zJ%A7a1EQ#?xS2(~Nw0CCEv~e0tGa?vS)@aV`NCMbpVL!l`fOK6bhxYwhuz=5?+3AW zxJ2p)Tfl>H7t}hg+%l+NVjX82^pk?=RT;;a_&4czNwvXlW1U(RM(dRttyeA}r>I;^>c=%cJA^9{2;3FH|kzxEc(yf@AMDuQXPUZ<|nXEmkhW*M5ITsNv z1{1w;(_!#yN(_Fz7UMm^4;h_U1j2$4gj;DkG;olrro6vz)P?{iw;Ow>`xV~9K6CnH zlg^Rye?*S_d7LOyX(XK1m8f=cU(9F1V!pDWzZk#3oNfzD_r(yD19#CZPl{)J&$HK! z?sndMtAzr3+ZwO_*Zd@%A&WM-Y)(l7*s9c;bwnSwE#RKFQ<0)`EDpLx9k*V9b$b&a zvD80V*HZ}Hi(LeT>|<3LuEWu4)ehe8u<>g&SkM=2{H}l%ofPhWCPpMG9jZazPgv+y z-Onw90XNNh(NND#1moRdKtVac?A25^KB=rBHr)-d@QQ)ah$t(nC~2O6>N=@~*U$Uc8eXd-psoB5p%ax4fvs~16*sV~ ze{uH!@c&#?EJdq2V(0L~LYm@~{|ict;BRr_GrNX={4U|2L`h5a6$d)Jp3Q52p-sg= z-}arI04>4|{{(hbzfj=y(~y#OwwttZ--xoh24!`P%TW}xFrm4tp#{|?ow>n{pl0F@ zAg+oy@PyAf2)cjn&pCr2iW|Hm^-=X7tNQDy-<0L`oNbFfMfXY1Vyd=@*FQBShBp_-o(1RboHF2PWNE$u!GRJ<=dblHC3Em)^& zpWV5V>P(uAMoe0){As2D_nE$L#}~-td1$>)#`>uw&yk`++4JlKz@V~SnNQ7}0I;c; z?U|^{Z}}F)_Odz{A;&gk`X_{Qd%Qet)0~@5%21Hlx8Nh-L`6a}qdjYwsM5qw5l%6r z#2|x_#1UaHt*U>ZPvfD<;H+w$vVbOz(FTkdWzj}Y1^{he=G)&zko1P9;YQC>cL|PD zAkLwlID2Op&Q041&z->lK;cQ1+GOspPn*?L`M$yKIw&RFA&)jtLdI;z{u?-RB>A?X zsyREpIeRv*&^+glst54x;`K%f)?{apQ^&9(V89)gIjOERVb&CGkB3W3PAE-}Bud@~ z4Ii1gbsrSo{nqZ_0~-bXaSa?)<9Nz@+P6|3CcKHc5vY4Pb##QoJttqfuiq<+ zFAq_8=G}u)*!9hR6lSmRW;6Ym3qF;c@?rYNA_qpL4fT_&)xWa+5?XUJ$!{EIXYgIO zGxz}B_pxohUGT`j&9^(3g`oc8I|WcR^}Z&LbYWNT3eN9-1e`x6f5;jAkM$R7L7m(T zUgGo^Z+QucO5-^e~ip8~2 zYE-!2yv{AVQ|M5Ks260p+)sbH@^x2*1SeIvvOgimvjo#%9Tu|fvwQklAZ(VqkUFqC zL4eUhM3i10V#mFT9rtJtEd~(L9vUhJ%tzPuwbWS_7UqzqyxW;G-Gy)5M+-PE{JjYr z{GEVhwRdvW99%pe19MIsWv{3DrYgI9_Zj3~T|=Tt?pflL ztzI~*)44IP#aR0_!&jaa?hJemur_!eDhj=IK47`R92yrhipIqZ8yDf2*y!$|plB8B z8P-QxsA37ie5+OVZe0HBqB;UemrFwTDpX( zvF!f=32C!Jf^c8;)cb4FKD3s9`H>IZsGrJ*#_*$c4~JyTKPd;JuwRN`JwZL$g7Lm+Za%ZAbh_ZfYL;O1#sZ1WUoGNuimNGN4$ zG3C}Rw1*cY!uMFwzeZ@```!G%d19&#Nn!6PPp9@=_`Y@lVx7JGPb@>Z4FPi7(=ri{ ze?xg}Zwp^vK^#^T@26s&cUf}noA^X%mF^KUX(X$NeX zef^RB=(J69wiPjJo}2J;bGB_WM=Uo@#uh>U6~C21s98MmEY)|=ghXcToU&RGFB-l}_)P}hS9)P@b|ROk+Q_gWR^#?G`jd#CYD{(|tK8ER z7dV2)VoG0j?NPx=$;6Z=uNk?#TpIEbe9a#M@iJwskV}Zy$)Cs`6*MFh*=Z%5(Xbn4 z|JDWl>5K-7CmjY$>M$5bAn&PdH=r)#a0{{j%0znCrd_4u<*mh6n5={a;$}Tw15ffL`cN*_|*6yP915+%9&9yuQ4RN zU5-gD&;*G$x;4~q3+>GIK5n5hOP42Z^P?y32af5b)yQ4WH}Qq-;|1eyx z@a2SEJHlON+rBrB55Jfd!B8O-i;Fd+$ZV@Ae5CM_-st1K_OZV3QRBGq(Js$fi*2G6 z8~g5xg)6%Go~y|g*{L~P;wS^!p`N5M>OE&wKbn{c(62X`I9sjK032U=e zxgSTN-Vy!loZ!g^bdm^qqGdZ^h!;&Fmj@|L(BiWJrt$=_eB5QYU%%zLMkeUsHT#| z>uJLsJjHE_+8eg5e5ck`m_qS4q!e4Rm%zbQJo9)gPe}=bs{FtGX&?W;rTIVjUWTE- z|LZ@xrhk3LUf%$vK~}PmU!ozcW|k4^U!`UAQGcv&CEs$&YSHu1xRz~V9b)aJi!_jm zmu-bPv1t8f)u@Dzs3aKSj^C(toI%0J+{seTAkswkS_o|Mf=>GF=D?~dTGE|xs~;DB zYjvSoIAB#*0N404`n82`JY{XGTzN=gW!FtiX1V5n8v8!F-gFGDBMe`T5ppUs=_^(n z5v8pOnvj`rzh2wU_rkKS8C)h<7n!q%a+IGED#ym1K3W!#*HN~{KB+3Z!yn9IF z=ka~N6!MMRYP*$@b<-WN5_zK9qVU3%LI>I=V3fXA|NLTJ#kZZ7woj9%`*$1B#NXC6b z*^@s~g3dvmk_>YHOSQ|5oEaLec3q0wgHK)^80*j{UE#BcU%N&ucIS%5?2>MR+4}4v z5e0Hab9SjP<7UupQaQ+NPy!WctV7Y#mF}MDt4NLXwsJr1K$<|Uwchpq*(Qxc&=j*& zT+*2PWWd@fhZ{g1NXn(Xz&D zRAM$%*a3q2w1BOlUaU)P6Kh}=_yZy! zJE|YxaPGEgyV!xxKzM8?0E~1PVNMI4j@)g|WIs*&QD~r8Ku!xDZ;~1624wYq^sF#_ zhS&N_#0)T+g$*?pc+o|;2|*UusvLgh4*Zibqd3fH<^XOpOD$gI-u|8GJU`BD@kgM| z@}oOFo_%h%T28Chs6HP)0~e^!h4P+Uez;JB?Ej9UtC%4Q6y0eB6wb2PT2*TbyG`8m zdqw@N?zZ0kJv_vEdk1=aI}xlva~hK5HudL3BT6Gi&32P6|%DR`zy16D(ClDQ%gA)*^u)0Y#ImGIsDZm254`DH{Qk$UZtn`y*G z{8@(cY(c~3w`q=LR>TCoknN*nj(%48>nDo{>u_q2%4iO=8eB3dz9TDwf&R4M2Ym74 zFB~fUlW)Bc98y7>HI>Di=q_2{GCS#Sl&_mOq2@&faYguwXh2=v2o)Nm6W;FQ{xWcO zTvR`HBH}z$G>MAi8tL_7gdqft;*skOjOig6wyI@J0w{RGAu|Xban!=0Yj4DDC$C_A z>(GG(ue3ZK@*lvP!AYA8b6UL*EZpTtE!X1#Z}4R`l{g6>fnjPHgvAN32Pk5 zs&ikQ@Jx6}e6^TJ*T}=nkl>H*14f9+vqE;kDL_X1ZJlectByS|6c3mlMOUz)K zJKKudQW!A9S)+k%P2BU{96stQEhvMwZ*a#G)~MPHZn@$L6>3{^aDizSYlQbYL%vas z{vpD#4}hLp)2NOVXlkkxDOC~R*NkISRh&Rlk;&k#U^{A_JycZU?BY%(zhRvLeTb(${B?{4Z_BbjEtoCY$6BG(pwO`L;zNy@c0q>`;= z?WrM)h9tYbSZYUB*Sl)Q`C-Tnv!<2lQ=RZ$vWTHTc#kFbz!xQ}NU58oQr@I1w{$t}HJ?NW!vI=0dB zuI3}a`@^+MgavwRKHk`c@;2A1lHHhV4YoVU|j?jTkJ^4U%`-s zM;UE5f}mt`a3Lc?y|JD$>l25qXHXny`Ugm`w-6U7e@(#Gxr>lAn1}lJuCK0R*TPa9 zLkd6kWc!PCZvbpX8I&I7Vqyws)|Qs0hgllI@3a4Fet&k$^`LahxgqdVU&zz1=iY;1 z6-o^GX=KFe&szsCp`JdW4zA&{`|->r7jRWWu80##xiU;s>s3C+&VW6D5451 z`-JY^25Frjwi}QE%d@icMXHS!`4QjhU*FS9`)97hISX8;soFe|G|h9bP>(A38vuCF zqMc%oqCx!H3$5;qiv;dA@FE@-@yxJcZGwu$ub8-dWp324^hj8sdzhSv+9&tMWgW=< ziT{#%&I~Z;*)A{_5@s7(gXxgy?M|4+I43y0$~}7-1!2{axe0$ClGZEyiL!>-g?0}D z#2R4hPcx&+TweoNlDSjkmM65fTzyS68-xmH&8Cywbr%*l&TOCyD(MI36*sQ$3sK{| z%~qjN`&*-IPdnCOW5in6s_PbMP-Ad10_gN)a7J9xx4YJ+&<%WwyL_fhB6yvqhClCD z!Fy`o&{k$$WAH>{@VMLdSwjUQts7Uq*-Mi`5a>D-jJkU-6-<&Oge`Z1B#A8Eq9}7u zNm6}duQScTMt3yr1dm7rv+Ma1*T9AEkk;IFhr|RQq5}#DP@>wR^UO494-WiV)%B{H zN<{~eTQfH3=LPXG5jmo?ZJL++IBoRgRb)TF)@(R9u-uV>o_L=ow@E=8>&JOX^-esP z56W;S6_6HX$9}pmWBz&63ofeV&>>qF4be765;^=3r3Dn$5SIfNn~Drb*{}Dj+7k6L z3g9FdtdL7A#$&!xQWBpuDb~o!_oR7jgT95&N4^fS*8vVj!AT(TX_}XGvp310S>b3j z=Eg=7k@y#hTHTL+kAk`VZjlpgZUBBV*BxGx9)c2xqp;{xCZ8B72fdGmA`Ru%QBb)-6qmEt_UAy_*iB6=3S|+n;AvxL;kXG{741rm%1HQz#!i zz61|5f4o;Pa7+u&gl0Q98(nSMPhvj?YMWf#wyQ@JooVW__^~tZkIuL)ohb$TElGa- z>EQi@3ZRe-A3wKe*#U#X2M!7!JScqVpzvXX!bc1WA3Z2MVNm$kL1AhAi{YbJ280uX z!qWzYn+Anv4ho+=DE#?B;qwNCFCG-Wd{DS^Q246@!+tgik$vIf$<3S>;>q%?J*l)L z$1{xgi+OT9d(lsO@p~xGSv=q3Sh{=!C>^ZZbI&4T4C#^iE;6!AWae|l3j6+AOy<&Kmucfz zy~L~_TS6lxF_9K`3`{oIf}pj?3ooZs#2zR;p(0&5`Pz}G`6sX|-cH_N#z?J@>O|)V z+V$>S$XF}88b(vNTRG_}XdQ=eu+)~xS68P`f{SW*mEGXICo8-jsV*Y ztoR=fUc$zK>m)Q&vj13uzWbcSGVL)2&$}ge(4QShC1w5>VGzEY^W-;vV`0)yPO+98X$VC3Sf$WYKnMi8N6WlGTy3Pf#=XjSDgSHY=<|OvGNt-%bln z*?$8mI0O{y@E%*rQo|p*g~U0W(3E7);9xs9%k#|9%lSMQRH5L(q6JeLK$cM7?kj0s z=znWenX9EQyh#_fkR=)K%)cz1;7vf5vq4aNBK#0kEW@#O<(M`2axh~>;8#26o zL>rRa`_ch){AfM8>n0sdIckzM&Fd_p)`_a!xA0o*!QGvdh1OjYwyrcypBA<5+fr3w z^5cE{4QSoXg-8PK}(3!nTVaC%#`$)vVVx34*|WZ(8%dE2q=JGQaLx2;vDjnrL6 zTWc2k2BjMdjX8F*C;s%|1KP4d8atUU?LD9!f3Ro<_$`3p2izN%!sGDv?g!%k5Yl4) z_O`MT77J$rZm`CEiC9=)xgFl}gIJ~|8v0r_ia|toDu|~T1Cu=A`FE(giu^N93v$zN zQ;E=$gNdE%nOFkPpf6#+(AYJjG$E_8^=KBFzEX#ZH#iP+ay1LKjId}-<+{o7Oj zhG({yr4Q)3p)|kuW1fpWCM@MgKE@bg~5#@xj$dgG-yfAr# z9O^|L#{A%ICq#yTf4(?c6DN`RbfMv?n6kpPOc$XnC9V?`(40N#)$0))`1x5;F0JcP zvd=;Mo>O}Q9<0)3ee2vpQurmOmQSI|)YhAEn?em^aG!eDMM}R@mmZ=inRBjEAlV{u z0aNpJ_Fc=#6pIgeY3n)@H4*g9(zJI*6o*NvN}&^8#=;Au%HH_0p#anyf4I_qx~l|UcJ|W7;IF~< zWRUNTuN-Dymgq}w{O*zVbDt00uMm69v5ucWR%XS*p#d~QZR4A}uEKzSKD$vH+~4Pc zur=r{&u}%VV=}H)o1`_d z&U=VVcKIvCjly$Z3uEr$*N8pWUYy3r|H`mjF-W2HkVX8jp61}T+IDKP>v1S=wxq%qWVa+A zR9vHM%R-?5wH2}IEfP#piW1)0KVwE`Bq&1Duolje{uJJvD@EO*9rf8gvi$zN zc5L?l9Wv&<3jRb&wn53nQgYwvEz*uX`DAb^`~sFU>$Xy3Iq1@(sD(`3etjqb+nj>6 zYE|L=?1~-L(@1{f;f&m(8M(loO#TAD&3c)|Gsj(Uf%t^+fs>;ng>H^Tim|4SY7C|W z&KaJ4F_BVuji}hI${PRr1Z{k<-N+<&zGO#Dwg*yxU+o}w_?`4tc}Uc&PV-4t)Io7r zrj!@_HWIGmw>jGYX#kxx2mH>-Ho&6EDl5s%N=mWz!&zkC04t8$p`tG2E0)T(?Xb=! zlhwo+gI2E_27vqo1>B`ai+I+#t1qVKSe~T!U0x=c{7}K)9WDYw7j=TVoRjX!F1Dye zs5N4e^$Al{1RMGm|C|yvz}B$|QFaNs3S9DofuG)ND0yM-&Wg1CZnmwAq4w`SpN5Ds zxOV8n^Z^=a)@a+`u902(i|&|7YRI-nAzbt1U4eJ^-6GEf=}rbMBR#wgYxTv_kgRjJ z-{&g<%P0|Lgs+(}qm7(!e(Tp?`lC%n_C}QL_M==CbSDMb6u_~sFsJ`9c|%=;ZU+qs zyg40dZ<18RW?>U{q$t)VJi`f1?pGB6HtIi%P~^E&I&v=;_mi|`qbEd?IBzhY&V5g5 z1-ijK{A=Zk=JP;1-2*lx*?(a5CKlV&)ldUZ$3E`-&_}Sb-cUouCTlK~|JGPY|e%u&%i3Qiet%Z7Jto z__3Kbgq{RjsTT7BdXzP{UGPP}YQni0s~B}*m_RUj`ofDRhdf@qb~rh4?i8Gd`w4Y` z$f4dPuMlPXdFnOA!ez!>EzvM$_x48T2-N>?;Os#05`x)N@*3rnS_^#bpyk?-KvAq8 zcZ@!S=K(%0UUdW!q4>GM)ts-oO#ccP5qaaKp*mrum>vMtNWh7Hk zi^^PUwGS>vM9Q#Z16^O#Y=0k#8u3$#5bse6`x5nD|9r4=shaU zR)O&0O70PJvYlQL);x^2SO$rvT3zibVL~*O-b+i3iRXw!_+s50CY^k@6@Alj$>4*~ z-+5!eu|#P^{`DpWcn0*8`s@x0>|@KUw_=LVwct6G`^x84t}#|oeOPdRe@6H-rBXZX z;22F;!y?3DcznDFi8j!{MN1J9=h!<)1m}iFzSj#^iR`5{JHcb?PVsn|@E8{!*MxYC z55(iL9}15q0gQF|9wBa9h`4ob`y89p7Orepy*fDtjwk=Z%DSmZ$|b)Z{TElhHcBXD zbq4;#?6qUdZQB??FifCZcgjj|xC%Gx6;pfx3qWmDz&f{>sx)E-*42+oy@hU*j?m$h z19Y}!cibkW%JG(on}B$(3(rZs%+7WAm$uvu{-rK=6)(145jlrfu1ZMdY$6L|NReYG ztK;KKSI28ui@yP?Cy8W*@@jsyxwuzy@@J~kdjwO*1EccVjS*l3qPyF6`IA^H=)}jA z;Il|N>)hvWF~(V=_orLSkT3T^zF;#b(RYVkOhEiv;`RNj`kuXrNr0-kFiKV>nx2dm zE3&?k-Q>7}TwC2y8|NF)d1YIyaRu)!0*c=`;fQP{sPJX_O=1_&rrhW2HmXZG0wqhg z1NCoD`Q;g*6R!s+yH1JY1-@>y$b-(QK4#tnKcVn(lKVjNE9dqJ}n2 z9&GBcPj+{0yK1AN6lQSzEYQh72t_LZQv%)#V(n$W=;eBHTTF#s@DFsbF0UCC^4Rt6 zg0q=1OqY74ul5c|y|-M3AH5A)9nw0F5k$!f&gd(yw_)D_U%EyO;S3JI+881sbJ7gd zY**LtUK`A)hfB4SBinFz-`Kxi4ly$Rxz=w6XLakPZRAQA(BJUC!Hkw{!+&z~fZq0N zz60UPxsU8=)?lXb7|@1#*>P&e2=kD>-hJQ0{zvjfB?@CRxQ9q5)B|5+tY%x#;*a?oE8>f--~h5|r_1`mzU&=1NCLqh?M8S{&AbZdJEL*WI z9`--t2Jz&I?G??3xuz8#RKRh@dH$=ZstO{8$yTGSOaD_zCu$iJpBA7eLpBwE-q@%m zmHQu3%B)+xq6wgQ$h~tWcbahJkRODa5;qg0OHU?ir-xE0MjE5ZXT!hH9w|!fT*F+p zD@LM&_@wkjjixV3R-Gx;WI|^Rkaa{95%+2pFCp9}yiDkurVDn~YI9oBULy}n+663W z7igPc0ow!%YA@4Eif2J@`!ZHY2OIL1Jf6Pb!$D%8k(R$mf`2TSqJ(Ab#GA$Q++sE_2&PVTS z(X|#`$Nx$neYizWwCG9v*Kki}mz`kI^10XBp5%X(k8ZZ;Sr$E;{~95ro@3GHTl75s zOVvj7Wfq;X==uC7R?!O-J-?$jzDO*9OB!y=&i{IE{H`|3HUIAH{Cj%iOUr%e7uosu zqrCfq4?UcnztSJsWWilu8eg=a_UJ_BAEoYrn@v5ik3agoVOA(Is9*i1O6T^-3DHJR zx6GBB_+s+H!b$4nR86vPMc?CQZ=HE>?1J3#QmxTDt)Sfg0Ggcpc(S~kDQsn&`8B<} zPjJ3Z@PX=Kt4VH=m+-F1<}QA1M)?M<LRp(&RE^??)tGAd&_DmSlU_mcl0AViLLg$lxcF)TC+XXPQF&Oq^ws30Q~D zH{>5A{SzxGerA%zrcRC8TYQBpr~}=ZQ@wLnNk4rw2sQl%qV>wS8+{WVTOE?Y?h-~; zvQY;cug<(B9>S=8$^eddi7}GKV7+PLH6&}?*A|o(DrK28f@oJWcV-!K|Bcm&?2WW*dX01?6BEH1+?R>Wh`|mk;CSroSReMfgZ`lv z%su}Pac=@&Rgv_62a-To!VOCR5ix4OD2N$BB_MDE0d62@zzuPW;wbK@H-ZDB!~`%N zqPUDY>L}x=gUh=|8@(1b0Zj(|I;qbCFvmq9?~zTaQcq^Ssah{e0f{MLV}n zcb`7p)z#J2)z#IxLW)e}tfQ%zI$G>TB!yU(OmoPKW9F?|Dl5RkW$KN>(3m$Wv2{#A z*r^Y*d~Li8sW7z6Z!5SA7L7v@Tm=cO`!#Dhp!>k=+=2{ZWNeA{0LXXYIx8WmV5sM%17}*mXFBkZG%^Z zQ}|;Zqf4lOIACG*geq30H@QzwSjh98Jl`YUSzJBgex4uZd5H!u&rkCFJkLwTw|Rb* z=aoFyi!<`Pmgj%+yjhjw`6Hgcpa#FVN(v`JJ>**JC}|5%`Igr!aroHI6R6$6PtX}> zkwA>}OLJY;k6hMYc%tw*B+#78XtsKZC*m!}y*Rfy#^x|^N(?V9f+)7!mqf_p<% z;r&RJGsiW#wmHuLS5%2Bs<$g@tt+aOpMdsWbw%Zn9>gqkMQv!# zbAl`CELYS3SJX#5d2fM&G62`f-dYN)+|r6j^<)rvKjp!;rd#GM&6!JFsh7D@PjIDf z=c#hbAg_TpX8AK5BM%&?+%%DcWV9BoM0&Mp8{1K4)a}#AJfB3zoSFR@0ipETeKr4iiKC@F8QcxM1p$fHYwF6v%s3&dR z8-X(v35Qj=CH(lO&SVoC^>gZn<7@8xNLi(=%kyOw~L%C@TdIF_;tZSc{-GbmAGP~VNJBID4{vq?rn)gQ#p(KlC%SEo#7zmMj1DLwM#< z+(Zi#mDy-=iTlQ4l7nwN1L#&%Rk;rX^9?lwNMEK5O-lNVzPv#&aUwz1H$a+aNDV7? zrNu^GmypDx<_&#(F~5!f;7^fvdfFIm^_mS%Te4IUJE*p%v?m>m3X_>yy9^;MOk*qz z-t`OTy}@1}8)vHvV=LbEi(|E;ZYoN

i9(dzNQZ?%8!igFc~hsC6kd4kqq0KuyQ0 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 P6oEq#I23{Zs|frzb~_X& literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nss3.lib b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nss3.lib new file mode 100644 index 0000000000000000000000000000000000000000..a3bb1af1a45c1c843778f9e9d223cc8686402f3b GIT binary patch literal 178038 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⪙lG*#u36#+GKSQOI415wlT2Af`#4WaX* zTmg00`E%~2dIojV)hFIa!z_kY+SZqQIM3qNawC%$Dzc+V805Gw^@krLT{x>*SZkGC zh{WYlkS&&;)UOIlRvlKQfP$lnMMZ^KZ6)Of4JF~I^>-(2@-S%6rUlPKlLJjOTCeh_ zeP+zaC$%J1Xe}alNflNWw#bsK)1-UPQTr+9J4 zWRpfj$$aaSsRmDWf=shI*_V;*MG8M7#7$F(;6>|D#x8M%DB5ZaWH2_N({1(^dL6<0 zTFM#doLmi=kI)4Y6cC*<2vFW_QxRFx>m}^&S}16DN<}}MVHBM{)llQC%7n|Rr6|1{ zs6@4+)~I&mvTAG-)2f$s43%gO-9vd&;v_1?$F8DMDxDzf!AUZkok+h`M+9+ul8Ru@ zHscOlNTuwdBPma#%}_MM!FD3~FagqT;AFiF4N69^+ggQO;Q*&ol1)j{MRe>jQ zY?X5)eRqA*`g12&xi))-u0c!W@G4i3xxFf|6r5k>T;A|P=T!}CB}Z5}J6HW?jZ&Ry zmSRV%4VmFaGUfJ(4q+7>WW}+nag$Xs@$J(1Gwzb9B_}58R+1is@ifNa32o4p6Tfw$ z6{yA?UWX1ksKB9C#cSPaRR}j3^!~IeQUfYaNx|J#rO9?-;&e;Ur87h{e5trV1^CKISAg`cx*{CTqJ$2+QW~vv z_`4Dz(K+u5aiI&Z5T7{mib-ox1sdIX)w0XgN9+7cKEj-vkLySFc4Xz+D^fPTp6@!^ zjeWR7z}6j|bdZhyNEeUAZ3%lfU!gK)ki&_IAyg;G*dDwSkWAXUpUNmOrtsKdiEb}7 zmq@WIuz&+IHyO41E-Os4oUr8_qGrmv1q;RbP_EBHxj0s%VY(3V;8yK`_m7G@`-v22+m;esq=j2w{#go3*<+8`!BEzMkFDrLraToxZwTAq=gnXtuOU3J z$A*GLT2go((vxCGZL!MAU0aOzPTLZ+bPk9u`xZwGmj=^*3)y6^5@xKp6&g2O;Pso` zrIDbevs1WO8;O{7DhN zb0tz;N-H;XB`KPs6)GY(oP`82zK|m8o-Pi-xuFTL(f#5WA8ZG3K80@U0?sb+R_FKY zg|~8Hm$TBKNF3QU(5ySVj03Zrw4IO`SVEmIa-kgN^;&6eMZpa~Cn6?RbrYgp=bG(SpyU2^MaFiE)yDq1Ur7i;%EGBx_ zd66P_+dV?k@)f($ORzXIFt7q%SpzhJf^CrPSWikB&00{Aob-ZF1`OqCX$qRV+6%&> z!6L;X8U=Y|KGY|Y8>Bmbd5JnQFvO^VDpRyN2G=&1=z&wdFjR5Pmto*KD9rQBOhtiBHEDen7yU-mvHv#Vc^)7iz;vle`vH4*dewz^z|`r3RepRTv)n zY_XUKnK}9kG?9NhyF4H#AyP^7xrx)iL>dga>%W{QbO4xBVOfzIz?>s-23TOoT>>Ud zZWosM7e#l=_b!ug`!yki4%He+#r_1nQz-6v z(iJ@L1@6y+I7hAsBYfbHFvO$%k9?*@w9q+Wk&sQ!ae%=&DvSgocZC5Z@KG4%Re%;} zYN1Hwz%atbZVY3RTeD|ph6xEKA+399yos$VKVqn%*NuH4Ds5q%9A{o>xC+U_NR!&> zD39>%9V3NlV!bpMur3e-8jp7K{+ZEv0~?^dC5ACzx^s;fhSKaHv4PWGXUIEocL|;{ zJL~*&mx)0TCC7;o`S`%GU`EJ$vts=WbEU|TR$w_6L#gp63nLvgi3yx5hVcSPPUEKo zzr3jz3G-mY2s1a#ld4B3S7zI zqIdIHV2wR6)^pand<=DFSyqZon588rkb%NHSH&Tuu%vDw1&fXR#5rVw4_!pYq|i}h zO0n)DW3+P`8DqWc$QVt#5S0VTm{z%w^!O%ck`WVob)cIT!-L@}r#(o7{kXN5^@NTk zW9bI>k{M$)qqc?U0~v?ADc2zev;2_mW;?m4ZN7bvSx_Jw!=dxZIC4ynTu>J1u_MX? z!}Jl61BjTh&V-dWM4Oi@YzEmWN0o3&JUI)LQxJQ(k$fq^S}g z4qDb8YPGAwyEfSsBRU&)Wf>KUY^%>GvvDdvc54|asuoHSPB3G&(IB!*c21=ex^5sC zXK1y2<)mXeO|X2e$n(>OnXKO1SY>4E05eKitsBgUi^hP-n9l|x0}2`%kxNW3lsU$% zrN9AYM5}X>nKC(7nK3?am>CneenMwHZ1XG9F#b!K>)Rh3Fs{LkfO8#?felm%`)BRuMK*_mg` zRdVSW@uZGD6C%4GFK2q<RDG5ukS#8nK{m_*i7}7_fVy-%CRj1An1a zfB}*!BRLWEA%!%IGm8Z4EVCq&xfQKv3Y>u!nUGcFVzfv@asx-Bbu80`z*q6g0YukE zTt3P$A`uW|IUg-8&qpCFho?8X*VZIl%xe*sysk}T$V3AJaZ(!RRmc;14=r*P3&d(b zflL<>uuKyTa7-JCQkmH}6w6EwIz-1Es5oh$;?~75vk}*(RjLDbrhZ?P!~#4N#J3)W z&ac)6`@e$a0et0Yi;?2^vn3=B&YUQEM7o#fRtcdu&2nHD)&4G26I4Lqn;B-`u6XJ9EHODGHR2~w9k zV6JW>k|>p@b;Mc)6xA8>SQ@5`zGK&{BADT=YttGkt=)Rt^PLkZDJGK$Rm|-d>F|bZ zlSrg2{<5|h6c=$-$SkH6sXm&PC(PbJE2Hc5GO?_=!O`n5t}@iRdku(w5rLYsxHW2W z{TgU+>)NzF%no)Oi!XfQPnUL_tRgss5P&8sC;NA<1Y2F_js z7PN6_TY@6*Cm*zY3nrL=5UO)ZJnGu4;sr0e0uo6y^1cJqeZ;+O-=gJ959#lm*EdfQ za*v^rkv(^m|MuQz)~vno|Gi&l5%y;<`#XETS@y4EHXAziY3f~*-(R|kR%%lv|Lrl< zS~0b1=U)4%4#Xd4xDWd~S8ds`$M6tt#qT`Jk+#Mkw*r1;5l_SKT(#E?mTzB+R-56E z#{rIy@N?CUHyHdrS3Qe9)ut{{uT;<9@|i%~&S=Ht9eTD}GCbHGn;2U;x#O-qui9~O z*V02QJ^I-kUla=hrJl}zZHa%M!GF0R5c(jTpdy+(^n6JD^PeF<7!}3KD3{u~N^wkA zI}E2wLa{uvi3dW;^USF*gntSBWB()VO8Lye-$pIQzZ>u0_^GjuS+idoSchTjxRzsu zfAC+)I);Sg{|&5TABQCCxY&KzU$Ty;zSL(@np6U{j-oenmNC;BHETatx2hU-7ebJ- zE$3N7jhf@KiE1R(sPMnJYObqMvmKuJ?r_*kZC7X;-5$=_rySDD5RP^sp&M9>o-Xv)?E~Csdua;MAjCQ!;7>lp zrrdm*3z7OU=W56Y<^GsyU6?bwoSQpwsXblQx+-@8ZG8E;?kusC9TDO)khVNT_J01P z!}ASf65fju-X=kKSkJc()qPMKZ7KWiUCzx{A*^QxVUaT%@;Ev^NoN;#9$4sqec1=28fY6>5ghmdyoo=$06?}KuG%rqb8)U=vABZZs0kl;g#$DgqqeHWC^-Fw(VCW%GviEy@v!UjW%n{sm-A6onrg-g-K=VnuX`$8XD_`Jox5LQk5Nu$nfldyP2)CcAMm}!a4nN#lB zUyhJol!U|<;$Pu#A#Hq4HuZnog<%$7_IUE)HuVrMuEMpih5QTQ)U?psAWyds!-<9w zF1(qR-0Yg#y)8m{i4TQWSmBJhs%9G-PE&ugLmW=H2H3qIJ5 zZ%t}y!i$ifJI3M0Rc@n0YU)v67KcPb2+CC~8bA4zHI?8_d3ae?x{zmDf=!nB@;JPI zsRlHSGIx%{vFo&ymAtL)lH_xB#%XI9oxCCr(>0eqjE!$8n|ioiTxhZe?%(k7N!xh4 ztQpz90yW^3NoeW2Ku%M0krff2aOM4fLPwh;@ z+qb5ld<{x;uQ)vFC$VCQz5nDHEFbvBw^22-d|D;lI}SaZe*08zy!|xg@2n)m;UVXj zvkK6qb;kL-UwK5n7gD%S93CBsMVnN70n7#KBQn$Qo6PR-a6l>}Q?M!th;pJ1ojSj75mPGrR z3w&tR1CIWEM;FjWmtfPJVPPS}?3I!y9dgqs`k)}>!YhG|YCY#LoH&O@v>(Tz`Q z!)Rbh6*9jp`V_8})U5IOL~h1);{4Xhhi;heu~q z(vdN5tXD6TeUKy3oEgeb1|r-Zz!P&z>0eN#FRspeAfulR7dE+wMao3&|TFVom!< zXENR#hgcfwKBeIu<-C~DPaJ56{7kxNS?fUJCC`4pvb@%K^muORKKbVIXya!b!(gi-#Ty5GX9LmFt zmrFLjHE1ZqRv|R|40x5ijSjJCk8ovuh{40-Rp1+&x38_~N&lbP&MGjDC&fbD;In2z=%*@Qp%*@QpshXLdhME3Pr5?T9 ztzYy_byrtcS65eY+WYE;*vW$BrsoQs|JdmK?gXceBgJp1YM1dyzKtaBxYP>H7)XoH zc6nL5_k2jjI)&EhQIn=_SSpYZ<+gN9X4%bIt~Hymfxur_Gr3l$`^}FniW&DTUfLcm z@rSAyUl1jWO|IHNYw6{g9$F>yhF7NNHk9+{`ej7w^5D1(V$DT&>gO0tDjr~DWMxt0 zyxLum?*Q~^V1GeAt0BA{o>Au9tYOZJ2WzdgHoBTc`AXU0@rtfNq)|?ywiqP=GezB~ z?jY9KWU2S4#t=$bXa_l_SaiDQ1mII?!=jNKMeVdxtzvCrG(GE)a}WGq;_{n+> zQa?62k|>Mygu&tE;7N-YuR?UEvhFaa)>@q|h2sX)&?`Vn;CG#Lh^20&Tt=|Y@8u9n zlvK<^(dv6UJSSDXQr3N3)?iE};FMNwVjTecbzg_INClZUPeNLGKZlgvF0ii=pp~b4 zPR*y#8oz%zG24pDwgx5nMpr(H`#iv;cU#m;Z<%9Vsyjd$hYA?$Gd$~&AI?6ooSoi& zwD+_I?P)Rz;{nz5>vopcx9BS#1izw557(>u3bdC!*!+rkZ7uHE2T<{xdsY)?pgqK5 zWvORT+wg-Nb(h->aDVqui$3m+2J5z{Vj5b{4>M@>T2djRm$$oCgPLpBMpqQd8+y1& zOv~l*$kuB)MQ$6BXYvS>7t@&<)R{$M@olfkzuO?&DN0pqS{fha3lgj6*EFNRp4JXYb*N?PDDx zkEXtK&R>4K`Ob9tZ65Xq7&} zVWuoPM6hiz6XwN|B7g9SCY3UXMuSezI6}x-9*e+d%qN+w!K%G5v#(-<(ep0hRAns|;P?}<)yRzgk( zNH3qOD2=q&-9!=^*}Oz33iG^DR`P%#3OVnhw}#Jmm{iD8sYm`}quvx+b1!f>fvel& zMR6UA7v`j4YDIE69+?)N zTa5P3*W|?P_CNK{^L;Z=R&X=@T18HBjJe(qRaG9**&x8BWm(`U>uK(r6H!C;qidD zSmPUWYP3qnk!Uc{WxtEu%;a3%nBWujB(-v?wWz~_S}XEh5Y6nH^fyp9)<`YUnYbMy zHHxpjSrNJYUPX8D$gh4&&WlD#XgrPSr9lH~GouGqjc^s#=&cSli$PO2gphGX*&}ar zh+iOSWZJ8c5yfNPQy^x$G)Uf%u1u6m@m|HJhK}Kt^3ZwkeTtNZoYK=w zF;PxDpGdm*J4~8TZQ$f2utR^KND7ROpwq?&OK9qv9!6K~zXC?r$2Y`Iiqq%9s~;QnLXb811o7!yzLeEcwgaVNeL`pEPiCaFP!oeDkHl6H z3$a|Dn?$Z|{;7exQCcGYTo2*bX({B@T&qQ-i))-0+Tt1W=)GX=yF8)zM^oOEcJ);9~&hgJM;rZ zpx#Q{ws`jN+0n9bTvX7FvQSRK4@+6K^{h*sLW$)=v5g-&Om5a3PDGmVV}qEqhTgPX zi1HIf;Yq8FSMov2e{6Kdkf-)jMWJ)yxH}56J;;*(tiTDMBNTuBd4ZQ?m7XvZU%uM| zoAe9C%evU*Dj}wz$l))EGSh5w2ldl;r2Fq6>(Z8Mh1?3F)%B|~Vz5O-GXA=ZxTT}| z8OGov0WyJ7N_3WS9XlMJqNz9x@GGi+tXF+t5|AWO#r?J89dh?~I zer(uof>X;MQ`-C?ZcC_|UusmPtNu?GYY$zh9imL!C~1hOWRkCXZ2OKLE88?i^DC{L&p&9c7HFS1&^ZV?7}Y||B>>zX))b; z46P(^rI8z5Whe{%pPI9jbR9F&J+g}=P6FxDWqQCoq6qrGz!wzJQrXeY`|kpI&bK8?5)~eLfd}Co9h7GfF2ws(rgWqcB0=apB^3%*CA^Wo0eI8~z~iIz%IL5%5J- zj|{4BchQpXIG2eLj{~xX7c27TNk5zPSYgmw8&;s7h<@>M`uH%tYbM34g6`RmxI@e( zZ2D}YzBJKY! ztB}^Se)%Qx6&&i!xLe}BiC3-X?ttHtUC|+?k^L%c1@hgl) zzG;`5E9pq1{uEd7k!O+c(l0=ns#kTsAUP&fA~*5}uI5tH;{hFyvQ)V$))ZLDS9kbX zc0dJGbSk<=fjYg*r{K~#M%-%}+~I0(soq(QhLk{4b|8^*(H-QqGH!#OXzMVFlz=kS zu5A!1xQFp*3}=&UGe{h>432^U)^!XPU)=BKhh%yH#eNIAr@OAf>QGIMlLkmUQ$VKc zDbA3!Atf1sU%5=+4e0eV)=XTlE!oN^=YX7q8)Tfh@o1`dOiz$>+)%vth8bf%d*stR zG9I<#;~{w}p1T#!O}J4;tAGL`^EY-V;VT#25Z@%DE%pZ0jiDzR!EY9Cn(?v#cG6~M z^SXhuvu;MDx!P2Ar5HYn=;r3;87sR?EWo5Xk6s7eB4eeeicv%@I*b%dG079L;i@I4 zFlq1h?alf;-z0L#NKcjARshm14N?{h3LqhUzg0%!Q~s#6x)AS=mXEZ0o#7VUSZ>dG zRLY0SPIahykFkl!N6~W@;`^af6|2VgUUu5QSTDd1a+=~$y@%dvG@xj;^dFn&qdUCYYJPt`1<@-wzR3!!W`)kDw=2djN? zP?ou8&*ztU6E=-pH6!q@CsD3Bo-+woNvsu^=@o~@iD%Grs^jSMWPx_@)QV*E?9N;% zv974}I4#Y`%5NIAnDS8t>v1Y4M%`#cZ!XB_@?}1icpxLFq2jRx%;^%QzOxHp0*&2W z##HxI8Yv%J&zW-@&E}pGX6Syh!{c-D+pdP@(G_Hfr;5CUJKK~hy4ZXCV!k8T>!Hm> zg8;7|-R$iv5-W(FBHO)R6NjTgyk6LvXAkU3O^26k60U$^B8rnNXc@KlruF)0Y-l>WGt31lW7*+!ho$&9uA$DLMzsI8T3BTp?YwJctG&9-$NdVV9{2Z_-I7fatM)oJq0_ zh+%JNkVR;hQ7fqWiM-RuWj1pM$+BF2!~K>MJ*QE=0XW+v(l%0Cr{o*9g?d3&$~#)%6$%QA zd1zg93q1Bj>LJpBc+{Fn)1Cm^xxg_+GWJX=ulkzPm_$6HXqS#%8ud%$XDuNbilpo3 zJn|`{lP6pBZk!y0fEh%zb6gsAArGqqf=&U0oJRc$1MM}kVMCW=J2rCt@SLDH7Bnhj zO?9I+@~8Bqi7m7zR>HUFV~d#F3u%yCHjgLFk>6vAq*4RuCMeO##=#JxXQ$@H_N#)XcRtDby-MgGN8|oV(ALc%qIhyEp*{Tg`nS}0to?Vx7BkyYylfYNVZiMvZ zeg-Q!qDJd!k+u+h@p!x(`MSTuvo{H;6-B4B2b7TZQ|XjWKcu=oIww8QAs!mE`XwPM z@rpn@;e$*jC-F1`;~Ad0<1_Yy4Hm0EyMfv%)CyDOEI!0!jt2wUba_}Cy>@gWfCzS| zhZ@9sTAh4iFldF`N&?!$iZo|?5RWFf8+^D)>kM1eXrfKo*F&>8oRo*O^AQFw>1)_* ztr$T)`AYC;CtH?B8mz`a*N91_LOa5vOcFmwrRY7mF}5ia%ZB2kk1iqFIH`Q-6~JQ* z8p&m+1&ZZD+47IIN#uoYeoZ4ie4Nd3l|wEQ$i{xW&7ub>QEzn=67xlK^#q${mpK#5 zgLQA1KM7E)*n5!HJlSAZv5zBfX^@pT; zro*(iQmJ$(tKeBK$q7M7S*Q}_vkewy6io7yfl4y$Jy8$7|9g(j42pH2D8O?~&Vk)& zwuH}V7V8S~7oKO5TkR6#C7wfYDu2F7Q$1CSiKlW2J>DLlMP6VrRZWucn-jF^Usz;P z2cdCyJS00Eu<8->MJ7{a4i?1}k1dMnyx3r}m&qziJAH_RU?yKuLaStF_r!ELE9RvR zGi0AYHv45Rhu#S5VU(^xM0&YHvYWq1NyxUm!XeEaN>Vk90F{)6_M%rhv}QEum{&7W z7Lx2$CM((V_E0c0#9KjchhANv6_>SCIy926De&yWf|P}1du@TmZ=>vkq?Cs|_177^ zBwQNm&4TFc>s^+;)Z~^J*r_)dtV10NtQ%!8#pCDM!THANjV6b}Yhl(N&D5I|iEcf) z{VvB54bveXJx{cYUtho3Uq=`VJqD-l2tM7a`00PMcat5RtBA6i0YhDa##HF%jgXy}Llv z-kWWPrBw8e^F8N6rI$qW(P%vAS;{2+0u-5gul)s9cJNl`=)TWp`vzQWO;LvD`w_Ez zxW#)Caao-XkiqE~1i)uidhTr-3Mqfw4nj`Fr+ID>E>Ak~aZTD2QY`^R zfIp!bjqDmLVBFAo;FCoX*=2jn6>B$`r%!1fJx5-RD7qaW8H#OxT9f7m(QwOh!ak!p zTrO+27o>S8lJHrRL|w@Fl2{L(be2%=$>$V_bRoM$nmR$P*F(+&$T#}D&CC2S7b%qx zS*0%+MC)=>Z2QoC^cQUk?;I7p9YyQ;ONzL!(>v<9{1A^LIQe{8^M>w`QOZF+##ag) z_t}A%=8=jsOTTK;R3<*va|^SJNK?LM64`5{l~(}DbrbkDUw4VAYg~Ye$JJx~IZN;x z7E}3&1*BL`WHrB;GviiLBt7Wdfo#gRG-)*+8!51=9WUJlJ|=e9#zBatQdz+F%Rt7zchK&@P^wM=AmuFITtfMw(3S?tA6D$C*v_6 zNg3;kDz{pmTo8T%^J|B@ry8PXMR1L$-#A2a!`4cNS1u=*)89JOCK;GAQKfT=>SX`U zWsVPfg_Uwqy#4nkSG|7;&|Ad%gTr!_RV1AbDHM4te=X3=v@_{Aq8rw~S){}V z3z7=W+23;(oh7q^ze)8@?edA|40V?Hhvvm2>W&??Cv=fqF5}rU6RpLg3eFAx%*o@! znV|EnklT3A+T*j=zbuwrR81-qn!SG)I2=0KTb~Y?JrrH}kHO2X%N%8qN{1}-e~YxB z8AFo&&tNU~j#CDOdrXi@hF-Ov=X`0E?Ik+AnzWKDBl+s{_)0e;y*%%^aqaSWVm6x1 z^BHV@02VsF$bz0jIi}yyVy-9z(R=FPO9F27%VX#E7~99Ug~O7Y8=; zLYhb2q@&)lQxZVDCcrzo3l~{|S?eewa1l)#Mx!M55MVQrmvT{qG>Qim)Z#{7%Ec6| zNzJPZ1tG=r1?se1yo5wS#&|ho96d2%&TzX#&LbZ-{Ea%$#7k<@h;FsA5+BP)wP50L z1hh*TG*x?kdfYRHQA`7;$V;0va!k@-et6z0%7DL&$yCAoB2sQC!Khx=VDfEDc#boQ zCtc2@C045_o_H2Ld6C;_EnL39s~|fUti3B3Jl?y*qWdUo;)*$m!rgkoiFE_**jF+c zElM$qtRu0Qg?8*K=d466_>k(Rq>FjT{$EA$k}WOxX53>*IBWK*7AZJd>(M^G4ZKB!YB=6tk5sUaaRfKl(zYvil}ZQ6rjl%!PC&ZCTod!a1W7?cHhO&`6P_Um@x zRoby@xokGoPC|K=ylX4oVsE*sUL`1BWt--8E6lS19{Y7Pkq@z1hJZGt($Pd~nK53q3 zSPlz15#7k7P4zfE&4!6J2W4B_Skc_TzMKMf!<*O?+74&;2CO=;!f$Gms4_6!X@^u_ z1AgYs6zfo{!$+aisW=vvBMCe`^qM+DCil zX%=Umn&;5fyfzf_u>-4VhsB~YHtn&|ZceNZfV9&hE%w&J#t)EAw@7C>swb5RokY)2 zq-m;z8Ztvb>voxp30_MYB$WkKb-lIXP%g;SU=SPIgkgT?j6oNkqS+P2aIpIUV_icgpFGaTLpl;-3?WQZ~7IQsqpKW#R0P zn#HsSRU^eV#&aLQUBo68(KX6qxsZ2L&ndQ97E1!Wn<-+Z8Bc#w+4|76U&C8 zo(+rEU$;?Wxqxom*&r1Luu_@!8YI^BFqu${dY?gJ%8<71sdL6=Lo2ytKWC(0p%~6g%Gx`1=F&tvdDfBMcrCrc)bWtI_y2eLTBFf_zRr zXL+u*zu+*{<*61?YTHn?yG5Ip#s7013YF7iRr!YJpg~UhJJ0= z*9o|b%Op3W3@V;gk0s)quQOd{#q)|zHfL!zrCi4Ch+gbsyjXJ2K66Ww{H`WF>5zJ^ z21>qqfe(JS0>6s6MiqYV4v6;hm5wu_-UCqWwk~3-N3VH@T`E$G=21SM9)03>ANTYV zZ861Ew8ypz)QVS-M}u!p5+BxVvW}c(KU|3UG0|My>5XOw?Py@7PKf8%!{!t0av7WM zRqXZ%QX;ZeZG%Yn!&_jj(97<~pr1&3Xy!Yw-tNVkh3*+wG?C(h+BVrwOr;}?WL&k0 zYQ5S(v5e@h@rWi;y}BbR!7gM(fgjV+v_?|ljrO~(p2f2@lV3{ZZm?~V#Ip!i=21<| zg)0`xmlDw_t_z5bUaeym91(LpXN;SW4O-LO`G_j1ME3B`kc|k?B&4@JP3DK+Rb;7w zb4ILbX|6oy;LIJ^t%Z}0Dw3_A()Q2R`Akkqo77+q8A%k~IH#O8Wi+1=TO6dT1I?Rk z_3CuPH;PnoCRb4LsCv8;ep@)SxXV$O@9gyiie*G^IYtJn8xNx-`?RKEV!1#hacr=X zv!OePV#!c_$zz&^r%p^oE8@6I4VTel)i`o;qMR1AB2eUc-Q*?bFjqXWzJPUbQq!nA zc-uwE=gqU z-q+?u)b@aj^GAV15RbW^LtJT5dpUyEYaFTFygfq}=KdaLK~V8rqS)R8Fm)gGozvoq z$!Jy|XpyVh2@&x@7SXpFGm2qU}9KkCsz!iGs#9g^!YHp_K*#p?~(>c?spov$Z5{UcOH zhdU0BVr4!9W)Hnff1E|;a%UBCJ^5VQ$d7uw=F(G}^rf+@rqbC&EB*;4FG<0yz-EJ0 z_(YR89JL1QWYC6hm`||=p*`YBnzz{Nl8vcm-2;pLWP_NzT5zXNE*}`rr?@m;__muU z=XoqPNB*Cxd08g>L~p$;8D309Z`7ZbQfC`UoMfsu8W`om#3XdOc)BKK$vRX?Cmv8O zku|filAH%is6lh^Abhr52G8WC>@}ScX%ZWw%!}BziPQJOGSYk@&55*{- zuX&Vfobya|kXSCmpK8C#&auPmXmPr7-{MKk%TA}zcg6R>TsHh7fp zV_nfnR|b;nH3iPr+P2pgd11EA%SlO4VR8`gq6EEsd%xn0`#}t(^&iL> z9IPNnZ9TZtCDOqUy0pMPyy({TLm7*X^YhUvJ^i5|b9>Kd)Sv897dT^)iFE_*xF6Qk zJc}zo-OqN~RzN{aMv`YQ&m>ZpT0A@Tg{O$xupl1l4Z(lu2w1b6QH) z(V`LW}_0B5Y4%m-n#5{Cs{l%QuUoV46#}Do2 zUs9|jak2^;lI+VFExTSJ2X+*lFt%2)WMJ05VzbIblh2yxw8K@EzN&bMdTicio#xr+ zE=!EBWsIp_P!9{Rr+qym@NOMCJIE{eM#gcEXi^P8w&9z^I5>S~ux&sd>bEk+WU_t= zLnhWRbZ7tVGFH7ape7kw-NZ!Hi{m?GM6Rir@6hH2lyvTprTA_}uF6uNRrS4$6}GC7 zmHoaZ@aW~9zMeMm*a1uQgNzosw$SO}hZ!R+nP?xLrLv%r`%!`8D!iBme5D^3XkKL( zuQODg;aa0fx&=TA#Wp(BdUw?8Z4RX3*S6!UW;FD*?@ah=0kf_WFEnwI-@GI-Gh)^Q-o2oR#V<84e>=}IhR4lNCeW`mm7D}MuHj5n1MJtDxsX-B zR)ae>ON8E@@Y6qO>3y-|v_6z#}=N?4?O iOWb}n@O6PFgXV^$BYz+SV;+HvK-fczc&&n{$-p15MP=jmaaKii%Y z-u&6i8*Z8JZ=83>=jYvUoBzfeZomDGi2rjp`{zY(_uq26KQv>e|F%1By7}}`qlOoo zrd9p2Z$F;1Wu5c0JAbk6Kk@w3%!|$Sx^<6Ae)qcXNqWt?xLjwg`>9;7G1u90z3i47 z8`#!Bkk?juJU4xHsAqd*()+zO`<$G#T`lT21Jx#cJmJRhRW7lm%Jx}|XVE#QZ z)bpzoJf5v%ay&;lX$NyH%<(J}!22(JdgSJ&2(oT?AAblk$4(}2{quV~^{3Cf>4wM+ z9?ui&k%=}v8*ts@Dumkr{-3Ukd3OE)2|F>6f5UZ^#wG6LU%=z(IK5F9lrdtg()Ufc zy8fYD;PiR(=iP`j!3l8VVUb9Gw3HiX4=VV;(>QinqQvd&d{a_$$ue1{5 z77WSpScy>!zc|#>^ES9)Q|cd5Z(!=0F*?<^moVwlu}G@1yTbM=-*TpwGj#`3 z)BlhuHI8E5HxA3lV<{(pe=w2+cVgf6>`-xiJXBng-EKMC{SSXeyX@a$ z1uIp<1@chVs5sVDLje5i9q9QUh{#QwlfW{8{~$ck$B% z>Hq9Z5c|W=uG`Rm?z#Q8C;06~fu4KLV@s~~pJD3U^1kh7@t>>8SJ_j=`L3Qa@t@7% zSF-#`m9FwGeyd>rr(TfRzpJwe%s*;UX8z#){b?@x>$%X?-{9q!v;5ToS9uqF4!sbg42=zZT9j{1Y#fb* ziW^1KN((OHKFk*W`Z;OAaHl%22Ywc;32(_-VdaX6B2&_&#%zGiQ+~5#Tbm#y=YkhV7gx+ZtI_X?dfgNv_&X5Z&WJZ`F1Ht%i%Oi|xa^f{9>G zFdi5gW|5xVa5}V93CtuIA^Yl);TtbQKd)6)zV2&z5-lvQxCeiIt>436CdTf^jb)Fu z;){yQeanYf_Pz^-MDnZ3I+9n0e9JG+v0|%+;Hj!*{hg-Sn5$_Y|agG1l)n|3+D`B&%S)|HdrT+H1#}nI=)kUhF=M^)?k$k}!c zMnBbC;f;*yU2VlW@`9DG&3i9-l>MUJZLNGO&szCro|SuLVRi0i^`pP{_O^6HPOdyA zazbyX6vtlU5E=YSXl3|RKuVlZ)}xR!tiuM5tajX@-TPY^{069I)YuMpsZR|d%` zrDZ#6?DwkdJz+a(*&kVUQr-8O#}l@9ayI!bAmqrzOuuD!sR=JLT_GuYVX$-P5Fy)U z^%RmVyIcJ`uGRKt^>4V=wEiLDt+qF*o6%MoF;yCz9lTyZy6)Q5D~eE;+3Q|n-92n_ zm}xTkAK|#aI$i}oC;!BcdwX%~#qC_Vy{-t4h4#3w&B^nWtzY?8u4<7M1gMdwg`PRR zy}cDj&q0|5*M#kxD03pkjp4*Oe_oUC@l9+-=N|iSLHkvJVBNaAsXBLe*j}e9fZPjm zq9g2SoJeauz0vch4Q~f`K96FB54KX_o94toHH10w*Mlt{U>rpjN8wptpBbHQCn=d-hL>hYR-yE62?Hv+fS^WEkg9P8BL0 z!NROpSs0nnyHfLf*SzzG5R%H*5kFnyHdO2~9uC^z8 zLlir{i2+Zj(i1tdca?7Ig?YQ!R$ZruZCUop)sO=#cji^+PR8^Mf+j07N6Yb!X@~Ig z*u&BEv6g*VAwBNcDzC#Y!|_m99aA}pkoWNDuD@k9AoE{~-q>A5=yPB6BslEHg9cV& zMp3Z69*wI7uaHyjF0vBSinPqdM4i3bN=$Y?lH_3uSdK1W*&8UP%6lsI_x3VN{<-?I zUx%nymCa}x$Sqod8}#3$Zh1jcqK9?na;{<;ij>zq%57rQw=q?$c)1m~>M1iQ`Az$Y z{Ppj-_zV1Vr~4WFbwk$k74B!0?|DD7{(V{bU(R}tXFPMr)G{SKV*ukOtxsy~txzRk zH>-8MuVp<48msU`Mzr4tj^qHYU2U~)^R@g;##__6Et+R;?in+ zgL>sF=r*3qiC+R*mB#iAUwB4r&#?LD#`X+}oEh7bx8TIso`MA@w&$ZE4dAX={&Ta3 zdZ4%U^CZF^$#<0?1xQ~t{&^^-Q`=Ee>@7T@(v0l@DEPDDbBl{8{QUxH*^X+vr`p~F z)Rq#J!`q3H9$L1|`*M6s?!rwCP#v`rAhvof22Ab(CPP+hZ?pg^2`0()AsbhWvl}9P zh+4bN=&!;3&4Nf>YgRqF+grBZb?%B->r@WUd@D=&*v3*hV7CUn_drd1@uoplReby>E}E? zzl~>H!3Q^~>*K-@b2LK$L8;-j=dw$g2I)kN>(Yfqkz>I%^NM17au?uF-h$D@`{-mr zHuJb!)Ev|=|G<{pZody34yLMb(Ag`( zSLEZirx|yeB41jpDRMl^{~Z(=hnvb>z9pkrq;*Hso0wV9Gae6R+k)-OP?;9|6HCDlr5?Tl(--#GJ3^MR3v;o*HY3u6#cs3mUfq~EZp zY%B3C{3S3*MNb~J63-45qN9?RtssjheN;fPeP{WW+y_%Qa#CXQ-(!2u@GW@+PvJ!V z8?W~E27Sw0JabDto}hhi^G&!`=XUkJ3E>qP$uU=860s3zPd#5UrOceR>8P^ucyva@ zcdqqlzV-x#1Hv1pl*Ot6}fwLP3yan z`4qmlOAdMdgJ$B2oEtem*!+i_a6(L^%^3Sj>d(wXjvq3((yAL^XMOCDzfPC1_5d)2nGUk}@F zLO{qs&k_Lv;qWGg7xBf^9g*R&J%LERhyzUt(+S(3HT!xPgG9otFKh7tJ?e>l1o7}Z zZYsC?mi!V|`0mlsD++LjsU7H9$t2dIOZDR2X`%1{G7?iD6pn&W*r>`OFCY{OL?|Th zF*x0*nyI8UPCrjEu=PF=0OJ1L=&<}w&@kf(2krNFj&oY_L>8Dt$s{b{Yq<@12A(dJcYo@k8wOpK`*BL1YQ?iw^4=U%r(1RC zM2KXsh-40*#A|n@J7{706Rz~Uba(18SGw1gzRZzDRn^ zjAyl^fBywDGwM#)Gb49?pEnCNVzU->ep?Hp7n#%~qo$|s#CedY%ONkO}( zM$eD;An0pF(2M-*$u%rgt6G{g*Ms-S_4DRc?pY|(9a46S8jm@lxjk}|aJm*;cViMj za19s1)w3K`Ndwf_sMbK-Sz?<;&SDI*kvV>_Fid|0fNv`HtM{OEMHbaU7L7?Raxh(+ z91SGZF5dSD8eDi%~kGu_j3#bx>eC(Q>R77#MDIS)^9M?t@!Anl+IqQ0uj&< zv?*A@ipl3F!t%H6@TWWCs20bHzQ9ctiLbbyNnNyfNU>q z(PZ=1ovF!Ii>r`L`wphhwk@R|&wBh|=g6Ofvvv-l=)pC3pi)jaUB~x{??4*gV-3D( z&N1X004_h6=gc4notGeXPK@SPBNWmHrD4n%xV&RAb(*LEN-btS5UVJUO!X!XYLQBjOQWEpB`C4LP-9bBw(Ba}JuEN!~ z{G-6uzXqEBoU?m%p0DLGBz?GgFU$Z4OWKD$PvH;wqlqjaF6A<&Xz{tZldgqFeLw0j zO=O|ViS*v-wijQ029m6(gvu?UD zN21I){767I1qUY>i~mplWA|jRgM|X{y6jcg`X7zd*T_z1N>Iq|THHf<8JQRB$&K8$ zc<*ocaI=m%f;&p-;y8iCCvPXq&@PM?w2MUUuwSJbQ^5;@Be6YaF33xMPfvPx`x;=G4-(3f@U=URYDN|9@*R2;&@R#O+C!G2 znn6dvRG|C4@I+&fow4vV%D*ndn{S+_dGjS)jg_#II38te0=M2XgKArcvMcdBR30S; zQ~H;oKoYt@2%Q|O-p9(aSyMYz$d@AiSQ3AfA%368DXo>H<0=%Ys`pjUde6 zF7;K&A|%4_=Y9{~!RCJtvJ2~G2<&->;3rX=&B%^Vf$;<00t*Nt4X3*3ua`<`M8LJe zIw`myKy+|Cna0HU)4qpvI?$zbpbInX2sqGs&6CE&-)<#fdtCO!v!eYFO-s%r*#jKN z=F7=SQLaJ-uu3qE9`)e}=E(Y%C7mtwby$aBrC*R3ES~w_!3)IJJFbE z$&SVQILmxXs!-0?ay|Zvx}@dfTXHcT!7^v9Gb;0)3e7Tqz*SggJZ{F|MQxXm|D^1Z%0v0tu|FB@9 zwm{VhwD2Jdu{tsS&!EZYI<0MmcNLlc%5P9{q>3W>q>9nm8bwe`u1nRu-viqv|M ziRTE7!uCci?Q)$Lp!-8~3e*=Ja#hCm%<(O$0a;>uZt}%$)Z~iog|Bs)rqx&17+O7D zscH2%u0kuvn1Lw|)e|xHyezr5Z8+cKS&QEx)6q3UQuCWrBS?N;A9V{x$9B%Uh3wu% zT#Oa-S&KQ7Eu7Dt6twT^sf+z=*bn=z#C}yRyu>hW1af;JXp}$yI>_?mrIRT3p@?V1 zI<`(~=6wL1+qBvUJB7`IjLGc8Rj@JXmnakY>?A7N$dQxClnX{r%IC#d-f-E21~`pE z^RNz0t;7%iJ{gyO!dlrhO6k+sJ0-;V2@XpWBlKi0>Ep@7)|9MPi#|`WmGWV>P{@=x z=sjIKE6+q;fU^SrTDS(-Jb9Jjt^JcUHb21C;Vrh=_8=0zg#)ThOgNvlEUlp3QMm7u; z^6<;V)q#vZDL*(m|Ealzb}(bF?_@~vC#JEcuZcgGia%kf3yn-lro4$RJgV1jawz4v zhKoqxrWAp1<5ra|hOQ%0yueUR^3qU0wthDZdv#A11JsJOzeSyVvzr0l_?9pLqAmS0 zz|qe;3=lL7fa_okkZtb|NBMmG{-^1W{tw~bf#~0tH{A4h+517*>)PNic!o|?(x=}3 zoSw|*K10!EuRKj8*hP%WoX@DtIg|bq>5QgvXsX!RV-5ypK)zmfQfVz}IpY z{yH()TW}Bgb^Wgl`@S?qv+pKcg?-b&I=GnAHVm10_+|3yf!GG+v+M)6eCK+b+0qv% z+Z{OT-75aalEq#uS#bNCVGkqjZvc;|u6m83;bJ)S)F4g5{~Oh4U^J|a=#d6}Ju{Kb zwK#9$sse89!4}3xWQTB7>mPhAWz0>?9_gFdf-LaK%nzsy8mmDG&o}YB2ddy)nsoLC zp!C#O&lqUao}9=Li}zlSy1rJdPI>~r$mz@lN_&$x22;0~>QiXXM{4X5mEH66gUfT0 zA+)b|60;MSMGq{ubN;Z;aKdBs?yYpO2{g5q;m7>awQYKrfvG8C_B z*&QhncL7U6ZchFlTF6}eOAaaP2q&;6T5Vs8c-yVG&bO-V->3FUu5Nn~&2GUji&y$8 zh79&Wc^9wnHp_nJW?R3kTf)BFo0c9Ujk(ja7)_`jU!O9{4Uc>s$yzcbX9K-@H)w&d zNHR+9$Om^MZ>2#D)19lZu}<(r07a+m!FEV61*1f;KmB$=HP@Op(-u`VWD$DaC(4R# zAy#ZRJN6+oz4pntZTbMru!{0%z(b}7&xmO@JSwjqIWdq1t+Tv)rmVM1p7!X@le|vXy7@`UJi7N||vba-9b9h3KJ#}FHnO!9B*Y+Uvg(rHxF)gu7EwcM7 zu$;}R&S%7&=vL1LAe9lHMgt*grj7T5V{}X=!{0XBA~>NjP1i0r3^BJ_GsI1}4j`D@ zzG`82I)0gaL3_o8B9FedUhY+=JkGgG!LMVzTY~Wm)dR4Q^%m~P zE!bNza}GA6Yk5uaSzES^8@SH|W_3T2vw(bVDtHb=7Gr*_lmnHRY5|~lZVWqb59em| z)p?a4&-*31!E%2&&`&SmkC5u163jl**|#JQ>AsdC{B<;FfhN>Zzc7T#o3079|6)U^ zIc+_l*&p!Brb{1EWF(-xO9txwqi$>C!~+uo=Eb$E)eo+An9*kBmalHDZ5~o? z!|xv%f0{qj`yqoi_p87#aHGW-2!BC$>c@2)xy)@N|9{9)ie;D-tVq1Yi+D>92#vDc z>Thu3_0)wfsLfACh>Yjz-75(<81!vaL$&1=3EEf4_5+antyR`%02P!cE57?%+=Qrm)@3Wk!;Q&yC=G>UGAN)DIxcMYoS|wWOy)3?^9z_OV^E z@LM2M(UXQy-Wi%u9$bY`bK34iBN6;Ks(~?+oij*LL0%d`pAvqeR~$Ni7Gr836n^&n z%;2Y_R^!KytHIAhK-K;D4UV5|ruhW;VLbBC`Nu^0)D?)mx=e-Dnr|p4yGQ}Qx*u{r zjSN#wGs^>!pBrZR5tt?Up9UFcU#gLDDz1Wzwr7Brr}6t|;li<}-ToJ~{Q>3aRWr#Q z{mawu5;J<$EkmCE5DP?o@#MX$}67)BmTq!Sg2bwuACBz>NQ7(I0QJPRj1Ew~1yPwBrK`Wyvq zO8Sh%^$_TD9hA%-{QiVr9ex~fHkQ+<{9jHVmp(ZFeHKoGgL#WWn-q+s7bXD{9Qg zZx8POFVe!L&(iM~aWTFW;{mGIM=Kr4M*E*T`$jQBfYsgp*2A*Hvp2x8$&3&z$MjMg z(7I7 z95M6nP`ECkwnZPjG#J5vK8UKwPIHa0K;`{iPGJwla{vbSp8_kH0kk zWTtO73~S;~7s6yn>y)&=^i`UA+5S=xXz15pYT%N%(JPzkQ+nk<@u%Q2gZ4bsA=>w2 z=|s?eknyLtQ2sageaf^+lTq&e`{PggBI3|nzuZC*(-=L{> zFRnthw*B?kWsTq9^kBC8pOkkeWZh>K&&oZB$8<0Yv#vk=*Pr|uz<_h)&!bTE8S=+L zGL#^&D_Zc$ii4Ct<=-*x!6Rw9M&!0m1pW=4_x@HkU%4emyAG2q||DZe<`x^2* zm-74)%JUfmhr=dw39UbQo{te{%k%wdd46%m6m#S`jc=Dc=hA|WN%rdp4b5(XKgdZo z3s<2T?95Hj>z()wPLFI+b3l5eY#-iyqWN;-B%-GO`EskEt?&BV{Lebv?plAlu&V$0 z@>LpGee54N;Qh{*$6zix^JNnz)j`ge;CBq}xmQ{2pN2!5FK?mzZ}1zOKJK}|`vcM^ ztHOW(d~xsRcC4GTD~V&VZruC1O}2$q`lc0m7+Utk_&7Z=&Mb559{0q+%PTd;AK-rO z$8h?SoEh;rRtQL#M{t!%A^VlFpIZ#GBPTtN4zZtmB`^K#=QdrmJ%H->;Ws#)KG{4< z>+iHbpR#8-=^2okctEHAW!Nei_Kbr|QQjYmJ@aO%8-GUa$M)1N{C4Ci!CvXYM}fUB z+;6b=G{Q~9-s89m_9}35HhzQSp&whuB{Ae&OrD_#{}IY>J$4vyU#ED-rP!1((hOvj zv*|y!2FZLEug>ttMtLC*R@%qlCw0N;W>7=9f$G}TdPyylA0GUc8Bsf4A>xRh!1Yl1 zL0X^F_9ImN0e**!gREJZ`Iu?X9kM_9>Uo@8{mawO5TX6pAIBZV^ep@1FBkPMPtOes zdu7@m?=fC2EkrW+GcX9`$kRnw4?9SC`rdtpOqbuT$rQ#_$aIkYKX7=}w+(BrRW)zR>A^XQS?aJFe2d>$Mou#+8dTGuk9yCJi4QYH#JE=c> z2zOUTs#4s2F0gUx*9wPx;W-%6`YXL0m_SE}qBR~x`>~xY!JYcgswS%Q#?A|e! zSFzb-Y56gee%`rawwZH;zR6U*IeMd7MAHzS@I12uDur+!8fq0O{=GP~&8KG~=b|J37sNVB`SrMMY`;y<#`8O|zjDL`ddsy?;Mz;|)# z@h(mY-o=66^?Ny=N&VmylGe><=b$F}qo9yi@h61OjyCDtWo|wzU~1z2;${K>Rv1Hz zlP7P!j09mf4Io=wJK1T`*Rq`D!F6?Mt_uhklI^Ht?Uv$Yx=o5^9(GkCytwmH=_sz7 zRi8zW$JX70<-Wkfq-(s#^{Fx29GgxweWFT-k20wCX#w=}D*xW}*>k5puIW6zfjt67*xO9?v~ zK7tQzcmV&aKVvq6r5{5Bmi;T8Tsd*U*id|;+K4=TC`g3aoPmTMuVF(LK|jc`6PTxR z>;(25seKxLrP(16&dw z!X<=bxP;*E%jiv({djRRtH##UYGM7s@#GRWmmiCkG?$m3$UH?d7pxF2e}HTp9M0sl z6n~Emf-z}dfQ^l{u!E`KWX!8>bqTFRitwKyHE17ROjVB@oR66b+51|=z%c9-wl^Eg zA%K(zQ4McDf)^|@4cl}iI&BqUCKOwSdtoLP3h>UaR?i@GSZ&;;tN@|d9l=3F(grra zZB#!80>E00MwCB+CbTFY0p{uiOEJ@t%-_N@27$kn%)3z5x8z|wK{DHSo9XgKvz{&; zxM~BH<$CTyu@yvBPb2T%=iMCMk#aq=csG`Jm*Ebw+;_Lf^Aoi2bNp=lzK!4a@f(hG z&rrr%hMIr;f~0fb-_=!AvU7%HmddW2J2WrfU1IRo0gAh@zRyU)13>Is$Vutjer937 z-=DprCH>AUNq?F%ANm?AbbpPcr;z8-!D{!hWDYm?e~j)l_n$8dslxpt#ea_+vj5}) zUeoNqQPR5Y7XR0~q@bP9le~(XKG|>lmAsnXsT!G8z^Q8T+r`GG;oAy@6cU@+$tO zO^!8q0%Je5$T0TYm}cyoa23WbyvO4if!{yZ-pICJ(w0r8o$EXSn(TiWNrd*3*~{7I zclHxMB{qPwuYAeithiO<>?m9XXDa3=tx_-lu1p=Pa6H+?52i>R;Hh3c93;eB-jM*$ z7xpZ?KXNk8$BON}M79V{Fr9b{zp6X&;;JQ1K1%C=k6Dg!-VKlO0MQ`;=HnI=AtpY} ze+OvoK$QD5L19~rm%7J#@cj#J1_8&!OH=zrv1t~shQhL2AFXgC5H$%ka(Yo;H1ZuO z?}-8_K&z9Vt>95?4aaasi)1k`3$~}Y9v+`F5w-Y%cs>d=SP~QmyOw7%0TvpI+$J}8gIiS9e zg>!?*Bc&|lwl1#n&LtUZT9cD!&Pb*R@j?*pL+tu$<$$s@i zNrvBR*)#lMep2QY6fX%ay(18gf4FaH-_nMw~rC zc)u15WQ>52^jvjp>Ya0WUQ&{Nj@@bDLq+^d&d_!Wzt#ATm1RDTCF2iTMC;JbA@?CS z`}0!xzUiG_d{||AMx+=lh6uYxAl^wsdF)Nq&tri-2@$sadJFs~ps{~e>p^|l( zeD$0Zz%(v#28sM~3!m+>VoimfXn{3Yx9v5?*{2ecUj|j&0 z=0q=Sr$+607+8CjtNF=5dma;P+_(P{f8;EaDx61gERTPAfq(GcN=~E`pYe;lC>TxN z@GO}lng1-M1I{YpIEy@yNnv{i1~{z<&{`q<3CKvN`N^5(U`)&p8SgZV8K09&4Y>%U z9EEvNXuqfypGj&tWAx>Sb_%`hBKB`(oE43Jo}8|SX-0=$;FWR) z^glX3(E0WhQmDieEo^^FD3)3Z3Zquoo}yWD3JA4`uQ|MEMl!|C zm!Mgyn&C%>2z`02=nfd;o?Z^y(14bZEsNE^fxqpT!S8*H(Mu%D0Ea-X0Pe zQ=ORXZ7TzzIsnYuInfV-l^5qlhD&2TKSJqh0PnRb>MVTmjQYBV8YY+s06V`DmkgtA zU@OE;J-+)A0V{7-&xAX{ za&iB7#1j!t5HKL&W($Ud@%xg8hwTl)SVd0c&fbpd*h-x6)iLj{I1(*vpNJ2W`dZdXZ!`SrJ4F;OzSeb; zFwGmTXsq?M{D*#mF?1DJNef098)heLA_#tl+6R)2wLRZJedxp7ZNb>0mq+GATdVEM zU(T}<_euaUC|~web8kYdW%=Wh6lne!KwJ;Yg%X)SL`QYzQfR=k)1rGuA*6vi(eH$5 zeXZA^c&MVxvB6OCRe^g(VaVQ6W3Ls=(~>?GhK@P&2T`MG7#4@riPO#yU4`9KIO#n<2vchwTUMj|{ng->)nUsa_ng*^A5^sYg zcpTL;%@u9eJV_3p3!O zTX9g@?^A~&rQ}~2eW62q-z2f8d zd}HV5;A>O-VrXIIW_)dGB1|D{#;e!l1~XtG<&``Y{Tx*K*HB&0Nz6amg5ipWI$z6K znEcHjHHE?n~aMHY}m|xI)ScU*nMWw7T$WZNZCG+r& zpknBx$Tb}5R&>#4!pfdFh}xJ!nyUHCC*cj0>< z0BBa&zE?P)%FZjUwpW_(+46h2W5KWT$y~DRU(inS3@~bSY|#sOILtX{=e@x55s@CB zvI}H=And4v}(Lb3& z01^?R#8KML_q=Phbq*)g(L4CE_q*y6L@S_3TKHi^do6V3cnDT#AYaS#0I0Xaf)=V= zH}Bobb>_2*B8M~8OMp{vFwIi0*Dic5^mk}~<8X6CQ7}E#b61ja6;SMJJp;LE-#lzz z;XN3+4TVom%aYqYy#U|QWiO4)i9jzMh9uDFkAmsTUxH%8M?j2Ld*C_|PmMXzDkuQh z91ZopmVZS_M~|l5C)imB9B&eV5%(y!U%_#6l+l_D>65$`z4^2C^?^IkjU}Iihv&EK ztANnWj>OV@`=`kOJ)w0E%oc76m@oQA4th^1AKE9ecPz2KV@(Yn*jawkD7MBr6tlZQ zD(F^S?KOI$6U77Ze#YZ@=Cf#6cC~@uLL2yvYIG92%j-Dhhtwn8P)l6=>Ki+tJy+JI z{QVoTzb@o@cIJbhnw6inFRi&z!GyKnzSy4CQw!CaviET)VL>}>%;aPS_@1oB_i9x1 zT`CyNpGC!uv5)hjl`tuz*Rc+DFw0e=9Oioc^v=*bwMavvRDh<^elwzqI&@?fA~vcy ztl~qMfc3x@Ct)p>rs~>IsX72;WKTSK~ zKnKT$uc*vgS?eCyI2l;BFGlb;z(lCr6a5`P5$RX&bS@ne0(AtyO#^!!b#pVuX?w9k zM={q#)`lVn!@0a^jAg+%)em3PS!Gf44Ma zybRK&#~C0f78nI_RF3nlX{m9hhM2}L&(~zv?po}c{mD@TrIvklJ^V%>HGr{0E$o2n zNN!;@S3h^5AAF1;`g=rH*zXt6GWx-HJBLOu!a=|EF9OgO!NjFwQj17c=d&GZ`3P3> zx3bH~(q_qq7H(Sg|TH$H5EByJi>fywBvD5HoP27)mgAHH)yxY8t{H%SEXvEK+#u$)XmU+Y*Xd*SY$ zqj6`*fp{f8C{+gzZGaYTEHY=R2IU09Fb^L(RHCjx z4VWSWL&61qA*83>#Pkv_S^o>pqbXBNdLm-?1Z^Y7kToU?Qa z^u@GOVXW3C^VS9Ga&U-fjlGUriMrL(TxG_Get^frDu()6a{xr=(0l;evm3Ls+OG0a zcuYVDv0egjn|rs$hjMnlitOMob5H^d))4_f2+tvRX{;HwlLhPK$`*>)`Uumid|8zy zt1ca%(%^J`2O2bmZo+Ni@U>_M^|vVc#{j<(?f6h%9OfU(1Qe zvh11g#nJvo^&q?>D;`^hRwR3LX7-&r`w1ueuhLtUg|aDVcOVTz2dfxxW#|N~>|Oig zid!2NToAVZi1-)6n@!dB;d$_+P(Lt?^cV zsbSuR_~|gjdsrOAKFxUItCNS*pC>G_>|qk_Qv2Ypmi1PAsbK*al5t!P&jqiHZ?yV7u#<*R zQIMnP6tELxW?Wr~3ho>h!1I@3Zwjbi1w>td#!r; z0*qvRYe#&juL_GnBh&{3Fx94BPAt_;8_4v9@X7iDKtsi0_Uq~)R0U9@G*D8B7R)!6 z31VJU8lOIhBlUIZ1({s)0Ng0&*ehnJSgoj*_M)(99f*a_Dkx;wMJ}9>&Qo`BCXpTW*%wtVW$- zs^pdRCXaTw#(sr3{$eHb%6cI|sy?*;PRPEF9tz%P&a21gLTx`|gce%}PVIwC3fHF@etBy0ToPiKJY=qW-u z2j6;r*ue%fVFCv24y7b>ps;7_?{4s0evv1WeF7af8@N~32tKYtIOqNhOR z6k_`N5mpi1j_K>46JNrz$MPE=GPvR zPhBBdw#`fMNq?~2&!YG;*rZx9MFV&g)ZS)+vy9ERYR<+tC8QWZ5<^8SsA@YBJ?vfHi(P?Evs+(jTRP#ewKggD_41hxnAD zKUTU@^e+efS(fydI_s9OaIU65Q`9*0)Gz(NwzwJjjx>k=WCt75PsV>U_zfb+xSe7z z)>P|>9v>+9mfBpq1Nl`3NaodUKa}e9hwXbSGU>`BO8BO7e2?$emAYA3G zT!kpM&+YzfoN$ z9kD&5(Lw(rH~sCP-~E`LZ>7d25f8f-`0=PVbcp#@3)DASu`glO9Dq-U^%JC}if{Cq zC3CtBwOm8-8_6++!UT3Q>PAmaj)2&ha3rT4((UObGT{Q~fC6JAYyeC+>5zlG0DVGW z056OMNbn#-V5H<*Kk)9Hk^wK4&>eXF2Y{EtBLm)BCJ4OfWO`|afS3hc?1uMV^f@TJ zTv?YL2f0t=q=I@}!^RZptp`FRAF$@0)zLQ}07yQT<@?Pq&yYXAn>?8Oxx3s5pVH>L zD?HJYF+&Mjz=HsQvs_6l3mPaeCqAt_>0LLi+_P?4g;qSX%hmVMewNh9=zsR${hy!i zzcSrFwm0?Z-$MWAv;Xtaf2HaFd^NFe|KtZJK4kQr+8zWS(C#rNoD&>^lmSD`$FxEO z(QtAtDevtpz#Q`=trSOd;|Jcwh8jfnQ56MPv63PbVbV$}r+= zsCj^bT#R`RFN>A>a`UE5uK7MpO+*#+SBUCX=M+v6k2;0TxaKqMRf@er3Qb5(Kq)%| z;AlgZzfFtgM(K=_sL0 zp4AfF)uWO)19Ak0%qwb4Daza6d@zOHfq{xbjTl_yQCIp)I-UM) zB;iW`m836eW><85Z%3@iGS2$3V0*NSK!7+GaMIWKAX5}l;G%o3R+INZPU3I5hqJ? zFQRHYlf|bus7?-oj;?H$d`3TEsOuT)85cLjZ_ve?)PqvM)?=o_w?x+{QeXd=qlf30 zFXMCZl_O*+Z`=yPUQEKKQwEd2^#~NW^aW&A0G)xGgDLr|$J<9=l#^H8`l9DBk-xzA z^zsb(`vzFYEq_O%&q3uc=L_u}U^#6MYyI{F955HWfi%3-U!vazfEOYp6W$69FUK3m zfcMlacxR!{PYSOm6J9F~Z|MQxwX)%jj}`nvHcht#-a<|g=;K9T3^#rshcos`;jKko z7k*)5I{ZL-4~E~`YdX0ifgq zw?^M)<^y4pkFoTd4*(^4KQTyo=4F>}AEZ3xE#-B){}U{Xd3+B?`))qF+;kh;qPgno&Fd6V%LwK$M zJl7g{u2EMH29I06fb+PL`WohIgU8pxRj^EE?X7L#HoQlXq19^pRs!Q|iAmAvT6&9i z)#h9q^I-}JF|rve1UZS3 z7A`{)hsP5mYjKy0yHKK~_K7p_#@O;{dAeAB;(luvlq^z)>Xd>|;$bJrtCNPMQ-dU3nrS+--Cmx-p}P*mOsG&5|i=a`4Re%s$gOY9*)7w^2o3fql!Br zC~sU9s+_fW|J`@T_6>>F1nrK8VsGWs9ZcL#jVq+>C*X;l|Z7ZfxSVNXAvB7FrceR^%LP>jfiB#r#2t6V8nlIDc() zqTVRk^A2jqo?D8)c{G+eS9`YOkFMU%+sJj=%MbXL^E=ms(627vL`!N9^%x>(Q?Uia zbb?&;)P>FhOXqU;0Nsc--K0V+fST>_vTbVS=H6a>0x^2K4r(OlaC6cnTM*u+5qh4p z|K?aUPUz7AdggWn83}{oe8f)JZ4731t6a2~{H$eP(qOj1tvcS|Wuz|f79cJI%%jzI zy!c|Q+Im{GP%8S(0`tm$S~^Jlh(c#4@Bo#9XkF$Ew0f5@D_sMY7K}F08A|Htt;4W1 z<*g441=?1J3aD~>+gM6+bsJ(Yms+uBnpqo@Kk7qVDj)aY6gW^gt5CPTi}{k-=*kr6 zh$i;q?uNxl7T|U{WCil4gG@7lR)p+2KUo{SuYr}T>auKG0nJP|3>LAG43q*Z1g&g z1m7@8U3wgEW_s~Z!lmPKbqCxUxVH`D;lc{E6Fm~PS2?MZEY#q{zch=WA&-FFj&5L$ z;l3Zx03G~acl>-Jii1FSM+ubRVhUCPIG^mlvA z2d@#EmkXX>#$u&mVLo7%4q)qU#K`^&%gJ;Fv9H?M@vhzb-ph(0X@Jg&9D~p~z$t6u z8iGgXPqzHji*D~*cF&3u^vmyD^Rp(Z1x=Y??q{qx#8e}q3QY(q)D>|@QEhd63L**y z-)YZR$l~bX$Q)6F)ZQLl_LxFWTm75HvMmY0DD*LZg zr1)CvPSre?Jb9Sxf0x5tu=gA1(n9|DIU{Sy6BZ^MqF!Ny)9_R-(+_h7_Ymh(yx9{+ z9Qn&I553YVRio5JlayQl00J${y3>o~&4(~GEMgW&^g~~$S$>qjh(<#+%Eqv6H4KBq z6shNSqGmK;UOc%L4WwSaNxhzXF`0xPuoBo#+{sLn@b^J+SVPO2h+ByLK zj+)p9f9qd9bo`m`i`D9v>*Q-T!hK}DCII14F|dFSH&$Q7Z?xSq|d}_kr>Fx*%*Y%{*QTZrqm$12QJtdzl0| zu5fq{?PT&E?2R<;H;2k|`TVvD^!imY%ZPlPQ+lJo-~-ImXr^DYRjhWugsUP#SIhPT8Lvl|q~F zr$*b%7Y~Z-2A;12;BN%l?H7LtA(<(gjlT!qPT?;x>Ql!bV||0*FYkc(yX7C$sqY5-Ef&*^y*`xLe zAKfb*APOa@Zy*!b6DzRBtAvYTjdK+gNdY9`*aQhr!7i%8tKDKTmC8CRwoencu#4o? zD9{3f(twal1u!6ku##J|h5>tq{69E8ii}Oyr}kh-IPCW+BzVotaUtQq4E2cRe+m*{ zz8yRg9A_6-_g1OJ?=%b6Ame&!@cL;?`*p%4??th+-y(Cz;gX(_&Lqa$$%1DvgdX#+ z^dv(pYX6&@&x(?5jCwFO-u$;^H%h=7hfqFger}bo9yoT+Wnd3rs7QV&xO(T0L z>gXx?o}Q8&cy^FY-p=A>tyCV*n2Y2BR$~}&@y-EI{}c)s)N`7sIutahuYoxXG;1~$ z)HgVI<_OcM$Gp7+^VWs#3@;jZMs(akwc|xQ*ycznvDmwV?VAR}_6btZ4AsTxSr`%g zLLWJ=27&{4d>B+u7#xikVvb@gsv-5dJ)F8)s4{a9RJFaH(jlPA#c30s#U4tjfawdx z-tz}s=p(?9pYP+F;t_0l#N%eQ29G^!k-ef;$_TGm>b7GzLWcFDPE&Nf(A537gyRje zPY_Wu>}c4*ts;1T@3$Zu4$2a3ys%W!PoP^?k4&V4|7Hi2UZRTNxD5Mc{niDt%GJNp zc+>j~M^_BRCL?*H1a<^I_|j=0-3J#zcFCi+ZnX#iB7ayXWET5DG>~E#zF>fzy3nKf zn1b7Ne$Ft2pX2n8^ez-^VXS~g!<2CjzCkN^w?XD1WcieG!xM;6f;p%m^?ZUD_u^Fy zoGLcGRJGHefpP?ZGr>n)>X!hSUNm>8c+sGGb@NEg9#QV`H_hzWS z((_2|kNL!q0R}*IY&KM%&4wyqpo-z7nx5k{KwMpL$AjhgEpvQU#=%<}y_@V{Ry@+d zcde{b;7lFaU+eco59=JFxl%JnjORFU&?jTiT=R+k5vE-LFC)XWlFh?YYbe+2KtM#E%4>B9hOF2WC~__hEUXd60-GO=RtZ?;QC&B}725I9!jgro^j*u;lT;wd3LQ}yjSAthA0iP_w z2LjM1s37LpR2-s%m+MXB3Y;?)RM=)HGF3PR6qxFFSVxN2b2-5FSaH0nhE2wC>^r3_ zr6@eCVxq70XM|HWLH0aC(bM{F^!UUTkf)o}c>?8j79G)9K!GV|r%8RD!}1%8E1jp< zwO*8t&-ALHtPq#C>HN9^o4bVK^t;GPhH$z=#T4(nbK`&nM+P;72oiQh+GEuhFi~SX z$|UN?7z!=B77?Ru5gj(}-4-uMVml{S^UHQ{u`_uD$%P4_F&a)hT-*!*-KX`tj};8t zZ&b&x^;XAkEv$~u_g@7!iHa1CQIKmeu)kjmc1|fmk|&5m)O@WI&{MUY69VQjn_j@W z$-_bHp{ugHkTR<}F{P*`G37x~4zxq=eTI@y6b${Pt!T&PFI_B@9ihepXm~8l1y1p< zlTYQklOizgMyNs=TDNN7*W26UWmQnU9`ZKWPNk;)wU|SP)P2bXq_H~|MGe`$Hk1dK@)L(u^=)2Wa^aw`$E_%t3^G^N=l230~ zc0(Z)R?uFE!pXUmBjsp1J-VwQ@xjVmiq(pUvxhA0h!ZHGbcEj}PSUE#0>Gw0_0c%U zKaD!l`U&(3T7yk*MYKi^#!AKJDQHB#a1ByKAo)Ss@>m z(fVS8MV!)Kq6Fsz~3bh05 zYvo!073cX{|Cnl*SjomEYDrrLsnV3`gRKG5`3^39EsS?)V85Pf)M@Y^0XF)Diu1U= zmc$lOnnmz~0J1QC9tHmj2x_yogiu&&84Yem6Nre9tt}Ry#8tuP_!wM{~kmfHhL*RgNS+&Xj-3vV5%Ij`G6n2q*G$ zXqY6%Er4@NVI;>&Q-b~;ok4nF!go*^j!+@^k8JN9^sL7XuWWed6g)CR1bTpIv}h~R zEyFP=7-7cy0KHf}12Vm;jm^s>@n75X5ZXv#q@VHosiHVNcJU?OB-)Tqo1B37GWZNM zds$6odldMIx*^HjUhEr%1@R_J3Shus>RpByH`=7SOY1}Q!b!;eN=s1@jlm4z%U`dm zzrgMQrm-6d?T%1!8AaB<9H+&Uel<`-!>V#=FER>yE5Ki+z>VznnSsV%RNoP!M&AA{ zWy7to;!p^i6?8eLVRP-T{q1n{0AKbC+`9eq((P{*htOce-~s#v-oCVm!J2BjqXvd( zZz1?NX11}I{b?FE++fC2%SzPE(q$BHOi%afb2<{^o&*!AEykR>iG6_yQZL%O;ioLq zLeT7n68;W=lT!P2UP67nUndIOAY$$u`<*;zpzS*>RtI|&@e#)fXhu1*bXjklKnw-uKhlvI)^ZDAqcGl5J5DV z-u2^%X}pZA|FVnv4{}~N$u)hw_oP~`^kj0m$lmU9t zjbl2XBhnE!{q~X`VY)xrA2ba6Z~0~9Ph~9ZCEb1r_aF7s{y#R9bo-?PwBHv?2TKcq zAO5csZ^Dl6eUu`xCO80vsf`yDh5^PtHmI*-^NK78IhH^74eIXXwWxILAj8;qqDbI? z^mxh#7|%b9uLjM(0eAZins;>!8=ha-9zwV+Fp%(WfGmaMWSK~V8uCQ=n5>4Gu2~J< zu$!UfNP$(E(@EqpDlndap<+6~&g@}h25*KQT+j zgzO<9yx!Y1f4DwijN;Lw71GOVBSlKo2J<6-vP7ka;w6Ge53a#ArcBqRlrs4c!m=#s_@K8J_j2J}~WYlM> z?a6GX7W?_p)MtX+z2A{nRk?EBE)jydEeo~<_QG2$cji^+P6kpL;m9&KwEoMK$G~d^ zm!=p6x35E;8D9HEuz88P$V*)AB0c?-kqBU1fupm4i7vGoI}_|95HxQ_wW_im2vHo4 z7*tVZQRMU>3Dc1ms(hUQ&M53%#Zx?C^H_oHdq^^?) z4oxr{r*p{`wHzFmgNz_T7NH&9q=f}%n=8xH3KNHaI}d%U9zqG|9+NDL8B z8Slw^p&D8agLuKqQ#WvE{ZUJMxiJ%ZH;`?@7<*(9^p#yvwk>2&4B=Fm*YR?|5PMbF z-nIzamjP~K%HLnWn&rx(-VU6?pW87bariJF&%4dNbXO=B+eKIU<)OkAc)gi=K%XZ+nm~D}osdgUD+{78c&iSSlo`?_R(d-BU z{Uv$QR68_&q_y%*uuZtQFjNurMrU4ZUp_t$_7U80RfJ6xhy_J23|1ah94YTzi*tku zEAJ?p_f42xG^cT11C)|c-@`hmc^M*0`na5cq5G@jx#9S1zd^MiU7L)u(BZbuMBbHP zQJ9CIg7fp$1)Q~@c@U=Zek*?V{jN2 z3id{}q~3QmW*Ltcqy^Rqn9Y=SS&ZyYY#^{)`VeJz7y#2pZ?7oZ4dX9t?@e5Z5p1lo zd&2gg;!%&<3og|mF<;9o@VJ6JaSJ|aofoqr6faTRSpW6GIYf@LE2Z@bN!`skD<&s%35fQvx?`wGpjfYSH6Mv7|D&hb( zp&ZNGiBr|r7FJdM*Szl%e?X!}Ll_L+xT2m=0sQ?~z|%(u`&yPTEskJp{%*YZj3a0< zrSYR{BM-%dq3`PH0dR{|BksY#r;Ne&t@kg4#c{MAmx|s z*Y~yRwP)cb@ujGx=)Y5+g=N1mzv2EfVZRxHW$wtzRa zlS#m*dR1<^RkvLAuo)-jmsI3<-U4)^*VVYJ$bP}YrKu1H4%5a0u3oqUZT)ID97l6x z^5;NDoQ<4Zrx{-OFSS3wFGq(ctbhkQ!3vmo`&W?cJ1JMkJ71mQ!JuI7)J_TPq*pIt zf*RKpuK`I2dl~AlD8(Q8xR5CjEQqtKi;<}V1d-3J@Jsdj5N7wQy@_?dH-e>UJ?_)#A3W8K^?^SmLM<&iT-h|;f z)7dDZTJ*|r&P#z6&yD>(Cwh4AxL5rsAD6H_&O;z9h+T0JaHIMIn$jx6U0t{2cpK89 z8#vr&`x`@h$KAqS(Byr(Nz`&VO)!EWJ%&;Eq3F3NieBCFFO_fJEht&tJFWo5KHUD9 zj@V8*n<-hD!jE`e;)?|R_P)gBg@qq(h2eVKRw%|I*l4+3)sG#M>XMi9JgOBWa)vL%v~V(Oq7G;3Bl3u9@g}dr>DU;Ts59g9I`q-~zaCpv2-iNg zuW&w^{qQ9;dwQQ{u_%7hGi2@FaVMFr)h}9FH1pU?90o4JT2l{BY&kGRD4$?+zrzA# z29&+yKEQf1W1HRTeSGE)v$q@!(L3&CSqIO8mH0~23+y8aSV1%~fsH)jV~`vP z9-!g3r|qfSz5rYVpI=X~eCu6MZD_pFY+?p*g;!>P#sS~ZdUfJmT(7!{wBmijy>_S2KKC=ZVbUcMIR6+7@DxjAFadK4Qvj7=RzJ{X2QUvgNo7UH>(f0EC!#T`BZ|I?#PS= z7!^dp_6%s39)NVJa)75JGl*ZZ?52agZ$Pl|{DRfQ}rRRx)y^mFfXcHqpnm-ACdVyCKjj`s{) zyRW{KNLL2>3quoKh{nNp=pUjh`3folw?%_>LZwJm0pvnJMq6gu!4%uYN&tL}1ue%9 z0e*(g4Rry{S9e`@;L!U3bP(dSKY0R(f!-GbG$c?tP?hasRdHigfhdV#TbS{Ky21Ft zNy*+FdJ?F9Z2Io{ir)Z)jcKL}BI%$Wr@i$+wpM6DW{S}SADRjj=s$KAy!KO7w8RF+ zh=k5NGSFrX_^n~vcbU>?B69u|o0wkjc1x#m` zV*I#tJyq0gG?om^$bhr>iiu}-3S4%)eLBDhkgg_#)>>!Ql%OFCZ0cKEqJJ`%42<(*cDc39KFZ0(2f=>yD=& zMA!5Pokp=72@w{MB^!j*rMJ8Z)TNhDdFt_7>hV)^X+Y`Np}z`}cIczgbr3v*3d9mT z2Ow4^7d#cE7pWqrz&KQ+Wv+uT`X``(*f0R1!Z(3a3nWnfn5Xzf)%ag$Y5;8HVrI$& zQ~+j*05eevASm68BHx{-Q{V;89S2le6ig3z!)yRF6R?0h(6r9*fMn@r?+B1#3+ihk z#XJBrBp|w(U^RjOtt3h>dIQP3Sv8tq5yYrU$-qEy)IpGW9fW5xz^eldf+NKZm~(+I zcj(`OlpTUx@I?P?7DUGY7NK|JfY!8oQFAyD=g^z#5Jvr2TaX*Uc}6tJ0o(6O@tfdA zHT17L#v0AU(zAgY!7oAWlcHAv-@HjhUW4e_w%vI{5kU8Ch^WRBbhhF{QU{87r#pTa zDBN&B7QnHGCP@70m=Og;2^&onkq8R^ND=^p*-ZkM|9gu8E`3|5gh!Av-iX~1?Y z#2A5D=?4b{6K_5n4~Zf>++4uQyTi?ceo})cc&p1{U`1|&qCa(wcnW-|EA$V*?k!|( z1={J?9dFr9VLC3gZV!%*9$z&)5uC+$H z(Ezt7$(hTbJR}_eyAO~RJkYrbVnI*0S%yVH6%l%C`k==4f{(*8> z+7CgXyi{qJfU9_9jex<$ACU7@+?$JTM1mCL0(M;hF~Xknvp8y8Tj>Bb!)j} zkZVzVuR7jyIUp9$DN$7z5uQv`hcQCGg~}d(np|DF*OL@jobg_$OLu!x$w9W#=X^@i z?VgiR3%{|cLvx}Y{~YYFd+vM(hMU$ICon-^%p4m0&%rNEK`}AVlz}L!cv&uR>&$w0 z_&ClSE}HHGU44gp80@w0aJQkKx6#j3^fLxLq57f4My(nyW7q`fhBq(^2!VuMyhn>g z&^)4lgAxvwy>$q9o8dNGzg+x_743M z@D=hg0KS`bq=U#hdTxRj6y%pgQqO?6FOiVz=srUC}{v&2u?h4 ztOnQ20wm3WvZlY44}RotCNKp}K)u<`^&??-Az%KHuy^$Up8m5v9Ff*g=&lbSxj&Bw zf4lVn>h*u0|K1r89|3O+eBc;Jih-NMyYb@~*nojgFc3SU5={6W2HwEH%NXc}f!Y`- ziGhbPkP!okF%X7qWe26AB_ zBL-4p;P&8dKR#g~w%( zLLd?8k3Pew4oxT?5N_Bt@UIQ-{L+57+h1HDKj9dHe-ID-YqhrW&)wM; zT{D#Sk9?NcFymw2g(2`=NR0`@F%Vmq>@Q(#{I5_Olg|PJJuol?1D|0a?7$z-uf?Cl z|JsfRroY&J|C){sCu8zuW8fnU#HRlpeD+H_-I(zBFZE!@`*-#ItJ8lSAGZFbU;2lQ z{}l>a=JcHJ{8VQw@`#g;Dg{{Uc0U834e!s-QWI)hE0a9{GMMrx_ zO?Q-~CtP08KoBX6KtKt2j^cj|hA&%QSL_Tl!ad#kVQthjNw!$v=+nNYjEHNDGGjDMHY>*&{W z_u0B46z5cW9=f&!@)b6JmheZJn>XUp#pRkzvAEz&nI?@m46cx{2*0^hc4QSkmw@NW zqgHvPA<}fX_xeKvrw#&V?Fug%SDMdFBP`8zM)^b|>@ zTrY{p%j0d}T|Vt~$hX?w?YsJ$(#c!5LWQKjnF>kT&hEUkFQSja>}};am&J`q*>X>} zJjqQtj2xRf_W36BG5kl1#iR&YukxWUx$0o^D)RiZp*Sg{NbOC*_l-}x;!ixhDBjOa zBG5}!*=d>BU|y8a)o(#vcHZ=TZBf1`<>yRqm?;y^ttQX+RUWr z!IKX}(+ED%<*&Vwyl`@sOOHq<%|SxhnWFj5!H2YZ??{}MHIzwPO}DOV)sAje=(Sf$ z-YAgTauRqJkXV>kU^svBa-2xx1pKVmaPnpTkO8VFM#n%Yt%#^6>*{B|43xHIzgUvs zX!FxKp!@#bm*hv%Z$I;WE1GL0GZ&Jt9FUoDutwg zfD9K82ZoayhGU5c!!bpug0;;C$CpE#K*$i{gRd}z7(#@Qn4b`bfPe@WXFsn43gvNB zNXXaMSI`Dvh8u(#f^IHC)*fC$9?p(fJU~!EHPPbW?BEk1@BlziLJ?F@1U|q*LPTgJ z6v2sq0TCENCq*5vcKPgU%YE>dYB!maUfr;lt-57)`|Pi%!H!@Br2tye>!K_zQE(eu zPq?Nnc)D1++1R=v`4NYpbUbp7KTL<~xVrwf;p+!x6-M-wLuoUfnW0<`Ulabg?OQ{UmxH{< zaUn49!>il(=PLx6na+Jx)qbUL@kqqm=d!$0WlQv$sr_HiPDLG3<{y$Knv)D}i84&< zTRbe%z@R-~ z6L;{Cyh{h{XsXZkMcHS!&3q$-U3d;l**!3ws;VkE;&6aHBN>E7ep9cuB6qO%gM z0f(9+0^Jqqh2|}d@mrPJa|U&C0)r1-9z59?FMp^1`^VwtXimm=H~oXWWOc4(KX98O zI6*))p4a56u@Ej1bEEmo8~F^U@}Yxj;=Z338MPWcMlxqdEBNDAo?PG?qmXTlJp15g zBXXzvEM?i93rn*?)emDHOqcZ-J7(w+m$#Y`2g!9t%BDf(Z6eEe* z#`Fz{?;nX2FfGQLcyJHZc>9ZHwZyf6uqq7S`gNKAE4dHUgwlBr7e{MHl#3r+(a{U# z>FtHGwE^dJ|6~42`zwEyK!~9+m{#zQy9e=CEU&e7gUj36cse@y z*t$VX79j!t#1N9AfYAabixfjh2umO&MWjR}O#b~H2*de3r^SIdEe_zcI5@C3wY>$J zPNX%`Igt~=u=`I-5f0agUS|6@q;#Fzh?97yJ7?(A5&z!h`=@CAmg6<}Qm}%M^F?R0 zF09m6>Q$bTCPJ!7UC|4KOZ)L(tg%cEDlU3|AX)IH63$&40gZa0st?)&nupI8`uIpF z5Bbf@r?2PC-;VWoBgr3~e~;_^&C6UYPuITn3o$YHzZWJ-(Ie1Rn00ybP^JAz`?p$Y z#eJd6&ZlY?O1lcVwHSLlaJO@{%H&1bjbDC^s}?UPV+!7fgI?LO<}FXdZw%5xe+ zLWptKPiMrRDxxaj1cs3sGccx{HS+flZatG9D<}#xZFZ<&d>?x%!+EpQZ{y360xYM| z1~a1mALTS55MAcP_e1!G(2+$AQu*dO6mQv()W^7;#b-5~mAPen+Yq7u+Xaf{G_-%h zX?PG^yX%zgFF6gwWHS5!Get8QafB#BI2(~I7hOPZ5wa1zw&h*xdtRhL7#nMn?beo5% zjxS_S5w8tso_U!6fO}HOnS-iAkMF|e(L_3z9@c3$6#k8hMNvhivDR=lrUTCoIgZ5+ zoOtm_*L7Nx;hmQyCoRu8g>UM{?e$|E_YU%p)Lo@vj=McsSYUd}{m`mT&%0jw;`r}N zcwGfSv+2>2k14$9-gzFG=v=)|sA{v>cc?07xMpR5EKgQZAt}4A(!$JrBgW*J%Gq$=5| z29&bNrxlBszb$`?Jg_crg3&{3`aK;#tYD?o3N5*0-Na{9lm|L^pY-cEW_ zfjedq_V>R%T~uyvsp|6DUJy?Vs-#QW-X;0|v#JvjI!j{mZ%}Xeq-%9b z3yM6I7@C%1=SuH!e>Od3)-w`aJs1?Y+9{kxEz($gvc~KZ@1*#7f67MOFXfJ z)4evG(K0FaXEAtrC*sp-EfvbHhdurTckjBTnDbG{SvKn;zv2B`x-TL*9B*cyI6X!t zcZniz;?BLZYQ(0sqaJd_RIS#|eZitATp>}D^WLlu{-O49UtY;BSy-=Jh7aN8%jB}# zH$epsn(>QZRM~BuVKe&K$Vn$BS{#ruxKx>~%d!OEALK0EA z^-%W{nXQ4|`j0+5f9yL`-vAT4D(gXgl3<9&^wR6;;|0y*?IuZv_v?1xZ`l$J_GPYJHz?&;y~iMFF5c@f-D3K=as zIt4;EJxCsd>$;<5 z+t$4JmB)mJ!bsYzs1j>Vj`#bE@e>O4@L84@;cSJgJ$cYCBoOt0DLikGjdqgZ>33n& ztUsM(TZ-BGAsokZESH$S<<{I|YYUj%|Ls;TJ%iOu0mbM`ydM;d;D*faC=19 zjd>r4B!#Vyp&sc!PWt*mqQ&i=f#O=NZYXD}OzEa@oUWZBcMf+`{xR-^rExw&jtU+* z3{m~})2iKu{xSXlg9+_-NK<#v>ePvw*S&Z}?JK66uzk`W+wAOpEyw2^K7U`xp@I|W zdq8Qxc5)6_YuNodwyu>;z=2u*|`LSu1(^zrJthUu}5p2_&8CSrKw2)pXMosqqt z6~CPIN^GLTtA~{-;_*yex3jPGrc;&N7ZB5UDdaS6#YfoxaBp?ZRfWp1k$kAjGfTH^RvE zq40`syfIcjEgx zj)Q{_Bt`@$Hah|*iUA|uxm$aA2->>sO0#aZC}5{Y3xY=whY@_)JlR}P9D9rmdol`n zfkk2KiTp+E`~D_Hjof|lY;e=^zI3hqYWKIoY!PHoom3c;{Q)Szi4TO^5V|D>D_VV- z$2+7j=Pm7sv@Z)*-ONCrMDMAs1rf=?@W~OREcgZzf=F=wD0J_OglrVx4O*j|B<`L_ zyHXU>|Lj}~Azbpp z(S4>5m&8upi&MG8yc&5#zL{7FOZ?4m zjq2Tq8ngU*n-lcw)SG$DPVeVG4)AVwD-ht{e{4WCj;=nfIuq}4{3?FqaC!ayk(fut(QF>CqDrag;{Cg*dr;yz z`vQEUPWrtM7{jG;$kU8^AZm1-i}t($2RA!T{HfFDw!%7$QypVW9CRD2C~zg(Pd%|a znS9|e83ED4esld~?_uRumheg9r^}oj>1>0Cslws(M!aEyo0A+b)QYQcLY;29-jwxq z@X>PABvGoDmrthimC6~1|wdV zYFLyV8H*!T>zrhaKMym3`sE?6{?yM!Is&;W13GIbzIR3tdgR|bp7XifK$Oui=Uu4l zhqfiBzUE8LxZ!ev^o!0JHfB@Z$EJ(t0!*W}+TZ)Cz09?JvtD(h@*SD^m97p1voLEX ztM%2qjgJ$k_{>@UyNG~n#sid$WYcHv_Vu{16WL$9bn0&0lU}=fS8!rVE^Q*u4&*=A zAtrfAYMs-^kw0^5M2awN)h!V>Ie{+VM952)8`TX)o}3TM4YHd2PmzqO+fPcGh`E!#m#-VOJNvuIy(%EXAPdXyBg?vck7t}&;@=4<+wjV>xxMkn} z?Dg0@lbaTwpl@v|zJ|=NQ+M=TYGcnsuO|cb-Lm?DvcWG|%t;152WC02)tGkrOT9=K zycW?!tZ=2D zyZLj7?Sw9__vvl_ql*%S5qyT^!~Ol~1};-M-;E+HIo zc$o8%C$yGn@?X!_bhPATwJkZ+I|eKZ_L9%R=Z9nU#DY&?6Yk5TM)5sf)h zSsBX?$H}uz{_hwT;dcvGPTY?x$iU~mN!cdxUi({u{2}~|`Kqo{p0$(2;tx56tft#= z`aE6-hH)O*k0fsrCrb7&K45RuAZ=tE`zRqn`|)s8yF+dR=?BMC@XqJ#2B)sx<#ZTE z4A;*+(m(xj`Wt`cY7I@6uHKp`Q-U9fc$*~yHv?JNH7{~sRQ&+htKX;IT%dPOMeqo7 zQ0o-GwCX5tM1i&V&}z~62DJ-Xmoc^fa~eZeS+CY7-8DgKd-kU^1W^RZ4aVJp=cyls zoUNE>=J#$7%z9APbCXlTy5Nm`j=*Jn7VYN&mB(3H4e;ZIbgtjOYcTtK=l)%zXheDF zdYaNUlc6-f`#Y7DbfxcX%U{!SW7s5E&t4q&;m*+hnyt5^nC!#ZE8J9HNLaVMRrlq7 z&}A#!Gl%-ba<614*jSjBYzps4<3H4pb=qj2TIBrZ+&)beFG=xoJ1S7Wi&(d5K>PH^qZPanz2RPoq^lM2nqK1<`{4MUu4y|Ux>+Nrr9hHvrdNbBU zqCPhNYNuaU{#NT}D>jbsV`+^WOjf)_wj4u!$C{>-N_0EaI-elE2T+P6Z!PrFT{=MY z@VC3`|Bm&IApn1ih?sn8)(?1B2Cm8szvhanyg{UkiH7w(v;NGqKy+O6zNt5vu+O2L zfsD^k8lWFtfPPf$(hocw7xrIXGa@u`kNzvChg3xCkWSd zw01!I;-S2}{D7Z>t1aBo6>jTd>x}XggewA{9XFu-INLgS!c|-zh5^y$8gr5oOtWa(#eWDy}R z=MU%JbgprGAs?}Rnr(zq-p50Y+x3yNK}~bIZ?-h1koe%A>_$R=(HS4~VuWA3Gm|BAD}Ay>iaB?Pjwxqkzm=%?|@#PauOXM$eOS2yxDS zuL)`$Uzwi^YjH99%I$BkFP}DtFsn*7t$%3D{6IoZTORY3=$vD zovfc|OVgXGPq6P9Lvs_~JRt=Q7bRt$XtT)yGC5ZbD3&1HnV^8u^)eLu3!Ird{MNngS`6b(-@882aAMqR*#3+T^(8#-XR1^X4_vGGR|7|e?G3a>Df ziJQFcX+qN|C@tG-y0KQlk|Ij|AT4R6kzvP;kIGOy@Gp)BI=2_bekZLo?eHrB+iPJ^ z(nTIXI}3sh!u=|?ZnmD5E{-VR&S+riV(Vt@Xz6B&qyiN{WQmp#IA^IC$YD1Q@o3pG z0uua>OQJ~=5;#IZ20LNk`2>`0Cyc&YT}qL?J3TnJ~LKXBjht7tBkV6P1YeU-MN$Se7rf?Y$yi0~vUuQLieMwKq*?gI^{p9mq?_Lla{K1zY)C*GcRboCJ;tqY&UaHp_ zp?Nj89zRccsW&d{jl9HcRWj;5*`*abaw(Zgj-}M(q;IW#`1q9%W(DLQLi<*9igZix zniYAr{HEJQEwrfvSYA61sT7(AI<&dnl*6O`F^pY(M6sTvVgE|;9Y5nIGZqkSzC6$^`3MpKB9yF@1pPa5z)34}1##s_SE zz`F>+feizj-~PQeKj4%qXzybwXzTR{c1K*mM@7NP0S3h|Tz(MX1^=9cr0D(eI(^`C z3c|F&XgPze9v2kBdBq-vGYFG|dBadJcbF&45oQCk1pjdGZwsCZ;OPm{9AS3g-x{P@ z1Na5z2GVpuXaVN`Bd-ex!(l3*gd4h)CCmlnMS)lph&KSx1)T=fUV?;jR{yGp=fJq2Q9$FeM}M;gEx^H8yg~a= zKitv%a0TC>UPE($9r^BPJV04n(AsV)RM-D(uAmy==vu7NeS+G8#S%G{Gpacr$0Xqs40)M{fKS2<724w`n=zKtJf*`LKNVNv>Uclktr~fw7 zUf+Np>j?7R-s8O-Al4__%X*&4ZV^Sz_vW}($$9*3;Qj!uD&Pr`hzN}fq5Gpew_I*J z{pZL_82%s7Sv2qEveaBHYmvu2{P?W*{YKZe4=E?|9InPZ*Lz0on6poa@dUT_oxqbH zn@C1hyqjcSJ=DG_lefRd71`A6MXLH8?z!OJF%xdNUpX1)>Zzcl3>^}oHFwr`x6XAX z95!L_3Rlsf65qntP&++I*J@+A)lWCRl35{ok(8%4?d*!*(UStRkG$~3)~ z>FUhOQq3{L4BF(Gmam>^>W_Xfsr1+Mji#8coZHMa3t(^P;zKoGS*2^@;KSdzRA0#J z9I!G!_gwC-gi-yVx6nr5#vBGyzamH5}R^Mjqv@v26M zWfpyRyqoE7CdR#4TA(K8n_3`#X5!@-r^m3VdLD83az2+N?VWj{JGbnc^97<*KE-X% zU#CQ^@T=hlBzq@pr%T~T4W5jh&h#lfp2{c56aO|b;n^AvyL%pTpJdS07w0}LpdP#v z&r$FmScYAnd^gk~k9X?4|8!7IbExZNM0ud`Yu+Pup3BDG{Dm-B@w z-gbT8bYQDD=g`XPlhJo$FGK1s#RL`5mP%D0sjlsD?)Z|&x1g9Aq?7BOD#&z!^~;&& z{YfdSNgc3m4(%cO+Tn+^*3Mev({W%A#ESjtqU?%XL*q*WWQ`i7HAd$ta9p zoul6@`$G^9uj&}La^gw8z^KfP>&(Vgwsiz=%jHdF-osSG%;4)ZVWVxsS??uOc-ZI8 zuUpp3*%;xb z)uqlhr$=b57zh!-E{7l|Bt0DJk7Iy~3;UgI4{hP*I&MLDfo<{V@z)<8vSu8?AzNuI z8&N~9n93!_l56g`ViX zpDb#h_;Jo$Nl%)gDE?iOE!C&)1XDYyPT_)K>a=GUL~mrJd|8V+(8c0)KgBQF!J}Rz z&*Q`JfMklhwclJFDJAiTMj7AmskY2+* zg+?UOs5Z6nqqj?jcd^FT^|YPT{h!k`X4byYY#a@WlXSyxpXgJfzn9m;cGJ{)hU>jJ z-DLEA7UNaL>sv#h{MD@T@z-#^OVeIznO%@`(adCPP)<$`!I%#!~P?*5H$9e1RJCe%!bM~ zGCFQ6ABpw0qPlk;+dral;cx`3ZH~+ZB%P z{qK$0*vjx|nJ^jA1}<=5N7EMN>+b1{bH66 zTS2*=)i0J>>7rMiaWp5~WQnR>c};`Y&j>s=X+CXUcw0E%GP>N2DykQOoA!0c(eM_d zl&O=AUlWdT(J|yn$-rLxUT`ll++3O{r$fW*^_K@)%?1M|1*x%{UkV-iIirkuyGVGS z6uEhZvm!jl#&c$SCs5u@wTCkU==Jbfh7_dk>+>~EGS{p;d-p(6O{BvoGD}LS_jcyz zeF>+(2EG#rUM(`8+n-e|&{N%UN#0kTyER$T{q<7ERuX%f@$mr*&G!U+3u=C}r>a$7 z3vGDzNws}HFf8i1S}NOx#HpVjr4e8-Jy5CLW5!hAI7%eK*QR}Sqd>1+FG^eK?uObf zotFQj4ac8!nb_xLJJAl;TI0)wn&c;w5faMY>;H)DDgVxWj!qnz{M;R@Zq=LdW}c7E zD^9&(eMs_+Q+2cUa6^?oei?OcBJU_!n05E3QE~}CxicIkk22)W=6j6ycl)+;_QA$o z41^{eDJVwn)g27g9wE%TvvXCV``-7-$E)cAN)d6>@+3pR;e9=JIDPgBZ@)@nHH9*( zZx`Kd)~egch8uh+JkcEyCZ4=m3RK1Mv?iY!-qc*Xw-XOO%bjVvW)SY>@h*zF7b#aQ z^i+V>#K&E8Ml+Q1#2Gw}?0rw|jA%}_<295XJ}i*RFfOI{M77U{_hyCwVSekpRBz$y ztPC<j7#b-Ut6_DAXB=)2I|mS~&XsjtDNK@ceL-@$+6F1;c~ zrE$kKpYYd1kP;GuGwz)-_;`2-r9Bi2c&O8%Z3n=BP9|q(=jiE*rZH$&4nW87$Qky; z!nHkZT^#|zQc_TWq+sAAj1-naf>U&sidwX}!(d!H#_&SLn=Vl9&pG1XbS` zF)Exd>XxXlEqQt5y~-r>d+SOWL80>vTCZ2AZab*!dpcib(`1ytdcH&A*rmzqw)}^3 zA&mTqfEf=D`9Gr(6XQ9JfYm#FmmPR8c5t39)hXAeWz;361EzC_1pn>=iJCSRvw zzUtx>HQvCBdMBwnL=em(I@KifxQ*nP#Lb}(mCDQCZcU!UMaUaREA*cptL`HaHtCGH zU?_9LT;6$=NT6&f?8=6*`vaRzqv?3|DeI?Yp)cKW6EGYY_s6T>yE?%7_}9FA*qUM5Qp&Wy_aBTJSQ!3?opJaXDU=-uAsibRNr?^&+s;J>1Yzf;K?_Kn>& z|1S6T?P^xs)LPNRvGW;EhL?iDJmQOsrq%jsruFIIg&XuEeaVaN~tbOHBaPMuSPdpl}_wEE_jBHAdDjL#H ze@$o^QJtjN&&$T%5+2E2QGHKet^<$bl)$A#aB2QSyXM&){@G(iuX-QXPdMC&{pt@h z7+ul7>ataB^VTYUjLcVf&Z>ha<9f|Kt8n#FLVrZdp}GY^jkGG(1|1< z)8sL~nCw6zRQdG{;jCcB@zVu891WxelBzC`H+F&wqYS622P4n>Rx5l|4PG05%IV5p z*CXy?bawgEZ6-bDRlHuG_Y(=V#~$~oo|lNmP{3;RBPV&P~Y^{tdJ;K-nj_(-klLd1a! zc^nrHSIV!1RrKp7pVt&%{ub)4I3$gON|hgnO$s`HZ2aU|R8#l;jAR#g*It zWc5D@%gtx@`Q#iUJgZ8D`L;SVyu(UG)_+e}_G~i&^gwG~j}0}btu&9mEBaW;`cRm& z<*}N{=^H+LiGKGCl^F(Bb=E2rXNVQ+7$bVgLS8oR`v%h|u#A>_Q^u8ftYNri%Og|h zd}=scd^C{Ckv1mJTl^Yve$!Y{=akW4#qrVVFLR=@!#Sa==T8U?;g4n^JFv-t%^)4}qT}g3uI@(y$T@xF1W#)P- z)zJd~%3Dk4l{dE~gr?&nzKngxAGzg_EyOiRa+Pr4YTE=?>RjO36@r=tuUUZ}Z>gaV zT(5^U%@r3gWA8zM_@d^&jzFBNgXg76ay=l4(xPG%LW$h;0F(Gd5?Ma)xK zO986)2XIF0%kO$#`6yslR#N#+=2*$1dcwy!qPjw{4E?AljQM4E%u2&uoE>HRvfeD$ zJ33cQxRR_a-_!OX^$+rAxTT*epN=GXYeADpfVl8JNxA1H-K%DXcLb>k4P0d`U35ex zvR`vE<)WV8cRQ!H91aovR<}r)`_`y2Qs(%@@0o|j%PUD7m{=JVcIhlGF_whxhW`a* z4PDV6P*ilhylvZ4oQw?hy9sh?FP{wr@3snq9TGo?8xLQ=UA1cz?ipN2&QbzKXz&5F zULELDq8NG~sD&@Z+Mh14m)=8eLW=(gy~pgF;gRp(+dGVE@I9uvu&*gUcrKnG*grv9Y+bG&zw6~cgoH{F^wkC8vB7$Au zv&Bt>W=BNijiY8|_ugVnIEY#(HQ{!{|iaIfI0(%Z8YroTdj_PzAL08-Mr(AaWT&H9ei&=&y zUPL|{r9L6EP`SOl%&GgP&Nj_`WJC5`Vo>eX{?4b_X1tuE-}1Y8C}D@@jwvt6Sk#@+ z?tQ}}cRG_!LLNWY!|)DE^n$=2YNr;c=f_9N4E5lzc#fts-dO!pQ3t@=Xe+n4lLHNWWWEN7vBa) zu3r~@aidh2PNU%V*!89o?gfy8M><(6>wOVZ~30 zue_#HS&Xut>$M7(V&ua3b3nnnVNY?%0m&wm==HIV-jm0-yVk|0Q zV|L-cW{ra@>3^yQSmOi0Fc>WCa`l2Je@Z*4|y}| zcBHxFJUZ?&@mm3AWB%euMww2uS4nf&WnOU)0Lq z;r|+omOT;wE&5eLj`jmMB~xBXgo)VzZ$_+EL}B~87d z^uz3J|5ly4d8J7=-mLB6i7a-i>GZ2lxYklG{!{pmzBUQqzfsW&KIO}26g#Bf`m6Vw zAF2&-NH(h(!{Lm=gK2cdqX~V5vGl{vT>Z=Y z9}M3<+aG*7X@L=^_=DLgHp$o9hM93lv$NKJhGBp5JuDQ5~X#a8@ER*OcgH0KJ8Rx-t(yP*Gfs0st!zIR|5;o?4kN-b0 z>9_d5H=aQZ^)SGab#7(j*yJbKjT~(2mrX7v9&yDVw=*|(+Tj?sp5b;s0i^-_Uj+Pr zXqW#37lb{MEQI)>*M7_SG0womv_x{Aj{fez9R{~*!;%siaALST?hbah_u2#v;8<@^NU-t?N6uTA9wd5q`)6AdO#nDnn*x~ zR$-A{&*J~$uKyj08X!N~aCk#=a`h=wnt4);Zt;N=?Oj=LTGvBITd0DLtvmZjT91fZ z+_`Rc78X(>WE{K}y}_*z^}&%vCnI^{+|;lDg{J#ji`q!}7iNP8{N*URxvnjqDduXn zR6!?cqm)<`gB|YdD;~PxuOd)%_4b+g4oAn5WKGykYIZ4HlKx;Y2=i#y`4kZJ;OK`Z z$PJ~n7ZzQ##<=_;9il2@RinwauDD%CF6HNc7>#693$)YBJ?eV5?31WqH3eR!$e7Ap zv2!B#$o0<99wlYrRFCLUTuL>C$Z{928k>)naz(BEdSlT-%^W2>9a+YD4q4kz4+}Nu zvwF)~Fht_&OT`Bh{1j1s=kxdHdu2DwVPp4jh7kOcF*%j4CvSYFxfK4(az=|Nr^NFk zd>!9PGiBLx61!7cwtkCvV?Hb%`f`{>P9V$TZ8NjONRM08L=0ya?WjW6r08S(n+FaJ z)O|H;8F*g%>9V^p>hq;Aq1rHc|NDn4;6WNs{Pp*}p#NCA?sQeq1(nssTKc&WCpWU& z^Z0$QLbB`LL{C5kAmL& z6^A_hJ|25z&7Jklp#m}QvE?0C;c8)D!roFfJAB6-H{PB?gU9gPEBN;FliG>JeAQTz zfQJ9Y2#)UGKTj8Shc_q{+N5(K)p2{f&2E9;%klbX9P>9?_>EFEU*SUr->T*l-g0buzTve@`?O{f zG4IAy6?^1O#F+uqma}XNvn^!gqo^aJww|e;U0GV~o(VJV_ez0qns4ku`S?ez)o=!{@>23X# z-W?KK@v+a1m#u=$ADi1Ez7|wy_?WQ!n2A1{Ni|51d%P5U`(^DLVPxQ?u5ojkug>?> z&i16I^yExgpCR!nGq9RCg1UCdZ zU3 zIoC)x^!c6Ee3`srPsG%6Oxd3TC#ccrgX{Z91VaW_1NAum`uOMI{(Gc5@@x_dDbqH_ z`{2HkeZt2jL%mbIHXSY&w|5?BoZq~0q3c5NGLb;}c3s=;y6!ZBlTSV}^5G`e>YXP! zc&@J}h;3y5qq~+e-J~#%?dE`X5*sBlY1z>Apg`f(Yi&kJL5Dvj8++Moh@;H7Z>`!9 z2nI{h-#xsg9iJ5GxUv`7A$$-0Z$ppW4*tXVj~P$M(I*_w-)|*em*zbw%#wkF9j40D z!d8xtGnD7gi&_@u|3jQy(Dl*Ary_yr}nI(aXQ1Yjx+Wh?h5wMb}wc8FSY|)Qo01!fEpx z;R-m?5zFr*)v|a$u0^nDW|zM9xYjI;Q%rE2Nb}Rmrk0Q~g5yIWlY#SO2+{VJ{oWx` zrvs)p#L7{ccN4>C-<6-Zix<9`^E8eg+!#hyU(Q5F(Dt$Z4t|QXa-cB97nmJKOQNHz zcmfS$MPCW4MXBT_ZbE0@TVPD64bsQb0ar!G{2SE;1@D}sQp zxZaiD@`{HZtPPFQw(C+~h*R!K+pG}erzuQ+#2d0PlVvh1kyZF^%;j+;!%dkHE-k-H zVuR-Rb0Oh{8Mp#v)GNcu&G=rj3!dEBceCa*3mx{Q8#Z0sca-FIt>QOAdWq-P-wEd~ zNX`t~d^vJ~ZX5Sw*2^6t2Zq-i$&v#8i9LGDj#K6$ZT>O=q*HCd=2Fv>-qnphj3S*! zmW0&ruNQyl)VkAf{iGgYV{p&_G1VmN_X`Y_MP_UL`%4r^$TijqoJ-RqY}@=}CMOl2 zo?ZXQx{5(+MCgA5D!^d>C~9MA(YpDyC&M=6`==j#x(8c3K!lACvphAQrb<8Bk(bk$U(}v>2MHRN(iL^>vkW^mO!f^{|FFu?aP>7D@DG$N_BbyQEeSdjJs6C8 z0SPS`CZngVEecy4IOd+Rbc8Fp*@Mnw-JQs2nUvi8HDTVsv|L`1w2|JXK%;zf;P5@zq)0n@?O$vnhKHm^m!k*E6zz{r;fc&7doeV z$Sv;+mzF9wr!3AqDLvV|TT3Pnr`^`<>tVjggIerk0qWD%&&f)x3{rI4>u%iA7>RCl zR6SN)m*=2!kj?*1ik70A3O8HUjmy0fY#V3Jl)OF8IP@jj?tbn{=fxiPrK-}!;*a#! zq@AI=#0(tI0Nx#g==YDkf8~~^IS&ipHHE9DL=pp$sW(sc)+_DtT#&se#dAYFiZi|G zG)eyZ&(FUXtX2Hhb%-Dv{cd+}Rm4TWb_;Xk??=#K&kO9muLgbI68M9Hi{TN{gyiVs zBqc~3TpT=n1a#~A&m#tG(DL*Gcf@d95wcx&L?#qi?MN<+6pN5Wg!a2=2iV`ipYsu>AyQY-|zMU?iA+BXFaH ze$?xp_P*o}{uY5bhb0s^xxNO_SMoPHmr*X*k7qtoVeNA#J+ zalFpQt*U7~S^2k|sJ{F5uv0%a47p3l6Oq5=FG1TG(c$YyA_&O$fg)cwUuC)1k4hXb zp?X46Es^9xq+Mm*Z-@ov*1W?;;{>Z^h>|U&48kYE+Bl2Grn)pd44+q4T*+8?6F+(~ zTb~cNP=Q=8&4DpzPHLiRyUr`bMr2<=v<2>m;~uTiZFj|w5iAp$og<|r6;FQ@{lU?s zI2)lEWNFmibSE{$Ea>^+o$Du0&KPX>Fx#v1d*2R?nW8`k(3T8>FyS!K|;DE1qo>t z5dLcu=XgEme&=_-|Gm$R@9gJ+$(nQRz1G^y@xEh>Ip!E)Pb03e7v?umdpQF3{=bJ) zkS7R|cyNSksZT>;_U60w{54F~k;`uf3aURVpsZh&zjKl+$d{wt`IdEX zS=03xqy_kF6X3IvOFqMdDyhciAB_1{X;l=_W#7pCn`qa6e?kKasX$(UdzOh6;5XJ^ z2yN~MLIc9yekC*(PF4;Mre8hH;^x414}G2Mo*URV0Ddwzu`|AAY(#*u4Rk<{A(fGg z41k1czr@gCBTHCW8JQb^?%V4#T$3C!gd_EgL81oM_6$ta;JcRuMk;A_k$hj*1tjrE z3M64`-W*7CVd-E2p{=XkE3nvTkdR_a26Gd~3uFa&;eXCLzkhm< z@$*8V>W(mP>#k2Tolw-!Q5?(5`whCgFI8?zj_&tW0>;tJX3vLWUiBou%>(69ZDia@(NSdWb$=Gw2%d zO)dW!1|88q%3aIy9B8*Eov?a`f8-5CBaK$Y`k2aw7-kSF>oDd9Yd@_V6yK5UXA{FWsR;$1*75~P5>rhg z>YE{5?c{#lsZ|O$2O@|Vy-ZeFSyszaGgnX(aK0&@BIgPrAD*iSMUqh&Vj*+_d5*F> z=0&mO-sC*Z7V7FUIj@6fh%Mw9+}Ovl@FZHPn`Lbx!`w8EWATPDMaEWgVRDe=?yACW zjJ4uGLZ*L)HfI#xTHXWdNqBgm&p&;@Ahy>jftPb|9Ip1%>$Ok8vbnc-y@Ef8;;Yv$ z^*dmG3-uSY0QUYbhsi7QyX4Pn?1X}np5Zmxy7NxGU$YByIc0$F>NF^?7~18r_6p%3 z*_Ubj(k3Z4#-azV#~>}hpOXN8wp`hR{0{viW+vb}cb2SELCsgJFe-QBgkI zwkT;1I2mq!k829g6)Xa4m2B2)W(Ps>CYUGol_y3Gexo44%`JX}YPx4<%t zpQ;#AqIeg%zY3=lZqLlWL(e^O@gsa;4pSAd()`fW@aulkuqujMR=o2&_xR(E7>Nny z5qn28CmE1^W_6H5q;!S4(lvjM0^iiopW)8{DX~))0+tcDEh?SuHRx`Xr;MI|@#nvS zKOyn)0Dl4@6h6P1{=Y+(iY9R{sAZGxso(B1bE4*}KhBc%d`y%131jhKl^$WpZ<@S6 zcHg)PoqG-knc{ZDk~ssodfmF@t+?0DaOuNlxiRNgrv)7YOmKROtV;0Gd`IBAeU_EF z_c8mUrBzWugqg-oo?ChqgpzL*mos*_P?#e-MNkQCwg$zcnxk~hS!CX^qnbRaH;;+G zW6~yLWIJtcTJyztt39kx&)_A}{SV*JJvsRDMxyGB5Z`8HqQa_Kj3S@y2;QnVsxfi5 zXl0g3tt9*?UUXmWUY_fdaOIcB(}pl05>pdHoTS#O!v^`v?_!;##uXB(1#LvsQL+k( zSgw(7(R`V3k7b{ zmpPZeC^dS&Z3BA~E500t#%eBPt|b>1NsWb=4->XS5+yDPhhg%yzrsiO;36>j#ul}? z_B#F3Fo_Vx!I{;1bWg24N$(f(aC)T=y&Mv9t1yT$w5;&0KA^>j^>6Q1f~G%DS$4f# zIuiTdbDE_kWr0BQeoluE$Ae>qnC%5ZtJ#-|9BMkI-n@$JSh?ijqhe2vS~tG=NW+jY z+2juPj~cJ@vCzjLh5`)6&yaqJ{y*{uP-YPdg|un-6wz|kvel5wA;1jC6npv7J1dGo z&Wl(Q>AyEojThHxHtjTcJqBq3{s7`B;jZE-F`>ql!ln*)G1SYjsqa}k(PaEZAb%0a zf13gF2{1rb|1v-z%een(OJI;l9KZkpeBi$^Kzy)&_2B(#l>d%Z!l&FVNujZ=?|oR* zq(p;zPRr=GHTg9IwhL@n-!!(8yCE7;lWlAy_TCm#d(oy^UTHBn7j-Oh8;&*v{3;z@ zoYf+-gD3C7tHFF|0wm_@wWWdG_pwrL1(~s5c9e_soD!bKOg;GCG;@P}iLx=s^n5ro?DZCE31yA0(C}@8r=e4z(3%>`x)vl`oZ4+ z?S7hz$Glqqy0pI_#+H9(MVrZ;`7~2hmB%VFETWfZ0dXP3(Fxun(`uvdcDro@q$%N! z$-A$|AnnimxegQZ(s>zYhR_D--ZLCgiNE;s-+jw0c)7t#Z(4Tz z5T@y&9trRC{5X`RTJ4IP=_gK58Bf)=!y~_MuX{MHXPZmTv-~wHgwAI9CTSPIB7|`+ zQLnT<7@5C3=65Z!aa*!@CM-ZXvfX5CTu@k`{Q;E0`dvNjj5j(S4f=l0f zo+vBA2j;6S$$|y+_HUa$Y1kP+)0EOSTdTJ8cf3vS64RgyFCM1?T@4p;){|X1*Z~60=>Hi~t{?hpqd|m8Exw+@<5K-Tc1&81IKk9I0AMKM{wpa=@+(Ywc0r#We= zy_qH(e5UyIN#s1E#$7xMSPvL<^gIzGixS;tPsQ23O=r88D_KWS8F1eP;AqR^+N)uS zr@Q6zOW<#lG(D~u;1|Y@PWko`+B?hH3dPm206t)|pcS*=0{#L1{2A&m`u}VB^Oq@c z@t9ZqsR+T&iw~{9xwp-K1dsu1n>b1#-Fda!rxd#n=WfR15M6CTCcSr-FU`Q=_@bKCy*9pYa zBPm05X)E-=q_zHE*%ols9Hsi?B^9|;gU0+|P7*eWIvAXrmcBB2lD{owDLvDP!ysbz9b8m6%h;s)MhU^@+OA;#Ll`3_dMPZy%H=m%sQFScLnY;E{q5}c zLHa=we#hvvc@r=2+6iP#8Vc71b%Z`_r4!?lg`N6> zzt)GuJt;O}Zpj*=np$&qdR;uF9?+WfR5-{B)EHzRJKrLcp322Cwj2w^A{@Q;Uvk};4*B70rqQ38% zNrgQocVKdj`2cVJ4Dr`P7wvyx{K(%PfKv3^ z;y3^H`w9Loeg4<^B`kDI%>UxgKhK|k+Wh>BKY!l6bK&;=7sOxwXny`Q{V&bWpE`fi z{x8f=BZQksRP9lgFne=&0)xXu?&p>7TsxgQo93~42o6m0{KbJ z9uCqlqQOn6rl4V`9=u^rJWs=z-~yHJ~A zwQXOYQ8tBbj=m0fdq+c6VbT;?BUNUu^4sR(L3^LBqGOQ3GR;(VbIb?rP}FKfr7=OJ z+bw%BcN~g?0!THzV`->KXvSk&K(NeiP&}p_cxoBtgjUQvmb)36`T2dcyjR?pafqF|o{sj1|{0W#)6Z=}S)q(fu^ARGKa5x$N12^RT zT>@SDvjLb_I~;Cc!#~oou-3WWIq=)v3s+kTkg(At%&l~R?QxfB#tp9D0aVKPY2Y8X ziNWadiWfT<4Ge&-;lJI)0D}(vn_-Y(e1MWgllFUgLbvA+TX99CG-#Tug6wG;l0s3$ z%qf=wkW$FR$ezz8uV%cQn|TJKq_LzP;jnSnM6Z^iqlbZN{#hLi z$nvZfnPxnDY+RC%xPO*3mkLc+E-i*+_7OL$p0wkklZUF&1ja}uI=2W}-1Grr85=U(<&o>^@3Gf#(-5HT^7&K$%~L_#WH9xZ1B9M<>CysW6VC-ixP zvmQ&uQ`5`r4ZNGQl+sVkbqRM;%DqWcNNAt(0X7N=vAQt3LgTZqd38cXhq0j7ZQ&tH zm&9CxI|)hO0_dTJSkFFGeN(DByxaZ~H_P2F6^SOOfIIF>qPE$@y}&b zC2xIlsJqioMD{D9Ba3t6E zm5=QwNJoq&&!3Yje?W*o#~f8)2E|gvZ5v!0;Uj<%KKN&h@ang7gd$r)vAJP1&PlMf z1%kp*1%Dag{|Y0V;L->OO1t}@{UrUrV|a(vIn;5D+#R+?Z!3q%ZpR|G=|0n2&(L+I z5S1IL#pEaLr2eR6wtcVw6%i2JjcAt2kSWGBq@(*JDhpoBIaM2r?!er@0JTq?HH5nE zRmVZRjs8BFV}abhZg)0|+6_{^?f|cuX*k9}sxT@Q~C zcfJ>=;O68-B|W)#T&pm0a{=YyA*ZUp+mW3c+fL}Yl z5h*QUc++Ajz8owRB$Vpn1=b1~a!v1T^UZ7{BFIQUahT#7gA4$=!dJlF{&4NDj^r9; z4HFzPQL}$!y|5=B@{`8;pX{$*{ImMP)egvivw&M7Fa$7woPAh8>J}?YI|d6YSIEXo z1}j^mKlEAWcUZ9R>rUVJaBYQrpwc76nq*;WC8(9>Y>%2}DI>(IQCBp5b5=r5 z{FZr(9H-hu?y1`&e{Iq<-gQ>5?DyE!j2E2h+2-_?Z;DGZuc0X1FMf_bj!8}DhkxIr zaxx5DNpww@JHR)!`Df^I*6aNvzAyK!dooI9SzVcz*Lc);{-Vo&1zoaT(j^0!&gXX| zzy}xNp8Orj_#G-`;nBl6E#16D7d7h;J?E`9DI4E(BAv;l^dL>pbqk}jE{KYe&d4Ggp!t#>pL0|-DOfb=S#_ks zkXXRpqaS9VFcXmElW!?6Go^J55A_U;HW&K1*;^u%4`H!PH_|99r7NLq1);{8qQ=Rc z9EtO-%gu?>hsgymF*^nEQZk6c_As-Jsivgh{qWsY=%I}?R#MYw>ZQ5F7@INkT++8H zMk)Mv+vLyu-btAJ|AtiAe-31VQy1*xV0v^nu;>AZj}U0}zlU#MZ#l9t6y1TLU{g5KssiGQIV5 zfQ-(N(lnRZK(0nymkJUac*!)+Ua*-XFf&N#?n}Wndx)}^+VnN5A=-^j`iq`N zC{xZqVSiygq+ug+dvfZt#`_bZM()bq!i+xAY}BGVI0Ch<>X8l;nOK}b1i{r_?-!Y^ z9w$YNJ;OjQx7Uxf*WN!Gz?ai5BOmPK>DQ5o4{Jpk6fBFILCulPs6{H$epM)@pjT(u zX#C+@6Jd^bJ&BOB!*I(Plu}9Hqcy5AEwThvG1AZRvgOiF>Ak z7r!M28|%p%K=SN)(_VyMm;vhq)P0X?COkD7S0sE2a0W-EYc90M-LY?IFI0EG6R}j% z@Zj+XRo$5#dBc~Lno24n-(BBe?iw4n{q8yGNz%ij5bH*&RGT+u1s>ssYvY>Ss3oJV zp`%^N$t@OxgUt_@m%hH`WG@=ac33U;6VZ%{L@~WF$8$T5Y^<+*L8j1;0VD$bRCL6_(pGHxwUbc*8b4NI4#^1n14f&pQ0gP!T2pZy{=ETZ!2v0e`!-wNAf)pfKUP~Sb7D4Jg)!%P7+ z!SHuVNu&IbPpB5LCy8Ww*qqy}XzS6gdK3a1!xOOg0)(Z2lE9N-?=i1izjscWcUh)) z@qd`)`22uqKW75wgFG?_jvdSj6zqlr{)7V4f~l`F0l`4y5?`eevbHie(E~CP{sKl9 z;TAs=G~nFwdiK?ARTRSc<}hYC=5Eibhr8nKjm@S-!(W z#Ya{P+UYrnwVNBN?j3BqGx+PfMk~d2VjmFadPLD%@z9(i#9Udlv|{LtLs}%l;u87Z zZ1x_G`b7G%4K=ZIKDK32m!QwX%hY?gfdpOnbkiZFH;r`nDOPFivi?(}F>>028ZOPa zwL94hjeNp{_6gR-#^&;xQUm8FXqu~Z664<7s!)}7W_q9_Cb64bXb0Awg4SvRgJ#0H z_I%WgFcuEBFA+l}^*TDpl_R5`u(gDKL;6COtV?`U=sx?JiKMEu)6@U%ai(eIlpc8K za}-CJA)^QUmygvlanWpVCb?-^lFQ^-ZcFE?z3ztnymjy~$1=D=*>59LU~oGxFHl`? zEo#v$XQal~*^Fq5Ygw~5F)wgbP8RBH(lnKq37r}S+9Pf)yChvd#pSEy9!_rGYM1DS zfOGtwn+-qjZd`UdK9<00JvEE)x)_qX#a@65W4jN52V#(W*(1kiMRP6teG8V;Ok+_+ z@vlBpn%cz$sdF=6KO<>=6B*4)v_w@MLSiL+{&AfnQT{f4`Zt*EUKJH?n+D^hyq02O zYSQ!>asvVHPet*=6W{@CR5_e(zlLl{`mbPerwMTx7mK6kTij2zF`W10??)s zkm`|jI+HOM&--D-9U8IXMN9A z?TCqp>L}KhTf}EtT@sXLS4nRi7#E0TTgWanR1Ruu5krA z<=uOl(NsJFB&%kW@L@!)$)#YnJ{PqI1RRmoZ7qex2QCx|Wzfi_#TqgDUd$&Nd~v(4 z1f=JhilZ4Ol@jnQwUhPCYxKH{yfyIIK7`jd@ycIy18R1yPWNfV&TssVN>y_)y z?vhOc9%7MC)~8AdPH}ltE7T2BOh3M@)qJ*wUN}IGK1a#@q)#rZrINmY;=Rg^x%2@O zKW&yZ3{>n~@3Ub=;@8L9Tdr|YOSsh=#etwRwEA3u1eE8^V zXjQ`FKwKYgmV7m`n_qnDJ~4cdNT{e3%Yf&ZoM8|X{An&16GhnIqRnvGWv)7-^{+`_@e!flbx%( z|0BM=e#qA)@BF={G~`(`xWXBgj4pg0kTFJQK1v1rY-s~7n@YO$BrzPTbpl8~pnL2B zIm;)n;`4y~h-$c!TFnc+hauwxs~$h9A&~MloIh$IKbF>&QWKMv7rXRATvf1vMM08s zHL$$eyae$$0Oe$uSeRIV;&hx>)nzUYIGEYg{(pS(9}#o+uxk%GNkMkN8m@t9X)BQ! zv(3xNGYs{<;*VJ_&|yJud-jxUzBn~GMeo~Y(uq!_L?+(iPWwm^j)e61Mf=3v=!Hqi z1$zD|B-`1Hc$_Kk^uPl*%eziNDurVkC}l#fc9s^?uFgX1H=kj71~M38>X|<};Z3%E z)4*`vT0M*ExWqmFrNX!={cy?KvPIlVGxWoQjz>yCge*)*rOLG#!EtXld05+D3YmC1 zwDN-5b?P2UyaI(srG?Av%ewoEJxUmYzbjNy`QSE7QyXj-rF)C@G|vGd{Ua*L0>*{5 z0{*Vv$oq<19ORqB(BD2FiavOt|7HPIEs(6CkSOEqZY9os_NgDi`exd*3Q-e3-~FH= zdxYFRWTtlO-_J=@?lyQIshSNC zD6WU%^h)>UT8XX@2@Na+WcLi3rZ(IUMPN}&_g@KTd!?&^E4#Clehf=kL1$C0LO17z zJWYtcF?WX)!3hDjr2BLH>6=%&*>bZUhZ)-n#HXf% zqqy(1EE!DL!ILn8-gE5m9$HW>)TKFOKxQBhx8>z>;r(EKyoixf-4&k|FStxt&(P+n zr|Iaiawx;7C*wmaww}aYPUq?g=+#B=;w!s3xSJB0c$dWNeFXO22YZ)5I2IGmI|uBY z<&AD)X=o(~RI$IBq?z6kVDA@95@0cimWzbK|HG^X5-^KMiGzf|Oe`!M%Ii)WQ!#)nz|=M_^WvKYA45QDn0(P>$y8 zpZGG9>W+l4w7Vqtp_qF)%8Q521uwDZI=*|<5Qg8+kA&^q5{B+apC~;}k6h5UC~`GJ z%t$L~|!%IyuU4i3J zg!-(G!R}3?O5lp{-o}${5-?eOFUL^Z9dqx^CX2hP#LL2<6p4}oUsY>5wy|P%){1vL zUzu}0FF6ODgo@EkCDnKe66<{APmiRN*?V^!S4DHazvq@q%J3>m`QDsA>^BpR-V|q3 z_=5*NSzRBJTVRyKxkTBgZmF;}5X2JA#uG($J3eErx#@wYC? zw(@$fqXT zfoIVkeiKoJW5yzqWz!pW6dxm=KFX}};!n=ty>Hv9-1cgukCUo@6d@&Da&kSj-^ZFg zDuHJ{=FXC8HOf>3$If?Ewet8b6LXQf&}@3zNjE6j4qfb z;QcAmQZ@^woLw*RYX{hnUN{3fd+LFva1#`pB9p{_`>F(wKy zdF*kUr^mN^Q8-AuBRQUqd(*G9)qdb-Ju^DsHyj#15FB`-%ZhG|zz@P#>;Ga)L}?yn ze=91(t`sdV5QAJ*3j|Lfv1R-s601k^bnISPBrj-SL8}1P<{16&to`4UXpOd_sF$`r0=8Q;b zOm;Aow^%N7|E!pH7(UtMW?C<#oN-rpnb840ZWQ;a#Ke$u3=?VHJrpg?_(HuPH42d9 z#QgVs+1F%w$xl|Pf<26BGCl^^OkvjJ(Z?raQ;2_QUz|vN@w79{-a@Tx&GxWhn*yVd z@z&HieS)}+M3eA*J@oX!(_!i`CRO#}ZkX2<3O$ywCnD`P?^*>P)PGN<&O;p)+sEd< zJ@LjlOvs3rBwD}74Y_@768aezVQhfD&?rwJisdnSN2BDeX08V#DMD3YF}L+%q9$J= zI5Qcia3Jt_1&Qf!k#`b_X5g$4e~kp!UoqEbu=nQg7?jX|yIu{A@PiZE;N3<(8wnJ@ z=cxS~;tD$nG(vqwu=i^S`GMfPQ^4MdK%ufLr>=JxP(bF_r1s=jUR}t-)Ww?A4{%Q0?nia~7o!H<+|uwS1ND3LQTnA*2_J$=TCp)O-(ld?35V0Z7hQ&Pq-21sgeCm&(W7QdB6Bfa|sb*4OYbJW{R(>F`+zoEVTv7*!aGaBX6tA8Uz2Qa+744B3{>If#A~_E=Ol^O%Wm z;Pa*auy&X*eG0QQvw^&Oxhe3x zHoEGoCP;cj>tmy_o53Cq$$Rcx`gNejXhE!ss6?SE{_Y(E>$!eb?Hs|~ecsHs)a1|4 zs8~bv?2*a%zDsdjqQ%t66SHlyKSePk`l%5B^{C$kmOe&Q9l_zc?4W zqqSq69Cmi^`u<}czjITLiF-M?AS7;#a8lEOi4b@_25ABATL6NAyD#|fdzpQCd6P!{xUcuZ0tuOmm$s~z+$t3El9#bSCWYWOa>W6#wPk{ zRLK&^ux@JyAw;3;?Cr4Fr2oTNASo%SizQ@8xlk@ZWng3G0Qi!b3$mJgosa%sdUJo2 zE53CqNw=id2CD?Qi%_|&$oE!!Ijc-!czXNCkBl&{9?)kV`%fiO`qK+igDgIMXe^cV zC8H5dmG#|bdx&jkKiaSdHjGw$BgoE(;%Cs0ZrQ35wMK``z25TTWY4UJcQHx!#qu|g zVX9Q3Q6uL-`lrYe<(+HYlJ3QfeMpl+pHt5g7RrjgDORqmi>GQY&4&&@J&ExwueALt zQ+U(mok@@&)gf(5p~z;YVwXHS7@h~A5esi0r;-ci@dcUL9# z{E}Jpz&d{uGxhl6f;y#$*N3C$3pNceR=gP7Bp3gT{qei+|9Kq{C~EB6S^Vkg10-Iq zQsX8!iy(&ea>S4L%Ax)Vc>9jR^4RE|;Z`h#?NZwJ%%xNaMi!f@oAad_qPy~&sLgSW zKXk>4gI*aMX+PrvJ)AIx#_Z2N!n|>`xmiF+T4reZ*ht&e{>dAQSoWeyR82#>HXGrYE(PTT5pGaC2N&Sz4paLO7~G-@IVCy7Sl9LnA33PV87VSW=w*;u(Do5uP{>E|masOT)gRh8q{~3};X}Ds6gysZD*(f#o(J2@ z>G{nCsrRP3jHFMFV~pp6s9tiWB8>BQ_uf@SwVNyHTEC0ti_`I0J>)%{c8}C+>LU}L zquws+h?V4E9c7LJ`&%>iAGo(|85xpJ2J4#-`JfgMSk`>*6)C>v#Ab|P? zOOM&AeQg~SeNiUT@Zs(*dT_Iyk+g58sGIYLVoP%?Seh3sTw-ruEY~WV=bd83Y$|rp zFH@M;M(dr-C>k3*=J%}`V7v3S+xV=1s#P(sFFbgCM^pUy%UM?yYC^`_bMK%ygu=E& zEyfk8V?Fnc;7D-BgJUX&=k8Nw-Y2rNb3DL{ZzXj_TcW>Nh(t_x&YQ1<9VcTt*szolZu%enAzJ}S(=!EgiXwiOh6J2js}+I zCcs}p42ld)ykKq!w!mVu7|>q~fn==AKtH?-sCNbN6`1LOBu!i`41kJnI!5L?E+%>= zb|x2S!T~tvSeckum{}ptYoM;&uZRDt+xjEed5Z-~DR}~A5GpHP@1?O$hY&luZ`*BM z`%%Wgt3{^ClXv_PQ}o;@R-Ga)%qJDS&*~HVTeO6EHj)`L81!0N8yYf6F*k)NsWJP4 z)pVidM>h}^8Na>_J1al^o}9j<<1H$``6TB=$Lv9W8S?)|c7` zdj}6JI#Sm?9sjorIzz2VJCH4v^;wBI6@AxEDZN}n!as1 z>!)dW0Xt8%Y8BP>_#Bu&9=F*O_KMGon-D7uEn8rx*Nct&x7FqoFHtqzm5mQ0 zNSqDJ5lf>R8Z8C$M5gX3D-Q3gVgsl90`G}%``s+g=biq-YseH(lC0>m^_6^1c!}O; z7k%aUD$4^5#?K=AqjUrE{jZT&D6u~;pRq6n?L6qLNNz%lFM*p<*`e}mZ?awq0 z(51b;Epd1}nu=I}W_ke`1NPb=0r<6diC>6Nt)3!qvJwIWKh7A4cH`~y19C|!F=1Zl z)o?dZZVEf->sSM&AekWL2rrf$P#>7+*#Z?I^)9PyQGp?8UEp9*NPg)zpjUJSlq0LF zLcc2}IcDPcC*qPV?7y~mwVC=$V1EPR0 z4*xxF@{d4m{cG61Ug1>0MD_>alYxl2*LT0hXX#lNCKmOu2zpq=Sf-(gZZBXbM+++? zG&=a()8(Muj;g}1eomJ&aH3&TJGFVX<{7rkc)KjeA#kEPZG~qbURr$6m%!sq8W!*IOw`o<`{Unzo+R_-|~#-#vi{qMc#F0fpMU ze>5KqDML|8w@u&#>w}er#9U#UC4Bpezo}MR%snE zO(y;kR$cn7TT4uAU4rM;AK)F8TZmQnzBVs!QR-^=?Ra{UmN$K?zJu8Z3;ozS8zYj0 zh}D~8z7}`j-o0J1z!koNp-yGLMzf-siEmXzy4J{i?A^k9%;T;) ztM8}z2D);)6KAGXM8~Z-i=R3VXA}}T)DgF^yN8ij5WjU0FJgm#eWby6XZ!I^w+|V; z>!W<@w;p5$KGrc8@r~CIZ~-0v7BU6g$^Q%;P*9)Mc3D2}zN>!-vyF92CZ_G;=7C>n z(|S=6R(Q+!N{E7RIGr$pB}Hb}V~`fWK3*W;DGLUJH-f2`^k|R>Eum&mv>B`EM+AhZ zZdyM8AW)w0*FE`<4Qx#y3guNfa}F?MM-bqrVh}Oc0rp6+00nY&fdFHWyse3aj;+hD zt2*|ORUN=lXAG?P*tSibMZeK(1v?!=Bk4@Ub)j)T@}~|BuM*qG6gSW9*_Ju0+)4v4P+ZzhQRv{Pu76J23p`CU!q&`pdI|T2Rjb^lR ziB@~o?2^eQ;wWF*8R`I zujkTl=g;LxK*8L-c8j-@ jchvH(BT%X@>s-Jz(uOkbY;>EZv^^O5OaJsu4F7 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 z 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

ye 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 UPO~MiiE_{`aTt^<<&54TgVur5xc~qF literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nssdbm3.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/nssdbm3.dll new file mode 100644 index 0000000000000000000000000000000000000000..e0e93a79c8835c4674fe240e2463b90e05f28c8b GIT binary patch literal 142336 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 XNj6&tk literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/softokn3.chk b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/softokn3.chk new file mode 100644 index 0000000000000000000000000000000000000000..5e80c45c525585aa0f8a8f494457b2142eb21daf GIT binary patch literal 478 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≺tIgT#&|;;{t1g3R#+YHRD_2<~t!&Lmao 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

1a5pQ`$@Fd?6g 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ȠG&`}Q}M5a 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 Q-4S?q1l}Ei|DzH3PsM9P&j0`b literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/ssl3.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/ssl3.dll new file mode 100644 index 0000000000000000000000000000000000000000..372fa2e2c2a244402cfeb62cba69933456fe0105 GIT binary patch literal 241152 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�FwofzFOOgx92}ToU7XlD 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 Gf&T<&!CnUd literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/ssl3.lib b/jdk/test/sun/security/pkcs11/nss/lib/windows-amd64/ssl3.lib new file mode 100644 index 0000000000000000000000000000000000000000..811f6abca4c928473e8a8d9379db0860d8d1cda0 GIT binary patch literal 17208 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 mozhs=MSKbqs%XQo&C2s+ep%DjbaIACJf+*js zf($_nm9soO>Wbz>3b?C~6+sc`NPCU2oYV4YX8&eOa4Wz2)@X%x9yF@OS8gK$2w-mg zXLjLy$jec8&#^lIF8U$OGV=&_1O>;HLCOTR0}aA@c;k-fCD9{>OV zfJfIL*Rh}8fVsi^-KOMz@JliTI3P)KdT?MV-JBX|Ezrb;U>q+uJxe)LsPLIrh*IM? zLv?t~6`>H+Oyh3eJTQrZVX+WF=GTOha6l2*&%pto`M07uH#BPGa_ED9S~Lt(J3d`Z zWfw?{_YW|M?lKx=3CVOf42upsoJ1JHMF0Q*C?T7aoE6{rIDI5vG3Q~U8Z|3DQHuxz Uxw!_cr=UwKwRiV{e{H(9Bj+5^TL1t6 literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/freebl3.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/freebl3.dll new file mode 100644 index 0000000000000000000000000000000000000000..8b393ac621a070d57c66bffd2b8605c71a314e69 GIT binary patch literal 307351 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

LJesnO>U+$Nv8BkBT&?lSfr!$n0ZUm!sE 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%0DC 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

_ZnL{!C4aXzgSE0nN-XMr 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 +uu&T9(=?iX=_o_|ifO8L# zT;IoH2l}nm?`=wSAsl8*1@;e@yK5fWGnQql&9Q{qarxw+V5vbtQa{2Vbll~A6TV7m zH=yY(6`?Y!=uLB-+q5xK<6mxuW5~5AkEpew$6}Zz?(nG+9(08Qqjm+Enu`J?<@;QK zBzaqbD}J#ax{%2>Ol^D($_?GBgX56FrP3FxS}I^P`6Ppg07-M9RUpao_=EzVOy~$CfN*n^BEK+KAD$(+rDwA!q#4|bC<~x0KdZ7xYsRCyS zfqj!Hz@{_tD;lk?uH^15N;Zf}UAn2d0qTC%^A0Yc^4E4&F4^92Hf?KvJ;+5%wGbPg18zp+DK^tr~~tS=C{)_&YcWx@S|FKxSAXF9KPIM~d6FuRj+-OA;hJ%?6k zgRY$kYU?0?3nCd%)!JSVFsW-R*|-FC|8}p=``YsT9leM*B6>EEU2S z2`MIet(q}%+fdWk*t^}SFVhp}uX#_9fx~#Qz>T5=e@g+qO!O=C*Z%dA?1Fc^v@mWg zd%l$)JrtC2fUqh*`XJ@$TooujhNV!ccU0t|k*+Z6(;1r%d(|xFa*H;fk3H&rpE+1Ae>9w_eB?T5GqdWSqu`*U+aWXNt^ZC)2Dq4`WJMyE?cPg1%WB)Ke z+V4~nt+nsWk3IzYGT&{?$0FvxMK9`ni0fKs-Y>OQM2xvod&FGO-{ojF5i1R+8q3ji zsJ+h2HpiXFbW*JpeL~2#s`+8gm7-sJpr7;{A5F zrzXifo9XleR`4m3gi9Bzz+CdG8*Yqmo^KbU_FK_4!LwI$}kK5_LQ5YI-;k!61iG(S&ZVg z>F``3vO)3OaH^aNs2>z2c^+TKF?@2*q;A}0<}AnZ zNPuaQaSJ2O^|Mno~yKk=p`_(*5>rMJb!W!kCcSZI zbe4lR)Z2%pY^&1Xe(YeP9xV;!%Cpix=9EvMCrpc30&ofhfV}9Cv+*`XGYcOE;XiLS z3x5pjMPG*H`VW1LiOfvccRQ&IYHZ6%<=vI#e1YScJ!7unYqICB{PmtWf1&@hC~rYu zkML4stg#2=M}Jb$W}P2cn3sFBq78SrGe5eNXjZKbG1FMN^-XBnefDT(~mVm+KuJzH`Loz7U>|ot%FzR3=jWtSl#Ww*w@ah}R%NED^;{uP zT}___uGgb7gQ@Gjk_xG|PmcK}2NlhGFSS6*fNlAn>8L`b>|jpHWJ@8n>?8=Tak z&JgR|i1uryBn5!VihT6}*H)8AAqbZ+D~CJ3bW%iqPwdy%NMxl(6ZV%Ji59|$vn?6$ zM>#V{5x9)g;4pVr(*upoN>e**oz0LH!^#q0YhdT>SXDXtMoPI!$uabOh=1FeoK+FR z=vb9`5Hd^cz-IR6Rzum!@V}!kF{t*>^d;8K{sCVijV?Ewf52S+sw@|%cTCQ3psTWn z5f?a4nT!F!{)w%BsbgD^rm-xMUP4S<+B(#+f|#*#$o9r?s4o^d3-_OM1 z$M7X;yUE^qJvBZY8N&~mICS!p#gjF0z#gu}9DTX3bd05dkj9t3E2C4NGo31+bqF

^WV%i!4#E7?n7YGYvL+7dx+J1A zvr;Bag3rz7j@gim%z(?Rb^}-nVfbMGLZH@pQ00E7ZNMEZ+aW`}#{s=F)L)RyP|IuV zUOMHhfVcFuBBF;B>*%+F>ZWv)v2_q8sUtsDoi+Kx)l>I*!*y*PZoaO! zw-O@&@YS|??>Sat7LiExxRXF!^X8Dl2k1fQDM7w43Ocmam@2s_!NGRVH z;vr?G4>XW7w=jo%V-4}RQ;H_~SVJs&&nE74o8atUH)NCGqPxL_EF;UBH2RvioY5Qn zUCl7S7>-4)O1l=7Fy}HAi5? zKWVw7@p#LLA0E^58MGN~s-?_%2b?mJ?3{0ifn%51)RZ$49BR$*)?xTpR|N}ePV6NK z`v{XFc;R9&&%8nud=Dv2_AZm2Gq0FqZJd?eBrJ!PSPt>1MeKsS?bqv7VVGHA@`}W>+}akRV!nWnu5n{J z%%7@)=cHy|-8C*DJn9-(A5}y@p5;#QG{6-_yc?#+@O0UT7kl1gKrl}OXd90=+cQ?n zH*Yght|B<{U)|psBM{?OIUGNlkp#D#9q(?D$i!lkPgr?~}N@!&TNc<3(!rHZ~z%+NYwVecB1ZwQ7&0;_{Jlm~114HUF z_j%4m8$t`}Qx`HqVbY!V4<&drK7{aK$DCaCCzB0H+1X8~l7ARz8QDaepPR}diW=rb z<=JklO}D+wn+=Pq8?k?5fZ7^5cyqO>2-!o|?U{%n(yp)KG)Cpjs&l`nuK3~`v3*F` zGqYt+rfLJ0M*Ecsro8eSd7(9~8kX;5-Y9VF>AhX!sx`l4U;O_H7?=`a zAWkH2Rf3s~fkyI3WJ@*67k`t(dsp>4x6{97Q~ZhByqC2NTD7C!_K&UQlNT{n#J^_i ziVkfa!8T;~_7BW#`nrc5+{LdS8p7i1_HOiEW*QKFu%-X(^X!>Wzi|osR%D81di=M; z&1wiGSHxdm5*+cg=h*R&K{|aeGjR1<8yo>_4j&{OArM38smV3IQ3Fv`Awpf0})#y*=7wQ(=) z3^!MO(yhL!jy5GQVcFbZ`j!{*DMi#Z>4@ayNDv`Zqys?D$Y7m>Pne?Wznc>`w#un% zC!Xvz!Wt*%N!CqJS^&_fL76#ZiOBwg9mrU*RWhfc+VuEndTIh}kmI#*qA@)ukp8@$ zDyp{U?8~6W0-BIOTPR?ZLxd_#bvib37OSyOwUrZ(0T^Y8Pe8QPf&&-b7-#0>E+;;L zWIh|W%!x~O`4SKg2g>T{bot(v9z+T2<)a)q47q9jG|fek&z$~QwWh1$_RCZQKq4<* z;OuullTC>zMXIM9*udpK_VYm zswuOAzUSh7T@KA%^E5hza6VBZ0P)Ll@6u*tN?46_Ve>E+l!>*GXne;dJ$({OA>mW+B(wgY%<5r)ZW9{*peO zS4pFyA9GB<#o0ZVNz~Cx;;<%rU4GR0L^)^kK-<%Rg4ZLO>~H1g@H#nA;UCcUXKO`7 z7Ut=@jEOqS@FurU=J@!6knOI>dgX9Vcr3^I{2ad`2fZ%W!Ha9ByCPeO&^c&5fBPQ4 z+KKsX5uj!`J5|ga^SDWntOie3Q+pEWragU+dDF<}jK<&g49py!)=YVw+tWXeXu>fk zPEYQE7(C_<()3*ZvS6jn){?p8_qWS_6Y>#6c2Sw!AI6W8h-cel9FCr(DvnB;doww_ zd^h4R&ODei($i{jbale+|0%_$rxeyWY%kP|O4u7(2RqJ_zDrJkCgf=Dua{BIJ1EK~ zws8?7ohDF~>Wm6))6gq)F5xbN76%=oZdO5ZeaR~CX?S`Z<6qN}RRLi*Kt_LtzZ48|+`atjG{U05u*J z>hoSOpaW@>U4cohue;dxs8)&*2YrRqCOd8NxQ7XvsH(MZCQ1Xq|FpiKRWBU<)zl`)iW5pPCpqrmcwbR zyqxqp`&A?P()nP;1u8J#Tq1<6vEK9&-I>C~>wqD`~ey7Py#73c5{;fH<4@IXb(848JM!(*^S*P z;b|T9+_@grC5oA_OnLTTNyz2En9WwHa;uR|mDW~0i&`3)&9e*$U9GM98vBLW;I)(u z?PvJXVw2VuSBMMvsh+a_^#uW{wP%_vMt4Am>}cQ9p7WlQ_RTzf4*SpycVR*-$HBOY z1uSJ<2#AiRMDCi4Eax$ZG8RcRtF;vrYf@TUXIzCKpoGkEw5PvjD18)cDVx*RQn7%P zy*SPZmfY?1)z(sf-$!4|=xRxC%N~{KzFY)f%gUkK(3NxZqw5t7@vpUq92mH$Y8CU&|Jf=Id+4Ii)%)BK@RtNndN7 zGG+9&&dg(&eN&3#*F3 z8T8B`ufIK(Z8~ADu0%7YX-+aYny>X0)&eY3YL4a{uk|J5Ij)VI)|Yc-`@yun@~(X~ zmVZ#|D>ICY)>pkFFk%al)>kE+W#wkHzCQ9Z2N^P2Uv9Gfj5q~|?D1M(uYe`gg4UPt zg}QKGv_oIUebHto71`6{d?nZS(fZ2X->49iF{JrqVK(=>Y>3l1FTP@UC!H5p7>!14$c^?k zw;Hp*z6rhvaC#l}UWR4BqK#edCRqUUfI^sFMZr4`W*JOT4vC{2Y&@QjEA`*=Qn`;n zc$81bmBVa2&`X)EI!{_$>66c{WtR5=+>a03);(e6x|YNG^CHLcd9B0XVdtGgj>(L1 zp2@m$zaz*pk0Q-mxtVsgJ+SjPVI#J(_(zN_(o#m_LE(CpDAiTO;To9tgas|o0Q7J+ z9&&`m>)~Op`y$F{PiJ{R*rcMXgQ@*j4J%Vdx48nIRKm)r@D;U9qS?H4n+uhkx2?Mh z7I&UM#c{iLa%Kpo_x{v4;&QE0O_c7zvO-ssq5R0XVx{_jf4e)e2slwesqTb z!B(pgF$W0u+*L*qbKK#DMc^QD#TcEs8UzcctJ(>dt2mdOI7nh9Is6-8O9m#NA<3C- z$pNzioa!9kIO=B!W`&88K)^*&be$;cfLStuOqHi_Tf#VzB`3Htae-sD;x4*Q0sJ8S zmM`dM225e}70XNAN@x~o5RnA`O#anN)4f# zXT)C+I_yJqU2FfFK*=)T{T-)2V4`%I3-;cvLMWWn*|BUP`8JjQ-3v2D0)F9Ysij7n;6wkplXP3vug2Oy{%llkE>)i(j z8|tJkQ} zn59f%l4TiCtYw;O<5gidS)3Y3HnOyAr;R+?Bm+B2m&(;^uCz`oPH8updMeb1+*!nO zvzP&>i>f8R4@SM5F-~J737r^98u}zp)*wZg^UwlfByC{>l|D1jc8;SdT;0U$CwT{h zB4H+YAiR&%*h_28LPCnwqAw!_Xy%J{Fs@|-If!xjoP%3u&pJ<@D9W7sAM=WO06XH2 z_|r`-!?=+eP-B*1e4W4jHci%)qQ{5ONc@=_hjAZun>qX!DOJw3WpTK)sKKf!vG%1a zhQ*F_zT)ZJ?}@!@U8A>GkE9j{t;K=Pm(PkFv1%ejrtm&-WZMBU9w?3-ph$|0N34Ch zasj7YfTv2`a$)P5K#GS;k1H4GTh7Oeum>>fb_*5DNrx$sy2h7lj9mGR6*-L+VJ_~L z3t86`$$!p~)bx=0nVMdlD_x}0sp;WdZ@tP9q2W=ceCir6R=*7T`PB51&V3%`F5R|2 zwy$&l86&Uprb~zM`4^A#&qw+5vM2U@>Z7TeAaKUX(X5+f-kGjn_0Fg><@soz@qF~A zdAc_12Rb8Pg}!*@L$3BAy-cL1$orRJdT=E zbmK525|3w3d(*<`cq6T|633WfjO%hhx}bV8hk>Jgnu6lLN6Bq zB)v=d$IPT2KWCW5dsj6M{JVNI;DjDwQt$moVdNsGGj%&si6U$0sz%S>)uDbTbchGC zt>+vJvV3Mm=x0&qAB(hHirttYPjs?qU-l>e%TG!sI`|9oj^-0Y4cTHI|0?Dh#=iN8 zS)h7_7hz2D)pC}!uF@*GG{Ln)W4yD8BcI+8ix7$la=TMPkk~Xt2(%6-zxJ7Wt@yo1 z-4!nZPx(4LoF&&DOCIqq{CIEV?rDb{YyDbziZIst&Bl7)I07@4`n5%*l*)R)Rvsmc zGb_9V6eT;3@v|B~6RK$Cd{u;RfP`^5p|5GiJ<65x72#TZGG)A(z&1W9zGFNOthpmi^VF*}|ga5_IM@=?qh)^HaUa zMwS*QOBKlp^U^p6HH1IB4~{N+Oy1V!QsoMx5fterb(UE9@dOw^Pqvl5|Lz+{eEi+C43wTMeKX`xVCG0&V+h@TwQtf~<0R)w6@ za%)~Nwl_6To;gV^Q%`oKfVwG5RleBaM?~IJi+sefUnDz9`+Co#*fip6QBUz4>VqZo z-tHHeO{gbKA&epXjPL`(Hwa%PqzQlwuGHIgMOmUpnB?ucvV6~5d{uh8Dk}nS^yA&C ze3>GnVt-=Z`|uavuTtZNgSgJ+FHXww7bQmUU{VdMnBgy?mf5$5vX{bJgtXHKJ6}GB z{kW!7Oa}Y}tOW7=(ZrT))K>hn5@LZdi2T46Y_@XFj*sp<1kr?PhA7sBF4e( zfKORrHB8p9VKq!v;$b)XWGzyZvchA)I;h9+CNLNjpq3+Y8`#jqnE<$_32j?O*pLzVlz!Ug~?ps|varp<$ zQ-*)I1-&1pQHyv>hJOh4q1O#A7vb*wFJ$)I54iJ3kK;!^$j<-&3@_sH3#+Dx7s=-z z3@7rx#2fuz<3)J5TAU+%qm=VmtI>er&JdNxJl-GPbTkGH7@|`vO&F*nvfqZAq?=SksDQPf)HJNjD5l z$Z#MDD^V6p1Pu#PZ6%^HTp1#aA=?U1YzO)H7LkeXJapKy`Zq6j@%6me2%FD$;tut939 zs#tuFVS~gK%?qh2!v={fnx>vlGi(rdNYazJ`UPGk{1@T(gjvMZ5hf5WCyXLoNC4n2|Fha~(&B#>kl*2d5=Y*j z|7pVYAOaR6U-|y!2BYF#{&u4XH>K!NKLdzA!Lhv2EQ-rF5ZV~t=Qv_}!pdvxjflMo83^_%pD&Q7Dcw>sdqxe)LU^>C^ubKl8VFzW3&^{?Evt{+D3%-aH?& z%beISgU4Ae^#88>>3_oWebVS7`ew~A_9f`kK(eGVH?0r9R{^glo-f1SW%#}Fi87>Ft z@Pd+28CTUg4)7}8=v3t^?^WgE0F4XG55Nl=Z|?8S3(jv2h!B|dd(r}A#lwqV`ju5R6uQ;tQuUOxgSERLkUa`6_uUOTWR~*xqSFCh+ zMWbz=;}t7T;1w6RyyE3Xt--wgAosk5EJi5P~;` znZ_tiCyQpqI#_05d7iBNxWQE|yYRZk6V<~SO&6EIy~zu9Pys2kGt`c#D3+Lvz~#-Al+D=AyEv0=|9Gmwq(jkKyqJt*Nh$S~Dh56$5W z{GgnF?{wUNrz`paBDJ-pWr~@*4W7Mv&4Ek?y7)3?dZ=Uzm26>Hn;4edRue~_wQ_)M zzT67s4q2dS{W;R^){6KaTFZGCO6ER+cvp)*dFWW{N8$%s&l`nW2#?or?QLxss|I6l zQ{5&W949LFBCreyjVMXW(-NZkMi=>i~- zx}nJVsz}{{e=%R`V_jDiN#)(yA$WxpqSoDE^?u#w3EWMv2+Iiz37;bzzn+XeBr5%t zahEo?`RQ8#<5~N+#_yBQeN4z%e|qr6dEZFS8%-KzRsg-0LQ_zp@!RqWC7t(cLo4^c zr~g^$pRj(+Bdc}Nn?-HO-o$&)(ln64>Np5xlmSWIF_5k^i>|~~5<#5{(_&Pal!ghk z{dl=kPzfj1aW{1AsHxuQ%LZ!g|F}p$9er8%UDsq=q^OYh1F~eL$84w~E0un&U_|v5 z0ewkSU%7y<9qDn)H($2#ap zRMciWqvpgi+x)Ie9vr0B!+Kpynihg1dcc`L{AuEz8F7>vpV5NFShmRO znu?MV-mTeu$tl@ebc94jlEhUzp7ilnoqf`wT3*vpkFj1D!A)WOiEKUVCOP$N7{Lvl zd6+L`9&}LIP1v~uyO17r05hyjBe;``ce3uCCnNTgSke-(_D)#2Uy-f-D-}ataW@gm z9}7Pk-$y`ay)_sT+iJ-eKr3(MdsUGjNk3W+;;{)Y|_M zlhOgCw0i{eM$)%TAX6sbmKm{a<#zv<-qJyQUApv4rhT`%(V`_3@^k_uHN+Gu*8Q!< zjiY+^xA}G*-7^@W5-3&XUm?xK*mh@%`~Sx6;&!?yaoMhk=&JJ3>JDqWrH5*KEBB{o z^|l_DJ7n#f2uN5d+1xG=f|&s^X?lViiB! z>W#nNQethK0t4XyzPx3K19ERKL!!5O=RgcZ2!=~CQCR8thL)3?2R7JuOf?jatzxpl z-wM50RUZj-jRh>oXvP)|WICz#5BeeF=$;}TEGI- z{XRk3rsXWB3jR7*9*}&#BTJ+%I+qtY2gA7-w!3N_o>n&l4mLuEo2goNX#x6qOT~C! z1(wb=TVbQ!ahXyWe;@}!RmjR$2R8v8_Mo2!dTpNwzrt279!tH@| zvus?V5}_xwEmbJ>iV_BcSdTA}Ohj{hh54#9Up^k@b9Y4ct90-(*6MRyqqAq3hcV1r z-k2^sCw>sQa$lY_T`?kl6rnHc_YmvXS@&9n5zp@UZg}0D@VYzcoSuDx?T0Fe6ApWJ z6Bml_CN`Skm0?tO!>I12+hMbJipABATH<-l?4T}}PV93`R;lOUdobkAsU84%p4THT z2mb&#^r%``zxiwU0kc=@SIDDtbJU~ji~#AVzc9WX@Z38X(esSxdHNYvc|CmOk>*IL z=iT_b^!X?wgY_qNH+_t_ee7nJ?>4b7(Z`^6dB#}DejYN%la1C$&rA3k<9udK_bQ5{ zFj>n?)(J%_>%uGSmKMKNWlF2Aa?cCqC9Id&6`h07>)=q-ttQ}k8ZN=9wwP+e`pw^B zkugJA^{d45h7K{F*MaxzCUy&BFLhwX;}w61Z!@vaFy4qe-ouRdu!+?PDnxxcUq+mB z*1_GNqMnHgd!ABCTzSmne;$2RnYRr~J44x$+YW3Gnz0_yF^<#cuDCRts_0$y@a@VYsDXI~hw?FxIufK+=HXNxUXog$O{p;0 z7PQ_NanL%<+1J@^s)T_fbj4TYa&_Aoe+Vw-`Ki1R)&C0pB2~~Xfin_x_0o-jAgq2! zPhp2)zVwKRQk4ed6Wb0N1z>0bY`?~;g?-%F;l+f7aN!(CH}qz>0>c2&Om*x<^A<{w z)QN2Hnv2%{vi+1oRss-L@-)g*@oj3=eeug@ZJS_n^4yXbvwCut!(i@m*~|T~sXHc_ z=dLI(m8}xkHds9C0LZ#|#F6)8@E8VliHg;mVb^P5oM*-Oipg_18jV#GZ#_GLWf*^! zu>}NL!}LBinZXdj12M3D4(F853ps4x_V-}>45S23Ywrk~wm|1765}|zXu~xqSSZP&HD$S?gPid|V%+zl^I;IE*WH?KdzJ6tW}kFK-;eh3NZ^x|H@K|NW?A+nGlrtjVz3#V&>dcMcO- zxCacp^5D*Vj->}u4b(22gIOqxAH%>8lC*My9MsM6LPx=UBbcxFK9Yj&EcndIQ3SPS z`^3CEhnaAuPdZ#aF=BW83D#9*7NWvyMF7zeooGFM=~sfz(;VVnhX}Dq=>P{FJrHDw zC&b&@GJOAtO^~H6BJ_}(ryw^Xn+|~%DGsHZdyPbDFG+hdQ|M7r@c1M%4v${;)H7I{ zCK!=Vrb-@0q;Zw2Opgil#@EtZCv|pOJBN3u-|Wb1>GtiohwAmG|4Qc%?zC)6j_U%P z!8SfZOo29T_=S2f$Q(Cw$0ZZ1^Gz{_M1B;TlLC08!(6?!1(DbLKFdWDA#3fG<}Id> znlR|+zQqKJ>YN(1wq0Rpjf0<@Z_IQt>v7+eqm}Htd>Z}aJ_Fdy3*BXwoa`QioCfb$j5Tc{?rSkBTME`O{q6>S}>2aHQv<-#n; z@%wE4;^3!Mk5tQ1#n4e82=6N&Z7t?qa-sWG4bEe{_J<9x2+MxHId_c7zL4Bt%mk8` z@TOD7PQZO3*(f*grc*TJ37k(TCJZAK5ssbi3H+6?k3i$u^F)E+fF;1oo+qCAt7-ag zoF|5ypXppyes*tOA<3saxZ=&qrz+K`Q5#(*CfBHqCirr>^yI7cy4jd1NB_~Yn5?a_ zw~c$4SO=~#BI11Be2_E2<0msC$lHpSACVmt@p?ozK#zksxYw{qdpgMm~KeO+(z(3l%ul@`m=qQ{MQ$-ckc9d^w3u|Mf!=hgYfEw*l1$-zVxW*YSh|1n@uA1y zT_1dyb<6ltM7l&KPwAO{Ee@U*kr9=S!n%{m+G)MT=yjN$pk`N`nP|@8(4Zl?@9V=oiv|% zG556wrA}&l*c)iQeBLs!+;N_>vSa#pRw$AOBf3A63>SP$zvg+v{8PX`-&w{_TOKuf zO|8?XcV9{yqf9nLO;PJ4tXJ!-Sw)RjtFOsgf?;m!pyZ|MZ9(_>$zz2r{gcP~wVwN}+bBaLgPL%LwpBtf zKI~H^pz1Iko}%A%bdEBqvA$M46!M8CR{!guA+OF;ji>c|W!j^Nj#kfypz2F}1uZ9M z>Mk;MQy6;BGMPo^dOzGEh#6`7DalLKiGtR_y)6-M@2Or=oFP2)#&?;1imp^`9>FpcnO!Z!&&CpxULyRC&_P&DSVg#u5G9;XC?*65vkCg|f>XT(+X;^mzD-y~ zxPdT}Foy6NAxP+_@1VC}Ct)MuVM6A=Yd`no6n)E2!dEkqtGxx0s;fVB)zvp#5}s05 z7mi&plK(G=hQ}^yx%#@RuD&WfcJ%0Qc*^H*3SV?l_@d~@k>Qb}E-4#z$;Uq)juaGB zmYny|zq6QW`LF#>^345aVc?F{g@K-*7X}u5xiApDyD+f&YlVRV{@%~u)is5I%ErP# zcsluJkY^6@KPw3I5CT6h2qb<5%l|e061M)dAP`+$5Lias9fYm77n*SYW8^1a8gTmHJsDs~?1jR2StR@tUD+t_ASWVbUSau=x5(=W!MW`gqC9EFBU+P#u zxP!3g0{#*bgt>%0XVA`>v`bJO0YaEiNm%eCb#JGCJE-Sb@+>M06f7kTQhCowUK<9ztLdZ7-(ZgbqRvA#poxe3|m(Q{K6R1%x{Y zs|g*1t%QQFP@WJaEF&a{Q{L5lcMt;m_)WNj5Z+H4^sD1(`ZkX~6BaZV1`_l6dn5fO z%)O3zeV+2bc=fNy|5d_j`bymW#NAKa9mL&1+-l&~1B~YalPF`@N_z^cw^9#zmfcPK zUBvOX;2z2n0)!s&EI65X<~s2u@MkKxLg-OQ@D2VbbfoDg>6ORGL)fFgz0^(ELkMpM zzZlQ5=V*uiEg-BW-0=hIq3*c_{Q}`4!q9$!)u;3e>|xvq`Z<@dfN(!yHDN0uESLkg z1b^oe77&&Z_E7&|Fkb?+FyUN+{#$1L{m1|L=mn!Ue|u+J;iVVXf9utr0jGTW2mRmd z=(@4}-mi>!;j!v3ZaMqwO%?C{ZqI3-z4G&+Rj2=D*qSNppWF4#mnPhQ^sO&Fdf{s~ z|8U;oFQ5AJftTO4Hjo-}?wk)TyJgnDfAWrtKJxL)o_yu;gJ1RZo)P`es_*?`+w-&U z{Me5hf3$JxugkaJ^W7!Cyy=~5U%s!!`}){#ESP@P_5T*Wb;dJS|JT1f&~NzM5C7z$ z)sMVgJnmE1lvOVEH;n(zdAncKqR~zh1F?a&7bP zKe1_k=YvNgfBZs`@3%jjxahXKtv~&%{kgqQJbNr&aMq|d4*Y89XQpla^Y<6taHzX= z(%_L}5)a?L|C}>l{8~EpA15b+|5Nz=qmcjqtKEOJzyH&6_g=W_$}f-k#P!b{?fAv_ zUi`)08EYFyy?*lR)4%)0%kO-4cJYJv{%GLN!Wqe7YgUeotXtx1XqmO^O~>!`PT7k4s85Jr~k=s`68b$-TN;;TG2A`_di@cbJuN$Z>p`i?B369 z9QnYek9byh-7@|0H;3%mIR48&c(&$Ww+#5~M?V@|Irvu}DgV&$3*Px$>Eu&RDzB@* zaq!iT4sO2bg3W7}uPnXc&TrX|e|yqr&U|2jHEHd4YUX#HVc)qeGT>{^t^D}Vzb?4H zIdEF%ch4xA|B17!7gl}b7muwj`%ho-sEI$?Ic4gW`)0iP`3vT~_Ql&kqz=Jm-w3_RQG%&HkMOpKZJN^xX@hqoxl%IP(7^>nz}+TBClwfk99~K(K2NJ5lT; zRKUVKc6WEz5O#pwirtBwAR=OSH+Cy_-seA@^WFRVF6TV%*)@A+?{_`#T1(F{ee7Si zOwGHmi~Qbsb;yq+dAAn2u6ua4%R4XK$C8!nz1F=vbbE5B?q`MFK`FYY*)G`c(S2PU zl5LyrZPw5}w{(B~ZS7X+9v|t~zozcs~+F_4lgocfZM_KI)$Dn3uV-?t9sc ziTQQ!=M?C1Uibe}?GMZJ43hJQRM2zSeRbMYJ&P_&HV@PD7-Czrg`P?HlbGC zK+mp!-wf&W{C<_ZR7=mWKvIF$dX8_39B-*-c|T_EQa#UmowiNYGhM%PSQS0jr(53y z>e*H<8|IJrIPQx@d zR_)t)P2=O&&UbAzM%tIm5}UQ=?wfEi_p1kIuZ_9&a`?r*Z^wm<`Fx;XmVq0)y-%}t z!O4{gV>+eV>iqqPX+d?j9DzCA%cdWYBVvrn>+`VNg=XhV^c}V7ROv%Uk}{<`vaCv7 zXV)diyX6Yl<6rIckt+#xi;V5^Yf0g8Enfe)R%uhe)9tb}53D^cTaDh1NrzH2hAXc- z6`^rl^xK?28p|Kb@2AH02+y(Z|Bdf9OAnsb7%x(I zQAdsQmNqSBYOLRQT{4r#d$$5U-8AMW*4{Nk$uxLHa#d9iv=L$NcYnO~)v=)&GZG`Iq&W|CNL382%Rx);U;t zmGxTxE4R`y%9_1FIg*a~-+7XSefHoB%DHq*G|O1{FYmIjPk)|Ue^He31?%Tw`Tyn& zzUt6N4nq2EL`&|2-IS2g{>#=UyhdUXEoXS)A$m5It zRj+ujs0ng_$BIHwP$JKua-R7HTQML=P&PB8om7* zv2oz$vh{ivnV0?2fR>qp2iIACp{*(F>et5}`1N&Zc=}AfncEty_|(7R!qJt+d+pmb z@|SJ7R{5LGFIBwFj|It7W^J{Xy;nBU9!q zS+ix&kuz8BJZ8_lUitDDC|Ia)k)p+lmni97shhTOPe)<*LVdJLFTefc7zGG+1uHAd~?%RLh;Gx4uj>g6vi$9)lBJpI>snci9o;!cx;-$-1 zu3o!-n{vjHgcSf)h>R~Io4x!nvT_Z?6bay zuBDec?%(TLSM?s+kqRfJUW?V#&!p?<-_*~cZKd!{Z@ zudUanFvFkNRrJ~#7G4`fmW5x#Scb7J%=%i#2py$g|L-vd+byi?SpEF>tKQ4jdYtzC z_oHL=4*%^-JzB?xajXG)ADyRTQm>}h`fLXKbiUA!wi^HQeunj2t*5?6n022ozxqS! z(UyPD39}xf?f!;Yg@L1^nO|`eOGm4s*v<}K|GR;uwzGj_wT;(ivleVO>sP%;>U(KL z$FN_=bDrLdoqBENmEOa8to4%CYwLLJw;uQJd+AV}rZ@QS9G(B)xq4yd95z``?uT-_N9Dc&%eh+!PZxOK^L1lWk4hS`%yROa0*(-Dr-{zSN)pj?tRM zx=F{g^?zRLy^Md~%lg{7SI6pogpTD5UF-jQf4z;~kN2=1lX{$CVw*|to4Q>~>-+E? z*3Y5$;+WKH=$zEoY_Ps&i(c}pg(1|A99kZj2NjK8Wdg`2)x{dYJZR|H2I>v@$ zImfVJ4?kMxwb{DDevZ+5>6p}GwM{=9uk-XIILG>$mz=BXrXHj1+GhPMx?bvg=v>ZA zeP8S6;~?wjNWBj4p>^wfTi;*DTes1`o^H@(kMz7gyVX60I zzx6ZdTy57<+bnv`zglu!>Nb`fWBp8eKke5!*7xw$3+pxXJ*@k*UGHbn9$xBL-s`_@ z7H+=9m1vMw4a3Zh;?L(`)N{ z^1jyXdLRAhnEz+V=dixlzwfR0XRq~rt;ce_^%|+y{lA~@-_ND@PQ9+)(|V26&(3S> zb#(32WA&L+Ut0{rkK5zR33_`!Yr5xa-Dab0?6G0H(m?I=<+ZQ%wf1laLHqPr^p78_ zI!5Qv_DMZf$Nc-FZU1wu^?h|sc7op5mzR1^>$xnoPg||qv{&bYwpu^0mi+ixx9eQi zt?#4H!fSrCFZFZtTI*o_PVCn;^`noVD6!6wtY`wYPPj~z7G6eyh5b=rVP6zj*cbKh zWX-CHe>K5d-$WCC>f~!OalVQ3S(;d~&OXj($+~qSb~IeAkIRWA|NA^1yQ?0(E9+ok zUzBwiII(1%eNkXxUzDr<3SdXB>&ViHCF`!N1Lw1J;<}Dp*O8?YOV-)P`7BxIJ@jL? z{%T=qv5q;`Sy~v67VA#44luLd%ziWD30P;zem3YI!-(eBXwEZpo|$Dd%V<_v1H&B6 zlKp1(1M4iKxlx9Z4|J#VaZT18S!Zcs$z9{rd|)!OpKG%2$T~~*v(3a+^MT2TW*N|<$W>B@PooafEbo24t~xpJO2OK+C0oaf4U-YmUYx^kW? z=XtaAX8G@ruZ0)jYj7ihbv+Oh@0j`tV_5?0CJr+B#sh#-h3i>Zk6=B5^$6A@I6n0eYr)gtUlYHW zST(V3a^yi6jAMgkYSw0EKk(;}SZBXsSop=lauUl)oX5J!!jg5%P{f&mA?Q zI53Lke*-d#lcG3|r(tHlnf+$=v(7fQv!8YA3D#j_;XpmU)ZxOlIf=(*<_*mZD>M7e z>}Q>AY-c~~zBrOoI8RQFV(H3xu56ED8O3qzH?!Z&elz=7XB*qu&pOxV3+Wdgm@gQP ztOH9EOOug$BiLYJzlHsLaqI17-H~;!$a!4c@L=h|c?y4Nz=Nd+=dqs;Z&=uGVL$7@ zlKmDB3n#_`OA||zg=@zGOA||zg*~yrKkT=#pLJl#e%85mEU@%o>A`ufoaf5YgC*~8 zVZVj_7WQ*JuFZMuXB`ZF^x+K?OWpXi%{6nrne)w@Z{~b6=bJg-%=u=6e|a*zAxkjv+5=3y_5el+*JoLS zC75{a0VZC10OxakGaFa}=W~6Qyykqa&vxK^uFrN}b3WH+3B1Ao_hZABMrnIq^)9!j z!cpH<%R*DG{~VoMF>GH_x}-J-?7Asu7z&q z+c~t=%HTdzFXkWk?Mvqg-4|rOvbyz|HeL42>fJx6!S6TwZ?(--tJ%8gOCzFgY%-=D zx}5IoAaaoY~t*|<;XRcWT1Ur4t*FXw+efA0ORr-SBg9-Q~t zma^j?eJ}q!=aBn-13zRRkgIUQyoZOFE}wsY|(BbU!kTJkRXLFIZ|i+tXG^3}mA;f)t|$Wqia z_Q0@f1s?YB=+xBHY0QaEoz{FCJv!p;uwe_oj2bol@5hhM*Lw9je6L@>9WxUWnzZ-! zZeVL;V|T7ww+;UkEjs4epFi1lU%%e5-lk1YUk@F+DDu>)nt8&)mQGGe^8GPp%*1y; zeq`FoAJm)?7?||){rmKOTeiH8xpJjjyOk?{*W9-4rPq=rM;otR{q^y{f%6u}#zklbfI(zokx&;dK>|L&0%dyp~`+ffU)i(UhnUL;f%Cv5{X3eLIPo9+d{^5h; zqX7eEZ@O_~P{&fG8W+iwsk)=d?&047Zym>3q+1tC6T(oF+ z1_y_<`7&lKm&0ONeE-p-s%KxlDp0>*!5-sw?mYW)$dKh3)27XlD?EHz^J2vYm&u;J zM7bO}ir?wmcjvB_E#J0^j{dp2QKK(ID_5?!_u91%V`5^?H7Z$vv%Fy}8n}=aK2BPuJ>p1F`SJsG)~`=q*|1?sn^mj+py*ip$jB+x zXU*E;xpe8F{uL?&efa#@)alTn`@{C^iQ9JT))0SB&rW#J`^n$G*?*^`WH@^1QlHSX zXX|Ela`GtP?p`+j_3M&H+O>OFcK-a8lWNpBQzA>2inEU&Z`O3(x{trcjtv`GwQAtW z&Yd?OXw&9d>1^4GJ{>e@ZfyJZ(b+;n7c2`2xwz`iopCkt=Iz>~NRhFXqoOvYpEN0a zTCG~A65qZp+-u*y%Y{5Vs;s+rZ^WUtZ69S$pFY=?+qZ|_e(<1j=hCJB8Cr2g@yZZ9u$K^kc z7%}zgvuCBJo;(@Qw|w~)xBB$iYcqZNv>jKkc3x7y{-xjz8y?)~-Fw&OfByNA^68Vq z`Ij&ApX$&B>{pc`rI?CigO`C^kZLxzmUI&@govuxRRTbnie-edp%3t1*in7J@6u6dH=7#flZ*(oUXi$?oi&rOVNyx2`{ZS}MZd z|HOsv-S>t0`NbDrxNv*R;>CyMc5!hVwSD{P^-Y@m>T~emwPKkwS6YJrA`rkr1TY-| zI3s|=2w(>SXo3J5AOJfAumJ&#K>*nhKt}}d6ag$k05uW7QUu_O045@UObFl=0!Tst z=@Gzd1keou{6+vT5x`Ld@D%~fLjbK1z%c}n69H^R06h^vO9bGD0BjLJ2m)x006rmr zG6=vC0nA1KgAhPt1W+9TI3a*W2%rlBXo~;}A%GPKzy$&9MgVCMKsf}k7y(p800j_0 z4+L-)0W3!VIS{}y1TYu@lt2K*5x`Ca@D>65L;zn9Ks^M|0Rfyt0HY8&Rbz&ix676GhB0ILx|c?2*O z0hC4n0SKT40@#ZHrXhgN2;dR|cz^(QA%GtUzySf|M*!OpzzhWN0s&-209O&fBm~e8 z0SrU{`4GSd1dxaT8X^EM1TY!_EI|OC2;eRPxPt&DAb{}*APNEaBY@)wU?T#!fdK3g zfDHo3hyYe0fOZJrI|8_X0A?b9<_Mr50@#lLDj)!N1Q3G&d=S7v1kfJ=Ohy3f5WpS; zkQV{WLI7q25R3r+B7ory3KbfO03s2gEd)>s0h~Yp`w&1p0@#iKh9Lkq z1aKMw{6YZN5I`ja&j+>I z0vL(_P9cCW1dxOP#vp(n2%rT52t)wy5x^D%a0LOZL;%|mz!C(o8UYMM0I>*QF9P_D z0A?eA0tlcS0;rAvz9N7#2%roCSc3qbAb<}DU;qNRfdEP&fJ_L$ga8r|fENOYM*vw7 zz&r$Cj{p`S00#t+5dl~bz#|0k3IP;E06P)D5Co7G0fZxfVhA8R0?2^?`XYdq2p}2( zG(rHC5x_MB5Q6{;BYG4gqXL06!5x00O9o0DKU@cmz-r0enXQwg_Mx0%(8$svv;n z2w*(|Xovt-Apl*nhz#s(B9sz_RfDi<52La?o z07Vc$6atup0BRwCw+LV#0`Ncp_Ygo^1dtv9+(rNo5I|`JPzeE~Ljb`DAPoY@hX7h5 zfMW>YG6L9)06HRonFwGm0(gu7Mj(J^2;d|FD31X8Ab{xz;3@*Bj{r6xfZhn;9|Z6T z0lY*2T@b)X1h5qWI3j=p2w*q@$d3R@Ab^|*U@ZdJg#b<>g0P-M!Itbt} z0+@;brXYa+2%s7Q*o^?XB7h(SV21#{Ab<=ApaTLZivXG-fc*$y0s@Fb0J#vrG6e7t z0enLM3lM-C0_cGNZX$pg2w)BZSd0L2BY=qr-~|FWhX9%)fI6Quv&NdMoG{(m9;|4aIR zjr9K>>Hkd9|MsN+wxs{(NdNyK{eMRKznk>G9_jyU(*H=(|2(AslS%)7kp90T{ohIY zKZErDC+WW*>3>9unxy|;r2mac{~we7FDCsTLi+!Z^uH?Ue_hi5-lYFyN&i2S z{)dzPcPIUCNcw+~^#42Q|0B}>O{D)FN&kzG{yUQX&n5k@Mf$&#^xvEGzdY%GI@14= zr2iR6|MQXl=OF#RPx^nB^uIpo|2WeBm!$t0N&j<^{x>K6FGKoYj`aTy>HjX$|5l{` zt4aTdlK$@{{U1a6--z`8F6n<;(tmf-|Fxw5*8ifJ^goXD-Hi+m|0|^b z(@Fokk^T=P{hvenzku|AJL&&;(*J{`{|Ti3A*BCrNdG60{x2f^?@IdbM*2U6^#29v zzlrq!59xn2>Hl!j|NNx?bx8kLlK!_L{kM?*+mrrRC;j&%{qIlu|AF+s6Y2jj(*JFw z|Nf-^X43yBr2oH3|BsUXhm!thCH*fz`X5jFe}weEEb0Fw(*F{q|FcQ|o09(jBK;pp z`hSx2{{ZQKY103vr2ny`|Jg|Ymy!OjBK@yH`rm}~zcT56deZ-Cr2mPe|Gh~63z7b> zBmF-_`k$Hfe+%jVZPNeFr2m6S|2;_mXOaFpk^Tpf{_i9GUrzdenDjq@^#3^Ne?`*& zQl$TvN&i2R{$C~ipGx}Qm-PP@>Awx>{|?gsC8Ynsr2jWa|2LEVr;z@iC;dM~`u~aa zKalj_mGr+K>HmAu|JtPgtx5kYkp4F#{U1d7KcDpfH0l2e(*NhA|J6wU=aK$*ApLhH z{dXb#e?a;_n)H7F>Hith|0vS`G^GDuN&j<_{vRX#?@9W3e|FOUE~Nk0N&h2A|1XgKhmrmlCjD9yvs>UH`13A@O4 z&oa$gGWTeok+0@9YH{nzk?`Wp2YX%)e$b=vjHHt_h8&yR^V5tG!xuKM)~n$D0e6o) z4B7L3(v~bq=FMHloU62})BW06pJXo;Hou`y`;Lvr)!fl}*n@+;wnqF3jn4VqvFM!s zLEW22*8H7q&b{6f8;$z5chjKDUIXjcK1$9L*{o~RO+|LTD&$ad_c6N(38NNWF7LR; zyU@gsUPssLw6*Jb;7#VR)>F>sEV^#Qu30G#AK%yS@n}VtTc6IRu|IP4VwsM4j<5YQ zrA&#&OIM~ejkcfiu=MILuZE-#e_heH{kx5A2P{u>xUXx&YMxWR&%2wZ>fLJgTkAbN zTx({N>AMFUZ)0ytbERMV2ATe5TktdAwZkvwPxcKs)9vQ6VcVbkA9k2Lb<(qJttyN- z`S$jT(dhz5`@6jO7LhwiIYe5^gz(Zu-vs4$>%X~o%YpTOXZZWmWqgHys&2iSyIk># z1=G3Q?A*QeTF=F;nq16Ru0$oLblrB$ZuZP&*V}oQax9*?%o3Xr(&3JIWy@i8dgRQQ zJ@cd42hznx7kN@8?}LDhIkM!+kk&c<$Ek^1itky!-y`>ilg&P48^3LcL*2Iv?;cz= zuKn+?HU*Zq9{BlCjjojwTKybbW@dqwir<9{s+0_J76{yOGx?>fOZP`iVCyT#TD`YUQ5=SJIbT`#JRdnvwSk-P${& zK=mz0R~M_a^l^jXvz&XjJF~dS*jgRGOm{yPbz|T25*5F;4U6CQd3hVlkscRjkM4K1 z_=fZOGsc|Uys)xs)-mgzFX`0xcIAVk&K4M+wr`89pI$H8YZD%_X#LZ8*FRMLSJHSK?bj#Ip*6mA;Ubz0_)8|^C`=aX|rj=je zG_u7vj~TDrt4uz(q2SxS9g@mE%=zTa$iN*{mR!2uqUpy$)w6n>8!;%c{L#i=&%SK; zdt?> zonr3Y*!6fx=YQg&MxBo6aJBTF{z1K455BOknSTQW&=>*4BY=4b;4}jGfB-fjfY}J3 zDFXO{0A?b9{0QI|0=SL_Pxp5kMFMXpaDDB7g@7AOZp8 zL;!OTKyw6;4FOC<0DBRD7Xo;M0Gc6yA_%|%0oWmcMF?OG0{Dmkb|QcS2%t3rD2f1P zA%OP?Uz^= zAQu8ij{vqHfc*&IBmx+Z0O}%ug9zX^0$7d!4k3U91W*P63`GEU5I}bX&)82zy$=*8v!gt06!2wUIcI)0c1x2HxR%(1dxaT z;t;?e1W*nEoJRnK5I_M0uo?k8MgYzTU@-#dhyacufaeIHEduzA0FEGl(FkAz0*FBX zl@Y)?1ke`&j6wiu5x^$|V1oeGBY-XlU@QV~L;z0_z)b{j4gp+20M`(}HUv-#0eB;T zSOicW0jxy;+Yvw}1W+3Rd_@2m5I{);FdYHZLjX+>zVfPDyH90D*QfHnwV z5CSNH09qn|MhL(M0k|W8X$W8>0+@jSCL@5i2%szic!L0{Ab=JKpgIB=fdGyofR_lM z6$0=;022^EC<3U40E!`ib_ie~0&qeAQxSk40vLb*?je9B2p|dpbU*<85x`&s;Ew>- zA%HFjU^N10ivW5dfSL%PIRdal06!2w9|SNI0n|kR*Ac*J1W*G3tU>@S5kL+EkO2Y2 zB7h+X;5`DEj{v?SfOZIA2?7|209qh`a0K9q0D2&RlL%lk0vLe+sv&>@2p|LjY(W5< z5kMsbP#Xc1LI6GpU>pJ%h5)uAfM^6z6ajQc0KXAHZv^lS0bE7^wg?~+0c=75g%H3o z1TYE#I3j?F2w)8Y=!pQr5I{}@unPfvL;#Nvz$XN71OaqJ0DllbV+7C?0X#$iuMog% z1n>?4EJpyY2w(~VNP__E5x`*tFdYH3K>$|}Kqdt669K$H009VK83OP}08=}0A~b{hyd0jfDH&B8v<}Z0Cy2UdjwDb0enUP zl@Y*L1W*_OoIn7-5Woina0da5M*w*dfExnHhXAS~fYJzH1p+9E0K5@EBLt9)05T(h z{Rkik0dz(H(-1&)1W*hCL?M9s2;d?DScw4ABY;o@a1Q~@KmbP(z)}P-3jv%#0JRW+ zI|A5;0KOuCZ3w`E0A?eA;s_uk0$7Lu#vp)B2;d+B7>)q4B7nUJU=af7ivXS?fb$68 zIRaRW0LmeNvKmfN8Km!Eu1p!<`0NW8j zJp^Dv0J{;uBm|HL0W?GaFA+dl1TYu@_#uE?2;dR|_y++5B7hDEzzG3(Ab=_epdbQB zLI6(?zzzg(9{~(P0Ot@uc?5740c=D7{Sd%y1dxINjw66F2*4Ks#3O+G2p|{%%tZh; z2p|RlJVpR<2p|Fh>_Gsn5kNBpK>FX1^nWbre|FOUN~HglN&oYZ{%3;#z|J|hj_elTqlm6Ev{cl71A5Z!pO8P&Y^uHJBza8m+Cer_- zr2lhC|F4k#Hz)lMCjFm5`agv9{}bu|Lel?&r2j`q|KF4TCz1Y-A^q<}`u~LVe?IAd zN7DZtr2hv=|NoHwe<%I#Px>E8`ag&CzY*#GCer_br2omJ|6NJ{car{>B>kU2`hS`9 z-<$N`i}c@?^#2X%{}j^yb)^3(r2q9v|GSX>ry>2nNcw-A^uG-0|4Pz-d(!{ar2pwj z|9wgS+miktCjGBQ`ah5K|1Rl&J<|V~r2hj*|4pR-?MeT$k^WyJ{hv(w-;MNtJL$gz z>Hjm*{}H7BD@gxGlm35G{FDBtCH*f=`k$Nhzc=asZ_(*Lcb|B0mkxk&%-kp4T9{tqMlFG~8qf%M;v^godFe?94cH0l38r2lzI|0k0E z-z5E?M*6>i^nWes{~FT&TcrQhN&kzH{x=}~?@9XKg!KOl>3B>nd!{eMULe}MGAHtGLM z(*MGw|D{O(i;(`GApI{(`ahWT{}<{11JZvV(*F;n|9+(Z<4FIrkp2%P{SP4hKSTQe znDl=c>3?0)|2WeBTBQF=N&js~|9_DF|0Mm7A^o34`u~FTzYppEBGUizr2j2Q|6h^* zpCkR>OZxwi^nWDj{}R&wrlkK_N&g3t{x>H5Z%6unpY(q?>HjIx|NW%@6-fV&k^W~U z{XazdUx@VoFX?|p(tk(N{~M(Lok{;kk^WyL{SPAjzo0RvnozZ(>O<8Lsxwtvst!_p zt^R;&QPtn78&ub*7E_I>x=6L7Y9!T_sxwsYs&-awqFPNgk?K3uYpVZLd4RhO%FQLUwVUiF}ABGoynbyZWT=2xFV{R-7->K&+lQ@=sAr+OHwIn~2Z zZ$fphYAn@I>MN*TRGqBehU#AR75?i{sJ2$UuG&;}z4`{K=Tu*+7oj>$y$99Gs`*v_ zsgI(%O#KYiSgJ`?@2hTC-Kcs~eF*gt)I(5T;J^A&b)4#3)o1EKsK20IhU#$jB2>Sr zKcjkG{RZ_gR6DCSR_{S|v-%jS$5n@`zE;b#-imr5>K~}LrM`fAB zTlKp7D(Y9M2c-UidLinGsQ;o~l6ns6*{ENnKAP%p^~luQQ9nw(AoU^CS5dz~Juvk^ zRQsz&SD!?EH1&GaFHnC)y%hCK)GJdjMtuPF9n@b^UrhZ2^<&gOQIAG_IrTKuJ5WDM zy(9Iu)PGUWO#M3bOVp!MFGM{$#lLDo)rzVQRY$1KRBfp`NcFY)1FA(;f2(d#U87n| zHKyt!)sCu>R9C9bP`#_#S+$93HPu9_?^Lg;{!@*odR4WTYBbd&svTAHt8Q0auG&Sl zmg;%cgQ|&C=cv|IO{JP&eFpU_RHvzTp!!Yy2GySGVW{R*4@12P)w!y%R70t+pn6et zvU(e;d(~I?uScQUTJ^eWQ`PnA8>pUBeW_lA>NNEpR4c3ISN*3xis~};GgM=#CRM$! zx?Odn>P___)JIScL4AS$>POXas&7@FsRyC{f_fRM!_|vW{ignm>UH%S)WcBitlC(; z2i48$W2hci9j^LXeGk=vs&`cjtNv7sBTvuMEx7p z!>Ys8FHqk^{R#Ci)YDPFLH!H$57Y}$ZL2k?p5zYy(HDc zs(;nHQGZ4~CiPm>dr}`ry%N>ss;gD^t4E?V>F(px&1H0_u^d=cJyJ`cvvXsE?o?fa-76>*}khU!@+9`UmQT zs3)TSi+V}wIjCo&ev$fUs=w7EQ*TH8DD{HWhfrTd{RZ{G)B{oNuNqx_67|v4>ruZz z{T206)H6}9OuZQO0n~R;e@T5Y^$*mKQU63e8ujJW(@^g~{Ves4)Z0@3MLje1>(nn% zk4n7|_2?A;stHvqsy>sX9aT zu4-r1CaTp`6REyay{7t4HJ<8K)n2O6RF9~3RL!rtU3Ix?7u8y-=T#4?CQ_ZFT30od zYJT+@)UQyTrrv?-H}xA-d#Z<_no~Ut^(Iv3s>V_crM`mdMb*jbZK&>5U*W$Vg=%Zn z>#9vv*Q;-!dQSDFdJ(GA)O%2^teRi-pZX}O%P41#sm4-Gs(N2_yXr>Oo9aWTkDwlc z`U3yekE-KT->N=S4?_I~^)gh4s~4gAP5l|w>*_bChoRb8wXu2+s+-lvP(7|XT=lj3 z9;yRX@2VD7{i!~S`ZcQiR4b}xRV}NYj(Rt$E!C4y-L5`}`ZubFRfnrzpuUOv6Y5{6 zr=xy@`WNaSs28HzR(%}xYSb4{??8PN)vBt))f-aXtKNrtNvelc|EhPR{)~D|>b0o% zq&|>(C92C+SF7$IJC}p}vax4eEiZ2cp_vHM;sF>Z7UGqke((nn%k4n7|_2?A;stHvq zsy>sX9aTu4-r1CaTp`6REya zy{7t4HJ<8K)n2O6RF9~3RL!rtU3Ix?7u8y-=T#4?CQ_ZFT30odYJT+@)UQyTrrv?- zH}xA-d#Z<_no~Ut^(Iv3s>V_crM`mdMb*jbZK&>5U*W$Vg=%Zn>#9vv*Q;-!dQSDF zdJ(GA)O%2^teRi-pZX}O%hb;1KdR%q5>TC5qR0pcwRV}RgQ+*co zYgG5CR#eTZT2?(B^=?#KswbhkU40PsZ&VMf4p+ZGeG~O3)W1+qNBsu%FVsI!FGRJi z`Z(&A2(y$|)0R1d5ERqsaq8TFXdYfeIWHpRF|u+R^6{2 ziFys{FQ`sdUqdyrYIOB_)E7~2LiM-$GwK_tU!q=&>SEQ<>aD03qW*z;Tj~p_N1~pS zdP?d~srR5hf_ea|zg4fRucCgHdO+$Qs28H1i25(;C8_72o{joN>Z7UtR*y`*9rdHs z3sN6KeHHZ^)B{rwM76(aboEKpM^mpy{Q~t@)Jsv%M7=WgV$=sv-$DH)^~KabP(Mcf z6ZL4+ms3wey#w{L)H_mdOZ^x1%t-%tt6!oXm3krS(b*9Hw!nYSVep@$SpORlGfQ8v zKn^Gez2OFIf_ktBNd$(z!>-e?;rtYg3-T!el?Xp0->9HOn}B_^>fy!USXAzJ12FZQG2<$Vg-K=+VZjSFembdGZ+N&Yd%=RjX!rdwUyq z?%XljwQFazZQIsJNJuc!r%!KW&z{{_yLPSd@Zm$FV#SKasZ*znt5>fYfq{WWn>KBX zs#U8RH*enLKTEbTTDELyT)TG7XxOl!@y|d17`=PfWOVJ? z)%f}Ir@{Yu+t|K+yHUJ&abxh{!A8c68I7VviyCIL*?9l{y|H7*4kIEW!dSR)p>hBI zeWPyOy2k0#r;TIBju~ajlrhGR9cv67I@GYYw>SFq>0|8OyVuyTVS`bsR4L;ke?~b= zmMr`SHzwoy_3MU*hlkO;d2^#urAkJJ4jqhp_wE@va^x`F+}wBNY}~lfxNzZu5gi?Ej2Sb= zSg~S-F?sT2qhrU8#{Bv7jV4W+7_C~hGIHn6ZOolJ*Ld*Yfx-WL+vwc6vvKLtCBxO# z)i{3qxP}t{on(-)YSk*^>({TwkRd~i+qZ8UQ>IKY?Ck7}r%#_6w{G1s(xy#oRIgs$ zxO?}mF=x&kW8%b#M(ftCjqvbr!`9Z;ID7W2QM-0+ga1Fh;p5|D3>q}Z=+>>9@#V`G zBPAupSh{qnF>c&A;16Gr9A zm5tEQP-EV_c}Bl}{fs(w>KN|s?#7WLM~qILIvFKOlrUbrcwvkfF~V54Zk;i0+B9SN z^5sU~zI}~DhYlGtX3Q`O7cOjk{`}ea{{6eLXU`s^WXY1o@87?TUAuM}En2iNh7TWZ zELgC>NRuXw(X(ey5Ova${E4I!A6lH zMU3vuVG$RLHn|`LZ!;)F|WN!GlIpQj!r65Mac` z#Tl70WipbJlZ`D~wius2eKLj(8)hUXCK?ut#aOm%nI5NxsfM6JMYmdEs@tX^t+!IB zDctq-6kZyB3NL9xUsWNX(2_RvxHV*TtMzp?1T>7flywMem@7i1xuc4=~ zRY)m3H0%_TQl1{2R3ptuA5x+oxk6iySz)Holis9g=}tP7nicjMiW*WHw$iG?Nh;Q( zmYNlk3Q=iC>XX(rloh%Pc?~&*yi~5?s9~cJQAlg3OBovW8g^2khLplzVJ5{(iPD9B z6tYsUrUOkA(w>H&LPKFKElH))qlT$MOKOw;6#`PCLRnhS)FB;98=3|*jVQDf(o&uj zplLuMpm3LxrC}*g;j8eHf~6j5Tw0X|qzGwFdXRP$Hd3jkCrw*YlcpLeK~t6VqUlKL zk;*mwXo`?NrCUu0(z>QZg}O8>jYv&WptLWYY5LTZA+2kQl;WioO|P0Br8%isVJ$UE zEt(oMO=+r>hNWrgMpL#zT3S#TOXJd)6shpmG^}Y=N|iPg?ozl^C$(sr)s(2|ks(%r zNAE{CW#)DbMFBTCeKsN2p4;+~uo}p)JVsb;B3u^nm4@&*)9`hgF?^!A-7^W9uRPk_ zs3M8*TFKX+#_+ntaERg~ec{nM@bT86hk}IW3~t*_K6)^Zyq;lPln^UND6M4(C2*_wv%W?>!r6y#`pvNGiVmAIT;`#x zN`!h^)H0Vaa^?09M;$j%n?JfZ!%%<6kSahpK0z5BP)T-%P<4iBW%L+E=D; z%@bwUK*J5u&j~a%2CY{lOv6#m9m0Pj)7@x7co@^oKTON^Xd(xSTa89DG2NA6D#*=r znv-er8)|BVe$8mYgV27#)NvSf+(jvmQThs|_6JPIQ&7qWrsr!+ha=JMLDZ4VROXBF zLU^408GgmM#WCEfSWbORXg4E_UJ^oE`6^z7O)nl}O>W;B9_brS3t_nC;%m(!bS4m% z+xXa{3DrD=Z#BNk9d2J+hHH94Y%O20B47V1x1$Yuxyh|-$t`HeBkN5lOhqe;7&1Q@ z{@WR*g9*=~g!FrcN(7JjKEv=dU%d=^8p;srLkMhOm|bL8oA~M;glHvHa*uFuV_23( z1xwIEWAycrNA-tCdY)kx&(|Nx5Y0yjK1Xlu8NNNZxBln)C}kDu8^Z0J!VrCm64G+3?-H65d3@mv!L#TtieWwo<$Yo3EoGP<Q0$QEH(R^hRK;4%9$v@i4652D%thEXQM zc?&~q7+SQTs4x`y8Z{S0VNcNNc!qIV6ywCS;D_GcF&)fCL)jRPS@fiqJfVUc3pfc4##L6=p|A57EXcLMad>RVBo27>d^z-v6N7dMMl(-F8K# zXHax;bd`}IZ6-W-5dI4Zt-4G<$57T-!oi*}-iw+_5xQBJGOnZP=4iJAVUmNe$cd(0 zn94FUWn@K*c?q`~OgB53o^~@;%|us@Oabc&=U*tV0lK?D7>+>;lL_tlgm^1dKNrRQ zWeU553Xh|rAf~vlX#6%|ZiilPq4?^kVGdJQYgBHF%4#!x_%LO4Ljfshc^uQ!BUH4Q z>7f8hDbJKpnJHx+I;w+ekD$F0XnX|IhWiqU5S={Fts|M@TTbWEmKK4rqy6{-koW^0@_%O;tQe9QB2KAC^nAJ zPeys4m}(Q59+$0OF}ZL==y>}pmri89a5>(+NrM_5Io+IdZH}H+ET5-+{?-la{Pn;odUcHnH>w&@U3BzhnCEop6kJbSo4EN$MT+x zJ?ZG-?vQ2mit+iUg-5z55gR_JPUU?uQ!Bf=+qqx3bS&fRN9RiP@9*n9%`(lYijPb6 z_0f|Gd6%{=edprYT%SIkC^xu&jWVwvoGCVE=J-sGcIneMX&jiPb%VM&n>VhLiGmaimuj;hW>CPH!Io)0IESNbto94%?ZfW`36-=fEjRV|2r6iVr@G#Ev*N3xJ z2M?@Ou9%lg$$VZ81-EavcuxwSn%>DaLx%OMrWTD}8J4$q$ND9rW{11i^{eOHy+d%} z(f#XIakNRB*3mXyx`~Zn902#_VZBgRV}|&K+wNP;vC>Lqgf8Sz#F`g-uDPxZfTV?lXE| z{c0C3#JUb2Si4eivnFJI{4gPZzPxD)DCgX~VtVmAm(S;kUJ>f4oT7}6L;1}s zXOt*YI!!qbH~UQHyta8Ocso}3^!|96)vG2Jtl?MFzOHXwCrfCk&GUyzg(EBxra7}G zW+_w3zU;~P)9KF~JC~t~w^Nn=1N=(4y4koLk56=%6goNW-~lzueoHxB`NpMF*}uI% zSz%68gh%s+!PzWfVYbI(kDGp_oUb0_7o4_2sk9Y4cM2@1`sPghd6z4f6SM5wKB#ie+lQozj~|^VuzhD3e-DLC zsppSQ73tlfUh&qAL-IU+a6I4p_p#n*;?6oxvP^RH$e1Q`h0^INHE$4<^~#0g9_>5& z=Pl%!wy??0!NJ?d&gc1qlZCRnr_W)sv9}*SAh=>wl*P4s$J#{-<_<$(JGXBi!+bL#(w?u{ghz6mP_Mx)>do-!P8c?4=*M!&_FT%F zueOUz7vk$iqksoI_SGom0=GPhN9xMZGZCsexs`_)CS@3sK@8p3e2qywlHP>>dX(Y8 zV?EB-@?hwE;*rEMbZQVP4^Y$Wuz26NZxr(@zZb z&8i^?<(z2mBuXj9Fj&vfDTBr?pe9FD_L^b+99_0%h|WQmSsAY1P*xMdVzUZ06q4;<*%vItQcGtmy8Sa$3~vsws%+;SfXKM2LN3nlK2N z_YC<$gjZ{(y!C`;6Q(s^roISt>49n{F*PhezuVE=V{{NixC}>8bC~XaG4aKBW^<;6223x{(duYac7v(s zB>|V;GfnP8^P`ytoS2>(ptlOBHy_iZH|mUF8tBfH5QTQj zFugry8q9~zR-@9BOfLnM4i&#S0op4;iWy5)tb_}CIe61Klz@4zUM94hivG?b8S_o?&!atg?SDGPvk#PRV z4IN{tzY4bV5pBVYX@p=### zBopcbbqjdJvk9q-gkKnsAP%*)=k_*GNbq=)(S{9=U?)R*7LPH2TNK0aZN%_9#*pog zB3ClRGNQ#*48@CtTL%;v&yd`XLi~8ljR@xfgiok?d?>@6u(bYG3&Yfn&^35GjnPU9 zN_)r<_`nbzh?1;oV)$)GJK;QbTS9adA-9q+>d2#>O}P2-*gG&R`ZM%xc*M4ZXbcKX zCahA>OB|0poZ;+BID8~@+N1JIgkxS*8$ftxM8UQUVNdkk2_<$!DYhu*1EDz!?S!e1 zh5BO{rUTK#1(Z1uH3Xo6S%k$yhG1S)XhDf9(CcM%utE(=!E9|gu5?O%`r`FOfRLF4n0*nq0*g9E2WvT_^XOy@FeK|RbkFlOCh68@7=h69iFIA1FbL+3b;qSi$($%MuF&W8euqDqcqX7eJ09Ix^fQ6SKAGWr9$nO9 zXvOiUZ3x8#!f*HU=(9FD zK89k#&{RC(8jMPV(DWHpVNZCUW*YD%)N2w#At=FKzh|LZ8->+i=+{d_0mgJt1LY>5 z+6Y486bej>I%}cTwCL^};p&T;ZJB~%nI5Jy;sLNkbI!Jp~nG+M2X%1$x$B%%JZ`n?>cxAEwpCi-(? z>X|@@A6KD_=Ib&IWMF#oMQ>?QZyKgYThtlBG!V>`5RP^onBEeZ22JQJ0+pU-dI?}^ zNXJw#ktr|5mR(kYQo2hN$3~ObY`ezU9_{{d8zo#QTID;FwLl(#d zc_2R&hN7T9d!RpOP#LO100crX=q5CV7SI8@KsV?GeP95LgK*IAAWen2pg+5?6js4H z*a9)I8;(L8BtRluhWn5VPv8Z-gAec%$Po+&a0VC11lb@5YbiclH+pbj*IX3zrKK^N!&y=`b7S!U|Xen;-@bLjs(K>u?v6;TgPx z&+r{=>=+l|4!NK(6os--9x6js2!y840$M>k=mP^_5DbH<5DD{P1#EyV5Ci)m5l+KJ zxDNN>34DOh@DqN6gNgeEEaw1H001I9rpOoiF76js3o z*a3$j4ie!koQJFM5MIG=_zQOSd=^L#ZjcGGKn^Gfg`p%ggl5nNy1+09g-DnUb73JY zhjp+Cwm=LVg(Nr)=iwq;h1>89Qs5^zq+zUs8)Shz-~~mYBvb`I2!vp$2aTaAw1O@$ z0>(i&jEAML0#?Bm*bfIG0nWl@xC!^+1AK*_@Eg)PFm50Z6om3n6Y4++G=!$m3_3s` z7z86=Dolr^upD;7L5PPWI1A_DGTerT@Cx3*SFq;~Qn^4T@B}X?2!+81s)HXigvQVU z+CV$#0Rtc$7Q=E_16$xQ9EEr|4Y%PgJcJkU4nD(ouusb~fn4AP`JpJ3gt8C-!B7uE zpeeL~cF+q3z%UpOlOYlo!z$PSTObi`LNdI9ckmg$!f$X-$NdLSCLRbzPU=!?y!w?7O;U+wRXYd9-KnmC~sklKV$N^qZ7>Yx6 z2!w{v4B9{!=m(=2dhW&655+NC$z$^FwU*RX%FnQX63%Elb@PwjJ9I8Tf2!W>1 z14ck7jE9LZ6{f=~*aUmwFeE|}oQ2D96>h^5cm^r(8~#Gt40r%?0l#@;6oisc7Aiv> zXa+5y4fKKmFa*ZHM2LjBuo!m0Uf2)ua1pM;ZFmFk;5#_DaL>URvOs<)45c6d0-+v+ zKx1eDt)Lt9f^jexR=_G)2U{QpcEdrq2$$g|ynuJ`6Mlmozia0LdB79$Ls6&*RiQdG zgdQ*mM!+Z-4-;V~%!Z|~3f90j*Z~J24wB#*e1H`A4fZ5V=^+yogyK*UYC<5ifOgOc zdO$x2g>aY-i(v(4u2sB|KoE{C<#7L8EQg3XaT*T9}IvYFdY`c za##U7U@sho({L4%;ThOx;yHpFWPv=89|}WJC=XS^5BN=0BN*C27w87PU<{0daEOGN zFdr7fZa4^WkN{`lI(!9(%)~A58<~bXWP)sv1M-6pRD`Nf6GEUV^ngCl4~D>Om=DWg z18jrca2Vp@JY0sGa2p=N6LLVf2&-TNY=RxI8xr9> z+=e&s8|<<(uD}hlfG2oCaVQC8p*qxqhR_3g!6+C56JavUhIOzBw!jY94@qzyuEKRl zh7|Y-f5DzVMD7Lop(K=o@=zK4AP_>JDYSqt&VWS9#JVL7aUbr1u4Apx$#ZFmTu;XByye~NN|^xzIz zAU_m^l28?bp&o=l9~c0WArj`o3fKY%Ar2BC5l+KhNQQUt6@G&a1-LV~Kn|z~!B7Vp zLN^!!qhLJDg!!-#mckm?2D{-PT!x463|>JB`~^2N?+>}4AQXn;-~)kB4;n%{=mcG$ z2MmKTFd0_BCfEV{As!MS8J@u#cn3e>FF1R0AE7MxK`?|s3up!HU=WOf@h}(W!wT32 zF|ZrrAQ7&^U3da7-~)VypJ11l@dGZ913V!=6opby5$Zq)bb@X$2!_Bo7!MO+CM<>J zunP9VVYm$s;R(EfuVClJH6c9|gu+k~e4s4Ugoe-q10b7389fgNxZ5+Dh# z!d*y)caQ?#!9E|?gDj8@3PV-!g8--p?VuaMxVJHigp*qxo#?S(~Ko95#qaYN*Arkn*I>vI?0x=K|NpKpj!d-X=pCL;@ zz892*@=y;NLsMu6y`T>af?+TY=E7oF3hQ7S#K3-tg9Nw;$?y*B3ULp?8QdWUWgO#~#AK>yriE7Kv79xm zWfPm(%6^V>g=^g6F8As4G4+sv3}-BH(qyQnhGsfg$P!kuf$i*K563vcIWBUEtK8rL zy~oHmhEhh3iBwQeBePk`dN#6^UF_yCM>xd=NCMv&VkjdRLzE)FI+cCv?q9O5{qxWYAhjg@yiML$L|iVOuNQNa|dX{DX{EMyUz*~Tsoae|Ya z<2+Zm&Tae$mL;Vj&&hB`k)(_&YN(}&*>p0W#jIpCo7l=;4se8Hoa77_xXcaiai1Px z&&eQ$F_JN)$x&buQ>mwk7TQ?AO4hQ0t?c9wM>x$nu5*V6^oi&b8ORVu5vPW!G%%f3 z+UZ~(%UR0?wy>RD?BOWKIKfG-a-Cb;rFT@FVKifjlVJk2)X~Ir+UR5fi`d8}wzHRm z9OD$%xXFD=W7--08N^_c6sV$_2AXMMA0~~OSjI|L zvyP2yVF$a|#{rIWp37Y02KVUkFV#B+FqDyuCd?$JP)h?%w9v^CHnWvI9OpC_xy&_g zai1P#>H&ip#&E`vra&b%)G?cREMzI`*uZACu$?{Z$r&zkiQ7D&^b`6-`Z189 zj3Q2s$y8EHBh#79VwSRoE$rq1M>xrOE^w1O^cd$l3}P@t8O9i*BpFYRR@!K%lX)y= zC2LsEHg>R^eH`Q{C%8qga_yOC=*JL-Gm5c9$xuxLjdZY(C2V9b`#HcN4s(<{D!Wvpa72RP0t&U2M(+~hukpOasVU^HRIlcT^?>S>~d zC9Gr63B)^kV?Sh!Ura@zl`BbUK*FDz>qQ{T$#JSGd6~?$Rr( z|6veA8O|uilB1F;YN@A<`7B~FOIgVp*0Y<#9OD${xx`I+=af4`8No=RBuO)wYMNQb za#pdKt?Xbo`#Hi1E^>uyT<0ct>64dl3}iT?C}TVYCNYIdYG|aDMXX>Wo7u*8_H%%v zoZ%dIxks;p@}WPY36o(Wl~hqr2lH9L3O2Ew9qi)>XSu`;ZgYpyqIOCj`ZI!&L`gG_ z90jJ*$vhUYkYxnF*CbN$Z<|` zhO6A8_hjvpL5yGwqrfEUX`zjUtYQu8*~~U}vX4U?;V9?0%rzb`pi*8joD2mf zFo~%&u#iP8VFjyM%LcZwmvda@2DiA)Js$A%EAou~3?fdFGBQl0k}B$`XF4s+W(6x* z&sKJEn3G)KD%ZHfeR@~9CW9HtXwr;hGE=CffhJn%WHD>l%1-uhl(SsnI=8sbQ?F{P z3}7I`8B3HjkM*vuS4$OIgke*0G(PoaPF*ctB~jHcM}wqCZ0!&IBr`qn;Kz zn9ou+vXvd|<}fEY#bs{LXBfapMl*&gYMDw4t+X+Z<*Z>7TiM2L_H&RUoZ>VW zxXE1}(4$7aF_>W#m_!BDOr@Q9EM+Yl*vT&TbCPph;wsm<#cdu?`Wv2$e)MM`Lm9l@a|J%rHhWnlXe)Q(z+1 zG}A^qi&@47HnW30?Bgu==~Jf;Fp?;7%9ubkQ)!@)4(73%wQOV;`#H=BPIHMX+@s&8 zwME8~q>?%snNAy>EM`61*~bBnbCwHSb zaFpX*X^-Zma~FYY-BUr*~?)raf^FAp!9WZfgy|{ zOc@y_P(dyAv@xHhEMqlmSjTSma+u?s<_r@$0yX{D2eEM_I! z*v~S&~iHaeKkB37`HHLPPJTiL-bj&O`?+~z({w|E{#Fp|-PNi&|wOr@SS=COcP ztYtGh*~38&ahwyJ;|@J$YUd1O6j913&`t;QSjbXVv6>C+=KzEm=&yJJ)79UZuW72V;tucXSl>wZgQJD+~=8D%8Q|lBuW~;@T6o4 z)ilsfCren)N;b2NeH`KlC%DXY?(%?Mv*jJbh%$v5rcy@(%`9RGtJ%&Wj&h8XoZ})l zxXnF!&yjx&WDp}5OBp$;Xks=UEMNtzS;r=JafD+W=L~1L#0_q9pB`<>i(!mr9M#lP z&jJ>*nB}Zu1KZfoL5^~P%Ut0W1LhiM8AF=!WSGiy=CPFJtYZt?*vTIDa-NG^;U2x) zl_?`AV;mLKF`W*UvW%6iVLcn!!fy7mkCU9`GS|4xJ$n4M`ol2B5M>I@A{iGlXG`Ax?%#)G(DgX0wnj_+>36yV%QNPH>uwT;&G0xJ&QP z$QwozXB?H(P)`dTbh3!WEMqlm*vNJcaEh~>=Q8&w?Q{)BFq$;unM5^HX`-1nRHxe*u5p8#+^6@OuEAi!B$-GP&9t$QWvpTo zr#Z)Eu5*VT^Th!SW(ZNzlrf$H6;x6~1MPIMoE2S#XB49u zOPmZjCQwB^O-yGtZFDl9m8@euTiDKC_Hl{}T;nEpxJUm5%9%lgiIQdWHnpa!Er8egPYu;&tm1mBqlS3sWi|+ zEAv>wCN{H`Jsjs0r#Z((u5p+9JfP3NQpXs`FvgN*JQ*rzpq=?FVJ(~4!Y=l3h{K%V zBxktF4Q?}ViF(CQMl+T;6R4q<>CC2s1uSL-8`;V(_Hmda9K$a(E4f3D-&1!P%ut4r zWE?rBP)`%{SjPH>8IT;Upbc))-a@`&M#VLSyUQArJrG&7q;EN3kn*v58tv4_1JM%xX;sTj4KRa1fz+PBu$QqOre&kw6cID ztYR}e*~1}@bBeQE;|{(4SRU~d0~p0v%E&N<>9n$tMJ!nSZ11FqjccVlq`!Q%^e! zSjI}$vxh?*;RM&X#T_0naGidLk&Goyfhp9`Kr0xlieO<;+ON5M~@z)KbqHHn5qk z9O4SsxXw+U`V)D=a7HqQC}m7w3YFB+%0iZ~g4Jwf7yCKDZSHc9UK^a3u_P%YM65D!UZmKjoXxdQJrKMQPPZOGS$>lPdlBgWj)*2%^vo1l(U@U z0++eTE$-86qrBo7`Z1VMj3rKnO4^yv5|*=>ZER-`hd9h7u5*vx|5jaRIHMR#m>d(R zU^<=5XAw(T#!6PRj;-uq7yCHONzQPG(oOmZhBA!Ngqg?`s%WE=c`RWK8`#WNcCd#d zoaP)Cxy%)Aa-Ro0^CfMKVGL&^WmHg24GlEY&MMZioxL35FvmE_X)bb|8{Fan{Wi-t zMiZxu9F^2kPYWF^W*KW(&nC98m4h7S7^gVPc`k5?tK8upJ^r0~#|XwTkx5KpDs8M} z6>HhXZuW7Iqa5c1r@6otZgPhQJhMd`XE>u6LxBpasiBeSw6coTY-1;TIlxg)a)wJ> z=N`SjtWGn8QH&-@8CBHL!hBY+hOO-8AV)aEW$x2^t9r~}!X!zPV*!gd)%kbpLqrbGm<1}3QVS&TIy+F0n1p$dbYBS9qi{U z7rDYUu5*(++@;rceIErXnMxgvEMy~_Im9tea+-5o;TE^K%L97-pURWrjAkMgOs0l< znwZXPma&3$tY-^*Im}5eaha>!=01IPxCSE`O_Usysb(rIw6lO^tYrh6*v20Aae~v_ zr`K2HJ%brfh6zk!3Y9c7kNGTNIXgMPF-~xit6b+Ey>_ZM^kWc17)qE771Yv58=Wj* zE4$ds0ZwtA%iQEPrT<=DFo2((N^9*Ac&m@{?rj<52S;BJGvWac%U>~Qsz!k1@p9l2$bM=E!j3r8%2~<-< z9SyXyh$XCJ1Dn~&F3xa{i(KM5H|Vv;Gti$Qj3Ukis%T*)tJ%syj&YJx+~797|3W^{ zpFs>`B%>Kankt%TXECeT%ntV8m%f)AgMo}-6r;&dNfmX}(?}=tS-?g%v4h)YMu5pt)^f|0AVh9-~Foim%(@HxXtY#e>*vJ+R zafWl;;2!<|O4}t)hRIY>LnDh>$r?7Ym0j%R7{@u!HEz=Ti1y1M1~Y~*X{u?Ui8k6< zz-IQbpM#v>G#9zceIC%`uazT17|AHojHi-nrn8XctY8(Z*~lJFaGG!|B6kU-0G0S?I$+MiHlsN@{4Jk=ZO^EgRUyUJh}R)12WvS9!qG z-;h5HVK}47kfVYc>RHM%RHZnYFrtiO5|e4Bm4z&3EgRUxHuiIn z<6PkZJx;10jA1Mps;OZr%}i%D9n5DTOIXcXcCw#CoaPLdc)-(tqdhT@p~NX;0yWgr zNGA(e#8Q^Ao=t3F7Y8`PC9ZOld)#NhDS5(Za!jI%X4;v@5>~N>&FthT*SJrwZ;2}z zz(~dtrHo0`P)7sJEMyT&S?Vp$sQXoFo&ep^iqH z=wKNuS;KDja*!ij;0Cw3N00x@GckrRIjWdSJ@Z)164tYs9qi{2M>xwxuG8m?`=%cQ z7{*A(Q=o!srZbO4Y-9`D*~u>UbBvRm;~xFKEe{yMC`L1uBo$QAL>ntu$wszwfa9Fu zDz~}E;Iqz0lr%XCOlAtzw9rZ$oh)P-E7`ziwz8X3T;nEpctEfJB42olXBfZ`hBJ!s zOreIU)G?b5<}sh;Y+x7rImA(}aFyHiJEt8ngyD=JOc^<09((M%hQS;AU2v5npA;SfhS%}s96I?oxVD{b3Yg;^df24fV7zn+_JRh^4GyJGVyy)5#LnvyC0>;~+;l&MD4vi~BsF-zD{kk&Gfu85K;S znmQV2rkxJvvxp5G<|rq*$UPoV`aSiCfed0eqX|>S1SV2R6)ntW1zXv{ZjNxAQ(Wa5 zx9NRZ|H%lFjHkdPs%fHyb{4aYRcvB2C+PFvxg>E_03BlwOlB^dU@| z@zhdJ1FbA%G3(jJPWEt+(_G*>_j&4X^2}z#)!uf-{`w3Rk(s zZF*mq7Yt=ANyd?(iW+KZWICNJV>SCY%o)ydiObyNHg~v3pTARn3}P4)nM?ysv@wr` zY+@S+Im&4+aFLq~zM&ssECniPU^=r|#cI~Ef$i+#5QjO(MXpl%j{3w9hBBJ5#K|#% z$uu#Y*>up!3O2Eo?d;q-(W*AAvQAIoRSk5Xovx7aH<_g!j zPoMuso-&vr3}+-!%E(Yn9gQ^8!9rHCg`MnTFZ(&bIj(bqyF8%RE%lEH*I+|#s zgJrB>2M0OH8Sc^J@7*&`)1P6CU^E3LQAGpoEMPIqSj#51vV;8`;v5&aPLJE}k%0_j z6mcdng$Aaxh~=ziEj!u6QBH7@bKK<~z5ZWi##1~^oFtXhQcn||EMO^XSjTpbah?lY zqt6}X#u&onn9LNaXrP%kI$6jPR*v|=0afNH#{Y;Jz8gNX8In0yQ+y zNGr4HU>*xu&IUHJja}^FD91R-8P0Qs8{Fjq{qCxhj37*sGBQl2j(S>{O$Y1Q#8&ol zoU7cY_dm#c`ZJ6Xj3>twYH48}Ygo&Awy}@>oaF*nxXv^8)D;FZhOvxi0u{6~pB1cP zCwn-=VJ>l%Ta^A#eIrSR9FwV`o<>?|qm$LFVI5o8&0&snje9(O-#s#j(S(^o6-~6z z$~+dchP7;9D|%u#5ei;VQSd zP45TppCOE9EEB1qmPTf?fW<6h1?$r*%gY+l<-hV9sq)X%B;9ACe0yuW{4W>B$~XSo zXnDzBMaq}m2$$da-^1np#q{!qKO9^Bz2hG*fBu&~US3-}ru@Hu`D5i@|A*1#`(GOE z`F^eZiHDg`Y8&`c@1A{wL&1JedJ!Dx$A=lfb7aU<;3cN;3RS2T{`iNUoTc}(-JY}! z{H%XI^xTJ@D=i5Gf4a9%K77^t;r6|A^>L)nbHU%iAOF7fvyc9~m*%~_;O=^KrF`#L zY1jP*cl@J&o_sF&^P|Ull?HzvKNej3z3T_>Ji7jm9)0{X|MdOtd;jr!{imPtf9@xr z8{V^Th-c|b3Ge($&%WQ~o4n0e_(e74g*n~z?QQ!XvH!i<-s4T4=febb@kv{olJD}3 zSv~uHj#u~y-)ZgH_lpGSK5uK&Re@i!|0HkE?AiA-g!q0-ce?M`2Fc#?q0iXw%a>>L z?E4(wp5C+XEQ0fW+BQhnM??AcZ}sf^5`Wz+9e?qLa}uO`_ThGu{l9OL=Akdx&LU6H z)>5`X`p46K$g%If-m~vl`8|SkZ`uawOe;!0VgHAXJ^Ox*H~9oVoYu2%&_3U>eLP)| z<|~fPBE&ll-RJwBZIEuTzy8?%^Zej7&&(%zlHhzltpCw;L7J~P_G$X^_NTkg_f^~A zd~5yny!~(2_3ZlwKln}0z()wq_aWQI(*BJ z_eIA(&9i*>rS5d!c(@Jf%NOm><#~RYcP6_>g6I8;ZE*cZ=|1cAC;1ru0ja*ZA{aHLmU%vZ-I>Ah1=of5*bO(6DevA^nF{x+Y zKV}-i{k>%Sc)DNq`uo4G&hr*85Y(5H?c?csdi~9bJ^OxvH;C~I(miV%r28h{f8PD@ z8J^=wzBxfYi5tFV8>9=$?M?fi;D<$Ri8uKK!F4}s`*^zV7qkuD;G=v$-+kS0**>1` z^IpHghxt~nXW!2g^lNX~2I+#oQug1;Iv=0rBYZRCeDd!vY=d+mf4yP-8M+q6r{8NBwsG~jC_BbHpdIzpJf}Qo8_;*_P_E8ZGv~o)MY}}K z{O_Z_dl#us>#PtnybZG-DC;$!xoFPxAc{-RJwRtz=#G{%!kTAuL{{%Uvqd)xN&yul|3(#`#F zaP{t=C;r!-CGUiKl!P8T)^lLbl0S3oqmLc?m}6gZ>|6cc`|P(Jd&#lSK6Y&GAn!Z& zlYYMSk)9==^#1cC_$a?b@DC5ZI{1Ly)3|^(2U!yO<&u_W@f9A9Nu5 z?Hu0Z9e&@j@7ew(DW2ok`6RFLC;WT9%pVc_{L;hiT>0`Ryu@$u5ByiY#oK&^-=~}q z|AJqpFTY9f^YH;aOa6wh@o)Kk=I|-<{2d?WiC|w|f1AJJs}J+NSn|^3mtU#N%$U*I zP**j#c}B_P?jyxHjg8$0NFX zD}{>gOH7>G*z)l6FTQu3%$&xV_1%Xnx{r1pdHmFs-N#>S?0773N#na`&$Z6#eDCB< z?;a2CgPOmDzm{CD=X_N8yni^G*&dW zG_=erDVf>U)-DgDAD=d3MoCGe#ac!zWs#kni+iL-#sy>e&)22lHUwcIM>Q2T4Zc%LrF>OiTc-C z=gcj6?umwnNB*$1ZdSwG&RLEAh1t61w(ebZx2~?`wK~OF*HZtPl9F#dF}JmS)~v=k zB^8yg=3aiK`-z_MiJ8rF=Qhr1DOq1qS3m8y+S}&Vy*{n^x2-3Yde&E(8>Z)4+h@-8 zZwfy#rM+=Z=Sz)qUT>Y#Qm>G^-f+f}AZ5O}ZF-Qim9y#_8Z#vw!Le6cXSBC8PMq2G zfw|4CGc#&|e?A3s|1pSzB!zU^-MMWvMy zIRw{wp|z=5mgMI&|8`@W)ymQdGg@D(pP??d&grb2TR*qm(bv14sj+2Ncd?axuB6yJ zb6R(${*$i#7aKn_H>eENC2P7~7n|p_Jv>nIH&0YIPixG*Q9tLE){6ESbDOiBa~n&( zS`s|=!+KOw9$X=Kgv_*Qb38^#$$u<;p|yV6!}s0o)Dl@$|Jsbk?#F-lMowwAl}swU z{9@rzMJo9Z>Wv#OIS_2;ObdQt(EEO-w|wKp;LzXbw}Wx&k-zr(8+?;s0qDO5+mfIz zz4ov<7hf(EvM&TJ;MK;4xvdKEpMU;22mUz+{y7K!IS2kZ2YylxeD0e)N=B5lm3*q} zZ?U>R!B6ma_wiq||7%^xg5e}Lr*qca35_#f7Rj`>Jbe9f_4?EUwrfAqQFv%P-d7kdBy{ro?6 z{`X(+(RG7s|3dHHPyX?*SXbaPyunMP_*K3;%=|aVFh8MiBpQn+lBskio68r96P};= z>yuuncyaPeQ(mrorRvq{PuBcK{c8==8eeaEqxrX{&uE$1I%~FIsQtG)KGXR-qsIp4 z5aEb}o^5V>wtc3A%`+RPl{C-%?fMzb)1GafDMowNG((UkRx7EW(cR&`|Nv#;0B2&NkEzMea$J$UJNLr$OB+A;Ilhu3asoz__L zz|Vw6d(Xbs`Rt38xgcGoyLu#eT~(2L_L1QA%gt?#j|8t()pif?O2ubVL3Jw;2|Cmj zPtFWp=iGaJ`<&&`jNpP4vQMHRyP$+XXXLz3o(OhrC;{qTGf)pWC`?w?=% zMeBUb>0y_Tp<&Whco$9G+7AV|KOj0>{*R;v2-?{4TYr&MMJ4{AsLN_Lz!GQl8hH~(QqUa&*u`^WFj7q z7DKtNF(;DFgtCcDDwWKnQ_(^?84aaVsZ1i3j3hIuY$P9!ByzEsJjmse*+|A`2JDsL-GuZ)RA)04dViR~x&XgHq9WaEi&HWZ4-!qHqVA1f5n z>3ml?eamJmXwR`6odpQOKuMoNzjn4P|q&Xd#zR zq|?b{GNkULv-0&0A$!9XjOt=uwW^+l+B&SO17s4uQ zDjW+w6V`-M#X>fyZ0Te?oRI0sa50(8#x$>dLEX#bQkir(oG&KTWS{xz4di_lOKtR- zck?j#eDrr>?lB(^7Yjv2r;cbB z#aLJlrGow;8kAc)kxpi^v8aa;QN)#O@OQG9)SO7DN5OL^!_h=IlF#MyIS=a6=~yD0 z&jc6OsFTr5F&$53ius`YlI|<0gcRN0O;Xrl5XwKW8HP za`2q*Z*=lD9?L|c+C(}lyMsEMh^305gc_JkyN!4>k;tbDkwiRSNEfn^SSU!NCAra5 zG2+sps7jNFNAenIJeE;iD5^ZwDE<~&t87Y@=z6Va5GA&q;;h4d$(R4SHDM6>B! zBA1M$!-}t%&PQWGeyYe?M>>;C=y@XHSS;q*ifU6T7l|iB*&rW&Qs?(xjSPp}b9Whe z#^9Vk8Xvg4>LTCM8e_U^%*jSGqJ>x?uhu1!v0NxoP>k73HWLn>Kb(=-iHv?Yk;}vj z#dxHc%V$&JM9fg+{ZKkyNNeo6sz^GS&1<{SL?IMUht;IueO2CmK3m8curi^1K9Mix zRLFQd=kwk78vcoWkKQy_&@^?E@kH0TGVw?%s^uir-9jN1%ZH<3ttT2z1(BqC$tTtN zgbuJM=n2O{Ne5)5!Kv%>g;cgsh~=Y&NJQTqWUm9ELRv|5<%JO}6^R?B6uJJckcg#o z1>Hv^R1BW=gZl;D+hfmSKlu4cy})C~^q!eQK37l@`i4+6n=R&bq^Vq9Lyv`n8qxg| zODQ5fZzPdXw~U7QOstrdiG{H8%%qAs*=)=?5-BY=oKELr$-Eea9K@o6(Rmp+qDtz(}cFA>)CrRpIJ23XxPk9oM6$!ofIGOzDo_JH6{qI9hNz%d_;hxg6m~MnRHV3l9t&) z9Z8DWgim>+UM3pTh3Zzt1&Ly^5Dlk|f59M}kLv<+nV85)XO>TBW5GQL0^;#(G#bkn zLn4i0G*rw*QW?FfZcn5u0t+SMnY7ASNW_i4;;Kw6-W3x)mMuTeZr62xo)0{pHn``X zC&Q)f%5$x`Yu={q%kxMq$ny_4kCDQtkP9b6#e_~-KNJ%m`eHe1NK2^r`A{Sk5=X^!!+8N~I2$gQ zJ?WskKJ)l9{|x(jlAtg8`F?(myzI`yLbR(Lb>*Sa?}O{Dc)Uxi`(?rVj{hBF`ZUry({93dONr;gK;h!ipC;o9~Ya3i$NZSv+Ad)(%@yJ z(v5ZHm0{7amyZ^+>UcI~7>SGOW9g8>i{;~)q5)o~+cgjPfHHq{xa&EM^IdbS?&nN| zJ}^dgQ#m848HDjbfEAAzGR<|O8FjEp?F>_t4hX; z8fS3cM-TKt+hq3}UG4aT(mXo;FztJNR#={BKkpmoyDMKfn<^^qd{Oi#R95hbtlF6t z%NYFSiJ>D`$S1P8nMf+(KvMK#o@SUS7P`tlnlK|Jqq zlZC7r^)uJ`u6p~kwvL}6{~pzou6FmRo&@dTQ5gOx&kXgUNGusKTaISqnXdE^v9BP^ zWJ0CQXei-OqF6|Ug2}77xJX)`Zswv_NX4zC2+*U2L{MWgNt3&5PLL6#i5CiLgD5ei zGYKM4lP@E+Y9sdb;UG;uA-L7P^e@3+U&xv$s*HAvdZJ*4^KcvrM^ZsOe^}=3y8B1p z9}W4iS(Z^DSP`%`R#fqXm;yE@R6|3NAjps8^Twb|Fl+GtUr3liXb`EaP|WBaQryAR zRWy~0XS>(ngaGlRpfwya`;SHQ`IHzj9Sx?Cg&@KT&hzko@{j7``?inQ-w#UjSiSX( zK^du?fG!GJ5n%yRo z@$Pk^P&(!<(}A@4xvHkKiJK@yjP_lzRYI3p)Hj+Es*;65-b3kcLy>HxtIzq->n9Sa zkW&;g`G}}Bc$S~?epg<;`z&2GO?!>T{z?Cf=p({Wok~0uHwzWH#)U(vd^DaCGv^ZO zs4USk)TfNjF#Yg)L8;0e)mKMbOyzZu5fd8=lyO~l%xq6=pG!y0H`Cc7lDXLVcJSaG!-_a<`ub{6M6>a?Xe@Gc}q*;OLf+_3_(C@iYy=W zI;nWjFGQk=T+WDORM%;l+qh|0w$u_4ix#r!wCTB7oMoh(t}kPC$c-ybVUl1=Y!FP% zgX{hDspq3!>Sx^k=)Cm(AL^JOWD60Kvrt4xrteqkUF9TRw%QLOv2n7X_1XlV>Zu1^sbchaM8GlL+!RX30t!nDThcOx9|g0WcpCl&XZ8 zg3+z3e1Ce~cz<2_z}G)Q?g6uHILS5EUvZdsA*RIm@3qmvk;|*XYHY#R4ta|?*3A-{pMnln;{1OIEg)nqWSgwzGuE)<8f(sQ7B&z^jDVIx zW4?unq*O7ZM%HXN2&P1{@;=BD(Z1+0k~3ll=TnZ#EfuqXrz6q(85%-G)zQ+I(ZaHY zt|6Gj85VL;%XP)Pb!G!pFm|Nk88@e65a=X=mG+VnJ!UreR!Zk*0858bg;>;rdd||3 zFYHu9Yn>@yZe=WeTRj!JCViuoO$9M@G@S@p#kbUET{o2NntK%W8;P{pWm>eWv6;wP zCoTlFMk@-w3yE78*STkXtLb3Pyk*@K{a(?iIPD~JJ0W+qHkZr*tki|x8$m*@{35*?Dr!hEK=1J;NJfiL) z(sjQ^0}D$*CZ&Qoyxt~bkQPGvhA0+MJdv0go>{mq*xbWfX)a^rD+KG5#=%0`8hTJJ z!J@N?cs7XTjU&D!5VvJCm7E!oxxQd1Z*?)6QHk_VMy!lUyuiY+sY(W2Q&;_SBf({6%1_qbk}Oqe|dUA0M@XiAhJPO~^z z5ElmDAL{Fa5jdz1`u}V&_eyk?eX!uA0DVTG$eExskmV-rAzcFCONt zkW*isFkU1KCx&cYv$>4cWY&@JO_W%{yS^>(rIYuAzjIQjyPp5uJk=i>MqUjnq9Es| z{D{&Gy1Fh=m6$AQCAt^{q7ea1q^te~vGlihinZc_;8Ab3v+B+LKt>(0kpUFho zP%DHGLRRIx{LlMaGjq=EFdHf2idz#o616O6XR@2U1g9_CPW`O6p)5}80RxyW7U+( zsv?z!Ns6tzOtLM~JOkK_Av9?KN@2fBCw%6m0zf4Sz>~Qm=HVcDL*fcP9b&a#G&lTdzc>7 zW#h&0irMRbdrz}DePnUEwV%s_n4c;y6G5svc@@N4Oy5XNXUJPdt(W*?wwfcgGtW0R zansaZJcr~6fc7A#xmsMD=0f-o56f`!)PJMMp#k=okmpJ>zlL^XE)Fs*1|e8vBw#ly zNgBs+ycI(s+6_-p%1aF9d@|7!+p!qnRJ@KZha!OC4Jk^B;Y6_vf`J~4*qK3Ke0l+9 zt$tRQx474@|4ELw!+gE1#n`IOQu(v|yuDmPtz*POfU?ds-ryAGhfHtf_yi@r6j_Tu z+u&7Vk1PfvW(3CsmR6A=TS<=611^GDk=Ix}kH46Tq>Cp}#$ja$SBOICh?xKCK0`II zH8>SyB(H%M>Cj<}=_FY_IUPN+l(F%YHcm6R}eClkPvBEDdZDO2WB zX@5(Qfl!1 zQOI>DcwDDL0%uG>DA6Q%3^F_c(wejpcb$ux=3zHR(^r=EP@diD5zJnXJ~gWf?XCCeg97EVd5UDY>O=Qiy+8a!;pm;x$`=YokuDM&j;#{pf)_=j?j2+=Nvb)Y$bqEse` zo9DVr2f%Zdh$ZYIP*oAm3F@PuDrVWJf#~UJJjs%q;|=^wnaJ|cHZ@Q*Kr9cF3uxiu zVuUYTHujQ{g9F{fpZQi|!w4}rLEyx=hU`LS%29tn9z>-~aKJ_^p)`FEm*5T3DH#LT zz~ksvieXVnNIVx0qATK^P*~7`d9v0-bD2OdfRIPIv*0ax2(AL*0PW3Y_lsE*<91JuqDr`8bQ$#;dLICl23F(0eDndbGq!gtM zeLoT|+GJWKWLV%(bXuT3)`7`4C4?kEZ=Z9?Kv<%LpSU1`fqX@S&t#J4q8Ee{fZcNUP*Q{(yEEWAnaSynC~o zZ{r8**UxPu`C`-jt-9;W&-usE=IgpcS6%d+}Lj>M*3DZwM`2hXNIM)KqrF@Ipz zfY+lMpo;4-|3pAB!(HknoWGsbIvG*$YY{jImy*9TYi1zMxB+gL2jShMOyv}9Ah>`j zKoRm$XfZ3p5P5$=>aej7+MYe~W`^iR{%NxS(%>0PlAxPKDTxZn$>SIS$u>GBhCe77 zWT2TVl2Hel6krIw2Tw$&l`92-D+i9vWgdr1lh(wZ5)VkFe9_x-VT?&=8j;$;0}(+G z{>Y4SG&Im}(yK@tOLr$sLtf8J3Ss!;c(g1o90HR}*y9|jf!L(Rkw^$%pMyaF;C`5% zi5pEAYK<(vSGR}6&i3rF(Ld;*X+9``u&MCeIfH(XAw3j6`A)6}983&I^9##Ol#w0K z?85%jD+@!&ib3-l6b)WTkP|+|lvtBaCy!@I2r#c)Ghz`+57A{Yq!Ic-+IyQ|W3+`N zfG9N)_7ubD5^%UrQP!6sA>maPNfyVW?H1Y!whbqCK?%~AQf(kDU`BH+Drp|p*z^@d zT(%y+eEs>TsUCvWo}byX+V3?&toq~Id409MGVh-fa5dhf+Art;VSgUdafSyWZAHUML&Xr490;cg7h*7Z zqcx`o@hJI>R9H1C1-VJq8eD8z4A+@#Q2~*xLMH>bpuPxb8FLUb@L80moWSSoHJkhm z`9fBks$Ej`A8A$Tt(e_%!aC57bA|Xq-6F@OVPGC&z(&t4qo>frV4&kybLKj|^ zBH)R171Eu$4za^w5%Ezd@kh7{UPX(5=Grw3_&v}$E+rKSAV4kzB{OgIWj{`l2x~k^ zn-ElVF5(stF<@jP(EZo|-2$Ri+wO(2m!%E&ngeDnQcW;dAy6T`e3nJlUi#K6cTXhgwOxClto#!MwX z{1Px1D&SPNPZUYPbh&pl-4WjeAAL0AV9fgDOQ$!gGAq(G`B`$&i;mY7SCsk2mW5(EDO z)j-=p$H24!5b052Bx!cs9N+^OAff{4?x~H)VE{HV03?M#GAZx~35~*r{F)^f0X3~P z08fx?{%iXy^S|Nx_7A$*Ue$}~_MiTr`3wD;oL3f??Kj5dW{UDRoPtOd zNDf5^qG&1z48o1RUGO+VAyoflb@*Qt1mIih&qnSjzfL4znjyfsxb3D}8T7oekB&h+?GCX@CKD+I6%@G=@PQE}WlYA3;9od5 z*aFU;MwF*0T2mx9(wXMJqzx?su}OkP+g%K20Qhrl6eYwLyf$sLG*Daub%s3@FpMBd z*bsJx!6`{PX4J}P3Ec?eFnC{v(wPOIB@kVr-GH0Suvk97B2nVdG~B(Ut%$KX4bT*$N%R$)kEhcf z(^vucWc&vyV6kZfV2`XAxWrpB0S0)W3&Dy?umOO9At`hL#G|l;q()@M9EstwXi``O z6bq0iN(P(0v_5K!-~5Jf_&1*VAJ1Q#?YTYj_g}u4Z6>YmP&N9 zF^sNC_GK}$E>oiZXAV@BX%gfeaWNkZi4uqD9$lnNN#Kl0DJb}udCBm}L5=nTJ9|G74TA$qAmdux`K?fs%~kL1j659U4#uC~Sdc zD!fj$Z$*EhCvq~FKKE=U)i1oXek|8zWVx!!-- z&uhLgZ$0d{P4}<)+#US}!&xm}Hm&n7y$a=p@2XOlid*FP=pm%1p+b?*^jsDr!bd~L zdPNMPb+#chxWM{M&Y^f9u-IG;Y-htIp;bgE5iQ8hGL&g&m=8uBH)j`~D3Zh-8BV~8 z&_p4v0`e1>beX(>8ccfyTkO)7Gt-6E$@~fyj9SZ>7S;o@&?Qh92k<^{RJK^=a0C)Ua7J=*Wh_9<*Iq-J)$PW)1=E zjTbX7Coj;gGSQ@jQ7?#Kkw!rO!3r~lhEkWg8U!#TS9UE116sOt+DvFS6t|!T=rigx ztq1cLWO7)U-S~+0^&*AY5N4CFfJvDj|I$kC;BT2b^7oMD?g6fMsG{8F6n7qtp zNAd)_kmzj4vNGf(JO>qAw6e3#6KMd>La0Pt)0Mp#&O@{l?Win{QWB3+^-qu;X2 zm@MV}h@2;Ww9RuDR-d6eVxEkjgfu9{YeX!^Zbx)Rs1t?V0IJepL!*=AMNPvz6SW$X zH+e4p%dQHUwZS_ZG{)$ogoYQj4NpeV189V%;<>-}OKkEhb4v;5kgv7*>&*M?j;h2C z|Bf;m{0l~hkYVm57#160YT}3KrwnHSiOj^%9f?YY{+EW*mChR)BVYEZF9thLgfC`t zKqa7orkr48HtCZUXhtE0nMxugK*fe05mmWC$4nOhoxnC4=6%c$Np+0kV5((q33AlY z;mGy^>J$SpT);)_0FFdri&TUhCqy5T2PiPveJyrp_W{aRCIgJ_MBqcz19pXe6rzv= zv+W%^k1WSR!i}@sYc_ua_0r! zjhUH@;^9IOda=E8V=h2aWuurBhL@>1upbeCG)r>73jmESj37IC0UK<@Ve2x(3tDv1 zcEQmYC<&;WfD@)TvRm56=Rir&#KJg(YZ*U5$wN3&d(ra)VxTRk{bl4vMsb8$-X6aK zN9@o;{=Fw;y!5ZZGymRUcKmAbk1T#VZxmJX`;K2#^BG8m*wRQPgMeXU75Rb%h0@0( zL@@&S3=2*az(J$!&TA^v9{48Y$a$0ExiKcmEP{&H&#(m0A1f)qkMzqdt>Lt!TeQzl_y zaekS0iQu{z;hU&%abgBg+${lM32X;4L$wjG6i$)`o7ZHk6oNP5*dPW_r&4w4si9`U z;0!(G81hxq`oH-%z)${b>vX*F;mkMx1INj(C+~YG@2g$crt{i#o}0e2*9l}ITm6~Q zL!FZyXrS2l;hZFI zh1g!`calZccgXwD){vwreB81{p%wt}aR%(p2J=90%Wx26g^&ue6+H#~Hd_av5Oa)T zao^22URG8l|CCIaayBlI0vW$>0(c11T7=uor0D`mpiI!UQYnxRqbpzl1Y5J257=af zjrQ3ti?!)_TYdl8y8esrQ*GUtBVnhlj#J}TWGmncI0>Yl2JDYetZWGp&0MB^A#;;G zs9Hc^A$?&n(18P-*`7m4u!lobUn28|la|e)2+F7{c|AQ!BX;G$>OQ;~a?AJ}czt#6GShO=Y1o#D;%Qij;E+#2Bmh4VJ zAWc`5y`J$fN+R~t$ZQ5oBDbkB&~PwEgSP~CqT(W5^AJ2A6oJG5jjP<<3jUm49pB`x zSLi{ACbqhxufXR~mdX4Z9KgF}{S#!Lz)|i>l5qtfNpd3l{N#pDa_bu?LJ$KZNjXW* zQI7L7L)3g=Ynx`iT=OYE`)%vjRP$TxAP24esa3L3SU02;Py^9^^+pL${F69OS2-a|-$Np_+e{-xk%8 zj=G!HMeD)8rF>#k7p)zi*VU2V+wpH1Kg-usg0ep zKmqSpsSVQlYv*WZ@^1aL3O-@09lxESoy%+GgXan~T~qwu&%PJ)FFmogCy$r#oB@1( zTrZwKjI-&*Z+){P9>-rU%-*enN1O5dbG0Ens}H|b^7y&@EMFb7_t|vZ9Iqa%ot~Y~ zz^$Iwg)?o&Sq@6?+|dh!2Z+52_S_U61cys6UL1AHRaQS2nPaul8u0v1JhMNx z6pPC9H=T?8mbXsL*R|%D75pckExjMF@67AZ<*^~yp|aZ1#8!QIsf2Q^{v&KTer+s z GaCwo`>V7mo^#OLkT?62+b?EnwFXalUsB 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 bmv$YG=}_9EOWO|ZiZ?#hYCW(|Z|%PUzB1d; literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libnspr4.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libnspr4.dll new file mode 100644 index 0000000000000000000000000000000000000000..1bbbeb90c1852762020287543388bd2e7d4834fc GIT binary patch literal 213116 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 literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libnspr4.lib b/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libnspr4.lib new file mode 100644 index 0000000000000000000000000000000000000000..912c5cde67ffaf6f04f0893b414d1719c67b59e0 GIT binary patch literal 88388 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 literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libplc4.lib b/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/libplc4.lib new file mode 100644 index 0000000000000000000000000000000000000000..2125d3d328e68db335cfd317599ed56e48429d0b GIT binary patch literal 9534 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

DbdAJG1S*B#-eC$!&~j`F1?p|sV1GS& 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
%|g5Jw`1Xm&Y;*o?+M*9gyK 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 z⩔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

YL~WSm2!teF=hgD* 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

e-@&S#C+!e06vXS7_1r4+DK8?%$y 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

QS4$3pRJAm!kF;b~fuq_F%Q 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%0DgrAkD=l}ys;uan?E;t90Y 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%0A!14ZmSD1oSh<4S0NES#*A0q%XKl*T|# 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�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 literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssdbm3.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssdbm3.dll new file mode 100644 index 0000000000000000000000000000000000000000..343d8037cd7436ca321aa6251395b0ae6b893aa4 GIT binary patch literal 114831 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%0AMI(C4hFpXLg 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 literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssutil3.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssutil3.dll new file mode 100644 index 0000000000000000000000000000000000000000..3b73a1811e9c28800017f98a9c60c925e63ff24e GIT binary patch literal 102531 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
    6wy57$CCvEAiQ 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 UjwDkX_>B@_g$QmaW_B3=9luNX*#H0l literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssutil3.lib b/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/nssutil3.lib new file mode 100644 index 0000000000000000000000000000000000000000..397bd3e6cc7854fe7212f76a406d4ecc135f35f8 GIT binary patch literal 42550 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 U7Q1XXLp5cMA>B_#xEJHv3x>1TjsO4v literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/softokn3.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/softokn3.dll new file mode 100644 index 0000000000000000000000000000000000000000..735b38f1ec0408d51cf4d912254c85b7ddcab0a3 GIT binary patch literal 204935 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 P^y~Uk0#bSqRvZ2g{-{VO literal 0 HcmV?d00001 diff --git a/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/sqlite3.dll b/jdk/test/sun/security/pkcs11/nss/lib/windows-i586/sqlite3.dll new file mode 100644 index 0000000000000000000000000000000000000000..4530107d3101add705bd2ed396dfbd8926498b94 GIT binary patch literal 331908 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 z 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

j@EB;Ev1GDCLOlgIEo{%0N*aYgCm54*{4y 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 @4hWB3?X@EJbG*SLpA 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ⅅzP*mGas5rV~$%u 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