Back to index...

	/*
	* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
	* 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.
	*/

	package com.sun.java.util.jar.pack;

	import com.sun.java.util.jar.pack.ConstantPool.*;
	import com.sun.java.util.jar.pack.Package.Class;
	import com.sun.java.util.jar.pack.Package.File;
	import com.sun.java.util.jar.pack.Package.InnerClass;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.io.PrintStream;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import static com.sun.java.util.jar.pack.Constants.*;

	/**
	* Writer for a package file.
	* @author John Rose
	*/
	class PackageWriter extends BandStructure {
	Package pkg;
	OutputStream finalOut;
	Package.Version packageVersion;

	PackageWriter(Package pkg, OutputStream out) throws IOException {
	this.pkg = pkg;
	this.finalOut = out;
	// Caller has specified maximum class file version in the package:
	initHighestClassVersion(pkg.getHighestClassVersion());
	}

	void write() throws IOException {
	boolean ok = false;
	try {
	if (verbose > 0) {
	Utils.log.info("Setting up constant pool...");
	}
	setup();

	if (verbose > 0) {
	Utils.log.info("Packing...");
	}

	// writeFileHeader() is done last, since it has ultimate counts
	// writeBandHeaders() is called after all other bands are done
	writeConstantPool();
	writeFiles();
	writeAttrDefs();
	writeInnerClasses();
	writeClassesAndByteCodes();
	writeAttrCounts();

	if (verbose > 1) printCodeHist();

	// choose codings (fill band_headers if needed)
	if (verbose > 0) {
	Utils.log.info("Coding...");
	}
	all_bands.chooseBandCodings();

	// now we can write the headers:
	writeFileHeader();

	writeAllBandsTo(finalOut);

	ok = true;
	} catch (Exception ee) {
	Utils.log.warning("Error on output: "+ee, ee);
	//if (verbose > 0) ee.printStackTrace();
	// Write partial output only if we are verbose.
	if (verbose > 0) finalOut.close();
	if (ee instanceof IOException) throw (IOException)ee;
	if (ee instanceof RuntimeException) throw (RuntimeException)ee;
	throw new Error("error packing", ee);
	}
	}

	Set<Entry> requiredEntries; // for the CP
	Map<Attribute.Layout, int[]> backCountTable; // for layout callables
	int[][] attrCounts; // count attr. occurrences

	void setup() {
	requiredEntries = new HashSet<>();
	setArchiveOptions();
	trimClassAttributes();
	collectAttributeLayouts();
	pkg.buildGlobalConstantPool(requiredEntries);
	setBandIndexes();
	makeNewAttributeBands();
	collectInnerClasses();
	}

	/*
	* Convenience function to choose an archive version based
	* on the class file versions observed within the archive
	* or set the user defined version preset via properties.
	*/
	void chooseDefaultPackageVersion() throws IOException {
	if (pkg.packageVersion != null) {
	packageVersion = pkg.packageVersion;
	if (verbose > 0) {
	Utils.log.info("package version overridden with: "
	+ packageVersion);
	}
	return;
	}

	Package.Version highV = getHighestClassVersion();
	// set the package version now
	if (highV.lessThan(JAVA6_MAX_CLASS_VERSION)) {
	// There are only old classfiles in this segment or resources
	packageVersion = JAVA5_PACKAGE_VERSION;
	} else if (highV.equals(JAVA6_MAX_CLASS_VERSION) \|\|
	(highV.equals(JAVA7_MAX_CLASS_VERSION) && !pkg.cp.haveExtraTags())) {
	// force down the package version if we have jdk7 classes without
	// any Indy references, this is because jdk7 class file (51.0) without
	// Indy is identical to jdk6 class file (50.0).
	packageVersion = JAVA6_PACKAGE_VERSION;
	} else if (highV.equals(JAVA7_MAX_CLASS_VERSION)) {
	packageVersion = JAVA7_PACKAGE_VERSION;
	} else {
	// Normal case. Use the newest archive format, when available
	packageVersion = JAVA8_PACKAGE_VERSION;
	}

	if (verbose > 0) {
	Utils.log.info("Highest version class file: " + highV
	+ " package version: " + packageVersion);
	}
	}

	void checkVersion() throws IOException {
	assert(packageVersion != null);

	if (packageVersion.lessThan(JAVA7_PACKAGE_VERSION)) {
	// this bit was reserved for future use in previous versions
	if (testBit(archiveOptions, AO_HAVE_CP_EXTRAS)) {
	throw new IOException("Format bits for Java 7 must be zero in previous releases");
	}
	}
	if (testBit(archiveOptions, AO_UNUSED_MBZ)) {
	throw new IOException("High archive option bits are reserved and must be zero: " + Integer.toHexString(archiveOptions));
	}
	}

	void setArchiveOptions() {
	// Decide on some archive options early.
	// Does not decide on: AO_HAVE_SPECIAL_FORMATS,
	// AO_HAVE_CP_NUMBERS, AO_HAVE_FILE_HEADERS.
	// Also, AO_HAVE_FILE_OPTIONS may be forced on later.
	int minModtime = pkg.default_modtime;
	int maxModtime = pkg.default_modtime;
	int minOptions = -1;
	int maxOptions = 0;

	// Import defaults from package (deflate hint, etc.).
	archiveOptions \|= pkg.default_options;

	for (File file : pkg.files) {
	int modtime = file.modtime;
	int options = file.options;

	if (minModtime == NO_MODTIME) {
	minModtime = maxModtime = modtime;
	} else {
	if (minModtime > modtime) minModtime = modtime;
	if (maxModtime < modtime) maxModtime = modtime;
	}
	minOptions &= options;
	maxOptions \|= options;
	}
	if (pkg.default_modtime == NO_MODTIME) {
	// Make everything else be a positive offset from here.
	pkg.default_modtime = minModtime;
	}
	if (minModtime != NO_MODTIME && minModtime != maxModtime) {
	// Put them into a band.
	archiveOptions \|= AO_HAVE_FILE_MODTIME;
	}
	// If the archive deflation is set do not bother with each file.
	if (!testBit(archiveOptions,AO_DEFLATE_HINT) && minOptions != -1) {
	if (testBit(minOptions, FO_DEFLATE_HINT)) {
	// Every file has the deflate_hint set.
	// Set it for the whole archive, and omit options.
	archiveOptions \|= AO_DEFLATE_HINT;
	minOptions -= FO_DEFLATE_HINT;
	maxOptions -= FO_DEFLATE_HINT;
	}
	pkg.default_options \|= minOptions;
	if (minOptions != maxOptions
	\|\| minOptions != pkg.default_options) {
	archiveOptions \|= AO_HAVE_FILE_OPTIONS;
	}
	}
	// Decide on default version number (majority rule).
	Map<Package.Version, int[]> verCounts = new HashMap<>();
	int bestCount = 0;
	Package.Version bestVersion = null;
	for (Class cls : pkg.classes) {
	Package.Version version = cls.getVersion();
	int[] var = verCounts.get(version);
	if (var == null) {
	var = new int[1];
	verCounts.put(version, var);
	}
	int count = (var[0] += 1);
	//System.out.println("version="+version+" count="+count);
	if (bestCount < count) {
	bestCount = count;
	bestVersion = version;
	}
	}
	verCounts.clear();
	if (bestVersion == null) bestVersion = JAVA_MIN_CLASS_VERSION; // degenerate case
	pkg.defaultClassVersion = bestVersion;
	if (verbose > 0)
	Utils.log.info("Consensus version number in segment is " + bestVersion);
	if (verbose > 0)
	Utils.log.info("Highest version number in segment is "
	+ pkg.getHighestClassVersion());

	// Now add explicit pseudo-attrs. to classes with odd versions.
	for (Class cls : pkg.classes) {
	if (!cls.getVersion().equals(bestVersion)) {
	Attribute a = makeClassFileVersionAttr(cls.getVersion());
	if (verbose > 1) {
	Utils.log.fine("Version "+cls.getVersion() + " of " + cls
	+ " doesn't match package version "
	+ bestVersion);
	}
	// Note: Does not add in "natural" order. (Who cares?)
	cls.addAttribute(a);
	}
	}

	// Decide if we are transmitting a huge resource file:
	for (File file : pkg.files) {
	long len = file.getFileLength();
	if (len != (int)len) {
	archiveOptions \|= AO_HAVE_FILE_SIZE_HI;
	if (verbose > 0)
	Utils.log.info("Note: Huge resource file "+file.getFileName()+" forces 64-bit sizing");
	break;
	}
	}

	// Decide if code attributes typically have sub-attributes.
	// In that case, to preserve compact 1-byte code headers,
	// we must declare unconditional presence of code flags.
	int cost0 = 0;
	int cost1 = 0;
	for (Class cls : pkg.classes) {
	for (Class.Method m : cls.getMethods()) {
	if (m.code != null) {
	if (m.code.attributeSize() == 0) {
	// cost of a useless unconditional flags byte
	cost1 += 1;
	} else if (shortCodeHeader(m.code) != LONG_CODE_HEADER) {
	// cost of inflating a short header
	cost0 += 3;
	}
	}
	}
	}
	if (cost0 > cost1) {
	archiveOptions \|= AO_HAVE_ALL_CODE_FLAGS;
	}
	if (verbose > 0)
	Utils.log.info("archiveOptions = "
	+"0b"+Integer.toBinaryString(archiveOptions));
	}

	void writeFileHeader() throws IOException {
	chooseDefaultPackageVersion();
	writeArchiveMagic();
	writeArchiveHeader();
	}

	// Local routine used to format fixed-format scalars
	// in the file_header:
	private void putMagicInt32(int val) throws IOException {
	int res = val;
	for (int i = 0; i < 4; i++) {
	archive_magic.putByte(0xFF & (res >>> 24));
	res <<= 8;
	}
	}

	void writeArchiveMagic() throws IOException {
	putMagicInt32(pkg.magic);
	}

	void writeArchiveHeader() throws IOException {
	// for debug only: number of words optimized away
	int headerSizeForDebug = AH_LENGTH_MIN;

	// AO_HAVE_SPECIAL_FORMATS is set if non-default
	// coding techniques are used, or if there are
	// compressor-defined attributes transmitted.
	boolean haveSpecial = testBit(archiveOptions, AO_HAVE_SPECIAL_FORMATS);
	if (!haveSpecial) {
	haveSpecial \|= (band_headers.length() != 0);
	haveSpecial \|= (attrDefsWritten.length != 0);
	if (haveSpecial)
	archiveOptions \|= AO_HAVE_SPECIAL_FORMATS;
	}
	if (haveSpecial)
	headerSizeForDebug += AH_SPECIAL_FORMAT_LEN;

	// AO_HAVE_FILE_HEADERS is set if there is any
	// file or segment envelope information present.
	boolean haveFiles = testBit(archiveOptions, AO_HAVE_FILE_HEADERS);
	if (!haveFiles) {
	haveFiles \|= (archiveNextCount > 0);
	haveFiles \|= (pkg.default_modtime != NO_MODTIME);
	if (haveFiles)
	archiveOptions \|= AO_HAVE_FILE_HEADERS;
	}
	if (haveFiles)
	headerSizeForDebug += AH_FILE_HEADER_LEN;

	// AO_HAVE_CP_NUMBERS is set if there are any numbers
	// in the global constant pool. (Numbers are in 15% of classes.)
	boolean haveNumbers = testBit(archiveOptions, AO_HAVE_CP_NUMBERS);
	if (!haveNumbers) {
	haveNumbers \|= pkg.cp.haveNumbers();
	if (haveNumbers)
	archiveOptions \|= AO_HAVE_CP_NUMBERS;
	}
	if (haveNumbers)
	headerSizeForDebug += AH_CP_NUMBER_LEN;

	// AO_HAVE_CP_EXTRAS is set if there are constant pool entries
	// beyond the Java 6 version of the class file format.
	boolean haveCPExtra = testBit(archiveOptions, AO_HAVE_CP_EXTRAS);
	if (!haveCPExtra) {
	haveCPExtra \|= pkg.cp.haveExtraTags();
	if (haveCPExtra)
	archiveOptions \|= AO_HAVE_CP_EXTRAS;
	}
	if (haveCPExtra)
	headerSizeForDebug += AH_CP_EXTRA_LEN;

	// the archiveOptions are all initialized, sanity check now!.
	checkVersion();

	archive_header_0.putInt(packageVersion.minor);
	archive_header_0.putInt(packageVersion.major);
	if (verbose > 0)
	Utils.log.info("Package Version for this segment:" + packageVersion);
	archive_header_0.putInt(archiveOptions); // controls header format
	assert(archive_header_0.length() == AH_LENGTH_0);

	final int DUMMY = 0;
	if (haveFiles) {
	assert(archive_header_S.length() == AH_ARCHIVE_SIZE_HI);
	archive_header_S.putInt(DUMMY); // (archiveSize1 >>> 32)
	assert(archive_header_S.length() == AH_ARCHIVE_SIZE_LO);
	archive_header_S.putInt(DUMMY); // (archiveSize1 >>> 0)
	assert(archive_header_S.length() == AH_LENGTH_S);
	}

	// Done with unsized part of header....

	if (haveFiles) {
	archive_header_1.putInt(archiveNextCount); // usually zero
	archive_header_1.putInt(pkg.default_modtime);
	archive_header_1.putInt(pkg.files.size());
	} else {
	assert(pkg.files.isEmpty());
	}

	if (haveSpecial) {
	archive_header_1.putInt(band_headers.length());
	archive_header_1.putInt(attrDefsWritten.length);
	} else {
	assert(band_headers.length() == 0);
	assert(attrDefsWritten.length == 0);
	}

	writeConstantPoolCounts(haveNumbers, haveCPExtra);

	archive_header_1.putInt(pkg.getAllInnerClasses().size());
	archive_header_1.putInt(pkg.defaultClassVersion.minor);
	archive_header_1.putInt(pkg.defaultClassVersion.major);
	archive_header_1.putInt(pkg.classes.size());

	// Sanity: Make sure we came out to 29 (less optional fields):
	assert(archive_header_0.length() +
	archive_header_S.length() +
	archive_header_1.length()
	== headerSizeForDebug);

	// Figure out all the sizes now, first cut:
	archiveSize0 = 0;
	archiveSize1 = all_bands.outputSize();
	// Second cut:
	archiveSize0 += archive_magic.outputSize();
	archiveSize0 += archive_header_0.outputSize();
	archiveSize0 += archive_header_S.outputSize();
	// Make the adjustments:
	archiveSize1 -= archiveSize0;

	// Patch the header:
	if (haveFiles) {
	int archiveSizeHi = (int)(archiveSize1 >>> 32);
	int archiveSizeLo = (int)(archiveSize1 >>> 0);
	archive_header_S.patchValue(AH_ARCHIVE_SIZE_HI, archiveSizeHi);
	archive_header_S.patchValue(AH_ARCHIVE_SIZE_LO, archiveSizeLo);
	int zeroLen = UNSIGNED5.getLength(DUMMY);
	archiveSize0 += UNSIGNED5.getLength(archiveSizeHi) - zeroLen;
	archiveSize0 += UNSIGNED5.getLength(archiveSizeLo) - zeroLen;
	}
	if (verbose > 1)
	Utils.log.fine("archive sizes: "+
	archiveSize0+"+"+archiveSize1);
	assert(all_bands.outputSize() == archiveSize0+archiveSize1);
	}

	void writeConstantPoolCounts(boolean haveNumbers, boolean haveCPExtra) throws IOException {
	for (byte tag : ConstantPool.TAGS_IN_ORDER) {
	int count = pkg.cp.getIndexByTag(tag).size();
	switch (tag) {
	case CONSTANT_Utf8:
	// The null string is always first.
	if (count > 0)
	assert(pkg.cp.getIndexByTag(tag).get(0)
	== ConstantPool.getUtf8Entry(""));
	break;

	case CONSTANT_Integer:
	case CONSTANT_Float:
	case CONSTANT_Long:
	case CONSTANT_Double:
	// Omit counts for numbers if possible.
	if (!haveNumbers) {
	assert(count == 0);
	continue;
	}
	break;

	case CONSTANT_MethodHandle:
	case CONSTANT_MethodType:
	case CONSTANT_InvokeDynamic:
	case CONSTANT_BootstrapMethod:
	// Omit counts for newer entities if possible.
	if (!haveCPExtra) {
	assert(count == 0);
	continue;
	}
	break;
	}
	archive_header_1.putInt(count);
	}
	}

	protected Index getCPIndex(byte tag) {
	return pkg.cp.getIndexByTag(tag);
	}

	// (The following observations are out of date; they apply only to
	// "banding" the constant pool itself. Later revisions of this algorithm
	// applied the banding technique to every part of the package file,
	// applying the benefits more broadly.)

	// Note: Keeping the data separate in passes (or "bands") allows the
	// compressor to issue significantly shorter indexes for repeated data.
	// The difference in zipped size is 4%, which is remarkable since the
	// unzipped sizes are the same (only the byte order differs).

	// After moving similar data into bands, it becomes natural to delta-encode
	// each band. (This is especially useful if we sort the constant pool first.)
	// Delta encoding saves an extra 5% in the output size (13% of the CP itself).
	// Because a typical delta usees much less data than a byte, the savings after
	// zipping is even better: A zipped delta-encoded package is 8% smaller than
	// a zipped non-delta-encoded package. Thus, in the zipped file, a banded,
	// delta-encoded constant pool saves over 11% (of the total file size) compared
	// with a zipped unbanded file.

	void writeConstantPool() throws IOException {
	IndexGroup cp = pkg.cp;

	if (verbose > 0) Utils.log.info("Writing CP");

	for (byte tag : ConstantPool.TAGS_IN_ORDER) {
	Index index = cp.getIndexByTag(tag);

	Entry[] cpMap = index.cpMap;
	if (verbose > 0)
	Utils.log.info("Writing "+cpMap.length+" "+ConstantPool.tagName(tag)+" entries...");

	if (optDumpBands) {
	try (PrintStream ps = new PrintStream(getDumpStream(index, ".idx"))) {
	printArrayTo(ps, cpMap, 0, cpMap.length);
	}
	}

	switch (tag) {
	case CONSTANT_Utf8:
	writeUtf8Bands(cpMap);
	break;
	case CONSTANT_Integer:
	for (int i = 0; i < cpMap.length; i++) {
	NumberEntry e = (NumberEntry) cpMap[i];
	int x = ((Integer)e.numberValue()).intValue();
	cp_Int.putInt(x);
	}
	break;
	case CONSTANT_Float:
	for (int i = 0; i < cpMap.length; i++) {
	NumberEntry e = (NumberEntry) cpMap[i];
	float fx = ((Float)e.numberValue()).floatValue();
	int x = Float.floatToIntBits(fx);
	cp_Float.putInt(x);
	}
	break;
	case CONSTANT_Long:
	for (int i = 0; i < cpMap.length; i++) {
	NumberEntry e = (NumberEntry) cpMap[i];
	long x = ((Long)e.numberValue()).longValue();
	cp_Long_hi.putInt((int)(x >>> 32));
	cp_Long_lo.putInt((int)(x >>> 0));
	}
	break;
	case CONSTANT_Double:
	for (int i = 0; i < cpMap.length; i++) {
	NumberEntry e = (NumberEntry) cpMap[i];
	double dx = ((Double)e.numberValue()).doubleValue();
	long x = Double.doubleToLongBits(dx);
	cp_Double_hi.putInt((int)(x >>> 32));
	cp_Double_lo.putInt((int)(x >>> 0));
	}
	break;
	case CONSTANT_String:
	for (int i = 0; i < cpMap.length; i++) {
	StringEntry e = (StringEntry) cpMap[i];
	cp_String.putRef(e.ref);
	}
	break;
	case CONSTANT_Class:
	for (int i = 0; i < cpMap.length; i++) {
	ClassEntry e = (ClassEntry) cpMap[i];
	cp_Class.putRef(e.ref);
	}
	break;
	case CONSTANT_Signature:
	writeSignatureBands(cpMap);
	break;
	case CONSTANT_NameandType:
	for (int i = 0; i < cpMap.length; i++) {
	DescriptorEntry e = (DescriptorEntry) cpMap[i];
	cp_Descr_name.putRef(e.nameRef);
	cp_Descr_type.putRef(e.typeRef);
	}
	break;
	case CONSTANT_Fieldref:
	writeMemberRefs(tag, cpMap, cp_Field_class, cp_Field_desc);
	break;
	case CONSTANT_Methodref:
	writeMemberRefs(tag, cpMap, cp_Method_class, cp_Method_desc);
	break;
	case CONSTANT_InterfaceMethodref:
	writeMemberRefs(tag, cpMap, cp_Imethod_class, cp_Imethod_desc);
	break;
	case CONSTANT_MethodHandle:
	for (int i = 0; i < cpMap.length; i++) {
	MethodHandleEntry e = (MethodHandleEntry) cpMap[i];
	cp_MethodHandle_refkind.putInt(e.refKind);
	cp_MethodHandle_member.putRef(e.memRef);
	}
	break;
	case CONSTANT_MethodType:
	for (int i = 0; i < cpMap.length; i++) {
	MethodTypeEntry e = (MethodTypeEntry) cpMap[i];
	cp_MethodType.putRef(e.typeRef);
	}
	break;
	case CONSTANT_InvokeDynamic:
	for (int i = 0; i < cpMap.length; i++) {
	InvokeDynamicEntry e = (InvokeDynamicEntry) cpMap[i];
	cp_InvokeDynamic_spec.putRef(e.bssRef);
	cp_InvokeDynamic_desc.putRef(e.descRef);
	}
	break;
	case CONSTANT_BootstrapMethod:
	for (int i = 0; i < cpMap.length; i++) {
	BootstrapMethodEntry e = (BootstrapMethodEntry) cpMap[i];
	cp_BootstrapMethod_ref.putRef(e.bsmRef);
	cp_BootstrapMethod_arg_count.putInt(e.argRefs.length);
	for (Entry argRef : e.argRefs) {
	cp_BootstrapMethod_arg.putRef(argRef);
	}
	}
	break;
	default:
	throw new AssertionError("unexpected CP tag in package");
	}
	}
	if (optDumpBands \|\| verbose > 1) {
	for (byte tag = CONSTANT_GroupFirst; tag < CONSTANT_GroupLimit; tag++) {
	Index index = cp.getIndexByTag(tag);
	if (index == null \|\| index.isEmpty()) continue;
	Entry[] cpMap = index.cpMap;
	if (verbose > 1)
	Utils.log.info("Index group "+ConstantPool.tagName(tag)+" contains "+cpMap.length+" entries.");
	if (optDumpBands) {
	try (PrintStream ps = new PrintStream(getDumpStream(index.debugName, tag, ".gidx", index))) {
	printArrayTo(ps, cpMap, 0, cpMap.length, true);
	}
	}
	}
	}
	}

	void writeUtf8Bands(Entry[] cpMap) throws IOException {
	if (cpMap.length == 0)
	return; // nothing to write

	// The first element must always be the empty string.
	assert(cpMap[0].stringValue().equals(""));
	final int SUFFIX_SKIP_1 = 1;
	final int PREFIX_SKIP_2 = 2;

	// Fetch the char arrays, first of all.
	char[][] chars = new char[cpMap.length][];
	for (int i = 0; i < chars.length; i++) {
	chars[i] = cpMap[i].stringValue().toCharArray();
	}

	// First band: Write lengths of shared prefixes.
	int[] prefixes = new int[cpMap.length]; // includes 2 skipped zeroes
	char[] prevChars = {};
	for (int i = 0; i < chars.length; i++) {
	int prefix = 0;
	char[] curChars = chars[i];
	int limit = Math.min(curChars.length, prevChars.length);
	while (prefix < limit && curChars[prefix] == prevChars[prefix])
	prefix++;
	prefixes[i] = prefix;
	if (i >= PREFIX_SKIP_2)
	cp_Utf8_prefix.putInt(prefix);
	else
	assert(prefix == 0);
	prevChars = curChars;
	}

	// Second band: Write lengths of unshared suffixes.
	// Third band: Write the char values in the unshared suffixes.
	for (int i = 0; i < chars.length; i++) {
	char[] str = chars[i];
	int prefix = prefixes[i];
	int suffix = str.length - prefixes[i];
	boolean isPacked = false;
	if (suffix == 0) {
	// Zero suffix length is special flag to indicate
	// separate treatment in cp_Utf8_big bands.
	// This suffix length never occurs naturally,
	// except in the one case of a zero-length string.
	// (If it occurs, it is the first, due to sorting.)
	// The zero length string must, paradoxically, be
	// encoded as a zero-length cp_Utf8_big band.
	// This wastes exactly (& tolerably) one null byte.
	isPacked = (i >= SUFFIX_SKIP_1);
	// Do not bother to add an empty "(Utf8_big_0)" band.
	// Also, the initial empty string does not require a band.
	} else if (optBigStrings && effort > 1 && suffix > 100) {
	int numWide = 0;
	for (int n = 0; n < suffix; n++) {
	if (str[prefix+n] > 127) {
	numWide++;
	}
	}
	if (numWide > 100) {
	// Try packing the chars with an alternate encoding.
	isPacked = tryAlternateEncoding(i, numWide, str, prefix);
	}
	}
	if (i < SUFFIX_SKIP_1) {
	// No output.
	assert(!isPacked);
	assert(suffix == 0);
	} else if (isPacked) {
	// Mark packed string with zero-length suffix count.
	// This tells the unpacker to go elsewhere for the suffix bits.
	// Fourth band: Write unshared suffix with alternate coding.
	cp_Utf8_suffix.putInt(0);
	cp_Utf8_big_suffix.putInt(suffix);
	} else {
	assert(suffix != 0); // would be ambiguous
	// Normal string. Save suffix in third and fourth bands.
	cp_Utf8_suffix.putInt(suffix);
	for (int n = 0; n < suffix; n++) {
	int ch = str[prefix+n];
	cp_Utf8_chars.putInt(ch);
	}
	}
	}
	if (verbose > 0) {
	int normCharCount = cp_Utf8_chars.length();
	int packCharCount = cp_Utf8_big_chars.length();
	int charCount = normCharCount + packCharCount;
	Utils.log.info("Utf8string #CHARS="+charCount+" #PACKEDCHARS="+packCharCount);
	}
	}

	private boolean tryAlternateEncoding(int i, int numWide,
	char[] str, int prefix) {
	int suffix = str.length - prefix;
	int[] cvals = new int[suffix];
	for (int n = 0; n < suffix; n++) {
	cvals[n] = str[prefix+n];
	}
	CodingChooser cc = getCodingChooser();
	Coding bigRegular = cp_Utf8_big_chars.regularCoding;
	String bandName = "(Utf8_big_"+i+")";
	int[] sizes = { 0, 0 };
	final int BYTE_SIZE = CodingChooser.BYTE_SIZE;
	final int ZIP_SIZE = CodingChooser.ZIP_SIZE;
	if (verbose > 1 \|\| cc.verbose > 1) {
	Utils.log.fine("--- chooseCoding "+bandName);
	}
	CodingMethod special = cc.choose(cvals, bigRegular, sizes);
	Coding charRegular = cp_Utf8_chars.regularCoding;
	if (verbose > 1)
	Utils.log.fine("big string["+i+"] len="+suffix+" #wide="+numWide+" size="+sizes[BYTE_SIZE]+"/z="+sizes[ZIP_SIZE]+" coding "+special);
	if (special != charRegular) {
	int specialZipSize = sizes[ZIP_SIZE];
	int[] normalSizes = cc.computeSize(charRegular, cvals);
	int normalZipSize = normalSizes[ZIP_SIZE];
	int minWin = Math.max(5, normalZipSize/1000);
	if (verbose > 1)
	Utils.log.fine("big string["+i+"] normalSize="+normalSizes[BYTE_SIZE]+"/z="+normalSizes[ZIP_SIZE]+" win="+(specialZipSize<normalZipSize-minWin));
	if (specialZipSize < normalZipSize-minWin) {
	IntBand big = cp_Utf8_big_chars.newIntBand(bandName);
	big.initializeValues(cvals);
	return true;
	}
	}
	return false;
	}

	void writeSignatureBands(Entry[] cpMap) throws IOException {
	for (int i = 0; i < cpMap.length; i++) {
	SignatureEntry e = (SignatureEntry) cpMap[i];
	cp_Signature_form.putRef(e.formRef);
	for (int j = 0; j < e.classRefs.length; j++) {
	cp_Signature_classes.putRef(e.classRefs[j]);
	}
	}
	}

	void writeMemberRefs(byte tag, Entry[] cpMap, CPRefBand cp_class, CPRefBand cp_desc) throws IOException {
	for (int i = 0; i < cpMap.length; i++) {
	MemberEntry e = (MemberEntry) cpMap[i];
	cp_class.putRef(e.classRef);
	cp_desc.putRef(e.descRef);
	}
	}

	void writeFiles() throws IOException {
	int numFiles = pkg.files.size();
	if (numFiles == 0) return;
	int options = archiveOptions;
	boolean haveSizeHi = testBit(options, AO_HAVE_FILE_SIZE_HI);
	boolean haveModtime = testBit(options, AO_HAVE_FILE_MODTIME);
	boolean haveOptions = testBit(options, AO_HAVE_FILE_OPTIONS);
	if (!haveOptions) {
	for (File file : pkg.files) {
	if (file.isClassStub()) {
	haveOptions = true;
	options \|= AO_HAVE_FILE_OPTIONS;
	archiveOptions = options;
	break;
	}
	}
	}
	if (haveSizeHi \|\| haveModtime \|\| haveOptions \|\| !pkg.files.isEmpty()) {
	options \|= AO_HAVE_FILE_HEADERS;
	archiveOptions = options;
	}
	for (File file : pkg.files) {
	file_name.putRef(file.name);
	long len = file.getFileLength();
	file_size_lo.putInt((int)len);
	if (haveSizeHi)
	file_size_hi.putInt((int)(len >>> 32));
	if (haveModtime)
	file_modtime.putInt(file.modtime - pkg.default_modtime);
	if (haveOptions)
	file_options.putInt(file.options);
	file.writeTo(file_bits.collectorStream());
	if (verbose > 1)
	Utils.log.fine("Wrote "+len+" bytes of "+file.name.stringValue());
	}
	if (verbose > 0)
	Utils.log.info("Wrote "+numFiles+" resource files");
	}

	void collectAttributeLayouts() {
	maxFlags = new int[ATTR_CONTEXT_LIMIT];
	allLayouts = new FixedList<>(ATTR_CONTEXT_LIMIT);
	for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
	allLayouts.set(i, new HashMap<Attribute.Layout, int[]>());
	}
	// Collect maxFlags and allLayouts.
	for (Class cls : pkg.classes) {
	visitAttributeLayoutsIn(ATTR_CONTEXT_CLASS, cls);
	for (Class.Field f : cls.getFields()) {
	visitAttributeLayoutsIn(ATTR_CONTEXT_FIELD, f);
	}
	for (Class.Method m : cls.getMethods()) {
	visitAttributeLayoutsIn(ATTR_CONTEXT_METHOD, m);
	if (m.code != null) {
	visitAttributeLayoutsIn(ATTR_CONTEXT_CODE, m.code);
	}
	}
	}
	// If there are many species of attributes, use 63-bit flags.
	for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
	int nl = allLayouts.get(i).size();
	boolean haveLongFlags = haveFlagsHi(i);
	final int TOO_MANY_ATTRS = 32 /int flag size/
	- 12 /typical flag bits in use/
	+ 4 /typical number of OK overflows/;
	if (nl >= TOO_MANY_ATTRS) { // heuristic
	int mask = 1<<(LG_AO_HAVE_XXX_FLAGS_HI+i);
	archiveOptions \|= mask;
	haveLongFlags = true;
	if (verbose > 0)
	Utils.log.info("Note: Many "+Attribute.contextName(i)+" attributes forces 63-bit flags");
	}
	if (verbose > 1) {
	Utils.log.fine(Attribute.contextName(i)+".maxFlags = 0x"+Integer.toHexString(maxFlags[i]));
	Utils.log.fine(Attribute.contextName(i)+".#layouts = "+nl);
	}
	assert(haveFlagsHi(i) == haveLongFlags);
	}
	initAttrIndexLimit();

	// Standard indexes can never conflict with flag bits. Assert it.
	for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
	assert((attrFlagMask[i] & maxFlags[i]) == 0);
	}
	// Collect counts for both predefs. and custom defs.
	// Decide on custom, local attribute definitions.
	backCountTable = new HashMap<>();
	attrCounts = new int[ATTR_CONTEXT_LIMIT][];
	for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
	// Now the remaining defs in allLayouts[i] need attr. indexes.
	// Fill up unused flag bits with new defs.
	// Unused bits are those which are not used by predefined attrs,
	// and which are always clear in the classfiles.
	long avHiBits = ~(maxFlags[i] \| attrFlagMask[i]);
	assert(attrIndexLimit[i] > 0);
	assert(attrIndexLimit[i] < 64); // all bits fit into a Java long
	avHiBits &= (1L<<attrIndexLimit[i])-1;
	int nextLoBit = 0;
	Map<Attribute.Layout, int[]> defMap = allLayouts.get(i);
	@SuppressWarnings({"unchecked", "rawtypes"})
	Map.Entry<Attribute.Layout, int[]>[] layoutsAndCounts =
	new Map.Entry[defMap.size()];
	defMap.entrySet().toArray(layoutsAndCounts);
	// Sort by count, most frequent first.
	// Predefs. participate in this sort, though it does not matter.
	Arrays.sort(layoutsAndCounts,
	new Comparator<Map.Entry<Attribute.Layout, int[]>>() {
	public int compare(Map.Entry<Attribute.Layout, int[]> e0,
	Map.Entry<Attribute.Layout, int[]> e1) {
	// Primary sort key is count, reversed.
	int r = -(e0.getValue()[0] - e1.getValue()[0]);
	if (r != 0) return r;
	return e0.getKey().compareTo(e1.getKey());
	}
	});
	attrCounts[i] = new int[attrIndexLimit[i]+layoutsAndCounts.length];
	for (int j = 0; j < layoutsAndCounts.length; j++) {
	Map.Entry<Attribute.Layout, int[]> e = layoutsAndCounts[j];
	Attribute.Layout def = e.getKey();
	int count = e.getValue()[0];
	int index;
	Integer predefIndex = attrIndexTable.get(def);
	if (predefIndex != null) {
	// The index is already set.
	index = predefIndex.intValue();
	} else if (avHiBits != 0) {
	while ((avHiBits & 1) == 0) {
	avHiBits >>>= 1;
	nextLoBit += 1;
	}
	avHiBits -= 1; // clear low bit; we are using it now
	// Update attrIndexTable:
	index = setAttributeLayoutIndex(def, nextLoBit);
	} else {
	// Update attrIndexTable:
	index = setAttributeLayoutIndex(def, ATTR_INDEX_OVERFLOW);
	}

	// Now that we know the index, record the count of this def.
	attrCounts[i][index] = count;

	// For all callables in the def, keep a tally of back-calls.
	Attribute.Layout.Element[] cbles = def.getCallables();
	final int[] bc = new int[cbles.length];
	for (int k = 0; k < cbles.length; k++) {
	assert(cbles[k].kind == Attribute.EK_CBLE);
	if (!cbles[k].flagTest(Attribute.EF_BACK)) {
	bc[k] = -1; // no count to accumulate here
	}
	}
	backCountTable.put(def, bc);

	if (predefIndex == null) {
	// Make sure the package CP can name the local attribute.
	Entry ne = ConstantPool.getUtf8Entry(def.name());
	String layout = def.layoutForClassVersion(getHighestClassVersion());
	Entry le = ConstantPool.getUtf8Entry(layout);
	requiredEntries.add(ne);
	requiredEntries.add(le);
	if (verbose > 0) {
	if (index < attrIndexLimit[i])
	Utils.log.info("Using free flag bit 1<<"+index+" for "+count+" occurrences of "+def);
	else
	Utils.log.info("Using overflow index "+index+" for "+count+" occurrences of "+def);
	}
	}
	}
	}
	// Later, when emitting attr_definition_bands, we will look at
	// attrDefSeen and attrDefs at position 32/63 and beyond.
	// The attrIndexTable will provide elements of xxx_attr_indexes bands.

	// Done with scratch variables:
	maxFlags = null;
	allLayouts = null;
	}

	// Scratch variables for processing attributes and flags.
	int[] maxFlags;
	List<Map<Attribute.Layout, int[]>> allLayouts;

	void visitAttributeLayoutsIn(int ctype, Attribute.Holder h) {
	// Make note of which flags appear in the class file.
	// Set them in maxFlags.
	maxFlags[ctype] \|= h.flags;
	for (Attribute a : h.getAttributes()) {
	Attribute.Layout def = a.layout();
	Map<Attribute.Layout, int[]> defMap = allLayouts.get(ctype);
	int[] count = defMap.get(def);
	if (count == null) {
	defMap.put(def, count = new int[1]);
	}
	if (count[0] < Integer.MAX_VALUE) {
	count[0] += 1;
	}
	}
	}

	Attribute.Layout[] attrDefsWritten;

	void writeAttrDefs() throws IOException {
	List<Object[]> defList = new ArrayList<>();
	for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) {
	int limit = attrDefs.get(i).size();
	for (int j = 0; j < limit; j++) {
	int header = i; // ctype
	if (j < attrIndexLimit[i]) {
	header \|= ((j + ADH_BIT_IS_LSB) << ADH_BIT_SHIFT);
	assert(header < 0x100); // must fit into a byte
	// (...else header is simply ctype, with zero high bits.)
	if (!testBit(attrDefSeen[i], 1L<<j)) {
	// either undefined or predefined; nothing to write
	continue;
	}
	}
	Attribute.Layout def = attrDefs.get(i).get(j);
	defList.add(new Object[]{ Integer.valueOf(header), def });
	assert(Integer.valueOf(j).equals(attrIndexTable.get(def)));
	}
	}
	// Sort the new attr defs into some "natural" order.
	int numAttrDefs = defList.size();
	Object[][] defs = new Object[numAttrDefs][];
	defList.toArray(defs);
	Arrays.sort(defs, new Comparator<Object[]>() {
	public int compare(Object[] a0, Object[] a1) {
	// Primary sort key is attr def header.
	@SuppressWarnings("unchecked")
	int r = ((Comparable)a0[0]).compareTo(a1[0]);
	if (r != 0) return r;
	Integer ind0 = attrIndexTable.get(a0[1]);
	Integer ind1 = attrIndexTable.get(a1[1]);
	// Secondary sort key is attribute index.
	// (This must be so, in order to keep overflow attr order.)
	assert(ind0 != null);
	assert(ind1 != null);
	return ind0.compareTo(ind1);
	}
	});
	attrDefsWritten = new Attribute.Layout[numAttrDefs];
	try (PrintStream dump = !optDumpBands ? null
	: new PrintStream(getDumpStream(attr_definition_headers, ".def")))
	{
	int[] indexForDebug = Arrays.copyOf(attrIndexLimit, ATTR_CONTEXT_LIMIT);
	for (int i = 0; i < defs.length; i++) {
	int header = ((Integer)defs[i][0]).intValue();
	Attribute.Layout def = (Attribute.Layout) defs[i][1];
	attrDefsWritten[i] = def;
	assert((header & ADH_CONTEXT_MASK) == def.ctype());
	attr_definition_headers.putByte(header);
	attr_definition_name.putRef(ConstantPool.getUtf8Entry(def.name()));
	String layout = def.layoutForClassVersion(getHighestClassVersion());
	attr_definition_layout.putRef(ConstantPool.getUtf8Entry(layout));
	// Check that we are transmitting that correct attribute index:
	boolean debug = false;
	assert(debug = true);
	if (debug) {
	int hdrIndex = (header >> ADH_BIT_SHIFT) - ADH_BIT_IS_LSB;
	if (hdrIndex < 0) hdrIndex = indexForDebug[def.ctype()]++;
	int realIndex = (attrIndexTable.get(def)).intValue();
	assert(hdrIndex == realIndex);
	}
	if (dump != null) {
	int index = (header >> ADH_BIT_SHIFT) - ADH_BIT_IS_LSB;
	dump.println(index+" "+def);
	}
	}
	}
	}

	void writeAttrCounts() throws IOException {
	// Write the four xxx_attr_calls bands.
	for (int ctype = 0; ctype < ATTR_CONTEXT_LIMIT; ctype++) {
	MultiBand xxx_attr_bands = attrBands[ctype];
	IntBand xxx_attr_calls = getAttrBand(xxx_attr_bands, AB_ATTR_CALLS);
	Attribute.Layout[] defs = new Attribute.Layout[attrDefs.get(ctype).size()];
	attrDefs.get(ctype).toArray(defs);
	for (boolean predef = true; ; predef = false) {
	for (int ai = 0; ai < defs.length; ai++) {
	Attribute.Layout def = defs[ai];
	if (def == null) continue; // unused index
	if (predef != isPredefinedAttr(ctype, ai))
	continue; // wrong pass
	int totalCount = attrCounts[ctype][ai];
	if (totalCount == 0)
	continue; // irrelevant
	int[] bc = backCountTable.get(def);
	for (int j = 0; j < bc.length; j++) {
	if (bc[j] >= 0) {
	int backCount = bc[j];
	bc[j] = -1; // close out; do not collect further counts
	xxx_attr_calls.putInt(backCount);
	assert(def.getCallables()[j].flagTest(Attribute.EF_BACK));
	} else {
	assert(!def.getCallables()[j].flagTest(Attribute.EF_BACK));
	}
	}
	}
	if (!predef) break;
	}
	}
	}

	void trimClassAttributes() {
	for (Class cls : pkg.classes) {
	// Replace "obvious" SourceFile attrs by null.
	cls.minimizeSourceFile();
	// BootstrapMethods should never have been inserted.
	assert(cls.getAttribute(Package.attrBootstrapMethodsEmpty) == null);
	}
	}

	void collectInnerClasses() {
	// Capture inner classes, removing them from individual classes.
	// Irregular inner classes must stay local, though.
	Map<ClassEntry, InnerClass> allICMap = new HashMap<>();
	// First, collect a consistent global set.
	for (Class cls : pkg.classes) {
	if (!cls.hasInnerClasses()) continue;
	for (InnerClass ic : cls.getInnerClasses()) {
	InnerClass pic = allICMap.put(ic.thisClass, ic);
	if (pic != null && !pic.equals(ic) && pic.predictable) {
	// Different ICs. Choose the better to make global.
	allICMap.put(pic.thisClass, pic);
	}
	}
	}

	InnerClass[] allICs = new InnerClass[allICMap.size()];
	allICMap.values().toArray(allICs);
	allICMap = null; // done with it

	// Note: The InnerClasses attribute must be in a valid order,
	// so that A$B always occurs earlier than A$B$C. This is an
	// important side-effect of sorting lexically by class name.
	Arrays.sort(allICs); // put in canonical order
	pkg.setAllInnerClasses(Arrays.asList(allICs));

	// Next, empty out of every local set the consistent entries.
	// Calculate whether there is any remaining need to have a local
	// set, and whether it needs to be locked.
	for (Class cls : pkg.classes) {
	cls.minimizeLocalICs();
	}
	}

	void writeInnerClasses() throws IOException {
	for (InnerClass ic : pkg.getAllInnerClasses()) {
	int flags = ic.flags;
	assert((flags & ACC_IC_LONG_FORM) == 0);
	if (!ic.predictable) {
	flags \|= ACC_IC_LONG_FORM;
	}
	ic_this_class.putRef(ic.thisClass);
	ic_flags.putInt(flags);
	if (!ic.predictable) {
	ic_outer_class.putRef(ic.outerClass);
	ic_name.putRef(ic.name);
	}
	}
	}

	/** If there are any extra InnerClasses entries to write which are
	* not already implied by the global table, put them into a
	* local attribute. This is expected to be rare.
	*/
	void writeLocalInnerClasses(Class cls) throws IOException {
	List<InnerClass> localICs = cls.getInnerClasses();
	class_InnerClasses_N.putInt(localICs.size());
	for(InnerClass ic : localICs) {
	class_InnerClasses_RC.putRef(ic.thisClass);
	// Is it redundant with the global version?
	if (ic.equals(pkg.getGlobalInnerClass(ic.thisClass))) {
	// A zero flag means copy a global IC here.
	class_InnerClasses_F.putInt(0);
	} else {
	int flags = ic.flags;
	if (flags == 0)
	flags = ACC_IC_LONG_FORM; // force it to be non-zero
	class_InnerClasses_F.putInt(flags);
	class_InnerClasses_outer_RCN.putRef(ic.outerClass);
	class_InnerClasses_name_RUN.putRef(ic.name);
	}
	}
	}

	void writeClassesAndByteCodes() throws IOException {
	Class[] classes = new Class[pkg.classes.size()];
	pkg.classes.toArray(classes);
	// Note: This code respects the order in which caller put classes.
	if (verbose > 0)
	Utils.log.info(" ...scanning "+classes.length+" classes...");

	int nwritten = 0;
	for (int i = 0; i < classes.length; i++) {
	// Collect the class body, sans bytecodes.
	Class cls = classes[i];
	if (verbose > 1)
	Utils.log.fine("Scanning "+cls);

	ClassEntry thisClass = cls.thisClass;
	ClassEntry superClass = cls.superClass;
	ClassEntry[] interfaces = cls.interfaces;
	// Encode rare case of null superClass as thisClass:
	assert(superClass != thisClass); // bad class file!?
	if (superClass == null) superClass = thisClass;
	class_this.putRef(thisClass);
	class_super.putRef(superClass);
	class_interface_count.putInt(cls.interfaces.length);
	for (int j = 0; j < interfaces.length; j++) {
	class_interface.putRef(interfaces[j]);
	}

	writeMembers(cls);
	writeAttrs(ATTR_CONTEXT_CLASS, cls, cls);

	nwritten++;
	if (verbose > 0 && (nwritten % 1000) == 0)
	Utils.log.info("Have scanned "+nwritten+" classes...");
	}
	}

	void writeMembers(Class cls) throws IOException {
	List<Class.Field> fields = cls.getFields();
	class_field_count.putInt(fields.size());
	for (Class.Field f : fields) {
	field_descr.putRef(f.getDescriptor());
	writeAttrs(ATTR_CONTEXT_FIELD, f, cls);
	}

	List<Class.Method> methods = cls.getMethods();
	class_method_count.putInt(methods.size());
	for (Class.Method m : methods) {
	method_descr.putRef(m.getDescriptor());
	writeAttrs(ATTR_CONTEXT_METHOD, m, cls);
	assert((m.code != null) == (m.getAttribute(attrCodeEmpty) != null));
	if (m.code != null) {
	writeCodeHeader(m.code);
	writeByteCodes(m.code);
	}
	}
	}

	void writeCodeHeader(Code c) throws IOException {
	boolean attrsOK = testBit(archiveOptions, AO_HAVE_ALL_CODE_FLAGS);
	int na = c.attributeSize();
	int sc = shortCodeHeader(c);
	if (!attrsOK && na > 0)
	// We must write flags, and can only do so for long headers.
	sc = LONG_CODE_HEADER;
	if (verbose > 2) {
	int siglen = c.getMethod().getArgumentSize();
	Utils.log.fine("Code sizes info "+c.max_stack+" "+c.max_locals+" "+c.getHandlerCount()+" "+siglen+" "+na+(sc > 0 ? " SHORT="+sc : ""));
	}
	code_headers.putByte(sc);
	if (sc == LONG_CODE_HEADER) {
	code_max_stack.putInt(c.getMaxStack());
	code_max_na_locals.putInt(c.getMaxNALocals());
	code_handler_count.putInt(c.getHandlerCount());
	} else {
	assert(attrsOK \|\| na == 0);
	assert(c.getHandlerCount() < shortCodeHeader_h_limit);
	}
	writeCodeHandlers(c);
	if (sc == LONG_CODE_HEADER \|\| attrsOK)
	writeAttrs(ATTR_CONTEXT_CODE, c, c.thisClass());
	}

	void writeCodeHandlers(Code c) throws IOException {
	int sum, del;
	for (int j = 0, jmax = c.getHandlerCount(); j < jmax; j++) {
	code_handler_class_RCN.putRef(c.handler_class[j]); // null OK
	// Encode end as offset from start, and catch as offset from end,
	// because they are strongly correlated.
	sum = c.encodeBCI(c.handler_start[j]);
	code_handler_start_P.putInt(sum);
	del = c.encodeBCI(c.handler_end[j]) - sum;
	code_handler_end_PO.putInt(del);
	sum += del;
	del = c.encodeBCI(c.handler_catch[j]) - sum;
	code_handler_catch_PO.putInt(del);
	}
	}

	// Generic routines for writing attributes and flags of
	// classes, fields, methods, and codes.
	void writeAttrs(int ctype,
	final Attribute.Holder h,
	Class cls) throws IOException {
	MultiBand xxx_attr_bands = attrBands[ctype];
	IntBand xxx_flags_hi = getAttrBand(xxx_attr_bands, AB_FLAGS_HI);
	IntBand xxx_flags_lo = getAttrBand(xxx_attr_bands, AB_FLAGS_LO);
	boolean haveLongFlags = haveFlagsHi(ctype);
	assert(attrIndexLimit[ctype] == (haveLongFlags? 63: 32));
	if (h.attributes == null) {
	xxx_flags_lo.putInt(h.flags); // no extra bits to set here
	if (haveLongFlags)
	xxx_flags_hi.putInt(0);
	return;
	}
	if (verbose > 3)
	Utils.log.fine("Transmitting attrs for "+h+" flags="+Integer.toHexString(h.flags));

	long flagMask = attrFlagMask[ctype]; // which flags are attr bits?
	long flagsToAdd = 0;
	int overflowCount = 0;
	for (Attribute a : h.attributes) {
	Attribute.Layout def = a.layout();
	int index = (attrIndexTable.get(def)).intValue();
	assert(attrDefs.get(ctype).get(index) == def);
	if (verbose > 3)
	Utils.log.fine("add attr @"+index+" "+a+" in "+h);
	if (index < attrIndexLimit[ctype] && testBit(flagMask, 1L<<index)) {
	if (verbose > 3)
	Utils.log.fine("Adding flag bit 1<<"+index+" in "+Long.toHexString(flagMask));
	assert(!testBit(h.flags, 1L<<index));
	flagsToAdd \|= (1L<<index);
	flagMask -= (1L<<index); // do not use this bit twice here
	} else {
	// an overflow attr.
	flagsToAdd \|= (1L<<X_ATTR_OVERFLOW);
	overflowCount += 1;
	if (verbose > 3)
	Utils.log.fine("Adding overflow attr #"+overflowCount);
	IntBand xxx_attr_indexes = getAttrBand(xxx_attr_bands, AB_ATTR_INDEXES);
	xxx_attr_indexes.putInt(index);
	// System.out.println("overflow @"+index);
	}
	if (def.bandCount == 0) {
	if (def == attrInnerClassesEmpty) {
	// Special logic to write this attr.
	writeLocalInnerClasses((Class) h);
	continue;
	}
	// Empty attr; nothing more to write here.
	continue;
	}
	assert(a.fixups == null);
	final Band[] ab = attrBandTable.get(def);
	assert(ab != null);
	assert(ab.length == def.bandCount);
	final int[] bc = backCountTable.get(def);
	assert(bc != null);
	assert(bc.length == def.getCallables().length);
	// Write one attribute of type def into ab.
	if (verbose > 2) Utils.log.fine("writing "+a+" in "+h);
	boolean isCV = (ctype == ATTR_CONTEXT_FIELD && def == attrConstantValue);
	if (isCV) setConstantValueIndex((Class.Field)h);
	a.parse(cls, a.bytes(), 0, a.size(),
	new Attribute.ValueStream() {
	public void putInt(int bandIndex, int value) {
	((IntBand) ab[bandIndex]).putInt(value);
	}
	public void putRef(int bandIndex, Entry ref) {
	((CPRefBand) ab[bandIndex]).putRef(ref);
	}
	public int encodeBCI(int bci) {
	Code code = (Code) h;
	return code.encodeBCI(bci);
	}
	public void noteBackCall(int whichCallable) {
	assert(bc[whichCallable] >= 0);
	bc[whichCallable] += 1;
	}
	});
	if (isCV) setConstantValueIndex(null); // clean up
	}

	if (overflowCount > 0) {
	IntBand xxx_attr_count = getAttrBand(xxx_attr_bands, AB_ATTR_COUNT);
	xxx_attr_count.putInt(overflowCount);
	}

	xxx_flags_lo.putInt(h.flags \| (int)flagsToAdd);
	if (haveLongFlags)
	xxx_flags_hi.putInt((int)(flagsToAdd >>> 32));
	else
	assert((flagsToAdd >>> 32) == 0);
	assert((h.flags & flagsToAdd) == 0)
	: (h+".flags="
	+Integer.toHexString(h.flags)+"^"
	+Long.toHexString(flagsToAdd));
	}

	// temporary scratch variables for processing code blocks
	private Code curCode;
	private Class curClass;
	private Entry[] curCPMap;
	private void beginCode(Code c) {
	assert(curCode == null);
	curCode = c;
	curClass = c.m.thisClass();
	curCPMap = c.getCPMap();
	}
	private void endCode() {
	curCode = null;
	curClass = null;
	curCPMap = null;
	}

	// Return an _invokeinit_op variant, if the instruction matches one,
	// else -1.
	private int initOpVariant(Instruction i, Entry newClass) {
	if (i.getBC() != _invokespecial) return -1;
	MemberEntry ref = (MemberEntry) i.getCPRef(curCPMap);
	if ("<init>".equals(ref.descRef.nameRef.stringValue()) == false)
	return -1;
	ClassEntry refClass = ref.classRef;
	if (refClass == curClass.thisClass)
	return _invokeinit_op+_invokeinit_self_option;
	if (refClass == curClass.superClass)
	return _invokeinit_op+_invokeinit_super_option;
	if (refClass == newClass)
	return _invokeinit_op+_invokeinit_new_option;
	return -1;
	}

	// Return a _self_linker_op variant, if the instruction matches one,
	// else -1.
	private int selfOpVariant(Instruction i) {
	int bc = i.getBC();
	if (!(bc >= _first_linker_op && bc <= _last_linker_op)) return -1;
	MemberEntry ref = (MemberEntry) i.getCPRef(curCPMap);
	// do not optimize this case, simply fall back to regular coding
	if ((bc == _invokespecial \|\| bc == _invokestatic) &&
	ref.tagEquals(CONSTANT_InterfaceMethodref))
	return -1;
	ClassEntry refClass = ref.classRef;
	int self_bc = _self_linker_op + (bc - _first_linker_op);
	if (refClass == curClass.thisClass)
	return self_bc;
	if (refClass == curClass.superClass)
	return self_bc + _self_linker_super_flag;
	return -1;
	}

	void writeByteCodes(Code code) throws IOException {
	beginCode(code);
	IndexGroup cp = pkg.cp;

	// true if the previous instruction is an aload to absorb
	boolean prevAload = false;

	// class of most recent new; helps compress <init> calls
	Entry newClass = null;

	for (Instruction i = code.instructionAt(0); i != null; i = i.next()) {
	// %%% Add a stress mode which issues _ref/_byte_escape.
	if (verbose > 3) Utils.log.fine(i.toString());

	if (i.isNonstandard()) {
	// Crash and burn with a complaint if there are funny
	// bytecodes in this class file.
	String complaint = code.getMethod()
	+" contains an unrecognized bytecode "+i
	+"; please use the pass-file option on this class.";
	Utils.log.warning(complaint);
	throw new IOException(complaint);
	}

	if (i.isWide()) {
	if (verbose > 1) {
	Utils.log.fine("_wide opcode in "+code);
	Utils.log.fine(i.toString());
	}
	bc_codes.putByte(_wide);
	codeHist[_wide]++;
	}

	int bc = i.getBC();

	// Begin "bc_linker" compression.
	if (bc == _aload_0) {
	// Try to group aload_0 with a following operation.
	Instruction ni = code.instructionAt(i.getNextPC());
	if (selfOpVariant(ni) >= 0) {
	prevAload = true;
	continue;
	}
	}

	// Test for <init> invocations:
	int init_bc = initOpVariant(i, newClass);
	if (init_bc >= 0) {
	if (prevAload) {
	// get rid of it
	bc_codes.putByte(_aload_0);
	codeHist[_aload_0]++;
	prevAload = false; //used up
	}
	// Write special bytecode.
	bc_codes.putByte(init_bc);
	codeHist[init_bc]++;
	MemberEntry ref = (MemberEntry) i.getCPRef(curCPMap);
	// Write operand to a separate band.
	int coding = cp.getOverloadingIndex(ref);
	bc_initref.putInt(coding);
	continue;
	}

	int self_bc = selfOpVariant(i);
	if (self_bc >= 0) {
	boolean isField = Instruction.isFieldOp(bc);
	boolean isSuper = (self_bc >= _self_linker_op+_self_linker_super_flag);
	boolean isAload = prevAload;
	prevAload = false; //used up
	if (isAload)
	self_bc += _self_linker_aload_flag;
	// Write special bytecode.
	bc_codes.putByte(self_bc);
	codeHist[self_bc]++;
	// Write field or method ref to a separate band.
	MemberEntry ref = (MemberEntry) i.getCPRef(curCPMap);
	CPRefBand bc_which = selfOpRefBand(self_bc);
	Index which_ix = cp.getMemberIndex(ref.tag, ref.classRef);
	bc_which.putRef(ref, which_ix);
	continue;
	}
	assert(!prevAload);
	// End "bc_linker" compression.

	// Normal bytecode.
	codeHist[bc]++;
	switch (bc) {
	case _tableswitch: // apc: (df, lo, hi, (hi-lo+1)*(label))
	case _lookupswitch: // apc: (df, nc, nc*(case, label))
	bc_codes.putByte(bc);
	Instruction.Switch isw = (Instruction.Switch) i;
	// Note that we do not write the alignment bytes.
	int apc = isw.getAlignedPC();
	int npc = isw.getNextPC();
	// write a length specification into the bytecode stream
	int caseCount = isw.getCaseCount();
	bc_case_count.putInt(caseCount);
	putLabel(bc_label, code, i.getPC(), isw.getDefaultLabel());
	for (int j = 0; j < caseCount; j++) {
	putLabel(bc_label, code, i.getPC(), isw.getCaseLabel(j));
	}
	// Transmit case values in their own band.
	if (bc == _tableswitch) {
	bc_case_value.putInt(isw.getCaseValue(0));
	} else {
	for (int j = 0; j < caseCount; j++) {
	bc_case_value.putInt(isw.getCaseValue(j));
	}
	}
	// Done with the switch.
	continue;
	}

	int branch = i.getBranchLabel();
	if (branch >= 0) {
	bc_codes.putByte(bc);
	putLabel(bc_label, code, i.getPC(), branch);
	continue;
	}
	Entry ref = i.getCPRef(curCPMap);
	if (ref != null) {
	if (bc == _new) newClass = ref;
	if (bc == _ldc) ldcHist[ref.tag]++;
	CPRefBand bc_which;
	int vbc = bc;
	switch (i.getCPTag()) {
	case CONSTANT_LoadableValue:
	switch (ref.tag) {
	case CONSTANT_Integer:
	bc_which = bc_intref;
	switch (bc) {
	case _ldc: vbc = _ildc; break;
	case _ldc_w: vbc = _ildc_w; break;
	default: assert(false);
	}
	break;
	case CONSTANT_Float:
	bc_which = bc_floatref;
	switch (bc) {
	case _ldc: vbc = _fldc; break;
	case _ldc_w: vbc = _fldc_w; break;
	default: assert(false);
	}
	break;
	case CONSTANT_Long:
	bc_which = bc_longref;
	assert(bc == _ldc2_w);
	vbc = _lldc2_w;
	break;
	case CONSTANT_Double:
	bc_which = bc_doubleref;
	assert(bc == _ldc2_w);
	vbc = _dldc2_w;
	break;
	case CONSTANT_String:
	bc_which = bc_stringref;
	switch (bc) {
	case _ldc: vbc = _sldc; break;
	case _ldc_w: vbc = _sldc_w; break;
	default: assert(false);
	}
	break;
	case CONSTANT_Class:
	bc_which = bc_classref;
	switch (bc) {
	case _ldc: vbc = _cldc; break;
	case _ldc_w: vbc = _cldc_w; break;
	default: assert(false);
	}
	break;
	default:
	// CONSTANT_MethodHandle, etc.
	if (getHighestClassVersion().lessThan(JAVA7_MAX_CLASS_VERSION)) {
	throw new IOException("bad class file major version for Java 7 ldc");
	}
	bc_which = bc_loadablevalueref;
	switch (bc) {
	case _ldc: vbc = _qldc; break;
	case _ldc_w: vbc = _qldc_w; break;
	default: assert(false);
	}
	}
	break;
	case CONSTANT_Class:
	// Use a special shorthand for the current class:
	if (ref == curClass.thisClass) ref = null;
	bc_which = bc_classref; break;
	case CONSTANT_Fieldref:
	bc_which = bc_fieldref; break;
	case CONSTANT_Methodref:
	if (ref.tagEquals(CONSTANT_InterfaceMethodref)) {
	if (bc == _invokespecial)
	vbc = _invokespecial_int;
	if (bc == _invokestatic)
	vbc = _invokestatic_int;
	bc_which = bc_imethodref;
	} else {
	bc_which = bc_methodref;
	}
	break;
	case CONSTANT_InterfaceMethodref:
	bc_which = bc_imethodref; break;
	case CONSTANT_InvokeDynamic:
	bc_which = bc_indyref; break;
	default:
	bc_which = null;
	assert(false);
	}
	if (ref != null && bc_which.index != null && !bc_which.index.contains(ref)) {
	// Crash and burn with a complaint if there are funny
	// references for this bytecode instruction.
	// Example: invokestatic of a CONSTANT_InterfaceMethodref.
	String complaint = code.getMethod() +
	" contains a bytecode " + i +
	" with an unsupported constant reference; please use the pass-file option on this class.";
	Utils.log.warning(complaint);
	throw new IOException(complaint);
	}
	bc_codes.putByte(vbc);
	bc_which.putRef(ref);
	// handle trailing junk
	if (bc == _multianewarray) {
	assert(i.getConstant() == code.getByte(i.getPC()+3));
	// Just dump the byte into the bipush pile
	bc_byte.putByte(0xFF & i.getConstant());
	} else if (bc == _invokeinterface) {
	assert(i.getLength() == 5);
	// Make sure the discarded bytes are sane:
	assert(i.getConstant() == (1+((MemberEntry)ref).descRef.typeRef.computeSize(true)) << 8);
	} else if (bc == _invokedynamic) {
	if (getHighestClassVersion().lessThan(JAVA7_MAX_CLASS_VERSION)) {
	throw new IOException("bad class major version for Java 7 invokedynamic");
	}
	assert(i.getLength() == 5);
	assert(i.getConstant() == 0); // last 2 bytes MBZ
	} else {
	// Make sure there is nothing else to write.
	assert(i.getLength() == ((bc == _ldc)?2:3));
	}
	continue;
	}
	int slot = i.getLocalSlot();
	if (slot >= 0) {
	bc_codes.putByte(bc);
	bc_local.putInt(slot);
	int con = i.getConstant();
	if (bc == _iinc) {
	if (!i.isWide()) {
	bc_byte.putByte(0xFF & con);
	} else {
	bc_short.putInt(0xFFFF & con);
	}
	} else {
	assert(con == 0);
	}
	continue;
	}
	// Generic instruction. Copy the body.
	bc_codes.putByte(bc);
	int pc = i.getPC()+1;
	int npc = i.getNextPC();
	if (pc < npc) {
	// Do a few remaining multi-byte instructions.
	switch (bc) {
	case _sipush:
	bc_short.putInt(0xFFFF & i.getConstant());
	break;
	case _bipush:
	bc_byte.putByte(0xFF & i.getConstant());
	break;
	case _newarray:
	bc_byte.putByte(0xFF & i.getConstant());
	break;
	default:
	assert(false); // that's it
	}
	}
	}
	bc_codes.putByte(_end_marker);
	bc_codes.elementCountForDebug++;
	codeHist[_end_marker]++;
	endCode();
	}

	int[] codeHist = new int[1<<8];
	int[] ldcHist = new int[20];
	void printCodeHist() {
	assert(verbose > 0);
	String[] hist = new String[codeHist.length];
	int totalBytes = 0;
	for (int bc = 0; bc < codeHist.length; bc++) {
	totalBytes += codeHist[bc];
	}
	for (int bc = 0; bc < codeHist.length; bc++) {
	if (codeHist[bc] == 0) { hist[bc] = ""; continue; }
	String iname = Instruction.byteName(bc);
	String count = "" + codeHist[bc];
	count = " ".substring(count.length()) + count;
	String pct = "" + (codeHist[bc] * 10000 / totalBytes);
	while (pct.length() < 4) {
	pct = "0" + pct;
	}
	pct = pct.substring(0, pct.length()-2) + "." + pct.substring(pct.length()-2);
	hist[bc] = count + " " + pct + "% " + iname;
	}
	Arrays.sort(hist);
	System.out.println("Bytecode histogram ["+totalBytes+"]");
	for (int i = hist.length; --i >= 0; ) {
	if ("".equals(hist[i])) continue;
	System.out.println(hist[i]);
	}
	for (int tag = 0; tag < ldcHist.length; tag++) {
	int count = ldcHist[tag];
	if (count == 0) continue;
	System.out.println("ldc "+ConstantPool.tagName(tag)+" "+count);
	}
	}
	}

Back to index...