Mercurial > hg > truffle
changeset 4201:de9f8d8e4172
Merge.
| author | Thomas Wuerthinger <thomas.wuerthinger@oracle.com> |
|---|---|
| date | Tue, 03 Jan 2012 16:47:02 +0100 |
| parents | 816ac0e579fb (diff) 148fa38782e8 (current diff) |
| children | 93a99ff252d0 |
| files | |
| diffstat | 384 files changed, 14741 insertions(+), 15718 deletions(-) [+] |
line wrap: on
line diff
--- a/graal/com.oracle.max.asm/src/com/oracle/max/asm/AbstractAssembler.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.asm/src/com/oracle/max/asm/AbstractAssembler.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.asm; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiArchitecture.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiArchitecture.*; /** * The platform-independent base class for the assembler.
--- a/graal/com.oracle.max.asm/src/com/oracle/max/asm/target/amd64/AMD64.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.asm/src/com/oracle/max/asm/target/amd64/AMD64.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.asm.target.amd64; -import static com.oracle.max.cri.intrinsics.MemoryBarriers.*; -import static com.sun.cri.ci.CiKind.*; -import static com.sun.cri.ci.CiRegister.RegisterFlag.*; +import static com.oracle.max.cri.ci.CiKind.*; +import static com.oracle.max.cri.ci.CiRegister.RegisterFlag.*; +import static com.oracle.max.cri.util.MemoryBarriers.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiRegister.RegisterFlag; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiRegister.*; /** * Represents the AMD64 architecture.
--- a/graal/com.oracle.max.asm/src/com/oracle/max/asm/target/amd64/AMD64Assembler.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.asm/src/com/oracle/max/asm/target/amd64/AMD64Assembler.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,14 +22,14 @@ */ package com.oracle.max.asm.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; import static com.oracle.max.asm.NumUtil.*; import static com.oracle.max.asm.target.amd64.AMD64.*; -import static com.oracle.max.cri.intrinsics.MemoryBarriers.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.util.MemoryBarriers.*; import com.oracle.max.asm.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; /** * This class implements an assembler that can encode most X86 instructions.
--- a/graal/com.oracle.max.asm/src/com/oracle/max/asm/target/amd64/AMD64MacroAssembler.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.asm/src/com/oracle/max/asm/target/amd64/AMD64MacroAssembler.java Tue Jan 03 16:47:02 2012 +0100 @@ -23,8 +23,8 @@ package com.oracle.max.asm.target.amd64; import com.oracle.max.asm.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; /** * This class implements commonly used X86 code patterns.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiAddress.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2010, 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 com.oracle.max.cri.ci; + +import static com.oracle.max.cri.ci.CiValueUtil.*; + +/** + * Represents an address in target machine memory, specified via some combination of a base register, an index register, + * a displacement and a scale. Note that the base and index registers may be {@link CiVariable variable}, that is as yet + * unassigned to target machine registers. + */ +public final class CiAddress extends CiValue { + private static final long serialVersionUID = -1003772042519945089L; + + /** + * A sentinel value used as a place holder in an instruction stream for an address that will be patched. + */ + public static final CiAddress Placeholder = new CiAddress(CiKind.Illegal, CiValue.IllegalValue); + + /** + * Base register that defines the start of the address computation; always present. + */ + public final CiValue base; + /** + * Optional index register, the value of which (possibly scaled by {@link #scale}) is added to {@link #base}. + * If not present, is denoted by {@link CiValue#IllegalValue}. + */ + public final CiValue index; + /** + * Scaling factor for indexing, dependent on target operand size. + */ + public final Scale scale; + /** + * Optional additive displacement. + */ + public final int displacement; + + /** + * Creates a {@code CiAddress} with given base register, no scaling and no displacement. + * @param kind the kind of the value being addressed + * @param base the base register + */ + public CiAddress(CiKind kind, CiValue base) { + this(kind, base, IllegalValue, Scale.Times1, 0); + } + + /** + * Creates a {@code CiAddress} with given base register, no scaling and a given displacement. + * @param kind the kind of the value being addressed + * @param base the base register + * @param displacement the displacement + */ + public CiAddress(CiKind kind, CiValue base, int displacement) { + this(kind, base, IllegalValue, Scale.Times1, displacement); + } + + /** + * Creates a {@code CiAddress} with given base and offset registers, no scaling and no displacement. + * @param kind the kind of the value being addressed + * @param base the base register + * @param offset the offset register + */ + public CiAddress(CiKind kind, CiValue base, CiValue offset) { + this(kind, base, offset, Scale.Times1, 0); + } + + /** + * Creates a {@code CiAddress} with given base and index registers, scaling and displacement. + * This is the most general constructor.. + * @param kind the kind of the value being addressed + * @param base the base register + * @param index the index register + * @param scale the scaling factor + * @param displacement the displacement + */ + public CiAddress(CiKind kind, CiValue base, CiValue index, Scale scale, int displacement) { + super(kind); + + this.base = base; + if (isConstant(index)) { + long longIndex = ((CiConstant) index).asLong(); + long longDisp = displacement + longIndex * scale.value; + if ((int) longIndex != longIndex || (int) longDisp != longDisp) { + throw new Error("integer overflow when computing constant displacement"); + } + this.displacement = (int) longDisp; + this.index = IllegalValue; + this.scale = Scale.Times1; + } else { + assert isIllegal(base) || isVariable(base) || isRegister(base); + assert isIllegal(index) || isVariable(index) || isRegister(index); + + this.index = index; + this.scale = scale; + this.displacement = displacement; + } + } + + /** + * A scaling factor used in complex addressing modes such as those supported by x86 platforms. + */ + public enum Scale { + Times1(1, 0), + Times2(2, 1), + Times4(4, 2), + Times8(8, 3); + + Scale(int value, int log2) { + this.value = value; + this.log2 = log2; + } + + /** + * The value (or multiplier) of this scale. + */ + public final int value; + + /** + * The {@linkplain #value value} of this scale log 2. + */ + public final int log2; + + public static Scale fromInt(int scale) { + // Checkstyle: stop + switch (scale) { + case 1: return Times1; + case 2: return Times2; + case 4: return Times4; + case 8: return Times8; + default: throw new IllegalArgumentException(String.valueOf(scale)); + } + // Checkstyle: resume + } + + public static Scale fromShift(int shift) { + return fromInt(1 << shift); + } + } + + /** + * Encodes the possible addressing modes as a simple value. + */ + public enum Format { + BASE, + BASE_DISP, + BASE_INDEX, + BASE_INDEX_DISP, + PLACEHOLDER; + } + + /** + * Returns the {@link Format encoded addressing mode} that this {@code CiAddress} represents. + * @return the encoded addressing mode + */ + public Format format() { + if (this == Placeholder) { + return Format.PLACEHOLDER; + } + assert isLegal(base); + if (isLegal(index)) { + if (displacement != 0) { + return Format.BASE_INDEX_DISP; + } else { + return Format.BASE_INDEX; + } + } else { + if (displacement != 0) { + return Format.BASE_DISP; + } else { + return Format.BASE; + } + } + } + + private static String s(CiValue location) { + if (isRegister(location)) { + return asRegister(location).name; + } + assert isVariable(location); + return "v" + ((CiVariable) location).index; + } + + private static String signed(int i) { + if (i >= 0) { + return "+" + i; + } + return String.valueOf(i); + } + + @Override + public String toString() { + // Checkstyle: stop + switch (format()) { + case BASE : return "[" + s(base) + kindSuffix() + "]"; + case BASE_DISP : return "[" + s(base) + signed(displacement) + kindSuffix() + "]"; + case BASE_INDEX : return "[" + s(base) + "+" + s(index) + kindSuffix() + "]"; + case BASE_INDEX_DISP : return "[" + s(base) + "+(" + s(index) + "*" + scale.value + ")" + signed(displacement) + kindSuffix() + "]"; + case PLACEHOLDER : return "[<placeholder>]"; + default : throw new IllegalArgumentException("unknown format: " + format()); + } + // Checkstyle: resume + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof CiAddress) { + CiAddress addr = (CiAddress) obj; + return kind == addr.kind && displacement == addr.displacement && base.equals(addr.base) && scale == addr.scale && index.equals(addr.index); + } + return false; + } + + @Override + public int hashCode() { + return (base.hashCode() << 4) | kind.ordinal(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiArchitecture.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,212 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.util.*; + +import com.oracle.max.cri.ci.CiRegister.*; +import com.oracle.max.cri.util.*; + + +/** + * Represents a CPU architecture, including information such as its endianness, CPU + * registers, word width, etc. + */ +public abstract class CiArchitecture { + + /** + * The endianness of the architecture. + */ + public static enum ByteOrder { + LittleEndian, + BigEndian + } + + /** + * The number of bits required in a bit map covering all the registers that may store references. + * The bit position of a register in the map is the register's {@linkplain CiRegister#number number}. + */ + public final int registerReferenceMapBitCount; + + /** + * Represents the natural size of words (typically registers and pointers) of this architecture, in bytes. + */ + public final int wordSize; + + /** + * The name of this architecture (e.g. "AMD64", "SPARCv9"). + */ + public final String name; + + /** + * Array of all available registers on this architecture. The index of each register in this + * array is equal to its {@linkplain CiRegister#number number}. + */ + public final CiRegister[] registers; + + /** + * Map of all registers keyed by their {@linkplain CiRegister#name names}. + */ + public final HashMap<String, CiRegister> registersByName; + + /** + * The byte ordering can be either little or big endian. + */ + public final ByteOrder byteOrder; + + /** + * Mask of the barrier constants defined in {@link MemoryBarriers} denoting the barriers that + * are not required to be explicitly inserted under this architecture. + */ + public final int implicitMemoryBarriers; + + /** + * Determines the barriers in a given barrier mask that are explicitly required on this architecture. + * + * @param barriers a mask of the barrier constants defined in {@link MemoryBarriers} + * @return the value of {@code barriers} minus the barriers unnecessary on this architecture + */ + public final int requiredBarriers(int barriers) { + return barriers & ~implicitMemoryBarriers; + } + + /** + * Offset in bytes from the beginning of a call instruction to the displacement. + */ + public final int machineCodeCallDisplacementOffset; + + /** + * The size of the return address pushed to the stack by a call instruction. + * A value of 0 denotes that call linkage uses registers instead (e.g. SPARC). + */ + public final int returnAddressSize; + + private final EnumMap<RegisterFlag, CiRegister[]> registersByTypeAndEncoding; + + /** + * Gets the register for a given {@linkplain CiRegister#encoding encoding} and type. + * + * @param encoding a register value as used in a machine instruction + * @param type the type of the register + */ + public CiRegister registerFor(int encoding, RegisterFlag type) { + CiRegister[] regs = registersByTypeAndEncoding.get(type); + assert encoding >= 0 && encoding < regs.length; + CiRegister reg = regs[encoding]; + assert reg != null; + return reg; + } + + protected CiArchitecture(String name, + int wordSize, + ByteOrder byteOrder, + CiRegister[] registers, + int implicitMemoryBarriers, + int nativeCallDisplacementOffset, + int registerReferenceMapBitCount, + int returnAddressSize) { + this.name = name; + this.registers = registers; + this.wordSize = wordSize; + this.byteOrder = byteOrder; + this.implicitMemoryBarriers = implicitMemoryBarriers; + this.machineCodeCallDisplacementOffset = nativeCallDisplacementOffset; + this.registerReferenceMapBitCount = registerReferenceMapBitCount; + this.returnAddressSize = returnAddressSize; + + registersByName = new HashMap<>(registers.length); + for (CiRegister register : registers) { + registersByName.put(register.name, register); + assert registers[register.number] == register; + } + + registersByTypeAndEncoding = new EnumMap<>(RegisterFlag.class); + EnumMap<RegisterFlag, CiRegister[]> categorizedRegs = CiRegister.categorize(registers); + for (RegisterFlag type : RegisterFlag.values()) { + CiRegister[] regs = categorizedRegs.get(type); + int max = CiRegister.maxRegisterEncoding(regs); + CiRegister[] regsByEnc = new CiRegister[max + 1]; + for (CiRegister reg : regs) { + regsByEnc[reg.encoding] = reg; + } + registersByTypeAndEncoding.put(type, regsByEnc); + } + } + + /** + * Converts this architecture to a string. + * @return the string representation of this architecture + */ + @Override + public final String toString() { + return name.toLowerCase(); + } + + /** + * Checks whether this is a 32-bit architecture. + * @return {@code true} if this architecture is 32-bit + */ + public final boolean is32bit() { + return wordSize == 4; + } + + /** + * Checks whether this is a 64-bit architecture. + * @return {@code true} if this architecture is 64-bit + */ + public final boolean is64bit() { + return wordSize == 8; + } + + // The following methods are architecture specific and not dependent on state + // stored in this class. They have convenient default implementations. + + /** + * Checks whether this architecture's normal arithmetic instructions use a two-operand form + * (e.g. x86 which overwrites one operand register with the result when adding). + * @return {@code true} if this architecture uses two-operand mode + */ + public boolean twoOperandMode() { + return false; + } + + // TODO: Why enumerate the concrete subclasses here rather + // than use instanceof comparisons in code that cares? + + /** + * Checks whether the architecture is x86. + * @return {@code true} if the architecture is x86 + */ + public boolean isX86() { + return false; + } + + /** + * Checks whether the architecture is SPARC. + * @return {@code true} if the architecture is SPARC + */ + public boolean isSPARC() { + return false; + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiAssumptions.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,233 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.io.*; +import java.util.*; + +import com.oracle.max.cri.ri.*; + +/** + * Class for recording optimistic assumptions made during compilation. + * Recorded assumption can be visited for subsequent processing using + * an implementation of the {@link CiAssumptionProcessor} interface. + */ +public final class CiAssumptions implements Serializable, Iterable<CiAssumptions.Assumption> { + + /** + * + */ + private static final long serialVersionUID = 5152062717588239131L; + + public abstract static class Assumption implements Serializable { + + /** + * + */ + private static final long serialVersionUID = -1936652569665112915L; + } + + /** + * An assumption about a unique subtype of a given type. + */ + public static final class ConcreteSubtype extends Assumption { + /** + * + */ + private static final long serialVersionUID = -1457173265437676252L; + + /** + * Type the assumption is made about. + */ + public final RiResolvedType context; + + /** + * Assumed unique concrete sub-type of the context type. + */ + public final RiResolvedType subtype; + + public ConcreteSubtype(RiResolvedType context, RiResolvedType subtype) { + this.context = context; + this.subtype = subtype; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + context.hashCode(); + result = prime * result + subtype.hashCode(); + return result; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof ConcreteSubtype) { + ConcreteSubtype other = (ConcreteSubtype) obj; + return other.context == context && other.subtype == subtype; + } + return false; + } + } + + /** + * An assumption about a unique implementation of a virtual method. + */ + public static final class ConcreteMethod extends Assumption { + + /** + * + */ + private static final long serialVersionUID = -7636746737947390059L; + + /** + * A virtual (or interface) method whose unique implementation for the receiver type + * in {@link #context} is {@link #impl}. + */ + public final RiResolvedMethod method; + + /** + * A receiver type. + */ + public final RiResolvedType context; + + /** + * The unique implementation of {@link #method} for {@link #context}. + */ + public final RiResolvedMethod impl; + + public ConcreteMethod(RiResolvedMethod method, RiResolvedType context, RiResolvedMethod impl) { + this.method = method; + this.context = context; + this.impl = impl; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + method.hashCode(); + result = prime * result + context.hashCode(); + result = prime * result + impl.hashCode(); + return result; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof ConcreteMethod) { + ConcreteMethod other = (ConcreteMethod) obj; + return other.method == method && other.context == context && other.impl == impl; + } + return false; + } + } + + /** + * Array with the assumptions. This field is directly accessed from C++ code in the Graal/HotSpot implementation. + */ + private Assumption[] list; + + private int count; + + /** + * Returns whether any assumptions have been registered. + * @return {@code true} if at least one assumption has been registered, {@code false} otherwise. + */ + public boolean isEmpty() { + return count == 0; + } + + @Override + public Iterator<Assumption> iterator() { + return new Iterator<CiAssumptions.Assumption>() { + int index; + public void remove() { + throw new UnsupportedOperationException(); + } + public Assumption next() { + if (index >= count) { + throw new NoSuchElementException(); + } + return list[index++]; + } + public boolean hasNext() { + return index < count; + } + }; + } + + /** + * Records an assumption that the specified type has no finalizable subclasses. + * + * @param receiverType the type that is assumed to have no finalizable subclasses + * @return {@code true} if the assumption was recorded and can be assumed; {@code false} otherwise + */ + @SuppressWarnings("static-method") + public boolean recordNoFinalizableSubclassAssumption(RiResolvedType receiverType) { + // TODO(tw): Record that assumption correctly. + return false; + } + + /** + * Records that {@code subtype} is the only concrete subtype in the class hierarchy below {@code context}. + * @param context the root of the subtree of the class hierarchy that this assumptions is about + * @param subtype the one concrete subtype + */ + public void recordConcreteSubtype(RiResolvedType context, RiResolvedType subtype) { + record(new ConcreteSubtype(context, subtype)); + } + + /** + * Records that {@code impl} is the only possible concrete target for a virtual call to + * {@code method} with a receiver of type {@code context}. + * + * @param method a method that is the target of a virtual call + * @param context the receiver type of a call to {@code method} + * @param impl the concrete method that is the only possible target for the virtual call + */ + public void recordConcreteMethod(RiResolvedMethod method, RiResolvedType context, RiResolvedMethod impl) { + record(new ConcreteMethod(method, context, impl)); + } + + private void record(Assumption assumption) { + if (list == null) { + list = new Assumption[4]; + } else { + for (int i = 0; i < count; ++i) { + if (assumption.equals(list[i])) { + return; + } + } + } + if (list.length == count) { + Assumption[] newList = new Assumption[list.length * 2]; + for (int i = 0; i < list.length; ++i) { + newList[i] = list[i]; + } + list = newList; + } + list[count] = assumption; + count++; + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiBailout.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,62 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.util.*; + +/** + * {@code CiBailout} is thrown when the compiler refuses to compile a method because of problems with the method. + * e.g. bytecode wouldn't verify, too big, JSR/ret too complicated, etc. This exception is <i>not</i> + * meant to indicate problems with the compiler itself. + */ +public class CiBailout extends RuntimeException { + + public static final long serialVersionUID = 8974598793458772L; + + /** + * Create a new {@code CiBailout}. + * @param reason a message indicating the reason + */ + public CiBailout(String reason) { + super(reason); + } + + /** + * Create a new {@code CiBailout}. + * @param reason a message indicating the reason with a String.format - syntax + * @param args parameters to the formatter + */ + public CiBailout(String format, Object... args) { + this(String.format(Locale.ENGLISH, format, args)); + } + + /** + * Create a new {@code CiBailout} t due to an internal exception being thrown. + * @param reason a message indicating the reason + * @param cause the throwable that was the cause of the bailout + */ + public CiBailout(String reason, Throwable cause) { + super(reason); + initCause(cause); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiBitMap.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,682 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.io.*; +import java.util.*; + +/** + * Implements a bitmap that stores a single bit for a range of integers (0-n). + */ +public final class CiBitMap implements Serializable { + + private static final long serialVersionUID = 2471441272241401105L; + private static final int ADDRESS_BITS_PER_WORD = 6; + private static final int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD; + private static final int BIT_INDEX_MASK = BITS_PER_WORD - 1; + + public static final int DEFAULT_LENGTH = BITS_PER_WORD; + + public static int roundUpLength(int length) { + return ((length + (BITS_PER_WORD - 1)) >> ADDRESS_BITS_PER_WORD) << ADDRESS_BITS_PER_WORD; + } + + private int size; + private long low; + private long[] extra; + + /** + * Constructs a new bit map with the {@linkplain #DEFAULT_LENGTH default length}. + */ + public CiBitMap() { + this(DEFAULT_LENGTH); + } + + /** + * Constructs a new bit map from a byte array encoded bit map. + * + * @param bitmap the bit map to convert + */ + public CiBitMap(byte[] bitmap) { + this(bitmap, 0, bitmap.length); + } + + /** + * Constructs a copy of the given bit map. + * + * @param bitmap the bit map to copy. + */ + public CiBitMap(CiBitMap bitmap) { + this.size = bitmap.size; + this.low = bitmap.low; + if (bitmap.extra != null) { + this.extra = Arrays.copyOf(bitmap.extra, bitmap.extra.length); + } + } + + /** + * Constructs a new bit map from a byte array encoded bit map. + * + * @param arr the byte array containing the bit map to convert + * @param off the byte index in {@code arr} at which the bit map starts + * @param numberOfBytes the number of bytes worth of bits to copy from {@code arr} + */ + public CiBitMap(byte[] arr, int off, int numberOfBytes) { + this(numberOfBytes * 8); + int byteIndex = off; + int end = off + numberOfBytes; + assert end <= arr.length; + while (byteIndex < end && (byteIndex - off) < 8) { + long bite = (long) arr[byteIndex] & 0xff; + low |= bite << ((byteIndex - off) * 8); + byteIndex++; + } + if (byteIndex < end) { + assert (byteIndex - off) == 8; + int remBytes = end - byteIndex; + int remWords = (remBytes + 7) / 8; + for (int word = 0; word < remWords; word++) { + long w = 0L; + for (int i = 0; i < 8 && byteIndex < end; i++) { + long bite = (long) arr[byteIndex] & 0xff; + w |= bite << (i * 8); + byteIndex++; + } + extra[word] = w; + } + } + } + + /** + * Converts a {@code long} to a {@link CiBitMap}. + */ + public static CiBitMap fromLong(long bitmap) { + CiBitMap bm = new CiBitMap(64); + bm.low = bitmap; + return bm; + } + + /** + * Constructs a new bit map with the specified length. + * + * @param length the length of the bitmap + */ + public CiBitMap(int length) { + assert length >= 0; + this.size = length; + if (length > BITS_PER_WORD) { + extra = new long[length >> ADDRESS_BITS_PER_WORD]; + } + } + + /** + * Sets the bit at the specified index. + * + * @param i the index of the bit to set + */ + public void set(int i) { + if (checkIndex(i) < BITS_PER_WORD) { + low |= 1L << i; + } else { + int pos = wordIndex(i); + int index = bitInWord(i); + extra[pos] |= 1L << index; + } + } + + /** + * Grows this bitmap to a new size, appending necessary zero bits. + * + * @param newLength the new length of the bitmap + */ + public void grow(int newLength) { + if (newLength > size) { + // grow this bitmap to the new length + int newSize = newLength >> ADDRESS_BITS_PER_WORD; + if (newLength > 0) { + if (extra == null) { + // extra just needs to be allocated now + extra = new long[newSize]; + } else { + if (extra.length < newSize) { + // extra needs to be copied + long[] newExtra = new long[newSize]; + for (int i = 0; i < extra.length; i++) { + newExtra[i] = extra[i]; + } + extra = newExtra; + } else { + // nothing to do, extra is already the right size + } + } + } + size = newLength; + } + } + + private static int bitInWord(int i) { + return i & BIT_INDEX_MASK; + } + + private static int wordIndex(int i) { + return (i >> ADDRESS_BITS_PER_WORD) - 1; + } + + /** + * Clears the bit at the specified index. + * @param i the index of the bit to clear + */ + public void clear(int i) { + if (checkIndex(i) < BITS_PER_WORD) { + low &= ~(1L << i); + } else { + int pos = wordIndex(i); + int index = bitInWord(i); + extra[pos] &= ~(1L << index); + } + } + + /** + * Sets all the bits in this bitmap. + */ + public void setAll() { + low = -1; + if (extra != null) { + for (int i = 0; i < extra.length; i++) { + extra[i] = -1; + } + } + } + + /** + * Clears all the bits in this bitmap. + */ + public void clearAll() { + low = 0; + if (extra != null) { + for (int i = 0; i < extra.length; i++) { + extra[i] = 0; + } + } + } + + /** + * Gets the value of the bit at the specified index. + * + * @param i the index of the bit to get + * @return {@code true} if the bit at the specified position is {@code 1} + */ + public boolean get(int i) { + if (checkIndex(i) < BITS_PER_WORD) { + return ((low >> i) & 1) != 0; + } + int pos = wordIndex(i); + int index = bitInWord(i); + long bits = extra[pos]; + return ((bits >> index) & 1) != 0; + } + + /** + * Gets the value of the bit at the specified index, returning {@code false} if the + * bitmap does not cover the specified index. + * + * @param i the index of the bit to get + * @return {@code true} if the bit at the specified position is {@code 1} + */ + public boolean getDefault(int i) { + if (i < 0 || i >= size) { + return false; + } + if (i < BITS_PER_WORD) { + return ((low >> i) & 1) != 0; + } + int pos = wordIndex(i); + int index = bitInWord(i); + long bits = extra[pos]; + return ((bits >> index) & 1) != 0; + } + + /** + * Performs the union operation on this bitmap with the specified bitmap. That is, all bits set in either of the two + * bitmaps will be set in this bitmap following this operation. + * + * @param other the other bitmap for the union operation + */ + public void setUnion(CiBitMap other) { + low |= other.low; + if (extra != null && other.extra != null) { + for (int i = 0; i < extra.length && i < other.extra.length; i++) { + extra[i] |= other.extra[i]; + } + } + } + + /** + * Performs the union operation on this bitmap with the specified bitmap. That is, a bit is set in this + * bitmap if and only if it is set in both this bitmap and the specified bitmap. + * + * @param other the other bitmap for this operation + * @return {@code true} if any bits were cleared as a result of this operation + */ + public boolean setIntersect(CiBitMap other) { + boolean same = true; + long intx = low & other.low; + if (low != intx) { + same = false; + low = intx; + } + long[] oxtra = other.extra; + if (extra != null && oxtra != null) { + for (int i = 0; i < extra.length; i++) { + long a = extra[i]; + if (i < oxtra.length) { + // zero bits out of this map + long ax = a & oxtra[i]; + if (a != ax) { + same = false; + extra[i] = ax; + } + } else { + // this bitmap is larger than the specified bitmap; zero remaining bits + if (a != 0) { + same = false; + extra[i] = 0; + } + } + } + } + return !same; + } + + /** + * Gets the number of addressable bits in this bitmap. + * + * @return the size of this bitmap + */ + public int size() { + return size; + } + + private int checkIndex(int i) { + if (i < 0 || i >= size) { + throw new IndexOutOfBoundsException(); + } + return i; + } + + public void setFrom(CiBitMap other) { + assert this.size == other.size : "must have same size"; + + low = other.low; + if (extra != null) { + for (int i = 0; i < extra.length; i++) { + extra[i] = other.extra[i]; + } + } + } + + public void setDifference(CiBitMap other) { + assert this.size == other.size : "must have same size"; + + low &= ~other.low; + if (extra != null) { + for (int i = 0; i < extra.length; i++) { + extra[i] &= ~other.extra[i]; + } + } + } + + public boolean isSame(CiBitMap other) { + if (this.size != other.size || this.low != other.low) { + return false; + } + + if (extra != null) { + for (int i = 0; i < extra.length; i++) { + if (extra[i] != other.extra[i]) { + return false; + } + } + } + + return true; + } + + /** + * Returns the index of the first set bit that occurs on or after a specified start index. + * If no such bit exists then -1 is returned. + * <p> + * To iterate over the set bits in a {@code BitMap}, use the following loop: + * + * <pre> + * for (int i = bitMap.nextSetBit(0); i >= 0; i = bitMap.nextSetBit(i + 1)) { + * // operate on index i here + * } + * </pre> + * + * @param fromIndex the index to start checking from (inclusive) + * @return the index of the lowest set bit between {@code [fromIndex .. size())} or -1 if there is no set bit in this range + * @throws IndexOutOfBoundsException if the specified index is negative. + */ + public int nextSetBit(int fromIndex) { + return nextSetBit(fromIndex, size()); + } + + /** + * Returns the index of the first set bit that occurs on or after a specified start index + * and before a specified end index. If no such bit exists then -1 is returned. + * <p> + * To iterate over the set bits in a {@code BitMap}, use the following loop: + * + * <pre> + * for (int i = bitMap.nextSetBit(0, bitMap.size()); i >= 0; i = bitMap.nextSetBit(i + 1, bitMap.size())) { + * // operate on index i here + * } + * </pre> + * + * @param fromIndex the index to start checking from (inclusive) + * @param toIndex the index at which to stop checking (exclusive) + * @return the index of the lowest set bit between {@code [fromIndex .. toIndex)} or -1 if there is no set bit in this range + * @throws IndexOutOfBoundsException if the specified index is negative. + */ + public int nextSetBit(int fromIndex, int toIndex) { + assert fromIndex <= size() : "index out of bounds"; + assert toIndex <= size() : "index out of bounds"; + assert fromIndex <= toIndex : "fromIndex > toIndex"; + + if (fromIndex == toIndex) { + return -1; + } + int fromWordIndex = wordIndex(fromIndex); + int toWordIndex = wordIndex(toIndex - 1) + 1; + int resultIndex = fromIndex; + + // check bits including and to the left_ of offset's position + int pos = bitInWord(resultIndex); + long res = map(fromWordIndex) >> pos; + if (res != 0) { + resultIndex += Long.numberOfTrailingZeros(res); + assert resultIndex >= fromIndex && resultIndex < toIndex : "just checking"; + if (resultIndex < toIndex) { + return resultIndex; + } + return -1; + } + // skip over all word length 0-bit runs + for (fromWordIndex++; fromWordIndex < toWordIndex; fromWordIndex++) { + res = map(fromWordIndex); + if (res != 0) { + // found a 1, return the offset + resultIndex = bitIndex(fromWordIndex) + Long.numberOfTrailingZeros(res); + assert resultIndex >= fromIndex : "just checking"; + if (resultIndex < toIndex) { + return resultIndex; + } + return -1; + } + } + return -1; + } + + private static int bitIndex(int index) { + return (index + 1) << ADDRESS_BITS_PER_WORD; + } + + private long map(int index) { + if (index == -1) { + return low; + } + return extra[index]; + } + + private static boolean allZeros(int start, long[] arr) { + for (int i = start; i < arr.length; i++) { + if (arr[i] != 0) { + return false; + } + } + return true; + } + + /** + * Compares this object against the specified object. + * The result is {@code true} if and only if {@code obj} is + * not {@code null} and is a {@code CiBitMap} object that has + * exactly the same set of bits set to {@code true} as this bit + * set. + * + * @param obj the object to compare with. + */ + @Override + public boolean equals(Object obj) { + if (obj instanceof CiBitMap) { + CiBitMap bm = (CiBitMap) obj; + if (bm.low == low) { + if (bm.extra == null) { + if (extra == null) { + // Common case + return true; + } + return allZeros(0, extra); + } + if (extra == null) { + return allZeros(0, bm.extra); + } + // both 'extra' array non null: + int i = 0; + int length = Math.min(extra.length, bm.extra.length); + while (i < length) { + if (extra[i] != bm.extra[i]) { + return false; + } + i++; + } + if (extra.length > bm.extra.length) { + return allZeros(length, extra); + } + if (extra.length < bm.extra.length) { + return allZeros(length, bm.extra); + } + return true; + } + } + return false; + } + + @Override + public int hashCode() { + return (int) low ^ size; + } + + /** + * Returns a string representation of this bit map + * that is the same as the string returned by {@link BitSet#toString()} + * for a bit set with the same bits set as this bit map. + */ + @Override + public String toString() { + StringBuilder sb = new StringBuilder(size * 2); + sb.append('{'); + + int bit = nextSetBit(0); + if (bit != -1) { + sb.append(bit); + for (bit = nextSetBit(bit + 1); bit >= 0; bit = nextSetBit(bit + 1)) { + sb.append(", ").append(bit); + } + } + + sb.append('}'); + return sb.toString(); + } + + public static int highestOneBitIndex(long value) { + int bit = Long.numberOfTrailingZeros(Long.highestOneBit(value)); + if (bit == 64) { + return -1; + } + return bit; + } + + /** + * Returns the number of bits set to {@code true} in this bit map. + */ + public int cardinality() { + int sum = Long.bitCount(low); + if (extra != null) { + for (long word : extra) { + sum += Long.bitCount(word); + } + } + return sum; + } + + /** + * Returns the "logical size" of this bit map: the index of + * the highest set bit in the bit map plus one. Returns zero + * if the bit map contains no set bits. + * + * @return the logical size of this bit map + */ + public int length() { + if (extra != null) { + for (int i = extra.length - 1; i >= 0; i--) { + if (extra[i] != 0) { + return (highestOneBitIndex(extra[i]) + ((i + 1) * 64)) + 1; + } + } + } + return highestOneBitIndex(low) + 1; + } + + /** + * Returns a string representation of this bit map with every set bit represented as {@code '1'} + * and every unset bit represented as {@code '0'}. The first character in the returned string represents + * bit 0 in this bit map. + * + * @param length the number of bits represented in the returned string. If {@code length < 0 || length > size()}, + * then the value of {@link #length()} is used. + */ + public String toBinaryString() { + int length = length(); + if (length == 0) { + return ""; + } + StringBuilder sb = new StringBuilder(length); + for (int i = 0; i < length; ++i) { + sb.append(get(i) ? '1' : '0'); + } + return sb.toString(); + } + + static final char[] hexDigits = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' + }; + + /** + * Returns a string representation of this bit map in hex. + */ + public String toHexString() { + if (size == 0) { + return ""; + } + int hexSize = CiUtil.align(this.size, 4); + StringBuilder sb = new StringBuilder(hexSize / 4); + for (int i = 0; i < hexSize; i += 4) { + int nibble = get(i) ? 1 : 0; + if (get(i + 1)) { + nibble |= 2; + } + if (get(i + 2)) { + nibble |= 4; + } + if (get(i + 3)) { + nibble |= 8; + } + + sb.append(hexDigits[nibble]); + } + return sb.toString(); + } + + public CiBitMap copy() { + CiBitMap n = new CiBitMap(BITS_PER_WORD); + n.low = low; + if (extra != null) { + n.extra = Arrays.copyOf(extra, extra.length); + } + n.size = size; + return n; + } + + /** + * Copies this bit map into a given byte array. + * + * @param arr the destination + * @param off the byte index in {@code arr} at which to start writing + * @param numberOfBytes the number of bytes worth of bits to copy from this bit map. + * The number of bits copied is {@code numberOfBytes * 8}. If {@code numberOfBytes} + * is -1, then {@code ((size() + 7) / 8)} is used instead. + * @return the number of bytes written to {@code arr} + */ + public int copyTo(byte[] arr, int off, int numberOfBytes) { + for (int i = 0; i < numberOfBytes; ++i) { + long word = low; + int byteInWord; + if (i >= 8) { + int wordIndex = (i - 8) / 8; + word = extra[wordIndex]; + byteInWord = i & 0x7; + } else { + byteInWord = i; + } + assert byteInWord < 8; + byte b = (byte) (word >> (byteInWord * 8)); + arr[off + i] = b; + } + return numberOfBytes; + } + + /** + * Converts this bit map to a byte array. The length of the returned + * byte array is {@code ((size() + 7) / 8)}. + */ + public byte[] toByteArray() { + byte[] arr = new byte[(size + 7) / 8]; + copyTo(arr, 0, arr.length); + return arr; + } + + /** + * Converts this bit map to a long. + * + * @throws IllegalArgumentException if {@code (size() > 64)} + */ + public long toLong() { + if (size > 64) { + throw new IllegalArgumentException("bit map of size " + size + " cannot be converted to long"); + } + return low; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiCalleeSaveLayout.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,178 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.util.*; + + +/** + * The callee save area (CSA) is a contiguous space in a stack frame + * used to save (and restore) the values of the caller's registers. + * This class describes the layout of a CSA in terms of its + * {@linkplain #size size}, {@linkplain #slotSize slot size} and + * the {@linkplain #registers callee save registers} covered by the CSA. + */ +public class CiCalleeSaveLayout { + + /** + * The size (in bytes) of the CSA. + */ + public final int size; + + /** + * The size (in bytes) of an {@linkplain #registerAtIndex(int) indexable} slot in the CSA. + */ + public final int slotSize; + + /** + * Map from {@linkplain CiRegister#number register numbers} to slot indexes in the CSA. + */ + private final int[] regNumToIndex; + + private final CiRegister[] indexToReg; + + /** + * The list of registers {@linkplain #contains(CiRegister) contained} by this CSA. + */ + public final CiRegister[] registers; + + /** + * The offset from the frame pointer to the CSA. If this is not known, then this field + * will have the value {@link Integer#MAX_VALUE}. + */ + public final int frameOffsetToCSA; + + /** + * Creates a CSA layout. + * + * @param size size (in bytes) of the CSA. If this is {@code -1}, then the CSA size will be computed from {@code registers}. + * @param slotSize the size (in bytes) of an {@linkplain #registerAtIndex(int) indexable} slot in the CSA + * @param registers the registers that can be saved in the CSA + */ + public CiCalleeSaveLayout(int frameOffsetToCSA, int size, int slotSize, CiRegister... registers) { + this.frameOffsetToCSA = frameOffsetToCSA; + assert slotSize == 0 || CiUtil.isPowerOf2(slotSize); + this.slotSize = slotSize; + int maxRegNum = -1; + int maxOffset = 0; + this.registers = registers; + int offset = 0; + for (CiRegister reg : registers) { + assert offset % slotSize == 0; + assert reg.number >= 0; + if (reg.number > maxRegNum) { + maxRegNum = reg.number; + } + if (offset > maxOffset) { + maxOffset = offset; + } + offset += reg.spillSlotSize; + } + if (size == -1) { + this.size = offset; + } else { + assert offset <= size; + this.size = size; + } + + this.regNumToIndex = new int[maxRegNum + 1]; + this.indexToReg = offset == 0 ? new CiRegister[0] : new CiRegister[offset / slotSize]; + Arrays.fill(regNumToIndex, -1); + offset = 0; + for (CiRegister reg : registers) { + int index = offset / slotSize; + regNumToIndex[reg.number] = index; + indexToReg[index] = reg; + offset += reg.spillSlotSize; + } + } + + /** + * Gets the offset of a given register in the CSA. + * + * @return the offset (in bytes) of {@code reg} in the CSA + * @throws IllegalArgumentException if {@code reg} does not have a slot in the CSA + */ + public int offsetOf(int reg) { + return indexOf(reg) * slotSize; + } + + /** + * Gets the index of a given register in the CSA. + * + * @return the index of {@code reg} in the CSA + * @throws IllegalArgumentException if {@code reg} does not have a slot in the CSA + */ + public int indexOf(int reg) { + if (!contains(reg)) { + throw new IllegalArgumentException(String.valueOf(reg)); + } + return regNumToIndex[reg]; + } + + /** + * Gets the offset of a given register in the CSA. + * + * @return the offset (in bytes) of {@code reg} in the CSA + * @throws IllegalArgumentException if {@code reg} does not have a slot in the CSA + */ + public int offsetOf(CiRegister reg) { + return offsetOf(reg.number); + } + + /** + * Determines if the CSA includes a slot for a given register. + * + * @param reg the register to test + * @return true if the CSA contains a slot for {@code reg} + */ + public boolean contains(int reg) { + return reg >= 0 && reg < regNumToIndex.length && regNumToIndex[reg] != -1; + } + + /** + * Gets the register whose slot in the CSA is at a given index. + * + * @param index an index of a slot in the CSA + * @return the register whose slot in the CSA is at {@code index} or {@code null} if {@code index} does not denote a + * slot in the CSA aligned with a register + */ + public CiRegister registerAt(int index) { + if (index < 0 || index >= indexToReg.length) { + return null; + } + return indexToReg[index]; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("["); + for (CiRegister reg : registers) { + if (sb.length() != 1) { + sb.append(", "); + } + sb.append(reg).append("{+").append(offsetOf(reg)).append('}'); + } + return sb.append("] size=").append(size).toString(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiCallingConvention.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,107 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import static com.oracle.max.cri.ci.CiValueUtil.*; + +import com.oracle.max.cri.ri.*; + + +/** + * A calling convention describes the locations in which the arguments for a call are placed. + */ +public class CiCallingConvention { + + /** + * Constants denoting the type of a call for which a calling convention is + * {@linkplain RiRegisterConfig#getCallingConvention(Type, CiKind[], CiTarget, boolean) requested}. + */ + public enum Type { + /** + * A request for the outgoing argument locations at a call site to Java code. + */ + JavaCall(true), + + /** + * A request for the incoming argument locations. + */ + JavaCallee(false), + + /** + * A request for the outgoing argument locations at a call site to the runtime (which may be Java or native code). + */ + RuntimeCall(true), + + /** + * A request for the outgoing argument locations at a call site to + * external native code that complies with the platform ABI. + */ + NativeCall(true); + + /** + * Determines if this is a request for the outgoing argument locations at a call site. + */ + public final boolean out; + + public static final Type[] VALUES = values(); + + private Type(boolean out) { + this.out = out; + } + } + + /** + * The amount of stack space (in bytes) required for the stack-based arguments of the call. + */ + public final int stackSize; + + /** + * The locations in which the arguments are placed. This array ordered by argument index. + */ + public final CiValue[] locations; + + public CiCallingConvention(CiValue[] locations, int stackSize) { + this.locations = locations; + this.stackSize = stackSize; + assert verify(); + } + + @Override + public String toString() { + StringBuilder result = new StringBuilder(); + result.append("CallingConvention["); + for (CiValue op : locations) { + result.append(op.toString()).append(" "); + } + result.append("]"); + return result.toString(); + } + + private boolean verify() { + for (int i = 0; i < locations.length; i++) { + CiValue location = locations[i]; + assert isStackSlot(location) || isRegister(location); + } + return true; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiCodePos.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,105 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.io.*; + +import com.oracle.max.cri.ri.*; + +/** + * Represents a code position, that is, a chain of inlined methods with bytecode + * locations, that is communicated from the compiler to the runtime system. A code position + * can be used by the runtime system to reconstruct a source-level stack trace + * for exceptions and to create {@linkplain CiFrame frames} for deoptimization. + */ +public class CiCodePos implements Serializable { + /** + * + */ + private static final long serialVersionUID = 8633885274526033515L; + + /** + * The position where this position has been called, {@code null} if none. + */ + public final CiCodePos caller; + + /** + * The runtime interface method for this position. + */ + public final RiResolvedMethod method; + + /** + * The location within the method, as a bytecode index. The constant + * {@code -1} may be used to indicate the location is unknown, for example + * within code synthesized by the compiler. + */ + public final int bci; + + /** + * Constructs a new object representing a given parent/caller, a given method, and a given BCI. + * + * @param caller the parent position + * @param method the method + * @param bci a BCI within the method + */ + public CiCodePos(CiCodePos caller, RiResolvedMethod method, int bci) { + assert method != null; + this.caller = caller; + this.method = method; + this.bci = bci; + } + + /** + * Converts this code position to a string representation. + * @return a string representation of this code position + */ + @Override + public String toString() { + return CiUtil.append(new StringBuilder(100), this).toString(); + } + + /** + * Deep equality test. + */ + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CiCodePos) { + CiCodePos other = (CiCodePos) obj; + if (other.method.equals(method) && other.bci == bci) { + if (caller == null) { + return other.caller == null; + } + return caller.equals(other.caller); + } + } + return false; + } + + @Override + public int hashCode() { + return bci; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiCompiler.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,59 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import com.oracle.max.cri.ri.*; + +public interface CiCompiler { + + /** + * Denotes the level of debug info for safepoints that should be generated by a compilation. + */ + enum DebugInfoLevel { + /** + * Only ref maps are required. + */ + REF_MAPS, + + /** + * Code positions and ref maps are required. + */ + CODE_POS_AND_REF_MAPS, + + /** + * Frame info, code positions and ref maps are required. + * Only a compilation with level can make speculative optimizations. + */ + FULL + } + + /** + * Compile the specified method. + * + * @param method the method to compile + * @param osrBCI the bytecode index of the entrypoint for an on-stack-replacement or {@code -1} if this is not an + * on-stack-replacement compilation + * @param debugInfoLevel TODO + */ + CiResult compileMethod(RiResolvedMethod method, int osrBCI, CiStatistics stats, DebugInfoLevel debugInfoLevel); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiConstant.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,496 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +/** + * Represents a constant (boxed) value, such as an integer, floating point number, or object reference, + * within the compiler and across the compiler/runtime interface. Exports a set of {@code CiConstant} + * instances that represent frequently used constant values, such as {@link #ZERO}. + */ +public final class CiConstant extends CiValue { + private static final long serialVersionUID = -6355452536852663986L; + + private static final CiConstant[] INT_CONSTANT_CACHE = new CiConstant[100]; + static { + for (int i = 0; i < INT_CONSTANT_CACHE.length; ++i) { + INT_CONSTANT_CACHE[i] = new CiConstant(CiKind.Int, i); + } + } + + public static final CiConstant NULL_OBJECT = new CiConstant(CiKind.Object, null); + public static final CiConstant INT_MINUS_1 = new CiConstant(CiKind.Int, -1); + public static final CiConstant INT_0 = forInt(0); + public static final CiConstant INT_1 = forInt(1); + public static final CiConstant INT_2 = forInt(2); + public static final CiConstant INT_3 = forInt(3); + public static final CiConstant INT_4 = forInt(4); + public static final CiConstant INT_5 = forInt(5); + public static final CiConstant LONG_0 = new CiConstant(CiKind.Long, 0L); + public static final CiConstant LONG_1 = new CiConstant(CiKind.Long, 1L); + public static final CiConstant FLOAT_0 = new CiConstant(CiKind.Float, Float.floatToRawIntBits(0.0F)); + public static final CiConstant FLOAT_1 = new CiConstant(CiKind.Float, Float.floatToRawIntBits(1.0F)); + public static final CiConstant FLOAT_2 = new CiConstant(CiKind.Float, Float.floatToRawIntBits(2.0F)); + public static final CiConstant DOUBLE_0 = new CiConstant(CiKind.Double, Double.doubleToRawLongBits(0.0D)); + public static final CiConstant DOUBLE_1 = new CiConstant(CiKind.Double, Double.doubleToRawLongBits(1.0D)); + public static final CiConstant TRUE = new CiConstant(CiKind.Boolean, 1L); + public static final CiConstant FALSE = new CiConstant(CiKind.Boolean, 0L); + + static { + assert NULL_OBJECT.isDefaultValue(); + assert INT_0.isDefaultValue(); + assert FLOAT_0.isDefaultValue(); + assert DOUBLE_0.isDefaultValue(); + assert FALSE.isDefaultValue(); + + // Ensure difference between 0.0f and -0.0f is preserved + assert FLOAT_0 != forFloat(-0.0F); + assert !forFloat(-0.0F).isDefaultValue(); + + // Ensure difference between 0.0d and -0.0d is preserved + assert DOUBLE_0 != forDouble(-0.0d); + assert !forDouble(-0.0D).isDefaultValue(); + + assert NULL_OBJECT.isNull(); + } + + /** + * The boxed object value. This is ignored iff {@code !kind.isObject()}. + */ + private final Object object; + + /** + * The boxed primitive value as a {@code long}. This is ignored iff {@code kind.isObject()}. + * For {@code float} and {@code double} values, this value is the result of + * {@link Float#floatToRawIntBits(float)} and {@link Double#doubleToRawLongBits(double)} respectively. + */ + private final long primitive; + + /** + * Create a new constant represented by the specified object reference. + * + * @param kind the type of this constant + * @param object the value of this constant + */ + private CiConstant(CiKind kind, Object object) { + super(kind); + this.object = object; + this.primitive = 0L; + } + + /** + * Create a new constant represented by the specified primitive. + * + * @param kind the type of this constant + * @param primitive the value of this constant + */ + public CiConstant(CiKind kind, long primitive) { + super(kind); + this.object = null; + this.primitive = primitive; + } + + /** + * Checks whether this constant is non-null. + * @return {@code true} if this constant is a primitive, or an object constant that is not null + */ + public boolean isNonNull() { + return !kind.isObject() || object != null; + } + + /** + * Checks whether this constant is null. + * @return {@code true} if this constant is the null constant + */ + public boolean isNull() { + return kind.isObject() && object == null; + } + + @Override + public String toString() { + return kind.javaName + "[" + kind.format(boxedValue()) + (kind != CiKind.Object ? "|0x" + Long.toHexString(primitive) : "") + "]"; + } + + /** + * Gets this constant's value as a string. + * + * @return this constant's value as a string + */ + public String valueString() { + if (kind.isPrimitive()) { + return boxedValue().toString(); + } else if (kind.isObject()) { + if (object == null) { + return "null"; + } else if (object instanceof String) { + return "\"" + object + "\""; + } else { + return "<object: " + kind.format(object) + ">"; + } + } else if (kind.isJsr()) { + return "bci:" + boxedValue().toString(); + } else { + return "???"; + } + } + + /** + * Returns the value of this constant as a boxed Java value. + * @return the value of this constant + */ + public Object boxedValue() { + // Checkstyle: stop + switch (kind) { + case Byte: return (byte) asInt(); + case Boolean: return asInt() == 0 ? Boolean.FALSE : Boolean.TRUE; + case Short: return (short) asInt(); + case Char: return (char) asInt(); + case Jsr: return (int) primitive; + case Int: return asInt(); + case Long: return asLong(); + case Float: return asFloat(); + case Double: return asDouble(); + case Object: return object; + } + // Checkstyle: resume + throw new IllegalArgumentException(); + } + + private boolean valueEqual(CiConstant other, boolean ignoreKind) { + // must have equivalent kinds to be equal + if (!ignoreKind && kind != other.kind) { + return false; + } + if (kind.isObject()) { + return object == other.object; + } + return primitive == other.primitive; + } + + /** + * Converts this constant to a primitive int. + * @return the int value of this constant + */ + public int asInt() { + if (kind.stackKind().isInt() || kind.isJsr()) { + return (int) primitive; + } + throw new Error("Constant is not int: " + this); + } + + /** + * Converts this constant to a primitive boolean. + * @return the boolean value of this constant + */ + public boolean asBoolean() { + if (kind == CiKind.Boolean) { + return primitive != 0L; + } + throw new Error("Constant is not boolean: " + this); + } + + /** + * Converts this constant to a primitive long. + * @return the long value of this constant + */ + public long asLong() { + // Checkstyle: stop + switch (kind.stackKind()) { + case Jsr: + case Int: + case Long: return primitive; + case Float: return (long) asFloat(); + case Double: return (long) asDouble(); + default: throw new Error("Constant is not long: " + this); + } + // Checkstyle: resume + } + + /** + * Converts this constant to a primitive float. + * @return the float value of this constant + */ + public float asFloat() { + if (kind.isFloat()) { + return Float.intBitsToFloat((int) primitive); + } + throw new Error("Constant is not float: " + this); + } + + /** + * Converts this constant to a primitive double. + * @return the double value of this constant + */ + public double asDouble() { + if (kind.isFloat()) { + return Float.intBitsToFloat((int) primitive); + } + if (kind.isDouble()) { + return Double.longBitsToDouble(primitive); + } + throw new Error("Constant is not double: " + this); + } + + /** + * Converts this constant to the object reference it represents. + * @return the object which this constant represents + */ + public Object asObject() { + if (kind.isObject()) { + return object; + } + throw new Error("Constant is not object: " + this); + } + + /** + * Converts this constant to the jsr reference it represents. + * @return the object which this constant represents + */ + public int asJsr() { + if (kind.isJsr()) { + return (int) primitive; + } + throw new Error("Constant is not jsr: " + this); + } + + /** + * Unchecked access to a primitive value. + * @return + */ + public long asPrimitive() { + if (kind.isObject()) { + throw new Error("Constant is not primitive: " + this); + } + return primitive; + } + + /** + * Computes the hashcode of this constant. + * @return a suitable hashcode for this constant + */ + @Override + public int hashCode() { + if (kind.isObject()) { + return System.identityHashCode(object); + } + return (int) primitive; + } + + /** + * Checks whether this constant equals another object. This is only + * true if the other object is a constant and has the same value. + * @param o the object to compare equality + * @return {@code true} if this constant is equivalent to the specified object + */ + @Override + public boolean equals(Object o) { + return o == this || o instanceof CiConstant && valueEqual((CiConstant) o, false); + } + + /** + * Checks whether this constant is identical to another constant or has the same value as it. + * @param other the constant to compare for equality against this constant + * @return {@code true} if this constant is equivalent to {@code other} + */ + public boolean equivalent(CiConstant other) { + return other == this || valueEqual(other, false); + } + + /** + * Checks whether this constant is the default value for its type. + * @return {@code true} if the value is the default value for its type; {@code false} otherwise + */ + public boolean isDefaultValue() { + // Checkstyle: stop + switch (kind.stackKind()) { + case Int: return asInt() == 0; + case Long: return asLong() == 0; + case Float: return this == FLOAT_0; + case Double: return this == DOUBLE_0; + case Object: return object == null; + } + // Checkstyle: resume + throw new IllegalArgumentException("Cannot det default CiConstant for kind " + kind); + } + + /** + * Gets the default value for a given kind. + * + * @return the default value for {@code kind}'s {@linkplain CiKind#stackKind() stack kind} + */ + public static CiConstant defaultValue(CiKind kind) { + // Checkstyle: stop + switch (kind.stackKind()) { + case Int: return INT_0; + case Long: return LONG_0; + case Float: return FLOAT_0; + case Double: return DOUBLE_0; + case Object: return NULL_OBJECT; + } + // Checkstyle: resume + throw new IllegalArgumentException("Cannot get default CiConstant for kind " + kind); + } + + /** + * Creates a boxed double constant. + * @param d the double value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forDouble(double d) { + if (Double.compare(0.0D, d) == 0) { + return DOUBLE_0; + } + if (Double.compare(d, 1.0D) == 0) { + return DOUBLE_1; + } + return new CiConstant(CiKind.Double, Double.doubleToRawLongBits(d)); + } + + /** + * Creates a boxed float constant. + * @param f the float value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forFloat(float f) { + if (Float.compare(f, 0.0F) == 0) { + return FLOAT_0; + } + if (Float.compare(f, 1.0F) == 0) { + return FLOAT_1; + } + if (Float.compare(f, 2.0F) == 0) { + return FLOAT_2; + } + return new CiConstant(CiKind.Float, Float.floatToRawIntBits(f)); + } + + /** + * Creates a boxed long constant. + * @param i the long value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forLong(long i) { + return i == 0 ? LONG_0 : i == 1 ? LONG_1 : new CiConstant(CiKind.Long, i); + } + + /** + * Creates a boxed integer constant. + * @param i the integer value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forInt(int i) { + if (i == -1) { + return INT_MINUS_1; + } + if (i >= 0 && i < INT_CONSTANT_CACHE.length) { + return INT_CONSTANT_CACHE[i]; + } + return new CiConstant(CiKind.Int, i); + } + + /** + * Creates a boxed byte constant. + * @param i the byte value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forByte(byte i) { + return new CiConstant(CiKind.Byte, i); + } + + /** + * Creates a boxed boolean constant. + * @param i the boolean value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forBoolean(boolean i) { + return i ? TRUE : FALSE; + } + + /** + * Creates a boxed char constant. + * @param i the char value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forChar(char i) { + return new CiConstant(CiKind.Char, i); + } + + /** + * Creates a boxed short constant. + * @param i the short value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forShort(short i) { + return new CiConstant(CiKind.Short, i); + } + + /** + * Creates a boxed address (jsr/ret address) constant. + * @param i the address value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forJsr(int i) { + return new CiConstant(CiKind.Jsr, i); + } + + /** + * Creates a boxed object constant. + * @param o the object value to box + * @return a boxed copy of {@code value} + */ + public static CiConstant forObject(Object o) { + if (o == null) { + return NULL_OBJECT; + } + return new CiConstant(CiKind.Object, o); + } + + /** + * Creates a boxed constant for the given kind from an Object. + * The object needs to be of the Java boxed type corresponding to the kind. + * @param kind the kind of the constant to create + * @param value the Java boxed value: a Byte instance for CiKind Byte, etc. + * @return the boxed copy of {@code value} + */ + public static CiConstant forBoxed(CiKind kind, Object value) { + switch (kind) { + case Byte: + return forByte((Byte) value); + case Char: + return forChar((Character) value); + case Short: + return forShort((Short) value); + case Int: + return forInt((Integer) value); + case Long: + return forLong((Long) value); + case Float: + return forFloat((Float) value); + case Double: + return forDouble((Double) value); + case Object: + return forObject(value); + default: + throw new RuntimeException("cannot create CiConstant for boxed " + kind + " value"); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiDebugInfo.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,108 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.io.*; + +/** + * Represents the debugging information for a particular place in the code, + * which includes the code position, a reference map, and deoptimization information. + */ +public class CiDebugInfo implements Serializable { + + /** + * + */ + private static final long serialVersionUID = -6047206624915812516L; + + /** + * The code position (including all inlined methods) of this debug info. + * If this is a {@link CiFrame} instance, then it is also the deoptimization information for each inlined frame. + */ + public final CiCodePos codePos; + + /** + * The reference map for the registers at this point. The reference map is <i>packed</i> in that + * for bit {@code k} in byte {@code n}, it refers to the register whose + * {@linkplain CiRegister#number number} is {@code (k + n * 8)}. + */ + public final CiBitMap registerRefMap; + + /** + * The reference map for the stack frame at this point. A set bit at {@code k} in the map + * represents stack slot number {@code k}. + */ + public final CiBitMap frameRefMap; + + /** + * Creates a new {@code CiDebugInfo} from the given values. + * + * @param codePos the {@linkplain CiCodePos code position} or {@linkplain CiFrame frame} info + * @param registerRefMap the register map + * @param frameRefMap the reference map for {@code frame}, which may be {@code null} + */ + public CiDebugInfo(CiCodePos codePos, CiBitMap registerRefMap, CiBitMap frameRefMap) { + this.codePos = codePos; + this.registerRefMap = registerRefMap; + this.frameRefMap = frameRefMap; + } + + /** + * @return {@code true} if this debug information has a frame + */ + public boolean hasFrame() { + return codePos instanceof CiFrame; + } + + /** + * @return {@code true} if this debug info has a reference map for the registers + */ + public boolean hasRegisterRefMap() { + return registerRefMap != null && registerRefMap.size() > 0; + } + + /** + * @return {@code true} if this debug info has a reference map for the stack + */ + public boolean hasStackRefMap() { + return frameRefMap != null && frameRefMap.size() > 0; + } + + + /** + * Gets the deoptimization information for each inlined frame (if available). + * + * @return {@code null} if no frame de-opt info is {@linkplain #hasDebugFrame available} + */ + public CiFrame frame() { + if (hasFrame()) { + return (CiFrame) codePos; + } + return null; + } + + @Override + public String toString() { + return CiUtil.append(new StringBuilder(100), this, null).toString(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiExceptionHandler.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,93 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import com.oracle.max.cri.ri.*; + +/** + * An implementation of the {@link RiExceptionHandler} interface. + */ +public class CiExceptionHandler implements RiExceptionHandler { + + public static final CiExceptionHandler[] NONE = {}; + + public final int startBCI; + public final int endBCI; + public final int handlerBCI; + public final int catchTypeCPI; + public final RiType catchType; + + /** + * Creates a new exception handler with the specified ranges. + * @param startBCI the start index of the protected range + * @param endBCI the end index of the protected range + * @param catchBCI the index of the handler + * @param catchTypeCPI the index of the throwable class in the constant pool + * @param catchType the type caught by this exception handler + */ + public CiExceptionHandler(int startBCI, int endBCI, int catchBCI, int catchTypeCPI, RiType catchType) { + this.startBCI = startBCI; + this.endBCI = endBCI; + this.handlerBCI = catchBCI; + this.catchTypeCPI = catchTypeCPI; + this.catchType = catchType; + } + + public int startBCI() { + return startBCI; + } + + public int endBCI() { + return endBCI; + } + + public int handlerBCI() { + return handlerBCI; + } + + public int catchTypeCPI() { + return catchTypeCPI; + } + + public boolean isCatchAll() { + return catchTypeCPI == 0; + } + + public RiType catchType() { + return catchType; + } + + @Override + public String toString() { + return new StringBuilder(20). + append('['). + append(startBCI). + append(" - "). + append(endBCI). + append(") -> "). + append(handlerBCI). + append(" type="). + append(catchType == null ? "*any*" : catchType.name()). + toString(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiFrame.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,133 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.io.*; + +import com.oracle.max.cri.ri.*; + +/** + * Represents the Java bytecode frame state(s) at a given position + * including {@link CiValue locations} where to find the local variables, + * operand stack values and locked objects of the bytecode frame(s). + */ +public class CiFrame extends CiCodePos implements Serializable { + private static final long serialVersionUID = -345025397165977565L; + + /** + * An array of values representing how to reconstruct the state of the Java frame. + * This is array is partitioned as follows: + * <p> + * <table border="1" cellpadding="5" frame="void", rules="all"> + * <tr><th>Start index (inclusive)</th><th>End index (exclusive)</th><th>Description</th></tr> + * <tr><td>0</td> <td>numLocals</td> <td>Local variables</td></tr> + * <tr><td>numLocals</td> <td>numLocals + numStack</td><td>Operand stack</td></tr> + * <tr><td>numLocals + numStack</td><td>values.length</td> <td>Locked objects</td></tr> + * </table> + * <p> + * Note that the number of locals and the number of stack slots may be smaller than the + * maximum number of locals and stack slots as specified in the compiled method. + */ + public final CiValue[] values; + + /** + * The number of locals in the values array. + */ + public final int numLocals; + + /** + * The number of stack slots in the values array. + */ + public final int numStack; + + /** + * The number of locks in the values array. + */ + public final int numLocks; + + public final boolean rethrowException; + + /** + * Creates a new frame object. + * + * @param caller the caller frame (which may be {@code null}) + * @param method the method + * @param bci a BCI within the method + * @param rethrowException specifies if the VM should re-throw the pending exception when deopt'ing using this frame + * @param values the frame state {@link #values} + * @param numLocals the number of local variables + * @param numStack the depth of the stack + * @param numLocks the number of locked objects + */ + public CiFrame(CiFrame caller, RiResolvedMethod method, int bci, boolean rethrowException, CiValue[] values, int numLocals, int numStack, int numLocks) { + super(caller, method, bci); + assert values != null; + this.rethrowException = rethrowException; + this.values = values; + this.numLocks = numLocks; + this.numLocals = numLocals; + this.numStack = numStack; + assert !rethrowException || numStack == 1 : "must have exception on top of the stack"; + } + + /** + * Gets the value representing the specified local variable. + * @param i the local variable index + * @return the value that can be used to reconstruct the local's current value + */ + public CiValue getLocalValue(int i) { + return values[i]; + } + + /** + * Gets the value representing the specified stack slot. + * @param i the stack index + * @return the value that can be used to reconstruct the stack slot's current value + */ + public CiValue getStackValue(int i) { + return values[i + numLocals]; + } + + /** + * Gets the value representing the specified lock. + * @param i the lock index + * @return the value that can be used to reconstruct the lock's current value + */ + public CiValue getLockValue(int i) { + return values[i + numLocals + numStack]; + } + + /** + * Gets the caller of this frame. + * + * @return {@code null} if this frame has no caller + */ + public CiFrame caller() { + return (CiFrame) caller; + } + + @Override + public String toString() { + return CiUtil.append(new StringBuilder(100), this).toString(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiGenericCallback.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,41 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +/** + * This interface is used for {@link CiRuntimeCall#GenericCallback} runtime calls. + */ +public abstract class CiGenericCallback { + + @SuppressWarnings("unused") + private Object callbackInternal(Object arg) { + try { + return callback(arg); + } catch (Throwable t) { + t.printStackTrace(); + return null; + } + } + + public abstract Object callback(Object arg); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiKind.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,340 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import static com.oracle.max.cri.ci.CiKind.Flags.*; +import sun.misc.*; + +import com.oracle.max.cri.ri.*; + +/** + * Denotes the basic kinds of types in CRI, including the all the Java primitive types, + * for example, {@link CiKind#Int} for {@code int} and {@link CiKind#Object} + * for all object types. + * A kind has a single character short name, a Java name, and a set of flags + * further describing its behavior. + */ +public enum CiKind { + Boolean('z', "boolean", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), + Byte ('b', "byte", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), + Short ('s', "short", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), + Char ('c', "char", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), + Int ('i', "int", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), + Float ('f', "float", FIELD_TYPE | RETURN_TYPE | PRIMITIVE), + Long ('j', "long", FIELD_TYPE | RETURN_TYPE | PRIMITIVE), + Double ('d', "double", FIELD_TYPE | RETURN_TYPE | PRIMITIVE), + Object ('a', "Object", FIELD_TYPE | RETURN_TYPE), + Void ('v', "void", RETURN_TYPE), + /** Denote a bytecode address in a {@code JSR} bytecode. */ + Jsr ('r', "jsr", 0), + /** The non-type. */ + Illegal('-', "illegal", 0); + + public static final CiKind[] VALUES = values(); + public static final CiKind[] JAVA_VALUES = new CiKind[] {CiKind.Boolean, CiKind.Byte, CiKind.Short, CiKind.Char, CiKind.Int, CiKind.Float, CiKind.Long, CiKind.Double, CiKind.Object}; + + CiKind(char ch, String name, int flags) { + this.typeChar = ch; + this.javaName = name; + this.flags = flags; + } + + static class Flags { + /** + * Can be an object field type. + */ + public static final int FIELD_TYPE = 0x0001; + /** + * Can be result type of a method. + */ + public static final int RETURN_TYPE = 0x0002; + /** + * Behaves as an integer when on Java evaluation stack. + */ + public static final int STACK_INT = 0x0004; + /** + * Represents a Java primitive type. + */ + public static final int PRIMITIVE = 0x0008; + } + + /** + * The flags for this kind. + */ + private final int flags; + + /** + * The name of the kind as a single character. + */ + public final char typeChar; + + /** + * The name of this kind which will also be it Java programming language name if + * it is {@linkplain #isPrimitive() primitive} or {@code void}. + */ + public final String javaName; + + /** + * Checks whether this kind is valid as the type of a field. + * @return {@code true} if this kind is valid as the type of a Java field + */ + public boolean isValidFieldType() { + return (flags & FIELD_TYPE) != 0; + } + + /** + * Checks whether this kind is valid as the return type of a method. + * @return {@code true} if this kind is valid as the return type of a Java method + */ + public boolean isValidReturnType() { + return (flags & RETURN_TYPE) != 0; + } + + /** + * Checks whether this type is valid as an {@code int} on the Java operand stack. + * @return {@code true} if this type is represented by an {@code int} on the operand stack + */ + public boolean isInt() { + return (flags & STACK_INT) != 0; + } + + /** + * Checks whether this type is a Java primitive type. + * @return {@code true} if this is {@link #Boolean}, {@link #Byte}, {@link #Char}, {@link #Short}, + * {@link #Int}, {@link #Long}, {@link #Float} or {@link #Double}. + */ + public boolean isPrimitive() { + return (flags & PRIMITIVE) != 0; + } + + /** + * Gets the kind that represents this kind when on the Java operand stack. + * @return the kind used on the operand stack + */ + public CiKind stackKind() { + if (isInt()) { + return Int; + } + return this; + } + + public static CiKind fromTypeString(String typeString) { + assert typeString.length() > 0; + final char first = typeString.charAt(0); + if (first == '[' || first == 'L') { + return CiKind.Object; + } + return CiKind.fromPrimitiveOrVoidTypeChar(first); + } + + /** + * Gets the kind from the character describing a primitive or void. + * @param ch the character + * @return the kind + */ + public static CiKind fromPrimitiveOrVoidTypeChar(char ch) { + // Checkstyle: stop + switch (ch) { + case 'Z': return Boolean; + case 'C': return Char; + case 'F': return Float; + case 'D': return Double; + case 'B': return Byte; + case 'S': return Short; + case 'I': return Int; + case 'J': return Long; + case 'V': return Void; + } + // Checkstyle: resume + throw new IllegalArgumentException("unknown primitive or void type character: " + ch); + } + + public Class< ? > toJavaClass() { + // Checkstyle: stop + switch(this) { + case Void: return java.lang.Void.TYPE; + case Long: return java.lang.Long.TYPE; + case Int: return java.lang.Integer.TYPE; + case Byte: return java.lang.Byte.TYPE; + case Char: return java.lang.Character.TYPE; + case Double: return java.lang.Double.TYPE; + case Float: return java.lang.Float.TYPE; + case Short: return java.lang.Short.TYPE; + case Boolean: return java.lang.Boolean.TYPE; + default: return null; + } + // Checkstyle: resume + } + + public Class< ? > toUnboxedJavaClass() { + // Checkstyle: stop + switch(this) { + case Void: return null; + case Long: return java.lang.Long.class; + case Int: return java.lang.Integer.class; + case Byte: return java.lang.Byte.class; + case Char: return java.lang.Character.class; + case Double: return java.lang.Double.class; + case Float: return java.lang.Float.class; + case Short: return java.lang.Short.class; + case Boolean: return java.lang.Boolean.class; + default: return null; + } + // Checkstyle: resume + } + + /** + * Checks whether this value type is void. + * @return {@code true} if this type is void + */ + public final boolean isVoid() { + return this == CiKind.Void; + } + + /** + * Checks whether this value type is long. + * @return {@code true} if this type is long + */ + public final boolean isLong() { + return this == CiKind.Long; + } + + /** + * Checks whether this value type is float. + * @return {@code true} if this type is float + */ + public final boolean isFloat() { + return this == CiKind.Float; + } + + /** + * Checks whether this value type is double. + * @return {@code true} if this type is double + */ + public final boolean isDouble() { + return this == CiKind.Double; + } + + /** + * Checks whether this value type is float or double. + * @return {@code true} if this type is float or double + */ + public final boolean isFloatOrDouble() { + return this == CiKind.Double || this == CiKind.Float; + } + + /** + * Checks whether this value type is an object type. + * @return {@code true} if this type is an object + */ + public final boolean isObject() { + return this == CiKind.Object; + } + + /** + * Checks whether this value type is an address type. + * @return {@code true} if this type is an address + */ + public boolean isJsr() { + return this == CiKind.Jsr; + } + + /** + * Converts this value type to a string. + */ + @Override + public String toString() { + return javaName; + } + + /** + * Marker interface for types that should be {@linkplain CiKind#format(Object) formatted} + * with their {@link Object#toString()} value. + */ + public interface FormatWithToString {} + + /** + * Gets a formatted string for a given value of this kind. + * + * @param value a value of this kind + * @return a formatted string for {@code value} based on this kind + */ + public String format(Object value) { + if (isObject()) { + if (value == null) { + return "null"; + } else { + if (value instanceof String) { + String s = (String) value; + if (s.length() > 50) { + return "\"" + s.substring(0, 30) + "...\""; + } else { + return " \"" + s + '"'; + } + } else if (value instanceof RiType) { + return "class " + CiUtil.toJavaName((RiType) value); + } else if (value instanceof Enum || value instanceof FormatWithToString) { + return String.valueOf(value); + } else if (value instanceof Class< ? >) { + return ((Class< ? >) value).getName() + ".class"; + } else { + return CiUtil.getSimpleName(value.getClass(), true) + "@" + System.identityHashCode(value); + } + } + } else { + return value.toString(); + } + } + + public final char signatureChar() { + return Character.toUpperCase(typeChar); + } + + public CiConstant readUnsafeConstant(Object value, long displacement) { + Unsafe u = Unsafe.getUnsafe(); + switch(this) { + case Boolean: + return CiConstant.forBoolean(u.getBoolean(value, displacement)); + case Byte: + return CiConstant.forByte(u.getByte(value, displacement)); + case Char: + return CiConstant.forChar(u.getChar(value, displacement)); + case Short: + return CiConstant.forShort(u.getShort(value, displacement)); + case Int: + return CiConstant.forInt(u.getInt(value, displacement)); + case Long: + return CiConstant.forLong(u.getLong(value, displacement)); + case Float: + return CiConstant.forFloat(u.getFloat(value, displacement)); + case Double: + return CiConstant.forDouble(u.getDouble(value, displacement)); + case Object: + return CiConstant.forObject(u.getObject(value, displacement)); + default: + assert false : "unexpected kind: " + this; + return null; + } + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiMonitorValue.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,43 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +public final class CiMonitorValue extends CiValue { + private static final long serialVersionUID = 8241681800464483691L; + + public CiValue owner; + public final CiValue lockData; + public final boolean eliminated; + + public CiMonitorValue(CiValue owner, CiValue lockData, boolean eliminated) { + super(CiKind.Illegal); + this.owner = owner; + this.lockData = lockData; + this.eliminated = eliminated; + } + + @Override + public String toString() { + return "monitor[" + owner + (lockData != null ? ", " + lockData : "") + (eliminated ? ", eliminated" : "") + "]"; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiRegister.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,257 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.io.*; +import java.util.*; + +/** + * Represents a target machine register. + */ +public final class CiRegister implements Comparable<CiRegister>, Serializable { + + /** + * + */ + private static final long serialVersionUID = -7213269157816016300L; + + /** + * Invalid register. + */ + public static final CiRegister None = new CiRegister(-1, -1, 0, "noreg"); + + /** + * Frame pointer of the current method. All spill slots and outgoing stack-based arguments + * are addressed relative to this register. + */ + public static final CiRegister Frame = new CiRegister(-2, -2, 0, "framereg", RegisterFlag.CPU); + + public static final CiRegister CallerFrame = new CiRegister(-3, -3, 0, "callerframereg", RegisterFlag.CPU); + + /** + * The identifier for this register that is unique across all the registers in a {@link CiArchitecture}. + * A valid register has {@code number > 0}. + */ + public final int number; + + /** + * The mnemonic of this register. + */ + public final String name; + + /** + * The actual encoding in a target machine instruction for this register, which may or + * may not be the same as {@link #number}. + */ + public final int encoding; + + /** + * The size of the stack slot used to spill the value of this register. + */ + public final int spillSlotSize; + + /** + * The set of {@link RegisterFlag} values associated with this register. + */ + private final int flags; + + /** + * An array of {@link CiRegisterValue} objects, for this register, with one entry + * per {@link CiKind}, indexed by {@link CiKind#ordinal}. + */ + private final CiRegisterValue[] values; + + /** + * Attributes that characterize a register in a useful way. + * + */ + public enum RegisterFlag { + /** + * Denotes an integral (i.e. non floating point) register. + */ + CPU, + + /** + * Denotes a register whose lowest order byte can be addressed separately. + */ + Byte, + + /** + * Denotes a floating point register. + */ + FPU; + + public final int mask = 1 << (ordinal() + 1); + } + + /** + * Creates a {@code CiRegister} instance. + * + * @param number unique identifier for the register + * @param encoding the target machine encoding for the register + * @param spillSlotSize the size of the stack slot used to spill the value of the register + * @param name the mnemonic name for the register + * @param flags the set of {@link RegisterFlag} values for the register + */ + public CiRegister(int number, int encoding, int spillSlotSize, String name, RegisterFlag... flags) { + this.number = number; + this.name = name; + this.spillSlotSize = spillSlotSize; + this.flags = createMask(flags); + this.encoding = encoding; + + values = new CiRegisterValue[CiKind.VALUES.length]; + for (CiKind kind : CiKind.VALUES) { + values[kind.ordinal()] = new CiRegisterValue(kind, this); + } + } + + private static int createMask(RegisterFlag... flags) { + int result = 0; + for (RegisterFlag f : flags) { + result |= f.mask; + } + return result; + } + + public boolean isSet(RegisterFlag f) { + return (flags & f.mask) != 0; + } + + /** + * Gets this register as a {@linkplain CiRegisterValue value} with a specified kind. + * @param kind the specified kind + * @return the {@link CiRegisterValue} + */ + public CiRegisterValue asValue(CiKind kind) { + return values[kind.ordinal()]; + } + + /** + * Gets this register as a {@linkplain CiRegisterValue value} with no particular kind. + * @return a {@link CiRegisterValue} with {@link CiKind#Illegal} kind. + */ + public CiRegisterValue asValue() { + return asValue(CiKind.Illegal); + } + + /** + * Determines if this is a valid register. + * @return {@code true} iff this register is valid + */ + public boolean isValid() { + return number >= 0; + } + + /** + * Determines if this a floating point register. + */ + public boolean isFpu() { + return isSet(RegisterFlag.FPU); + } + + /** + * Determines if this a general purpose register. + */ + public boolean isCpu() { + return isSet(RegisterFlag.CPU); + } + + /** + * Determines if this register has the {@link RegisterFlag#Byte} attribute set. + * @return {@code true} iff this register has the {@link RegisterFlag#Byte} attribute set. + */ + public boolean isByte() { + return isSet(RegisterFlag.Byte); + } + + /** + * Categorizes a set of registers by {@link RegisterFlag}. + * + * @param registers a list of registers to be categorized + * @return a map from each {@link RegisterFlag} constant to the list of registers for which the flag is + * {@linkplain #isSet(RegisterFlag) set} + */ + public static EnumMap<RegisterFlag, CiRegister[]> categorize(CiRegister[] registers) { + EnumMap<RegisterFlag, CiRegister[]> result = new EnumMap<>(RegisterFlag.class); + for (RegisterFlag flag : RegisterFlag.values()) { + ArrayList<CiRegister> list = new ArrayList<>(); + for (CiRegister r : registers) { + if (r.isSet(flag)) { + list.add(r); + } + } + result.put(flag, list.toArray(new CiRegister[list.size()])); + } + return result; + } + + /** + * Gets the maximum register {@linkplain #number number} in a given set of registers. + * + * @param registers the set of registers to process + * @return the maximum register number for any register in {@code registers} + */ + public static int maxRegisterNumber(CiRegister[] registers) { + int max = Integer.MIN_VALUE; + for (CiRegister r : registers) { + if (r.number > max) { + max = r.number; + } + } + return max; + } + + /** + * Gets the maximum register {@linkplain #encoding encoding} in a given set of registers. + * + * @param registers the set of registers to process + * @return the maximum register encoding for any register in {@code registers} + */ + public static int maxRegisterEncoding(CiRegister[] registers) { + int max = Integer.MIN_VALUE; + for (CiRegister r : registers) { + if (r.encoding > max) { + max = r.encoding; + } + } + return max; + } + + @Override + public String toString() { + return name; + } + + @Override + public int compareTo(CiRegister o) { + if (number < o.number) { + return -1; + } + if (number > o.number) { + return 1; + } + return 0; + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiRegisterConfig.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,298 @@ +/* + * Copyright (c) 2010, 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 com.oracle.max.cri.ci; + +import java.util.*; + +import com.oracle.max.cri.ci.CiCallingConvention.*; +import com.oracle.max.cri.ci.CiRegister.*; +import com.oracle.max.cri.ri.*; + +/** + * A default implementation of {@link RiRegisterConfig}. + */ +public class CiRegisterConfig implements RiRegisterConfig { + + /** + * The object describing the callee save area of this register configuration. + */ + public CiCalleeSaveLayout csl; + + /** + * The minimum register role identifier. + */ + public final int minRole; + + /** + * The map from register role IDs to registers. + */ + public final CiRegister[] registersRoleMap; + + /** + * The set of registers that can be used by the register allocator. + */ + public final CiRegister[] allocatable; + + /** + * The set of registers that can be used by the register allocator, + * {@linkplain CiRegister#categorize(CiRegister[]) categorized} by register + * {@linkplain RegisterFlag flags}. + */ + public final EnumMap<RegisterFlag, CiRegister[]> categorized; + + /** + * The ordered set of registers used to pass integral arguments. + */ + public final CiRegister[] cpuParameters; + + /** + * The ordered set of registers used to pass floating point arguments. + */ + public final CiRegister[] fpuParameters; + + /** + * The caller saved registers. + */ + public final CiRegister[] callerSave; + + /** + * The register to which {@link CiRegister#Frame} and {@link CiRegister#CallerFrame} are bound. + */ + public final CiRegister frame; + + /** + * Register for returning an integral value. + */ + public final CiRegister integralReturn; + + /** + * Register for returning a floating point value. + */ + public final CiRegister floatingPointReturn; + + /** + * The map from register {@linkplain CiRegister#number numbers} to register + * {@linkplain RiRegisterAttributes attributes} for this register configuration. + */ + public final RiRegisterAttributes[] attributesMap; + + /** + * The scratch register. + */ + public final CiRegister scratch; + + /** + * The frame offset of the first stack argument for each calling convention {@link CiCallingConvention.Type}. + */ + public final int[] stackArg0Offsets = new int[CiCallingConvention.Type.VALUES.length]; + + public CiRegisterConfig( + CiRegister frame, + CiRegister integralReturn, + CiRegister floatingPointReturn, + CiRegister scratch, + CiRegister[] allocatable, + CiRegister[] callerSave, + CiRegister[] parameters, + CiCalleeSaveLayout csl, + CiRegister[] allRegisters, + Map<Integer, CiRegister> roles) { + this.frame = frame; + this.csl = csl; + this.allocatable = allocatable; + this.callerSave = callerSave; + assert !Arrays.asList(allocatable).contains(scratch); + this.scratch = scratch; + EnumMap<RegisterFlag, CiRegister[]> categorizedParameters = CiRegister.categorize(parameters); + this.cpuParameters = categorizedParameters.get(RegisterFlag.CPU); + this.fpuParameters = categorizedParameters.get(RegisterFlag.FPU); + categorized = CiRegister.categorize(allocatable); + attributesMap = RiRegisterAttributes.createMap(this, allRegisters); + this.floatingPointReturn = floatingPointReturn; + this.integralReturn = integralReturn; + int minRoleId = Integer.MAX_VALUE; + int maxRoleId = Integer.MIN_VALUE; + for (Map.Entry<Integer, CiRegister> e : roles.entrySet()) { + int id = e.getKey(); + assert id >= 0; + if (minRoleId > id) { + minRoleId = id; + } + if (maxRoleId < id) { + maxRoleId = id; + } + } + registersRoleMap = new CiRegister[(maxRoleId - minRoleId) + 1]; + for (Map.Entry<Integer, CiRegister> e : roles.entrySet()) { + int id = e.getKey(); + registersRoleMap[id] = e.getValue(); + } + minRole = minRoleId; + } + + public CiRegisterConfig(CiRegisterConfig src, CiCalleeSaveLayout csl) { + this.frame = src.frame; + this.csl = csl; + this.allocatable = src.allocatable; + this.callerSave = src.callerSave; + this.scratch = src.scratch; + this.cpuParameters = src.cpuParameters; + this.fpuParameters = src.fpuParameters; + this.categorized = src.categorized; + this.attributesMap = src.attributesMap; + this.floatingPointReturn = src.floatingPointReturn; + this.integralReturn = src.integralReturn; + this.registersRoleMap = src.registersRoleMap; + this.minRole = src.minRole; + System.arraycopy(src.stackArg0Offsets, 0, stackArg0Offsets, 0, stackArg0Offsets.length); + } + + public CiRegister getReturnRegister(CiKind kind) { + if (kind.isDouble() || kind.isFloat()) { + return floatingPointReturn; + } + return integralReturn; + } + + public CiRegister getFrameRegister() { + return frame; + } + + public CiRegister getScratchRegister() { + return scratch; + } + + /** + * {@inheritDoc} + * + * This implementation assigns all available registers to parameters before assigning + * any stack slots to parameters. + */ + public CiCallingConvention getCallingConvention(Type type, CiKind[] parameters, CiTarget target, boolean stackOnly) { + CiValue[] locations = new CiValue[parameters.length]; + + int currentGeneral = 0; + int currentXMM = 0; + int currentStackOffset = stackArg0Offsets[type.ordinal()]; + + for (int i = 0; i < parameters.length; i++) { + final CiKind kind = parameters[i]; + + switch (kind) { + case Byte: + case Boolean: + case Short: + case Char: + case Int: + case Long: + case Object: + if (!stackOnly && currentGeneral < cpuParameters.length) { + CiRegister register = cpuParameters[currentGeneral++]; + locations[i] = register.asValue(kind); + } + break; + + case Float: + case Double: + if (!stackOnly && currentXMM < fpuParameters.length) { + CiRegister register = fpuParameters[currentXMM++]; + locations[i] = register.asValue(kind); + } + break; + + default: + throw new InternalError("Unexpected parameter kind: " + kind); + } + + if (locations[i] == null) { + locations[i] = CiStackSlot.get(kind.stackKind(), currentStackOffset, !type.out); + currentStackOffset += Math.max(target.sizeInBytes(kind), target.wordSize); + } + } + + return new CiCallingConvention(locations, currentStackOffset); + } + + public CiRegister[] getCallingConventionRegisters(Type type, RegisterFlag flag) { + if (flag == RegisterFlag.CPU) { + return cpuParameters; + } + assert flag == RegisterFlag.FPU; + return fpuParameters; + } + + public CiRegister[] getAllocatableRegisters() { + return allocatable; + } + + public EnumMap<RegisterFlag, CiRegister[]> getCategorizedAllocatableRegisters() { + return categorized; + } + + public CiRegister[] getCallerSaveRegisters() { + return callerSave; + } + + public CiCalleeSaveLayout getCalleeSaveLayout() { + return csl; + } + + public RiRegisterAttributes[] getAttributesMap() { + return attributesMap; + } + + public CiRegister getRegisterForRole(int id) { + return registersRoleMap[id - minRole]; + } + + @Override + public String toString() { + StringBuilder roleMap = new StringBuilder(); + for (int i = 0; i < registersRoleMap.length; ++i) { + CiRegister reg = registersRoleMap[i]; + if (reg != null) { + if (roleMap.length() != 0) { + roleMap.append(", "); + } + roleMap.append(i + minRole).append(" -> ").append(reg); + } + } + StringBuilder stackArg0OffsetsMap = new StringBuilder(); + for (Type t : Type.VALUES) { + if (stackArg0OffsetsMap.length() != 0) { + stackArg0OffsetsMap.append(", "); + } + stackArg0OffsetsMap.append(t).append(" -> ").append(stackArg0Offsets[t.ordinal()]); + } + String res = String.format( + "Allocatable: " + Arrays.toString(getAllocatableRegisters()) + "%n" + + "CallerSave: " + Arrays.toString(getCallerSaveRegisters()) + "%n" + + "CalleeSave: " + getCalleeSaveLayout() + "%n" + + "CPU Params: " + Arrays.toString(cpuParameters) + "%n" + + "FPU Params: " + Arrays.toString(fpuParameters) + "%n" + + "VMRoles: " + roleMap + "%n" + + "stackArg0: " + stackArg0OffsetsMap + "%n" + + "Scratch: " + getScratchRegister() + "%n"); + return res; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiRegisterValue.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,55 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +/** + * Denotes a register that stores a value of a fixed kind. There is exactly one (canonical) instance of {@code + * CiRegisterValue} for each ({@link CiRegister}, {@link CiKind}) pair. Use {@link CiRegister#asValue(CiKind)} to + * retrieve the canonical {@link CiRegisterValue} instance for a given (register,kind) pair. + */ +public final class CiRegisterValue extends CiValue { + private static final long serialVersionUID = 7999341472196897163L; + + /** + * The register. + */ + public final CiRegister reg; + + /** + * Should only be called from {@link CiRegister#CiRegister} to ensure canonicalization. + */ + protected CiRegisterValue(CiKind kind, CiRegister register) { + super(kind); + this.reg = register; + } + + @Override + public int hashCode() { + return (reg.number << 4) ^ kind.ordinal(); + } + + @Override + public String toString() { + return reg.name + kindSuffix(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiResult.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,75 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +/** + * Represents the result of compiling a method. The result can include a target method with machine code and metadata, + * and/or statistics. If the compiler bailed out due to malformed bytecode, an internal error, or other cause, it will + * supply the bailout object. + */ +public class CiResult { + private final CiTargetMethod targetMethod; + private final CiBailout bailout; + private final CiStatistics stats; + + /** + * Creates a new compilation result. + * @param targetMethod the method that was produced, if any + * @param bailout the bailout condition that occurred + * @param stats statistics about the compilation + */ + public CiResult(CiTargetMethod targetMethod, CiBailout bailout, CiStatistics stats) { + this.targetMethod = targetMethod; + this.bailout = bailout; + this.stats = stats; + } + + /** + * Gets the target method that was produced by this compilation. If no target method was + * produced, but a bailout occured, then the bailout exception will be thrown at this point. + * @return the target method produced + * @throws {@link CiBailout} if a bailout occurred + */ + public CiTargetMethod targetMethod() { + if (bailout != null) { + throw bailout; + } + return targetMethod; + } + + /** + * Returns the statistics about the compilation that were produced, if any. + * @return the statistics + */ + public CiStatistics statistics() { + return stats; + } + + /** + * Returns the bailout condition that occurred for this compilation, if any. + * @return the bailout + */ + public CiBailout bailout() { + return bailout; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiRuntimeCall.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,62 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import static com.oracle.max.cri.ci.CiKind.*; + +/** + * Enumerates the calls that must be provided by the runtime system. The compiler + * may generate code that calls the runtime services for unresolved and slow cases of some + * bytecodes. + */ +public enum CiRuntimeCall { + UnwindException(Void, Object), + Deoptimize(Void), + RegisterFinalizer(Void, Object), + HandleException(Void, Object), + SetDeoptInfo(Void, Object), + CreateNullPointerException(Object), + CreateOutOfBoundsException(Object, Int), + OSRMigrationEnd(Void), + JavaTimeMillis(Long), + JavaTimeNanos(Long), + Debug(Void), + ArithmethicLrem(Long, Long, Long), + ArithmeticLdiv(Long, Long, Long), + ArithmeticFrem(Float, Float, Float), + ArithmeticDrem(Double, Double, Double), + ArithmeticCos(Double, Double), + ArithmeticTan(Double, Double), + ArithmeticLog(Double, Double), + ArithmeticLog10(Double, Double), + ArithmeticSin(Double, Double), + GenericCallback(Object, Object, Object); + + public final CiKind resultKind; + public final CiKind[] arguments; + + private CiRuntimeCall(CiKind resultKind, CiKind... args) { + this.resultKind = resultKind; + this.arguments = args; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiStackSlot.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2010, 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 com.oracle.max.cri.ci; + +import static com.oracle.max.cri.ci.CiKind.*; + +/** + * Represents a compiler spill slot or an outgoing stack-based argument in a method's frame + * or an incoming stack-based argument in a method's {@linkplain #inCallerFrame() caller's frame}. + */ +public final class CiStackSlot extends CiValue { + private static final long serialVersionUID = -7725071921307318433L; + + private final int offset; + private final boolean addFrameSize; + + /** + * Gets a {@link CiStackSlot} instance representing a stack slot at a given index + * holding a value of a given kind. + * + * @param kind The kind of the value stored in the stack slot. + * @param offset The offset of the stack slot (in bytes) + * @param inCallerFrame Specifies if the offset is relative to the stack pointer, + * or the beginning of the frame (stack pointer + total frame size). + */ + public static CiStackSlot get(CiKind kind, int offset, boolean addFrameSize) { + assert kind.stackKind() == kind; + assert addFrameSize || offset >= 0; + + if (offset % CACHE_GRANULARITY == 0) { + CiStackSlot[][] cache; + int index = offset / CACHE_GRANULARITY; + if (!addFrameSize) { + cache = OUT_CACHE; + } else if (offset >= 0) { + cache = IN_CACHE; + } else { + cache = SPILL_CACHE; + index = -index; + } + CiStackSlot[] slots = cache[kind.ordinal()]; + if (index < slots.length) { + CiStackSlot slot = slots[index]; + assert slot.kind == kind && slot.offset == offset && slot.addFrameSize == addFrameSize; + return slot; + } + } + return new CiStackSlot(kind, offset, addFrameSize); + } + + /** + * Private constructor to enforce use of {@link #get()} so that a cache can be used. + */ + private CiStackSlot(CiKind kind, int offset, boolean addFrameSize) { + super(kind); + this.offset = offset; + this.addFrameSize = addFrameSize; + } + + /** + * Gets the offset of this stack slot, relative to the stack pointer. + * @return The offset of this slot (in bytes). + */ + public int offset(int totalFrameSize) { + assert totalFrameSize > 0 || !addFrameSize; + int result = offset + (addFrameSize ? totalFrameSize : 0); + assert result >= 0; + return result; + } + + public boolean inCallerFrame() { + return addFrameSize && offset >= 0; + } + + public int rawOffset() { + return offset; + } + + public boolean rawAddFrameSize() { + return addFrameSize; + } + + @Override + public int hashCode() { + return kind.ordinal() ^ (offset << 4) ^ (addFrameSize ? 15 : 0); + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (o instanceof CiStackSlot) { + CiStackSlot l = (CiStackSlot) o; + return l.kind == kind && l.offset == offset && l.addFrameSize == addFrameSize; + } + return false; + } + + @Override + public String toString() { + String s; + if (!addFrameSize) { + s = "out:"; + } else if (offset >= 0) { + s = "in:"; + } else { + s = "spill:"; + } + return s + offset + kindSuffix(); + } + + /** + * Gets this stack slot used to pass an argument from the perspective of a caller. + */ + public CiStackSlot asOutArg() { + assert offset >= 0; + if (addFrameSize) { + return get(kind, offset, false); + } + return this; + } + + /** + * Gets this stack slot used to pass an argument from the perspective of a callee. + */ + public CiStackSlot asInArg() { + assert offset >= 0; + if (!addFrameSize) { + return get(kind, offset, true); + } + return this; + } + + + private static final int CACHE_GRANULARITY = 8; + private static final int SPILL_CACHE_PER_KIND_SIZE = 100; + private static final int PARAM_CACHE_PER_KIND_SIZE = 10; + + private static final CiStackSlot[][] SPILL_CACHE = makeCache(SPILL_CACHE_PER_KIND_SIZE, -1, true); + private static final CiStackSlot[][] IN_CACHE = makeCache(PARAM_CACHE_PER_KIND_SIZE, 1, true); + private static final CiStackSlot[][] OUT_CACHE = makeCache(PARAM_CACHE_PER_KIND_SIZE, 1, false); + + private static CiStackSlot[][] makeCache(int cachePerKindSize, int sign, boolean addFrameSize) { + CiStackSlot[][] cache = new CiStackSlot[CiKind.VALUES.length][]; + for (CiKind kind : new CiKind[] {Illegal, Int, Long, Float, Double, Object, Jsr}) { + CiStackSlot[] slots = new CiStackSlot[cachePerKindSize]; + for (int i = 0; i < cachePerKindSize; i++) { + slots[i] = new CiStackSlot(kind, sign * i * CACHE_GRANULARITY, addFrameSize); + } + cache[kind.ordinal()] = slots; + } + return cache; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiStatistics.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,66 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +/** + * Contains statistics gathered during the compilation of a method and reported back + * from the compiler as the result of compilation. + */ +public class CiStatistics { + + /** + * The total number of bytes of bytecode parsed during this compilation, including any inlined methods. + */ + public int bytecodeCount; + + /** + * The number of internal graph nodes created during this compilation. + */ + public int nodeCount; + + /** + * The number of basic blocks created during this compilation. + */ + public int blockCount; + + /** + * The number of loops in the compiled method. + */ + public int loopCount; + + /** + * The number of methods inlined. + */ + public int inlineCount; + + /** + * The number of methods folded (i.e. evaluated). + */ + public int foldCount; + + /** + * The number of intrinsics inlined in this compilation. + */ + public int intrinsicCount; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiTarget.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,157 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + + +/** + * Represents the target machine for a compiler, including the CPU architecture, the size of pointers and references, + * alignment of stacks, caches, etc. + */ +public class CiTarget { + public final CiArchitecture arch; + + /** + * The OS page size. + */ + public final int pageSize; + + /** + * Specifies if this is a multi-processor system. + */ + public final boolean isMP; + + /** + * Specifies if this target supports encoding objects inline in the machine code. + */ + public final boolean inlineObjects; + + /** + * The machine word size on this target. + */ + public final int wordSize; + + /** + * The CiKind to be used for representing raw pointers and CPU registers. + */ + public final CiKind wordKind; + + /** + * The stack alignment requirement of the platform. For example, + * from Appendix D of <a href="http://www.intel.com/Assets/PDF/manual/248966.pdf">Intel 64 and IA-32 Architectures Optimization Reference Manual</a>: + * <pre> + * "It is important to ensure that the stack frame is aligned to a + * 16-byte boundary upon function entry to keep local __m128 data, + * parameters, and XMM register spill locations aligned throughout + * a function invocation." + * </pre> + */ + public final int stackAlignment; + + /** + * @see http://docs.sun.com/app/docs/doc/806-0477/6j9r2e2b9?a=view + */ + public final int stackBias; + + /** + * The cache alignment. + */ + public final int cacheAlignment; + + /** + * Specifies how {@code long} and {@code double} constants are to be stored + * in {@linkplain CiFrame frames}. This is useful for VMs such as HotSpot + * where convention the interpreter uses is that the second local + * holds the first raw word of the native long or double representation. + * This is actually reasonable, since locals and stack arrays + * grow downwards in all implementations. + * If, on some machine, the interpreter's Java locals or stack + * were to grow upwards, the embedded doubles would be word-swapped.) + */ + public final boolean debugInfoDoubleWordsInSecondSlot; + + /** + * Temporary flag to distinguish between the semantics necessary for HotSpot and Maxine. + */ + // TODO This should go away when XIR goes away, and the logic be part of the VM-specific lowering. + public final boolean invokeSnippetAfterArguments; + + public CiTarget(CiArchitecture arch, + boolean isMP, + int stackAlignment, + int pageSize, + int cacheAlignment, + boolean inlineObjects, + boolean debugInfoDoubleWordsInSecondSlot, + boolean invokeSnippetAfterArguments) { + this.arch = arch; + this.pageSize = pageSize; + this.isMP = isMP; + this.wordSize = arch.wordSize; + if (wordSize == 8) { + this.wordKind = CiKind.Long; + } else { + this.wordKind = CiKind.Int; + } + this.stackAlignment = stackAlignment; + this.stackBias = 0; // TODO: configure with param once SPARC port exists + this.cacheAlignment = cacheAlignment; + this.inlineObjects = inlineObjects; + this.debugInfoDoubleWordsInSecondSlot = debugInfoDoubleWordsInSecondSlot; + this.invokeSnippetAfterArguments = invokeSnippetAfterArguments; + } + + /** + * Gets the size in bytes of the specified kind for this target. + * + * @param kind the kind for which to get the size + * @return the size in bytes of {@code kind} + */ + public int sizeInBytes(CiKind kind) { + // Checkstyle: stop + switch (kind) { + case Boolean: return 1; + case Byte: return 1; + case Char: return 2; + case Short: return 2; + case Int: return 4; + case Long: return 8; + case Float: return 4; + case Double: return 8; + case Object: return wordSize; + case Jsr: return 4; + default: return 0; + } + // Checkstyle: resume + } + + /** + * Aligns the given frame size (without return instruction pointer) to the stack + * alignment size and return the aligned size (without return instruction pointer). + * @param frameSize the initial frame size to be aligned + * @return the aligned frame size + */ + public int alignFrameSize(int frameSize) { + int x = frameSize + arch.returnAddressSize + (stackAlignment - 1); + return (x / stackAlignment) * stackAlignment - arch.returnAddressSize; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiTargetMethod.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,596 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.io.*; +import java.util.*; + +import com.oracle.max.cri.ri.*; + +/** + * Represents the output from compiling a method, including the compiled machine code, associated data and references, + * relocation information, deoptimization information, etc. It is the essential component of a {@link CiResult}, which also includes + * {@linkplain CiStatistics compilation statistics} and {@linkplain CiBailout failure information}. + */ +public class CiTargetMethod implements Serializable { + + /** + * + */ + private static final long serialVersionUID = -1319947729753702434L; + + /** + * Represents a code position with associated additional information. + */ + public abstract static class Site implements Serializable { + /** + * + */ + private static final long serialVersionUID = -8214214947651979102L; + /** + * The position (or offset) of this site with respect to the start of the target method. + */ + public final int pcOffset; + + public Site(int pos) { + this.pcOffset = pos; + } + } + + /** + * Represents a safepoint with associated debug info. + */ + public static class Safepoint extends Site implements Comparable<Safepoint> { + /** + * + */ + private static final long serialVersionUID = 2479806696381720162L; + public final CiDebugInfo debugInfo; + + Safepoint(int pcOffset, CiDebugInfo debugInfo) { + super(pcOffset); + this.debugInfo = debugInfo; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(pcOffset); + sb.append("[<safepoint>]"); + appendDebugInfo(sb, debugInfo); + return sb.toString(); + } + + @Override + public int compareTo(Safepoint o) { + if (pcOffset < o.pcOffset) { + return -1; + } else if (pcOffset > o.pcOffset) { + return 1; + } + return 0; + } + } + + /** + * Represents a call in the code. + */ + public static final class Call extends Safepoint { + /** + * + */ + private static final long serialVersionUID = 1440741241631046954L; + + /** + * The target of the call. + */ + public final Object target; + + /** + * The size of the call instruction. + */ + public final int size; + + /** + * Specifies if this call is direct or indirect. A direct call has an immediate operand encoding + * the absolute or relative (to the call itself) address of the target. An indirect call has a + * register or memory operand specifying the target address of the call. + */ + public final boolean direct; + + Call(Object target, int pcOffset, int size, boolean direct, CiDebugInfo debugInfo) { + super(pcOffset, debugInfo); + this.size = size; + this.target = target; + this.direct = direct; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(pcOffset); + sb.append('['); + sb.append(target); + sb.append(']'); + + if (debugInfo != null) { + appendDebugInfo(sb, debugInfo); + } + + return sb.toString(); + } + } + + /** + * Represents a reference to data from the code. The associated data can be any constant. + */ + public static final class DataPatch extends Site { + /** + * + */ + private static final long serialVersionUID = 5771730331604867476L; + public final CiConstant constant; + public final int alignment; + + DataPatch(int pcOffset, CiConstant data, int alignment) { + super(pcOffset); + this.constant = data; + this.alignment = alignment; + } + + @Override + public String toString() { + return String.format("%d[<data patch referring to data %s>]", pcOffset, constant); + } + } + + /** + * Provides extra information about instructions or data at specific positions in {@link CiTargetMethod#targetCode()}. + * This is optional information that can be used to enhance a disassembly of the code. + */ + public abstract static class CodeAnnotation implements Serializable { + /** + * + */ + private static final long serialVersionUID = -7903959680749520748L; + public final int position; + + public CodeAnnotation(int position) { + this.position = position; + } + } + + /** + * A string comment about one or more instructions at a specific position in the code. + */ + public static final class CodeComment extends CodeAnnotation { + /** + * + */ + private static final long serialVersionUID = 6802287188701961401L; + public final String value; + public CodeComment(int position, String comment) { + super(position); + this.value = comment; + } + + @Override + public String toString() { + return getClass().getSimpleName() + "@" + position + ": " + value; + } + } + + /** + * Labels some inline data in the code. + */ + public static final class InlineData extends CodeAnnotation { + /** + * + */ + private static final long serialVersionUID = 305997507263827108L; + public final int size; + public InlineData(int position, int size) { + super(position); + this.size = size; + } + + @Override + public String toString() { + return getClass().getSimpleName() + "@" + position + ": size=" + size; + } + } + + /** + * Describes a table of signed offsets embedded in the code. The offsets are relative to the starting + * address of the table. This type of table maybe generated when translating a multi-way branch + * based on a key value from a dense value set (e.g. the {@code tableswitch} JVM instruction). + * + * The table is indexed by the contiguous range of integers from {@link #low} to {@link #high} inclusive. + */ + public static final class JumpTable extends CodeAnnotation { + /** + * + */ + private static final long serialVersionUID = 2222194398353801831L; + + /** + * The low value in the key range (inclusive). + */ + public final int low; + + /** + * The high value in the key range (inclusive). + */ + public final int high; + + /** + * The size (in bytes) of each table entry. + */ + public final int entrySize; + + public JumpTable(int position, int low, int high, int entrySize) { + super(position); + this.low = low; + this.high = high; + this.entrySize = entrySize; + } + + @Override + public String toString() { + return getClass().getSimpleName() + "@" + position + ": [" + low + " .. " + high + "]"; + } + } + + /** + * Describes a table of key and offset pairs. The offset in each table entry is relative to the address of + * the table. This type of table maybe generated when translating a multi-way branch + * based on a key value from a sparse value set (e.g. the {@code lookupswitch} JVM instruction). + */ + public static final class LookupTable extends CodeAnnotation { + /** + * + */ + private static final long serialVersionUID = 8367952567559116160L; + + /** + * The number of entries in the table. + */ + public final int npairs; + + /** + * The size (in bytes) of entry's key. + */ + public final int keySize; + + /** + * The size (in bytes) of entry's offset value. + */ + public final int offsetSize; + + public LookupTable(int position, int npairs, int keySize, int offsetSize) { + super(position); + this.npairs = npairs; + this.keySize = keySize; + this.offsetSize = offsetSize; + } + + @Override + public String toString() { + return getClass().getSimpleName() + "@" + position + ": [npairs=" + npairs + ", keySize=" + keySize + ", offsetSize=" + offsetSize + "]"; + } + } + + /** + * Represents exception handler information for a specific code position. It includes the catch code position as + * well as the caught exception type. + */ + public static final class ExceptionHandler extends Site { + /** + * + */ + private static final long serialVersionUID = 4897339464722665281L; + public final int bci; + public final int scopeLevel; + public final int handlerPos; + public final int handlerBci; + public final RiType exceptionType; + + ExceptionHandler(int pcOffset, int bci, int scopeLevel, int handlerPos, int handlerBci, RiType exceptionType) { + super(pcOffset); + this.bci = bci; + this.scopeLevel = scopeLevel; + this.handlerPos = handlerPos; + this.handlerBci = handlerBci; + this.exceptionType = exceptionType; + } + + @Override + public String toString() { + return String.format("%d[<exception edge to %d with type %s>]", pcOffset, handlerPos, (exceptionType == null) ? "null" : exceptionType); + } + } + + public static final class Mark extends Site { + /** + * + */ + private static final long serialVersionUID = 3612943150662354844L; + public final Object id; + public final Mark[] references; + + Mark(int pcOffset, Object id, Mark[] references) { + super(pcOffset); + this.id = id; + this.references = references; + } + + @Override + public String toString() { + if (id == null) { + return String.format("%d[<mark with %d references>]", pcOffset, references.length); + } else if (id instanceof Integer) { + return String.format("%d[<mark with %d references and id %s>]", pcOffset, references.length, Integer.toHexString((Integer) id)); + } else { + return String.format("%d[<mark with %d references and id %s>]", pcOffset, references.length, id.toString()); + } + } + } + + /** + * List of safepoints, sorted by {@link Site#pcOffset}. + */ + public final List<Safepoint> safepoints = new ArrayList<>(); + + /** + * List of data references. + */ + public final List<DataPatch> dataReferences = new ArrayList<>(); + + /** + * List of exception handlers. + */ + public final List<ExceptionHandler> exceptionHandlers = new ArrayList<>(); + + /** + * List of marks. + */ + public final List<Mark> marks = new ArrayList<>(); + + private int frameSize = -1; + private int customStackAreaOffset = -1; + private int registerRestoreEpilogueOffset = -1; + /** + * The buffer containing the emitted machine code. + */ + private byte[] targetCode; + + /** + * The leading number of bytes in {@link #targetCode} containing the emitted machine code. + */ + private int targetCodeSize; + + private ArrayList<CodeAnnotation> annotations; + + private CiAssumptions assumptions; + + /** + * Constructs a new target method. + */ + public CiTargetMethod() { + } + + public void setAssumptions(CiAssumptions assumptions) { + this.assumptions = assumptions; + } + + public CiAssumptions assumptions() { + return assumptions; + } + + /** + * Sets the frame size in bytes. Does not include the return address pushed onto the + * stack, if any. + * + * @param size the size of the frame in bytes + */ + public void setFrameSize(int size) { + frameSize = size; + } + + /** + * Sets the machine that has been generated by the compiler. + * + * @param code the machine code generated + * @param size the size of the machine code + */ + public void setTargetCode(byte[] code, int size) { + targetCode = code; + targetCodeSize = size; + } + + /** + * Records a reference to the data section in the code section (e.g. to load an integer or floating point constant). + * + * @param codePos the position in the code where the data reference occurs + * @param data the data that is referenced + * @param alignment the alignment requirement of the data or 0 if there is no alignment requirement + */ + public void recordDataReference(int codePos, CiConstant data, int alignment) { + assert codePos >= 0 && data != null; + dataReferences.add(new DataPatch(codePos, data, alignment)); + } + + /** + * Records a call in the code array. + * + * @param codePos the position of the call in the code array + * @param size the size of the call instruction + * @param target the {@link RiRuntime#asCallTarget(Object) target} being called + * @param debugInfo the debug info for the call + * @param direct specifies if this is a {@linkplain Call#direct direct} call + */ + public void recordCall(int codePos, int size, Object target, CiDebugInfo debugInfo, boolean direct) { + final Call call = new Call(target, codePos, size, direct, debugInfo); + addSafepoint(call); + } + + /** + * Records an exception handler for this method. + * + * @param codePos the position in the code that is covered by the handler + * @param handlerPos the position of the handler + * @param throwableType the type of exceptions handled by the handler + */ + public void recordExceptionHandler(int codePos, int bci, int scopeLevel, int handlerPos, int handlerBci, RiType throwableType) { + exceptionHandlers.add(new ExceptionHandler(codePos, bci, scopeLevel, handlerPos, handlerBci, throwableType)); + } + + /** + * Records a safepoint in the code array. + * + * @param codePos the position of the safepoint in the code array + * @param debugInfo the debug info for the safepoint + */ + public void recordSafepoint(int codePos, CiDebugInfo debugInfo) { + addSafepoint(new Safepoint(codePos, debugInfo)); + } + + private void addSafepoint(Safepoint safepoint) { + // The safepoints list must always be sorted + if (!safepoints.isEmpty() && safepoints.get(safepoints.size() - 1).pcOffset >= safepoint.pcOffset) { + // This re-sorting should be very rare + Collections.sort(safepoints); + } + safepoints.add(safepoint); + } + + /** + * Records an instruction mark within this method. + * + * @param codePos the position in the code that is covered by the handler + * @param id the identifier for this mark + * @param references an array of other marks that this mark references + */ + public Mark recordMark(int codePos, Object id, Mark[] references) { + Mark mark = new Mark(codePos, id, references); + marks.add(mark); + return mark; + } + + /** + * Allows a method to specify the offset of the epilogue that restores the callee saved registers. Must be called + * iff the method is a callee saved method and stores callee registers on the stack. + * + * @param registerRestoreEpilogueOffset the offset in the machine code where the epilogue begins + */ + public void setRegisterRestoreEpilogueOffset(int registerRestoreEpilogueOffset) { + assert this.registerRestoreEpilogueOffset == -1; + this.registerRestoreEpilogueOffset = registerRestoreEpilogueOffset; + } + + /** + * The frame size of the method in bytes. + * + * @return the frame size + */ + public int frameSize() { + assert frameSize != -1 : "frame size not yet initialized!"; + return frameSize; + } + + /** + * @return the code offset of the start of the epilogue that restores all callee saved registers, or -1 if this is + * not a callee saved method + */ + public int registerRestoreEpilogueOffset() { + return registerRestoreEpilogueOffset; + } + + /** + * Offset in bytes for the custom stack area (relative to sp). + * @return the offset in bytes + */ + public int customStackAreaOffset() { + return customStackAreaOffset; + } + + /** + * @see #customStackAreaOffset() + * @param offset + */ + public void setCustomStackAreaOffset(int offset) { + customStackAreaOffset = offset; + } + + /** + * @return the machine code generated for this method + */ + public byte[] targetCode() { + return targetCode; + } + + /** + * @return the size of the machine code generated for this method + */ + public int targetCodeSize() { + return targetCodeSize; + } + + /** + * @return the code annotations or {@code null} if there are none + */ + public List<CodeAnnotation> annotations() { + return annotations; + } + + public void addAnnotation(CodeAnnotation annotation) { + assert annotation != null; + if (annotations == null) { + annotations = new ArrayList<>(); + } + annotations.add(annotation); + } + + private static void appendDebugInfo(StringBuilder sb, CiDebugInfo info) { + if (info != null) { + appendRefMap(sb, "stackMap", info.frameRefMap); + appendRefMap(sb, "registerMap", info.registerRefMap); + CiCodePos codePos = info.codePos; + if (codePos != null) { + CiUtil.appendLocation(sb.append(" "), codePos.method, codePos.bci); + if (info.hasFrame()) { + sb.append(" #locals=").append(info.frame().numLocals).append(" #expr=").append(info.frame().numStack); + if (info.frame().numLocks > 0) { + sb.append(" #locks=").append(info.frame().numLocks); + } + } + } + } + } + + private static void appendRefMap(StringBuilder sb, String name, CiBitMap map) { + if (map != null) { + sb.append(' ').append(name).append('[').append(map.toBinaryString()).append(']'); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiUtil.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,739 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import static java.lang.reflect.Modifier.*; + +import java.lang.annotation.*; +import java.util.*; + +import com.oracle.max.cri.ri.*; + +/** + * Miscellaneous collection of utility methods used in the {@code CRI} project. + */ +public class CiUtil { + + public static final String NEW_LINE = String.format("%n"); + + /** + * Gets the annotation of a particular type for a formal parameter of a given method. + * + * @param annotationClass the Class object corresponding to the annotation type + * @param parameterIndex the index of a formal parameter of {@code method} + * @param method the method for which a parameter annotation is being requested + * @return the annotation of type {@code annotationClass} for the formal parameter present, else null + * @throws IndexOutOfBoundsException if {@code parameterIndex} does not denote a formal parameter + */ + public static <T extends Annotation> T getParameterAnnotation(Class<T> annotationClass, int parameterIndex, RiResolvedMethod method) { + if (parameterIndex >= 0) { + Annotation[][] parameterAnnotations = method.getParameterAnnotations(); + for (Annotation a : parameterAnnotations[parameterIndex]) { + if (a.annotationType() == annotationClass) { + return annotationClass.cast(a); + } + } + } + return null; + } + + /** + * Extends the functionality of {@link Class#getSimpleName()} to include a non-empty string for anonymous and local + * classes. + * + * @param clazz the class for which the simple name is being requested + * @param withEnclosingClass specifies if the returned name should be qualified with the name(s) of the enclosing + * class/classes of {@code clazz} (if any). This option is ignored if {@code clazz} denotes an anonymous + * or local class. + * @return the simple name + */ + public static String getSimpleName(Class<?> clazz, boolean withEnclosingClass) { + final String simpleName = clazz.getSimpleName(); + if (simpleName.length() != 0) { + if (withEnclosingClass) { + String prefix = ""; + Class<?> enclosingClass = clazz; + while ((enclosingClass = enclosingClass.getEnclosingClass()) != null) { + prefix = prefix + enclosingClass.getSimpleName() + "."; + } + return prefix + simpleName; + } + return simpleName; + } + // Must be an anonymous or local class + final String name = clazz.getName(); + int index = name.indexOf('$'); + if (index == -1) { + return name; + } + index = name.lastIndexOf('.', index); + if (index == -1) { + return name; + } + return name.substring(index + 1); + } + + public static final int K = 1024; + public static final int M = 1024 * 1024; + public static boolean isOdd(int n) { + return (n & 1) == 1; + } + + public static boolean isEven(int n) { + return (n & 1) == 0; + } + + /** + * Checks whether the specified integer is a power of two. + * + * @param val the value to check + * @return {@code true} if the value is a power of two; {@code false} otherwise + */ + public static boolean isPowerOf2(int val) { + return val != 0 && (val & val - 1) == 0; + } + + /** + * Checks whether the specified long is a power of two. + * + * @param val the value to check + * @return {@code true} if the value is a power of two; {@code false} otherwise + */ + public static boolean isPowerOf2(long val) { + return val != 0 && (val & val - 1) == 0; + } + + /** + * Computes the log (base 2) of the specified integer, rounding down. + * (E.g {@code log2(8) = 3}, {@code log2(21) = 4}) + * + * @param val the value + * @return the log base 2 of the value + */ + public static int log2(int val) { + assert val > 0 && isPowerOf2(val); + return 31 - Integer.numberOfLeadingZeros(val); + } + + /** + * Computes the log (base 2) of the specified long, rounding down. + * (E.g {@code log2(8) = 3}, {@code log2(21) = 4}) + * + * @param val the value + * @return the log base 2 of the value + */ + public static int log2(long val) { + assert val > 0 && isPowerOf2(val); + return 63 - Long.numberOfLeadingZeros(val); + } + + public static int align(int size, int align) { + assert isPowerOf2(align); + return (size + align - 1) & ~(align - 1); + } + + /** + * Gets a word with the nth bit set. + * @param n the nth bit to set + * @return an integer value with the nth bit set + */ + public static int nthBit(int n) { + return n >= Integer.SIZE ? 0 : 1 << n; + } + + /** + * Gets a word with the right-most n bits set. + * @param n the number of right most bits to set + * @return an integer value with the right-most n bits set + */ + public static int rightNBits(int n) { + return nthBit(n) - 1; + } + + /** + * Converts a given type to its Java programming language name. The following are examples of strings returned by + * this method: + * + * <pre> + * qualified == true: + * java.lang.Object + * int + * boolean[][] + * qualified == false: + * Object + * int + * boolean[][] + * </pre> + * + * @param riType the type to be converted to a Java name + * @param qualified specifies if the package prefix of the type should be included in the returned name + * @return the Java name corresponding to {@code riType} + */ + public static String toJavaName(RiType riType, boolean qualified) { + CiKind kind = riType.kind(false); + if (kind.isPrimitive() || kind == CiKind.Void) { + return kind.javaName; + } + return internalNameToJava(riType.name(), qualified); + } + /** + * Converts a given type to its Java programming language name. The following are examples of strings returned by + * this method: + * + * <pre> + * java.lang.Object + * int + * boolean[][] + * </pre> + * + * @param riType the type to be converted to a Java name + * @return the Java name corresponding to {@code riType} + */ + public static String toJavaName(RiType riType) { + return (riType == null) ? null : internalNameToJava(riType.name(), true); + } + + public static String internalNameToJava(String name, boolean qualified) { + switch (name.charAt(0)) { + case 'L': { + String result = name.substring(1, name.length() - 1).replace('/', '.'); + if (!qualified) { + final int lastDot = result.lastIndexOf('.'); + if (lastDot != -1) { + result = result.substring(lastDot + 1); + } + } + return result; + + } + case '[': + return internalNameToJava(name.substring(1), qualified) + "[]"; + default: + if (name.length() != 1) { + throw new IllegalArgumentException("Illegal internal name: " + name); + } + return CiKind.fromPrimitiveOrVoidTypeChar(name.charAt(0)).javaName; + } + } + + /** + * Gets a string for a given method formatted according to a given format specification. A format specification is + * composed of characters that are to be copied verbatim to the result and specifiers that denote an attribute of + * the method that is to be copied to the result. A specifier is a single character preceded by a '%' character. The + * accepted specifiers and the method attributes they denote are described below: + * + * <pre> + * Specifier | Description | Example(s) + * ----------+------------------------------------------------------------------------------------------ + * 'R' | Qualified return type | "int" "java.lang.String" + * 'r' | Unqualified return type | "int" "String" + * 'H' | Qualified holder | "java.util.Map.Entry" + * 'h' | Unqualified holder | "Entry" + * 'n' | Method name | "add" + * 'P' | Qualified parameter types, separated by ', ' | "int, java.lang.String" + * 'p' | Unqualified parameter types, separated by ', ' | "int, String" + * 'f' | Indicator if method is unresolved, static or virtual | "unresolved" "static" "virtual" + * '%' | A '%' character | "%" + * </pre> + * + * @param format a format specification + * @param method the method to be formatted + * @param kinds if {@code true} then the types in {@code method}'s signature are printed in the + * {@linkplain CiKind#jniName JNI} form of their {@linkplain CiKind kind} + * @return the result of formatting this method according to {@code format} + * @throws IllegalFormatException if an illegal specifier is encountered in {@code format} + */ + public static String format(String format, RiMethod method) throws IllegalFormatException { + final StringBuilder sb = new StringBuilder(); + int index = 0; + RiSignature sig = null; + while (index < format.length()) { + final char ch = format.charAt(index++); + if (ch == '%') { + if (index >= format.length()) { + throw new UnknownFormatConversionException("An unquoted '%' character cannot terminate a method format specification"); + } + final char specifier = format.charAt(index++); + boolean qualified = false; + switch (specifier) { + case 'R': + qualified = true; + // fall through + case 'r': { + if (sig == null) { + sig = method.signature(); + } + sb.append(toJavaName(sig.returnType(null), qualified)); + break; + } + case 'H': + qualified = true; + // fall through + case 'h': { + sb.append(toJavaName(method.holder(), qualified)); + break; + } + case 'n': { + sb.append(method.name()); + break; + } + case 'P': + qualified = true; + // fall through + case 'p': { + if (sig == null) { + sig = method.signature(); + } + for (int i = 0; i < sig.argumentCount(false); i++) { + if (i != 0) { + sb.append(", "); + } + sb.append(toJavaName(sig.argumentTypeAt(i, null), qualified)); + } + break; + } + case 'f': { + sb.append(!(method instanceof RiResolvedMethod) ? "unresolved" : isStatic(((RiResolvedMethod) method).accessFlags()) ? "static" : "virtual"); + break; + } + case '%': { + sb.append('%'); + break; + } + default: { + throw new UnknownFormatConversionException(String.valueOf(specifier)); + } + } + } else { + sb.append(ch); + } + } + return sb.toString(); + } + /** + * Gets a string for a given field formatted according to a given format specification. A format specification is + * composed of characters that are to be copied verbatim to the result and specifiers that denote an attribute of + * the field that is to be copied to the result. A specifier is a single character preceded by a '%' character. The + * accepted specifiers and the field attributes they denote are described below: + * + * <pre> + * Specifier | Description | Example(s) + * ----------+------------------------------------------------------------------------------------------ + * 'T' | Qualified type | "int" "java.lang.String" + * 't' | Unqualified type | "int" "String" + * 'H' | Qualified holder | "java.util.Map.Entry" + * 'h' | Unqualified holder | "Entry" + * 'n' | Field name | "age" + * 'f' | Indicator if field is unresolved, static or instance | "unresolved" "static" "instance" + * '%' | A '%' character | "%" + * </pre> + * + * @param format a format specification + * @param field the field to be formatted + * @param kinds if {@code true} then {@code field}'s type is printed in the + * {@linkplain CiKind#jniName JNI} form of its {@linkplain CiKind kind} + * @return the result of formatting this field according to {@code format} + * @throws IllegalFormatException if an illegal specifier is encountered in {@code format} + */ + public static String format(String format, RiField field) throws IllegalFormatException { + final StringBuilder sb = new StringBuilder(); + int index = 0; + RiType type = field.type(); + while (index < format.length()) { + final char ch = format.charAt(index++); + if (ch == '%') { + if (index >= format.length()) { + throw new UnknownFormatConversionException("An unquoted '%' character cannot terminate a field format specification"); + } + final char specifier = format.charAt(index++); + boolean qualified = false; + switch (specifier) { + case 'T': + qualified = true; + // fall through + case 't': { + sb.append(toJavaName(type, qualified)); + break; + } + case 'H': + qualified = true; + // fall through + case 'h': { + sb.append(toJavaName(field.holder(), qualified)); + break; + } + case 'n': { + sb.append(field.name()); + break; + } + case 'f': { + sb.append(!(field instanceof RiResolvedField) ? "unresolved" : isStatic(((RiResolvedField) field).accessFlags()) ? "static" : "instance"); + break; + } + case '%': { + sb.append('%'); + break; + } + default: { + throw new UnknownFormatConversionException(String.valueOf(specifier)); + } + } + } else { + sb.append(ch); + } + } + return sb.toString(); + } + + /** + * Gets a stack trace element for a given method and bytecode index. + */ + public static StackTraceElement toStackTraceElement(RiMethod method, @SuppressWarnings("unused") int bci) { + // TODO(tw): Look if we can use bci to get the line number. + return new StackTraceElement(CiUtil.toJavaName(method.holder()), method.name(), null, -1); + } + + /** + * Converts a Java source-language class name into the internal form. + * + * @param className the class name + * @return the internal name form of the class name + */ + public static String toInternalName(String className) { + return "L" + className.replace('.', '/') + ";"; + } + + /** + * Creates a set that uses reference-equality instead of {@link Object#equals(Object)} + * when comparing values. + * + * @param <T> the type of elements in the set + * @return a set based on reference-equality + */ + public static <T> Set<T> newIdentityHashSet() { + return Collections.newSetFromMap(new IdentityHashMap<T, Boolean>()); + } + + /** + * Prepends the String {@code indentation} to every line in String {@code lines}, + * including a possibly non-empty line following the final newline. + */ + public static String indent(String lines, String indentation) { + if (lines.length() == 0) { + return lines; + } + final String newLine = "\n"; + if (lines.endsWith(newLine)) { + return indentation + (lines.substring(0, lines.length() - 1)).replace(newLine, newLine + indentation) + newLine; + } + return indentation + lines.replace(newLine, newLine + indentation); + } + + /** + * Formats the values in a frame as a tabulated string. + * + * @param frame + * @return the values in {@code frame} as a tabulated string + */ + public static String tabulateValues(CiFrame frame) { + int cols = Math.max(frame.numLocals, Math.max(frame.numStack, frame.numLocks)); + assert cols > 0; + ArrayList<Object> cells = new ArrayList<>(); + cells.add(""); + for (int i = 0; i < cols; i++) { + cells.add(i); + } + cols++; + if (frame.numLocals != 0) { + cells.add("locals:"); + cells.addAll(Arrays.asList(frame.values).subList(0, frame.numLocals)); + cells.addAll(Collections.nCopies(cols - frame.numLocals - 1, "")); + } + if (frame.numStack != 0) { + cells.add("stack:"); + cells.addAll(Arrays.asList(frame.values).subList(frame.numLocals, frame.numLocals + frame.numStack)); + cells.addAll(Collections.nCopies(cols - frame.numStack - 1, "")); + } + if (frame.numLocks != 0) { + cells.add("locks:"); + cells.addAll(Arrays.asList(frame.values).subList(frame.numLocals + frame.numStack, frame.values.length)); + cells.addAll(Collections.nCopies(cols - frame.numLocks - 1, "")); + } + Object[] cellArray = cells.toArray(); + for (int i = 0; i < cellArray.length; i++) { + if ((i % cols) != 0) { + cellArray[i] = "|" + cellArray[i]; + } + } + return CiUtil.tabulate(cellArray, cols, 1, 1); + } + + /** + * Formats a given table as a string. The value of each cell is produced by {@link String#valueOf(Object)}. + * + * @param cells the cells of the table in row-major order + * @param cols the number of columns per row + * @param lpad the number of space padding inserted before each formatted cell value + * @param rpad the number of space padding inserted after each formatted cell value + * @return a string with one line per row and each column left-aligned + */ + public static String tabulate(Object[] cells, int cols, int lpad, int rpad) { + int rows = (cells.length + (cols - 1)) / cols; + int[] colWidths = new int[cols]; + for (int col = 0; col < cols; col++) { + for (int row = 0; row < rows; row++) { + int index = col + (row * cols); + if (index < cells.length) { + Object cell = cells[index]; + colWidths[col] = Math.max(colWidths[col], String.valueOf(cell).length()); + } + } + } + StringBuilder sb = new StringBuilder(); + String nl = NEW_LINE; + for (int row = 0; row < rows; row++) { + for (int col = 0; col < cols; col++) { + int index = col + (row * cols); + if (index < cells.length) { + for (int i = 0; i < lpad; i++) { + sb.append(' '); + } + Object cell = cells[index]; + String s = String.valueOf(cell); + int w = s.length(); + sb.append(s); + while (w < colWidths[col]) { + sb.append(' '); + w++; + } + for (int i = 0; i < rpad; i++) { + sb.append(' '); + } + } + } + sb.append(nl); + } + return sb.toString(); + } + + /** + * Convenient shortcut for calling {@link #appendLocation(StringBuilder, RiMethod, int)} + * without having to supply a a {@link StringBuilder} instance and convert the result + * to a string. + */ + public static String toLocation(RiResolvedMethod method, int bci) { + return appendLocation(new StringBuilder(), method, bci).toString(); + } + + + /** + * Appends a string representation of a location specified by a given method and bci to + * a given {@link StringBuilder}. If a stack trace element with a non-null file name + * and non-negative line number is {@linkplain RiMethod#toStackTraceElement(int) available} + * for the given method, then the string returned is the {@link StackTraceElement#toString()} + * value of the stack trace element, suffixed by the bci location. For example: + * <pre> + * java.lang.String.valueOf(String.java:2930) [bci: 12] + * </pre> + * Otherwise, the string returned is the value of {@code CiUtil.format("%H.%n(%p)"}, suffixed + * by the bci location. For example: + * <pre> + * java.lang.String.valueOf(int) [bci: 12] + * </pre> + * + * @param sb + * @param method + * @param bci + * @return + */ + public static StringBuilder appendLocation(StringBuilder sb, RiResolvedMethod method, int bci) { + StackTraceElement ste = method.toStackTraceElement(bci); + if (ste.getFileName() != null && ste.getLineNumber() > 0) { + sb.append(ste); + } else { + sb.append(CiUtil.format("%H.%n(%p)", method)); + } + return sb.append(" [bci: ").append(bci).append(']'); + } + + /** + * Appends a formatted code position to a {@link StringBuilder}. + * + * @param sb the {@link StringBuilder} to append to + * @param pos the code position to format and append to {@code sb} + * @return the value of {@code sb} + */ + public static StringBuilder append(StringBuilder sb, CiCodePos pos) { + appendLocation(sb.append("at "), pos.method, pos.bci); + if (pos.caller != null) { + sb.append(NEW_LINE); + append(sb, pos.caller); + } + return sb; + } + + /** + * Appends a formatted frame to a {@link StringBuilder}. + * + * @param sb the {@link StringBuilder} to append to + * @param frame the frame to format and append to {@code sb} + * @return the value of {@code sb} + */ + public static StringBuilder append(StringBuilder sb, CiFrame frame) { + appendLocation(sb.append("at "), frame.method, frame.bci); + if (frame.values != null && frame.values.length > 0) { + sb.append(NEW_LINE); + String table = tabulateValues(frame); + String[] rows = table.split(NEW_LINE); + for (int i = 0; i < rows.length; i++) { + String row = rows[i]; + if (!row.trim().isEmpty()) { + sb.append(" ").append(row); + if (i != rows.length - 1) { + sb.append(NEW_LINE); + } + } + } + } + if (frame.caller() != null) { + sb.append(NEW_LINE); + append(sb, frame.caller()); + } else if (frame.caller != null) { + sb.append(NEW_LINE); + append(sb, frame.caller); + } + return sb; + } + + /** + * Formats a location present in a register or frame reference map. + */ + public static class RefMapFormatter { + /** + * The size of a stack slot. + */ + public final int slotSize; + + /** + * The register used as the frame pointer. + */ + public final CiRegister fp; + + public final CiArchitecture arch; + + /** + * The offset (in bytes) from the slot pointed to by {@link #fp} to the slot + * corresponding to bit 0 in the frame reference map. + */ + public final int refMapToFPOffset; + + public RefMapFormatter(CiArchitecture arch, int slotSize, CiRegister fp, int refMapToFPOffset) { + this.arch = arch; + this.slotSize = slotSize; + this.fp = fp; + this.refMapToFPOffset = refMapToFPOffset; + } + + public String formatStackSlot(int frameRefMapIndex) { + int refMapOffset = frameRefMapIndex * slotSize; + int fpOffset = refMapOffset + refMapToFPOffset; + if (fpOffset >= 0) { + return fp + "+" + fpOffset; + } + return fp.name + fpOffset; + } + + public String formatRegister(int regRefMapIndex) { + return arch.registers[regRefMapIndex].toString(); + } + } + + /** + * Appends a formatted debug info to a {@link StringBuilder}. + * + * @param sb the {@link StringBuilder} to append to + * @param info the debug info to format and append to {@code sb} + * @return the value of {@code sb} + */ + public static StringBuilder append(StringBuilder sb, CiDebugInfo info, RefMapFormatter formatter) { + String nl = NEW_LINE; + if (info.hasRegisterRefMap()) { + sb.append(" reg-ref-map:"); + CiBitMap bm = info.registerRefMap; + if (formatter != null) { + for (int reg = bm.nextSetBit(0); reg >= 0; reg = bm.nextSetBit(reg + 1)) { + sb.append(" " + formatter.formatRegister(reg)); + } + } + sb.append(' ').append(bm).append(nl); + } + if (info.hasStackRefMap()) { + sb.append("frame-ref-map:"); + CiBitMap bm = info.frameRefMap; + if (formatter != null) { + for (int i = bm.nextSetBit(0); i >= 0; i = bm.nextSetBit(i + 1)) { + sb.append(" " + formatter.formatStackSlot(i)); + } + } + sb.append(' ').append(bm).append(nl); + } + CiFrame frame = info.frame(); + if (frame != null) { + append(sb, frame); + } else if (info.codePos != null) { + append(sb, info.codePos); + } + return sb; + } + + public static CiKind[] signatureToKinds(RiResolvedMethod method) { + CiKind receiver = isStatic(method.accessFlags()) ? null : method.holder().kind(true); + return signatureToKinds(method.signature(), receiver); + } + + public static CiKind[] signatureToKinds(RiSignature signature, CiKind receiverKind) { + int args = signature.argumentCount(false); + CiKind[] result; + int i = 0; + if (receiverKind != null) { + result = new CiKind[args + 1]; + result[0] = receiverKind; + i = 1; + } else { + result = new CiKind[args]; + } + for (int j = 0; j < args; j++) { + result[i + j] = signature.argumentKindAt(j, true); + } + return result; + } + + public static Class<?>[] signatureToTypes(RiSignature signature, RiType accessingClass) { + int count = signature.argumentCount(false); + Class<?>[] result = new Class<?>[count]; + for (int i = 0; i < result.length; ++i) { + result[i] = ((RiResolvedType) signature.argumentTypeAt(i, accessingClass)).toJava(); + } + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiValue.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,60 @@ +/* + * 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. + * + * 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.oracle.max.cri.ci; + +import java.io.*; + +/** + * Abstract base class for values manipulated by the compiler. All values have a {@linkplain CiKind kind} and are immutable. + */ +public abstract class CiValue implements Serializable { + private static final long serialVersionUID = -6909397188697766469L; + + @SuppressWarnings("serial") + public static CiValue IllegalValue = new CiValue(CiKind.Illegal) { + @Override + public String toString() { + return "-"; + } + }; + + /** + * The kind of this value. + */ + public final CiKind kind; + + /** + * Initializes a new value of the specified kind. + * @param kind the kind + */ + protected CiValue(CiKind kind) { + this.kind = kind; + } + + /** + * String representation of the kind, which should be the end of all {@link #toString()} implementation of subclasses. + */ + protected final String kindSuffix() { + return "|" + kind.typeChar; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiValueUtil.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2012, 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 com.oracle.max.cri.ci; + +public class CiValueUtil { + public static boolean isIllegal(CiValue value) { + assert value != null; + return value == CiValue.IllegalValue; + } + + public static boolean isLegal(CiValue value) { + return !isIllegal(value); + } + + public static boolean isVirtualObject(CiValue value) { + assert value != null; + return value instanceof CiVirtualObject; + } + + + public static boolean isVariable(CiValue value) { + assert value != null; + return value instanceof CiVariable; + } + + public static CiVariable asVariable(CiValue value) { + assert value != null; + return (CiVariable) value; + } + + + public static boolean isConstant(CiValue value) { + assert value != null; + return value instanceof CiConstant; + } + + + public static boolean isStackSlot(CiValue value) { + assert value != null; + return value instanceof CiStackSlot; + } + + public static CiStackSlot asStackSlot(CiValue value) { + assert value != null; + return (CiStackSlot) value; + } + + + public static boolean isRegister(CiValue value) { + assert value != null; + return value instanceof CiRegisterValue; + } + + public static CiRegister asRegister(CiValue value) { + assert value != null; + return ((CiRegisterValue) value).reg; + } + + public static CiRegister asIntReg(CiValue value) { + assert value.kind == CiKind.Int || value.kind == CiKind.Jsr; + return asRegister(value); + } + + public static CiRegister asLongReg(CiValue value) { + assert value.kind == CiKind.Long : value.kind; + return asRegister(value); + } + + public static CiRegister asObjectReg(CiValue value) { + assert value.kind == CiKind.Object; + return asRegister(value); + } + + public static CiRegister asFloatReg(CiValue value) { + assert value.kind == CiKind.Float; + return asRegister(value); + } + + public static CiRegister asDoubleReg(CiValue value) { + assert value.kind == CiKind.Double; + return asRegister(value); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiVariable.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2010, 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 com.oracle.max.cri.ci; + +/** + * Represents a value that is yet to be bound to a machine location (such as + * a {@linkplain CiRegister register} or stack {@linkplain CiAddress address}) + * by a register allocator. + */ +public final class CiVariable extends CiValue { + private static final long serialVersionUID = 4507578431686109809L; + + /** + * The identifier of the variable. This is a non-zero index in a contiguous 0-based name space. + */ + public final int index; + + /** + * Creates a new variable. + * @param kind + * @param index + */ + private CiVariable(CiKind kind, int index) { + super(kind); + this.index = index; + } + + private static CiVariable[] generate(CiKind kind, int count) { + CiVariable[] variables = new CiVariable[count]; + for (int i = 0; i < count; i++) { + variables[i] = new CiVariable(kind, i); + } + return variables; + } + + private static final int CACHE_PER_KIND_SIZE = 100; + + /** + * Cache of common variables. + */ + private static final CiVariable[][] cache = new CiVariable[CiKind.values().length][]; + static { + for (CiKind kind : CiKind.values()) { + cache[kind.ordinal()] = generate(kind, CACHE_PER_KIND_SIZE); + } + } + + /** + * Gets a variable for a given kind and index. + * + * @param kind + * @param index + * @return the corresponding {@code CiVariable} + */ + public static CiVariable get(CiKind kind, int index) { + //assert kind == kind.stackKind() : "Variables can be only created for stack kinds"; + assert index >= 0; + CiVariable[] cachedVars = cache[kind.ordinal()]; + if (index < cachedVars.length) { + return cachedVars[index]; + } + return new CiVariable(kind, index); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof CiVariable) { + CiVariable var = (CiVariable) obj; + return kind == var.kind && index == var.index; + } + return false; + } + + @Override + public int hashCode() { + return (index << 4) | kind.ordinal(); + } + + @Override + public String toString() { + return "v" + index + kindSuffix(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiVirtualObject.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,164 @@ +/* + * Copyright (c) 2010, 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 com.oracle.max.cri.ci; + +import com.oracle.max.cri.ri.*; + +/** + * An instance of this class represents an object whose allocation was removed by escape analysis. The information stored in the {@link CiVirtualObject} is used during + * deoptimization to recreate the object. + */ +public final class CiVirtualObject extends CiValue { + private static final long serialVersionUID = -2907197776426346021L; + + private final RiType type; + private CiValue[] values; + private final int id; + + /** + * Creates a new CiVirtualObject for the given type, with the given fields. If the type is an instance class then the values array needs to have one entry for each field, ordered in + * like the fields returned by {@link RiResolvedType#declaredFields()}. If the type is an array then the length of the values array determines the reallocated array length. + * @param type the type of the object whose allocation was removed during compilation. This can be either an instance of an array type. + * @param values an array containing all the values to be stored into the object when it is recreated. + * @param id a unique id that identifies the object within the debug information for one position in the compiled code. + * @return a new CiVirtualObject instance. + */ + public static CiVirtualObject get(RiType type, CiValue[] values, int id) { + return new CiVirtualObject(type, values, id); + } + + private CiVirtualObject(RiType type, CiValue[] values, int id) { + super(CiKind.Object); + this.type = type; + this.values = values; + this.id = id; + } + + @Override + public String toString() { + return "vobject:" + id; + } + + /** + * @return the type of the object whose allocation was removed during compilation. This can be either an instance of an array type. + */ + public RiType type() { + return type; + } + + /** + * @return an array containing all the values to be stored into the object when it is recreated. + */ + public CiValue[] values() { + return values; + } + + /** + * @return the unique id that identifies the object within the debug information for one position in the compiled code. + */ + public int id() { + return id; + } + + /** + * Overwrites the current set of values with a new one. + * @param values an array containing all the values to be stored into the object when it is recreated. + */ + public void setValues(CiValue[] values) { + this.values = values; + } + + @Override + public int hashCode() { + return kind.ordinal() + type.hashCode(); + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (o instanceof CiVirtualObject) { + CiVirtualObject l = (CiVirtualObject) o; + if (l.type != type || l.values.length != values.length) { + return false; + } + for (int i = 0; i < values.length; i++) { + if (values[i] != l.values[i]) { + return false; + } + } + return true; + } + return false; + } + + /** + * This is a helper class used to create virtual objects for a number of different JDK classes. + */ + public static class CiVirtualObjectFactory { + private int nextId = 0; + private final RiRuntime runtime; + + public CiVirtualObjectFactory(RiRuntime runtime) { + this.runtime = runtime; + } + + public CiVirtualObject constantProxy(CiKind kind, CiValue objectValue, CiValue primitiveValue) { + CiConstant cKind = CiConstant.forObject(kind); + // TODO: here the ordering is hard coded... we should query RiType.fields() and act accordingly + return new CiVirtualObject(runtime.getType(CiConstant.class), new CiValue[] {cKind, primitiveValue, CiValue.IllegalValue, objectValue}, nextId++); + } + + public CiValue proxy(CiValue ciValue) { + switch (ciValue.kind) { + case Boolean: + return new CiVirtualObject(runtime.getType(Boolean.class), new CiValue[] {ciValue}, nextId++); + case Byte: + return new CiVirtualObject(runtime.getType(Byte.class), new CiValue[] {ciValue}, nextId++); + case Char: + return new CiVirtualObject(runtime.getType(Character.class), new CiValue[] {ciValue}, nextId++); + case Double: + return new CiVirtualObject(runtime.getType(Double.class), new CiValue[] {ciValue, CiValue.IllegalValue}, nextId++); + case Float: + return new CiVirtualObject(runtime.getType(Float.class), new CiValue[] {ciValue}, nextId++); + case Int: + return new CiVirtualObject(runtime.getType(Integer.class), new CiValue[] {ciValue}, nextId++); + case Long: + return new CiVirtualObject(runtime.getType(Long.class), new CiValue[] {ciValue, CiValue.IllegalValue}, nextId++); + case Object: + return ciValue; + case Short: + return new CiVirtualObject(runtime.getType(Short.class), new CiValue[] {ciValue}, nextId++); + default: + assert false : ciValue.kind; + return null; + } + } + + public CiVirtualObject arrayProxy(RiType arrayType, CiValue[] values) { + return new CiVirtualObject(arrayType, values, nextId++); + } + + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/package-info.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,47 @@ +/* + * 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. + * + * 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 compiler-provided part of the bi-directional interface between the compiler and the runtime system of a virtual machine for the instruction set defined in + * {@link com.oracle.max.graal.compiler.graphbuilder.Bytecodes}. + * + * The target hardware architecture is represented by {@link com.oracle.max.cri.ci.CiArchitecture} and the specific target machine + * environment for a compiler instance is represented by {@link com.oracle.max.cri.ci.CiTarget}. + * <p> + * A {@code CiResult} encapsulates + * {@linkplain com.oracle.max.cri.ci.CiStatistics compilation statistics}, possible {@linkplain com.oracle.max.cri.ci.CiBailout error state} + * and the {@linkplain com.oracle.max.cri.ci.CiTargetMethod compiled code and metadata}. + * {@link com.oracle.max.cri.ci.CiCodePos} and {@link com.oracle.max.cri.ci.CiDebugInfo} provide detailed information to the + * runtime to support debugging and deoptimization of the compiled code. + * <p> + * The compiler manipulates {@link com.oracle.max.cri.ci.CiValue} instances that have a {@link com.oracle.max.cri.ci.CiKind}, and are + * immutable. A concrete {@link com.oracle.max.cri.ci.CiValue value} is one of the following subclasses: + * <ul> + * <li>{@link com.oracle.max.cri.ci.CiConstant}: a constant value. + * <li>{@link com.oracle.max.cri.ci.CiRegisterValue}: a value stored in a {@linkplain com.oracle.max.cri.ci.CiRegister target machine register}. + * <li>{@link com.oracle.max.cri.ci.CiStackSlot}: a spill slot or an outgoing stack-based argument in a method's frame. + * <li>{@link com.oracle.max.cri.ci.CiAddress}: an address in target machine memory. + * <li>{@link com.oracle.max.cri.ci.CiVariable}: a value (cf. virtual register) that is yet to be bound to a target machine location (physical register or memory address). + *</ul> + */ +package com.oracle.max.cri.ci; +
--- a/graal/com.oracle.max.cri/src/com/oracle/max/cri/intrinsics/IntrinsicIDs.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,105 +0,0 @@ -/* - * Copyright (c) 2011, 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. - * - * 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.oracle.max.cri.intrinsics; - -/** - * Definition of ID strings for general-purpose intrinsics. - */ -public class IntrinsicIDs { - /** - * Prefix of ID strings defined in this class to make them unique. - */ - private static final String p = "com.oracle.max.cri.intrinsics:"; - - /** - * Unsigned comparison aboveThan for two numbers. - * The method definition must have the following form: - * <pre> - * static boolean m(T a, T b) - * where T is one of {int, long} - * </pre> - */ - public static final String UCMP_AT = p + "UCMP_AT"; - - /** - * Unsigned comparison aboveOrEqual for two numbers. - * The method definition must have the following form: - * <pre> - * static boolean m(T a, T b) - * where T is one of {int, long} - * </pre> - */ - public static final String UCMP_AE = p + "UCMP_AE"; - - /** - * Unsigned comparison belowThan for two numbers. - * The method definition must have the following form: - * <pre> - * static boolean m(T a, T b) - * where T is one of {int, long} - * </pre> - */ - public static final String UCMP_BT = p + "UCMP_BT"; - - /** - * Unsigned comparison belowOrEqual for two numbers. - * The method definition must have the following form: - * <pre> - * static boolean m(T a, T b) - * where T is one of {int, long} - * </pre> - */ - public static final String UCMP_BE = p + "UCMP_BE"; - - /** - * Unsigned division for two numbers. - * The method definition must have the following form: - * <pre> - * static T m(T a, T b) - * where T is one of {int, long} - * </pre> - */ - public static final String UDIV = p + "UDIV"; - - /** - * Unsigned remainder for two numbers. - * The method definition must have the following form: - * <pre> - * static T m(T a, T b) - * where T is one of {int, long} - * </pre> - */ - public static final String UREM = p + "UREM"; - - /** - * Intrinsic that emits the specified memory barriers. - * The method definition must have the following form: - * <pre> - * static void barrier(@INTRINSIC.Constant int barrierSpec); - * barrierSpec: A combination of the flags {@link MemoryBarriers#LOAD_LOAD}, {@link MemoryBarriers#LOAD_STORE}, - * {@link MemoryBarriers#STORE_LOAD}, {@link MemoryBarriers#STORE_STORE}. - * This parameter must be a compile-time constant. - * </pre> - */ - public static final String MEMBAR = p + "MEMBAR"; -}
--- a/graal/com.oracle.max.cri/src/com/oracle/max/cri/intrinsics/IntrinsicImpl.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,93 +0,0 @@ -/* - * Copyright (c) 2011, 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. - * - * 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.oracle.max.cri.intrinsics; - -import java.util.*; -import java.util.Map.*; -import java.util.concurrent.*; - -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; - -/** - * Empty marker interface for intrinsic implementations. - * - * Note: It is not necessary that this class is in the CRI, it could also be part of the compiler - * implementation. However, it might be useful for different compilers, so it is here for now. - */ -public interface IntrinsicImpl { - - /** - * Registry that maps intrinsic ID strings to implementation objects. - * Intrinsic ID strings can either be explicitly defined as String constants, or inferred from the - * fully qualified name and signature of a method. - */ - public class Registry implements Iterable<Map.Entry<String, IntrinsicImpl>> { - private Map<String, IntrinsicImpl> implRegistry = new ConcurrentHashMap<>(100, 0.75f, 1); - - /** - * Add an implementation object for an explicitly defined intrinsic ID string. - */ - public void add(String intrinsicId, IntrinsicImpl impl) { - assert !implRegistry.containsKey(intrinsicId); - implRegistry.put(intrinsicId, impl); - } - - /** - * Add an implementation object for an intrinsic implicitly defined by its fully qualified name and signature. - */ - public void add(String className, String methodName, String signature, IntrinsicImpl impl) { - add(literalId(className, methodName, signature), impl); - } - - /** - * Gets the implementation object for a method. First, the {@link RiMethod#intrinsic() explicit ID string} of the - * method is searched in the registry, then the implicit ID inferred from the method name and signature. - * @return The intrinsic implementation object, or {@code null} if none is found. - */ - public IntrinsicImpl get(RiResolvedMethod method) { - String intrinsic = method.intrinsic(); - if (intrinsic != null) { - IntrinsicImpl impl = implRegistry.get(intrinsic); - if (impl != null) { - return impl; - } - } - return implRegistry.get(literalId(method)); - } - - - private static String literalId(String className, String methodName, String signature) { - return CiUtil.toInternalName(className) + methodName + signature; - } - - private static String literalId(RiMethod method) { - return method.holder().name() + method.name() + method.signature().asString(); - } - - @Override - public Iterator<Entry<String, IntrinsicImpl>> iterator() { - return implRegistry.entrySet().iterator(); - } - } -}
--- a/graal/com.oracle.max.cri/src/com/oracle/max/cri/intrinsics/MemoryBarriers.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,126 +0,0 @@ -/* - * Copyright (c) 2011, 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. - * - * 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.oracle.max.cri.intrinsics; - -import static com.oracle.max.cri.intrinsics.IntrinsicIDs.*; - -import com.sun.max.annotate.*; - -/** - * Constants and intrinsic definition for memory barriers. - * - * The documentation for each constant is taken from Doug Lea's - * <a href="http://gee.cs.oswego.edu/dl/jmm/cookbook.html">The JSR-133 Cookbook for Compiler Writers</a>. - * <p> - * The {@code JMM_*} constants capture the memory barriers necessary to implement the Java Memory Model - * with respect to volatile field accesses. Their values are explained by this - * comment from templateTable_i486.cpp in the HotSpot source code: - * <pre> - * Volatile variables demand their effects be made known to all CPU's in - * order. Store buffers on most chips allow reads & writes to reorder; the - * JMM's ReadAfterWrite.java test fails in -Xint mode without some kind of - * memory barrier (i.e., it's not sufficient that the interpreter does not - * reorder volatile references, the hardware also must not reorder them). - * - * According to the new Java Memory Model (JMM): - * (1) All volatiles are serialized wrt to each other. - * ALSO reads & writes act as acquire & release, so: - * (2) A read cannot let unrelated NON-volatile memory refs that happen after - * the read float up to before the read. It's OK for non-volatile memory refs - * that happen before the volatile read to float down below it. - * (3) Similarly, a volatile write cannot let unrelated NON-volatile memory refs - * that happen BEFORE the write float down to after the write. It's OK for - * non-volatile memory refs that happen after the volatile write to float up - * before it. - * - * We only put in barriers around volatile refs (they are expensive), not - * _between_ memory refs (which would require us to track the flavor of the - * previous memory refs). Requirements (2) and (3) require some barriers - * before volatile stores and after volatile loads. These nearly cover - * requirement (1) but miss the volatile-store-volatile-load case. This final - * case is placed after volatile-stores although it could just as well go - * before volatile-loads. - * </pre> - */ -public class MemoryBarriers { - - /** - * The sequence {@code Load1; LoadLoad; Load2} ensures that {@code Load1}'s data are loaded before data accessed - * by {@code Load2} and all subsequent load instructions are loaded. In general, explicit {@code LoadLoad} - * barriers are needed on processors that perform speculative loads and/or out-of-order processing in which - * waiting load instructions can bypass waiting stores. On processors that guarantee to always preserve load - * ordering, these barriers amount to no-ops. - */ - public static final int LOAD_LOAD = 0x0001; - - /** - * The sequence {@code Load1; LoadStore; Store2} ensures that {@code Load1}'s data are loaded before all data - * associated with {@code Store2} and subsequent store instructions are flushed. {@code LoadStore} barriers are - * needed only on those out-of-order processors in which waiting store instructions can bypass loads. - */ - public static final int LOAD_STORE = 0x0002; - - /** - * The sequence {@code Store1; StoreLoad; Load2} ensures that {@code Store1}'s data are made visible to other - * processors (i.e., flushed to main memory) before data accessed by {@code Load2} and all subsequent load - * instructions are loaded. {@code StoreLoad} barriers protect against a subsequent load incorrectly using - * {@code Store1}'s data value rather than that from a more recent store to the same location performed by a - * different processor. Because of this, on the processors discussed below, a {@code StoreLoad} is strictly - * necessary only for separating stores from subsequent loads of the same location(s) as were stored before the - * barrier. {@code StoreLoad} barriers are needed on nearly all recent multiprocessors, and are usually the most - * expensive kind. Part of the reason they are expensive is that they must disable mechanisms that ordinarily - * bypass cache to satisfy loads from write-buffers. This might be implemented by letting the buffer fully - * flush, among other possible stalls. - */ - public static final int STORE_LOAD = 0x0004; - - /** - * The sequence {@code Store1; StoreStore; Store2} ensures that {@code Store1}'s data are visible to other - * processors (i.e., flushed to memory) before the data associated with {@code Store2} and all subsequent store - * instructions. In general, {@code StoreStore} barriers are needed on processors that do not otherwise - * guarantee strict ordering of flushes from write buffers and/or caches to other processors or main memory. - */ - public static final int STORE_STORE = 0x0008; - - public static final int JMM_PRE_VOLATILE_WRITE = LOAD_STORE | STORE_STORE; - public static final int JMM_POST_VOLATILE_WRITE = STORE_LOAD | STORE_STORE; - public static final int JMM_PRE_VOLATILE_READ = 0; - public static final int JMM_POST_VOLATILE_READ = LOAD_LOAD | LOAD_STORE; - - - /** - * @see IntrinsicIDs#MEMBAR - */ - @INTRINSIC(MEMBAR) - public static native void barrier(@INTRINSIC.Constant int barrierSpec); - - - public static String barriersString(int barriers) { - StringBuilder sb = new StringBuilder(); - sb.append((barriers & LOAD_LOAD) != 0 ? "LOAD_LOAD " : ""); - sb.append((barriers & LOAD_STORE) != 0 ? "LOAD_STORE " : ""); - sb.append((barriers & STORE_LOAD) != 0 ? "STORE_LOAD " : ""); - sb.append((barriers & STORE_STORE) != 0 ? "STORE_STORE " : ""); - return sb.toString().trim(); - } -}
--- a/graal/com.oracle.max.cri/src/com/oracle/max/cri/intrinsics/UnsignedMath.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,142 +0,0 @@ -/* - * Copyright (c) 2011, 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. - * - * 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.oracle.max.cri.intrinsics; - -import static com.oracle.max.cri.intrinsics.IntrinsicIDs.*; - -import java.math.*; - -import com.sun.max.annotate.*; - -/** - * {@link INTRINSIC} method definitions for unsigned comparisons. - * All methods have correct, but slow, standard Java implementations so that - * they can be used with compilers not supporting the intrinsics. - */ -public class UnsignedMath { - private static final long MASK = 0xffffffffL; - - /** - * @see IntrinsicIDs#UCMP_AT - */ - @INTRINSIC(UCMP_AT) - public static boolean aboveThan(int a, int b) { - return (a & MASK) > (b & MASK); - } - - /** - * @see IntrinsicIDs#UCMP_AE - */ - @INTRINSIC(UCMP_AE) - public static boolean aboveOrEqual(int a, int b) { - return (a & MASK) >= (b & MASK); - } - - /** - * @see IntrinsicIDs#UCMP_BT - */ - @INTRINSIC(UCMP_BT) - public static boolean belowThan(int a, int b) { - return (a & MASK) < (b & MASK); - } - - /** - * @see IntrinsicIDs#UCMP_BE - */ - @INTRINSIC(UCMP_BE) - public static boolean belowOrEqual(int a, int b) { - return (a & MASK) <= (b & MASK); - } - - - /** - * @see IntrinsicIDs#UCMP_AT - */ - @INTRINSIC(UCMP_AT) - public static boolean aboveThan(long a, long b) { - return (a > b) ^ ((a < 0) != (b < 0)); - } - - /** - * @see IntrinsicIDs#UCMP_AE - */ - @INTRINSIC(UCMP_AE) - public static boolean aboveOrEqual(long a, long b) { - return (a >= b) ^ ((a < 0) != (b < 0)); - } - - /** - * @see IntrinsicIDs#UCMP_BT - */ - @INTRINSIC(UCMP_BT) - public static boolean belowThan(long a, long b) { - return (a < b) ^ ((a < 0) != (b < 0)); - } - - /** - * @see IntrinsicIDs#UCMP_BE - */ - @INTRINSIC(UCMP_BE) - public static boolean belowOrEqual(long a, long b) { - return (a <= b) ^ ((a < 0) != (b < 0)); - } - - - /** - * @see IntrinsicIDs#UDIV - */ - @INTRINSIC(UDIV) - public static int divide(int a, int b) { - return (int) ((a & MASK) / (b & MASK)); - } - - /** - * @see IntrinsicIDs#UREM - */ - @INTRINSIC(UREM) - public static int remainder(int a, int b) { - return (int) ((a & MASK) % (b & MASK)); - } - - - /** - * @see IntrinsicIDs#UDIV - */ - @INTRINSIC(UDIV) - public static long divide(long a, long b) { - return bi(a).divide(bi(b)).longValue(); - } - - /** - * @see IntrinsicIDs#UREM - */ - @INTRINSIC(UREM) - public static long remainder(long a, long b) { - return bi(a).remainder(bi(b)).longValue(); - } - - private static BigInteger bi(long unsigned) { - return unsigned >= 0 ? BigInteger.valueOf(unsigned) : BigInteger.valueOf(unsigned & 0x7fffffffffffffffL).setBit(63); - } -} -
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/package-info.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,38 @@ +/* + * 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. + * + * 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. + */ +/** + * A virtual machine compiler-runtime interface (CRI). + * <p> + * Specifically, this package defines an interface between the compiler and the runtime system of a virtual machine for + * the instruction set defined in {@link com.oracle.max.graal.compiler.graphbuilder.Bytecodes}. The interface has three components: + * <ol> + * <li>the {@link com.oracle.max.cri.ci compiler-provided interface} that must be used by the runtime. + * <li>the {@link com.oracle.max.cri.ri runtime-provided interface} that must be used by the compiler. + * <li>the {@link com.oracle.max.cri.xir XIR interface} for translating object operations. + * </ol> + * + * The interface is independent of any particular compiler or runtime implementation. + * <p> + * For more details see <a href="http://wikis.sun.com/download/attachments/173802383/vee2010.pdf">Improving Compiler-Runtime Separation with XIR</a>. + */ +package com.oracle.max.cri;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiCompiledMethod.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,40 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +/** + * Represents a compiled instance of a method. It may have been invalidated or removed in the meantime. + */ +public interface RiCompiledMethod { + + /** + * Returns the method to which the compiled code belongs. + * @return the method to which the compiled code belongs. + */ + RiResolvedMethod method(); + + /** + * @return true if the code represented by this object is still valid, false otherwise (may happen due to deopt, etc.) + */ + boolean isValid(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiConstantPool.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,93 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +/** + * Represents the runtime representation of the constant pool that is + * used by the compiler when parsing bytecode. The {@code lookupXXX} methods look up a constant + * pool entry without performing resolution, and are used during compilation. + */ +public interface RiConstantPool { + + /** + * Makes sure that the type referenced by the specified constant pool entry is loaded and + * initialized. This can be used to compile time resolve a type. It works for field, method, + * or type constant pool entries. + * @param cpi the index of the constant pool entry that references the type + * @param opcode the opcode of the instruction that references the type + */ + void loadReferencedType(int cpi, int opcode); + + /** + * Looks up a reference to a field. If {@code opcode} is non-negative, then resolution checks + * specific to the JVM instruction it denotes are performed if the field is already resolved. + * Should any of these checks fail, an {@linkplain RiField#isResolved() unresolved} + * field reference is returned. + * + * @param cpi the constant pool index + * @param opcode the opcode of the instruction for which the lookup is being performed or {@code -1} + * @return a reference to the field at {@code cpi} in this pool + * @throws ClassFormatError if the entry at {@code cpi} is not a field + */ + RiField lookupField(int cpi, int opcode); + + /** + * Looks up a reference to a method. If {@code opcode} is non-negative, then resolution checks + * specific to the JVM instruction it denotes are performed if the method is already resolved. + * Should any of these checks fail, an {@linkplain RiMethod#isResolved() unresolved} + * method reference is returned. + * + * @param cpi the constant pool index + * @param opcode the opcode of the instruction for which the lookup is being performed or {@code -1} + * @return a reference to the method at {@code cpi} in this pool + * @throws ClassFormatError if the entry at {@code cpi} is not a method + */ + RiMethod lookupMethod(int cpi, int opcode); + + /** + * Looks up a reference to a type. If {@code opcode} is non-negative, then resolution checks + * specific to the JVM instruction it denotes are performed if the type is already resolved. + * Should any of these checks fail, an {@linkplain RiType#isResolved() unresolved} + * type reference is returned. + * + * @param cpi the constant pool index + * @param opcode the opcode of the instruction for which the lookup is being performed or {@code -1} + * @return a reference to the compiler interface type + */ + RiType lookupType(int cpi, int opcode); + + /** + * Looks up a method signature. + * + * @param cpi the constant pool index + * @return the method signature at index {@code cpi} in this constant pool + */ + RiSignature lookupSignature(int cpi); + + /** + * Looks up a constant at the specified index. + * @param cpi the constant pool index + * @return the {@code CiConstant} instance representing the constant + */ + Object lookupConstant(int cpi); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiExceptionHandler.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,67 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +/** + * Represents an exception handler within the bytecode. + */ +public interface RiExceptionHandler { + + /** + * Gets the start bytecode index of the protected range of this handler. + * @return the start bytecode index + */ + int startBCI(); + + /** + * Gets the end bytecode index of the protected range of this handler. + * @return the end bytecode index + */ + int endBCI(); + + /** + * Gets the bytecode index of the handler block of this handler. + * @return the handler block bytecode index + */ + int handlerBCI(); + + /** + * Gets the index into the constant pool representing the type of exception + * caught by this handler. + * @return the constant pool index of the catch type + */ + int catchTypeCPI(); + + /** + * Checks whether this handler catches all exceptions. + * @return {@code true} if this handler catches all exceptions + */ + boolean isCatchAll(); + + /** + * The type of exception caught by this exception handler. + * + * @return the exception type + */ + RiType catchType(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiField.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,59 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + + +import com.oracle.max.cri.ci.*; + +/** + * Represents a reference to a field, including both resolved and unresolved fields. Fields, like methods and types, are + * resolved through {@link RiConstantPool constant pools}, and their actual implementation is provided by the + * {@link RiRuntime runtime} to the compiler. + */ +public interface RiField { + /** + * Gets the name of this field as a string. + * @return the name of this field + */ + String name(); + + /** + * Gets the type of this field as a compiler-runtime interface type. + * @return the type of this field + */ + RiType type(); + + /** + * Gets the kind of this field. + * @param architecture When true, the architecture-specific kind used for emitting machine code is returned. + * When false, the kind according to the Java specification is returned. + * @return the kind + */ + CiKind kind(boolean architecture); + + /** + * Gets the holder of this field as a compiler-runtime interface type. + * @return the holder of this field + */ + RiType holder(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiMethod.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,49 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +/** + * Represents resolved and unresolved methods. Methods, like fields and types, are resolved through + * {@link RiConstantPool constant pools}, and their actual implementation is provided by the {@link RiRuntime runtime} + * to the compiler. + */ +public interface RiMethod { + + /** + * Gets the name of the method as a string. + * @return the name of the method + */ + String name(); + + /** + * Gets the type in which this method is declared. + * @return the type in which this method is declared + */ + RiType holder(); + + /** + * Gets the signature of the method. + * @return the signature of the method + */ + RiSignature signature(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiRegisterAttributes.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,97 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +import java.util.*; + +import com.oracle.max.cri.ci.*; + +/** + * A collection of register attributes. The specific attribute values for a register may be + * local to a compilation context. For example, a {@link RiRegisterConfig} in use during + * a compilation will determine which registers are callee saved. + */ +public class RiRegisterAttributes { + + /** + * Denotes a register whose value preservation (if required) across a call is the responsibility of the caller. + */ + public final boolean isCallerSave; + + /** + * Denotes a register whose value preservation (if required) across a call is the responsibility of the callee. + */ + public final boolean isCalleeSave; + + /** + * Denotes a register that is available for use by a register allocator. + */ + public final boolean isAllocatable; + + /** + * Denotes a register guaranteed to be non-zero if read in compiled Java code. + * For example, a register dedicated to holding the current thread. + */ + public boolean isNonZero; + + public RiRegisterAttributes(boolean isCallerSave, boolean isCalleeSave, boolean isAllocatable) { + this.isCallerSave = isCallerSave; + this.isCalleeSave = isCalleeSave; + this.isAllocatable = isAllocatable; + } + + public static final RiRegisterAttributes NONE = new RiRegisterAttributes(false, false, false); + + /** + * Creates a map from register {@linkplain CiRegister#number numbers} to register + * {@linkplain RiRegisterAttributes attributes} for a given register configuration and set of + * registers. + * + * @param registerConfig a register configuration + * @param registers a set of registers + * @return an array whose length is the max register number in {@code registers} plus 1. An element at index i holds + * the attributes of the register whose number is i. + */ + public static RiRegisterAttributes[] createMap(RiRegisterConfig registerConfig, CiRegister[] registers) { + RiRegisterAttributes[] map = new RiRegisterAttributes[registers.length]; + for (CiRegister reg : registers) { + if (reg != null) { + CiCalleeSaveLayout csl = registerConfig.getCalleeSaveLayout(); + RiRegisterAttributes attr = new RiRegisterAttributes( + Arrays.asList(registerConfig.getCallerSaveRegisters()).contains(reg), + csl == null ? false : Arrays.asList(csl.registers).contains(reg), + Arrays.asList(registerConfig.getAllocatableRegisters()).contains(reg)); + if (map.length <= reg.number) { + map = Arrays.copyOf(map, reg.number + 1); + } + map[reg.number] = attr; + } + } + for (int i = 0; i < map.length; i++) { + if (map[i] == null) { + map[i] = NONE; + } + } + return map; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiRegisterConfig.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,113 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +import java.util.*; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiCallingConvention.*; +import com.oracle.max.cri.ci.CiRegister.*; + +/** + * A register configuration binds roles and {@linkplain RiRegisterAttributes attributes} + * to physical registers. + */ +public interface RiRegisterConfig { + + /** + * Gets the register to be used for returning a value of a given kind. + */ + CiRegister getReturnRegister(CiKind kind); + + /** + * Gets the register to which {@link CiRegister#Frame} and {@link CiRegister#CallerFrame} are bound. + */ + CiRegister getFrameRegister(); + + CiRegister getScratchRegister(); + + /** + * Gets the calling convention describing how arguments are passed. + * + * @param type the type of calling convention being requested + * @param parameters the types of the arguments of the call + * @param target the target platform + * @param stackOnly ignore registers + */ + CiCallingConvention getCallingConvention(Type type, CiKind[] parameters, CiTarget target, boolean stackOnly); + + /** + * Gets the ordered set of registers that are can be used to pass parameters + * according to a given calling convention. + * + * @param type the type of calling convention + * @param flag specifies whether registers for {@linkplain RegisterFlag#CPU integral} or + * {@linkplain} RegisterFlag#FPU floating point} parameters are being requested + * @return the ordered set of registers that may be used to pass parameters in a call conforming to {@code type} + */ + CiRegister[] getCallingConventionRegisters(Type type, RegisterFlag flag); + + /** + * Gets the set of registers that can be used by the register allocator. + */ + CiRegister[] getAllocatableRegisters(); + + /** + * Gets the set of registers that can be used by the register allocator, + * {@linkplain CiRegister#categorize(CiRegister[]) categorized} by register {@linkplain RegisterFlag flags}. + * + * @return a map from each {@link RegisterFlag} constant to the list of {@linkplain #getAllocatableRegisters() + * allocatable} registers for which the flag is {@linkplain #isSet(RegisterFlag) set} + * + */ + EnumMap<RegisterFlag, CiRegister[]> getCategorizedAllocatableRegisters(); + + /** + * Gets the registers whose values must be preserved by a method across any call it makes. + */ + CiRegister[] getCallerSaveRegisters(); + + /** + * Gets the layout of the callee save area of this register configuration. + * + * @return {@code null} if there is no callee save area + */ + CiCalleeSaveLayout getCalleeSaveLayout(); + + /** + * Gets a map from register {@linkplain CiRegister#number numbers} to register + * {@linkplain RiRegisterAttributes attributes} for this register configuration. + * + * @return an array where an element at index i holds the attributes of the register whose number is i + * @see CiRegister#categorize(CiRegister[]) + */ + RiRegisterAttributes[] getAttributesMap(); + + /** + * Gets the register corresponding to a runtime-defined role. + * + * @param id the identifier of a runtime-defined register role + * @return the register playing the role specified by {@code id} + */ + CiRegister getRegisterForRole(int id); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiResolvedField.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,65 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +import java.lang.annotation.*; +import java.lang.reflect.*; + +import com.oracle.max.cri.ci.*; + +/** + * Represents a reference to a resolved field. Fields, like methods and types, are + * resolved through {@link RiConstantPool constant pools}, and their actual implementation is provided by the + * {@link RiRuntime runtime} to the compiler. + */ +public interface RiResolvedField extends RiField { + + /** + * Gets the access flags for this field. Only the flags specified in the JVM specification + * will be included in the returned mask. The utility methods in the {@link Modifier} class + * should be used to query the returned mask for the presence/absence of individual flags. + * @return the mask of JVM defined field access flags defined for this field + */ + int accessFlags(); + + /** + * Gets the constant value of this field if available. + * @param receiver object from which this field's value is to be read. This value is ignored if this field is static. + * @return the constant value of this field or {@code null} if the constant value is not available + */ + CiConstant constantValue(CiConstant receiver); + + /** + * Gets the holder of this field as a compiler-runtime interface type. + * @return the holder of this field + */ + RiResolvedType holder(); + + /** + * Returns this field's annotation of a specified type. + * + * @param annotationClass the Class object corresponding to the annotation type + * @return the annotation of type {@code annotationClass} for this field if present, else null + */ + <T extends Annotation> T getAnnotation(Class<T> annotationClass); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiResolvedMethod.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,228 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +import java.lang.annotation.*; +import java.lang.reflect.*; +import java.util.*; + +import com.oracle.max.cri.ci.*; + + +/** + * Represents resolved methods. Methods, like fields and types, are resolved through + * {@link RiConstantPool constant pools}, and their actual implementation is provided by the {@link RiRuntime runtime} + * to the compiler. + */ +public interface RiResolvedMethod extends RiMethod { + + /** + * Gets the bytecode of the method, if the method {@linkplain #isResolved()} and has code. + * @return the bytecode of the method or {@code null} if none is available + */ + byte[] code(); + + /** + * Gets the size of the bytecode of the method, if the method {@linkplain #isResolved()} and has code. + * @return the size of the bytecode in bytes, or 0 if no bytecode is available + */ + int codeSize(); + + /** + * Gets the symbol used to link this method if it is native, otherwise {@code null}. + */ + String jniSymbol(); + + /** + * Gets the type in which this method is declared. + * @return the type in which this method is declared + */ + RiResolvedType holder(); + + /** + * Gets the maximum number of locals used in this method's bytecode. + * @return the maximum number of locals + */ + int maxLocals(); + + /** + * Gets the maximum number of stack slots used in this method's bytecode. + * @return the maximum number of stack slots + */ + int maxStackSize(); + + /** + * Checks whether this method has balanced monitor operations. + * @return {@code true} if the method has balanced monitor operations + */ + boolean hasBalancedMonitors(); + + /** + * Gets the access flags for this method. Only the flags specified in the JVM specification + * will be included in the returned mask. The utility methods in the {@link Modifier} class + * should be used to query the returned mask for the presence/absence of individual flags. + * @return the mask of JVM defined method access flags defined for this method + */ + int accessFlags(); + + /** + * Checks whether this method is a leaf method. + * @return {@code true} if the method is a leaf method (that is, is final or private) + */ + boolean isLeafMethod(); + + /** + * Checks whether this method is a class initializer. + * @return {@code true} if the method is a class initializer + */ + boolean isClassInitializer(); + + /** + * Checks whether this method is a constructor. + * @return {@code true} if the method is a constructor + */ + boolean isConstructor(); + + /** + * Checks whether this method has been overridden. Decisions made based + * on a method being overridden must be registered as dependencies. + * @return {@code true} if the method has been overridden + */ + boolean isOverridden(); + + /** + * Checks whether the compiler can insert safepoint polls in this method. + * @return {@code true} if the method cannot have safepoint polls inserted + */ + boolean noSafepointPolls(); + + /** + * Gets a map from bytecode indexes to bit maps denoting the live locals at that position. + * If a non-null array is return, its length is guaranteed to be equal to {@code code().length}. + * + * @return the liveness map if it is available; {@code null} otherwise + */ + CiBitMap[] livenessMap(); + + /** + * Checks whether this method can be statically bound (that is, it is final or private or static). + * @return {@code true} if this method can be statically bound + */ + boolean canBeStaticallyBound(); + + /** + * Gets the list of exception handlers for this method. + * @return the list of exception handlers + */ + RiExceptionHandler[] exceptionHandlers(); + + /** + * Gets a stack trace element for this method and a given bytecode index. + */ + StackTraceElement toStackTraceElement(int bci); + + /** + * Temporary work-around to support the @ACCESSOR Maxine annotation. + * Non-Maxine VMs should just return {@code null}. + */ + RiResolvedType accessor(); + + /** + * Gets the intrinsic id of this method. + */ + String intrinsic(); + + /** + * Provides an estimate of how often this method has been executed. + * @return The number of invocations, or -1 if this information isn't available. + */ + int invocationCount(); + + /** + * Returns an estimate of hot often an exception was seen at the given bytecode. + * @return The estimate in percent (0-100), with 0 meaning never and 100 meaning always, or -1 if this information isn't available. + */ + int exceptionProbability(int bci); + + /** + * Returns the type profile of the instruction at the given byte code index. + * @return The RiTypeProfile information, or null if it isn't available. + */ + RiTypeProfile typeProfile(int bci); + + /** + * Returns an estimate of how often the branch at the given byte code was taken. + * @return The estimated probability, with 0.0 meaning never and 1.0 meaning always, or -1 if this information isn't available. + */ + double branchProbability(int bci); + + /** + * Returns an estimate of how often the branches of the switch at the given byte code were taken. + * @return The estimated probability, with 0.0 meaning never and 1.0 meaning always, or NULL if this information isn't available. + * The default case is specified at the last index. + */ + double[] switchProbability(int bci); + + /** + * Returns a map that the compiler can use to store objects that should survive the current compilation. + */ + Map<Object, Object> compilerStorage(); + + /** + * Returns a pointer to the method's constant pool. + * @return the constant pool + */ + RiConstantPool getConstantPool(); + + /** + * Returns this method's annotation of a specified type. + * + * @param annotationClass the Class object corresponding to the annotation type + * @return the annotation of type {@code annotationClass} for this method if present, else null + */ + <T extends Annotation> T getAnnotation(Class<T> annotationClass); + + /** + * Returns an array of arrays that represent the annotations on the formal + * parameters, in declaration order, of this method. + * + * @see Method#getParameterAnnotations() + * @see CiUtil#getParameterAnnotation(int, RiResolvedMethod) + */ + Annotation[][] getParameterAnnotations(); + + /** + * Returns an array of {@link Type} objects that represent the formal + * parameter types, in declaration order, of this method. + * + * @see Method#getGenericParameterTypes() + */ + Type[] getGenericParameterTypes(); + + /** + * Returns a {@link Type} object that represents the formal return type of this method. + * + * @see Method#getGenericReturnType() + */ + Type getGenericReturnType(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiResolvedType.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,183 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +import java.lang.annotation.*; +import java.lang.reflect.*; + +import com.oracle.max.cri.ci.*; + +/** + * Represents a resolved in the compiler-runtime interface. Types include primitives, objects, {@code void}, + * and arrays thereof. Types, like fields and methods, are resolved through {@link RiConstantPool constant pools}, and + * their actual implementation is provided by the {@link RiRuntime runtime} to the compiler. + */ +public interface RiResolvedType extends RiType { + + /** + * Gets the encoding of (that is, a constant representing the value of) the specified part of this type. + * @param r the part of the this type + * @return a constant representing a reference to the specified part of this type + */ + CiConstant getEncoding(Representation r); + + /** + * Checks whether this type has any subclasses so far. Any decisions + * based on this information require the registration of a dependency, since + * this information may change. + * @return {@code true} if this class has subclasses + */ + boolean hasSubclass(); + + /** + * Checks whether this type has a finalizer method. + * @return {@code true} if this class has a finalizer + */ + boolean hasFinalizer(); + + /** + * Checks whether this type has any finalizable subclasses so far. Any decisions + * based on this information require the registration of a dependency, since + * this information may change. + * @return {@code true} if this class has any subclasses with finalizers + */ + boolean hasFinalizableSubclass(); + + /** + * Checks whether this type is an interface. + * @return {@code true} if this type is an interface + */ + boolean isInterface(); + + /** + * Checks whether this type is an instance class. + * @return {@code true} if this type is an instance class + */ + boolean isInstanceClass(); + + /** + * Checks whether this type is an array class. + * @return {@code true} if this type is an array class + */ + boolean isArrayClass(); + + /** + * Gets the access flags for this type. Only the flags specified in the JVM specification + * will be included in the returned mask. The utility methods in the {@link Modifier} class + * should be used to query the returned mask for the presence/absence of individual flags. + * @return the mask of JVM defined class access flags defined for this type + */ + int accessFlags(); + + /** + * Checks whether this type is initialized. + * @return {@code true} if this type is initialized + */ + boolean isInitialized(); + + /** + * Checks whether this type is a subtype of another type. + * @param other the type to test + * @return {@code true} if this type a subtype of the specified type + */ + boolean isSubtypeOf(RiResolvedType other); + + /** + * Checks whether the specified object is an instance of this type. + * @param obj the object to test + * @return {@code true} if the object is an instance of this type + */ + boolean isInstance(CiConstant obj); + + /** + * Attempts to get an exact type for this type. Final classes, + * arrays of final classes, and primitive types all have exact types. + * @return the exact type of this type, if it exists; {@code null} otherwise + */ + RiResolvedType exactType(); + + /** + * Gets the super type of this type or {@code null} if no such type exists. + */ + RiResolvedType superType(); + + /** + * Attempts to get the unique concrete subtype of this type. + * @return the exact type of this type, if it exists; {@code null} otherwise + */ + RiResolvedType uniqueConcreteSubtype(); + + /** + * For array types, gets the type of the components. + * @return the component type of this array type + */ + RiResolvedType componentType(); + + /** + * Gets the type representing an array with elements of this type. + * @return a new compiler interface type representing an array of this type + */ + RiResolvedType arrayOf(); + + /** + * Resolves the method implementation for virtual dispatches on objects + * of this dynamic type. + * @param method the method to select the implementation of + * @return the method implementation that would be selected at runtime + */ + RiResolvedMethod resolveMethodImpl(RiResolvedMethod method); + + /** + * Given an RiMethod a, returns a concrete RiMethod b that is the only possible + * unique target for a virtual call on a(). Returns {@code null} if either no + * such concrete method or more than one such method exists. Returns the method a + * if a is a concrete method that is not overridden. If the compiler uses the + * result of this method for its compilation, it must register an assumption + * (see {@link CiAssumptions}), because dynamic class loading can invalidate + * the result of this method. + * @param method the method a for which a unique concrete target is searched + * @return the unique concrete target or {@code null} if no such target exists + * or assumptions are not supported by this runtime + */ + RiResolvedMethod uniqueConcreteMethod(RiResolvedMethod method); + + /** + * Returns the instance fields declared in this class sorted by field offset. + * @return an array of instance fields + */ + RiResolvedField[] declaredFields(); + + /** + * Returns this type's annotation of a specified type. + * + * @param annotationClass the Class object corresponding to the annotation type + * @return the annotation of type {@code annotationClass} for this type if present, else null + */ + <T extends Annotation> T getAnnotation(Class<T> annotationClass); + + /** + * Returns the java.lang.Class object representing this RiType instance or {@code null} if none exists. + * @return the java.lang.Class object + */ + Class<?> toJava(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiRuntime.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,196 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +import java.lang.reflect.*; + +import com.oracle.max.cri.ci.*; + +/** + * Encapsulates the main functionality of the runtime for the compiler, including access + * to constant pools, OSR frames, inlining requirements, and runtime calls such as checkcast. +s */ +public interface RiRuntime { + + /** + * Offset of the lock within the lock object on the stack. + + * Note: superseded by sizeOfLockData() in Graal. + * + * @return the offset in bytes + */ + int basicObjectLockOffsetInBytes(); + + /** + * Get the size in bytes of a lock object on the stack. + * + * Note: superseded by sizeOfLockData() in Graal. + */ + int sizeOfBasicObjectLock(); + + /** + * Get the size in bytes for locking information on the stack. + */ + int sizeOfLockData(); + + /** + * The offset of the normal entry to the code. The compiler inserts NOP instructions to satisfy this constraint. + * + * @return the code offset in bytes + */ + int codeOffset(); + + /** + * Returns the disassembly of the given code bytes. Used for debugging purposes only. + * + * @param code the code bytes that should be disassembled + * @param address an address at which the bytes are located. This can be used for an address prefix per line of disassembly. + * @return the disassembly. This will be of length 0 if the runtime does not support disassembling. + */ + String disassemble(byte[] code, long address); + + /** + * Returns the disassembly of the given code bytes. Used for debugging purposes only. + * + * @param targetMethod the {@link CiTargetMethod} containing the code bytes that should be disassembled + * @return the disassembly. This will be of length 0 if the runtime does not support disassembling. + */ + String disassemble(CiTargetMethod targetMethod); + + /** + * Returns the disassembly of the given method in a {@code javap}-like format. + * Used for debugging purposes only. + * + * @param method the method that should be disassembled + * @return the disassembly. This will be of length 0 if the runtime does not support disassembling. + */ + String disassemble(RiResolvedMethod method); + + /** + * Registers the given compiler stub and returns an object that can be used to identify it in the relocation + * information. + * + * @param targetMethod the target method representing the code of the compiler stub + * @param name the name of the stub, used for debugging purposes only + * @return the identification object + */ + Object registerCompilerStub(CiTargetMethod targetMethod, String name); + + /** + * Returns the RiType object representing the base type for the given kind. + */ + RiResolvedType asRiType(CiKind kind); + + /** + * Returns the type of the given constant object. + * + * @return {@code null} if {@code constant.isNull() || !constant.kind.isObject()} + */ + RiResolvedType getTypeOf(CiConstant constant); + + + RiResolvedType getType(Class<?> clazz); + + /** + * Returns true if the given type is a subtype of java/lang/Throwable. + */ + boolean isExceptionType(RiResolvedType type); + + /** + * Used by the canonicalizer to compare objects, since a given runtime might not want to expose the real objects to the compiler. + * + * @return true if the two parameters represent the same runtime object, false otherwise + */ + boolean areConstantObjectsEqual(CiConstant x, CiConstant y); + + /** + * Gets the register configuration to use when compiling a given method. + * + * @param method the top level method of a compilation + */ + RiRegisterConfig getRegisterConfig(RiMethod method); + + /** + * Custom area on the stack of each compiled method that the VM can use for its own purposes. + * @return the size of the custom area in bytes + */ + int getCustomStackAreaSize(); + + /** + * Minimum size of the stack area reserved for outgoing parameters. This area is reserved in all cases, even when + * the compiled method has no regular call instructions. + * @return the minimum size of the outgoing parameter area in bytes + */ + int getMinimumOutgoingSize(); + + /** + * Gets the length of the array that is wrapped in a CiConstant object. + */ + int getArrayLength(CiConstant array); + + /** + * Converts the given CiConstant object to a object. + * + * @return {@code null} if the conversion is not possible <b>OR</b> {@code c.isNull() == true} + */ + Object asJavaObject(CiConstant c); + + /** + * Converts the given CiConstant object to a {@link Class} object. + * + * @return {@code null} if the conversion is not possible. + */ + Class<?> asJavaClass(CiConstant c); + + /** + * Performs any runtime-specific conversion on the object used to describe the target of a call. + */ + Object asCallTarget(Object target); + + /** + * Returns the maximum absolute offset of a runtime call target from any position in the code cache or -1 + * when not known or not applicable. Intended for determining the required size of address/offset fields. + */ + long getMaxCallTargetOffset(CiRuntimeCall rtcall); + + /** + * Provides the {@link RiMethod} for a {@link Method} obtained via reflection. + */ + RiResolvedMethod getRiMethod(Method reflectionMethod); + + /** + * Installs some given machine code as the implementation of a given method. + * + * @param method a method whose executable code is being modified + * @param code the code to be executed when {@code method} is called + */ + void installMethod(RiMethod method, CiTargetMethod code); + + /** + * Adds the given machine code as an implementation of the given method without making it the default implementation. + * @param method a method to which the executable code is begin added + * @param code the code to be added + * @return a reference to the compiled and ready-to-run code + */ + RiCompiledMethod addMethod(RiResolvedMethod method, CiTargetMethod code); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiSignature.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,95 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +import com.oracle.max.cri.ci.*; + +/** + * Represents a method signature provided by the runtime. + * + * @see <a href="http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html#7035">Method Descriptors</a> + */ +public interface RiSignature { + /** + * Gets the number of arguments in this signature, adding 1 for a receiver if requested. + * + * @param receiver true if 1 is to be added to the result for a receiver + * @return the number of arguments + 1 iff {@code receiver == true} + */ + int argumentCount(boolean receiver); + + /** + * Gets the argument type at the specified position. This method will return a + * {@linkplain RiType#isResolved() resolved} type if possible but without + * triggering any class loading or resolution. + * + * @param index the index into the parameters, with {@code 0} indicating the first parameter + * @param accessingClass the context of the type lookup. If accessing class is resolved, its class loader + * is used to retrieve an existing resolved type. This value can be {@code null} if the caller does + * not care for a resolved type. + * @return the {@code index}'th argument type + */ + RiType argumentTypeAt(int index, RiType accessingClass); + + /** + * Gets the argument kind at the specified position. + * @param index the index into the parameters, with {@code 0} indicating the first parameter + * @param architecture When true, the architecture-specific kind used for emitting machine code is returned. + * When false, the kind according to the Java specification is returned. + * @return the kind of the argument at the specified position + */ + CiKind argumentKindAt(int index, boolean architecture); + + /** + * Gets the return type of this signature. This method will return a + * {@linkplain RiResolvedType resolved} type if possible but without + * triggering any class loading or resolution. + * + * @param accessingClass the context of the type lookup. If accessing class is resolved, its class loader + * is used to retrieve an existing resolved type. This value can be {@code null} if the caller does + * not care for a resolved type. + * @return the compiler interface type representing the return type + */ + RiType returnType(RiType accessingClass); + + /** + * Gets the return kind of this signature. + * @param architectureSpecific When true, the architecture-specific kind used for emitting machine code is returned. + * When false, the kind according to the Java specification is returned. + * @return the return kind + */ + CiKind returnKind(boolean architectureSpecific); + + /** + * Converts this signature to a string. + * @return the signature as a string + */ + String asString(); + + /** + * Gets the size, in Java slots, of the arguments to this signature. + * @param withReceiver {@code true} if to add a slot for a receiver object; {@code false} not to include the receiver + * @return the size of the arguments in slots + */ + int argumentSlots(boolean withReceiver); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiType.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,100 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +import com.oracle.max.cri.ci.*; + +/** + * Represents a resolved or unresolved type in the compiler-runtime interface. Types include primitives, objects, {@code void}, + * and arrays thereof. + */ +public interface RiType { + + /** + * Represents each of the several different parts of the runtime representation of + * a type which compiled code may need to reference individually. These may or may not be + * different objects or data structures, depending on the runtime system. + */ + public enum Representation { + /** + * The runtime representation of the data structure containing the static fields of this type. + */ + StaticFields, + + /** + * The runtime representation of the Java class object of this type. + */ + JavaClass, + + /** + * The runtime representation of the "hub" of this type--that is, the closest part of the type + * representation which is typically stored in the object header. + */ + ObjectHub, + + /** + * The runtime representation of the type information for an object, which is typically used + * for subtype tests. + */ + TypeInfo + } + + /** + * Gets the name of this type in internal form. The following are examples of strings returned by this method: + * <pre> + * "Ljava/lang/Object;" + * "I" + * "[[B" + * </pre> + * + * @return the name of this type in internal form + */ + String name(); + + /** + * For array types, gets the type of the components. + * @return the component type of this array type + */ + RiType componentType(); + + /** + * Gets the type representing an array with elements of this type. + * @return a new compiler interface type representing an array of this type + */ + RiType arrayOf(); + + /** + * Gets the kind of this compiler interface type. + * @param architecture When true, the architecture-specific kind used for emitting machine code is returned. + * When false, the kind according to the Java specification is returned. + * @return the kind + */ + CiKind kind(boolean architecture); + + /** + * Gets the kind used to represent the specified part of this type. + * @param r the part of the this type + * @return the kind of constants for the specified part of the type + */ + CiKind getRepresentationKind(Representation r); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/RiTypeProfile.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,61 @@ +/* + * 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. + * + * 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.oracle.max.cri.ri; + +import java.io.*; + +/** + * This profile object represents the type profile of one call site, cast or instanceof instruction. The precision of + * the supplied values may vary, but a runtime that provides this information should be aware that it will be used to + * guide performance-critical decisions like speculative inlining, etc. + */ +public class RiTypeProfile implements Serializable { + + /** + * + */ + private static final long serialVersionUID = -6877016333706838441L; + + /** + * How often the instruction was executed, which may be used to judge the maturity of this profile. + */ + public int count; + + /** + * An estimation of how many different receiver types were encountered. This may or may not be the same as + * probabilities.length/types.length, as the runtime may store probabilities for a limited number of receivers. + */ + public int morphism; + + /** + * A list of receivers for which the runtime has recorded probability information. This array needs to have the same + * length as {@link RiTypeProfile#probabilities}. + */ + public RiResolvedType[] types; + + /** + * The estimated probabilities of the different receivers. This array needs to have the same length as + * {@link RiTypeProfile#types}. + */ + public float[] probabilities; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/ri/package-info.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,37 @@ +/* + * 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. + * + * 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 runtime-provided part of the bi-directional interface between the compiler and the runtime system of a virtual machine for the + * instruction set defined in {@link com.oracle.max.graal.compiler.graphbuilder.Bytecodes}. + * <p> + * Unlike the {@link com.oracle.max.cri.ci compiler-provided interface}, the runtime-provided interface is specified largely + * using interfaces, that must be implemented by classes provided by a specific runtime implementation. + * <p> + * {@link com.oracle.max.cri.ri.RiRuntime} encapsulates the main functionality of the runtime for the compiler. + * <p> + * Types (i.e., primitives, classes and interfaces}, fields and methods are represented by {@link com.oracle.max.cri.ri.RiType}, + * {@link com.oracle.max.cri.ri.RiField} and {@link com.oracle.max.cri.ri.RiMethod}, respectively, with additional support from + * {@link com.oracle.max.cri.ri.RiSignature} and {@link com.oracle.max.cri.ri.RiExceptionHandler}. Access to the runtime constant pool + * is through {@link com.oracle.max.cri.ri.RiConstantPool}. + */ +package com.oracle.max.cri.ri;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/util/JavacBug.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,38 @@ +/* + * 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. + * + * 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.oracle.max.cri.util; + +/** + * Used to indicate that an otherwise strange looking code pattern is required to work around a bug in javac. + */ +public @interface JavacBug { + /** + * A description of the bug. Only really useful if there is no existing entry for the bug in the <a href="http://bugs.sun.com/bugdatabase/">Bug Database</a>. + */ + String value() default ""; + + /** + * An identifier in the <a href="http://bugs.sun.com/bugdatabase/">Bug Database</a>. + */ + int id() default 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/util/MemoryBarriers.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2011, 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. + * + * 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.oracle.max.cri.util; + +/** + * Constants and intrinsic definition for memory barriers. + * + * The documentation for each constant is taken from Doug Lea's + * <a href="http://gee.cs.oswego.edu/dl/jmm/cookbook.html">The JSR-133 Cookbook for Compiler Writers</a>. + * <p> + * The {@code JMM_*} constants capture the memory barriers necessary to implement the Java Memory Model + * with respect to volatile field accesses. Their values are explained by this + * comment from templateTable_i486.cpp in the HotSpot source code: + * <pre> + * Volatile variables demand their effects be made known to all CPU's in + * order. Store buffers on most chips allow reads & writes to reorder; the + * JMM's ReadAfterWrite.java test fails in -Xint mode without some kind of + * memory barrier (i.e., it's not sufficient that the interpreter does not + * reorder volatile references, the hardware also must not reorder them). + * + * According to the new Java Memory Model (JMM): + * (1) All volatiles are serialized wrt to each other. + * ALSO reads & writes act as acquire & release, so: + * (2) A read cannot let unrelated NON-volatile memory refs that happen after + * the read float up to before the read. It's OK for non-volatile memory refs + * that happen before the volatile read to float down below it. + * (3) Similarly, a volatile write cannot let unrelated NON-volatile memory refs + * that happen BEFORE the write float down to after the write. It's OK for + * non-volatile memory refs that happen after the volatile write to float up + * before it. + * + * We only put in barriers around volatile refs (they are expensive), not + * _between_ memory refs (which would require us to track the flavor of the + * previous memory refs). Requirements (2) and (3) require some barriers + * before volatile stores and after volatile loads. These nearly cover + * requirement (1) but miss the volatile-store-volatile-load case. This final + * case is placed after volatile-stores although it could just as well go + * before volatile-loads. + * </pre> + */ +public class MemoryBarriers { + + /** + * The sequence {@code Load1; LoadLoad; Load2} ensures that {@code Load1}'s data are loaded before data accessed + * by {@code Load2} and all subsequent load instructions are loaded. In general, explicit {@code LoadLoad} + * barriers are needed on processors that perform speculative loads and/or out-of-order processing in which + * waiting load instructions can bypass waiting stores. On processors that guarantee to always preserve load + * ordering, these barriers amount to no-ops. + */ + public static final int LOAD_LOAD = 0x0001; + + /** + * The sequence {@code Load1; LoadStore; Store2} ensures that {@code Load1}'s data are loaded before all data + * associated with {@code Store2} and subsequent store instructions are flushed. {@code LoadStore} barriers are + * needed only on those out-of-order processors in which waiting store instructions can bypass loads. + */ + public static final int LOAD_STORE = 0x0002; + + /** + * The sequence {@code Store1; StoreLoad; Load2} ensures that {@code Store1}'s data are made visible to other + * processors (i.e., flushed to main memory) before data accessed by {@code Load2} and all subsequent load + * instructions are loaded. {@code StoreLoad} barriers protect against a subsequent load incorrectly using + * {@code Store1}'s data value rather than that from a more recent store to the same location performed by a + * different processor. Because of this, on the processors discussed below, a {@code StoreLoad} is strictly + * necessary only for separating stores from subsequent loads of the same location(s) as were stored before the + * barrier. {@code StoreLoad} barriers are needed on nearly all recent multiprocessors, and are usually the most + * expensive kind. Part of the reason they are expensive is that they must disable mechanisms that ordinarily + * bypass cache to satisfy loads from write-buffers. This might be implemented by letting the buffer fully + * flush, among other possible stalls. + */ + public static final int STORE_LOAD = 0x0004; + + /** + * The sequence {@code Store1; StoreStore; Store2} ensures that {@code Store1}'s data are visible to other + * processors (i.e., flushed to memory) before the data associated with {@code Store2} and all subsequent store + * instructions. In general, {@code StoreStore} barriers are needed on processors that do not otherwise + * guarantee strict ordering of flushes from write buffers and/or caches to other processors or main memory. + */ + public static final int STORE_STORE = 0x0008; + + public static final int JMM_PRE_VOLATILE_WRITE = LOAD_STORE | STORE_STORE; + public static final int JMM_POST_VOLATILE_WRITE = STORE_LOAD | STORE_STORE; + public static final int JMM_PRE_VOLATILE_READ = 0; + public static final int JMM_POST_VOLATILE_READ = LOAD_LOAD | LOAD_STORE; + + public static String barriersString(int barriers) { + StringBuilder sb = new StringBuilder(); + sb.append((barriers & LOAD_LOAD) != 0 ? "LOAD_LOAD " : ""); + sb.append((barriers & LOAD_STORE) != 0 ? "LOAD_STORE " : ""); + sb.append((barriers & STORE_LOAD) != 0 ? "STORE_LOAD " : ""); + sb.append((barriers & STORE_STORE) != 0 ? "STORE_STORE " : ""); + return sb.toString().trim(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/util/UnsignedMath.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2011, 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. + * + * 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.oracle.max.cri.util; + +/** + * {@link INTRINSIC} method definitions for unsigned comparisons. + * All methods have correct, but slow, standard Java implementations so that + * they can be used with compilers not supporting the intrinsics. + */ +public class UnsignedMath { + private static final long MASK = 0xffffffffL; + + /** + * Unsigned comparison aboveThan for two numbers. + */ + public static boolean aboveThan(int a, int b) { + return (a & MASK) > (b & MASK); + } + + /** + * Unsigned comparison aboveOrEqual for two numbers. + */ + public static boolean aboveOrEqual(int a, int b) { + return (a & MASK) >= (b & MASK); + } + + /** + * Unsigned comparison belowThan for two numbers. + */ + public static boolean belowThan(int a, int b) { + return (a & MASK) < (b & MASK); + } + + /** + * Unsigned comparison belowOrEqual for two numbers. + */ + public static boolean belowOrEqual(int a, int b) { + return (a & MASK) <= (b & MASK); + } + + /** + * Unsigned comparison aboveThan for two numbers. + */ + public static boolean aboveThan(long a, long b) { + return (a > b) ^ ((a < 0) != (b < 0)); + } + + /** + * Unsigned comparison aboveOrEqual for two numbers. + */ + public static boolean aboveOrEqual(long a, long b) { + return (a >= b) ^ ((a < 0) != (b < 0)); + } + + /** + * Unsigned comparison belowThan for two numbers. + */ + public static boolean belowThan(long a, long b) { + return (a < b) ^ ((a < 0) != (b < 0)); + } + + /** + * Unsigned comparison belowOrEqual for two numbers. + */ + public static boolean belowOrEqual(long a, long b) { + return (a <= b) ^ ((a < 0) != (b < 0)); + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/xir/CiXirAssembler.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,989 @@ +/* + * 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. + * + * 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.oracle.max.cri.xir; + +import static com.oracle.max.cri.xir.CiXirAssembler.XirOp.*; + +import java.util.*; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiAddress.*; +import com.oracle.max.cri.ri.*; + +/** + * Represents an assembler that allows a client such as the runtime system to + * create {@link XirTemplate XIR templates}. + */ +public abstract class CiXirAssembler { + + protected XirOperand resultOperand; + protected boolean allocateResultOperand; + + protected final List<XirInstruction> instructions = new ArrayList<>(); + protected final List<XirLabel> labels = new ArrayList<>(5); + protected final List<XirParameter> parameters = new ArrayList<>(5); + protected final List<XirTemp> temps = new ArrayList<>(5); + protected final List<XirConstant> constants = new ArrayList<>(5); + protected final List<XirMark> marks = new ArrayList<>(5); + + protected int outgoingStackSize = 0; + + /** + * Increases by one for every {@link XirOperand operand} created. + */ + protected int variableCount; + + /** + * Marks the assembly complete. + */ + protected boolean finished = true; + + protected final CiTarget target; + + public CiXirAssembler(CiTarget target) { + this.target = target; + } + + public static class RuntimeCallInformation { + public final Object target; + public final boolean useInfoAfter; + + public RuntimeCallInformation(Object target, boolean useInfoAfter) { + this.target = target; + this.useInfoAfter = useInfoAfter; + } + } + + /** + * Represents additional address calculation information. + */ + public static final class AddressAccessInformation { + + /** + * The scaling factor for the scaled-index part of an address computation. + */ + public final Scale scale; + + /** + * The constant byte-sized displacement part of an address computation. + */ + public final int disp; + + /** + * Determines if the memory access through the address can trap. + */ + public final boolean canTrap; + + private AddressAccessInformation(boolean canTrap) { + this.canTrap = canTrap; + this.scale = Scale.Times1; + this.disp = 0; + } + + private AddressAccessInformation(boolean canTrap, int disp) { + this.canTrap = canTrap; + this.scale = Scale.Times1; + this.disp = disp; + } + + private AddressAccessInformation(boolean canTrap, int disp, Scale scale) { + this.canTrap = canTrap; + this.scale = scale; + this.disp = disp; + } + } + + /** + * A label that is the target of a control flow instruction. + */ + public static final class XirLabel { + public static final String TrueSuccessor = "TrueSuccessor"; + public static final String FalseSuccessor = "FalseSuccessor"; + public final String name; + public final int index; + /** + * If {@code true} the label is to an instruction in the fast path sequence, otherwise to the slow path. + */ + public final boolean inline; + + private XirLabel(String name, int index, boolean inline) { + this.name = name; + this.index = index; + this.inline = inline; + } + + @Override + public String toString() { + return name; + } + } + + /** + * Tagging interface that indicates that an {@link XirOperand} is a constant. + */ + public interface XirConstantOperand { + int getIndex(); + } + + public static final XirOperand VOID = null; + + /** + * Operands for {@link XirInstruction instructions}. + * There are three basic variants, {@link XirConstant constant}, {@link XirParameter parameter} and {@link XirTemp}. + */ + public abstract static class XirOperand { + + public final CiKind kind; + + /** + * Unique id in range {@code 0} to {@link #variableCount variableCount - 1}. + */ + public final int index; + + /** + * Value whose {@link #toString()} method provides a name for this operand. + */ + public final Object name; + + public XirOperand(CiXirAssembler asm, Object name, CiKind kind) { + this.kind = kind; + this.name = name; + this.index = asm.variableCount++; + } + + @Override + public String toString() { + return String.valueOf(name); + } + + public String detailedToString() { + + StringBuffer sb = new StringBuffer(); + + sb.append(name); + sb.append('$'); + sb.append(kind.typeChar); + return sb.toString(); + } + } + + /** + * Parameters to {@link XirTemplate templates}. + */ + public static class XirParameter extends XirOperand { + /** + * Unique id in range {@code 0} to {@code parameters.Size() - 1}. + */ + public final int parameterIndex; + + public final boolean canBeConstant; + + XirParameter(CiXirAssembler asm, String name, CiKind kind, boolean canBeConstant) { + super(asm, name, kind); + this.parameterIndex = asm.parameters.size(); + this.canBeConstant = canBeConstant; + asm.parameters.add(this); + } + + } + + public static class XirConstantParameter extends XirParameter implements XirConstantOperand { + XirConstantParameter(CiXirAssembler asm, String name, CiKind kind) { + super(asm, name, kind, true); + } + + public int getIndex() { + return index; + } + } + + public static class XirVariableParameter extends XirParameter { + XirVariableParameter(CiXirAssembler asm, String name, CiKind kind, boolean canBeConstant) { + super(asm, name, kind, canBeConstant); + } + } + + public static class XirConstant extends XirOperand implements XirConstantOperand { + public final CiConstant value; + + XirConstant(CiXirAssembler asm, CiConstant value) { + super(asm, value, value.kind); + this.value = value; + } + + public int getIndex() { + return index; + } + } + + public static class XirTemp extends XirOperand { + public final boolean reserve; + + XirTemp(CiXirAssembler asm, String name, CiKind kind, boolean reserve) { + super(asm, name, kind); + this.reserve = reserve; + } + } + + public static class XirRegister extends XirTemp { + public final CiValue register; + + XirRegister(CiXirAssembler asm, String name, CiRegisterValue register, boolean reserve) { + super(asm, name, register.kind, reserve); + this.register = register; + } + } + + /** + * Start a new assembly with no initial {@link #resultOperand result operand}. + */ + public void restart() { + reset(); + resultOperand = null; + } + + /** + * Start a new assembly with a {@link #resultOperand result operand} of type {@code kind}. + * @param kind the result kind + * @return an {@code XirOperand} for the result operand + */ + public XirOperand restart(CiKind kind) { + reset(); + resultOperand = new XirTemp(this, "result", kind, true); + allocateResultOperand = true; + return resultOperand; + } + + /** + * Reset the state of the class to the initial conditions to facilitate a new assembly. + */ + private void reset() { + assert finished : "must be finished before!"; + variableCount = 0; + allocateResultOperand = false; + finished = false; + instructions.clear(); + labels.clear(); + parameters.clear(); + temps.clear(); + constants.clear(); + marks.clear(); + outgoingStackSize = 0; + } + + /** + * Represents an XIR instruction, characterized by an {@link XirOp operation}, a {@link CiKind kind}, an optional {@link XirOperand result}, a variable number of {@link XirOperand arguments}, + * and some optional instruction-specific state. The {@link #x}, {@link #y} and {@link #z} methods are convenient ways to access the first, second and third + * arguments, respectively. Only the {@link XirOp#CallStub} and {@link XirOp#CallRuntime} instructions can have more than three arguments. + * + */ + public static final class XirInstruction { + /** + * The {@link CiKind kind} of values the instruction operates on. + */ + public final CiKind kind; + /** + * The {@link XirOp operation}. + */ + public final XirOp op; + /** + * The result, if any. + */ + public final XirOperand result; + /** + * The arguments. + */ + public final XirOperand[] arguments; + /** + * Arbitrary additional data associated with the instruction. + */ + public final Object extra; + + public XirInstruction(CiKind kind, XirOp op, XirOperand result, XirOperand... arguments) { + this(kind, null, op, result, arguments); + } + + public XirInstruction(CiKind kind, Object extra, XirOp op, XirOperand result, XirOperand... arguments) { + this.extra = extra; + this.kind = kind; + this.op = op; + this.result = result; + this.arguments = arguments; + } + + public XirOperand x() { + assert arguments.length > 0 : "no x operand for this instruction"; + return arguments[0]; + } + + public XirOperand y() { + assert arguments.length > 1 : "no y operand for this instruction"; + return arguments[1]; + } + + public XirOperand z() { + assert arguments.length > 2 : "no z operand for this instruction"; + return arguments[2]; + } + + @Override + public String toString() { + StringBuffer sb = new StringBuffer(); + + if (result != null) { + sb.append(result.toString()); + sb.append(" = "); + } + + sb.append(op.name()); + + if (kind != CiKind.Void) { + sb.append('$'); + sb.append(kind.typeChar); + } + + if (arguments != null && arguments.length > 0) { + sb.append("("); + + for (int i = 0; i < arguments.length; i++) { + if (i != 0) { + sb.append(", "); + } + sb.append(arguments[i]); + } + + sb.append(")"); + } + + if (extra != null) { + sb.append(" "); + sb.append(extra); + } + + return sb.toString(); + } + } + + /** + * These marks let the RiXirGenerator mark positions in the generated native code and bring them in relationship with on another. + * This is necessary for code patching, etc. + */ + public static class XirMark { + public final XirMark[] references; + public final Object id; + + // special mark used to refer to the actual call site of an invoke + public static final XirMark CALLSITE = new XirMark(null); + + public XirMark(Object id, XirMark... references) { + this.id = id; + this.references = references; + } + } + + /** + * The set of opcodes for XIR instructions. + * {@link XirInstruction} defines {@code x}, {@code y} and {@code z} as the first, second and third arguments, respectively. + * We use these mnemonics, plus {@code args} for the complete set of arguments, {@code r} for the result, and {@code extra} + * for the instruction-specific extra data, in the opcode specifications. Note that the opcodes that operate on values do not directly + * specify the size (kind) of the data operated on; this is is encoded in {@link XirInstruction#kind}. + * Note: If the instruction kind differs from the argument/result kinds, the behavior is undefined. + * + */ + public enum XirOp { + /** + * Move {@code x} to {@code r}. + */ + Mov, + /** + * Add {@code y} to {@code x} and put the result in {@code r}. + */ + Add, + /** + * Subtract {@code y} from {@code x} and put the result in {@code r}. + */ + Sub, + /** + * Divide {@code y} by {@code x} and put the result in {@code r}. + */ + Div, + /** + * Multiply {@code y} by {@code x} and put the result in {@code r}. + */ + Mul, + /** + * {@code y} modulus {@code x} and put the result in {@code r}. + */ + Mod, + /** + * Shift {@code y} left by {@code x} and put the result in {@code r}. + */ + Shl, + /** + * Arithmetic shift {@code y} right by {@code x} and put the result in {@code r}. + */ + Sar, + /** + * Shift {@code y} right by {@code x} and put the result in {@code r}. + */ + Shr, + /** + * And {@code y} by {@code x} and put the result in {@code r}. + */ + And, + /** + * Or {@code y} by {@code x} and put the result in {@code r}. + */ + Or, + /** + * Exclusive Or {@code y} by {@code x} and put the result in {@code r}. + */ + Xor, + /** + * Null check on {@code x}. + */ + NullCheck, + /** + * Load value at address {@code x} and put the result in {@code r}. + */ + PointerLoad, + /** + * Store {@code y} at address {@code x}. + */ + PointerStore, + /** + * Load value at an effective address defined by base {@code x} and either a scaled index {@code y} plus displacement + * or an offset {@code y} and put the result in {@code r}. + */ + PointerLoadDisp, + /** + * Load an effective address defined by base {@code x} and either a scaled index {@code y} plus displacement + * or an offset {@code y} and put the result in {@code r}. + */ + LoadEffectiveAddress, + /** + * Store {@code z} at address defined by base {@code x} and index {@code y}. + */ + PointerStoreDisp, + /** + * Repeat move from {@code x} to {@code y} using {@code z} words. + */ + RepeatMoveWords, + /** + * Repeat move from {@code x} to {@code y} using {@code z} words. + */ + RepeatMoveBytes, + /** + * Compare value at at address {@code x} with value in {@code y} and store value {@code z} at address {@code x} + * if it was equal to {@code y}. + */ + PointerCAS, + /** + * Call the {@link XirTemplate.GlobalFlags#GLOBAL_STUB shared stub} defined by {@code extra} with {@code args} and put the result in {@code r}. + */ + CallStub, + /** + * Call the {@link RiMethod} defined by {@code extra} with {@code args} and put the result in {@code r}. + */ + CallRuntime, + /** + * Transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. + */ + Jmp, + /** + * If {@code x == y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. + */ + Jeq, + /** + * If {@code x != y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. + */ + Jneq, + /** + * If {@code x > y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. + */ + Jgt, + /** + * If {@code x >= y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. + */ + Jgteq, + /** + * If {@code x unsigned >= y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. + */ + Jugteq, + /** + * If {@code x < y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. + */ + Jlt, + /** + * If {@code x <= y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. + */ + Jlteq, + /** + * Decreases the input by one and jumps to the target if the input is not 0. + */ + DecAndJumpNotZero, + /** + * If bit designated by {@code z} at effective address defined by base {@code x} and offset {@code y} + * is set transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. + */ + Jbset, + /** + * Bind the {@link XirLabel label} identified by {@code extra} to the current instruction and update any references to it. + * A label may be bound more than once to the same location. + */ + Bind, + /** + * Record a safepoint. + */ + Safepoint, + /** + * Align the code following this instruction to a multiple of (int)extra. + */ + Align, + /** + * Creates the stack banging overflow check. + */ + StackOverflowCheck, + /** + * Creates the stack frame for the method and spills callee-save registers (if any) to the {@linkplain CiRegisterSaveArea register save area}. + */ + PushFrame, + /** + * Restores all callee-save registers (if any) and removes the stack frame of the method. + */ + PopFrame, + /** + * Inserts an array of bytes directly into the code output. + */ + RawBytes, + /** + * Pushes a value onto the stack. + */ + Push, + /** + * Pops a value from the stack. + */ + Pop, + /** + * Marks a position in the generated native code. + */ + Mark, + /** + * Load instruction pointer of the next instruction in a destination register. + */ + Here, + /** + * Inserts nop instructions, with the given size in bytes. + */ + Nop, + /** + * This instruction should never be reached, this is useful for debugging purposes. + */ + ShouldNotReachHere + } + + public/*private*/ void append(XirInstruction xirInstruction) { + assert !finished : "no instructions can be added to finished template"; + instructions.add(xirInstruction); + } + + public XirLabel createInlineLabel(String name) { + final XirLabel result = new XirLabel(name, this.labels.size(), true); + labels.add(result); + return result; + } + + public XirLabel createOutOfLineLabel(String name) { + final XirLabel result = new XirLabel(name, this.labels.size(), false); + labels.add(result); + return result; + } + + public void mov(XirOperand result, XirOperand a) { + append(new XirInstruction(result.kind, Mov, result, a)); + } + + public void add(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, Add, result, a, b)); + } + + public void sub(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, Sub, result, a, b)); + } + + public void div(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, Div, result, a, b)); + } + + public void mul(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, Mul, result, a, b)); + } + + public void mod(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, Mod, result, a, b)); + } + + public void shl(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, Shl, result, a, b)); + } + + public void shr(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, Shr, result, a, b)); + } + + public void and(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, And, result, a, b)); + } + + public void or(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, Or, result, a, b)); + } + + public void xor(XirOperand result, XirOperand a, XirOperand b) { + append(new XirInstruction(result.kind, Xor, result, a, b)); + } + + public void nullCheck(XirOperand pointer) { + append(new XirInstruction(CiKind.Object, NullCheck, VOID, pointer)); + } + + public void pload(CiKind kind, XirOperand result, XirOperand pointer, boolean canTrap) { + append(new XirInstruction(kind, canTrap, PointerLoad, result, pointer)); + } + + public void pstore(CiKind kind, XirOperand pointer, XirOperand value, boolean canTrap) { + append(new XirInstruction(kind, canTrap, PointerStore, null, pointer, value)); + } + + public void pload(CiKind kind, XirOperand result, XirOperand pointer, XirOperand offset, boolean canTrap) { + append(new XirInstruction(kind, new AddressAccessInformation(canTrap), PointerLoadDisp, result, pointer, offset)); + } + + public void pstore(CiKind kind, XirOperand pointer, XirOperand offset, XirOperand value, boolean canTrap) { + append(new XirInstruction(kind, new AddressAccessInformation(canTrap), PointerStoreDisp, VOID, pointer, offset, value)); + } + + public void pload(CiKind kind, XirOperand result, XirOperand pointer, XirOperand index, int disp, Scale scale, boolean canTrap) { + append(new XirInstruction(kind, new AddressAccessInformation(canTrap, disp, scale), PointerLoadDisp, result, pointer, index)); + } + + public void lea(XirOperand result, XirOperand pointer, XirOperand index, int disp, Scale scale) { + append(new XirInstruction(target.wordKind, new AddressAccessInformation(false, disp, scale), LoadEffectiveAddress, result, pointer, index)); + } + + public void repmov(XirOperand src, XirOperand dest, XirOperand length) { + append(new XirInstruction(target.wordKind, null, RepeatMoveWords, null, src, dest, length)); + } + + public void here(XirOperand dst) { + append(new XirInstruction(target.wordKind, null, Here, dst)); + } + + public void repmovb(XirOperand src, XirOperand dest, XirOperand length) { + append(new XirInstruction(target.wordKind, null, RepeatMoveBytes, null, src, dest, length)); + } + + public void pstore(CiKind kind, XirOperand pointer, XirOperand index, XirOperand value, int disp, Scale scale, boolean canTrap) { + append(new XirInstruction(kind, new AddressAccessInformation(canTrap, disp, scale), PointerStoreDisp, VOID, pointer, index, value)); + } + + public void pcas(CiKind kind, XirOperand result, XirOperand pointer, XirOperand newValue, XirOperand oldValue) { + append(new XirInstruction(kind, null, PointerCAS, result, pointer, newValue, oldValue)); + } + + public void jmp(XirLabel l) { + append(new XirInstruction(CiKind.Void, l, Jmp, null)); + } + + public void decAndJumpNotZero(XirLabel l, XirOperand val) { + append(new XirInstruction(CiKind.Void, l, DecAndJumpNotZero, null, val)); + } + + public void jmpRuntime(Object rt) { + append(new XirInstruction(CiKind.Void, rt, Jmp, null)); + } + + public void jeq(XirLabel l, XirOperand a, XirOperand b) { + jcc(Jeq, l, a, b); + } + + private void jcc(XirOp op, XirLabel l, XirOperand a, XirOperand b) { + append(new XirInstruction(CiKind.Void, l, op, null, a, b)); + } + + public void jneq(XirLabel l, XirOperand a, XirOperand b) { + jcc(Jneq, l, a, b); + } + + public void jgt(XirLabel l, XirOperand a, XirOperand b) { + jcc(Jgt, l, a, b); + } + + public void jgteq(XirLabel l, XirOperand a, XirOperand b) { + jcc(Jgteq, l, a, b); + } + + public void jugteq(XirLabel l, XirOperand a, XirOperand b) { + jcc(Jugteq, l, a, b); + } + + public void jlt(XirLabel l, XirOperand a, XirOperand b) { + jcc(Jlt, l, a, b); + } + + public void jlteq(XirLabel l, XirOperand a, XirOperand b) { + jcc(Jlteq, l, a, b); + } + + public void jbset(XirLabel l, XirOperand a, XirOperand b, XirOperand c) { + append(new XirInstruction(CiKind.Void, l, Jbset, null, a, b, c)); + } + + public void bindInline(XirLabel l) { + assert l.inline; + append(new XirInstruction(CiKind.Void, l, Bind, null)); + } + + public void bindOutOfLine(XirLabel l) { + assert !l.inline; + append(new XirInstruction(CiKind.Void, l, Bind, null)); + } + + public void safepoint() { + append(new XirInstruction(CiKind.Void, null, Safepoint, null)); + } + + public void align(int multiple) { + assert multiple > 0; + append(new XirInstruction(CiKind.Void, multiple, Align, null)); + } + + public void stackOverflowCheck() { + append(new XirInstruction(CiKind.Void, null, StackOverflowCheck, null)); + } + + public void pushFrame() { + append(new XirInstruction(CiKind.Void, null, PushFrame, null)); + } + + public void popFrame() { + append(new XirInstruction(CiKind.Void, null, PopFrame, null)); + } + + public void rawBytes(byte[] bytes) { + append(new XirInstruction(CiKind.Void, bytes, RawBytes, null)); + } + + public void push(XirOperand value) { + append(new XirInstruction(CiKind.Void, Push, VOID, value)); + } + + public void pop(XirOperand result) { + append(new XirInstruction(result.kind, Pop, result)); + } + + public XirMark mark(Object id, XirMark... references) { + XirMark mark = new XirMark(id, references); + marks.add(mark); + append(new XirInstruction(CiKind.Void, mark, Mark, null)); + return mark; + } + + public void nop(int size) { + append(new XirInstruction(CiKind.Void, size, Nop, null)); + } + + public void shouldNotReachHere() { + append(new XirInstruction(CiKind.Void, null, ShouldNotReachHere, null)); + } + + public void shouldNotReachHere(String message) { + append(new XirInstruction(CiKind.Void, message, ShouldNotReachHere, null)); + } + + public void callStub(XirTemplate stub, XirOperand result, XirOperand... args) { + CiKind resultKind = result == null ? CiKind.Void : result.kind; + append(new XirInstruction(resultKind, stub, CallStub, result, args)); + } + + public void callRuntime(Object rt, XirOperand result, XirOperand... args) { + callRuntime(rt, result, false, args); + } + + public void callRuntime(Object rt, XirOperand result, boolean useInfoAfter, XirOperand... args) { + CiKind resultKind = result == null ? CiKind.Void : result.kind; + append(new XirInstruction(resultKind, new RuntimeCallInformation(rt, useInfoAfter), CallRuntime, result, args)); + } + + /** + * Terminates the assembly, checking invariants, in particular that {@link resultOperand} is set, and setting {@link #finished} to {@code true}. + */ + private void end() { + assert !finished : "template may only be finished once!"; + assert resultOperand != null : "result operand should be set"; + finished = true; + } + + /** + * Creates an {@link XirVariableParameter variable input parameter} of given name and {@link CiKind kind}. + * @param name a name for the parameter + * @param kind the parameter kind + * @return the {@link XirVariableParameter} + */ + public XirVariableParameter createInputParameter(String name, CiKind kind, boolean canBeConstant) { + assert !finished; + return new XirVariableParameter(this, name, kind, canBeConstant); + } + + public XirVariableParameter createInputParameter(String name, CiKind kind) { + return createInputParameter(name, kind, false); + } + + /** + * Creates an {@link XirConstantParameter constant input parameter} of given name and {@link CiKind kind}. + * @param name a name for the parameter + * @param kind the parameter kind + * @return the {@link XirConstantParameter} + */ + public XirConstantParameter createConstantInputParameter(String name, CiKind kind) { + assert !finished; + return new XirConstantParameter(this, name, kind); + } + + public XirConstant createConstant(CiConstant constant) { + assert !finished; + XirConstant temp = new XirConstant(this, constant); + constants.add(temp); + return temp; + } + + public XirOperand createTemp(String name, CiKind kind) { + assert !finished; + XirTemp temp = new XirTemp(this, name, kind, true); + temps.add(temp); + return temp; + } + + public XirOperand createRegister(String name, CiKind kind, CiRegister register) { + return createRegister(name, kind, register, false); + } + + public XirOperand createRegisterTemp(String name, CiKind kind, CiRegister register) { + return createRegister(name, kind, register, true); + } + + private XirOperand createRegister(String name, CiKind kind, CiRegister register, boolean reserve) { + assert !finished; + XirRegister fixed = new XirRegister(this, name, register.asValue(kind), reserve); + temps.add(fixed); + return fixed; + } + + public XirParameter getParameter(String name) { + for (XirParameter param : parameters) { + if (param.name.toString().equals(name)) { + return param; + } + } + throw new IllegalArgumentException("no parameter: " + name); + } + + public XirTemp getTemp(String name) { + for (XirTemp temp : temps) { + if (temp.name.toString().equals(name)) { + return temp; + } + } + throw new IllegalArgumentException("no temp: " + name); + } + + public XirConstant i(int v) { + return createConstant(CiConstant.forInt(v)); + } + + public XirConstant l(int v) { + return createConstant(CiConstant.forLong(v)); + } + + public XirConstant b(boolean v) { + return createConstant(CiConstant.forBoolean(v)); + } + + public XirConstant o(Object obj) { + return createConstant(CiConstant.forObject(obj)); + } + + public void reserveOutgoingStack(int size) { + outgoingStackSize = Math.max(outgoingStackSize, size); + } + + /** + * Finishes the assembly of a non-stub template, providing the {@link #resultOperand} and constructs the {@link XirTemplate}. + * @param result the {@link XirOperand} to be set as the {@link #resultOperand} + * @param name the name of the template + * @return the generated template + */ + public XirTemplate finishTemplate(XirOperand result, String name) { + assert this.resultOperand == null; + assert result != null; + this.resultOperand = result; + final XirTemplate template = buildTemplate(name, false); + end(); + return template; + } + + /** + * Finishes the assembly of a non-stub template and constructs the {@link XirTemplate}. + * @param name the name of the template + * @return the generated template + */ + public XirTemplate finishTemplate(String name) { + final XirTemplate template = buildTemplate(name, false); + end(); + return template; + } + + /** + * Finishes the assembly of a {@link XirTemplate.GlobalFlags#GLOBAL_STUB stub} and constructs the {@link XirTemplate}. + * @param name the name of the template + * @return the generated template + */ + public XirTemplate finishStub(String name) { + final XirTemplate template = buildTemplate(name, true); + end(); + return template; + } + + /** + * Builds the {@link XirTemplate} from the assembly state in this object. + * The actual assembly is dependent on the target architecture and implemented + * in a concrete subclass. + * @param name the name of the template + * @param isStub {@code true} if the template represents a {@link XirTemplate.GlobalFlags#GLOBAL_STUB stub} + * @return the generated template + */ + protected abstract XirTemplate buildTemplate(String name, boolean isStub); + + public abstract CiXirAssembler copy(); + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/xir/RiXirGenerator.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,123 @@ +/* + * 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. + * + * 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.oracle.max.cri.xir; + +import java.util.*; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.ri.RiType.*; + +/** + * Represents the interface through which the compiler requests the XIR for a given bytecode from the runtime system. + */ +public interface RiXirGenerator { + + /** + * Note: may return {@code null}. + */ + XirSnippet genPrologue(XirSite site, RiResolvedMethod method); + + /** + * Note: may return {@code null} in which case the compiler will not emit a return instruction. + */ + XirSnippet genEpilogue(XirSite site, RiResolvedMethod method); + + XirSnippet genSafepointPoll(XirSite site); + + XirSnippet genExceptionObject(XirSite site); + + XirSnippet genResolveClass(XirSite site, RiType type, Representation representation); + + XirSnippet genIntrinsic(XirSite site, XirArgument[] arguments, RiMethod method); + + XirSnippet genInvokeInterface(XirSite site, XirArgument receiver, RiMethod method); + + XirSnippet genInvokeVirtual(XirSite site, XirArgument receiver, RiMethod method); + + XirSnippet genInvokeSpecial(XirSite site, XirArgument receiver, RiMethod method); + + XirSnippet genInvokeStatic(XirSite site, RiMethod method); + + XirSnippet genMonitorEnter(XirSite site, XirArgument receiver, XirArgument lockAddress); + + XirSnippet genMonitorExit(XirSite site, XirArgument receiver, XirArgument lockAddress); + + XirSnippet genGetField(XirSite site, XirArgument receiver, RiField field); + + XirSnippet genPutField(XirSite site, XirArgument receiver, RiField field, XirArgument value); + + XirSnippet genGetStatic(XirSite site, XirArgument staticTuple, RiField field); + + XirSnippet genPutStatic(XirSite site, XirArgument staticTuple, RiField field, XirArgument value); + + XirSnippet genNewInstance(XirSite site, RiType type); + + XirSnippet genNewArray(XirSite site, XirArgument length, CiKind elementKind, RiType componentType, RiType arrayType); + + XirSnippet genNewObjectArrayClone(XirSite site, XirArgument newLength, XirArgument referenceArray); + + XirSnippet genNewMultiArray(XirSite site, XirArgument[] lengths, RiType type); + + XirSnippet genCheckCast(XirSite site, XirArgument receiver, XirArgument hub, RiType type); + + XirSnippet genInstanceOf(XirSite site, XirArgument receiver, XirArgument hub, RiType type); + + XirSnippet genMaterializeInstanceOf(XirSite site, XirArgument receiver, XirArgument hub, XirArgument trueValue, XirArgument falseValue, RiType type); + + XirSnippet genArrayLoad(XirSite site, XirArgument array, XirArgument index, CiKind elementKind, RiType elementType); + + XirSnippet genArrayStore(XirSite site, XirArgument array, XirArgument index, XirArgument value, CiKind elementKind, RiType elementType); + + XirSnippet genArrayLength(XirSite site, XirArgument array); + + XirSnippet genWriteBarrier(XirArgument object); + + XirSnippet genArrayCopy(XirSite site, XirArgument src, XirArgument srcPos, XirArgument dest, XirArgument destPos, XirArgument length, RiType elementType, boolean inputsSame, boolean inputsDifferent); + + XirSnippet genCurrentThread(XirSite site); + + XirSnippet genGetClass(XirSite site, XirArgument xirArgument); + + /** + * Generates code that checks that the {@linkplain Representation#ObjectHub hub} of + * an object is identical to a given hub constant. In pseudo code: + * <pre> + * if (object.getHub() != hub) { + * uncommonTrap(); + * } + * </pre> + * This snippet should only be used when the object is guaranteed not to be null. + */ + XirSnippet genTypeCheck(XirSite site, XirArgument object, XirArgument hub, RiType type); + + /** + * Gets the list of XIR templates, using the given XIR assembler to create them if + * they haven't yet been created. + * + * @param asm the XIR assembler + * @return the list of templates + */ + List<XirTemplate> makeTemplates(CiXirAssembler asm); + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/xir/XirArgument.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,70 @@ +/* + * 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. + * + * 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.oracle.max.cri.xir; + +import com.oracle.max.cri.ci.*; + +/** + * Represents an argument to an {@link XirSnippet}. + * Currently, this is a <i>union </i> type; it is either a {@link CiConstant} or an {@code Object}. + */ +public final class XirArgument { + + public final CiConstant constant; + public final Object object; + + private XirArgument(CiConstant value) { + this.constant = value; + this.object = null; + } + + private XirArgument(Object o) { + this.constant = null; + this.object = o; + } + + public static XirArgument forInternalObject(Object o) { + return new XirArgument(o); + } + + public static XirArgument forInt(int x) { + return new XirArgument(CiConstant.forInt(x)); + } + + public static XirArgument forLong(long x) { + return new XirArgument(CiConstant.forLong(x)); + } + + public static XirArgument forObject(Object o) { + return new XirArgument(CiConstant.forObject(o)); + } + + @Override + public String toString() { + if (constant != null) { + return constant.toString(); + } else { + return "" + object; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/xir/XirSite.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,94 @@ +/* + * 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. + * + * 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.oracle.max.cri.xir; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; + +/** + * Encapsulates the notion of a site where XIR can be supplied. It is supplied to the {@link RiXirGenerator} by the + * compiler for each place where XIR can be generated. This interface allows a number of queries, including the + * bytecode-level location and optimization hints computed by the compiler. + */ +public interface XirSite { + + /** + * Gets the {@link CiCodePos code position} associated with this site. This is useful for inserting + * instrumentation at the XIR level. + * @return the code position if it is available; {@code null} otherwise + */ + CiCodePos getCodePos(); + + /** + * Checks whether the specified argument is guaranteed to be non-null at this site. + * @param argument the argument + * @return {@code true} if the argument is non null at this site + */ + boolean isNonNull(XirArgument argument); + + /** + * Checks whether this site requires a null check. + * @return {@code true} if a null check is required + */ + boolean requiresNullCheck(); + + /** + * Checks whether this site requires a range check. + * @return {@code true} if a range check is required + */ + boolean requiresBoundsCheck(); + + /** + * Checks whether this site requires a read barrier. + * @return {@code true} if a read barrier is required + */ + boolean requiresReadBarrier(); + + /** + * Checks whether this site requires a write barrier. + * @return {@code true} if a write barrier is required + */ + boolean requiresWriteBarrier(); + + /** + * Checks whether this site requires an array store check. + * @return {@code true} if an array store check is required + */ + boolean requiresArrayStoreCheck(); + + /** + * Checks whether an approximation of the type for the specified argument is available. + * @param argument the argument + * @return an {@link RiType} indicating the most specific type known for the argument, if any; + * {@code null} if no particular type is known + */ + RiType getApproximateType(XirArgument argument); + + /** + * Checks whether an exact type is known for the specified argument. + * @param argument the argument + * @return an {@link RiType} indicating the exact type known for the argument, if any; + * {@code null} if no particular type is known + */ + RiType getExactType(XirArgument argument); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/xir/XirSnippet.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,94 @@ +/* + * 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. + * + * 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.oracle.max.cri.xir; + +import java.util.*; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiTargetMethod.*; +import com.oracle.max.cri.xir.CiXirAssembler.*; + +/** + * Represents a {@link XirTemplate template of XIR} along with the {@link XirArgument arguments} to be passed to the + * template. The runtime generates such snippets for each bytecode being compiled at the request of the compiler, and + * the compiler can generate machine code for the XIR snippet. + */ +public class XirSnippet { + + public final XirArgument[] arguments; + public final XirTemplate template; + public final Map<XirMark, Mark> marks; + + public XirSnippet(XirTemplate template, XirArgument... inputs) { + assert template != null; + this.template = template; + this.arguments = inputs; + this.marks = (template.marks != null && template.marks.length > 0) ? new HashMap<XirMark, Mark>() : null; + assert assertArgumentsCorrect(); + } + + private boolean assertArgumentsCorrect() { + int argLength = arguments == null ? 0 : arguments.length; + int paramLength = template.parameters == null ? 0 : template.parameters.length; + assert argLength == paramLength : "expected param count: " + paramLength + ", actual: " + argLength; + for (int i = 0; i < arguments.length; i++) { + assert assertArgumentCorrect(template.parameters[i], arguments[i]) : "mismatch in parameter " + i + ": " + arguments[i] + " instead of " + template.parameters[i]; + } + return true; + } + + private static boolean assertArgumentCorrect(XirParameter param, XirArgument arg) { + if (param.kind == CiKind.Illegal || param.kind == CiKind.Void) { + if (arg != null) { + return false; + } + } else { + if (arg == null) { + return false; + } + if (arg.constant != null) { + if (arg.constant != null && arg.constant.kind != param.kind) { + return false; + } + } + } + return true; + } + + @Override + public String toString() { + + StringBuffer sb = new StringBuffer(); + + sb.append(template.toString()); + sb.append("("); + for (XirArgument a : arguments) { + sb.append(" "); + sb.append(a); + } + + sb.append(" )"); + + return sb.toString(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/xir/XirTemplate.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,267 @@ +/* + * 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. + * + * 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.oracle.max.cri.xir; + +import java.io.*; +import java.util.*; + +import com.oracle.max.cri.xir.CiXirAssembler.*; + +/** + * Represents a completed template of XIR code that has been first assembled by + * the runtime, and then verified and preprocessed by the compiler. An {@code XirTemplate} + * instance is immutable. + */ +public class XirTemplate { + + /** + * Flags that indicate key features of the template for quick checking. + */ + public enum GlobalFlags { + /** + * Contains a call to a {@link GlobalFlags#GLOBAL_STUB} template. + */ + HAS_STUB_CALL, + + /** + * Contains a call to the runtime. + */ + HAS_RUNTIME_CALL, + + /** + * Not simply a linear sequence of instructions, contains control transfers. + */ + HAS_CONTROL_FLOW, + + /** + * Is a shared instruction sequence for use by other templates. + */ + GLOBAL_STUB; + + public final int mask = 1 << ordinal(); + } + + /** + * Name of the template. + */ + public final String name; + + public final XirOperand resultOperand; + + /** + * The sequence of instructions for the fast (inline) path. + */ + public final CiXirAssembler.XirInstruction[] fastPath; + + /** + * The sequence of instructions for the slow (out of line) path. + */ + public final CiXirAssembler.XirInstruction[] slowPath; + + /** + * Labels used in control transfers. + */ + public final XirLabel[] labels; + + /** + * Parameters to the template. + */ + public final XirParameter[] parameters; + + /** + * An array of same length as {@link #parameters} where {@code parameterDestroyed[i]} is {@code true} + * iff {@code parameters[i]} is the {@link XirInstruction#result result} of any {@link XirInstruction} in either + * {@link #fastPath} or {@link #slowPath}. + */ + public final boolean[] parameterDestroyed; + + /** + * Temporary variables used by the template. + */ + public final XirTemp[] temps; + + /** + * Constants used in the template. + */ + public final XirConstant[] constants; + + /** + * The total number of variables. (relation to temps/parameters???) + */ + public final int variableCount; + + public final boolean allocateResultOperand; + + public final XirTemplate[] calleeTemplates; + + public final XirMark[] marks; + + public final int outgoingStackSize; + + public final XirOperand[] inputOperands; + public final XirOperand[] inputTempOperands; + public final XirOperand[] tempOperands; + + + /** + * The {@link GlobalFlags} associated with the template. + */ + public final int flags; + + public XirTemplate(String name, + int variableCount, + boolean allocateResultOperand, + XirOperand resultOperand, + CiXirAssembler.XirInstruction[] fastPath, + CiXirAssembler.XirInstruction[] slowPath, + XirLabel[] labels, + XirParameter[] parameters, + XirTemp[] temps, + XirConstant[] constantValues, + int flags, + XirTemplate[] calleeTemplates, + XirMark[] marks, + int outgoingStackSize) { + this.name = name; + this.variableCount = variableCount; + this.resultOperand = resultOperand; + this.fastPath = fastPath; + this.slowPath = slowPath; + this.labels = labels; + this.parameters = parameters; + this.flags = flags; + this.temps = temps; + this.allocateResultOperand = allocateResultOperand; + this.constants = constantValues; + this.calleeTemplates = calleeTemplates; + this.marks = marks; + this.outgoingStackSize = outgoingStackSize; + + assert fastPath != null; + assert labels != null; + assert parameters != null; + + List<XirOperand> inputOperandList = new ArrayList<>(4); + List<XirOperand> inputTempOperandList = new ArrayList<>(4); + List<XirOperand> tempOperandList = new ArrayList<>(4); + + parameterDestroyed = new boolean[parameters.length]; + for (int i = 0; i < parameters.length; i++) { + for (XirInstruction ins : fastPath) { + if (ins.result == parameters[i]) { + parameterDestroyed[i] = true; + break; + } + } + + if (slowPath != null && !parameterDestroyed[i]) { + for (XirInstruction ins : slowPath) { + if (ins.result == parameters[i]) { + parameterDestroyed[i] = true; + } + } + } + + if (parameterDestroyed[i]) { + inputTempOperandList.add(parameters[i]); + } else { + inputOperandList.add(parameters[i]); + } + } + + for (XirTemp temp : temps) { + if (temp.reserve) { + tempOperandList.add(temp); + } + } + + this.inputOperands = inputOperandList.toArray(new XirOperand[inputOperandList.size()]); + this.inputTempOperands = inputTempOperandList.toArray(new XirOperand[inputTempOperandList.size()]); + this.tempOperands = tempOperandList.toArray(new XirOperand[tempOperandList.size()]); + } + + /** + * Convenience getter that returns the value at a given index in the {@link #parameterDestroyed} array. + * @param index + * @return the value at {@code parameterDestroyed[index]} + */ + public boolean isParameterDestroyed(int index) { + return parameterDestroyed[index]; + } + + @Override + public String toString() { + return name; + } + + public void print(PrintStream p) { + final String indent = " "; + + p.println(); + p.println("Template " + name); + + p.print("Param:"); + for (XirParameter param : parameters) { + p.print(" " + param.detailedToString()); + } + p.println(); + + if (temps.length > 0) { + p.print("Temps:"); + for (XirTemp temp : temps) { + p.print(" " + temp.detailedToString()); + } + p.println(); + } + + if (constants.length > 0) { + p.print("Constants:"); + for (XirConstant c : constants) { + p.print(" " + c.detailedToString()); + } + p.println(); + } + + if (flags != 0) { + p.print("Flags:"); + for (XirTemplate.GlobalFlags flag : XirTemplate.GlobalFlags.values()) { + if ((this.flags & flag.mask) != 0) { + p.print(" " + flag.name()); + } + } + p.println(); + } + + p.println("Fast path:"); + for (XirInstruction i : fastPath) { + p.println(indent + i.toString()); + } + + if (slowPath != null) { + p.println("Slow path:"); + for (XirInstruction i : slowPath) { + p.println(indent + i.toString()); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.cri/src/com/oracle/max/cri/xir/package-info.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,37 @@ +/* + * 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. + * + * 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. + */ +/** + * XIR defines a domain specific instruction set for expressing the lowering of bytecode operations. The details of the + * lowering operations are entirely encapsulated in the runtime and are provided to the compiler on request using + * {@link com.oracle.max.cri.xir.XirSnippet XIR snippets}. A snippet is a combination of a {@link com.oracle.max.cri.xir.XirTemplate + * template}, which is a sequence of {@link com.oracle.max.cri.xir.CiXirAssembler.XirInstruction XIR instructions} that has + * unbound {@link com.oracle.max.cri.xir.CiXirAssembler.XirParameter parameters}, and site-specific + * {@link com.oracle.max.cri.xir.XirArgument arguments} that are bound to the parameters. + * <p> + * The runtime is responsible for creating the {@link com.oracle.max.cri.xir.XirTemplate templates} and provides these to the + * compiler as part of the initialization process. + * <p> + * The XIR instruction set has no textual representation, and therefore no parser. An assembly is represented by an + * instance of {@link com.oracle.max.cri.xir.CiXirAssembler}, which provides methods to create instructions and operands. + */ +package com.oracle.max.cri.xir;
--- a/graal/com.oracle.max.cri/src/com/sun/cri/bytecode/BytecodeLookupSwitch.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,76 +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. - * - * 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.cri.bytecode; - -/** - * A utility for processing {@link Bytecodes#LOOKUPSWITCH} bytecodes. - */ -public class BytecodeLookupSwitch extends BytecodeSwitch { - private static final int OFFSET_TO_NUMBER_PAIRS = 4; - private static final int OFFSET_TO_FIRST_PAIR_MATCH = 8; - private static final int OFFSET_TO_FIRST_PAIR_OFFSET = 12; - private static final int PAIR_SIZE = 8; - - /** - * Constructor for a {@link BytecodeStream}. - * @param stream the {@code BytecodeStream} containing the switch instruction - * @param bci the index in the stream of the switch instruction - */ - public BytecodeLookupSwitch(BytecodeStream stream, int bci) { - super(stream, bci); - } - - /** - * Constructor for a bytecode array. - * @param code the bytecode array containing the switch instruction. - * @param bci the index in the array of the switch instruction - */ - public BytecodeLookupSwitch(byte[] code, int bci) { - super(code, bci); - } - - @Override - public int defaultOffset() { - return readWord(alignedBci); - } - - @Override - public int offsetAt(int i) { - return readWord(alignedBci + OFFSET_TO_FIRST_PAIR_OFFSET + PAIR_SIZE * i); - } - - @Override - public int keyAt(int i) { - return readWord(alignedBci + OFFSET_TO_FIRST_PAIR_MATCH + PAIR_SIZE * i); - } - - @Override - public int numberOfCases() { - return readWord(alignedBci + OFFSET_TO_NUMBER_PAIRS); - } - - @Override - public int size() { - return alignedBci + OFFSET_TO_FIRST_PAIR_MATCH + PAIR_SIZE * numberOfCases() - bci; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/bytecode/BytecodeStream.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,197 +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. - * - * 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.cri.bytecode; - -/** - * A utility class that makes iterating over bytecodes and reading operands - * simpler and less error prone. For example, it handles the {@link Bytecodes#WIDE} instruction - * and wide variants of instructions internally. - */ -public final class BytecodeStream { - - private final byte[] code; - private int opcode; - private int curBCI; - private int nextBCI; - - /** - * Creates a new {@code BytecodeStream} for the specified bytecode. - * @param code the array of bytes that contains the bytecode - */ - public BytecodeStream(byte[] code) { - assert code != null; - this.code = code; - setBCI(0); - } - - /** - * Advances to the next bytecode. - */ - public void next() { - setBCI(nextBCI); - } - - /** - * Gets the next bytecode index (no side-effects). - * @return the next bytecode index - */ - public int nextBCI() { - return nextBCI; - } - - /** - * Gets the current bytecode index. - * @return the current bytecode index - */ - public int currentBCI() { - return curBCI; - } - - /** - * Gets the bytecode index of the end of the code. - * @return the index of the end of the code - */ - public int endBCI() { - return code.length; - } - - /** - * Gets the current opcode. This method will never return the - * {@link Bytecodes#WIDE WIDE} opcode, but will instead - * return the opcode that is modified by the {@code WIDE} opcode. - * @return the current opcode; {@link Bytecodes#END} if at or beyond the end of the code - */ - public int currentBC() { - if (opcode == Bytecodes.WIDE) { - return Bytes.beU1(code, curBCI + 1); - } else { - return opcode; - } - } - - /** - * Reads the index of a local variable for one of the load or store instructions. - * The WIDE modifier is handled internally. - * @return the index of the local variable - */ - public int readLocalIndex() { - // read local variable index for load/store - if (opcode == Bytecodes.WIDE) { - return Bytes.beU2(code, curBCI + 2); - } - return Bytes.beU1(code, curBCI + 1); - } - - /** - * Read the delta for an {@link Bytecodes#IINC} bytecode. - * @return the delta for the {@code IINC} - */ - public int readIncrement() { - // read the delta for the iinc bytecode - if (opcode == Bytecodes.WIDE) { - return Bytes.beS2(code, curBCI + 4); - } - return Bytes.beS1(code, curBCI + 2); - } - - /** - * Read the destination of a {@link Bytecodes#GOTO} or {@code IF} instructions. - * @return the destination bytecode index - */ - public int readBranchDest() { - // reads the destination for a branch bytecode - return curBCI + Bytes.beS2(code, curBCI + 1); - } - - /** - * Read the destination of a {@link Bytecodes#GOTO_W} or {@link Bytecodes#JSR_W} instructions. - * @return the destination bytecode index - */ - public int readFarBranchDest() { - // reads the destination for a wide branch bytecode - return curBCI + Bytes.beS4(code, curBCI + 1); - } - - /** - * Read a signed 4-byte integer from the bytecode stream at the specified bytecode index. - * @param bci the bytecode index - * @return the integer value - */ - public int readInt(int bci) { - // reads a 4-byte signed value - return Bytes.beS4(code, bci); - } - - /** - * Reads an unsigned, 1-byte value from the bytecode stream at the specified bytecode index. - * @param bci the bytecode index - * @return the byte - */ - public int readUByte(int bci) { - return Bytes.beU1(code, bci); - } - - /** - * Reads a constant pool index for the current instruction. - * @return the constant pool index - */ - public char readCPI() { - if (opcode == Bytecodes.LDC) { - return (char) Bytes.beU1(code, curBCI + 1); - } - return (char) Bytes.beU2(code, curBCI + 1); - } - - /** - * Reads a signed, 1-byte value for the current instruction (e.g. BIPUSH). - * @return the byte - */ - public byte readByte() { - return code[curBCI + 1]; - } - - /** - * Reads a signed, 2-byte short for the current instruction (e.g. SIPUSH). - * @return the short value - */ - public short readShort() { - return (short) Bytes.beS2(code, curBCI + 1); - } - - /** - * Sets the bytecode index to the specified value. - * If {@code bci} is beyond the end of the array, {@link #currentBC} will return - * {@link Bytecodes#END} and other methods may throw {@link ArrayIndexOutOfBoundsException}. - * @param bci the new bytecode index - */ - public void setBCI(int bci) { - curBCI = bci; - if (curBCI < code.length) { - opcode = Bytes.beU1(code, bci); - nextBCI = bci + Bytecodes.lengthOf(code, bci); - } else { - opcode = Bytecodes.END; - nextBCI = curBCI; - } - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/bytecode/BytecodeSwitch.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,139 +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. - * - * 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.cri.bytecode; - -/** - * An abstract class that provides the state and methods common to {@link Bytecodes#LOOKUPSWITCH} - * and {@link Bytecodes#TABLESWITCH} instructions. - */ -public abstract class BytecodeSwitch { - /** - * The {@link BytecodeStream} containing bytecode array or {@code null} if {@link #code} is not {@code null}. - */ - private final BytecodeStream stream; - /** - * The bytecode array or {@code null} if {@link #stream} is not {@code null}. - */ - private final byte[] code; - /** - * Index of start of switch instruction. - */ - protected final int bci; - /** - * Index of the start of the additional data for the switch instruction, aligned to a multiple of four from the method start. - */ - protected final int alignedBci; - - /** - * Constructor for a {@link BytecodeStream}. - * @param stream the {@code BytecodeStream} containing the switch instruction - * @param bci the index in the stream of the switch instruction - */ - public BytecodeSwitch(BytecodeStream stream, int bci) { - this.alignedBci = (bci + 4) & 0xfffffffc; - this.stream = stream; - this.code = null; - this.bci = bci; - } - - /** - * Constructor for a bytecode array. - * @param code the bytecode array containing the switch instruction. - * @param bci the index in the array of the switch instruction - */ - public BytecodeSwitch(byte[] code, int bci) { - this.alignedBci = (bci + 4) & 0xfffffffc; - this.stream = null; - this.code = code; - this.bci = bci; - } - - /** - * Gets the current bytecode index. - * @return the current bytecode index - */ - public int bci() { - return bci; - } - - /** - * Gets the index of the instruction denoted by the {@code i}'th switch target. - * @param i index of the switch target - * @return the index of the instruction denoted by the {@code i}'th switch target - */ - public int targetAt(int i) { - return bci + offsetAt(i); - } - - /** - * Gets the index of the instruction for the default switch target. - * @return the index of the instruction for the default switch target - */ - public int defaultTarget() { - return bci + defaultOffset(); - } - - /** - * Gets the offset from the start of the switch instruction to the default switch target. - * @return the offset to the default switch target - */ - public abstract int defaultOffset(); - - /** - * Gets the key at {@code i}'th switch target index. - * @param i the switch target index - * @return the key at {@code i}'th switch target index - */ - public abstract int keyAt(int i); - - /** - * Gets the offset from the start of the switch instruction for the {@code i}'th switch target. - * @param i the switch target index - * @return the offset to the {@code i}'th switch target - */ - public abstract int offsetAt(int i); - - /** - * Gets the number of switch targets. - * @return the number of switch targets - */ - public abstract int numberOfCases(); - - /** - * Gets the total size in bytes of the switch instruction. - * @return the total size in bytes of the switch instruction - */ - public abstract int size(); - - /** - * Reads the signed value at given bytecode index. - * @param readBci the start index of the value to retrieve - * @return the signed, 4-byte value in the bytecode array starting at {@code bci} - */ - protected int readWord(int readBci) { - if (code != null) { - return Bytes.beS4(code, readBci); - } - return stream.readInt(readBci); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/bytecode/BytecodeTableSwitch.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,92 +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. - * - * 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.cri.bytecode; - -/** - * A utility for processing {@link Bytecodes#TABLESWITCH} bytecodes. - */ -public class BytecodeTableSwitch extends BytecodeSwitch { - private static final int OFFSET_TO_LOW_KEY = 4; - private static final int OFFSET_TO_HIGH_KEY = 8; - private static final int OFFSET_TO_FIRST_JUMP_OFFSET = 12; - private static final int JUMP_OFFSET_SIZE = 4; - - /** - * Constructor for a {@link BytecodeStream}. - * @param stream the {@code BytecodeStream} containing the switch instruction - * @param bci the index in the stream of the switch instruction - */ - public BytecodeTableSwitch(BytecodeStream stream, int bci) { - super(stream, bci); - } - - /** - * Constructor for a bytecode array. - * @param code the bytecode array containing the switch instruction. - * @param bci the index in the array of the switch instruction - */ - public BytecodeTableSwitch(byte[] code, int bci) { - super(code, bci); - } - - /** - * Gets the low key of the table switch. - * @return the low key - */ - public int lowKey() { - return readWord(alignedBci + OFFSET_TO_LOW_KEY); - } - - /** - * Gets the high key of the table switch. - * @return the high key - */ - public int highKey() { - return readWord(alignedBci + OFFSET_TO_HIGH_KEY); - } - - @Override - public int keyAt(int i) { - return lowKey() + i; - } - - @Override - public int defaultOffset() { - return readWord(alignedBci); - } - - @Override - public int offsetAt(int i) { - return readWord(alignedBci + OFFSET_TO_FIRST_JUMP_OFFSET + JUMP_OFFSET_SIZE * i); - } - - @Override - public int numberOfCases() { - return highKey() - lowKey() + 1; - } - - @Override - public int size() { - return alignedBci + OFFSET_TO_FIRST_JUMP_OFFSET + JUMP_OFFSET_SIZE * numberOfCases() - bci; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/bytecode/Bytecodes.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,961 +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. - * - * 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.cri.bytecode; - -import static com.sun.cri.bytecode.Bytecodes.Flags.*; - -import java.io.*; -import java.lang.reflect.*; -import java.util.regex.*; - -/** - * The definitions of the bytecodes that are valid input to the compiler and - * related utility methods. This comprises two groups: the standard Java - * bytecodes defined by <a href= - * "http://java.sun.com/docs/books/jvms/second_edition/html/VMSpecTOC.doc.html"> - * Java Virtual Machine Specification</a>, and a set of <i>extended</i> - * bytecodes that support low-level programming, for example, memory barriers. - * - * The extended bytecodes are one or three bytes in size. The one-byte bytecodes - * follow the values in the standard set, with no gap. The three-byte extended - * bytecodes share a common first byte and carry additional instruction-specific - * information in the second and third bytes. - */ -public class Bytecodes { - public static final int NOP = 0; // 0x00 - public static final int ACONST_NULL = 1; // 0x01 - public static final int ICONST_M1 = 2; // 0x02 - public static final int ICONST_0 = 3; // 0x03 - public static final int ICONST_1 = 4; // 0x04 - public static final int ICONST_2 = 5; // 0x05 - public static final int ICONST_3 = 6; // 0x06 - public static final int ICONST_4 = 7; // 0x07 - public static final int ICONST_5 = 8; // 0x08 - public static final int LCONST_0 = 9; // 0x09 - public static final int LCONST_1 = 10; // 0x0A - public static final int FCONST_0 = 11; // 0x0B - public static final int FCONST_1 = 12; // 0x0C - public static final int FCONST_2 = 13; // 0x0D - public static final int DCONST_0 = 14; // 0x0E - public static final int DCONST_1 = 15; // 0x0F - public static final int BIPUSH = 16; // 0x10 - public static final int SIPUSH = 17; // 0x11 - public static final int LDC = 18; // 0x12 - public static final int LDC_W = 19; // 0x13 - public static final int LDC2_W = 20; // 0x14 - public static final int ILOAD = 21; // 0x15 - public static final int LLOAD = 22; // 0x16 - public static final int FLOAD = 23; // 0x17 - public static final int DLOAD = 24; // 0x18 - public static final int ALOAD = 25; // 0x19 - public static final int ILOAD_0 = 26; // 0x1A - public static final int ILOAD_1 = 27; // 0x1B - public static final int ILOAD_2 = 28; // 0x1C - public static final int ILOAD_3 = 29; // 0x1D - public static final int LLOAD_0 = 30; // 0x1E - public static final int LLOAD_1 = 31; // 0x1F - public static final int LLOAD_2 = 32; // 0x20 - public static final int LLOAD_3 = 33; // 0x21 - public static final int FLOAD_0 = 34; // 0x22 - public static final int FLOAD_1 = 35; // 0x23 - public static final int FLOAD_2 = 36; // 0x24 - public static final int FLOAD_3 = 37; // 0x25 - public static final int DLOAD_0 = 38; // 0x26 - public static final int DLOAD_1 = 39; // 0x27 - public static final int DLOAD_2 = 40; // 0x28 - public static final int DLOAD_3 = 41; // 0x29 - public static final int ALOAD_0 = 42; // 0x2A - public static final int ALOAD_1 = 43; // 0x2B - public static final int ALOAD_2 = 44; // 0x2C - public static final int ALOAD_3 = 45; // 0x2D - public static final int IALOAD = 46; // 0x2E - public static final int LALOAD = 47; // 0x2F - public static final int FALOAD = 48; // 0x30 - public static final int DALOAD = 49; // 0x31 - public static final int AALOAD = 50; // 0x32 - public static final int BALOAD = 51; // 0x33 - public static final int CALOAD = 52; // 0x34 - public static final int SALOAD = 53; // 0x35 - public static final int ISTORE = 54; // 0x36 - public static final int LSTORE = 55; // 0x37 - public static final int FSTORE = 56; // 0x38 - public static final int DSTORE = 57; // 0x39 - public static final int ASTORE = 58; // 0x3A - public static final int ISTORE_0 = 59; // 0x3B - public static final int ISTORE_1 = 60; // 0x3C - public static final int ISTORE_2 = 61; // 0x3D - public static final int ISTORE_3 = 62; // 0x3E - public static final int LSTORE_0 = 63; // 0x3F - public static final int LSTORE_1 = 64; // 0x40 - public static final int LSTORE_2 = 65; // 0x41 - public static final int LSTORE_3 = 66; // 0x42 - public static final int FSTORE_0 = 67; // 0x43 - public static final int FSTORE_1 = 68; // 0x44 - public static final int FSTORE_2 = 69; // 0x45 - public static final int FSTORE_3 = 70; // 0x46 - public static final int DSTORE_0 = 71; // 0x47 - public static final int DSTORE_1 = 72; // 0x48 - public static final int DSTORE_2 = 73; // 0x49 - public static final int DSTORE_3 = 74; // 0x4A - public static final int ASTORE_0 = 75; // 0x4B - public static final int ASTORE_1 = 76; // 0x4C - public static final int ASTORE_2 = 77; // 0x4D - public static final int ASTORE_3 = 78; // 0x4E - public static final int IASTORE = 79; // 0x4F - public static final int LASTORE = 80; // 0x50 - public static final int FASTORE = 81; // 0x51 - public static final int DASTORE = 82; // 0x52 - public static final int AASTORE = 83; // 0x53 - public static final int BASTORE = 84; // 0x54 - public static final int CASTORE = 85; // 0x55 - public static final int SASTORE = 86; // 0x56 - public static final int POP = 87; // 0x57 - public static final int POP2 = 88; // 0x58 - public static final int DUP = 89; // 0x59 - public static final int DUP_X1 = 90; // 0x5A - public static final int DUP_X2 = 91; // 0x5B - public static final int DUP2 = 92; // 0x5C - public static final int DUP2_X1 = 93; // 0x5D - public static final int DUP2_X2 = 94; // 0x5E - public static final int SWAP = 95; // 0x5F - public static final int IADD = 96; // 0x60 - public static final int LADD = 97; // 0x61 - public static final int FADD = 98; // 0x62 - public static final int DADD = 99; // 0x63 - public static final int ISUB = 100; // 0x64 - public static final int LSUB = 101; // 0x65 - public static final int FSUB = 102; // 0x66 - public static final int DSUB = 103; // 0x67 - public static final int IMUL = 104; // 0x68 - public static final int LMUL = 105; // 0x69 - public static final int FMUL = 106; // 0x6A - public static final int DMUL = 107; // 0x6B - public static final int IDIV = 108; // 0x6C - public static final int LDIV = 109; // 0x6D - public static final int FDIV = 110; // 0x6E - public static final int DDIV = 111; // 0x6F - public static final int IREM = 112; // 0x70 - public static final int LREM = 113; // 0x71 - public static final int FREM = 114; // 0x72 - public static final int DREM = 115; // 0x73 - public static final int INEG = 116; // 0x74 - public static final int LNEG = 117; // 0x75 - public static final int FNEG = 118; // 0x76 - public static final int DNEG = 119; // 0x77 - public static final int ISHL = 120; // 0x78 - public static final int LSHL = 121; // 0x79 - public static final int ISHR = 122; // 0x7A - public static final int LSHR = 123; // 0x7B - public static final int IUSHR = 124; // 0x7C - public static final int LUSHR = 125; // 0x7D - public static final int IAND = 126; // 0x7E - public static final int LAND = 127; // 0x7F - public static final int IOR = 128; // 0x80 - public static final int LOR = 129; // 0x81 - public static final int IXOR = 130; // 0x82 - public static final int LXOR = 131; // 0x83 - public static final int IINC = 132; // 0x84 - public static final int I2L = 133; // 0x85 - public static final int I2F = 134; // 0x86 - public static final int I2D = 135; // 0x87 - public static final int L2I = 136; // 0x88 - public static final int L2F = 137; // 0x89 - public static final int L2D = 138; // 0x8A - public static final int F2I = 139; // 0x8B - public static final int F2L = 140; // 0x8C - public static final int F2D = 141; // 0x8D - public static final int D2I = 142; // 0x8E - public static final int D2L = 143; // 0x8F - public static final int D2F = 144; // 0x90 - public static final int I2B = 145; // 0x91 - public static final int I2C = 146; // 0x92 - public static final int I2S = 147; // 0x93 - public static final int LCMP = 148; // 0x94 - public static final int FCMPL = 149; // 0x95 - public static final int FCMPG = 150; // 0x96 - public static final int DCMPL = 151; // 0x97 - public static final int DCMPG = 152; // 0x98 - public static final int IFEQ = 153; // 0x99 - public static final int IFNE = 154; // 0x9A - public static final int IFLT = 155; // 0x9B - public static final int IFGE = 156; // 0x9C - public static final int IFGT = 157; // 0x9D - public static final int IFLE = 158; // 0x9E - public static final int IF_ICMPEQ = 159; // 0x9F - public static final int IF_ICMPNE = 160; // 0xA0 - public static final int IF_ICMPLT = 161; // 0xA1 - public static final int IF_ICMPGE = 162; // 0xA2 - public static final int IF_ICMPGT = 163; // 0xA3 - public static final int IF_ICMPLE = 164; // 0xA4 - public static final int IF_ACMPEQ = 165; // 0xA5 - public static final int IF_ACMPNE = 166; // 0xA6 - public static final int GOTO = 167; // 0xA7 - public static final int JSR = 168; // 0xA8 - public static final int RET = 169; // 0xA9 - public static final int TABLESWITCH = 170; // 0xAA - public static final int LOOKUPSWITCH = 171; // 0xAB - public static final int IRETURN = 172; // 0xAC - public static final int LRETURN = 173; // 0xAD - public static final int FRETURN = 174; // 0xAE - public static final int DRETURN = 175; // 0xAF - public static final int ARETURN = 176; // 0xB0 - public static final int RETURN = 177; // 0xB1 - public static final int GETSTATIC = 178; // 0xB2 - public static final int PUTSTATIC = 179; // 0xB3 - public static final int GETFIELD = 180; // 0xB4 - public static final int PUTFIELD = 181; // 0xB5 - public static final int INVOKEVIRTUAL = 182; // 0xB6 - public static final int INVOKESPECIAL = 183; // 0xB7 - public static final int INVOKESTATIC = 184; // 0xB8 - public static final int INVOKEINTERFACE = 185; // 0xB9 - public static final int XXXUNUSEDXXX = 186; // 0xBA - public static final int NEW = 187; // 0xBB - public static final int NEWARRAY = 188; // 0xBC - public static final int ANEWARRAY = 189; // 0xBD - public static final int ARRAYLENGTH = 190; // 0xBE - public static final int ATHROW = 191; // 0xBF - public static final int CHECKCAST = 192; // 0xC0 - public static final int INSTANCEOF = 193; // 0xC1 - public static final int MONITORENTER = 194; // 0xC2 - public static final int MONITOREXIT = 195; // 0xC3 - public static final int WIDE = 196; // 0xC4 - public static final int MULTIANEWARRAY = 197; // 0xC5 - public static final int IFNULL = 198; // 0xC6 - public static final int IFNONNULL = 199; // 0xC7 - public static final int GOTO_W = 200; // 0xC8 - public static final int JSR_W = 201; // 0xC9 - public static final int BREAKPOINT = 202; // 0xCA - - public static final int ILLEGAL = 255; - public static final int END = 256; - - /** - * The last opcode defined by the JVM specification. To iterate over all JVM bytecodes: - * <pre> - * for (int opcode = 0; opcode <= Bytecodes.LAST_JVM_OPCODE; ++opcode) { - * // - * } - * </pre> - */ - public static final int LAST_JVM_OPCODE = JSR_W; - - /** - * A collection of flags describing various bytecode attributes. - */ - static class Flags { - - /** - * Denotes an instruction that ends a basic block and does not let control flow fall through to its lexical successor. - */ - static final int STOP = 0x00000001; - - /** - * Denotes an instruction that ends a basic block and may let control flow fall through to its lexical successor. - * In practice this means it is a conditional branch. - */ - static final int FALL_THROUGH = 0x00000002; - - /** - * Denotes an instruction that has a 2 or 4 byte operand that is an offset to another instruction in the same method. - * This does not include the {@link Bytecodes#TABLESWITCH} or {@link Bytecodes#LOOKUPSWITCH} instructions. - */ - static final int BRANCH = 0x00000004; - - /** - * Denotes an instruction that reads the value of a static or instance field. - */ - static final int FIELD_READ = 0x00000008; - - /** - * Denotes an instruction that writes the value of a static or instance field. - */ - static final int FIELD_WRITE = 0x00000010; - - /** - * Denotes an instruction that is not defined in the JVM specification. - */ - static final int EXTENSION = 0x00000020; - - /** - * Denotes an instruction that can cause a trap. - */ - static final int TRAP = 0x00000080; - /** - * Denotes an instruction that is commutative. - */ - static final int COMMUTATIVE = 0x00000100; - /** - * Denotes an instruction that is associative. - */ - static final int ASSOCIATIVE = 0x00000200; - /** - * Denotes an instruction that loads an operand. - */ - static final int LOAD = 0x00000400; - /** - * Denotes an instruction that stores an operand. - */ - static final int STORE = 0x00000800; - /** - * Denotes the 4 INVOKE* instructions. - */ - static final int INVOKE = 0x00001000; - } - - // Performs a sanity check that none of the flags overlap. - static { - int allFlags = 0; - try { - for (Field field : Flags.class.getDeclaredFields()) { - int flagsFilter = Modifier.FINAL | Modifier.STATIC; - if ((field.getModifiers() & flagsFilter) == flagsFilter) { - assert field.getType() == int.class : "Only " + field; - final int flag = field.getInt(null); - assert flag != 0; - assert (flag & allFlags) == 0 : field.getName() + " has a value conflicting with another flag"; - allFlags |= flag; - } - } - } catch (Exception e) { - throw new InternalError(e.toString()); - } - } - - /** - * A array that maps from a bytecode value to a {@link String} for the corresponding instruction mnemonic. - * This will include the root instruction for the three-byte extended instructions. - */ - private static final String[] nameArray = new String[256]; - - /** - * A array that maps from a bytecode value to the set of {@link Flags} for the corresponding instruction. - */ - private static final int[] flagsArray = new int[256]; - - /** - * A array that maps from a bytecode value to the length in bytes for the corresponding instruction. - */ - private static final int[] lengthArray = new int[256]; - - // Checkstyle: stop - static { - def(NOP , "nop" , "b" ); - def(ACONST_NULL , "aconst_null" , "b" ); - def(ICONST_M1 , "iconst_m1" , "b" ); - def(ICONST_0 , "iconst_0" , "b" ); - def(ICONST_1 , "iconst_1" , "b" ); - def(ICONST_2 , "iconst_2" , "b" ); - def(ICONST_3 , "iconst_3" , "b" ); - def(ICONST_4 , "iconst_4" , "b" ); - def(ICONST_5 , "iconst_5" , "b" ); - def(LCONST_0 , "lconst_0" , "b" ); - def(LCONST_1 , "lconst_1" , "b" ); - def(FCONST_0 , "fconst_0" , "b" ); - def(FCONST_1 , "fconst_1" , "b" ); - def(FCONST_2 , "fconst_2" , "b" ); - def(DCONST_0 , "dconst_0" , "b" ); - def(DCONST_1 , "dconst_1" , "b" ); - def(BIPUSH , "bipush" , "bc" ); - def(SIPUSH , "sipush" , "bcc" ); - def(LDC , "ldc" , "bi" , TRAP); - def(LDC_W , "ldc_w" , "bii" , TRAP); - def(LDC2_W , "ldc2_w" , "bii" , TRAP); - def(ILOAD , "iload" , "bi" , LOAD); - def(LLOAD , "lload" , "bi" , LOAD); - def(FLOAD , "fload" , "bi" , LOAD); - def(DLOAD , "dload" , "bi" , LOAD); - def(ALOAD , "aload" , "bi" , LOAD); - def(ILOAD_0 , "iload_0" , "b" , LOAD); - def(ILOAD_1 , "iload_1" , "b" , LOAD); - def(ILOAD_2 , "iload_2" , "b" , LOAD); - def(ILOAD_3 , "iload_3" , "b" , LOAD); - def(LLOAD_0 , "lload_0" , "b" , LOAD); - def(LLOAD_1 , "lload_1" , "b" , LOAD); - def(LLOAD_2 , "lload_2" , "b" , LOAD); - def(LLOAD_3 , "lload_3" , "b" , LOAD); - def(FLOAD_0 , "fload_0" , "b" , LOAD); - def(FLOAD_1 , "fload_1" , "b" , LOAD); - def(FLOAD_2 , "fload_2" , "b" , LOAD); - def(FLOAD_3 , "fload_3" , "b" , LOAD); - def(DLOAD_0 , "dload_0" , "b" , LOAD); - def(DLOAD_1 , "dload_1" , "b" , LOAD); - def(DLOAD_2 , "dload_2" , "b" , LOAD); - def(DLOAD_3 , "dload_3" , "b" , LOAD); - def(ALOAD_0 , "aload_0" , "b" , LOAD); - def(ALOAD_1 , "aload_1" , "b" , LOAD); - def(ALOAD_2 , "aload_2" , "b" , LOAD); - def(ALOAD_3 , "aload_3" , "b" , LOAD); - def(IALOAD , "iaload" , "b" , TRAP); - def(LALOAD , "laload" , "b" , TRAP); - def(FALOAD , "faload" , "b" , TRAP); - def(DALOAD , "daload" , "b" , TRAP); - def(AALOAD , "aaload" , "b" , TRAP); - def(BALOAD , "baload" , "b" , TRAP); - def(CALOAD , "caload" , "b" , TRAP); - def(SALOAD , "saload" , "b" , TRAP); - def(ISTORE , "istore" , "bi" , STORE); - def(LSTORE , "lstore" , "bi" , STORE); - def(FSTORE , "fstore" , "bi" , STORE); - def(DSTORE , "dstore" , "bi" , STORE); - def(ASTORE , "astore" , "bi" , STORE); - def(ISTORE_0 , "istore_0" , "b" , STORE); - def(ISTORE_1 , "istore_1" , "b" , STORE); - def(ISTORE_2 , "istore_2" , "b" , STORE); - def(ISTORE_3 , "istore_3" , "b" , STORE); - def(LSTORE_0 , "lstore_0" , "b" , STORE); - def(LSTORE_1 , "lstore_1" , "b" , STORE); - def(LSTORE_2 , "lstore_2" , "b" , STORE); - def(LSTORE_3 , "lstore_3" , "b" , STORE); - def(FSTORE_0 , "fstore_0" , "b" , STORE); - def(FSTORE_1 , "fstore_1" , "b" , STORE); - def(FSTORE_2 , "fstore_2" , "b" , STORE); - def(FSTORE_3 , "fstore_3" , "b" , STORE); - def(DSTORE_0 , "dstore_0" , "b" , STORE); - def(DSTORE_1 , "dstore_1" , "b" , STORE); - def(DSTORE_2 , "dstore_2" , "b" , STORE); - def(DSTORE_3 , "dstore_3" , "b" , STORE); - def(ASTORE_0 , "astore_0" , "b" , STORE); - def(ASTORE_1 , "astore_1" , "b" , STORE); - def(ASTORE_2 , "astore_2" , "b" , STORE); - def(ASTORE_3 , "astore_3" , "b" , STORE); - def(IASTORE , "iastore" , "b" , TRAP); - def(LASTORE , "lastore" , "b" , TRAP); - def(FASTORE , "fastore" , "b" , TRAP); - def(DASTORE , "dastore" , "b" , TRAP); - def(AASTORE , "aastore" , "b" , TRAP); - def(BASTORE , "bastore" , "b" , TRAP); - def(CASTORE , "castore" , "b" , TRAP); - def(SASTORE , "sastore" , "b" , TRAP); - def(POP , "pop" , "b" ); - def(POP2 , "pop2" , "b" ); - def(DUP , "dup" , "b" ); - def(DUP_X1 , "dup_x1" , "b" ); - def(DUP_X2 , "dup_x2" , "b" ); - def(DUP2 , "dup2" , "b" ); - def(DUP2_X1 , "dup2_x1" , "b" ); - def(DUP2_X2 , "dup2_x2" , "b" ); - def(SWAP , "swap" , "b" ); - def(IADD , "iadd" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(LADD , "ladd" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(FADD , "fadd" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(DADD , "dadd" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(ISUB , "isub" , "b" ); - def(LSUB , "lsub" , "b" ); - def(FSUB , "fsub" , "b" ); - def(DSUB , "dsub" , "b" ); - def(IMUL , "imul" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(LMUL , "lmul" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(FMUL , "fmul" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(DMUL , "dmul" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(IDIV , "idiv" , "b" , TRAP); - def(LDIV , "ldiv" , "b" , TRAP); - def(FDIV , "fdiv" , "b" ); - def(DDIV , "ddiv" , "b" ); - def(IREM , "irem" , "b" , TRAP); - def(LREM , "lrem" , "b" , TRAP); - def(FREM , "frem" , "b" ); - def(DREM , "drem" , "b" ); - def(INEG , "ineg" , "b" ); - def(LNEG , "lneg" , "b" ); - def(FNEG , "fneg" , "b" ); - def(DNEG , "dneg" , "b" ); - def(ISHL , "ishl" , "b" ); - def(LSHL , "lshl" , "b" ); - def(ISHR , "ishr" , "b" ); - def(LSHR , "lshr" , "b" ); - def(IUSHR , "iushr" , "b" ); - def(LUSHR , "lushr" , "b" ); - def(IAND , "iand" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(LAND , "land" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(IOR , "ior" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(LOR , "lor" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(IXOR , "ixor" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(LXOR , "lxor" , "b" , COMMUTATIVE | ASSOCIATIVE); - def(IINC , "iinc" , "bic" , LOAD | STORE); - def(I2L , "i2l" , "b" ); - def(I2F , "i2f" , "b" ); - def(I2D , "i2d" , "b" ); - def(L2I , "l2i" , "b" ); - def(L2F , "l2f" , "b" ); - def(L2D , "l2d" , "b" ); - def(F2I , "f2i" , "b" ); - def(F2L , "f2l" , "b" ); - def(F2D , "f2d" , "b" ); - def(D2I , "d2i" , "b" ); - def(D2L , "d2l" , "b" ); - def(D2F , "d2f" , "b" ); - def(I2B , "i2b" , "b" ); - def(I2C , "i2c" , "b" ); - def(I2S , "i2s" , "b" ); - def(LCMP , "lcmp" , "b" ); - def(FCMPL , "fcmpl" , "b" ); - def(FCMPG , "fcmpg" , "b" ); - def(DCMPL , "dcmpl" , "b" ); - def(DCMPG , "dcmpg" , "b" ); - def(IFEQ , "ifeq" , "boo" , FALL_THROUGH | BRANCH); - def(IFNE , "ifne" , "boo" , FALL_THROUGH | BRANCH); - def(IFLT , "iflt" , "boo" , FALL_THROUGH | BRANCH); - def(IFGE , "ifge" , "boo" , FALL_THROUGH | BRANCH); - def(IFGT , "ifgt" , "boo" , FALL_THROUGH | BRANCH); - def(IFLE , "ifle" , "boo" , FALL_THROUGH | BRANCH); - def(IF_ICMPEQ , "if_icmpeq" , "boo" , COMMUTATIVE | FALL_THROUGH | BRANCH); - def(IF_ICMPNE , "if_icmpne" , "boo" , COMMUTATIVE | FALL_THROUGH | BRANCH); - def(IF_ICMPLT , "if_icmplt" , "boo" , FALL_THROUGH | BRANCH); - def(IF_ICMPGE , "if_icmpge" , "boo" , FALL_THROUGH | BRANCH); - def(IF_ICMPGT , "if_icmpgt" , "boo" , FALL_THROUGH | BRANCH); - def(IF_ICMPLE , "if_icmple" , "boo" , FALL_THROUGH | BRANCH); - def(IF_ACMPEQ , "if_acmpeq" , "boo" , COMMUTATIVE | FALL_THROUGH | BRANCH); - def(IF_ACMPNE , "if_acmpne" , "boo" , COMMUTATIVE | FALL_THROUGH | BRANCH); - def(GOTO , "goto" , "boo" , STOP | BRANCH); - def(JSR , "jsr" , "boo" , STOP | BRANCH); - def(RET , "ret" , "bi" , STOP); - def(TABLESWITCH , "tableswitch" , "" , STOP); - def(LOOKUPSWITCH , "lookupswitch" , "" , STOP); - def(IRETURN , "ireturn" , "b" , TRAP | STOP); - def(LRETURN , "lreturn" , "b" , TRAP | STOP); - def(FRETURN , "freturn" , "b" , TRAP | STOP); - def(DRETURN , "dreturn" , "b" , TRAP | STOP); - def(ARETURN , "areturn" , "b" , TRAP | STOP); - def(RETURN , "return" , "b" , TRAP | STOP); - def(GETSTATIC , "getstatic" , "bjj" , TRAP | FIELD_READ); - def(PUTSTATIC , "putstatic" , "bjj" , TRAP | FIELD_WRITE); - def(GETFIELD , "getfield" , "bjj" , TRAP | FIELD_READ); - def(PUTFIELD , "putfield" , "bjj" , TRAP | FIELD_WRITE); - def(INVOKEVIRTUAL , "invokevirtual" , "bjj" , TRAP | INVOKE); - def(INVOKESPECIAL , "invokespecial" , "bjj" , TRAP | INVOKE); - def(INVOKESTATIC , "invokestatic" , "bjj" , TRAP | INVOKE); - def(INVOKEINTERFACE , "invokeinterface" , "bjja_", TRAP | INVOKE); - def(XXXUNUSEDXXX , "xxxunusedxxx" , "" ); - def(NEW , "new" , "bii" , TRAP); - def(NEWARRAY , "newarray" , "bc" , TRAP); - def(ANEWARRAY , "anewarray" , "bii" , TRAP); - def(ARRAYLENGTH , "arraylength" , "b" , TRAP); - def(ATHROW , "athrow" , "b" , TRAP | STOP); - def(CHECKCAST , "checkcast" , "bii" , TRAP); - def(INSTANCEOF , "instanceof" , "bii" , TRAP); - def(MONITORENTER , "monitorenter" , "b" , TRAP); - def(MONITOREXIT , "monitorexit" , "b" , TRAP); - def(WIDE , "wide" , "" ); - def(MULTIANEWARRAY , "multianewarray" , "biic" , TRAP); - def(IFNULL , "ifnull" , "boo" , FALL_THROUGH | BRANCH); - def(IFNONNULL , "ifnonnull" , "boo" , FALL_THROUGH | BRANCH); - def(GOTO_W , "goto_w" , "boooo", STOP | BRANCH); - def(JSR_W , "jsr_w" , "boooo", STOP | BRANCH); - def(BREAKPOINT , "breakpoint" , "b" , TRAP); - } - // Checkstyle: resume - - /** - * Determines if an opcode is commutative. - * @param opcode the opcode to check - * @return {@code true} iff commutative - */ - public static boolean isCommutative(int opcode) { - return (flagsArray[opcode & 0xff] & COMMUTATIVE) != 0; - } - - /** - * Gets the length of an instruction denoted by a given opcode. - * - * @param opcode an instruction opcode - * @return the length of the instruction denoted by {@code opcode}. If {@code opcode} is an illegal instruction or denotes a - * variable length instruction (e.g. {@link #TABLESWITCH}), then 0 is returned. - */ - public static int lengthOf(int opcode) { - return lengthArray[opcode & 0xff]; - } - - /** - * Gets the length of an instruction at a given position in a given bytecode array. - * This methods handles variable length and {@linkplain #WIDE widened} instructions. - * - * @param code an array of bytecode - * @param bci the position in {@code code} of an instruction's opcode - * @return the length of the instruction at position {@code bci} in {@code code} - */ - public static int lengthOf(byte[] code, int bci) { - int opcode = Bytes.beU1(code, bci); - int length = Bytecodes.lengthArray[opcode & 0xff]; - if (length == 0) { - switch (opcode) { - case TABLESWITCH: { - return new BytecodeTableSwitch(code, bci).size(); - } - case LOOKUPSWITCH: { - return new BytecodeLookupSwitch(code, bci).size(); - } - case WIDE: { - int opc = Bytes.beU1(code, bci + 1); - if (opc == RET) { - return 4; - } else if (opc == IINC) { - return 6; - } else { - return 4; // a load or store bytecode - } - } - default: - throw new Error("unknown variable-length bytecode: " + opcode); - } - } - return length; - } - - /** - * Gets the lower-case mnemonic for a given opcode. - * - * @param opcode an opcode - * @return the mnemonic for {@code opcode} or {@code "<illegal opcode: " + opcode + ">"} if {@code opcode} is not a legal opcode - */ - public static String nameOf(int opcode) throws IllegalArgumentException { - String name = nameArray[opcode & 0xff]; - if (name == null) { - return "<illegal opcode: " + opcode + ">"; - } - return name; - } - - /** - * Allocation-free version of {@linkplain #nameOf(int)}. - * @param opcode an opcode. - * @return the mnemonic for {@code opcode} or {@code "<illegal opcode>"} if {@code opcode} is not a legal opcode. - */ - public static String baseNameOf(int opcode) { - String name = nameArray[opcode & 0xff]; - if (name == null) { - return "<illegal opcode>"; - } - return name; - } - - /** - * Gets the opcode corresponding to a given mnemonic. - * - * @param name an opcode mnemonic - * @return the opcode corresponding to {@code mnemonic} - * @throws IllegalArgumentException if {@code name} does not denote a valid opcode - */ - public static int valueOf(String name) { - for (int opcode = 0; opcode < nameArray.length; ++opcode) { - if (name.equalsIgnoreCase(nameArray[opcode])) { - return opcode; - } - } - throw new IllegalArgumentException("No opcode for " + name); - } - - /** - * Determines if a given opcode denotes an instruction that can cause an implicit exception. - * - * @param opcode an opcode to test - * @return {@code true} iff {@code opcode} can cause an implicit exception, {@code false} otherwise - */ - public static boolean canTrap(int opcode) { - return (flagsArray[opcode & 0xff] & TRAP) != 0; - } - - /** - * Determines if a given opcode denotes an instruction that loads a local variable to the operand stack. - * - * @param opcode an opcode to test - * @return {@code true} iff {@code opcode} loads a local variable to the operand stack, {@code false} otherwise - */ - public static boolean isLoad(int opcode) { - return (flagsArray[opcode & 0xff] & LOAD) != 0; - } - - /** - * Determines if a given opcode denotes an instruction that ends a basic block and does not let control flow fall - * through to its lexical successor. - * - * @param opcode an opcode to test - * @return {@code true} iff {@code opcode} properly ends a basic block - */ - public static boolean isStop(int opcode) { - return (flagsArray[opcode & 0xff] & STOP) != 0; - } - - /** - * Determines if a given opcode denotes an instruction that stores a value to a local variable - * after popping it from the operand stack. - * - * @param opcode an opcode to test - * @return {@code true} iff {@code opcode} stores a value to a local variable, {@code false} otherwise - */ - public static boolean isInvoke(int opcode) { - return (flagsArray[opcode & 0xff] & INVOKE) != 0; - } - - /** - * Determines if a given opcode denotes an instruction that stores a value to a local variable - * after popping it from the operand stack. - * - * @param opcode an opcode to test - * @return {@code true} iff {@code opcode} stores a value to a local variable, {@code false} otherwise - */ - public static boolean isStore(int opcode) { - return (flagsArray[opcode & 0xff] & STORE) != 0; - } - - /** - * Determines if a given opcode is an instruction that delimits a basic block. - * - * @param opcode an opcode to test - * @return {@code true} iff {@code opcode} delimits a basic block - */ - public static boolean isBlockEnd(int opcode) { - return (flagsArray[opcode & 0xff] & (STOP | FALL_THROUGH)) != 0; - } - - /** - * Determines if a given opcode is an instruction that has a 2 or 4 byte operand that is an offset to another - * instruction in the same method. This does not include the {@linkplain #TABLESWITCH switch} instructions. - * - * @param opcode an opcode to test - * @return {@code true} iff {@code opcode} is a branch instruction with a single operand - */ - public static boolean isBranch(int opcode) { - return (flagsArray[opcode & 0xff] & BRANCH) != 0; - } - - /** - * Determines if a given opcode denotes a conditional branch. - * @param opcode - * @return {@code true} iff {@code opcode} is a conditional branch - */ - public static boolean isConditionalBranch(int opcode) { - return (flagsArray[opcode & 0xff] & FALL_THROUGH) != 0; - } - - /** - * Determines if a given opcode denotes a standard bytecode. A standard bytecode is - * defined in the JVM specification. - * - * @param opcode an opcode to test - * @return {@code true} iff {@code opcode} is a standard bytecode - */ - public static boolean isStandard(int opcode) { - return (flagsArray[opcode & 0xff] & EXTENSION) == 0; - } - - /** - * Determines if a given opcode denotes an extended bytecode. - * - * @param opcode an opcode to test - * @return {@code true} if {@code opcode} is an extended bytecode - */ - public static boolean isExtended(int opcode) { - return (flagsArray[opcode & 0xff] & EXTENSION) != 0; - } - - /** - * Determines if a given opcode is a three-byte extended bytecode. - * - * @param opcode an opcode to test - * @return {@code true} if {@code (opcode & ~0xff) != 0} - */ - public static boolean isThreeByteExtended(int opcode) { - return (opcode & ~0xff) != 0; - } - - /** - * Gets the arithmetic operator name for a given opcode. If {@code opcode} does not denote an - * arithmetic instruction, then the {@linkplain #nameOf(int) name} of the opcode is returned - * instead. - * - * @param op an opcode - * @return the arithmetic operator name - */ - public static String operator(int op) { - // Checkstyle: stop - switch (op) { - // arithmetic ops - case IADD : // fall through - case LADD : // fall through - case FADD : // fall through - case DADD : return "+"; - case ISUB : // fall through - case LSUB : // fall through - case FSUB : // fall through - case DSUB : return "-"; - case IMUL : // fall through - case LMUL : // fall through - case FMUL : // fall through - case DMUL : return "*"; - case IDIV : // fall through - case LDIV : // fall through - case FDIV : // fall through - case DDIV : return "/"; - case IREM : // fall through - case LREM : // fall through - case FREM : // fall through - case DREM : return "%"; - // shift ops - case ISHL : // fall through - case LSHL : return "<<"; - case ISHR : // fall through - case LSHR : return ">>"; - case IUSHR: // fall through - case LUSHR: return ">>>"; - // logic ops - case IAND : // fall through - case LAND : return "&"; - case IOR : // fall through - case LOR : return "|"; - case IXOR : // fall through - case LXOR : return "^"; - } - // Checkstyle: resume - return nameOf(op); - } - - /** - * Defines a bytecode by entering it into the arrays that record its name, length and flags. - * - * @param name instruction name (should be lower case) - * @param format encodes the length of the instruction - * @param flagsArray the set of {@link Flags} associated with the instruction - */ - private static void def(int opcode, String name, String format) { - def(opcode, name, format, 0); - } - - /** - * Defines a bytecode by entering it into the arrays that record its name, length and flags. - * - * @param name instruction name (lower case) - * @param format encodes the length of the instruction - * @param flags the set of {@link Flags} associated with the instruction - */ - private static void def(int opcode, String name, String format, int flags) { - assert nameArray[opcode] == null : "opcode " + opcode + " is already bound to name " + nameArray[opcode]; - nameArray[opcode] = name; - int instructionLength = format.length(); - lengthArray[opcode] = instructionLength; - Bytecodes.flagsArray[opcode] = flags; - - assert !isConditionalBranch(opcode) || isBranch(opcode) : "a conditional branch must also be a branch"; - } - - /** - * Utility for ensuring that the extended opcodes are contiguous and follow on directly - * from the standard JVM opcodes. If these conditions do not hold for the input source - * file, then it is modified 'in situ' to fix the problem. - * - * @param args {@code args[0]} is the path to this source file - */ - public static void main(String[] args) throws Exception { - Method findWorkspaceDirectory = Class.forName("com.sun.max.ide.JavaProject").getDeclaredMethod("findWorkspaceDirectory"); - File base = new File((File) findWorkspaceDirectory.invoke(null), "com.oracle.max.cri/src"); - File file = new File(base, Bytecodes.class.getName().replace('.', File.separatorChar) + ".java").getAbsoluteFile(); - - Pattern opcodeDecl = Pattern.compile("(\\s*public static final int )(\\w+)(\\s*=\\s*)(\\d+)(;.*)"); - - BufferedReader br = new BufferedReader(new FileReader(file)); - CharArrayWriter buffer = new CharArrayWriter((int) file.length()); - PrintWriter out = new PrintWriter(buffer); - String line; - int lastExtendedOpcode = BREAKPOINT; - boolean modified = false; - int section = 0; - while ((line = br.readLine()) != null) { - if (section == 0) { - if (line.equals(" // Start extended bytecodes")) { - section = 1; - } - } else if (section == 1) { - if (line.equals(" // End extended bytecodes")) { - section = 2; - } else { - Matcher matcher = opcodeDecl.matcher(line); - if (matcher.matches()) { - String name = matcher.group(2); - String value = matcher.group(4); - int opcode = Integer.parseInt(value); - if (nameArray[opcode] == null || !nameArray[opcode].equalsIgnoreCase(name)) { - throw new RuntimeException("Missing definition of name and flags for " + opcode + ":" + name + " -- " + nameArray[opcode]); - } - if (opcode != lastExtendedOpcode + 1) { - System.err.println("Fixed declaration of opcode " + name + " to be " + (lastExtendedOpcode + 1) + " (was " + value + ")"); - opcode = lastExtendedOpcode + 1; - line = line.substring(0, matcher.start(4)) + opcode + line.substring(matcher.end(4)); - modified = true; - } - - if (opcode >= 256) { - throw new RuntimeException("Exceeded maximum opcode value with " + name); - } - - lastExtendedOpcode = opcode; - } - } - } - - out.println(line); - } - if (section == 0) { - throw new RuntimeException("Did not find line starting extended bytecode declarations:\n\n // Start extended bytecodes"); - } else if (section == 1) { - throw new RuntimeException("Did not find line ending extended bytecode declarations:\n\n // End extended bytecodes"); - } - - if (modified) { - out.flush(); - FileWriter fileWriter = new FileWriter(file); - fileWriter.write(buffer.toCharArray()); - fileWriter.close(); - - System.out.println("Modified: " + file); - } - - - // Uncomment to print out visitor method declarations: -// for (int opcode = 0; opcode < flags.length; ++opcode) { -// if (isExtension(opcode)) { -// String visitorParams = length(opcode) == 1 ? "" : "int index"; -// System.out.println("@Override"); -// System.out.println("protected void " + name(opcode) + "(" + visitorParams + ") {"); -// System.out.println("}"); -// System.out.println(); -// } -// } - - // Uncomment to print out visitor method declarations: -// for (int opcode = 0; opcode < flags.length; ++opcode) { -// if (isExtension(opcode)) { -// System.out.println("case " + name(opcode).toUpperCase() + ": {"); -// String arg = ""; -// int length = length(opcode); -// if (length == 2) { -// arg = "readUnsigned1()"; -// } else if (length == 3) { -// arg = "readUnsigned2()"; -// } -// System.out.println(" bytecodeVisitor." + name(opcode) + "(" + arg + ");"); -// System.out.println(" break;"); -// System.out.println("}"); -// } -// } - - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/bytecode/Bytes.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,93 +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. - * - * 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.cri.bytecode; - -/** - * A collection of utility methods for dealing with bytes, particularly in byte arrays. - */ -public class Bytes { - /** - * Gets a signed 1-byte value. - * @param data the array containing the data - * @param bci the start index of the value to retrieve - * @return the signed 1-byte value at index {@code bci} in array {@code data} - */ - public static int beS1(byte[] data, int bci) { - return data[bci]; - } - - /** - * Gets a signed 2-byte big-endian value. - * @param data the array containing the data - * @param bci the start index of the value to retrieve - * @return the signed 2-byte, big-endian, value at index {@code bci} in array {@code data} - */ - public static int beS2(byte[] data, int bci) { - return (data[bci] << 8) | (data[bci + 1] & 0xff); - } - - /** - * Gets an unsigned 1-byte value. - * @param data the array containing the data - * @param bci the start index of the value to retrieve - * @return the unsigned 1-byte value at index {@code bci} in array {@code data} - */ - public static int beU1(byte[] data, int bci) { - return data[bci] & 0xff; - } - - /** - * Gets an unsigned 2-byte big-endian value. - * @param data the array containing the data - * @param bci the start index of the value to retrieve - * @return the unsigned 2-byte, big-endian, value at index {@code bci} in array {@code data} - */ - public static int beU2(byte[] data, int bci) { - return ((data[bci] & 0xff) << 8) | (data[bci + 1] & 0xff); - } - - /** - * Gets a signed 4-byte big-endian value. - * @param data the array containing the data - * @param bci the start index of the value to retrieve - * @return the signed 4-byte, big-endian, value at index {@code bci} in array {@code data} - */ - public static int beS4(byte[] data, int bci) { - return (data[bci] << 24) | ((data[bci + 1] & 0xff) << 16) | ((data[bci + 2] & 0xff) << 8) | (data[bci + 3] & 0xff); - } - - /** - * Gets either a signed 2-byte or a signed 4-byte big-endian value. - * @param data the array containing the data - * @param bci the start index of the value to retrieve - * @param fourByte if true, this method will return a 4-byte value - * @return the signed 2 or 4-byte, big-endian, value at index {@code bci} in array {@code data} - */ - public static int beSVar(byte[] data, int bci, boolean fourByte) { - if (fourByte) { - return beS4(data, bci); - } else { - return beS2(data, bci); - } - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/bytecode/package-info.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,31 +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. - * - * 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. - */ - -/** - * A collection of classes that support the processing of bytecodes. - * The majority are merely utility classes that simplify and reduce errors during bytecode processing. - */ -package com.sun.cri.bytecode; - -/** - */
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiAddress.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,237 +0,0 @@ -/* - * Copyright (c) 2010, 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 com.sun.cri.ci; - -import static com.sun.cri.ci.CiValueUtil.*; - -/** - * Represents an address in target machine memory, specified via some combination of a base register, an index register, - * a displacement and a scale. Note that the base and index registers may be {@link CiVariable variable}, that is as yet - * unassigned to target machine registers. - */ -public final class CiAddress extends CiValue { - private static final long serialVersionUID = -1003772042519945089L; - - /** - * A sentinel value used as a place holder in an instruction stream for an address that will be patched. - */ - public static final CiAddress Placeholder = new CiAddress(CiKind.Illegal, CiValue.IllegalValue); - - /** - * Base register that defines the start of the address computation; always present. - */ - public final CiValue base; - /** - * Optional index register, the value of which (possibly scaled by {@link #scale}) is added to {@link #base}. - * If not present, is denoted by {@link CiValue#IllegalValue}. - */ - public final CiValue index; - /** - * Scaling factor for indexing, dependent on target operand size. - */ - public final Scale scale; - /** - * Optional additive displacement. - */ - public final int displacement; - - /** - * Creates a {@code CiAddress} with given base register, no scaling and no displacement. - * @param kind the kind of the value being addressed - * @param base the base register - */ - public CiAddress(CiKind kind, CiValue base) { - this(kind, base, IllegalValue, Scale.Times1, 0); - } - - /** - * Creates a {@code CiAddress} with given base register, no scaling and a given displacement. - * @param kind the kind of the value being addressed - * @param base the base register - * @param displacement the displacement - */ - public CiAddress(CiKind kind, CiValue base, int displacement) { - this(kind, base, IllegalValue, Scale.Times1, displacement); - } - - /** - * Creates a {@code CiAddress} with given base and offset registers, no scaling and no displacement. - * @param kind the kind of the value being addressed - * @param base the base register - * @param offset the offset register - */ - public CiAddress(CiKind kind, CiValue base, CiValue offset) { - this(kind, base, offset, Scale.Times1, 0); - } - - /** - * Creates a {@code CiAddress} with given base and index registers, scaling and displacement. - * This is the most general constructor.. - * @param kind the kind of the value being addressed - * @param base the base register - * @param index the index register - * @param scale the scaling factor - * @param displacement the displacement - */ - public CiAddress(CiKind kind, CiValue base, CiValue index, Scale scale, int displacement) { - super(kind); - - this.base = base; - if (isConstant(index)) { - long longIndex = ((CiConstant) index).asLong(); - long longDisp = displacement + longIndex * scale.value; - if ((int) longIndex != longIndex || (int) longDisp != longDisp) { - throw new Error("integer overflow when computing constant displacement"); - } - this.displacement = (int) longDisp; - this.index = IllegalValue; - this.scale = Scale.Times1; - } else { - assert isIllegal(base) || isVariable(base) || isRegister(base); - assert isIllegal(index) || isVariable(index) || isRegister(index); - - this.index = index; - this.scale = scale; - this.displacement = displacement; - } - } - - /** - * A scaling factor used in complex addressing modes such as those supported by x86 platforms. - */ - public enum Scale { - Times1(1, 0), - Times2(2, 1), - Times4(4, 2), - Times8(8, 3); - - Scale(int value, int log2) { - this.value = value; - this.log2 = log2; - } - - /** - * The value (or multiplier) of this scale. - */ - public final int value; - - /** - * The {@linkplain #value value} of this scale log 2. - */ - public final int log2; - - public static Scale fromInt(int scale) { - // Checkstyle: stop - switch (scale) { - case 1: return Times1; - case 2: return Times2; - case 4: return Times4; - case 8: return Times8; - default: throw new IllegalArgumentException(String.valueOf(scale)); - } - // Checkstyle: resume - } - - public static Scale fromShift(int shift) { - return fromInt(1 << shift); - } - } - - /** - * Encodes the possible addressing modes as a simple value. - */ - public enum Format { - BASE, - BASE_DISP, - BASE_INDEX, - BASE_INDEX_DISP, - PLACEHOLDER; - } - - /** - * Returns the {@link Format encoded addressing mode} that this {@code CiAddress} represents. - * @return the encoded addressing mode - */ - public Format format() { - if (this == Placeholder) { - return Format.PLACEHOLDER; - } - assert isLegal(base); - if (isLegal(index)) { - if (displacement != 0) { - return Format.BASE_INDEX_DISP; - } else { - return Format.BASE_INDEX; - } - } else { - if (displacement != 0) { - return Format.BASE_DISP; - } else { - return Format.BASE; - } - } - } - - private static String s(CiValue location) { - if (isRegister(location)) { - return asRegister(location).name; - } - assert isVariable(location); - return "v" + ((CiVariable) location).index; - } - - private static String signed(int i) { - if (i >= 0) { - return "+" + i; - } - return String.valueOf(i); - } - - @Override - public String toString() { - // Checkstyle: stop - switch (format()) { - case BASE : return "[" + s(base) + kindSuffix() + "]"; - case BASE_DISP : return "[" + s(base) + signed(displacement) + kindSuffix() + "]"; - case BASE_INDEX : return "[" + s(base) + "+" + s(index) + kindSuffix() + "]"; - case BASE_INDEX_DISP : return "[" + s(base) + "+(" + s(index) + "*" + scale.value + ")" + signed(displacement) + kindSuffix() + "]"; - case PLACEHOLDER : return "[<placeholder>]"; - default : throw new IllegalArgumentException("unknown format: " + format()); - } - // Checkstyle: resume - } - - @Override - public boolean equals(Object obj) { - if (obj instanceof CiAddress) { - CiAddress addr = (CiAddress) obj; - return kind == addr.kind && displacement == addr.displacement && base.equals(addr.base) && scale == addr.scale && index.equals(addr.index); - } - return false; - } - - @Override - public int hashCode() { - return (base.hashCode() << 4) | kind.ordinal(); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiArchitecture.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,212 +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. - * - * 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.cri.ci; - -import java.util.*; - -import com.oracle.max.cri.intrinsics.*; -import com.sun.cri.ci.CiRegister.RegisterFlag; - - -/** - * Represents a CPU architecture, including information such as its endianness, CPU - * registers, word width, etc. - */ -public abstract class CiArchitecture { - - /** - * The endianness of the architecture. - */ - public static enum ByteOrder { - LittleEndian, - BigEndian - } - - /** - * The number of bits required in a bit map covering all the registers that may store references. - * The bit position of a register in the map is the register's {@linkplain CiRegister#number number}. - */ - public final int registerReferenceMapBitCount; - - /** - * Represents the natural size of words (typically registers and pointers) of this architecture, in bytes. - */ - public final int wordSize; - - /** - * The name of this architecture (e.g. "AMD64", "SPARCv9"). - */ - public final String name; - - /** - * Array of all available registers on this architecture. The index of each register in this - * array is equal to its {@linkplain CiRegister#number number}. - */ - public final CiRegister[] registers; - - /** - * Map of all registers keyed by their {@linkplain CiRegister#name names}. - */ - public final HashMap<String, CiRegister> registersByName; - - /** - * The byte ordering can be either little or big endian. - */ - public final ByteOrder byteOrder; - - /** - * Mask of the barrier constants defined in {@link MemoryBarriers} denoting the barriers that - * are not required to be explicitly inserted under this architecture. - */ - public final int implicitMemoryBarriers; - - /** - * Determines the barriers in a given barrier mask that are explicitly required on this architecture. - * - * @param barriers a mask of the barrier constants defined in {@link MemoryBarriers} - * @return the value of {@code barriers} minus the barriers unnecessary on this architecture - */ - public final int requiredBarriers(int barriers) { - return barriers & ~implicitMemoryBarriers; - } - - /** - * Offset in bytes from the beginning of a call instruction to the displacement. - */ - public final int machineCodeCallDisplacementOffset; - - /** - * The size of the return address pushed to the stack by a call instruction. - * A value of 0 denotes that call linkage uses registers instead (e.g. SPARC). - */ - public final int returnAddressSize; - - private final EnumMap<RegisterFlag, CiRegister[]> registersByTypeAndEncoding; - - /** - * Gets the register for a given {@linkplain CiRegister#encoding encoding} and type. - * - * @param encoding a register value as used in a machine instruction - * @param type the type of the register - */ - public CiRegister registerFor(int encoding, RegisterFlag type) { - CiRegister[] regs = registersByTypeAndEncoding.get(type); - assert encoding >= 0 && encoding < regs.length; - CiRegister reg = regs[encoding]; - assert reg != null; - return reg; - } - - protected CiArchitecture(String name, - int wordSize, - ByteOrder byteOrder, - CiRegister[] registers, - int implicitMemoryBarriers, - int nativeCallDisplacementOffset, - int registerReferenceMapBitCount, - int returnAddressSize) { - this.name = name; - this.registers = registers; - this.wordSize = wordSize; - this.byteOrder = byteOrder; - this.implicitMemoryBarriers = implicitMemoryBarriers; - this.machineCodeCallDisplacementOffset = nativeCallDisplacementOffset; - this.registerReferenceMapBitCount = registerReferenceMapBitCount; - this.returnAddressSize = returnAddressSize; - - registersByName = new HashMap<>(registers.length); - for (CiRegister register : registers) { - registersByName.put(register.name, register); - assert registers[register.number] == register; - } - - registersByTypeAndEncoding = new EnumMap<>(RegisterFlag.class); - EnumMap<RegisterFlag, CiRegister[]> categorizedRegs = CiRegister.categorize(registers); - for (RegisterFlag type : RegisterFlag.values()) { - CiRegister[] regs = categorizedRegs.get(type); - int max = CiRegister.maxRegisterEncoding(regs); - CiRegister[] regsByEnc = new CiRegister[max + 1]; - for (CiRegister reg : regs) { - regsByEnc[reg.encoding] = reg; - } - registersByTypeAndEncoding.put(type, regsByEnc); - } - } - - /** - * Converts this architecture to a string. - * @return the string representation of this architecture - */ - @Override - public final String toString() { - return name.toLowerCase(); - } - - /** - * Checks whether this is a 32-bit architecture. - * @return {@code true} if this architecture is 32-bit - */ - public final boolean is32bit() { - return wordSize == 4; - } - - /** - * Checks whether this is a 64-bit architecture. - * @return {@code true} if this architecture is 64-bit - */ - public final boolean is64bit() { - return wordSize == 8; - } - - // The following methods are architecture specific and not dependent on state - // stored in this class. They have convenient default implementations. - - /** - * Checks whether this architecture's normal arithmetic instructions use a two-operand form - * (e.g. x86 which overwrites one operand register with the result when adding). - * @return {@code true} if this architecture uses two-operand mode - */ - public boolean twoOperandMode() { - return false; - } - - // TODO: Why enumerate the concrete subclasses here rather - // than use instanceof comparisons in code that cares? - - /** - * Checks whether the architecture is x86. - * @return {@code true} if the architecture is x86 - */ - public boolean isX86() { - return false; - } - - /** - * Checks whether the architecture is SPARC. - * @return {@code true} if the architecture is SPARC - */ - public boolean isSPARC() { - return false; - } - -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiAssumptions.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,233 +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. - * - * 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.cri.ci; - -import java.io.*; -import java.util.*; - -import com.sun.cri.ri.*; - -/** - * Class for recording optimistic assumptions made during compilation. - * Recorded assumption can be visited for subsequent processing using - * an implementation of the {@link CiAssumptionProcessor} interface. - */ -public final class CiAssumptions implements Serializable, Iterable<CiAssumptions.Assumption> { - - /** - * - */ - private static final long serialVersionUID = 5152062717588239131L; - - public abstract static class Assumption implements Serializable { - - /** - * - */ - private static final long serialVersionUID = -1936652569665112915L; - } - - /** - * An assumption about a unique subtype of a given type. - */ - public static final class ConcreteSubtype extends Assumption { - /** - * - */ - private static final long serialVersionUID = -1457173265437676252L; - - /** - * Type the assumption is made about. - */ - public final RiResolvedType context; - - /** - * Assumed unique concrete sub-type of the context type. - */ - public final RiResolvedType subtype; - - public ConcreteSubtype(RiResolvedType context, RiResolvedType subtype) { - this.context = context; - this.subtype = subtype; - } - - @Override - public int hashCode() { - final int prime = 31; - int result = 1; - result = prime * result + context.hashCode(); - result = prime * result + subtype.hashCode(); - return result; - } - - @Override - public boolean equals(Object obj) { - if (obj instanceof ConcreteSubtype) { - ConcreteSubtype other = (ConcreteSubtype) obj; - return other.context == context && other.subtype == subtype; - } - return false; - } - } - - /** - * An assumption about a unique implementation of a virtual method. - */ - public static final class ConcreteMethod extends Assumption { - - /** - * - */ - private static final long serialVersionUID = -7636746737947390059L; - - /** - * A virtual (or interface) method whose unique implementation for the receiver type - * in {@link #context} is {@link #impl}. - */ - public final RiResolvedMethod method; - - /** - * A receiver type. - */ - public final RiResolvedType context; - - /** - * The unique implementation of {@link #method} for {@link #context}. - */ - public final RiResolvedMethod impl; - - public ConcreteMethod(RiResolvedMethod method, RiResolvedType context, RiResolvedMethod impl) { - this.method = method; - this.context = context; - this.impl = impl; - } - - @Override - public int hashCode() { - final int prime = 31; - int result = 1; - result = prime * result + method.hashCode(); - result = prime * result + context.hashCode(); - result = prime * result + impl.hashCode(); - return result; - } - - @Override - public boolean equals(Object obj) { - if (obj instanceof ConcreteMethod) { - ConcreteMethod other = (ConcreteMethod) obj; - return other.method == method && other.context == context && other.impl == impl; - } - return false; - } - } - - /** - * Array with the assumptions. This field is directly accessed from C++ code in the Graal/HotSpot implementation. - */ - private Assumption[] list; - - private int count; - - /** - * Returns whether any assumptions have been registered. - * @return {@code true} if at least one assumption has been registered, {@code false} otherwise. - */ - public boolean isEmpty() { - return count == 0; - } - - @Override - public Iterator<Assumption> iterator() { - return new Iterator<CiAssumptions.Assumption>() { - int index; - public void remove() { - throw new UnsupportedOperationException(); - } - public Assumption next() { - if (index >= count) { - throw new NoSuchElementException(); - } - return list[index++]; - } - public boolean hasNext() { - return index < count; - } - }; - } - - /** - * Records an assumption that the specified type has no finalizable subclasses. - * - * @param receiverType the type that is assumed to have no finalizable subclasses - * @return {@code true} if the assumption was recorded and can be assumed; {@code false} otherwise - */ - @SuppressWarnings("static-method") - public boolean recordNoFinalizableSubclassAssumption(RiResolvedType receiverType) { - // TODO(tw): Record that assumption correctly. - return false; - } - - /** - * Records that {@code subtype} is the only concrete subtype in the class hierarchy below {@code context}. - * @param context the root of the subtree of the class hierarchy that this assumptions is about - * @param subtype the one concrete subtype - */ - public void recordConcreteSubtype(RiResolvedType context, RiResolvedType subtype) { - record(new ConcreteSubtype(context, subtype)); - } - - /** - * Records that {@code impl} is the only possible concrete target for a virtual call to - * {@code method} with a receiver of type {@code context}. - * - * @param method a method that is the target of a virtual call - * @param context the receiver type of a call to {@code method} - * @param impl the concrete method that is the only possible target for the virtual call - */ - public void recordConcreteMethod(RiResolvedMethod method, RiResolvedType context, RiResolvedMethod impl) { - record(new ConcreteMethod(method, context, impl)); - } - - private void record(Assumption assumption) { - if (list == null) { - list = new Assumption[4]; - } else { - for (int i = 0; i < count; ++i) { - if (assumption.equals(list[i])) { - return; - } - } - } - if (list.length == count) { - Assumption[] newList = new Assumption[list.length * 2]; - for (int i = 0; i < list.length; ++i) { - newList[i] = list[i]; - } - list = newList; - } - list[count] = assumption; - count++; - } - -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiBailout.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,62 +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. - * - * 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.cri.ci; - -import java.util.*; - -/** - * {@code CiBailout} is thrown when the compiler refuses to compile a method because of problems with the method. - * e.g. bytecode wouldn't verify, too big, JSR/ret too complicated, etc. This exception is <i>not</i> - * meant to indicate problems with the compiler itself. - */ -public class CiBailout extends RuntimeException { - - public static final long serialVersionUID = 8974598793458772L; - - /** - * Create a new {@code CiBailout}. - * @param reason a message indicating the reason - */ - public CiBailout(String reason) { - super(reason); - } - - /** - * Create a new {@code CiBailout}. - * @param reason a message indicating the reason with a String.format - syntax - * @param args parameters to the formatter - */ - public CiBailout(String format, Object... args) { - this(String.format(Locale.ENGLISH, format, args)); - } - - /** - * Create a new {@code CiBailout} t due to an internal exception being thrown. - * @param reason a message indicating the reason - * @param cause the throwable that was the cause of the bailout - */ - public CiBailout(String reason, Throwable cause) { - super(reason); - initCause(cause); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiBitMap.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,682 +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. - * - * 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.cri.ci; - -import java.io.*; -import java.util.*; - -/** - * Implements a bitmap that stores a single bit for a range of integers (0-n). - */ -public final class CiBitMap implements Serializable { - - private static final long serialVersionUID = 2471441272241401105L; - private static final int ADDRESS_BITS_PER_WORD = 6; - private static final int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD; - private static final int BIT_INDEX_MASK = BITS_PER_WORD - 1; - - public static final int DEFAULT_LENGTH = BITS_PER_WORD; - - public static int roundUpLength(int length) { - return ((length + (BITS_PER_WORD - 1)) >> ADDRESS_BITS_PER_WORD) << ADDRESS_BITS_PER_WORD; - } - - private int size; - private long low; - private long[] extra; - - /** - * Constructs a new bit map with the {@linkplain #DEFAULT_LENGTH default length}. - */ - public CiBitMap() { - this(DEFAULT_LENGTH); - } - - /** - * Constructs a new bit map from a byte array encoded bit map. - * - * @param bitmap the bit map to convert - */ - public CiBitMap(byte[] bitmap) { - this(bitmap, 0, bitmap.length); - } - - /** - * Constructs a copy of the given bit map. - * - * @param bitmap the bit map to copy. - */ - public CiBitMap(CiBitMap bitmap) { - this.size = bitmap.size; - this.low = bitmap.low; - if (bitmap.extra != null) { - this.extra = Arrays.copyOf(bitmap.extra, bitmap.extra.length); - } - } - - /** - * Constructs a new bit map from a byte array encoded bit map. - * - * @param arr the byte array containing the bit map to convert - * @param off the byte index in {@code arr} at which the bit map starts - * @param numberOfBytes the number of bytes worth of bits to copy from {@code arr} - */ - public CiBitMap(byte[] arr, int off, int numberOfBytes) { - this(numberOfBytes * 8); - int byteIndex = off; - int end = off + numberOfBytes; - assert end <= arr.length; - while (byteIndex < end && (byteIndex - off) < 8) { - long bite = (long) arr[byteIndex] & 0xff; - low |= bite << ((byteIndex - off) * 8); - byteIndex++; - } - if (byteIndex < end) { - assert (byteIndex - off) == 8; - int remBytes = end - byteIndex; - int remWords = (remBytes + 7) / 8; - for (int word = 0; word < remWords; word++) { - long w = 0L; - for (int i = 0; i < 8 && byteIndex < end; i++) { - long bite = (long) arr[byteIndex] & 0xff; - w |= bite << (i * 8); - byteIndex++; - } - extra[word] = w; - } - } - } - - /** - * Converts a {@code long} to a {@link CiBitMap}. - */ - public static CiBitMap fromLong(long bitmap) { - CiBitMap bm = new CiBitMap(64); - bm.low = bitmap; - return bm; - } - - /** - * Constructs a new bit map with the specified length. - * - * @param length the length of the bitmap - */ - public CiBitMap(int length) { - assert length >= 0; - this.size = length; - if (length > BITS_PER_WORD) { - extra = new long[length >> ADDRESS_BITS_PER_WORD]; - } - } - - /** - * Sets the bit at the specified index. - * - * @param i the index of the bit to set - */ - public void set(int i) { - if (checkIndex(i) < BITS_PER_WORD) { - low |= 1L << i; - } else { - int pos = wordIndex(i); - int index = bitInWord(i); - extra[pos] |= 1L << index; - } - } - - /** - * Grows this bitmap to a new size, appending necessary zero bits. - * - * @param newLength the new length of the bitmap - */ - public void grow(int newLength) { - if (newLength > size) { - // grow this bitmap to the new length - int newSize = newLength >> ADDRESS_BITS_PER_WORD; - if (newLength > 0) { - if (extra == null) { - // extra just needs to be allocated now - extra = new long[newSize]; - } else { - if (extra.length < newSize) { - // extra needs to be copied - long[] newExtra = new long[newSize]; - for (int i = 0; i < extra.length; i++) { - newExtra[i] = extra[i]; - } - extra = newExtra; - } else { - // nothing to do, extra is already the right size - } - } - } - size = newLength; - } - } - - private static int bitInWord(int i) { - return i & BIT_INDEX_MASK; - } - - private static int wordIndex(int i) { - return (i >> ADDRESS_BITS_PER_WORD) - 1; - } - - /** - * Clears the bit at the specified index. - * @param i the index of the bit to clear - */ - public void clear(int i) { - if (checkIndex(i) < BITS_PER_WORD) { - low &= ~(1L << i); - } else { - int pos = wordIndex(i); - int index = bitInWord(i); - extra[pos] &= ~(1L << index); - } - } - - /** - * Sets all the bits in this bitmap. - */ - public void setAll() { - low = -1; - if (extra != null) { - for (int i = 0; i < extra.length; i++) { - extra[i] = -1; - } - } - } - - /** - * Clears all the bits in this bitmap. - */ - public void clearAll() { - low = 0; - if (extra != null) { - for (int i = 0; i < extra.length; i++) { - extra[i] = 0; - } - } - } - - /** - * Gets the value of the bit at the specified index. - * - * @param i the index of the bit to get - * @return {@code true} if the bit at the specified position is {@code 1} - */ - public boolean get(int i) { - if (checkIndex(i) < BITS_PER_WORD) { - return ((low >> i) & 1) != 0; - } - int pos = wordIndex(i); - int index = bitInWord(i); - long bits = extra[pos]; - return ((bits >> index) & 1) != 0; - } - - /** - * Gets the value of the bit at the specified index, returning {@code false} if the - * bitmap does not cover the specified index. - * - * @param i the index of the bit to get - * @return {@code true} if the bit at the specified position is {@code 1} - */ - public boolean getDefault(int i) { - if (i < 0 || i >= size) { - return false; - } - if (i < BITS_PER_WORD) { - return ((low >> i) & 1) != 0; - } - int pos = wordIndex(i); - int index = bitInWord(i); - long bits = extra[pos]; - return ((bits >> index) & 1) != 0; - } - - /** - * Performs the union operation on this bitmap with the specified bitmap. That is, all bits set in either of the two - * bitmaps will be set in this bitmap following this operation. - * - * @param other the other bitmap for the union operation - */ - public void setUnion(CiBitMap other) { - low |= other.low; - if (extra != null && other.extra != null) { - for (int i = 0; i < extra.length && i < other.extra.length; i++) { - extra[i] |= other.extra[i]; - } - } - } - - /** - * Performs the union operation on this bitmap with the specified bitmap. That is, a bit is set in this - * bitmap if and only if it is set in both this bitmap and the specified bitmap. - * - * @param other the other bitmap for this operation - * @return {@code true} if any bits were cleared as a result of this operation - */ - public boolean setIntersect(CiBitMap other) { - boolean same = true; - long intx = low & other.low; - if (low != intx) { - same = false; - low = intx; - } - long[] oxtra = other.extra; - if (extra != null && oxtra != null) { - for (int i = 0; i < extra.length; i++) { - long a = extra[i]; - if (i < oxtra.length) { - // zero bits out of this map - long ax = a & oxtra[i]; - if (a != ax) { - same = false; - extra[i] = ax; - } - } else { - // this bitmap is larger than the specified bitmap; zero remaining bits - if (a != 0) { - same = false; - extra[i] = 0; - } - } - } - } - return !same; - } - - /** - * Gets the number of addressable bits in this bitmap. - * - * @return the size of this bitmap - */ - public int size() { - return size; - } - - private int checkIndex(int i) { - if (i < 0 || i >= size) { - throw new IndexOutOfBoundsException(); - } - return i; - } - - public void setFrom(CiBitMap other) { - assert this.size == other.size : "must have same size"; - - low = other.low; - if (extra != null) { - for (int i = 0; i < extra.length; i++) { - extra[i] = other.extra[i]; - } - } - } - - public void setDifference(CiBitMap other) { - assert this.size == other.size : "must have same size"; - - low &= ~other.low; - if (extra != null) { - for (int i = 0; i < extra.length; i++) { - extra[i] &= ~other.extra[i]; - } - } - } - - public boolean isSame(CiBitMap other) { - if (this.size != other.size || this.low != other.low) { - return false; - } - - if (extra != null) { - for (int i = 0; i < extra.length; i++) { - if (extra[i] != other.extra[i]) { - return false; - } - } - } - - return true; - } - - /** - * Returns the index of the first set bit that occurs on or after a specified start index. - * If no such bit exists then -1 is returned. - * <p> - * To iterate over the set bits in a {@code BitMap}, use the following loop: - * - * <pre> - * for (int i = bitMap.nextSetBit(0); i >= 0; i = bitMap.nextSetBit(i + 1)) { - * // operate on index i here - * } - * </pre> - * - * @param fromIndex the index to start checking from (inclusive) - * @return the index of the lowest set bit between {@code [fromIndex .. size())} or -1 if there is no set bit in this range - * @throws IndexOutOfBoundsException if the specified index is negative. - */ - public int nextSetBit(int fromIndex) { - return nextSetBit(fromIndex, size()); - } - - /** - * Returns the index of the first set bit that occurs on or after a specified start index - * and before a specified end index. If no such bit exists then -1 is returned. - * <p> - * To iterate over the set bits in a {@code BitMap}, use the following loop: - * - * <pre> - * for (int i = bitMap.nextSetBit(0, bitMap.size()); i >= 0; i = bitMap.nextSetBit(i + 1, bitMap.size())) { - * // operate on index i here - * } - * </pre> - * - * @param fromIndex the index to start checking from (inclusive) - * @param toIndex the index at which to stop checking (exclusive) - * @return the index of the lowest set bit between {@code [fromIndex .. toIndex)} or -1 if there is no set bit in this range - * @throws IndexOutOfBoundsException if the specified index is negative. - */ - public int nextSetBit(int fromIndex, int toIndex) { - assert fromIndex <= size() : "index out of bounds"; - assert toIndex <= size() : "index out of bounds"; - assert fromIndex <= toIndex : "fromIndex > toIndex"; - - if (fromIndex == toIndex) { - return -1; - } - int fromWordIndex = wordIndex(fromIndex); - int toWordIndex = wordIndex(toIndex - 1) + 1; - int resultIndex = fromIndex; - - // check bits including and to the left_ of offset's position - int pos = bitInWord(resultIndex); - long res = map(fromWordIndex) >> pos; - if (res != 0) { - resultIndex += Long.numberOfTrailingZeros(res); - assert resultIndex >= fromIndex && resultIndex < toIndex : "just checking"; - if (resultIndex < toIndex) { - return resultIndex; - } - return -1; - } - // skip over all word length 0-bit runs - for (fromWordIndex++; fromWordIndex < toWordIndex; fromWordIndex++) { - res = map(fromWordIndex); - if (res != 0) { - // found a 1, return the offset - resultIndex = bitIndex(fromWordIndex) + Long.numberOfTrailingZeros(res); - assert resultIndex >= fromIndex : "just checking"; - if (resultIndex < toIndex) { - return resultIndex; - } - return -1; - } - } - return -1; - } - - private static int bitIndex(int index) { - return (index + 1) << ADDRESS_BITS_PER_WORD; - } - - private long map(int index) { - if (index == -1) { - return low; - } - return extra[index]; - } - - private static boolean allZeros(int start, long[] arr) { - for (int i = start; i < arr.length; i++) { - if (arr[i] != 0) { - return false; - } - } - return true; - } - - /** - * Compares this object against the specified object. - * The result is {@code true} if and only if {@code obj} is - * not {@code null} and is a {@code CiBitMap} object that has - * exactly the same set of bits set to {@code true} as this bit - * set. - * - * @param obj the object to compare with. - */ - @Override - public boolean equals(Object obj) { - if (obj instanceof CiBitMap) { - CiBitMap bm = (CiBitMap) obj; - if (bm.low == low) { - if (bm.extra == null) { - if (extra == null) { - // Common case - return true; - } - return allZeros(0, extra); - } - if (extra == null) { - return allZeros(0, bm.extra); - } - // both 'extra' array non null: - int i = 0; - int length = Math.min(extra.length, bm.extra.length); - while (i < length) { - if (extra[i] != bm.extra[i]) { - return false; - } - i++; - } - if (extra.length > bm.extra.length) { - return allZeros(length, extra); - } - if (extra.length < bm.extra.length) { - return allZeros(length, bm.extra); - } - return true; - } - } - return false; - } - - @Override - public int hashCode() { - return (int) low ^ size; - } - - /** - * Returns a string representation of this bit map - * that is the same as the string returned by {@link BitSet#toString()} - * for a bit set with the same bits set as this bit map. - */ - @Override - public String toString() { - StringBuilder sb = new StringBuilder(size * 2); - sb.append('{'); - - int bit = nextSetBit(0); - if (bit != -1) { - sb.append(bit); - for (bit = nextSetBit(bit + 1); bit >= 0; bit = nextSetBit(bit + 1)) { - sb.append(", ").append(bit); - } - } - - sb.append('}'); - return sb.toString(); - } - - public static int highestOneBitIndex(long value) { - int bit = Long.numberOfTrailingZeros(Long.highestOneBit(value)); - if (bit == 64) { - return -1; - } - return bit; - } - - /** - * Returns the number of bits set to {@code true} in this bit map. - */ - public int cardinality() { - int sum = Long.bitCount(low); - if (extra != null) { - for (long word : extra) { - sum += Long.bitCount(word); - } - } - return sum; - } - - /** - * Returns the "logical size" of this bit map: the index of - * the highest set bit in the bit map plus one. Returns zero - * if the bit map contains no set bits. - * - * @return the logical size of this bit map - */ - public int length() { - if (extra != null) { - for (int i = extra.length - 1; i >= 0; i--) { - if (extra[i] != 0) { - return (highestOneBitIndex(extra[i]) + ((i + 1) * 64)) + 1; - } - } - } - return highestOneBitIndex(low) + 1; - } - - /** - * Returns a string representation of this bit map with every set bit represented as {@code '1'} - * and every unset bit represented as {@code '0'}. The first character in the returned string represents - * bit 0 in this bit map. - * - * @param length the number of bits represented in the returned string. If {@code length < 0 || length > size()}, - * then the value of {@link #length()} is used. - */ - public String toBinaryString() { - int length = length(); - if (length == 0) { - return ""; - } - StringBuilder sb = new StringBuilder(length); - for (int i = 0; i < length; ++i) { - sb.append(get(i) ? '1' : '0'); - } - return sb.toString(); - } - - static final char[] hexDigits = { - '0', '1', '2', '3', '4', '5', '6', '7', - '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' - }; - - /** - * Returns a string representation of this bit map in hex. - */ - public String toHexString() { - if (size == 0) { - return ""; - } - int hexSize = CiUtil.align(this.size, 4); - StringBuilder sb = new StringBuilder(hexSize / 4); - for (int i = 0; i < hexSize; i += 4) { - int nibble = get(i) ? 1 : 0; - if (get(i + 1)) { - nibble |= 2; - } - if (get(i + 2)) { - nibble |= 4; - } - if (get(i + 3)) { - nibble |= 8; - } - - sb.append(hexDigits[nibble]); - } - return sb.toString(); - } - - public CiBitMap copy() { - CiBitMap n = new CiBitMap(BITS_PER_WORD); - n.low = low; - if (extra != null) { - n.extra = Arrays.copyOf(extra, extra.length); - } - n.size = size; - return n; - } - - /** - * Copies this bit map into a given byte array. - * - * @param arr the destination - * @param off the byte index in {@code arr} at which to start writing - * @param numberOfBytes the number of bytes worth of bits to copy from this bit map. - * The number of bits copied is {@code numberOfBytes * 8}. If {@code numberOfBytes} - * is -1, then {@code ((size() + 7) / 8)} is used instead. - * @return the number of bytes written to {@code arr} - */ - public int copyTo(byte[] arr, int off, int numberOfBytes) { - for (int i = 0; i < numberOfBytes; ++i) { - long word = low; - int byteInWord; - if (i >= 8) { - int wordIndex = (i - 8) / 8; - word = extra[wordIndex]; - byteInWord = i & 0x7; - } else { - byteInWord = i; - } - assert byteInWord < 8; - byte b = (byte) (word >> (byteInWord * 8)); - arr[off + i] = b; - } - return numberOfBytes; - } - - /** - * Converts this bit map to a byte array. The length of the returned - * byte array is {@code ((size() + 7) / 8)}. - */ - public byte[] toByteArray() { - byte[] arr = new byte[(size + 7) / 8]; - copyTo(arr, 0, arr.length); - return arr; - } - - /** - * Converts this bit map to a long. - * - * @throws IllegalArgumentException if {@code (size() > 64)} - */ - public long toLong() { - if (size > 64) { - throw new IllegalArgumentException("bit map of size " + size + " cannot be converted to long"); - } - return low; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiCalleeSaveLayout.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,178 +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. - * - * 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.cri.ci; - -import java.util.*; - - -/** - * The callee save area (CSA) is a contiguous space in a stack frame - * used to save (and restore) the values of the caller's registers. - * This class describes the layout of a CSA in terms of its - * {@linkplain #size size}, {@linkplain #slotSize slot size} and - * the {@linkplain #registers callee save registers} covered by the CSA. - */ -public class CiCalleeSaveLayout { - - /** - * The size (in bytes) of the CSA. - */ - public final int size; - - /** - * The size (in bytes) of an {@linkplain #registerAtIndex(int) indexable} slot in the CSA. - */ - public final int slotSize; - - /** - * Map from {@linkplain CiRegister#number register numbers} to slot indexes in the CSA. - */ - private final int[] regNumToIndex; - - private final CiRegister[] indexToReg; - - /** - * The list of registers {@linkplain #contains(CiRegister) contained} by this CSA. - */ - public final CiRegister[] registers; - - /** - * The offset from the frame pointer to the CSA. If this is not known, then this field - * will have the value {@link Integer#MAX_VALUE}. - */ - public final int frameOffsetToCSA; - - /** - * Creates a CSA layout. - * - * @param size size (in bytes) of the CSA. If this is {@code -1}, then the CSA size will be computed from {@code registers}. - * @param slotSize the size (in bytes) of an {@linkplain #registerAtIndex(int) indexable} slot in the CSA - * @param registers the registers that can be saved in the CSA - */ - public CiCalleeSaveLayout(int frameOffsetToCSA, int size, int slotSize, CiRegister... registers) { - this.frameOffsetToCSA = frameOffsetToCSA; - assert slotSize == 0 || CiUtil.isPowerOf2(slotSize); - this.slotSize = slotSize; - int maxRegNum = -1; - int maxOffset = 0; - this.registers = registers; - int offset = 0; - for (CiRegister reg : registers) { - assert offset % slotSize == 0; - assert reg.number >= 0; - if (reg.number > maxRegNum) { - maxRegNum = reg.number; - } - if (offset > maxOffset) { - maxOffset = offset; - } - offset += reg.spillSlotSize; - } - if (size == -1) { - this.size = offset; - } else { - assert offset <= size; - this.size = size; - } - - this.regNumToIndex = new int[maxRegNum + 1]; - this.indexToReg = offset == 0 ? new CiRegister[0] : new CiRegister[offset / slotSize]; - Arrays.fill(regNumToIndex, -1); - offset = 0; - for (CiRegister reg : registers) { - int index = offset / slotSize; - regNumToIndex[reg.number] = index; - indexToReg[index] = reg; - offset += reg.spillSlotSize; - } - } - - /** - * Gets the offset of a given register in the CSA. - * - * @return the offset (in bytes) of {@code reg} in the CSA - * @throws IllegalArgumentException if {@code reg} does not have a slot in the CSA - */ - public int offsetOf(int reg) { - return indexOf(reg) * slotSize; - } - - /** - * Gets the index of a given register in the CSA. - * - * @return the index of {@code reg} in the CSA - * @throws IllegalArgumentException if {@code reg} does not have a slot in the CSA - */ - public int indexOf(int reg) { - if (!contains(reg)) { - throw new IllegalArgumentException(String.valueOf(reg)); - } - return regNumToIndex[reg]; - } - - /** - * Gets the offset of a given register in the CSA. - * - * @return the offset (in bytes) of {@code reg} in the CSA - * @throws IllegalArgumentException if {@code reg} does not have a slot in the CSA - */ - public int offsetOf(CiRegister reg) { - return offsetOf(reg.number); - } - - /** - * Determines if the CSA includes a slot for a given register. - * - * @param reg the register to test - * @return true if the CSA contains a slot for {@code reg} - */ - public boolean contains(int reg) { - return reg >= 0 && reg < regNumToIndex.length && regNumToIndex[reg] != -1; - } - - /** - * Gets the register whose slot in the CSA is at a given index. - * - * @param index an index of a slot in the CSA - * @return the register whose slot in the CSA is at {@code index} or {@code null} if {@code index} does not denote a - * slot in the CSA aligned with a register - */ - public CiRegister registerAt(int index) { - if (index < 0 || index >= indexToReg.length) { - return null; - } - return indexToReg[index]; - } - - @Override - public String toString() { - StringBuilder sb = new StringBuilder("["); - for (CiRegister reg : registers) { - if (sb.length() != 1) { - sb.append(", "); - } - sb.append(reg).append("{+").append(offsetOf(reg)).append('}'); - } - return sb.append("] size=").append(size).toString(); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiCallingConvention.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,107 +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. - * - * 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.cri.ci; - -import static com.sun.cri.ci.CiValueUtil.*; - -import com.sun.cri.ri.*; - - -/** - * A calling convention describes the locations in which the arguments for a call are placed. - */ -public class CiCallingConvention { - - /** - * Constants denoting the type of a call for which a calling convention is - * {@linkplain RiRegisterConfig#getCallingConvention(Type, CiKind[], CiTarget, boolean) requested}. - */ - public enum Type { - /** - * A request for the outgoing argument locations at a call site to Java code. - */ - JavaCall(true), - - /** - * A request for the incoming argument locations. - */ - JavaCallee(false), - - /** - * A request for the outgoing argument locations at a call site to the runtime (which may be Java or native code). - */ - RuntimeCall(true), - - /** - * A request for the outgoing argument locations at a call site to - * external native code that complies with the platform ABI. - */ - NativeCall(true); - - /** - * Determines if this is a request for the outgoing argument locations at a call site. - */ - public final boolean out; - - public static final Type[] VALUES = values(); - - private Type(boolean out) { - this.out = out; - } - } - - /** - * The amount of stack space (in bytes) required for the stack-based arguments of the call. - */ - public final int stackSize; - - /** - * The locations in which the arguments are placed. This array ordered by argument index. - */ - public final CiValue[] locations; - - public CiCallingConvention(CiValue[] locations, int stackSize) { - this.locations = locations; - this.stackSize = stackSize; - assert verify(); - } - - @Override - public String toString() { - StringBuilder result = new StringBuilder(); - result.append("CallingConvention["); - for (CiValue op : locations) { - result.append(op.toString()).append(" "); - } - result.append("]"); - return result.toString(); - } - - private boolean verify() { - for (int i = 0; i < locations.length; i++) { - CiValue location = locations[i]; - assert isStackSlot(location) || isRegister(location); - } - return true; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiCodePos.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,105 +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. - * - * 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.cri.ci; - -import java.io.*; - -import com.sun.cri.ri.*; - -/** - * Represents a code position, that is, a chain of inlined methods with bytecode - * locations, that is communicated from the compiler to the runtime system. A code position - * can be used by the runtime system to reconstruct a source-level stack trace - * for exceptions and to create {@linkplain CiFrame frames} for deoptimization. - */ -public class CiCodePos implements Serializable { - /** - * - */ - private static final long serialVersionUID = 8633885274526033515L; - - /** - * The position where this position has been called, {@code null} if none. - */ - public final CiCodePos caller; - - /** - * The runtime interface method for this position. - */ - public final RiResolvedMethod method; - - /** - * The location within the method, as a bytecode index. The constant - * {@code -1} may be used to indicate the location is unknown, for example - * within code synthesized by the compiler. - */ - public final int bci; - - /** - * Constructs a new object representing a given parent/caller, a given method, and a given BCI. - * - * @param caller the parent position - * @param method the method - * @param bci a BCI within the method - */ - public CiCodePos(CiCodePos caller, RiResolvedMethod method, int bci) { - assert method != null; - this.caller = caller; - this.method = method; - this.bci = bci; - } - - /** - * Converts this code position to a string representation. - * @return a string representation of this code position - */ - @Override - public String toString() { - return CiUtil.append(new StringBuilder(100), this).toString(); - } - - /** - * Deep equality test. - */ - @Override - public boolean equals(Object obj) { - if (obj == this) { - return true; - } - if (obj instanceof CiCodePos) { - CiCodePos other = (CiCodePos) obj; - if (other.method.equals(method) && other.bci == bci) { - if (caller == null) { - return other.caller == null; - } - return caller.equals(other.caller); - } - } - return false; - } - - @Override - public int hashCode() { - return bci; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiCompiler.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -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. - * - * 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.cri.ci; - -import com.sun.cri.ri.*; - -public interface CiCompiler { - - /** - * Denotes the level of debug info for safepoints that should be generated by a compilation. - */ - enum DebugInfoLevel { - /** - * Only ref maps are required. - */ - REF_MAPS, - - /** - * Code positions and ref maps are required. - */ - CODE_POS_AND_REF_MAPS, - - /** - * Frame info, code positions and ref maps are required. - * Only a compilation with level can make speculative optimizations. - */ - FULL - } - - /** - * Compile the specified method. - * - * @param method the method to compile - * @param osrBCI the bytecode index of the entrypoint for an on-stack-replacement or {@code -1} if this is not an - * on-stack-replacement compilation - * @param debugInfoLevel TODO - */ - CiResult compileMethod(RiResolvedMethod method, int osrBCI, CiStatistics stats, DebugInfoLevel debugInfoLevel); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiConstant.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,496 +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. - * - * 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.cri.ci; - -/** - * Represents a constant (boxed) value, such as an integer, floating point number, or object reference, - * within the compiler and across the compiler/runtime interface. Exports a set of {@code CiConstant} - * instances that represent frequently used constant values, such as {@link #ZERO}. - */ -public final class CiConstant extends CiValue { - private static final long serialVersionUID = -6355452536852663986L; - - private static final CiConstant[] INT_CONSTANT_CACHE = new CiConstant[100]; - static { - for (int i = 0; i < INT_CONSTANT_CACHE.length; ++i) { - INT_CONSTANT_CACHE[i] = new CiConstant(CiKind.Int, i); - } - } - - public static final CiConstant NULL_OBJECT = new CiConstant(CiKind.Object, null); - public static final CiConstant INT_MINUS_1 = new CiConstant(CiKind.Int, -1); - public static final CiConstant INT_0 = forInt(0); - public static final CiConstant INT_1 = forInt(1); - public static final CiConstant INT_2 = forInt(2); - public static final CiConstant INT_3 = forInt(3); - public static final CiConstant INT_4 = forInt(4); - public static final CiConstant INT_5 = forInt(5); - public static final CiConstant LONG_0 = new CiConstant(CiKind.Long, 0L); - public static final CiConstant LONG_1 = new CiConstant(CiKind.Long, 1L); - public static final CiConstant FLOAT_0 = new CiConstant(CiKind.Float, Float.floatToRawIntBits(0.0F)); - public static final CiConstant FLOAT_1 = new CiConstant(CiKind.Float, Float.floatToRawIntBits(1.0F)); - public static final CiConstant FLOAT_2 = new CiConstant(CiKind.Float, Float.floatToRawIntBits(2.0F)); - public static final CiConstant DOUBLE_0 = new CiConstant(CiKind.Double, Double.doubleToRawLongBits(0.0D)); - public static final CiConstant DOUBLE_1 = new CiConstant(CiKind.Double, Double.doubleToRawLongBits(1.0D)); - public static final CiConstant TRUE = new CiConstant(CiKind.Boolean, 1L); - public static final CiConstant FALSE = new CiConstant(CiKind.Boolean, 0L); - - static { - assert NULL_OBJECT.isDefaultValue(); - assert INT_0.isDefaultValue(); - assert FLOAT_0.isDefaultValue(); - assert DOUBLE_0.isDefaultValue(); - assert FALSE.isDefaultValue(); - - // Ensure difference between 0.0f and -0.0f is preserved - assert FLOAT_0 != forFloat(-0.0F); - assert !forFloat(-0.0F).isDefaultValue(); - - // Ensure difference between 0.0d and -0.0d is preserved - assert DOUBLE_0 != forDouble(-0.0d); - assert !forDouble(-0.0D).isDefaultValue(); - - assert NULL_OBJECT.isNull(); - } - - /** - * The boxed object value. This is ignored iff {@code !kind.isObject()}. - */ - private final Object object; - - /** - * The boxed primitive value as a {@code long}. This is ignored iff {@code kind.isObject()}. - * For {@code float} and {@code double} values, this value is the result of - * {@link Float#floatToRawIntBits(float)} and {@link Double#doubleToRawLongBits(double)} respectively. - */ - private final long primitive; - - /** - * Create a new constant represented by the specified object reference. - * - * @param kind the type of this constant - * @param object the value of this constant - */ - private CiConstant(CiKind kind, Object object) { - super(kind); - this.object = object; - this.primitive = 0L; - } - - /** - * Create a new constant represented by the specified primitive. - * - * @param kind the type of this constant - * @param primitive the value of this constant - */ - public CiConstant(CiKind kind, long primitive) { - super(kind); - this.object = null; - this.primitive = primitive; - } - - /** - * Checks whether this constant is non-null. - * @return {@code true} if this constant is a primitive, or an object constant that is not null - */ - public boolean isNonNull() { - return !kind.isObject() || object != null; - } - - /** - * Checks whether this constant is null. - * @return {@code true} if this constant is the null constant - */ - public boolean isNull() { - return kind.isObject() && object == null; - } - - @Override - public String toString() { - return kind.javaName + "[" + kind.format(boxedValue()) + (kind != CiKind.Object ? "|0x" + Long.toHexString(primitive) : "") + "]"; - } - - /** - * Gets this constant's value as a string. - * - * @return this constant's value as a string - */ - public String valueString() { - if (kind.isPrimitive()) { - return boxedValue().toString(); - } else if (kind.isObject()) { - if (object == null) { - return "null"; - } else if (object instanceof String) { - return "\"" + object + "\""; - } else { - return "<object: " + kind.format(object) + ">"; - } - } else if (kind.isJsr()) { - return "bci:" + boxedValue().toString(); - } else { - return "???"; - } - } - - /** - * Returns the value of this constant as a boxed Java value. - * @return the value of this constant - */ - public Object boxedValue() { - // Checkstyle: stop - switch (kind) { - case Byte: return (byte) asInt(); - case Boolean: return asInt() == 0 ? Boolean.FALSE : Boolean.TRUE; - case Short: return (short) asInt(); - case Char: return (char) asInt(); - case Jsr: return (int) primitive; - case Int: return asInt(); - case Long: return asLong(); - case Float: return asFloat(); - case Double: return asDouble(); - case Object: return object; - } - // Checkstyle: resume - throw new IllegalArgumentException(); - } - - private boolean valueEqual(CiConstant other, boolean ignoreKind) { - // must have equivalent kinds to be equal - if (!ignoreKind && kind != other.kind) { - return false; - } - if (kind.isObject()) { - return object == other.object; - } - return primitive == other.primitive; - } - - /** - * Converts this constant to a primitive int. - * @return the int value of this constant - */ - public int asInt() { - if (kind.stackKind().isInt() || kind.isJsr()) { - return (int) primitive; - } - throw new Error("Constant is not int: " + this); - } - - /** - * Converts this constant to a primitive boolean. - * @return the boolean value of this constant - */ - public boolean asBoolean() { - if (kind == CiKind.Boolean) { - return primitive != 0L; - } - throw new Error("Constant is not boolean: " + this); - } - - /** - * Converts this constant to a primitive long. - * @return the long value of this constant - */ - public long asLong() { - // Checkstyle: stop - switch (kind.stackKind()) { - case Jsr: - case Int: - case Long: return primitive; - case Float: return (long) asFloat(); - case Double: return (long) asDouble(); - default: throw new Error("Constant is not long: " + this); - } - // Checkstyle: resume - } - - /** - * Converts this constant to a primitive float. - * @return the float value of this constant - */ - public float asFloat() { - if (kind.isFloat()) { - return Float.intBitsToFloat((int) primitive); - } - throw new Error("Constant is not float: " + this); - } - - /** - * Converts this constant to a primitive double. - * @return the double value of this constant - */ - public double asDouble() { - if (kind.isFloat()) { - return Float.intBitsToFloat((int) primitive); - } - if (kind.isDouble()) { - return Double.longBitsToDouble(primitive); - } - throw new Error("Constant is not double: " + this); - } - - /** - * Converts this constant to the object reference it represents. - * @return the object which this constant represents - */ - public Object asObject() { - if (kind.isObject()) { - return object; - } - throw new Error("Constant is not object: " + this); - } - - /** - * Converts this constant to the jsr reference it represents. - * @return the object which this constant represents - */ - public int asJsr() { - if (kind.isJsr()) { - return (int) primitive; - } - throw new Error("Constant is not jsr: " + this); - } - - /** - * Unchecked access to a primitive value. - * @return - */ - public long asPrimitive() { - if (kind.isObject()) { - throw new Error("Constant is not primitive: " + this); - } - return primitive; - } - - /** - * Computes the hashcode of this constant. - * @return a suitable hashcode for this constant - */ - @Override - public int hashCode() { - if (kind.isObject()) { - return System.identityHashCode(object); - } - return (int) primitive; - } - - /** - * Checks whether this constant equals another object. This is only - * true if the other object is a constant and has the same value. - * @param o the object to compare equality - * @return {@code true} if this constant is equivalent to the specified object - */ - @Override - public boolean equals(Object o) { - return o == this || o instanceof CiConstant && valueEqual((CiConstant) o, false); - } - - /** - * Checks whether this constant is identical to another constant or has the same value as it. - * @param other the constant to compare for equality against this constant - * @return {@code true} if this constant is equivalent to {@code other} - */ - public boolean equivalent(CiConstant other) { - return other == this || valueEqual(other, false); - } - - /** - * Checks whether this constant is the default value for its type. - * @return {@code true} if the value is the default value for its type; {@code false} otherwise - */ - public boolean isDefaultValue() { - // Checkstyle: stop - switch (kind.stackKind()) { - case Int: return asInt() == 0; - case Long: return asLong() == 0; - case Float: return this == FLOAT_0; - case Double: return this == DOUBLE_0; - case Object: return object == null; - } - // Checkstyle: resume - throw new IllegalArgumentException("Cannot det default CiConstant for kind " + kind); - } - - /** - * Gets the default value for a given kind. - * - * @return the default value for {@code kind}'s {@linkplain CiKind#stackKind() stack kind} - */ - public static CiConstant defaultValue(CiKind kind) { - // Checkstyle: stop - switch (kind.stackKind()) { - case Int: return INT_0; - case Long: return LONG_0; - case Float: return FLOAT_0; - case Double: return DOUBLE_0; - case Object: return NULL_OBJECT; - } - // Checkstyle: resume - throw new IllegalArgumentException("Cannot get default CiConstant for kind " + kind); - } - - /** - * Creates a boxed double constant. - * @param d the double value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forDouble(double d) { - if (Double.compare(0.0D, d) == 0) { - return DOUBLE_0; - } - if (Double.compare(d, 1.0D) == 0) { - return DOUBLE_1; - } - return new CiConstant(CiKind.Double, Double.doubleToRawLongBits(d)); - } - - /** - * Creates a boxed float constant. - * @param f the float value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forFloat(float f) { - if (Float.compare(f, 0.0F) == 0) { - return FLOAT_0; - } - if (Float.compare(f, 1.0F) == 0) { - return FLOAT_1; - } - if (Float.compare(f, 2.0F) == 0) { - return FLOAT_2; - } - return new CiConstant(CiKind.Float, Float.floatToRawIntBits(f)); - } - - /** - * Creates a boxed long constant. - * @param i the long value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forLong(long i) { - return i == 0 ? LONG_0 : i == 1 ? LONG_1 : new CiConstant(CiKind.Long, i); - } - - /** - * Creates a boxed integer constant. - * @param i the integer value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forInt(int i) { - if (i == -1) { - return INT_MINUS_1; - } - if (i >= 0 && i < INT_CONSTANT_CACHE.length) { - return INT_CONSTANT_CACHE[i]; - } - return new CiConstant(CiKind.Int, i); - } - - /** - * Creates a boxed byte constant. - * @param i the byte value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forByte(byte i) { - return new CiConstant(CiKind.Byte, i); - } - - /** - * Creates a boxed boolean constant. - * @param i the boolean value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forBoolean(boolean i) { - return i ? TRUE : FALSE; - } - - /** - * Creates a boxed char constant. - * @param i the char value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forChar(char i) { - return new CiConstant(CiKind.Char, i); - } - - /** - * Creates a boxed short constant. - * @param i the short value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forShort(short i) { - return new CiConstant(CiKind.Short, i); - } - - /** - * Creates a boxed address (jsr/ret address) constant. - * @param i the address value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forJsr(int i) { - return new CiConstant(CiKind.Jsr, i); - } - - /** - * Creates a boxed object constant. - * @param o the object value to box - * @return a boxed copy of {@code value} - */ - public static CiConstant forObject(Object o) { - if (o == null) { - return NULL_OBJECT; - } - return new CiConstant(CiKind.Object, o); - } - - /** - * Creates a boxed constant for the given kind from an Object. - * The object needs to be of the Java boxed type corresponding to the kind. - * @param kind the kind of the constant to create - * @param value the Java boxed value: a Byte instance for CiKind Byte, etc. - * @return the boxed copy of {@code value} - */ - public static CiConstant forBoxed(CiKind kind, Object value) { - switch (kind) { - case Byte: - return forByte((Byte) value); - case Char: - return forChar((Character) value); - case Short: - return forShort((Short) value); - case Int: - return forInt((Integer) value); - case Long: - return forLong((Long) value); - case Float: - return forFloat((Float) value); - case Double: - return forDouble((Double) value); - case Object: - return forObject(value); - default: - throw new RuntimeException("cannot create CiConstant for boxed " + kind + " value"); - } - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiDebugInfo.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,108 +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. - * - * 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.cri.ci; - -import java.io.*; - -/** - * Represents the debugging information for a particular place in the code, - * which includes the code position, a reference map, and deoptimization information. - */ -public class CiDebugInfo implements Serializable { - - /** - * - */ - private static final long serialVersionUID = -6047206624915812516L; - - /** - * The code position (including all inlined methods) of this debug info. - * If this is a {@link CiFrame} instance, then it is also the deoptimization information for each inlined frame. - */ - public final CiCodePos codePos; - - /** - * The reference map for the registers at this point. The reference map is <i>packed</i> in that - * for bit {@code k} in byte {@code n}, it refers to the register whose - * {@linkplain CiRegister#number number} is {@code (k + n * 8)}. - */ - public final CiBitMap registerRefMap; - - /** - * The reference map for the stack frame at this point. A set bit at {@code k} in the map - * represents stack slot number {@code k}. - */ - public final CiBitMap frameRefMap; - - /** - * Creates a new {@code CiDebugInfo} from the given values. - * - * @param codePos the {@linkplain CiCodePos code position} or {@linkplain CiFrame frame} info - * @param registerRefMap the register map - * @param frameRefMap the reference map for {@code frame}, which may be {@code null} - */ - public CiDebugInfo(CiCodePos codePos, CiBitMap registerRefMap, CiBitMap frameRefMap) { - this.codePos = codePos; - this.registerRefMap = registerRefMap; - this.frameRefMap = frameRefMap; - } - - /** - * @return {@code true} if this debug information has a frame - */ - public boolean hasFrame() { - return codePos instanceof CiFrame; - } - - /** - * @return {@code true} if this debug info has a reference map for the registers - */ - public boolean hasRegisterRefMap() { - return registerRefMap != null && registerRefMap.size() > 0; - } - - /** - * @return {@code true} if this debug info has a reference map for the stack - */ - public boolean hasStackRefMap() { - return frameRefMap != null && frameRefMap.size() > 0; - } - - - /** - * Gets the deoptimization information for each inlined frame (if available). - * - * @return {@code null} if no frame de-opt info is {@linkplain #hasDebugFrame available} - */ - public CiFrame frame() { - if (hasFrame()) { - return (CiFrame) codePos; - } - return null; - } - - @Override - public String toString() { - return CiUtil.append(new StringBuilder(100), this, null).toString(); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiExceptionHandler.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,93 +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. - * - * 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.cri.ci; - -import com.sun.cri.ri.*; - -/** - * An implementation of the {@link RiExceptionHandler} interface. - */ -public class CiExceptionHandler implements RiExceptionHandler { - - public static final CiExceptionHandler[] NONE = {}; - - public final int startBCI; - public final int endBCI; - public final int handlerBCI; - public final int catchTypeCPI; - public final RiType catchType; - - /** - * Creates a new exception handler with the specified ranges. - * @param startBCI the start index of the protected range - * @param endBCI the end index of the protected range - * @param catchBCI the index of the handler - * @param catchTypeCPI the index of the throwable class in the constant pool - * @param catchType the type caught by this exception handler - */ - public CiExceptionHandler(int startBCI, int endBCI, int catchBCI, int catchTypeCPI, RiType catchType) { - this.startBCI = startBCI; - this.endBCI = endBCI; - this.handlerBCI = catchBCI; - this.catchTypeCPI = catchTypeCPI; - this.catchType = catchType; - } - - public int startBCI() { - return startBCI; - } - - public int endBCI() { - return endBCI; - } - - public int handlerBCI() { - return handlerBCI; - } - - public int catchTypeCPI() { - return catchTypeCPI; - } - - public boolean isCatchAll() { - return catchTypeCPI == 0; - } - - public RiType catchType() { - return catchType; - } - - @Override - public String toString() { - return new StringBuilder(20). - append('['). - append(startBCI). - append(" - "). - append(endBCI). - append(") -> "). - append(handlerBCI). - append(" type="). - append(catchType == null ? "*any*" : catchType.name()). - toString(); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiFrame.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,133 +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. - * - * 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.cri.ci; - -import java.io.*; - -import com.sun.cri.ri.*; - -/** - * Represents the Java bytecode frame state(s) at a given position - * including {@link CiValue locations} where to find the local variables, - * operand stack values and locked objects of the bytecode frame(s). - */ -public class CiFrame extends CiCodePos implements Serializable { - private static final long serialVersionUID = -345025397165977565L; - - /** - * An array of values representing how to reconstruct the state of the Java frame. - * This is array is partitioned as follows: - * <p> - * <table border="1" cellpadding="5" frame="void", rules="all"> - * <tr><th>Start index (inclusive)</th><th>End index (exclusive)</th><th>Description</th></tr> - * <tr><td>0</td> <td>numLocals</td> <td>Local variables</td></tr> - * <tr><td>numLocals</td> <td>numLocals + numStack</td><td>Operand stack</td></tr> - * <tr><td>numLocals + numStack</td><td>values.length</td> <td>Locked objects</td></tr> - * </table> - * <p> - * Note that the number of locals and the number of stack slots may be smaller than the - * maximum number of locals and stack slots as specified in the compiled method. - */ - public final CiValue[] values; - - /** - * The number of locals in the values array. - */ - public final int numLocals; - - /** - * The number of stack slots in the values array. - */ - public final int numStack; - - /** - * The number of locks in the values array. - */ - public final int numLocks; - - public final boolean rethrowException; - - /** - * Creates a new frame object. - * - * @param caller the caller frame (which may be {@code null}) - * @param method the method - * @param bci a BCI within the method - * @param rethrowException specifies if the VM should re-throw the pending exception when deopt'ing using this frame - * @param values the frame state {@link #values} - * @param numLocals the number of local variables - * @param numStack the depth of the stack - * @param numLocks the number of locked objects - */ - public CiFrame(CiFrame caller, RiResolvedMethod method, int bci, boolean rethrowException, CiValue[] values, int numLocals, int numStack, int numLocks) { - super(caller, method, bci); - assert values != null; - this.rethrowException = rethrowException; - this.values = values; - this.numLocks = numLocks; - this.numLocals = numLocals; - this.numStack = numStack; - assert !rethrowException || numStack == 1 : "must have exception on top of the stack"; - } - - /** - * Gets the value representing the specified local variable. - * @param i the local variable index - * @return the value that can be used to reconstruct the local's current value - */ - public CiValue getLocalValue(int i) { - return values[i]; - } - - /** - * Gets the value representing the specified stack slot. - * @param i the stack index - * @return the value that can be used to reconstruct the stack slot's current value - */ - public CiValue getStackValue(int i) { - return values[i + numLocals]; - } - - /** - * Gets the value representing the specified lock. - * @param i the lock index - * @return the value that can be used to reconstruct the lock's current value - */ - public CiValue getLockValue(int i) { - return values[i + numLocals + numStack]; - } - - /** - * Gets the caller of this frame. - * - * @return {@code null} if this frame has no caller - */ - public CiFrame caller() { - return (CiFrame) caller; - } - - @Override - public String toString() { - return CiUtil.append(new StringBuilder(100), this).toString(); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiGenericCallback.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,41 +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. - * - * 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.cri.ci; - -/** - * This interface is used for {@link CiRuntimeCall#GenericCallback} runtime calls. - */ -public abstract class CiGenericCallback { - - @SuppressWarnings("unused") - private Object callbackInternal(Object arg) { - try { - return callback(arg); - } catch (Throwable t) { - t.printStackTrace(); - return null; - } - } - - public abstract Object callback(Object arg); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiKind.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,340 +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. - * - * 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.cri.ci; - -import static com.sun.cri.ci.CiKind.Flags.*; -import sun.misc.*; - -import com.sun.cri.ri.*; - -/** - * Denotes the basic kinds of types in CRI, including the all the Java primitive types, - * for example, {@link CiKind#Int} for {@code int} and {@link CiKind#Object} - * for all object types. - * A kind has a single character short name, a Java name, and a set of flags - * further describing its behavior. - */ -public enum CiKind { - Boolean('z', "boolean", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), - Byte ('b', "byte", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), - Short ('s', "short", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), - Char ('c', "char", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), - Int ('i', "int", FIELD_TYPE | RETURN_TYPE | PRIMITIVE | STACK_INT), - Float ('f', "float", FIELD_TYPE | RETURN_TYPE | PRIMITIVE), - Long ('j', "long", FIELD_TYPE | RETURN_TYPE | PRIMITIVE), - Double ('d', "double", FIELD_TYPE | RETURN_TYPE | PRIMITIVE), - Object ('a', "Object", FIELD_TYPE | RETURN_TYPE), - Void ('v', "void", RETURN_TYPE), - /** Denote a bytecode address in a {@code JSR} bytecode. */ - Jsr ('r', "jsr", 0), - /** The non-type. */ - Illegal('-', "illegal", 0); - - public static final CiKind[] VALUES = values(); - public static final CiKind[] JAVA_VALUES = new CiKind[] {CiKind.Boolean, CiKind.Byte, CiKind.Short, CiKind.Char, CiKind.Int, CiKind.Float, CiKind.Long, CiKind.Double, CiKind.Object}; - - CiKind(char ch, String name, int flags) { - this.typeChar = ch; - this.javaName = name; - this.flags = flags; - } - - static class Flags { - /** - * Can be an object field type. - */ - public static final int FIELD_TYPE = 0x0001; - /** - * Can be result type of a method. - */ - public static final int RETURN_TYPE = 0x0002; - /** - * Behaves as an integer when on Java evaluation stack. - */ - public static final int STACK_INT = 0x0004; - /** - * Represents a Java primitive type. - */ - public static final int PRIMITIVE = 0x0008; - } - - /** - * The flags for this kind. - */ - private final int flags; - - /** - * The name of the kind as a single character. - */ - public final char typeChar; - - /** - * The name of this kind which will also be it Java programming language name if - * it is {@linkplain #isPrimitive() primitive} or {@code void}. - */ - public final String javaName; - - /** - * Checks whether this kind is valid as the type of a field. - * @return {@code true} if this kind is valid as the type of a Java field - */ - public boolean isValidFieldType() { - return (flags & FIELD_TYPE) != 0; - } - - /** - * Checks whether this kind is valid as the return type of a method. - * @return {@code true} if this kind is valid as the return type of a Java method - */ - public boolean isValidReturnType() { - return (flags & RETURN_TYPE) != 0; - } - - /** - * Checks whether this type is valid as an {@code int} on the Java operand stack. - * @return {@code true} if this type is represented by an {@code int} on the operand stack - */ - public boolean isInt() { - return (flags & STACK_INT) != 0; - } - - /** - * Checks whether this type is a Java primitive type. - * @return {@code true} if this is {@link #Boolean}, {@link #Byte}, {@link #Char}, {@link #Short}, - * {@link #Int}, {@link #Long}, {@link #Float} or {@link #Double}. - */ - public boolean isPrimitive() { - return (flags & PRIMITIVE) != 0; - } - - /** - * Gets the kind that represents this kind when on the Java operand stack. - * @return the kind used on the operand stack - */ - public CiKind stackKind() { - if (isInt()) { - return Int; - } - return this; - } - - public static CiKind fromTypeString(String typeString) { - assert typeString.length() > 0; - final char first = typeString.charAt(0); - if (first == '[' || first == 'L') { - return CiKind.Object; - } - return CiKind.fromPrimitiveOrVoidTypeChar(first); - } - - /** - * Gets the kind from the character describing a primitive or void. - * @param ch the character - * @return the kind - */ - public static CiKind fromPrimitiveOrVoidTypeChar(char ch) { - // Checkstyle: stop - switch (ch) { - case 'Z': return Boolean; - case 'C': return Char; - case 'F': return Float; - case 'D': return Double; - case 'B': return Byte; - case 'S': return Short; - case 'I': return Int; - case 'J': return Long; - case 'V': return Void; - } - // Checkstyle: resume - throw new IllegalArgumentException("unknown primitive or void type character: " + ch); - } - - public Class< ? > toJavaClass() { - // Checkstyle: stop - switch(this) { - case Void: return java.lang.Void.TYPE; - case Long: return java.lang.Long.TYPE; - case Int: return java.lang.Integer.TYPE; - case Byte: return java.lang.Byte.TYPE; - case Char: return java.lang.Character.TYPE; - case Double: return java.lang.Double.TYPE; - case Float: return java.lang.Float.TYPE; - case Short: return java.lang.Short.TYPE; - case Boolean: return java.lang.Boolean.TYPE; - default: return null; - } - // Checkstyle: resume - } - - public Class< ? > toUnboxedJavaClass() { - // Checkstyle: stop - switch(this) { - case Void: return null; - case Long: return java.lang.Long.class; - case Int: return java.lang.Integer.class; - case Byte: return java.lang.Byte.class; - case Char: return java.lang.Character.class; - case Double: return java.lang.Double.class; - case Float: return java.lang.Float.class; - case Short: return java.lang.Short.class; - case Boolean: return java.lang.Boolean.class; - default: return null; - } - // Checkstyle: resume - } - - /** - * Checks whether this value type is void. - * @return {@code true} if this type is void - */ - public final boolean isVoid() { - return this == CiKind.Void; - } - - /** - * Checks whether this value type is long. - * @return {@code true} if this type is long - */ - public final boolean isLong() { - return this == CiKind.Long; - } - - /** - * Checks whether this value type is float. - * @return {@code true} if this type is float - */ - public final boolean isFloat() { - return this == CiKind.Float; - } - - /** - * Checks whether this value type is double. - * @return {@code true} if this type is double - */ - public final boolean isDouble() { - return this == CiKind.Double; - } - - /** - * Checks whether this value type is float or double. - * @return {@code true} if this type is float or double - */ - public final boolean isFloatOrDouble() { - return this == CiKind.Double || this == CiKind.Float; - } - - /** - * Checks whether this value type is an object type. - * @return {@code true} if this type is an object - */ - public final boolean isObject() { - return this == CiKind.Object; - } - - /** - * Checks whether this value type is an address type. - * @return {@code true} if this type is an address - */ - public boolean isJsr() { - return this == CiKind.Jsr; - } - - /** - * Converts this value type to a string. - */ - @Override - public String toString() { - return javaName; - } - - /** - * Marker interface for types that should be {@linkplain CiKind#format(Object) formatted} - * with their {@link Object#toString()} value. - */ - public interface FormatWithToString {} - - /** - * Gets a formatted string for a given value of this kind. - * - * @param value a value of this kind - * @return a formatted string for {@code value} based on this kind - */ - public String format(Object value) { - if (isObject()) { - if (value == null) { - return "null"; - } else { - if (value instanceof String) { - String s = (String) value; - if (s.length() > 50) { - return "\"" + s.substring(0, 30) + "...\""; - } else { - return " \"" + s + '"'; - } - } else if (value instanceof RiType) { - return "class " + CiUtil.toJavaName((RiType) value); - } else if (value instanceof Enum || value instanceof FormatWithToString) { - return String.valueOf(value); - } else if (value instanceof Class< ? >) { - return ((Class< ? >) value).getName() + ".class"; - } else { - return CiUtil.getSimpleName(value.getClass(), true) + "@" + System.identityHashCode(value); - } - } - } else { - return value.toString(); - } - } - - public final char signatureChar() { - return Character.toUpperCase(typeChar); - } - - public CiConstant readUnsafeConstant(Object value, long displacement) { - Unsafe u = Unsafe.getUnsafe(); - switch(this) { - case Boolean: - return CiConstant.forBoolean(u.getBoolean(value, displacement)); - case Byte: - return CiConstant.forByte(u.getByte(value, displacement)); - case Char: - return CiConstant.forChar(u.getChar(value, displacement)); - case Short: - return CiConstant.forShort(u.getShort(value, displacement)); - case Int: - return CiConstant.forInt(u.getInt(value, displacement)); - case Long: - return CiConstant.forLong(u.getLong(value, displacement)); - case Float: - return CiConstant.forFloat(u.getFloat(value, displacement)); - case Double: - return CiConstant.forDouble(u.getDouble(value, displacement)); - case Object: - return CiConstant.forObject(u.getObject(value, displacement)); - default: - assert false : "unexpected kind: " + this; - return null; - } - } - -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiMonitorValue.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,43 +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. - * - * 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.cri.ci; - -public final class CiMonitorValue extends CiValue { - private static final long serialVersionUID = 8241681800464483691L; - - public CiValue owner; - public final CiValue lockData; - public final boolean eliminated; - - public CiMonitorValue(CiValue owner, CiValue lockData, boolean eliminated) { - super(CiKind.Illegal); - this.owner = owner; - this.lockData = lockData; - this.eliminated = eliminated; - } - - @Override - public String toString() { - return "monitor[" + owner + (lockData != null ? ", " + lockData : "") + (eliminated ? ", eliminated" : "") + "]"; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiRegister.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,257 +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. - * - * 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.cri.ci; - -import java.io.*; -import java.util.*; - -/** - * Represents a target machine register. - */ -public final class CiRegister implements Comparable<CiRegister>, Serializable { - - /** - * - */ - private static final long serialVersionUID = -7213269157816016300L; - - /** - * Invalid register. - */ - public static final CiRegister None = new CiRegister(-1, -1, 0, "noreg"); - - /** - * Frame pointer of the current method. All spill slots and outgoing stack-based arguments - * are addressed relative to this register. - */ - public static final CiRegister Frame = new CiRegister(-2, -2, 0, "framereg", RegisterFlag.CPU); - - public static final CiRegister CallerFrame = new CiRegister(-3, -3, 0, "callerframereg", RegisterFlag.CPU); - - /** - * The identifier for this register that is unique across all the registers in a {@link CiArchitecture}. - * A valid register has {@code number > 0}. - */ - public final int number; - - /** - * The mnemonic of this register. - */ - public final String name; - - /** - * The actual encoding in a target machine instruction for this register, which may or - * may not be the same as {@link #number}. - */ - public final int encoding; - - /** - * The size of the stack slot used to spill the value of this register. - */ - public final int spillSlotSize; - - /** - * The set of {@link RegisterFlag} values associated with this register. - */ - private final int flags; - - /** - * An array of {@link CiRegisterValue} objects, for this register, with one entry - * per {@link CiKind}, indexed by {@link CiKind#ordinal}. - */ - private final CiRegisterValue[] values; - - /** - * Attributes that characterize a register in a useful way. - * - */ - public enum RegisterFlag { - /** - * Denotes an integral (i.e. non floating point) register. - */ - CPU, - - /** - * Denotes a register whose lowest order byte can be addressed separately. - */ - Byte, - - /** - * Denotes a floating point register. - */ - FPU; - - public final int mask = 1 << (ordinal() + 1); - } - - /** - * Creates a {@code CiRegister} instance. - * - * @param number unique identifier for the register - * @param encoding the target machine encoding for the register - * @param spillSlotSize the size of the stack slot used to spill the value of the register - * @param name the mnemonic name for the register - * @param flags the set of {@link RegisterFlag} values for the register - */ - public CiRegister(int number, int encoding, int spillSlotSize, String name, RegisterFlag... flags) { - this.number = number; - this.name = name; - this.spillSlotSize = spillSlotSize; - this.flags = createMask(flags); - this.encoding = encoding; - - values = new CiRegisterValue[CiKind.VALUES.length]; - for (CiKind kind : CiKind.VALUES) { - values[kind.ordinal()] = new CiRegisterValue(kind, this); - } - } - - private static int createMask(RegisterFlag... flags) { - int result = 0; - for (RegisterFlag f : flags) { - result |= f.mask; - } - return result; - } - - public boolean isSet(RegisterFlag f) { - return (flags & f.mask) != 0; - } - - /** - * Gets this register as a {@linkplain CiRegisterValue value} with a specified kind. - * @param kind the specified kind - * @return the {@link CiRegisterValue} - */ - public CiRegisterValue asValue(CiKind kind) { - return values[kind.ordinal()]; - } - - /** - * Gets this register as a {@linkplain CiRegisterValue value} with no particular kind. - * @return a {@link CiRegisterValue} with {@link CiKind#Illegal} kind. - */ - public CiRegisterValue asValue() { - return asValue(CiKind.Illegal); - } - - /** - * Determines if this is a valid register. - * @return {@code true} iff this register is valid - */ - public boolean isValid() { - return number >= 0; - } - - /** - * Determines if this a floating point register. - */ - public boolean isFpu() { - return isSet(RegisterFlag.FPU); - } - - /** - * Determines if this a general purpose register. - */ - public boolean isCpu() { - return isSet(RegisterFlag.CPU); - } - - /** - * Determines if this register has the {@link RegisterFlag#Byte} attribute set. - * @return {@code true} iff this register has the {@link RegisterFlag#Byte} attribute set. - */ - public boolean isByte() { - return isSet(RegisterFlag.Byte); - } - - /** - * Categorizes a set of registers by {@link RegisterFlag}. - * - * @param registers a list of registers to be categorized - * @return a map from each {@link RegisterFlag} constant to the list of registers for which the flag is - * {@linkplain #isSet(RegisterFlag) set} - */ - public static EnumMap<RegisterFlag, CiRegister[]> categorize(CiRegister[] registers) { - EnumMap<RegisterFlag, CiRegister[]> result = new EnumMap<>(RegisterFlag.class); - for (RegisterFlag flag : RegisterFlag.values()) { - ArrayList<CiRegister> list = new ArrayList<>(); - for (CiRegister r : registers) { - if (r.isSet(flag)) { - list.add(r); - } - } - result.put(flag, list.toArray(new CiRegister[list.size()])); - } - return result; - } - - /** - * Gets the maximum register {@linkplain #number number} in a given set of registers. - * - * @param registers the set of registers to process - * @return the maximum register number for any register in {@code registers} - */ - public static int maxRegisterNumber(CiRegister[] registers) { - int max = Integer.MIN_VALUE; - for (CiRegister r : registers) { - if (r.number > max) { - max = r.number; - } - } - return max; - } - - /** - * Gets the maximum register {@linkplain #encoding encoding} in a given set of registers. - * - * @param registers the set of registers to process - * @return the maximum register encoding for any register in {@code registers} - */ - public static int maxRegisterEncoding(CiRegister[] registers) { - int max = Integer.MIN_VALUE; - for (CiRegister r : registers) { - if (r.encoding > max) { - max = r.encoding; - } - } - return max; - } - - @Override - public String toString() { - return name; - } - - @Override - public int compareTo(CiRegister o) { - if (number < o.number) { - return -1; - } - if (number > o.number) { - return 1; - } - return 0; - } - -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiRegisterConfig.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,298 +0,0 @@ -/* - * Copyright (c) 2010, 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 com.sun.cri.ci; - -import java.util.*; - -import com.sun.cri.ci.CiCallingConvention.Type; -import com.sun.cri.ci.CiRegister.RegisterFlag; -import com.sun.cri.ri.*; - -/** - * A default implementation of {@link RiRegisterConfig}. - */ -public class CiRegisterConfig implements RiRegisterConfig { - - /** - * The object describing the callee save area of this register configuration. - */ - public CiCalleeSaveLayout csl; - - /** - * The minimum register role identifier. - */ - public final int minRole; - - /** - * The map from register role IDs to registers. - */ - public final CiRegister[] registersRoleMap; - - /** - * The set of registers that can be used by the register allocator. - */ - public final CiRegister[] allocatable; - - /** - * The set of registers that can be used by the register allocator, - * {@linkplain CiRegister#categorize(CiRegister[]) categorized} by register - * {@linkplain RegisterFlag flags}. - */ - public final EnumMap<RegisterFlag, CiRegister[]> categorized; - - /** - * The ordered set of registers used to pass integral arguments. - */ - public final CiRegister[] cpuParameters; - - /** - * The ordered set of registers used to pass floating point arguments. - */ - public final CiRegister[] fpuParameters; - - /** - * The caller saved registers. - */ - public final CiRegister[] callerSave; - - /** - * The register to which {@link CiRegister#Frame} and {@link CiRegister#CallerFrame} are bound. - */ - public final CiRegister frame; - - /** - * Register for returning an integral value. - */ - public final CiRegister integralReturn; - - /** - * Register for returning a floating point value. - */ - public final CiRegister floatingPointReturn; - - /** - * The map from register {@linkplain CiRegister#number numbers} to register - * {@linkplain RiRegisterAttributes attributes} for this register configuration. - */ - public final RiRegisterAttributes[] attributesMap; - - /** - * The scratch register. - */ - public final CiRegister scratch; - - /** - * The frame offset of the first stack argument for each calling convention {@link CiCallingConvention.Type}. - */ - public final int[] stackArg0Offsets = new int[CiCallingConvention.Type.VALUES.length]; - - public CiRegisterConfig( - CiRegister frame, - CiRegister integralReturn, - CiRegister floatingPointReturn, - CiRegister scratch, - CiRegister[] allocatable, - CiRegister[] callerSave, - CiRegister[] parameters, - CiCalleeSaveLayout csl, - CiRegister[] allRegisters, - Map<Integer, CiRegister> roles) { - this.frame = frame; - this.csl = csl; - this.allocatable = allocatable; - this.callerSave = callerSave; - assert !Arrays.asList(allocatable).contains(scratch); - this.scratch = scratch; - EnumMap<RegisterFlag, CiRegister[]> categorizedParameters = CiRegister.categorize(parameters); - this.cpuParameters = categorizedParameters.get(RegisterFlag.CPU); - this.fpuParameters = categorizedParameters.get(RegisterFlag.FPU); - categorized = CiRegister.categorize(allocatable); - attributesMap = RiRegisterAttributes.createMap(this, allRegisters); - this.floatingPointReturn = floatingPointReturn; - this.integralReturn = integralReturn; - int minRoleId = Integer.MAX_VALUE; - int maxRoleId = Integer.MIN_VALUE; - for (Map.Entry<Integer, CiRegister> e : roles.entrySet()) { - int id = e.getKey(); - assert id >= 0; - if (minRoleId > id) { - minRoleId = id; - } - if (maxRoleId < id) { - maxRoleId = id; - } - } - registersRoleMap = new CiRegister[(maxRoleId - minRoleId) + 1]; - for (Map.Entry<Integer, CiRegister> e : roles.entrySet()) { - int id = e.getKey(); - registersRoleMap[id] = e.getValue(); - } - minRole = minRoleId; - } - - public CiRegisterConfig(CiRegisterConfig src, CiCalleeSaveLayout csl) { - this.frame = src.frame; - this.csl = csl; - this.allocatable = src.allocatable; - this.callerSave = src.callerSave; - this.scratch = src.scratch; - this.cpuParameters = src.cpuParameters; - this.fpuParameters = src.fpuParameters; - this.categorized = src.categorized; - this.attributesMap = src.attributesMap; - this.floatingPointReturn = src.floatingPointReturn; - this.integralReturn = src.integralReturn; - this.registersRoleMap = src.registersRoleMap; - this.minRole = src.minRole; - System.arraycopy(src.stackArg0Offsets, 0, stackArg0Offsets, 0, stackArg0Offsets.length); - } - - public CiRegister getReturnRegister(CiKind kind) { - if (kind.isDouble() || kind.isFloat()) { - return floatingPointReturn; - } - return integralReturn; - } - - public CiRegister getFrameRegister() { - return frame; - } - - public CiRegister getScratchRegister() { - return scratch; - } - - /** - * {@inheritDoc} - * - * This implementation assigns all available registers to parameters before assigning - * any stack slots to parameters. - */ - public CiCallingConvention getCallingConvention(Type type, CiKind[] parameters, CiTarget target, boolean stackOnly) { - CiValue[] locations = new CiValue[parameters.length]; - - int currentGeneral = 0; - int currentXMM = 0; - int currentStackOffset = stackArg0Offsets[type.ordinal()]; - - for (int i = 0; i < parameters.length; i++) { - final CiKind kind = parameters[i]; - - switch (kind) { - case Byte: - case Boolean: - case Short: - case Char: - case Int: - case Long: - case Object: - if (!stackOnly && currentGeneral < cpuParameters.length) { - CiRegister register = cpuParameters[currentGeneral++]; - locations[i] = register.asValue(kind); - } - break; - - case Float: - case Double: - if (!stackOnly && currentXMM < fpuParameters.length) { - CiRegister register = fpuParameters[currentXMM++]; - locations[i] = register.asValue(kind); - } - break; - - default: - throw new InternalError("Unexpected parameter kind: " + kind); - } - - if (locations[i] == null) { - locations[i] = CiStackSlot.get(kind.stackKind(), currentStackOffset, !type.out); - currentStackOffset += Math.max(target.sizeInBytes(kind), target.wordSize); - } - } - - return new CiCallingConvention(locations, currentStackOffset); - } - - public CiRegister[] getCallingConventionRegisters(Type type, RegisterFlag flag) { - if (flag == RegisterFlag.CPU) { - return cpuParameters; - } - assert flag == RegisterFlag.FPU; - return fpuParameters; - } - - public CiRegister[] getAllocatableRegisters() { - return allocatable; - } - - public EnumMap<RegisterFlag, CiRegister[]> getCategorizedAllocatableRegisters() { - return categorized; - } - - public CiRegister[] getCallerSaveRegisters() { - return callerSave; - } - - public CiCalleeSaveLayout getCalleeSaveLayout() { - return csl; - } - - public RiRegisterAttributes[] getAttributesMap() { - return attributesMap; - } - - public CiRegister getRegisterForRole(int id) { - return registersRoleMap[id - minRole]; - } - - @Override - public String toString() { - StringBuilder roleMap = new StringBuilder(); - for (int i = 0; i < registersRoleMap.length; ++i) { - CiRegister reg = registersRoleMap[i]; - if (reg != null) { - if (roleMap.length() != 0) { - roleMap.append(", "); - } - roleMap.append(i + minRole).append(" -> ").append(reg); - } - } - StringBuilder stackArg0OffsetsMap = new StringBuilder(); - for (Type t : Type.VALUES) { - if (stackArg0OffsetsMap.length() != 0) { - stackArg0OffsetsMap.append(", "); - } - stackArg0OffsetsMap.append(t).append(" -> ").append(stackArg0Offsets[t.ordinal()]); - } - String res = String.format( - "Allocatable: " + Arrays.toString(getAllocatableRegisters()) + "%n" + - "CallerSave: " + Arrays.toString(getCallerSaveRegisters()) + "%n" + - "CalleeSave: " + getCalleeSaveLayout() + "%n" + - "CPU Params: " + Arrays.toString(cpuParameters) + "%n" + - "FPU Params: " + Arrays.toString(fpuParameters) + "%n" + - "VMRoles: " + roleMap + "%n" + - "stackArg0: " + stackArg0OffsetsMap + "%n" + - "Scratch: " + getScratchRegister() + "%n"); - return res; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiRegisterValue.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,55 +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. - * - * 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.cri.ci; - -/** - * Denotes a register that stores a value of a fixed kind. There is exactly one (canonical) instance of {@code - * CiRegisterValue} for each ({@link CiRegister}, {@link CiKind}) pair. Use {@link CiRegister#asValue(CiKind)} to - * retrieve the canonical {@link CiRegisterValue} instance for a given (register,kind) pair. - */ -public final class CiRegisterValue extends CiValue { - private static final long serialVersionUID = 7999341472196897163L; - - /** - * The register. - */ - public final CiRegister reg; - - /** - * Should only be called from {@link CiRegister#CiRegister} to ensure canonicalization. - */ - protected CiRegisterValue(CiKind kind, CiRegister register) { - super(kind); - this.reg = register; - } - - @Override - public int hashCode() { - return (reg.number << 4) ^ kind.ordinal(); - } - - @Override - public String toString() { - return reg.name + kindSuffix(); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiResult.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,75 +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. - * - * 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.cri.ci; - -/** - * Represents the result of compiling a method. The result can include a target method with machine code and metadata, - * and/or statistics. If the compiler bailed out due to malformed bytecode, an internal error, or other cause, it will - * supply the bailout object. - */ -public class CiResult { - private final CiTargetMethod targetMethod; - private final CiBailout bailout; - private final CiStatistics stats; - - /** - * Creates a new compilation result. - * @param targetMethod the method that was produced, if any - * @param bailout the bailout condition that occurred - * @param stats statistics about the compilation - */ - public CiResult(CiTargetMethod targetMethod, CiBailout bailout, CiStatistics stats) { - this.targetMethod = targetMethod; - this.bailout = bailout; - this.stats = stats; - } - - /** - * Gets the target method that was produced by this compilation. If no target method was - * produced, but a bailout occured, then the bailout exception will be thrown at this point. - * @return the target method produced - * @throws {@link CiBailout} if a bailout occurred - */ - public CiTargetMethod targetMethod() { - if (bailout != null) { - throw bailout; - } - return targetMethod; - } - - /** - * Returns the statistics about the compilation that were produced, if any. - * @return the statistics - */ - public CiStatistics statistics() { - return stats; - } - - /** - * Returns the bailout condition that occurred for this compilation, if any. - * @return the bailout - */ - public CiBailout bailout() { - return bailout; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiRuntimeCall.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,62 +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. - * - * 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.cri.ci; - -import static com.sun.cri.ci.CiKind.*; - -/** - * Enumerates the calls that must be provided by the runtime system. The compiler - * may generate code that calls the runtime services for unresolved and slow cases of some - * bytecodes. - */ -public enum CiRuntimeCall { - UnwindException(Void, Object), - Deoptimize(Void), - RegisterFinalizer(Void, Object), - HandleException(Void, Object), - SetDeoptInfo(Void, Object), - CreateNullPointerException(Object), - CreateOutOfBoundsException(Object, Int), - OSRMigrationEnd(Void), - JavaTimeMillis(Long), - JavaTimeNanos(Long), - Debug(Void), - ArithmethicLrem(Long, Long, Long), - ArithmeticLdiv(Long, Long, Long), - ArithmeticFrem(Float, Float, Float), - ArithmeticDrem(Double, Double, Double), - ArithmeticCos(Double, Double), - ArithmeticTan(Double, Double), - ArithmeticLog(Double, Double), - ArithmeticLog10(Double, Double), - ArithmeticSin(Double, Double), - GenericCallback(Object, Object, Object); - - public final CiKind resultKind; - public final CiKind[] arguments; - - private CiRuntimeCall(CiKind resultKind, CiKind... args) { - this.resultKind = resultKind; - this.arguments = args; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiStackSlot.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,175 +0,0 @@ -/* - * Copyright (c) 2010, 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 com.sun.cri.ci; - -import static com.sun.cri.ci.CiKind.*; - -/** - * Represents a compiler spill slot or an outgoing stack-based argument in a method's frame - * or an incoming stack-based argument in a method's {@linkplain #inCallerFrame() caller's frame}. - */ -public final class CiStackSlot extends CiValue { - private static final long serialVersionUID = -7725071921307318433L; - - private final int offset; - private final boolean addFrameSize; - - /** - * Gets a {@link CiStackSlot} instance representing a stack slot at a given index - * holding a value of a given kind. - * - * @param kind The kind of the value stored in the stack slot. - * @param offset The offset of the stack slot (in bytes) - * @param inCallerFrame Specifies if the offset is relative to the stack pointer, - * or the beginning of the frame (stack pointer + total frame size). - */ - public static CiStackSlot get(CiKind kind, int offset, boolean addFrameSize) { - assert kind.stackKind() == kind; - assert addFrameSize || offset >= 0; - - if (offset % CACHE_GRANULARITY == 0) { - CiStackSlot[][] cache; - int index = offset / CACHE_GRANULARITY; - if (!addFrameSize) { - cache = OUT_CACHE; - } else if (offset >= 0) { - cache = IN_CACHE; - } else { - cache = SPILL_CACHE; - index = -index; - } - CiStackSlot[] slots = cache[kind.ordinal()]; - if (index < slots.length) { - CiStackSlot slot = slots[index]; - assert slot.kind == kind && slot.offset == offset && slot.addFrameSize == addFrameSize; - return slot; - } - } - return new CiStackSlot(kind, offset, addFrameSize); - } - - /** - * Private constructor to enforce use of {@link #get()} so that a cache can be used. - */ - private CiStackSlot(CiKind kind, int offset, boolean addFrameSize) { - super(kind); - this.offset = offset; - this.addFrameSize = addFrameSize; - } - - /** - * Gets the offset of this stack slot, relative to the stack pointer. - * @return The offset of this slot (in bytes). - */ - public int offset(int totalFrameSize) { - assert totalFrameSize > 0 || !addFrameSize; - int result = offset + (addFrameSize ? totalFrameSize : 0); - assert result >= 0; - return result; - } - - public boolean inCallerFrame() { - return addFrameSize && offset >= 0; - } - - public int rawOffset() { - return offset; - } - - public boolean rawAddFrameSize() { - return addFrameSize; - } - - @Override - public int hashCode() { - return kind.ordinal() ^ (offset << 4) ^ (addFrameSize ? 15 : 0); - } - - @Override - public boolean equals(Object o) { - if (o == this) { - return true; - } - if (o instanceof CiStackSlot) { - CiStackSlot l = (CiStackSlot) o; - return l.kind == kind && l.offset == offset && l.addFrameSize == addFrameSize; - } - return false; - } - - @Override - public String toString() { - String s; - if (!addFrameSize) { - s = "out:"; - } else if (offset >= 0) { - s = "in:"; - } else { - s = "spill:"; - } - return s + offset + kindSuffix(); - } - - /** - * Gets this stack slot used to pass an argument from the perspective of a caller. - */ - public CiStackSlot asOutArg() { - assert offset >= 0; - if (addFrameSize) { - return get(kind, offset, false); - } - return this; - } - - /** - * Gets this stack slot used to pass an argument from the perspective of a callee. - */ - public CiStackSlot asInArg() { - assert offset >= 0; - if (!addFrameSize) { - return get(kind, offset, true); - } - return this; - } - - - private static final int CACHE_GRANULARITY = 8; - private static final int SPILL_CACHE_PER_KIND_SIZE = 100; - private static final int PARAM_CACHE_PER_KIND_SIZE = 10; - - private static final CiStackSlot[][] SPILL_CACHE = makeCache(SPILL_CACHE_PER_KIND_SIZE, -1, true); - private static final CiStackSlot[][] IN_CACHE = makeCache(PARAM_CACHE_PER_KIND_SIZE, 1, true); - private static final CiStackSlot[][] OUT_CACHE = makeCache(PARAM_CACHE_PER_KIND_SIZE, 1, false); - - private static CiStackSlot[][] makeCache(int cachePerKindSize, int sign, boolean addFrameSize) { - CiStackSlot[][] cache = new CiStackSlot[CiKind.VALUES.length][]; - for (CiKind kind : new CiKind[] {Illegal, Int, Long, Float, Double, Object, Jsr}) { - CiStackSlot[] slots = new CiStackSlot[cachePerKindSize]; - for (int i = 0; i < cachePerKindSize; i++) { - slots[i] = new CiStackSlot(kind, sign * i * CACHE_GRANULARITY, addFrameSize); - } - cache[kind.ordinal()] = slots; - } - return cache; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiStatistics.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,66 +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. - * - * 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.cri.ci; - -/** - * Contains statistics gathered during the compilation of a method and reported back - * from the compiler as the result of compilation. - */ -public class CiStatistics { - - /** - * The total number of bytes of bytecode parsed during this compilation, including any inlined methods. - */ - public int bytecodeCount; - - /** - * The number of internal graph nodes created during this compilation. - */ - public int nodeCount; - - /** - * The number of basic blocks created during this compilation. - */ - public int blockCount; - - /** - * The number of loops in the compiled method. - */ - public int loopCount; - - /** - * The number of methods inlined. - */ - public int inlineCount; - - /** - * The number of methods folded (i.e. evaluated). - */ - public int foldCount; - - /** - * The number of intrinsics inlined in this compilation. - */ - public int intrinsicCount; - -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiTarget.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,157 +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. - * - * 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.cri.ci; - - -/** - * Represents the target machine for a compiler, including the CPU architecture, the size of pointers and references, - * alignment of stacks, caches, etc. - */ -public class CiTarget { - public final CiArchitecture arch; - - /** - * The OS page size. - */ - public final int pageSize; - - /** - * Specifies if this is a multi-processor system. - */ - public final boolean isMP; - - /** - * Specifies if this target supports encoding objects inline in the machine code. - */ - public final boolean inlineObjects; - - /** - * The machine word size on this target. - */ - public final int wordSize; - - /** - * The CiKind to be used for representing raw pointers and CPU registers. - */ - public final CiKind wordKind; - - /** - * The stack alignment requirement of the platform. For example, - * from Appendix D of <a href="http://www.intel.com/Assets/PDF/manual/248966.pdf">Intel 64 and IA-32 Architectures Optimization Reference Manual</a>: - * <pre> - * "It is important to ensure that the stack frame is aligned to a - * 16-byte boundary upon function entry to keep local __m128 data, - * parameters, and XMM register spill locations aligned throughout - * a function invocation." - * </pre> - */ - public final int stackAlignment; - - /** - * @see http://docs.sun.com/app/docs/doc/806-0477/6j9r2e2b9?a=view - */ - public final int stackBias; - - /** - * The cache alignment. - */ - public final int cacheAlignment; - - /** - * Specifies how {@code long} and {@code double} constants are to be stored - * in {@linkplain CiFrame frames}. This is useful for VMs such as HotSpot - * where convention the interpreter uses is that the second local - * holds the first raw word of the native long or double representation. - * This is actually reasonable, since locals and stack arrays - * grow downwards in all implementations. - * If, on some machine, the interpreter's Java locals or stack - * were to grow upwards, the embedded doubles would be word-swapped.) - */ - public final boolean debugInfoDoubleWordsInSecondSlot; - - /** - * Temporary flag to distinguish between the semantics necessary for HotSpot and Maxine. - */ - // TODO This should go away when XIR goes away, and the logic be part of the VM-specific lowering. - public final boolean invokeSnippetAfterArguments; - - public CiTarget(CiArchitecture arch, - boolean isMP, - int stackAlignment, - int pageSize, - int cacheAlignment, - boolean inlineObjects, - boolean debugInfoDoubleWordsInSecondSlot, - boolean invokeSnippetAfterArguments) { - this.arch = arch; - this.pageSize = pageSize; - this.isMP = isMP; - this.wordSize = arch.wordSize; - if (wordSize == 8) { - this.wordKind = CiKind.Long; - } else { - this.wordKind = CiKind.Int; - } - this.stackAlignment = stackAlignment; - this.stackBias = 0; // TODO: configure with param once SPARC port exists - this.cacheAlignment = cacheAlignment; - this.inlineObjects = inlineObjects; - this.debugInfoDoubleWordsInSecondSlot = debugInfoDoubleWordsInSecondSlot; - this.invokeSnippetAfterArguments = invokeSnippetAfterArguments; - } - - /** - * Gets the size in bytes of the specified kind for this target. - * - * @param kind the kind for which to get the size - * @return the size in bytes of {@code kind} - */ - public int sizeInBytes(CiKind kind) { - // Checkstyle: stop - switch (kind) { - case Boolean: return 1; - case Byte: return 1; - case Char: return 2; - case Short: return 2; - case Int: return 4; - case Long: return 8; - case Float: return 4; - case Double: return 8; - case Object: return wordSize; - case Jsr: return 4; - default: return 0; - } - // Checkstyle: resume - } - - /** - * Aligns the given frame size (without return instruction pointer) to the stack - * alignment size and return the aligned size (without return instruction pointer). - * @param frameSize the initial frame size to be aligned - * @return the aligned frame size - */ - public int alignFrameSize(int frameSize) { - int x = frameSize + arch.returnAddressSize + (stackAlignment - 1); - return (x / stackAlignment) * stackAlignment - arch.returnAddressSize; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiTargetMethod.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,596 +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. - * - * 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.cri.ci; - -import java.io.*; -import java.util.*; - -import com.sun.cri.ri.*; - -/** - * Represents the output from compiling a method, including the compiled machine code, associated data and references, - * relocation information, deoptimization information, etc. It is the essential component of a {@link CiResult}, which also includes - * {@linkplain CiStatistics compilation statistics} and {@linkplain CiBailout failure information}. - */ -public class CiTargetMethod implements Serializable { - - /** - * - */ - private static final long serialVersionUID = -1319947729753702434L; - - /** - * Represents a code position with associated additional information. - */ - public abstract static class Site implements Serializable { - /** - * - */ - private static final long serialVersionUID = -8214214947651979102L; - /** - * The position (or offset) of this site with respect to the start of the target method. - */ - public final int pcOffset; - - public Site(int pos) { - this.pcOffset = pos; - } - } - - /** - * Represents a safepoint with associated debug info. - */ - public static class Safepoint extends Site implements Comparable<Safepoint> { - /** - * - */ - private static final long serialVersionUID = 2479806696381720162L; - public final CiDebugInfo debugInfo; - - Safepoint(int pcOffset, CiDebugInfo debugInfo) { - super(pcOffset); - this.debugInfo = debugInfo; - } - - @Override - public String toString() { - StringBuilder sb = new StringBuilder(); - sb.append(pcOffset); - sb.append("[<safepoint>]"); - appendDebugInfo(sb, debugInfo); - return sb.toString(); - } - - @Override - public int compareTo(Safepoint o) { - if (pcOffset < o.pcOffset) { - return -1; - } else if (pcOffset > o.pcOffset) { - return 1; - } - return 0; - } - } - - /** - * Represents a call in the code. - */ - public static final class Call extends Safepoint { - /** - * - */ - private static final long serialVersionUID = 1440741241631046954L; - - /** - * The target of the call. - */ - public final Object target; - - /** - * The size of the call instruction. - */ - public final int size; - - /** - * Specifies if this call is direct or indirect. A direct call has an immediate operand encoding - * the absolute or relative (to the call itself) address of the target. An indirect call has a - * register or memory operand specifying the target address of the call. - */ - public final boolean direct; - - Call(Object target, int pcOffset, int size, boolean direct, CiDebugInfo debugInfo) { - super(pcOffset, debugInfo); - this.size = size; - this.target = target; - this.direct = direct; - } - - @Override - public String toString() { - StringBuilder sb = new StringBuilder(); - sb.append(pcOffset); - sb.append('['); - sb.append(target); - sb.append(']'); - - if (debugInfo != null) { - appendDebugInfo(sb, debugInfo); - } - - return sb.toString(); - } - } - - /** - * Represents a reference to data from the code. The associated data can be any constant. - */ - public static final class DataPatch extends Site { - /** - * - */ - private static final long serialVersionUID = 5771730331604867476L; - public final CiConstant constant; - public final int alignment; - - DataPatch(int pcOffset, CiConstant data, int alignment) { - super(pcOffset); - this.constant = data; - this.alignment = alignment; - } - - @Override - public String toString() { - return String.format("%d[<data patch referring to data %s>]", pcOffset, constant); - } - } - - /** - * Provides extra information about instructions or data at specific positions in {@link CiTargetMethod#targetCode()}. - * This is optional information that can be used to enhance a disassembly of the code. - */ - public abstract static class CodeAnnotation implements Serializable { - /** - * - */ - private static final long serialVersionUID = -7903959680749520748L; - public final int position; - - public CodeAnnotation(int position) { - this.position = position; - } - } - - /** - * A string comment about one or more instructions at a specific position in the code. - */ - public static final class CodeComment extends CodeAnnotation { - /** - * - */ - private static final long serialVersionUID = 6802287188701961401L; - public final String value; - public CodeComment(int position, String comment) { - super(position); - this.value = comment; - } - - @Override - public String toString() { - return getClass().getSimpleName() + "@" + position + ": " + value; - } - } - - /** - * Labels some inline data in the code. - */ - public static final class InlineData extends CodeAnnotation { - /** - * - */ - private static final long serialVersionUID = 305997507263827108L; - public final int size; - public InlineData(int position, int size) { - super(position); - this.size = size; - } - - @Override - public String toString() { - return getClass().getSimpleName() + "@" + position + ": size=" + size; - } - } - - /** - * Describes a table of signed offsets embedded in the code. The offsets are relative to the starting - * address of the table. This type of table maybe generated when translating a multi-way branch - * based on a key value from a dense value set (e.g. the {@code tableswitch} JVM instruction). - * - * The table is indexed by the contiguous range of integers from {@link #low} to {@link #high} inclusive. - */ - public static final class JumpTable extends CodeAnnotation { - /** - * - */ - private static final long serialVersionUID = 2222194398353801831L; - - /** - * The low value in the key range (inclusive). - */ - public final int low; - - /** - * The high value in the key range (inclusive). - */ - public final int high; - - /** - * The size (in bytes) of each table entry. - */ - public final int entrySize; - - public JumpTable(int position, int low, int high, int entrySize) { - super(position); - this.low = low; - this.high = high; - this.entrySize = entrySize; - } - - @Override - public String toString() { - return getClass().getSimpleName() + "@" + position + ": [" + low + " .. " + high + "]"; - } - } - - /** - * Describes a table of key and offset pairs. The offset in each table entry is relative to the address of - * the table. This type of table maybe generated when translating a multi-way branch - * based on a key value from a sparse value set (e.g. the {@code lookupswitch} JVM instruction). - */ - public static final class LookupTable extends CodeAnnotation { - /** - * - */ - private static final long serialVersionUID = 8367952567559116160L; - - /** - * The number of entries in the table. - */ - public final int npairs; - - /** - * The size (in bytes) of entry's key. - */ - public final int keySize; - - /** - * The size (in bytes) of entry's offset value. - */ - public final int offsetSize; - - public LookupTable(int position, int npairs, int keySize, int offsetSize) { - super(position); - this.npairs = npairs; - this.keySize = keySize; - this.offsetSize = offsetSize; - } - - @Override - public String toString() { - return getClass().getSimpleName() + "@" + position + ": [npairs=" + npairs + ", keySize=" + keySize + ", offsetSize=" + offsetSize + "]"; - } - } - - /** - * Represents exception handler information for a specific code position. It includes the catch code position as - * well as the caught exception type. - */ - public static final class ExceptionHandler extends Site { - /** - * - */ - private static final long serialVersionUID = 4897339464722665281L; - public final int bci; - public final int scopeLevel; - public final int handlerPos; - public final int handlerBci; - public final RiType exceptionType; - - ExceptionHandler(int pcOffset, int bci, int scopeLevel, int handlerPos, int handlerBci, RiType exceptionType) { - super(pcOffset); - this.bci = bci; - this.scopeLevel = scopeLevel; - this.handlerPos = handlerPos; - this.handlerBci = handlerBci; - this.exceptionType = exceptionType; - } - - @Override - public String toString() { - return String.format("%d[<exception edge to %d with type %s>]", pcOffset, handlerPos, (exceptionType == null) ? "null" : exceptionType); - } - } - - public static final class Mark extends Site { - /** - * - */ - private static final long serialVersionUID = 3612943150662354844L; - public final Object id; - public final Mark[] references; - - Mark(int pcOffset, Object id, Mark[] references) { - super(pcOffset); - this.id = id; - this.references = references; - } - - @Override - public String toString() { - if (id == null) { - return String.format("%d[<mark with %d references>]", pcOffset, references.length); - } else if (id instanceof Integer) { - return String.format("%d[<mark with %d references and id %s>]", pcOffset, references.length, Integer.toHexString((Integer) id)); - } else { - return String.format("%d[<mark with %d references and id %s>]", pcOffset, references.length, id.toString()); - } - } - } - - /** - * List of safepoints, sorted by {@link Site#pcOffset}. - */ - public final List<Safepoint> safepoints = new ArrayList<>(); - - /** - * List of data references. - */ - public final List<DataPatch> dataReferences = new ArrayList<>(); - - /** - * List of exception handlers. - */ - public final List<ExceptionHandler> exceptionHandlers = new ArrayList<>(); - - /** - * List of marks. - */ - public final List<Mark> marks = new ArrayList<>(); - - private int frameSize = -1; - private int customStackAreaOffset = -1; - private int registerRestoreEpilogueOffset = -1; - /** - * The buffer containing the emitted machine code. - */ - private byte[] targetCode; - - /** - * The leading number of bytes in {@link #targetCode} containing the emitted machine code. - */ - private int targetCodeSize; - - private ArrayList<CodeAnnotation> annotations; - - private CiAssumptions assumptions; - - /** - * Constructs a new target method. - */ - public CiTargetMethod() { - } - - public void setAssumptions(CiAssumptions assumptions) { - this.assumptions = assumptions; - } - - public CiAssumptions assumptions() { - return assumptions; - } - - /** - * Sets the frame size in bytes. Does not include the return address pushed onto the - * stack, if any. - * - * @param size the size of the frame in bytes - */ - public void setFrameSize(int size) { - frameSize = size; - } - - /** - * Sets the machine that has been generated by the compiler. - * - * @param code the machine code generated - * @param size the size of the machine code - */ - public void setTargetCode(byte[] code, int size) { - targetCode = code; - targetCodeSize = size; - } - - /** - * Records a reference to the data section in the code section (e.g. to load an integer or floating point constant). - * - * @param codePos the position in the code where the data reference occurs - * @param data the data that is referenced - * @param alignment the alignment requirement of the data or 0 if there is no alignment requirement - */ - public void recordDataReference(int codePos, CiConstant data, int alignment) { - assert codePos >= 0 && data != null; - dataReferences.add(new DataPatch(codePos, data, alignment)); - } - - /** - * Records a call in the code array. - * - * @param codePos the position of the call in the code array - * @param size the size of the call instruction - * @param target the {@link RiRuntime#asCallTarget(Object) target} being called - * @param debugInfo the debug info for the call - * @param direct specifies if this is a {@linkplain Call#direct direct} call - */ - public void recordCall(int codePos, int size, Object target, CiDebugInfo debugInfo, boolean direct) { - final Call call = new Call(target, codePos, size, direct, debugInfo); - addSafepoint(call); - } - - /** - * Records an exception handler for this method. - * - * @param codePos the position in the code that is covered by the handler - * @param handlerPos the position of the handler - * @param throwableType the type of exceptions handled by the handler - */ - public void recordExceptionHandler(int codePos, int bci, int scopeLevel, int handlerPos, int handlerBci, RiType throwableType) { - exceptionHandlers.add(new ExceptionHandler(codePos, bci, scopeLevel, handlerPos, handlerBci, throwableType)); - } - - /** - * Records a safepoint in the code array. - * - * @param codePos the position of the safepoint in the code array - * @param debugInfo the debug info for the safepoint - */ - public void recordSafepoint(int codePos, CiDebugInfo debugInfo) { - addSafepoint(new Safepoint(codePos, debugInfo)); - } - - private void addSafepoint(Safepoint safepoint) { - // The safepoints list must always be sorted - if (!safepoints.isEmpty() && safepoints.get(safepoints.size() - 1).pcOffset >= safepoint.pcOffset) { - // This re-sorting should be very rare - Collections.sort(safepoints); - } - safepoints.add(safepoint); - } - - /** - * Records an instruction mark within this method. - * - * @param codePos the position in the code that is covered by the handler - * @param id the identifier for this mark - * @param references an array of other marks that this mark references - */ - public Mark recordMark(int codePos, Object id, Mark[] references) { - Mark mark = new Mark(codePos, id, references); - marks.add(mark); - return mark; - } - - /** - * Allows a method to specify the offset of the epilogue that restores the callee saved registers. Must be called - * iff the method is a callee saved method and stores callee registers on the stack. - * - * @param registerRestoreEpilogueOffset the offset in the machine code where the epilogue begins - */ - public void setRegisterRestoreEpilogueOffset(int registerRestoreEpilogueOffset) { - assert this.registerRestoreEpilogueOffset == -1; - this.registerRestoreEpilogueOffset = registerRestoreEpilogueOffset; - } - - /** - * The frame size of the method in bytes. - * - * @return the frame size - */ - public int frameSize() { - assert frameSize != -1 : "frame size not yet initialized!"; - return frameSize; - } - - /** - * @return the code offset of the start of the epilogue that restores all callee saved registers, or -1 if this is - * not a callee saved method - */ - public int registerRestoreEpilogueOffset() { - return registerRestoreEpilogueOffset; - } - - /** - * Offset in bytes for the custom stack area (relative to sp). - * @return the offset in bytes - */ - public int customStackAreaOffset() { - return customStackAreaOffset; - } - - /** - * @see #customStackAreaOffset() - * @param offset - */ - public void setCustomStackAreaOffset(int offset) { - customStackAreaOffset = offset; - } - - /** - * @return the machine code generated for this method - */ - public byte[] targetCode() { - return targetCode; - } - - /** - * @return the size of the machine code generated for this method - */ - public int targetCodeSize() { - return targetCodeSize; - } - - /** - * @return the code annotations or {@code null} if there are none - */ - public List<CodeAnnotation> annotations() { - return annotations; - } - - public void addAnnotation(CodeAnnotation annotation) { - assert annotation != null; - if (annotations == null) { - annotations = new ArrayList<>(); - } - annotations.add(annotation); - } - - private static void appendDebugInfo(StringBuilder sb, CiDebugInfo info) { - if (info != null) { - appendRefMap(sb, "stackMap", info.frameRefMap); - appendRefMap(sb, "registerMap", info.registerRefMap); - CiCodePos codePos = info.codePos; - if (codePos != null) { - CiUtil.appendLocation(sb.append(" "), codePos.method, codePos.bci); - if (info.hasFrame()) { - sb.append(" #locals=").append(info.frame().numLocals).append(" #expr=").append(info.frame().numStack); - if (info.frame().numLocks > 0) { - sb.append(" #locks=").append(info.frame().numLocks); - } - } - } - } - } - - private static void appendRefMap(StringBuilder sb, String name, CiBitMap map) { - if (map != null) { - sb.append(' ').append(name).append('[').append(map.toBinaryString()).append(']'); - } - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiUtil.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,739 +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. - * - * 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.cri.ci; - -import static java.lang.reflect.Modifier.*; - -import java.lang.annotation.*; -import java.util.*; - -import com.sun.cri.ri.*; - -/** - * Miscellaneous collection of utility methods used in the {@code CRI} project. - */ -public class CiUtil { - - public static final String NEW_LINE = String.format("%n"); - - /** - * Gets the annotation of a particular type for a formal parameter of a given method. - * - * @param annotationClass the Class object corresponding to the annotation type - * @param parameterIndex the index of a formal parameter of {@code method} - * @param method the method for which a parameter annotation is being requested - * @return the annotation of type {@code annotationClass} for the formal parameter present, else null - * @throws IndexOutOfBoundsException if {@code parameterIndex} does not denote a formal parameter - */ - public static <T extends Annotation> T getParameterAnnotation(Class<T> annotationClass, int parameterIndex, RiResolvedMethod method) { - if (parameterIndex >= 0) { - Annotation[][] parameterAnnotations = method.getParameterAnnotations(); - for (Annotation a : parameterAnnotations[parameterIndex]) { - if (a.annotationType() == annotationClass) { - return annotationClass.cast(a); - } - } - } - return null; - } - - /** - * Extends the functionality of {@link Class#getSimpleName()} to include a non-empty string for anonymous and local - * classes. - * - * @param clazz the class for which the simple name is being requested - * @param withEnclosingClass specifies if the returned name should be qualified with the name(s) of the enclosing - * class/classes of {@code clazz} (if any). This option is ignored if {@code clazz} denotes an anonymous - * or local class. - * @return the simple name - */ - public static String getSimpleName(Class<?> clazz, boolean withEnclosingClass) { - final String simpleName = clazz.getSimpleName(); - if (simpleName.length() != 0) { - if (withEnclosingClass) { - String prefix = ""; - Class<?> enclosingClass = clazz; - while ((enclosingClass = enclosingClass.getEnclosingClass()) != null) { - prefix = prefix + enclosingClass.getSimpleName() + "."; - } - return prefix + simpleName; - } - return simpleName; - } - // Must be an anonymous or local class - final String name = clazz.getName(); - int index = name.indexOf('$'); - if (index == -1) { - return name; - } - index = name.lastIndexOf('.', index); - if (index == -1) { - return name; - } - return name.substring(index + 1); - } - - public static final int K = 1024; - public static final int M = 1024 * 1024; - public static boolean isOdd(int n) { - return (n & 1) == 1; - } - - public static boolean isEven(int n) { - return (n & 1) == 0; - } - - /** - * Checks whether the specified integer is a power of two. - * - * @param val the value to check - * @return {@code true} if the value is a power of two; {@code false} otherwise - */ - public static boolean isPowerOf2(int val) { - return val != 0 && (val & val - 1) == 0; - } - - /** - * Checks whether the specified long is a power of two. - * - * @param val the value to check - * @return {@code true} if the value is a power of two; {@code false} otherwise - */ - public static boolean isPowerOf2(long val) { - return val != 0 && (val & val - 1) == 0; - } - - /** - * Computes the log (base 2) of the specified integer, rounding down. - * (E.g {@code log2(8) = 3}, {@code log2(21) = 4}) - * - * @param val the value - * @return the log base 2 of the value - */ - public static int log2(int val) { - assert val > 0 && isPowerOf2(val); - return 31 - Integer.numberOfLeadingZeros(val); - } - - /** - * Computes the log (base 2) of the specified long, rounding down. - * (E.g {@code log2(8) = 3}, {@code log2(21) = 4}) - * - * @param val the value - * @return the log base 2 of the value - */ - public static int log2(long val) { - assert val > 0 && isPowerOf2(val); - return 63 - Long.numberOfLeadingZeros(val); - } - - public static int align(int size, int align) { - assert isPowerOf2(align); - return (size + align - 1) & ~(align - 1); - } - - /** - * Gets a word with the nth bit set. - * @param n the nth bit to set - * @return an integer value with the nth bit set - */ - public static int nthBit(int n) { - return n >= Integer.SIZE ? 0 : 1 << n; - } - - /** - * Gets a word with the right-most n bits set. - * @param n the number of right most bits to set - * @return an integer value with the right-most n bits set - */ - public static int rightNBits(int n) { - return nthBit(n) - 1; - } - - /** - * Converts a given type to its Java programming language name. The following are examples of strings returned by - * this method: - * - * <pre> - * qualified == true: - * java.lang.Object - * int - * boolean[][] - * qualified == false: - * Object - * int - * boolean[][] - * </pre> - * - * @param riType the type to be converted to a Java name - * @param qualified specifies if the package prefix of the type should be included in the returned name - * @return the Java name corresponding to {@code riType} - */ - public static String toJavaName(RiType riType, boolean qualified) { - CiKind kind = riType.kind(false); - if (kind.isPrimitive() || kind == CiKind.Void) { - return kind.javaName; - } - return internalNameToJava(riType.name(), qualified); - } - /** - * Converts a given type to its Java programming language name. The following are examples of strings returned by - * this method: - * - * <pre> - * java.lang.Object - * int - * boolean[][] - * </pre> - * - * @param riType the type to be converted to a Java name - * @return the Java name corresponding to {@code riType} - */ - public static String toJavaName(RiType riType) { - return (riType == null) ? null : internalNameToJava(riType.name(), true); - } - - public static String internalNameToJava(String name, boolean qualified) { - switch (name.charAt(0)) { - case 'L': { - String result = name.substring(1, name.length() - 1).replace('/', '.'); - if (!qualified) { - final int lastDot = result.lastIndexOf('.'); - if (lastDot != -1) { - result = result.substring(lastDot + 1); - } - } - return result; - - } - case '[': - return internalNameToJava(name.substring(1), qualified) + "[]"; - default: - if (name.length() != 1) { - throw new IllegalArgumentException("Illegal internal name: " + name); - } - return CiKind.fromPrimitiveOrVoidTypeChar(name.charAt(0)).javaName; - } - } - - /** - * Gets a string for a given method formatted according to a given format specification. A format specification is - * composed of characters that are to be copied verbatim to the result and specifiers that denote an attribute of - * the method that is to be copied to the result. A specifier is a single character preceded by a '%' character. The - * accepted specifiers and the method attributes they denote are described below: - * - * <pre> - * Specifier | Description | Example(s) - * ----------+------------------------------------------------------------------------------------------ - * 'R' | Qualified return type | "int" "java.lang.String" - * 'r' | Unqualified return type | "int" "String" - * 'H' | Qualified holder | "java.util.Map.Entry" - * 'h' | Unqualified holder | "Entry" - * 'n' | Method name | "add" - * 'P' | Qualified parameter types, separated by ', ' | "int, java.lang.String" - * 'p' | Unqualified parameter types, separated by ', ' | "int, String" - * 'f' | Indicator if method is unresolved, static or virtual | "unresolved" "static" "virtual" - * '%' | A '%' character | "%" - * </pre> - * - * @param format a format specification - * @param method the method to be formatted - * @param kinds if {@code true} then the types in {@code method}'s signature are printed in the - * {@linkplain CiKind#jniName JNI} form of their {@linkplain CiKind kind} - * @return the result of formatting this method according to {@code format} - * @throws IllegalFormatException if an illegal specifier is encountered in {@code format} - */ - public static String format(String format, RiMethod method) throws IllegalFormatException { - final StringBuilder sb = new StringBuilder(); - int index = 0; - RiSignature sig = null; - while (index < format.length()) { - final char ch = format.charAt(index++); - if (ch == '%') { - if (index >= format.length()) { - throw new UnknownFormatConversionException("An unquoted '%' character cannot terminate a method format specification"); - } - final char specifier = format.charAt(index++); - boolean qualified = false; - switch (specifier) { - case 'R': - qualified = true; - // fall through - case 'r': { - if (sig == null) { - sig = method.signature(); - } - sb.append(toJavaName(sig.returnType(null), qualified)); - break; - } - case 'H': - qualified = true; - // fall through - case 'h': { - sb.append(toJavaName(method.holder(), qualified)); - break; - } - case 'n': { - sb.append(method.name()); - break; - } - case 'P': - qualified = true; - // fall through - case 'p': { - if (sig == null) { - sig = method.signature(); - } - for (int i = 0; i < sig.argumentCount(false); i++) { - if (i != 0) { - sb.append(", "); - } - sb.append(toJavaName(sig.argumentTypeAt(i, null), qualified)); - } - break; - } - case 'f': { - sb.append(!(method instanceof RiResolvedMethod) ? "unresolved" : isStatic(((RiResolvedMethod) method).accessFlags()) ? "static" : "virtual"); - break; - } - case '%': { - sb.append('%'); - break; - } - default: { - throw new UnknownFormatConversionException(String.valueOf(specifier)); - } - } - } else { - sb.append(ch); - } - } - return sb.toString(); - } - /** - * Gets a string for a given field formatted according to a given format specification. A format specification is - * composed of characters that are to be copied verbatim to the result and specifiers that denote an attribute of - * the field that is to be copied to the result. A specifier is a single character preceded by a '%' character. The - * accepted specifiers and the field attributes they denote are described below: - * - * <pre> - * Specifier | Description | Example(s) - * ----------+------------------------------------------------------------------------------------------ - * 'T' | Qualified type | "int" "java.lang.String" - * 't' | Unqualified type | "int" "String" - * 'H' | Qualified holder | "java.util.Map.Entry" - * 'h' | Unqualified holder | "Entry" - * 'n' | Field name | "age" - * 'f' | Indicator if field is unresolved, static or instance | "unresolved" "static" "instance" - * '%' | A '%' character | "%" - * </pre> - * - * @param format a format specification - * @param field the field to be formatted - * @param kinds if {@code true} then {@code field}'s type is printed in the - * {@linkplain CiKind#jniName JNI} form of its {@linkplain CiKind kind} - * @return the result of formatting this field according to {@code format} - * @throws IllegalFormatException if an illegal specifier is encountered in {@code format} - */ - public static String format(String format, RiField field) throws IllegalFormatException { - final StringBuilder sb = new StringBuilder(); - int index = 0; - RiType type = field.type(); - while (index < format.length()) { - final char ch = format.charAt(index++); - if (ch == '%') { - if (index >= format.length()) { - throw new UnknownFormatConversionException("An unquoted '%' character cannot terminate a field format specification"); - } - final char specifier = format.charAt(index++); - boolean qualified = false; - switch (specifier) { - case 'T': - qualified = true; - // fall through - case 't': { - sb.append(toJavaName(type, qualified)); - break; - } - case 'H': - qualified = true; - // fall through - case 'h': { - sb.append(toJavaName(field.holder(), qualified)); - break; - } - case 'n': { - sb.append(field.name()); - break; - } - case 'f': { - sb.append(!(field instanceof RiResolvedField) ? "unresolved" : isStatic(((RiResolvedField) field).accessFlags()) ? "static" : "instance"); - break; - } - case '%': { - sb.append('%'); - break; - } - default: { - throw new UnknownFormatConversionException(String.valueOf(specifier)); - } - } - } else { - sb.append(ch); - } - } - return sb.toString(); - } - - /** - * Gets a stack trace element for a given method and bytecode index. - */ - public static StackTraceElement toStackTraceElement(RiMethod method, @SuppressWarnings("unused") int bci) { - // TODO(tw): Look if we can use bci to get the line number. - return new StackTraceElement(CiUtil.toJavaName(method.holder()), method.name(), null, -1); - } - - /** - * Converts a Java source-language class name into the internal form. - * - * @param className the class name - * @return the internal name form of the class name - */ - public static String toInternalName(String className) { - return "L" + className.replace('.', '/') + ";"; - } - - /** - * Creates a set that uses reference-equality instead of {@link Object#equals(Object)} - * when comparing values. - * - * @param <T> the type of elements in the set - * @return a set based on reference-equality - */ - public static <T> Set<T> newIdentityHashSet() { - return Collections.newSetFromMap(new IdentityHashMap<T, Boolean>()); - } - - /** - * Prepends the String {@code indentation} to every line in String {@code lines}, - * including a possibly non-empty line following the final newline. - */ - public static String indent(String lines, String indentation) { - if (lines.length() == 0) { - return lines; - } - final String newLine = "\n"; - if (lines.endsWith(newLine)) { - return indentation + (lines.substring(0, lines.length() - 1)).replace(newLine, newLine + indentation) + newLine; - } - return indentation + lines.replace(newLine, newLine + indentation); - } - - /** - * Formats the values in a frame as a tabulated string. - * - * @param frame - * @return the values in {@code frame} as a tabulated string - */ - public static String tabulateValues(CiFrame frame) { - int cols = Math.max(frame.numLocals, Math.max(frame.numStack, frame.numLocks)); - assert cols > 0; - ArrayList<Object> cells = new ArrayList<>(); - cells.add(""); - for (int i = 0; i < cols; i++) { - cells.add(i); - } - cols++; - if (frame.numLocals != 0) { - cells.add("locals:"); - cells.addAll(Arrays.asList(frame.values).subList(0, frame.numLocals)); - cells.addAll(Collections.nCopies(cols - frame.numLocals - 1, "")); - } - if (frame.numStack != 0) { - cells.add("stack:"); - cells.addAll(Arrays.asList(frame.values).subList(frame.numLocals, frame.numLocals + frame.numStack)); - cells.addAll(Collections.nCopies(cols - frame.numStack - 1, "")); - } - if (frame.numLocks != 0) { - cells.add("locks:"); - cells.addAll(Arrays.asList(frame.values).subList(frame.numLocals + frame.numStack, frame.values.length)); - cells.addAll(Collections.nCopies(cols - frame.numLocks - 1, "")); - } - Object[] cellArray = cells.toArray(); - for (int i = 0; i < cellArray.length; i++) { - if ((i % cols) != 0) { - cellArray[i] = "|" + cellArray[i]; - } - } - return CiUtil.tabulate(cellArray, cols, 1, 1); - } - - /** - * Formats a given table as a string. The value of each cell is produced by {@link String#valueOf(Object)}. - * - * @param cells the cells of the table in row-major order - * @param cols the number of columns per row - * @param lpad the number of space padding inserted before each formatted cell value - * @param rpad the number of space padding inserted after each formatted cell value - * @return a string with one line per row and each column left-aligned - */ - public static String tabulate(Object[] cells, int cols, int lpad, int rpad) { - int rows = (cells.length + (cols - 1)) / cols; - int[] colWidths = new int[cols]; - for (int col = 0; col < cols; col++) { - for (int row = 0; row < rows; row++) { - int index = col + (row * cols); - if (index < cells.length) { - Object cell = cells[index]; - colWidths[col] = Math.max(colWidths[col], String.valueOf(cell).length()); - } - } - } - StringBuilder sb = new StringBuilder(); - String nl = NEW_LINE; - for (int row = 0; row < rows; row++) { - for (int col = 0; col < cols; col++) { - int index = col + (row * cols); - if (index < cells.length) { - for (int i = 0; i < lpad; i++) { - sb.append(' '); - } - Object cell = cells[index]; - String s = String.valueOf(cell); - int w = s.length(); - sb.append(s); - while (w < colWidths[col]) { - sb.append(' '); - w++; - } - for (int i = 0; i < rpad; i++) { - sb.append(' '); - } - } - } - sb.append(nl); - } - return sb.toString(); - } - - /** - * Convenient shortcut for calling {@link #appendLocation(StringBuilder, RiMethod, int)} - * without having to supply a a {@link StringBuilder} instance and convert the result - * to a string. - */ - public static String toLocation(RiResolvedMethod method, int bci) { - return appendLocation(new StringBuilder(), method, bci).toString(); - } - - - /** - * Appends a string representation of a location specified by a given method and bci to - * a given {@link StringBuilder}. If a stack trace element with a non-null file name - * and non-negative line number is {@linkplain RiMethod#toStackTraceElement(int) available} - * for the given method, then the string returned is the {@link StackTraceElement#toString()} - * value of the stack trace element, suffixed by the bci location. For example: - * <pre> - * java.lang.String.valueOf(String.java:2930) [bci: 12] - * </pre> - * Otherwise, the string returned is the value of {@code CiUtil.format("%H.%n(%p)"}, suffixed - * by the bci location. For example: - * <pre> - * java.lang.String.valueOf(int) [bci: 12] - * </pre> - * - * @param sb - * @param method - * @param bci - * @return - */ - public static StringBuilder appendLocation(StringBuilder sb, RiResolvedMethod method, int bci) { - StackTraceElement ste = method.toStackTraceElement(bci); - if (ste.getFileName() != null && ste.getLineNumber() > 0) { - sb.append(ste); - } else { - sb.append(CiUtil.format("%H.%n(%p)", method)); - } - return sb.append(" [bci: ").append(bci).append(']'); - } - - /** - * Appends a formatted code position to a {@link StringBuilder}. - * - * @param sb the {@link StringBuilder} to append to - * @param pos the code position to format and append to {@code sb} - * @return the value of {@code sb} - */ - public static StringBuilder append(StringBuilder sb, CiCodePos pos) { - appendLocation(sb.append("at "), pos.method, pos.bci); - if (pos.caller != null) { - sb.append(NEW_LINE); - append(sb, pos.caller); - } - return sb; - } - - /** - * Appends a formatted frame to a {@link StringBuilder}. - * - * @param sb the {@link StringBuilder} to append to - * @param frame the frame to format and append to {@code sb} - * @return the value of {@code sb} - */ - public static StringBuilder append(StringBuilder sb, CiFrame frame) { - appendLocation(sb.append("at "), frame.method, frame.bci); - if (frame.values != null && frame.values.length > 0) { - sb.append(NEW_LINE); - String table = tabulateValues(frame); - String[] rows = table.split(NEW_LINE); - for (int i = 0; i < rows.length; i++) { - String row = rows[i]; - if (!row.trim().isEmpty()) { - sb.append(" ").append(row); - if (i != rows.length - 1) { - sb.append(NEW_LINE); - } - } - } - } - if (frame.caller() != null) { - sb.append(NEW_LINE); - append(sb, frame.caller()); - } else if (frame.caller != null) { - sb.append(NEW_LINE); - append(sb, frame.caller); - } - return sb; - } - - /** - * Formats a location present in a register or frame reference map. - */ - public static class RefMapFormatter { - /** - * The size of a stack slot. - */ - public final int slotSize; - - /** - * The register used as the frame pointer. - */ - public final CiRegister fp; - - public final CiArchitecture arch; - - /** - * The offset (in bytes) from the slot pointed to by {@link #fp} to the slot - * corresponding to bit 0 in the frame reference map. - */ - public final int refMapToFPOffset; - - public RefMapFormatter(CiArchitecture arch, int slotSize, CiRegister fp, int refMapToFPOffset) { - this.arch = arch; - this.slotSize = slotSize; - this.fp = fp; - this.refMapToFPOffset = refMapToFPOffset; - } - - public String formatStackSlot(int frameRefMapIndex) { - int refMapOffset = frameRefMapIndex * slotSize; - int fpOffset = refMapOffset + refMapToFPOffset; - if (fpOffset >= 0) { - return fp + "+" + fpOffset; - } - return fp.name + fpOffset; - } - - public String formatRegister(int regRefMapIndex) { - return arch.registers[regRefMapIndex].toString(); - } - } - - /** - * Appends a formatted debug info to a {@link StringBuilder}. - * - * @param sb the {@link StringBuilder} to append to - * @param info the debug info to format and append to {@code sb} - * @return the value of {@code sb} - */ - public static StringBuilder append(StringBuilder sb, CiDebugInfo info, RefMapFormatter formatter) { - String nl = NEW_LINE; - if (info.hasRegisterRefMap()) { - sb.append(" reg-ref-map:"); - CiBitMap bm = info.registerRefMap; - if (formatter != null) { - for (int reg = bm.nextSetBit(0); reg >= 0; reg = bm.nextSetBit(reg + 1)) { - sb.append(" " + formatter.formatRegister(reg)); - } - } - sb.append(' ').append(bm).append(nl); - } - if (info.hasStackRefMap()) { - sb.append("frame-ref-map:"); - CiBitMap bm = info.frameRefMap; - if (formatter != null) { - for (int i = bm.nextSetBit(0); i >= 0; i = bm.nextSetBit(i + 1)) { - sb.append(" " + formatter.formatStackSlot(i)); - } - } - sb.append(' ').append(bm).append(nl); - } - CiFrame frame = info.frame(); - if (frame != null) { - append(sb, frame); - } else if (info.codePos != null) { - append(sb, info.codePos); - } - return sb; - } - - public static CiKind[] signatureToKinds(RiResolvedMethod method) { - CiKind receiver = isStatic(method.accessFlags()) ? null : method.holder().kind(true); - return signatureToKinds(method.signature(), receiver); - } - - public static CiKind[] signatureToKinds(RiSignature signature, CiKind receiverKind) { - int args = signature.argumentCount(false); - CiKind[] result; - int i = 0; - if (receiverKind != null) { - result = new CiKind[args + 1]; - result[0] = receiverKind; - i = 1; - } else { - result = new CiKind[args]; - } - for (int j = 0; j < args; j++) { - result[i + j] = signature.argumentKindAt(j, true); - } - return result; - } - - public static Class<?>[] signatureToTypes(RiSignature signature, RiType accessingClass) { - int count = signature.argumentCount(false); - Class<?>[] result = new Class<?>[count]; - for (int i = 0; i < result.length; ++i) { - result[i] = ((RiResolvedType) signature.argumentTypeAt(i, accessingClass)).toJava(); - } - return result; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiValue.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,60 +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. - * - * 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.cri.ci; - -import java.io.*; - -/** - * Abstract base class for values manipulated by the compiler. All values have a {@linkplain CiKind kind} and are immutable. - */ -public abstract class CiValue implements Serializable { - private static final long serialVersionUID = -6909397188697766469L; - - @SuppressWarnings("serial") - public static CiValue IllegalValue = new CiValue(CiKind.Illegal) { - @Override - public String toString() { - return "-"; - } - }; - - /** - * The kind of this value. - */ - public final CiKind kind; - - /** - * Initializes a new value of the specified kind. - * @param kind the kind - */ - protected CiValue(CiKind kind) { - this.kind = kind; - } - - /** - * String representation of the kind, which should be the end of all {@link #toString()} implementation of subclasses. - */ - protected final String kindSuffix() { - return "|" + kind.typeChar; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiValueUtil.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,103 +0,0 @@ -/* - * Copyright (c) 2012, 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 com.sun.cri.ci; - -public class CiValueUtil { - public static boolean isIllegal(CiValue value) { - assert value != null; - return value == CiValue.IllegalValue; - } - - public static boolean isLegal(CiValue value) { - return !isIllegal(value); - } - - public static boolean isVirtualObject(CiValue value) { - assert value != null; - return value instanceof CiVirtualObject; - } - - - public static boolean isVariable(CiValue value) { - assert value != null; - return value instanceof CiVariable; - } - - public static CiVariable asVariable(CiValue value) { - assert value != null; - return (CiVariable) value; - } - - - public static boolean isConstant(CiValue value) { - assert value != null; - return value instanceof CiConstant; - } - - - public static boolean isStackSlot(CiValue value) { - assert value != null; - return value instanceof CiStackSlot; - } - - public static CiStackSlot asStackSlot(CiValue value) { - assert value != null; - return (CiStackSlot) value; - } - - - public static boolean isRegister(CiValue value) { - assert value != null; - return value instanceof CiRegisterValue; - } - - public static CiRegister asRegister(CiValue value) { - assert value != null; - return ((CiRegisterValue) value).reg; - } - - public static CiRegister asIntReg(CiValue value) { - assert value.kind == CiKind.Int || value.kind == CiKind.Jsr; - return asRegister(value); - } - - public static CiRegister asLongReg(CiValue value) { - assert value.kind == CiKind.Long : value.kind; - return asRegister(value); - } - - public static CiRegister asObjectReg(CiValue value) { - assert value.kind == CiKind.Object; - return asRegister(value); - } - - public static CiRegister asFloatReg(CiValue value) { - assert value.kind == CiKind.Float; - return asRegister(value); - } - - public static CiRegister asDoubleReg(CiValue value) { - assert value.kind == CiKind.Double; - return asRegister(value); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiVariable.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,106 +0,0 @@ -/* - * Copyright (c) 2010, 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 com.sun.cri.ci; - -/** - * Represents a value that is yet to be bound to a machine location (such as - * a {@linkplain CiRegister register} or stack {@linkplain CiAddress address}) - * by a register allocator. - */ -public final class CiVariable extends CiValue { - private static final long serialVersionUID = 4507578431686109809L; - - /** - * The identifier of the variable. This is a non-zero index in a contiguous 0-based name space. - */ - public final int index; - - /** - * Creates a new variable. - * @param kind - * @param index - */ - private CiVariable(CiKind kind, int index) { - super(kind); - this.index = index; - } - - private static CiVariable[] generate(CiKind kind, int count) { - CiVariable[] variables = new CiVariable[count]; - for (int i = 0; i < count; i++) { - variables[i] = new CiVariable(kind, i); - } - return variables; - } - - private static final int CACHE_PER_KIND_SIZE = 100; - - /** - * Cache of common variables. - */ - private static final CiVariable[][] cache = new CiVariable[CiKind.values().length][]; - static { - for (CiKind kind : CiKind.values()) { - cache[kind.ordinal()] = generate(kind, CACHE_PER_KIND_SIZE); - } - } - - /** - * Gets a variable for a given kind and index. - * - * @param kind - * @param index - * @return the corresponding {@code CiVariable} - */ - public static CiVariable get(CiKind kind, int index) { - //assert kind == kind.stackKind() : "Variables can be only created for stack kinds"; - assert index >= 0; - CiVariable[] cachedVars = cache[kind.ordinal()]; - if (index < cachedVars.length) { - return cachedVars[index]; - } - return new CiVariable(kind, index); - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj instanceof CiVariable) { - CiVariable var = (CiVariable) obj; - return kind == var.kind && index == var.index; - } - return false; - } - - @Override - public int hashCode() { - return (index << 4) | kind.ordinal(); - } - - @Override - public String toString() { - return "v" + index + kindSuffix(); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/CiVirtualObject.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,164 +0,0 @@ -/* - * Copyright (c) 2010, 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 com.sun.cri.ci; - -import com.sun.cri.ri.*; - -/** - * An instance of this class represents an object whose allocation was removed by escape analysis. The information stored in the {@link CiVirtualObject} is used during - * deoptimization to recreate the object. - */ -public final class CiVirtualObject extends CiValue { - private static final long serialVersionUID = -2907197776426346021L; - - private final RiType type; - private CiValue[] values; - private final int id; - - /** - * Creates a new CiVirtualObject for the given type, with the given fields. If the type is an instance class then the values array needs to have one entry for each field, ordered in - * like the fields returned by {@link RiResolvedType#declaredFields()}. If the type is an array then the length of the values array determines the reallocated array length. - * @param type the type of the object whose allocation was removed during compilation. This can be either an instance of an array type. - * @param values an array containing all the values to be stored into the object when it is recreated. - * @param id a unique id that identifies the object within the debug information for one position in the compiled code. - * @return a new CiVirtualObject instance. - */ - public static CiVirtualObject get(RiType type, CiValue[] values, int id) { - return new CiVirtualObject(type, values, id); - } - - private CiVirtualObject(RiType type, CiValue[] values, int id) { - super(CiKind.Object); - this.type = type; - this.values = values; - this.id = id; - } - - @Override - public String toString() { - return "vobject:" + id; - } - - /** - * @return the type of the object whose allocation was removed during compilation. This can be either an instance of an array type. - */ - public RiType type() { - return type; - } - - /** - * @return an array containing all the values to be stored into the object when it is recreated. - */ - public CiValue[] values() { - return values; - } - - /** - * @return the unique id that identifies the object within the debug information for one position in the compiled code. - */ - public int id() { - return id; - } - - /** - * Overwrites the current set of values with a new one. - * @param values an array containing all the values to be stored into the object when it is recreated. - */ - public void setValues(CiValue[] values) { - this.values = values; - } - - @Override - public int hashCode() { - return kind.ordinal() + type.hashCode(); - } - - @Override - public boolean equals(Object o) { - if (o == this) { - return true; - } - if (o instanceof CiVirtualObject) { - CiVirtualObject l = (CiVirtualObject) o; - if (l.type != type || l.values.length != values.length) { - return false; - } - for (int i = 0; i < values.length; i++) { - if (values[i] != l.values[i]) { - return false; - } - } - return true; - } - return false; - } - - /** - * This is a helper class used to create virtual objects for a number of different JDK classes. - */ - public static class CiVirtualObjectFactory { - private int nextId = 0; - private final RiRuntime runtime; - - public CiVirtualObjectFactory(RiRuntime runtime) { - this.runtime = runtime; - } - - public CiVirtualObject constantProxy(CiKind kind, CiValue objectValue, CiValue primitiveValue) { - CiConstant cKind = CiConstant.forObject(kind); - // TODO: here the ordering is hard coded... we should query RiType.fields() and act accordingly - return new CiVirtualObject(runtime.getType(CiConstant.class), new CiValue[] {cKind, primitiveValue, CiValue.IllegalValue, objectValue}, nextId++); - } - - public CiValue proxy(CiValue ciValue) { - switch (ciValue.kind) { - case Boolean: - return new CiVirtualObject(runtime.getType(Boolean.class), new CiValue[] {ciValue}, nextId++); - case Byte: - return new CiVirtualObject(runtime.getType(Byte.class), new CiValue[] {ciValue}, nextId++); - case Char: - return new CiVirtualObject(runtime.getType(Character.class), new CiValue[] {ciValue}, nextId++); - case Double: - return new CiVirtualObject(runtime.getType(Double.class), new CiValue[] {ciValue, CiValue.IllegalValue}, nextId++); - case Float: - return new CiVirtualObject(runtime.getType(Float.class), new CiValue[] {ciValue}, nextId++); - case Int: - return new CiVirtualObject(runtime.getType(Integer.class), new CiValue[] {ciValue}, nextId++); - case Long: - return new CiVirtualObject(runtime.getType(Long.class), new CiValue[] {ciValue, CiValue.IllegalValue}, nextId++); - case Object: - return ciValue; - case Short: - return new CiVirtualObject(runtime.getType(Short.class), new CiValue[] {ciValue}, nextId++); - default: - assert false : ciValue.kind; - return null; - } - } - - public CiVirtualObject arrayProxy(RiType arrayType, CiValue[] values) { - return new CiVirtualObject(arrayType, values, nextId++); - } - - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ci/package-info.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,47 +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. - * - * 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 compiler-provided part of the bi-directional interface between the compiler and the runtime system of a virtual machine for the instruction set defined in - * {@link com.sun.cri.bytecode.Bytecodes}. - * - * The target hardware architecture is represented by {@link com.sun.cri.ci.CiArchitecture} and the specific target machine - * environment for a compiler instance is represented by {@link com.sun.cri.ci.CiTarget}. - * <p> - * A {@code CiResult} encapsulates - * {@linkplain com.sun.cri.ci.CiStatistics compilation statistics}, possible {@linkplain com.sun.cri.ci.CiBailout error state} - * and the {@linkplain com.sun.cri.ci.CiTargetMethod compiled code and metadata}. - * {@link com.sun.cri.ci.CiCodePos} and {@link com.sun.cri.ci.CiDebugInfo} provide detailed information to the - * runtime to support debugging and deoptimization of the compiled code. - * <p> - * The compiler manipulates {@link com.sun.cri.ci.CiValue} instances that have a {@link com.sun.cri.ci.CiKind}, and are - * immutable. A concrete {@link com.sun.cri.ci.CiValue value} is one of the following subclasses: - * <ul> - * <li>{@link com.sun.cri.ci.CiConstant}: a constant value. - * <li>{@link com.sun.cri.ci.CiRegisterValue}: a value stored in a {@linkplain com.sun.cri.ci.CiRegister target machine register}. - * <li>{@link com.sun.cri.ci.CiStackSlot}: a spill slot or an outgoing stack-based argument in a method's frame. - * <li>{@link com.sun.cri.ci.CiAddress}: an address in target machine memory. - * <li>{@link com.sun.cri.ci.CiVariable}: a value (cf. virtual register) that is yet to be bound to a target machine location (physical register or memory address). - *</ul> - */ -package com.sun.cri.ci; -
--- a/graal/com.oracle.max.cri/src/com/sun/cri/package-info.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,38 +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. - * - * 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. - */ -/** - * A virtual machine compiler-runtime interface (CRI). - * <p> - * Specifically, this package defines an interface between the compiler and the runtime system of a virtual machine for - * the instruction set defined in {@link com.sun.cri.bytecode.Bytecodes}. The interface has three components: - * <ol> - * <li>the {@link com.sun.cri.ci compiler-provided interface} that must be used by the runtime. - * <li>the {@link com.sun.cri.ri runtime-provided interface} that must be used by the compiler. - * <li>the {@link com.sun.cri.xir XIR interface} for translating object operations. - * </ol> - * - * The interface is independent of any particular compiler or runtime implementation. - * <p> - * For more details see <a href="http://wikis.sun.com/download/attachments/173802383/vee2010.pdf">Improving Compiler-Runtime Separation with XIR</a>. - */ -package com.sun.cri;
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiCompiledMethod.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,40 +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. - * - * 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.cri.ri; - -/** - * Represents a compiled instance of a method. It may have been invalidated or removed in the meantime. - */ -public interface RiCompiledMethod { - - /** - * Returns the method to which the compiled code belongs. - * @return the method to which the compiled code belongs. - */ - RiResolvedMethod method(); - - /** - * @return true if the code represented by this object is still valid, false otherwise (may happen due to deopt, etc.) - */ - boolean isValid(); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiConstantPool.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,93 +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. - * - * 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.cri.ri; - -/** - * Represents the runtime representation of the constant pool that is - * used by the compiler when parsing bytecode. The {@code lookupXXX} methods look up a constant - * pool entry without performing resolution, and are used during compilation. - */ -public interface RiConstantPool { - - /** - * Makes sure that the type referenced by the specified constant pool entry is loaded and - * initialized. This can be used to compile time resolve a type. It works for field, method, - * or type constant pool entries. - * @param cpi the index of the constant pool entry that references the type - * @param opcode the opcode of the instruction that references the type - */ - void loadReferencedType(int cpi, int opcode); - - /** - * Looks up a reference to a field. If {@code opcode} is non-negative, then resolution checks - * specific to the JVM instruction it denotes are performed if the field is already resolved. - * Should any of these checks fail, an {@linkplain RiField#isResolved() unresolved} - * field reference is returned. - * - * @param cpi the constant pool index - * @param opcode the opcode of the instruction for which the lookup is being performed or {@code -1} - * @return a reference to the field at {@code cpi} in this pool - * @throws ClassFormatError if the entry at {@code cpi} is not a field - */ - RiField lookupField(int cpi, int opcode); - - /** - * Looks up a reference to a method. If {@code opcode} is non-negative, then resolution checks - * specific to the JVM instruction it denotes are performed if the method is already resolved. - * Should any of these checks fail, an {@linkplain RiMethod#isResolved() unresolved} - * method reference is returned. - * - * @param cpi the constant pool index - * @param opcode the opcode of the instruction for which the lookup is being performed or {@code -1} - * @return a reference to the method at {@code cpi} in this pool - * @throws ClassFormatError if the entry at {@code cpi} is not a method - */ - RiMethod lookupMethod(int cpi, int opcode); - - /** - * Looks up a reference to a type. If {@code opcode} is non-negative, then resolution checks - * specific to the JVM instruction it denotes are performed if the type is already resolved. - * Should any of these checks fail, an {@linkplain RiType#isResolved() unresolved} - * type reference is returned. - * - * @param cpi the constant pool index - * @param opcode the opcode of the instruction for which the lookup is being performed or {@code -1} - * @return a reference to the compiler interface type - */ - RiType lookupType(int cpi, int opcode); - - /** - * Looks up a method signature. - * - * @param cpi the constant pool index - * @return the method signature at index {@code cpi} in this constant pool - */ - RiSignature lookupSignature(int cpi); - - /** - * Looks up a constant at the specified index. - * @param cpi the constant pool index - * @return the {@code CiConstant} instance representing the constant - */ - Object lookupConstant(int cpi); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiExceptionHandler.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,67 +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. - * - * 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.cri.ri; - -/** - * Represents an exception handler within the bytecode. - */ -public interface RiExceptionHandler { - - /** - * Gets the start bytecode index of the protected range of this handler. - * @return the start bytecode index - */ - int startBCI(); - - /** - * Gets the end bytecode index of the protected range of this handler. - * @return the end bytecode index - */ - int endBCI(); - - /** - * Gets the bytecode index of the handler block of this handler. - * @return the handler block bytecode index - */ - int handlerBCI(); - - /** - * Gets the index into the constant pool representing the type of exception - * caught by this handler. - * @return the constant pool index of the catch type - */ - int catchTypeCPI(); - - /** - * Checks whether this handler catches all exceptions. - * @return {@code true} if this handler catches all exceptions - */ - boolean isCatchAll(); - - /** - * The type of exception caught by this exception handler. - * - * @return the exception type - */ - RiType catchType(); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiField.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,59 +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. - * - * 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.cri.ri; - - -import com.sun.cri.ci.*; - -/** - * Represents a reference to a field, including both resolved and unresolved fields. Fields, like methods and types, are - * resolved through {@link RiConstantPool constant pools}, and their actual implementation is provided by the - * {@link RiRuntime runtime} to the compiler. - */ -public interface RiField { - /** - * Gets the name of this field as a string. - * @return the name of this field - */ - String name(); - - /** - * Gets the type of this field as a compiler-runtime interface type. - * @return the type of this field - */ - RiType type(); - - /** - * Gets the kind of this field. - * @param architecture When true, the architecture-specific kind used for emitting machine code is returned. - * When false, the kind according to the Java specification is returned. - * @return the kind - */ - CiKind kind(boolean architecture); - - /** - * Gets the holder of this field as a compiler-runtime interface type. - * @return the holder of this field - */ - RiType holder(); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiMethod.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,61 +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. - * - * 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.cri.ri; - -/** - * Represents resolved and unresolved methods. Methods, like fields and types, are resolved through - * {@link RiConstantPool constant pools}, and their actual implementation is provided by the {@link RiRuntime runtime} - * to the compiler. - */ -public interface RiMethod { - - /** - * Gets the name of the method as a string. - * @return the name of the method - */ - String name(); - - /** - * Gets the type in which this method is declared. - * @return the type in which this method is declared - */ - RiType holder(); - - /** - * Gets the signature of the method. - * @return the signature of the method - */ - RiSignature signature(); - - /** - * Indicates whether a direct call to this method can be linked without - * any concerns of the call having to be relinked (e.g. when the - * compiled code for this method is relocated or invalidated). - * This determines whether a compiler can generate code for a direct call - * without having to worry about thread-safe code patching issues. - * <p> - * Note that the result will always be {@code false} for methods that don't yet - * have compiled code. - */ - boolean canBePermanentlyLinked(); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiRegisterAttributes.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,97 +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. - * - * 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.cri.ri; - -import java.util.*; - -import com.sun.cri.ci.*; - -/** - * A collection of register attributes. The specific attribute values for a register may be - * local to a compilation context. For example, a {@link RiRegisterConfig} in use during - * a compilation will determine which registers are callee saved. - */ -public class RiRegisterAttributes { - - /** - * Denotes a register whose value preservation (if required) across a call is the responsibility of the caller. - */ - public final boolean isCallerSave; - - /** - * Denotes a register whose value preservation (if required) across a call is the responsibility of the callee. - */ - public final boolean isCalleeSave; - - /** - * Denotes a register that is available for use by a register allocator. - */ - public final boolean isAllocatable; - - /** - * Denotes a register guaranteed to be non-zero if read in compiled Java code. - * For example, a register dedicated to holding the current thread. - */ - public boolean isNonZero; - - public RiRegisterAttributes(boolean isCallerSave, boolean isCalleeSave, boolean isAllocatable) { - this.isCallerSave = isCallerSave; - this.isCalleeSave = isCalleeSave; - this.isAllocatable = isAllocatable; - } - - public static final RiRegisterAttributes NONE = new RiRegisterAttributes(false, false, false); - - /** - * Creates a map from register {@linkplain CiRegister#number numbers} to register - * {@linkplain RiRegisterAttributes attributes} for a given register configuration and set of - * registers. - * - * @param registerConfig a register configuration - * @param registers a set of registers - * @return an array whose length is the max register number in {@code registers} plus 1. An element at index i holds - * the attributes of the register whose number is i. - */ - public static RiRegisterAttributes[] createMap(RiRegisterConfig registerConfig, CiRegister[] registers) { - RiRegisterAttributes[] map = new RiRegisterAttributes[registers.length]; - for (CiRegister reg : registers) { - if (reg != null) { - CiCalleeSaveLayout csl = registerConfig.getCalleeSaveLayout(); - RiRegisterAttributes attr = new RiRegisterAttributes( - Arrays.asList(registerConfig.getCallerSaveRegisters()).contains(reg), - csl == null ? false : Arrays.asList(csl.registers).contains(reg), - Arrays.asList(registerConfig.getAllocatableRegisters()).contains(reg)); - if (map.length <= reg.number) { - map = Arrays.copyOf(map, reg.number + 1); - } - map[reg.number] = attr; - } - } - for (int i = 0; i < map.length; i++) { - if (map[i] == null) { - map[i] = NONE; - } - } - return map; - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiRegisterConfig.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,113 +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. - * - * 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.cri.ri; - -import java.util.*; - -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiCallingConvention.Type; -import com.sun.cri.ci.CiRegister.RegisterFlag; - -/** - * A register configuration binds roles and {@linkplain RiRegisterAttributes attributes} - * to physical registers. - */ -public interface RiRegisterConfig { - - /** - * Gets the register to be used for returning a value of a given kind. - */ - CiRegister getReturnRegister(CiKind kind); - - /** - * Gets the register to which {@link CiRegister#Frame} and {@link CiRegister#CallerFrame} are bound. - */ - CiRegister getFrameRegister(); - - CiRegister getScratchRegister(); - - /** - * Gets the calling convention describing how arguments are passed. - * - * @param type the type of calling convention being requested - * @param parameters the types of the arguments of the call - * @param target the target platform - * @param stackOnly ignore registers - */ - CiCallingConvention getCallingConvention(Type type, CiKind[] parameters, CiTarget target, boolean stackOnly); - - /** - * Gets the ordered set of registers that are can be used to pass parameters - * according to a given calling convention. - * - * @param type the type of calling convention - * @param flag specifies whether registers for {@linkplain RegisterFlag#CPU integral} or - * {@linkplain} RegisterFlag#FPU floating point} parameters are being requested - * @return the ordered set of registers that may be used to pass parameters in a call conforming to {@code type} - */ - CiRegister[] getCallingConventionRegisters(Type type, RegisterFlag flag); - - /** - * Gets the set of registers that can be used by the register allocator. - */ - CiRegister[] getAllocatableRegisters(); - - /** - * Gets the set of registers that can be used by the register allocator, - * {@linkplain CiRegister#categorize(CiRegister[]) categorized} by register {@linkplain RegisterFlag flags}. - * - * @return a map from each {@link RegisterFlag} constant to the list of {@linkplain #getAllocatableRegisters() - * allocatable} registers for which the flag is {@linkplain #isSet(RegisterFlag) set} - * - */ - EnumMap<RegisterFlag, CiRegister[]> getCategorizedAllocatableRegisters(); - - /** - * Gets the registers whose values must be preserved by a method across any call it makes. - */ - CiRegister[] getCallerSaveRegisters(); - - /** - * Gets the layout of the callee save area of this register configuration. - * - * @return {@code null} if there is no callee save area - */ - CiCalleeSaveLayout getCalleeSaveLayout(); - - /** - * Gets a map from register {@linkplain CiRegister#number numbers} to register - * {@linkplain RiRegisterAttributes attributes} for this register configuration. - * - * @return an array where an element at index i holds the attributes of the register whose number is i - * @see CiRegister#categorize(CiRegister[]) - */ - RiRegisterAttributes[] getAttributesMap(); - - /** - * Gets the register corresponding to a runtime-defined role. - * - * @param id the identifier of a runtime-defined register role - * @return the register playing the role specified by {@code id} - */ - CiRegister getRegisterForRole(int id); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiResolvedField.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,65 +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. - * - * 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.cri.ri; - -import java.lang.annotation.*; -import java.lang.reflect.*; - -import com.sun.cri.ci.*; - -/** - * Represents a reference to a resolved field. Fields, like methods and types, are - * resolved through {@link RiConstantPool constant pools}, and their actual implementation is provided by the - * {@link RiRuntime runtime} to the compiler. - */ -public interface RiResolvedField extends RiField { - - /** - * Gets the access flags for this field. Only the flags specified in the JVM specification - * will be included in the returned mask. The utility methods in the {@link Modifier} class - * should be used to query the returned mask for the presence/absence of individual flags. - * @return the mask of JVM defined field access flags defined for this field - */ - int accessFlags(); - - /** - * Gets the constant value of this field if available. - * @param receiver object from which this field's value is to be read. This value is ignored if this field is static. - * @return the constant value of this field or {@code null} if the constant value is not available - */ - CiConstant constantValue(CiConstant receiver); - - /** - * Gets the holder of this field as a compiler-runtime interface type. - * @return the holder of this field - */ - RiResolvedType holder(); - - /** - * Returns this field's annotation of a specified type. - * - * @param annotationClass the Class object corresponding to the annotation type - * @return the annotation of type {@code annotationClass} for this field if present, else null - */ - <T extends Annotation> T getAnnotation(Class<T> annotationClass); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiResolvedMethod.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,228 +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. - * - * 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.cri.ri; - -import java.lang.annotation.*; -import java.lang.reflect.*; -import java.util.*; - -import com.sun.cri.ci.*; - - -/** - * Represents resolved methods. Methods, like fields and types, are resolved through - * {@link RiConstantPool constant pools}, and their actual implementation is provided by the {@link RiRuntime runtime} - * to the compiler. - */ -public interface RiResolvedMethod extends RiMethod { - - /** - * Gets the bytecode of the method, if the method {@linkplain #isResolved()} and has code. - * @return the bytecode of the method or {@code null} if none is available - */ - byte[] code(); - - /** - * Gets the size of the bytecode of the method, if the method {@linkplain #isResolved()} and has code. - * @return the size of the bytecode in bytes, or 0 if no bytecode is available - */ - int codeSize(); - - /** - * Gets the symbol used to link this method if it is native, otherwise {@code null}. - */ - String jniSymbol(); - - /** - * Gets the type in which this method is declared. - * @return the type in which this method is declared - */ - RiResolvedType holder(); - - /** - * Gets the maximum number of locals used in this method's bytecode. - * @return the maximum number of locals - */ - int maxLocals(); - - /** - * Gets the maximum number of stack slots used in this method's bytecode. - * @return the maximum number of stack slots - */ - int maxStackSize(); - - /** - * Checks whether this method has balanced monitor operations. - * @return {@code true} if the method has balanced monitor operations - */ - boolean hasBalancedMonitors(); - - /** - * Gets the access flags for this method. Only the flags specified in the JVM specification - * will be included in the returned mask. The utility methods in the {@link Modifier} class - * should be used to query the returned mask for the presence/absence of individual flags. - * @return the mask of JVM defined method access flags defined for this method - */ - int accessFlags(); - - /** - * Checks whether this method is a leaf method. - * @return {@code true} if the method is a leaf method (that is, is final or private) - */ - boolean isLeafMethod(); - - /** - * Checks whether this method is a class initializer. - * @return {@code true} if the method is a class initializer - */ - boolean isClassInitializer(); - - /** - * Checks whether this method is a constructor. - * @return {@code true} if the method is a constructor - */ - boolean isConstructor(); - - /** - * Checks whether this method has been overridden. Decisions made based - * on a method being overridden must be registered as dependencies. - * @return {@code true} if the method has been overridden - */ - boolean isOverridden(); - - /** - * Checks whether the compiler can insert safepoint polls in this method. - * @return {@code true} if the method cannot have safepoint polls inserted - */ - boolean noSafepointPolls(); - - /** - * Gets a map from bytecode indexes to bit maps denoting the live locals at that position. - * If a non-null array is return, its length is guaranteed to be equal to {@code code().length}. - * - * @return the liveness map if it is available; {@code null} otherwise - */ - CiBitMap[] livenessMap(); - - /** - * Checks whether this method can be statically bound (that is, it is final or private or static). - * @return {@code true} if this method can be statically bound - */ - boolean canBeStaticallyBound(); - - /** - * Gets the list of exception handlers for this method. - * @return the list of exception handlers - */ - RiExceptionHandler[] exceptionHandlers(); - - /** - * Gets a stack trace element for this method and a given bytecode index. - */ - StackTraceElement toStackTraceElement(int bci); - - /** - * Temporary work-around to support the @ACCESSOR Maxine annotation. - * Non-Maxine VMs should just return {@code null}. - */ - RiResolvedType accessor(); - - /** - * Gets the intrinsic id of this method. - */ - String intrinsic(); - - /** - * Provides an estimate of how often this method has been executed. - * @return The number of invocations, or -1 if this information isn't available. - */ - int invocationCount(); - - /** - * Returns an estimate of hot often an exception was seen at the given bytecode. - * @return The estimate in percent (0-100), with 0 meaning never and 100 meaning always, or -1 if this information isn't available. - */ - int exceptionProbability(int bci); - - /** - * Returns the type profile of the instruction at the given byte code index. - * @return The RiTypeProfile information, or null if it isn't available. - */ - RiTypeProfile typeProfile(int bci); - - /** - * Returns an estimate of how often the branch at the given byte code was taken. - * @return The estimated probability, with 0.0 meaning never and 1.0 meaning always, or -1 if this information isn't available. - */ - double branchProbability(int bci); - - /** - * Returns an estimate of how often the branches of the switch at the given byte code were taken. - * @return The estimated probability, with 0.0 meaning never and 1.0 meaning always, or NULL if this information isn't available. - * The default case is specified at the last index. - */ - double[] switchProbability(int bci); - - /** - * Returns a map that the compiler can use to store objects that should survive the current compilation. - */ - Map<Object, Object> compilerStorage(); - - /** - * Returns a pointer to the method's constant pool. - * @return the constant pool - */ - RiConstantPool getConstantPool(); - - /** - * Returns this method's annotation of a specified type. - * - * @param annotationClass the Class object corresponding to the annotation type - * @return the annotation of type {@code annotationClass} for this method if present, else null - */ - <T extends Annotation> T getAnnotation(Class<T> annotationClass); - - /** - * Returns an array of arrays that represent the annotations on the formal - * parameters, in declaration order, of this method. - * - * @see Method#getParameterAnnotations() - * @see CiUtil#getParameterAnnotation(int, RiResolvedMethod) - */ - Annotation[][] getParameterAnnotations(); - - /** - * Returns an array of {@link Type} objects that represent the formal - * parameter types, in declaration order, of this method. - * - * @see Method#getGenericParameterTypes() - */ - Type[] getGenericParameterTypes(); - - /** - * Returns a {@link Type} object that represents the formal return type of this method. - * - * @see Method#getGenericReturnType() - */ - Type getGenericReturnType(); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiResolvedType.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,183 +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. - * - * 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.cri.ri; - -import java.lang.annotation.*; -import java.lang.reflect.*; - -import com.sun.cri.ci.*; - -/** - * Represents a resolved in the compiler-runtime interface. Types include primitives, objects, {@code void}, - * and arrays thereof. Types, like fields and methods, are resolved through {@link RiConstantPool constant pools}, and - * their actual implementation is provided by the {@link RiRuntime runtime} to the compiler. - */ -public interface RiResolvedType extends RiType { - - /** - * Gets the encoding of (that is, a constant representing the value of) the specified part of this type. - * @param r the part of the this type - * @return a constant representing a reference to the specified part of this type - */ - CiConstant getEncoding(Representation r); - - /** - * Checks whether this type has any subclasses so far. Any decisions - * based on this information require the registration of a dependency, since - * this information may change. - * @return {@code true} if this class has subclasses - */ - boolean hasSubclass(); - - /** - * Checks whether this type has a finalizer method. - * @return {@code true} if this class has a finalizer - */ - boolean hasFinalizer(); - - /** - * Checks whether this type has any finalizable subclasses so far. Any decisions - * based on this information require the registration of a dependency, since - * this information may change. - * @return {@code true} if this class has any subclasses with finalizers - */ - boolean hasFinalizableSubclass(); - - /** - * Checks whether this type is an interface. - * @return {@code true} if this type is an interface - */ - boolean isInterface(); - - /** - * Checks whether this type is an instance class. - * @return {@code true} if this type is an instance class - */ - boolean isInstanceClass(); - - /** - * Checks whether this type is an array class. - * @return {@code true} if this type is an array class - */ - boolean isArrayClass(); - - /** - * Gets the access flags for this type. Only the flags specified in the JVM specification - * will be included in the returned mask. The utility methods in the {@link Modifier} class - * should be used to query the returned mask for the presence/absence of individual flags. - * @return the mask of JVM defined class access flags defined for this type - */ - int accessFlags(); - - /** - * Checks whether this type is initialized. - * @return {@code true} if this type is initialized - */ - boolean isInitialized(); - - /** - * Checks whether this type is a subtype of another type. - * @param other the type to test - * @return {@code true} if this type a subtype of the specified type - */ - boolean isSubtypeOf(RiResolvedType other); - - /** - * Checks whether the specified object is an instance of this type. - * @param obj the object to test - * @return {@code true} if the object is an instance of this type - */ - boolean isInstance(CiConstant obj); - - /** - * Attempts to get an exact type for this type. Final classes, - * arrays of final classes, and primitive types all have exact types. - * @return the exact type of this type, if it exists; {@code null} otherwise - */ - RiResolvedType exactType(); - - /** - * Gets the super type of this type or {@code null} if no such type exists. - */ - RiResolvedType superType(); - - /** - * Attempts to get the unique concrete subtype of this type. - * @return the exact type of this type, if it exists; {@code null} otherwise - */ - RiResolvedType uniqueConcreteSubtype(); - - /** - * For array types, gets the type of the components. - * @return the component type of this array type - */ - RiResolvedType componentType(); - - /** - * Gets the type representing an array with elements of this type. - * @return a new compiler interface type representing an array of this type - */ - RiResolvedType arrayOf(); - - /** - * Resolves the method implementation for virtual dispatches on objects - * of this dynamic type. - * @param method the method to select the implementation of - * @return the method implementation that would be selected at runtime - */ - RiResolvedMethod resolveMethodImpl(RiResolvedMethod method); - - /** - * Given an RiMethod a, returns a concrete RiMethod b that is the only possible - * unique target for a virtual call on a(). Returns {@code null} if either no - * such concrete method or more than one such method exists. Returns the method a - * if a is a concrete method that is not overridden. If the compiler uses the - * result of this method for its compilation, it must register an assumption - * (see {@link CiAssumptions}), because dynamic class loading can invalidate - * the result of this method. - * @param method the method a for which a unique concrete target is searched - * @return the unique concrete target or {@code null} if no such target exists - * or assumptions are not supported by this runtime - */ - RiResolvedMethod uniqueConcreteMethod(RiResolvedMethod method); - - /** - * Returns the instance fields declared in this class sorted by field offset. - * @return an array of instance fields - */ - RiResolvedField[] declaredFields(); - - /** - * Returns this type's annotation of a specified type. - * - * @param annotationClass the Class object corresponding to the annotation type - * @return the annotation of type {@code annotationClass} for this type if present, else null - */ - <T extends Annotation> T getAnnotation(Class<T> annotationClass); - - /** - * Returns the java.lang.Class object representing this RiType instance or {@code null} if none exists. - * @return the java.lang.Class object - */ - Class<?> toJava(); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiRuntime.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,242 +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. - * - * 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.cri.ri; - -import java.lang.reflect.*; - -import com.sun.cri.ci.*; - -/** - * Encapsulates the main functionality of the runtime for the compiler, including access - * to constant pools, OSR frames, inlining requirements, and runtime calls such as checkcast. -s */ -public interface RiRuntime { - - /** - * Checks whether the specified method is required to be inlined (for semantic reasons). - * If this method returns true, then the null-check of the receiver emitted during - * inlining is omitted. - * - * @param method the method being called - * @return {@code true} if the method must be inlined; {@code false} to let the compiler - * use its own heuristics - */ - boolean mustInline(RiResolvedMethod method); - - /** - * Checks whether the specified method must not be inlined (for semantic reasons). - * @param method the method being called - * @return {@code true} if the method must not be inlined; {@code false} to let the compiler - * use its own heuristics - */ - boolean mustNotInline(RiResolvedMethod method); - - /** - * Checks whether the specified method cannot be compiled. - * @param method the method being called - * @return {@code true} if the method cannot be compiled - */ - boolean mustNotCompile(RiResolvedMethod method); - - /** - * Offset of the lock within the lock object on the stack. - - * Note: superseded by sizeOfLockData() in Graal. - * - * @return the offset in bytes - */ - int basicObjectLockOffsetInBytes(); - - /** - * Get the size in bytes of a lock object on the stack. - * - * Note: superseded by sizeOfLockData() in Graal. - */ - int sizeOfBasicObjectLock(); - - /** - * Get the size in bytes for locking information on the stack. - */ - int sizeOfLockData(); - - /** - * The offset of the normal entry to the code. The compiler inserts NOP instructions to satisfy this constraint. - * - * @return the code offset in bytes - */ - int codeOffset(); - - /** - * Returns the disassembly of the given code bytes. Used for debugging purposes only. - * - * @param code the code bytes that should be disassembled - * @param address an address at which the bytes are located. This can be used for an address prefix per line of disassembly. - * @return the disassembly. This will be of length 0 if the runtime does not support disassembling. - */ - String disassemble(byte[] code, long address); - - /** - * Returns the disassembly of the given code bytes. Used for debugging purposes only. - * - * @param targetMethod the {@link CiTargetMethod} containing the code bytes that should be disassembled - * @return the disassembly. This will be of length 0 if the runtime does not support disassembling. - */ - String disassemble(CiTargetMethod targetMethod); - - /** - * Returns the disassembly of the given method in a {@code javap}-like format. - * Used for debugging purposes only. - * - * @param method the method that should be disassembled - * @return the disassembly. This will be of length 0 if the runtime does not support disassembling. - */ - String disassemble(RiResolvedMethod method); - - /** - * Registers the given compiler stub and returns an object that can be used to identify it in the relocation - * information. - * - * @param targetMethod the target method representing the code of the compiler stub - * @param name the name of the stub, used for debugging purposes only - * @return the identification object - */ - Object registerCompilerStub(CiTargetMethod targetMethod, String name); - - /** - * Returns the RiType object representing the base type for the given kind. - */ - RiResolvedType asRiType(CiKind kind); - - /** - * Returns the type of the given constant object. - * - * @return {@code null} if {@code constant.isNull() || !constant.kind.isObject()} - */ - RiResolvedType getTypeOf(CiConstant constant); - - - RiResolvedType getType(Class<?> clazz); - - /** - * Returns true if the given type is a subtype of java/lang/Throwable. - */ - boolean isExceptionType(RiResolvedType type); - - /** - * Checks whether this method is foldable (i.e. if it is a pure function without side effects). - * @param method the method that is checked - * @return whether the method is foldable - */ - boolean isFoldable(RiResolvedMethod method); - - /** - * Attempts to compile-time evaluate or "fold" a call to a given method. A foldable method is a pure function - * that has no side effects. Such methods can be executed via reflection when all their inputs are constants, - * and the resulting value is substituted for the method call. May only be called on methods for which - * isFoldable(method) returns {@code true}. The array of constant for arguments may contain {@code null} values, which - * means that this particular argument does not evaluate to a compile time constant. - * - * @param method the compiler interface method for which folding is being requested - * @param args the arguments to the call as an array of CiConstant objects - * @return the result of the folding or {@code null} if no folding occurred - */ - CiConstant fold(RiResolvedMethod method, CiConstant[] args); - - /** - * Used by the canonicalizer to compare objects, since a given runtime might not want to expose the real objects to the compiler. - * - * @return true if the two parameters represent the same runtime object, false otherwise - */ - boolean areConstantObjectsEqual(CiConstant x, CiConstant y); - - /** - * Gets the register configuration to use when compiling a given method. - * - * @param method the top level method of a compilation - */ - RiRegisterConfig getRegisterConfig(RiMethod method); - - /** - * Custom area on the stack of each compiled method that the VM can use for its own purposes. - * @return the size of the custom area in bytes - */ - int getCustomStackAreaSize(); - - /** - * Minimum size of the stack area reserved for outgoing parameters. This area is reserved in all cases, even when - * the compiled method has no regular call instructions. - * @return the minimum size of the outgoing parameter area in bytes - */ - int getMinimumOutgoingSize(); - - /** - * Gets the length of the array that is wrapped in a CiConstant object. - */ - int getArrayLength(CiConstant array); - - /** - * Converts the given CiConstant object to a object. - * - * @return {@code null} if the conversion is not possible <b>OR</b> {@code c.isNull() == true} - */ - Object asJavaObject(CiConstant c); - - /** - * Converts the given CiConstant object to a {@link Class} object. - * - * @return {@code null} if the conversion is not possible. - */ - Class<?> asJavaClass(CiConstant c); - - /** - * Performs any runtime-specific conversion on the object used to describe the target of a call. - */ - Object asCallTarget(Object target); - - /** - * Returns the maximum absolute offset of a runtime call target from any position in the code cache or -1 - * when not known or not applicable. Intended for determining the required size of address/offset fields. - */ - long getMaxCallTargetOffset(CiRuntimeCall rtcall); - - /** - * Provides the {@link RiMethod} for a {@link Method} obtained via reflection. - */ - RiResolvedMethod getRiMethod(Method reflectionMethod); - - /** - * Installs some given machine code as the implementation of a given method. - * - * @param method a method whose executable code is being modified - * @param code the code to be executed when {@code method} is called - */ - void installMethod(RiMethod method, CiTargetMethod code); - - /** - * Adds the given machine code as an implementation of the given method without making it the default implementation. - * @param method a method to which the executable code is begin added - * @param code the code to be added - * @return a reference to the compiled and ready-to-run code - */ - RiCompiledMethod addMethod(RiResolvedMethod method, CiTargetMethod code); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiSignature.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,95 +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. - * - * 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.cri.ri; - -import com.sun.cri.ci.*; - -/** - * Represents a method signature provided by the runtime. - * - * @see <a href="http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html#7035">Method Descriptors</a> - */ -public interface RiSignature { - /** - * Gets the number of arguments in this signature, adding 1 for a receiver if requested. - * - * @param receiver true if 1 is to be added to the result for a receiver - * @return the number of arguments + 1 iff {@code receiver == true} - */ - int argumentCount(boolean receiver); - - /** - * Gets the argument type at the specified position. This method will return a - * {@linkplain RiType#isResolved() resolved} type if possible but without - * triggering any class loading or resolution. - * - * @param index the index into the parameters, with {@code 0} indicating the first parameter - * @param accessingClass the context of the type lookup. If accessing class is resolved, its class loader - * is used to retrieve an existing resolved type. This value can be {@code null} if the caller does - * not care for a resolved type. - * @return the {@code index}'th argument type - */ - RiType argumentTypeAt(int index, RiType accessingClass); - - /** - * Gets the argument kind at the specified position. - * @param index the index into the parameters, with {@code 0} indicating the first parameter - * @param architecture When true, the architecture-specific kind used for emitting machine code is returned. - * When false, the kind according to the Java specification is returned. - * @return the kind of the argument at the specified position - */ - CiKind argumentKindAt(int index, boolean architecture); - - /** - * Gets the return type of this signature. This method will return a - * {@linkplain RiResolvedType resolved} type if possible but without - * triggering any class loading or resolution. - * - * @param accessingClass the context of the type lookup. If accessing class is resolved, its class loader - * is used to retrieve an existing resolved type. This value can be {@code null} if the caller does - * not care for a resolved type. - * @return the compiler interface type representing the return type - */ - RiType returnType(RiType accessingClass); - - /** - * Gets the return kind of this signature. - * @param architectureSpecific When true, the architecture-specific kind used for emitting machine code is returned. - * When false, the kind according to the Java specification is returned. - * @return the return kind - */ - CiKind returnKind(boolean architectureSpecific); - - /** - * Converts this signature to a string. - * @return the signature as a string - */ - String asString(); - - /** - * Gets the size, in Java slots, of the arguments to this signature. - * @param withReceiver {@code true} if to add a slot for a receiver object; {@code false} not to include the receiver - * @return the size of the arguments in slots - */ - int argumentSlots(boolean withReceiver); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiType.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,100 +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. - * - * 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.cri.ri; - -import com.sun.cri.ci.*; - -/** - * Represents a resolved or unresolved type in the compiler-runtime interface. Types include primitives, objects, {@code void}, - * and arrays thereof. - */ -public interface RiType { - - /** - * Represents each of the several different parts of the runtime representation of - * a type which compiled code may need to reference individually. These may or may not be - * different objects or data structures, depending on the runtime system. - */ - public enum Representation { - /** - * The runtime representation of the data structure containing the static fields of this type. - */ - StaticFields, - - /** - * The runtime representation of the Java class object of this type. - */ - JavaClass, - - /** - * The runtime representation of the "hub" of this type--that is, the closest part of the type - * representation which is typically stored in the object header. - */ - ObjectHub, - - /** - * The runtime representation of the type information for an object, which is typically used - * for subtype tests. - */ - TypeInfo - } - - /** - * Gets the name of this type in internal form. The following are examples of strings returned by this method: - * <pre> - * "Ljava/lang/Object;" - * "I" - * "[[B" - * </pre> - * - * @return the name of this type in internal form - */ - String name(); - - /** - * For array types, gets the type of the components. - * @return the component type of this array type - */ - RiType componentType(); - - /** - * Gets the type representing an array with elements of this type. - * @return a new compiler interface type representing an array of this type - */ - RiType arrayOf(); - - /** - * Gets the kind of this compiler interface type. - * @param architecture When true, the architecture-specific kind used for emitting machine code is returned. - * When false, the kind according to the Java specification is returned. - * @return the kind - */ - CiKind kind(boolean architecture); - - /** - * Gets the kind used to represent the specified part of this type. - * @param r the part of the this type - * @return the kind of constants for the specified part of the type - */ - CiKind getRepresentationKind(Representation r); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/RiTypeProfile.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,61 +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. - * - * 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.cri.ri; - -import java.io.*; - -/** - * This profile object represents the type profile of one call site, cast or instanceof instruction. The precision of - * the supplied values may vary, but a runtime that provides this information should be aware that it will be used to - * guide performance-critical decisions like speculative inlining, etc. - */ -public class RiTypeProfile implements Serializable { - - /** - * - */ - private static final long serialVersionUID = -6877016333706838441L; - - /** - * How often the instruction was executed, which may be used to judge the maturity of this profile. - */ - public int count; - - /** - * An estimation of how many different receiver types were encountered. This may or may not be the same as - * probabilities.length/types.length, as the runtime may store probabilities for a limited number of receivers. - */ - public int morphism; - - /** - * A list of receivers for which the runtime has recorded probability information. This array needs to have the same - * length as {@link RiTypeProfile#probabilities}. - */ - public RiResolvedType[] types; - - /** - * The estimated probabilities of the different receivers. This array needs to have the same length as - * {@link RiTypeProfile#types}. - */ - public float[] probabilities; -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/ri/package-info.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,36 +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. - * - * 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 runtime-provided part of the bi-directional interface between the compiler and the runtime system of a virtual machine for the - * instruction set defined in {@link com.sun.cri.bytecode.Bytecodes}. - * <p> - * Unlike the {@link com.sun.cri.ci compiler-provided interface}, the runtime-provided interface is specified largely - * using interfaces, that must be implemented by classes provided by a specific runtime implementation. - * <p> - * {@link com.sun.cri.ri.RiRuntime} encapsulates the main functionality of the runtime for the compiler. - * <p> - * Types (i.e., primitives, classes and interfaces}, fields and methods are represented by {@link com.sun.cri.ri.RiType}, {@link com.sun.cri.ri.RiField} and {@link com.sun.cri.ri.RiMethod}, respectively, with additional support from - * {@link com.sun.cri.ri.RiSignature} and {@link com.sun.cri.ri.RiExceptionHandler}. Access to the runtime constant pool - * is through {@link com.sun.cri.ri.RiConstantPool}. - */ -package com.sun.cri.ri;
--- a/graal/com.oracle.max.cri/src/com/sun/cri/xir/CiXirAssembler.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,989 +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. - * - * 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.cri.xir; - -import static com.sun.cri.xir.CiXirAssembler.XirOp.*; - -import java.util.*; - -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiAddress.*; -import com.sun.cri.ri.*; - -/** - * Represents an assembler that allows a client such as the runtime system to - * create {@link XirTemplate XIR templates}. - */ -public abstract class CiXirAssembler { - - protected XirOperand resultOperand; - protected boolean allocateResultOperand; - - protected final List<XirInstruction> instructions = new ArrayList<>(); - protected final List<XirLabel> labels = new ArrayList<>(5); - protected final List<XirParameter> parameters = new ArrayList<>(5); - protected final List<XirTemp> temps = new ArrayList<>(5); - protected final List<XirConstant> constants = new ArrayList<>(5); - protected final List<XirMark> marks = new ArrayList<>(5); - - protected int outgoingStackSize = 0; - - /** - * Increases by one for every {@link XirOperand operand} created. - */ - protected int variableCount; - - /** - * Marks the assembly complete. - */ - protected boolean finished = true; - - protected final CiTarget target; - - public CiXirAssembler(CiTarget target) { - this.target = target; - } - - public static class RuntimeCallInformation { - public final Object target; - public final boolean useInfoAfter; - - public RuntimeCallInformation(Object target, boolean useInfoAfter) { - this.target = target; - this.useInfoAfter = useInfoAfter; - } - } - - /** - * Represents additional address calculation information. - */ - public static final class AddressAccessInformation { - - /** - * The scaling factor for the scaled-index part of an address computation. - */ - public final Scale scale; - - /** - * The constant byte-sized displacement part of an address computation. - */ - public final int disp; - - /** - * Determines if the memory access through the address can trap. - */ - public final boolean canTrap; - - private AddressAccessInformation(boolean canTrap) { - this.canTrap = canTrap; - this.scale = Scale.Times1; - this.disp = 0; - } - - private AddressAccessInformation(boolean canTrap, int disp) { - this.canTrap = canTrap; - this.scale = Scale.Times1; - this.disp = disp; - } - - private AddressAccessInformation(boolean canTrap, int disp, Scale scale) { - this.canTrap = canTrap; - this.scale = scale; - this.disp = disp; - } - } - - /** - * A label that is the target of a control flow instruction. - */ - public static final class XirLabel { - public static final String TrueSuccessor = "TrueSuccessor"; - public static final String FalseSuccessor = "FalseSuccessor"; - public final String name; - public final int index; - /** - * If {@code true} the label is to an instruction in the fast path sequence, otherwise to the slow path. - */ - public final boolean inline; - - private XirLabel(String name, int index, boolean inline) { - this.name = name; - this.index = index; - this.inline = inline; - } - - @Override - public String toString() { - return name; - } - } - - /** - * Tagging interface that indicates that an {@link XirOperand} is a constant. - */ - public interface XirConstantOperand { - int getIndex(); - } - - public static final XirOperand VOID = null; - - /** - * Operands for {@link XirInstruction instructions}. - * There are three basic variants, {@link XirConstant constant}, {@link XirParameter parameter} and {@link XirTemp}. - */ - public abstract static class XirOperand { - - public final CiKind kind; - - /** - * Unique id in range {@code 0} to {@link #variableCount variableCount - 1}. - */ - public final int index; - - /** - * Value whose {@link #toString()} method provides a name for this operand. - */ - public final Object name; - - public XirOperand(CiXirAssembler asm, Object name, CiKind kind) { - this.kind = kind; - this.name = name; - this.index = asm.variableCount++; - } - - @Override - public String toString() { - return String.valueOf(name); - } - - public String detailedToString() { - - StringBuffer sb = new StringBuffer(); - - sb.append(name); - sb.append('$'); - sb.append(kind.typeChar); - return sb.toString(); - } - } - - /** - * Parameters to {@link XirTemplate templates}. - */ - public static class XirParameter extends XirOperand { - /** - * Unique id in range {@code 0} to {@code parameters.Size() - 1}. - */ - public final int parameterIndex; - - public final boolean canBeConstant; - - XirParameter(CiXirAssembler asm, String name, CiKind kind, boolean canBeConstant) { - super(asm, name, kind); - this.parameterIndex = asm.parameters.size(); - this.canBeConstant = canBeConstant; - asm.parameters.add(this); - } - - } - - public static class XirConstantParameter extends XirParameter implements XirConstantOperand { - XirConstantParameter(CiXirAssembler asm, String name, CiKind kind) { - super(asm, name, kind, true); - } - - public int getIndex() { - return index; - } - } - - public static class XirVariableParameter extends XirParameter { - XirVariableParameter(CiXirAssembler asm, String name, CiKind kind, boolean canBeConstant) { - super(asm, name, kind, canBeConstant); - } - } - - public static class XirConstant extends XirOperand implements XirConstantOperand { - public final CiConstant value; - - XirConstant(CiXirAssembler asm, CiConstant value) { - super(asm, value, value.kind); - this.value = value; - } - - public int getIndex() { - return index; - } - } - - public static class XirTemp extends XirOperand { - public final boolean reserve; - - XirTemp(CiXirAssembler asm, String name, CiKind kind, boolean reserve) { - super(asm, name, kind); - this.reserve = reserve; - } - } - - public static class XirRegister extends XirTemp { - public final CiValue register; - - XirRegister(CiXirAssembler asm, String name, CiRegisterValue register, boolean reserve) { - super(asm, name, register.kind, reserve); - this.register = register; - } - } - - /** - * Start a new assembly with no initial {@link #resultOperand result operand}. - */ - public void restart() { - reset(); - resultOperand = null; - } - - /** - * Start a new assembly with a {@link #resultOperand result operand} of type {@code kind}. - * @param kind the result kind - * @return an {@code XirOperand} for the result operand - */ - public XirOperand restart(CiKind kind) { - reset(); - resultOperand = new XirTemp(this, "result", kind, true); - allocateResultOperand = true; - return resultOperand; - } - - /** - * Reset the state of the class to the initial conditions to facilitate a new assembly. - */ - private void reset() { - assert finished : "must be finished before!"; - variableCount = 0; - allocateResultOperand = false; - finished = false; - instructions.clear(); - labels.clear(); - parameters.clear(); - temps.clear(); - constants.clear(); - marks.clear(); - outgoingStackSize = 0; - } - - /** - * Represents an XIR instruction, characterized by an {@link XirOp operation}, a {@link CiKind kind}, an optional {@link XirOperand result}, a variable number of {@link XirOperand arguments}, - * and some optional instruction-specific state. The {@link #x}, {@link #y} and {@link #z} methods are convenient ways to access the first, second and third - * arguments, respectively. Only the {@link XirOp#CallStub} and {@link XirOp#CallRuntime} instructions can have more than three arguments. - * - */ - public static final class XirInstruction { - /** - * The {@link CiKind kind} of values the instruction operates on. - */ - public final CiKind kind; - /** - * The {@link XirOp operation}. - */ - public final XirOp op; - /** - * The result, if any. - */ - public final XirOperand result; - /** - * The arguments. - */ - public final XirOperand[] arguments; - /** - * Arbitrary additional data associated with the instruction. - */ - public final Object extra; - - public XirInstruction(CiKind kind, XirOp op, XirOperand result, XirOperand... arguments) { - this(kind, null, op, result, arguments); - } - - public XirInstruction(CiKind kind, Object extra, XirOp op, XirOperand result, XirOperand... arguments) { - this.extra = extra; - this.kind = kind; - this.op = op; - this.result = result; - this.arguments = arguments; - } - - public XirOperand x() { - assert arguments.length > 0 : "no x operand for this instruction"; - return arguments[0]; - } - - public XirOperand y() { - assert arguments.length > 1 : "no y operand for this instruction"; - return arguments[1]; - } - - public XirOperand z() { - assert arguments.length > 2 : "no z operand for this instruction"; - return arguments[2]; - } - - @Override - public String toString() { - StringBuffer sb = new StringBuffer(); - - if (result != null) { - sb.append(result.toString()); - sb.append(" = "); - } - - sb.append(op.name()); - - if (kind != CiKind.Void) { - sb.append('$'); - sb.append(kind.typeChar); - } - - if (arguments != null && arguments.length > 0) { - sb.append("("); - - for (int i = 0; i < arguments.length; i++) { - if (i != 0) { - sb.append(", "); - } - sb.append(arguments[i]); - } - - sb.append(")"); - } - - if (extra != null) { - sb.append(" "); - sb.append(extra); - } - - return sb.toString(); - } - } - - /** - * These marks let the RiXirGenerator mark positions in the generated native code and bring them in relationship with on another. - * This is necessary for code patching, etc. - */ - public static class XirMark { - public final XirMark[] references; - public final Object id; - - // special mark used to refer to the actual call site of an invoke - public static final XirMark CALLSITE = new XirMark(null); - - public XirMark(Object id, XirMark... references) { - this.id = id; - this.references = references; - } - } - - /** - * The set of opcodes for XIR instructions. - * {@link XirInstruction} defines {@code x}, {@code y} and {@code z} as the first, second and third arguments, respectively. - * We use these mnemonics, plus {@code args} for the complete set of arguments, {@code r} for the result, and {@code extra} - * for the instruction-specific extra data, in the opcode specifications. Note that the opcodes that operate on values do not directly - * specify the size (kind) of the data operated on; this is is encoded in {@link XirInstruction#kind}. - * Note: If the instruction kind differs from the argument/result kinds, the behavior is undefined. - * - */ - public enum XirOp { - /** - * Move {@code x} to {@code r}. - */ - Mov, - /** - * Add {@code y} to {@code x} and put the result in {@code r}. - */ - Add, - /** - * Subtract {@code y} from {@code x} and put the result in {@code r}. - */ - Sub, - /** - * Divide {@code y} by {@code x} and put the result in {@code r}. - */ - Div, - /** - * Multiply {@code y} by {@code x} and put the result in {@code r}. - */ - Mul, - /** - * {@code y} modulus {@code x} and put the result in {@code r}. - */ - Mod, - /** - * Shift {@code y} left by {@code x} and put the result in {@code r}. - */ - Shl, - /** - * Arithmetic shift {@code y} right by {@code x} and put the result in {@code r}. - */ - Sar, - /** - * Shift {@code y} right by {@code x} and put the result in {@code r}. - */ - Shr, - /** - * And {@code y} by {@code x} and put the result in {@code r}. - */ - And, - /** - * Or {@code y} by {@code x} and put the result in {@code r}. - */ - Or, - /** - * Exclusive Or {@code y} by {@code x} and put the result in {@code r}. - */ - Xor, - /** - * Null check on {@code x}. - */ - NullCheck, - /** - * Load value at address {@code x} and put the result in {@code r}. - */ - PointerLoad, - /** - * Store {@code y} at address {@code x}. - */ - PointerStore, - /** - * Load value at an effective address defined by base {@code x} and either a scaled index {@code y} plus displacement - * or an offset {@code y} and put the result in {@code r}. - */ - PointerLoadDisp, - /** - * Load an effective address defined by base {@code x} and either a scaled index {@code y} plus displacement - * or an offset {@code y} and put the result in {@code r}. - */ - LoadEffectiveAddress, - /** - * Store {@code z} at address defined by base {@code x} and index {@code y}. - */ - PointerStoreDisp, - /** - * Repeat move from {@code x} to {@code y} using {@code z} words. - */ - RepeatMoveWords, - /** - * Repeat move from {@code x} to {@code y} using {@code z} words. - */ - RepeatMoveBytes, - /** - * Compare value at at address {@code x} with value in {@code y} and store value {@code z} at address {@code x} - * if it was equal to {@code y}. - */ - PointerCAS, - /** - * Call the {@link XirTemplate.GlobalFlags#GLOBAL_STUB shared stub} defined by {@code extra} with {@code args} and put the result in {@code r}. - */ - CallStub, - /** - * Call the {@link RiMethod} defined by {@code extra} with {@code args} and put the result in {@code r}. - */ - CallRuntime, - /** - * Transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. - */ - Jmp, - /** - * If {@code x == y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. - */ - Jeq, - /** - * If {@code x != y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. - */ - Jneq, - /** - * If {@code x > y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. - */ - Jgt, - /** - * If {@code x >= y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. - */ - Jgteq, - /** - * If {@code x unsigned >= y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. - */ - Jugteq, - /** - * If {@code x < y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. - */ - Jlt, - /** - * If {@code x <= y}, transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. - */ - Jlteq, - /** - * Decreases the input by one and jumps to the target if the input is not 0. - */ - DecAndJumpNotZero, - /** - * If bit designated by {@code z} at effective address defined by base {@code x} and offset {@code y} - * is set transfer control to the instruction at the {@link XirLabel label} identified by {@code extra}. - */ - Jbset, - /** - * Bind the {@link XirLabel label} identified by {@code extra} to the current instruction and update any references to it. - * A label may be bound more than once to the same location. - */ - Bind, - /** - * Record a safepoint. - */ - Safepoint, - /** - * Align the code following this instruction to a multiple of (int)extra. - */ - Align, - /** - * Creates the stack banging overflow check. - */ - StackOverflowCheck, - /** - * Creates the stack frame for the method and spills callee-save registers (if any) to the {@linkplain CiRegisterSaveArea register save area}. - */ - PushFrame, - /** - * Restores all callee-save registers (if any) and removes the stack frame of the method. - */ - PopFrame, - /** - * Inserts an array of bytes directly into the code output. - */ - RawBytes, - /** - * Pushes a value onto the stack. - */ - Push, - /** - * Pops a value from the stack. - */ - Pop, - /** - * Marks a position in the generated native code. - */ - Mark, - /** - * Load instruction pointer of the next instruction in a destination register. - */ - Here, - /** - * Inserts nop instructions, with the given size in bytes. - */ - Nop, - /** - * This instruction should never be reached, this is useful for debugging purposes. - */ - ShouldNotReachHere - } - - public/*private*/ void append(XirInstruction xirInstruction) { - assert !finished : "no instructions can be added to finished template"; - instructions.add(xirInstruction); - } - - public XirLabel createInlineLabel(String name) { - final XirLabel result = new XirLabel(name, this.labels.size(), true); - labels.add(result); - return result; - } - - public XirLabel createOutOfLineLabel(String name) { - final XirLabel result = new XirLabel(name, this.labels.size(), false); - labels.add(result); - return result; - } - - public void mov(XirOperand result, XirOperand a) { - append(new XirInstruction(result.kind, Mov, result, a)); - } - - public void add(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, Add, result, a, b)); - } - - public void sub(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, Sub, result, a, b)); - } - - public void div(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, Div, result, a, b)); - } - - public void mul(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, Mul, result, a, b)); - } - - public void mod(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, Mod, result, a, b)); - } - - public void shl(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, Shl, result, a, b)); - } - - public void shr(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, Shr, result, a, b)); - } - - public void and(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, And, result, a, b)); - } - - public void or(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, Or, result, a, b)); - } - - public void xor(XirOperand result, XirOperand a, XirOperand b) { - append(new XirInstruction(result.kind, Xor, result, a, b)); - } - - public void nullCheck(XirOperand pointer) { - append(new XirInstruction(CiKind.Object, NullCheck, VOID, pointer)); - } - - public void pload(CiKind kind, XirOperand result, XirOperand pointer, boolean canTrap) { - append(new XirInstruction(kind, canTrap, PointerLoad, result, pointer)); - } - - public void pstore(CiKind kind, XirOperand pointer, XirOperand value, boolean canTrap) { - append(new XirInstruction(kind, canTrap, PointerStore, null, pointer, value)); - } - - public void pload(CiKind kind, XirOperand result, XirOperand pointer, XirOperand offset, boolean canTrap) { - append(new XirInstruction(kind, new AddressAccessInformation(canTrap), PointerLoadDisp, result, pointer, offset)); - } - - public void pstore(CiKind kind, XirOperand pointer, XirOperand offset, XirOperand value, boolean canTrap) { - append(new XirInstruction(kind, new AddressAccessInformation(canTrap), PointerStoreDisp, VOID, pointer, offset, value)); - } - - public void pload(CiKind kind, XirOperand result, XirOperand pointer, XirOperand index, int disp, Scale scale, boolean canTrap) { - append(new XirInstruction(kind, new AddressAccessInformation(canTrap, disp, scale), PointerLoadDisp, result, pointer, index)); - } - - public void lea(XirOperand result, XirOperand pointer, XirOperand index, int disp, Scale scale) { - append(new XirInstruction(target.wordKind, new AddressAccessInformation(false, disp, scale), LoadEffectiveAddress, result, pointer, index)); - } - - public void repmov(XirOperand src, XirOperand dest, XirOperand length) { - append(new XirInstruction(target.wordKind, null, RepeatMoveWords, null, src, dest, length)); - } - - public void here(XirOperand dst) { - append(new XirInstruction(target.wordKind, null, Here, dst)); - } - - public void repmovb(XirOperand src, XirOperand dest, XirOperand length) { - append(new XirInstruction(target.wordKind, null, RepeatMoveBytes, null, src, dest, length)); - } - - public void pstore(CiKind kind, XirOperand pointer, XirOperand index, XirOperand value, int disp, Scale scale, boolean canTrap) { - append(new XirInstruction(kind, new AddressAccessInformation(canTrap, disp, scale), PointerStoreDisp, VOID, pointer, index, value)); - } - - public void pcas(CiKind kind, XirOperand result, XirOperand pointer, XirOperand newValue, XirOperand oldValue) { - append(new XirInstruction(kind, null, PointerCAS, result, pointer, newValue, oldValue)); - } - - public void jmp(XirLabel l) { - append(new XirInstruction(CiKind.Void, l, Jmp, null)); - } - - public void decAndJumpNotZero(XirLabel l, XirOperand val) { - append(new XirInstruction(CiKind.Void, l, DecAndJumpNotZero, null, val)); - } - - public void jmpRuntime(Object rt) { - append(new XirInstruction(CiKind.Void, rt, Jmp, null)); - } - - public void jeq(XirLabel l, XirOperand a, XirOperand b) { - jcc(Jeq, l, a, b); - } - - private void jcc(XirOp op, XirLabel l, XirOperand a, XirOperand b) { - append(new XirInstruction(CiKind.Void, l, op, null, a, b)); - } - - public void jneq(XirLabel l, XirOperand a, XirOperand b) { - jcc(Jneq, l, a, b); - } - - public void jgt(XirLabel l, XirOperand a, XirOperand b) { - jcc(Jgt, l, a, b); - } - - public void jgteq(XirLabel l, XirOperand a, XirOperand b) { - jcc(Jgteq, l, a, b); - } - - public void jugteq(XirLabel l, XirOperand a, XirOperand b) { - jcc(Jugteq, l, a, b); - } - - public void jlt(XirLabel l, XirOperand a, XirOperand b) { - jcc(Jlt, l, a, b); - } - - public void jlteq(XirLabel l, XirOperand a, XirOperand b) { - jcc(Jlteq, l, a, b); - } - - public void jbset(XirLabel l, XirOperand a, XirOperand b, XirOperand c) { - append(new XirInstruction(CiKind.Void, l, Jbset, null, a, b, c)); - } - - public void bindInline(XirLabel l) { - assert l.inline; - append(new XirInstruction(CiKind.Void, l, Bind, null)); - } - - public void bindOutOfLine(XirLabel l) { - assert !l.inline; - append(new XirInstruction(CiKind.Void, l, Bind, null)); - } - - public void safepoint() { - append(new XirInstruction(CiKind.Void, null, Safepoint, null)); - } - - public void align(int multiple) { - assert multiple > 0; - append(new XirInstruction(CiKind.Void, multiple, Align, null)); - } - - public void stackOverflowCheck() { - append(new XirInstruction(CiKind.Void, null, StackOverflowCheck, null)); - } - - public void pushFrame() { - append(new XirInstruction(CiKind.Void, null, PushFrame, null)); - } - - public void popFrame() { - append(new XirInstruction(CiKind.Void, null, PopFrame, null)); - } - - public void rawBytes(byte[] bytes) { - append(new XirInstruction(CiKind.Void, bytes, RawBytes, null)); - } - - public void push(XirOperand value) { - append(new XirInstruction(CiKind.Void, Push, VOID, value)); - } - - public void pop(XirOperand result) { - append(new XirInstruction(result.kind, Pop, result)); - } - - public XirMark mark(Object id, XirMark... references) { - XirMark mark = new XirMark(id, references); - marks.add(mark); - append(new XirInstruction(CiKind.Void, mark, Mark, null)); - return mark; - } - - public void nop(int size) { - append(new XirInstruction(CiKind.Void, size, Nop, null)); - } - - public void shouldNotReachHere() { - append(new XirInstruction(CiKind.Void, null, ShouldNotReachHere, null)); - } - - public void shouldNotReachHere(String message) { - append(new XirInstruction(CiKind.Void, message, ShouldNotReachHere, null)); - } - - public void callStub(XirTemplate stub, XirOperand result, XirOperand... args) { - CiKind resultKind = result == null ? CiKind.Void : result.kind; - append(new XirInstruction(resultKind, stub, CallStub, result, args)); - } - - public void callRuntime(Object rt, XirOperand result, XirOperand... args) { - callRuntime(rt, result, false, args); - } - - public void callRuntime(Object rt, XirOperand result, boolean useInfoAfter, XirOperand... args) { - CiKind resultKind = result == null ? CiKind.Void : result.kind; - append(new XirInstruction(resultKind, new RuntimeCallInformation(rt, useInfoAfter), CallRuntime, result, args)); - } - - /** - * Terminates the assembly, checking invariants, in particular that {@link resultOperand} is set, and setting {@link #finished} to {@code true}. - */ - private void end() { - assert !finished : "template may only be finished once!"; - assert resultOperand != null : "result operand should be set"; - finished = true; - } - - /** - * Creates an {@link XirVariableParameter variable input parameter} of given name and {@link CiKind kind}. - * @param name a name for the parameter - * @param kind the parameter kind - * @return the {@link XirVariableParameter} - */ - public XirVariableParameter createInputParameter(String name, CiKind kind, boolean canBeConstant) { - assert !finished; - return new XirVariableParameter(this, name, kind, canBeConstant); - } - - public XirVariableParameter createInputParameter(String name, CiKind kind) { - return createInputParameter(name, kind, false); - } - - /** - * Creates an {@link XirConstantParameter constant input parameter} of given name and {@link CiKind kind}. - * @param name a name for the parameter - * @param kind the parameter kind - * @return the {@link XirConstantParameter} - */ - public XirConstantParameter createConstantInputParameter(String name, CiKind kind) { - assert !finished; - return new XirConstantParameter(this, name, kind); - } - - public XirConstant createConstant(CiConstant constant) { - assert !finished; - XirConstant temp = new XirConstant(this, constant); - constants.add(temp); - return temp; - } - - public XirOperand createTemp(String name, CiKind kind) { - assert !finished; - XirTemp temp = new XirTemp(this, name, kind, true); - temps.add(temp); - return temp; - } - - public XirOperand createRegister(String name, CiKind kind, CiRegister register) { - return createRegister(name, kind, register, false); - } - - public XirOperand createRegisterTemp(String name, CiKind kind, CiRegister register) { - return createRegister(name, kind, register, true); - } - - private XirOperand createRegister(String name, CiKind kind, CiRegister register, boolean reserve) { - assert !finished; - XirRegister fixed = new XirRegister(this, name, register.asValue(kind), reserve); - temps.add(fixed); - return fixed; - } - - public XirParameter getParameter(String name) { - for (XirParameter param : parameters) { - if (param.name.toString().equals(name)) { - return param; - } - } - throw new IllegalArgumentException("no parameter: " + name); - } - - public XirTemp getTemp(String name) { - for (XirTemp temp : temps) { - if (temp.name.toString().equals(name)) { - return temp; - } - } - throw new IllegalArgumentException("no temp: " + name); - } - - public XirConstant i(int v) { - return createConstant(CiConstant.forInt(v)); - } - - public XirConstant l(int v) { - return createConstant(CiConstant.forLong(v)); - } - - public XirConstant b(boolean v) { - return createConstant(CiConstant.forBoolean(v)); - } - - public XirConstant o(Object obj) { - return createConstant(CiConstant.forObject(obj)); - } - - public void reserveOutgoingStack(int size) { - outgoingStackSize = Math.max(outgoingStackSize, size); - } - - /** - * Finishes the assembly of a non-stub template, providing the {@link #resultOperand} and constructs the {@link XirTemplate}. - * @param result the {@link XirOperand} to be set as the {@link #resultOperand} - * @param name the name of the template - * @return the generated template - */ - public XirTemplate finishTemplate(XirOperand result, String name) { - assert this.resultOperand == null; - assert result != null; - this.resultOperand = result; - final XirTemplate template = buildTemplate(name, false); - end(); - return template; - } - - /** - * Finishes the assembly of a non-stub template and constructs the {@link XirTemplate}. - * @param name the name of the template - * @return the generated template - */ - public XirTemplate finishTemplate(String name) { - final XirTemplate template = buildTemplate(name, false); - end(); - return template; - } - - /** - * Finishes the assembly of a {@link XirTemplate.GlobalFlags#GLOBAL_STUB stub} and constructs the {@link XirTemplate}. - * @param name the name of the template - * @return the generated template - */ - public XirTemplate finishStub(String name) { - final XirTemplate template = buildTemplate(name, true); - end(); - return template; - } - - /** - * Builds the {@link XirTemplate} from the assembly state in this object. - * The actual assembly is dependent on the target architecture and implemented - * in a concrete subclass. - * @param name the name of the template - * @param isStub {@code true} if the template represents a {@link XirTemplate.GlobalFlags#GLOBAL_STUB stub} - * @return the generated template - */ - protected abstract XirTemplate buildTemplate(String name, boolean isStub); - - public abstract CiXirAssembler copy(); - -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/xir/RiXirGenerator.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,123 +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. - * - * 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.cri.xir; - -import java.util.*; - -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.ri.RiType.*; - -/** - * Represents the interface through which the compiler requests the XIR for a given bytecode from the runtime system. - */ -public interface RiXirGenerator { - - /** - * Note: may return {@code null}. - */ - XirSnippet genPrologue(XirSite site, RiResolvedMethod method); - - /** - * Note: may return {@code null} in which case the compiler will not emit a return instruction. - */ - XirSnippet genEpilogue(XirSite site, RiResolvedMethod method); - - XirSnippet genSafepointPoll(XirSite site); - - XirSnippet genExceptionObject(XirSite site); - - XirSnippet genResolveClass(XirSite site, RiType type, Representation representation); - - XirSnippet genIntrinsic(XirSite site, XirArgument[] arguments, RiMethod method); - - XirSnippet genInvokeInterface(XirSite site, XirArgument receiver, RiMethod method); - - XirSnippet genInvokeVirtual(XirSite site, XirArgument receiver, RiMethod method); - - XirSnippet genInvokeSpecial(XirSite site, XirArgument receiver, RiMethod method); - - XirSnippet genInvokeStatic(XirSite site, RiMethod method); - - XirSnippet genMonitorEnter(XirSite site, XirArgument receiver, XirArgument lockAddress); - - XirSnippet genMonitorExit(XirSite site, XirArgument receiver, XirArgument lockAddress); - - XirSnippet genGetField(XirSite site, XirArgument receiver, RiField field); - - XirSnippet genPutField(XirSite site, XirArgument receiver, RiField field, XirArgument value); - - XirSnippet genGetStatic(XirSite site, XirArgument staticTuple, RiField field); - - XirSnippet genPutStatic(XirSite site, XirArgument staticTuple, RiField field, XirArgument value); - - XirSnippet genNewInstance(XirSite site, RiType type); - - XirSnippet genNewArray(XirSite site, XirArgument length, CiKind elementKind, RiType componentType, RiType arrayType); - - XirSnippet genNewObjectArrayClone(XirSite site, XirArgument newLength, XirArgument referenceArray); - - XirSnippet genNewMultiArray(XirSite site, XirArgument[] lengths, RiType type); - - XirSnippet genCheckCast(XirSite site, XirArgument receiver, XirArgument hub, RiType type); - - XirSnippet genInstanceOf(XirSite site, XirArgument receiver, XirArgument hub, RiType type); - - XirSnippet genMaterializeInstanceOf(XirSite site, XirArgument receiver, XirArgument hub, XirArgument trueValue, XirArgument falseValue, RiType type); - - XirSnippet genArrayLoad(XirSite site, XirArgument array, XirArgument index, CiKind elementKind, RiType elementType); - - XirSnippet genArrayStore(XirSite site, XirArgument array, XirArgument index, XirArgument value, CiKind elementKind, RiType elementType); - - XirSnippet genArrayLength(XirSite site, XirArgument array); - - XirSnippet genWriteBarrier(XirArgument object); - - XirSnippet genArrayCopy(XirSite site, XirArgument src, XirArgument srcPos, XirArgument dest, XirArgument destPos, XirArgument length, RiType elementType, boolean inputsSame, boolean inputsDifferent); - - XirSnippet genCurrentThread(XirSite site); - - XirSnippet genGetClass(XirSite site, XirArgument xirArgument); - - /** - * Generates code that checks that the {@linkplain Representation#ObjectHub hub} of - * an object is identical to a given hub constant. In pseudo code: - * <pre> - * if (object.getHub() != hub) { - * uncommonTrap(); - * } - * </pre> - * This snippet should only be used when the object is guaranteed not to be null. - */ - XirSnippet genTypeCheck(XirSite site, XirArgument object, XirArgument hub, RiType type); - - /** - * Gets the list of XIR templates, using the given XIR assembler to create them if - * they haven't yet been created. - * - * @param asm the XIR assembler - * @return the list of templates - */ - List<XirTemplate> makeTemplates(CiXirAssembler asm); - -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/xir/XirArgument.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,70 +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. - * - * 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.cri.xir; - -import com.sun.cri.ci.*; - -/** - * Represents an argument to an {@link XirSnippet}. - * Currently, this is a <i>union </i> type; it is either a {@link CiConstant} or an {@code Object}. - */ -public final class XirArgument { - - public final CiConstant constant; - public final Object object; - - private XirArgument(CiConstant value) { - this.constant = value; - this.object = null; - } - - private XirArgument(Object o) { - this.constant = null; - this.object = o; - } - - public static XirArgument forInternalObject(Object o) { - return new XirArgument(o); - } - - public static XirArgument forInt(int x) { - return new XirArgument(CiConstant.forInt(x)); - } - - public static XirArgument forLong(long x) { - return new XirArgument(CiConstant.forLong(x)); - } - - public static XirArgument forObject(Object o) { - return new XirArgument(CiConstant.forObject(o)); - } - - @Override - public String toString() { - if (constant != null) { - return constant.toString(); - } else { - return "" + object; - } - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/xir/XirSite.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,94 +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. - * - * 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.cri.xir; - -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; - -/** - * Encapsulates the notion of a site where XIR can be supplied. It is supplied to the {@link RiXirGenerator} by the - * compiler for each place where XIR can be generated. This interface allows a number of queries, including the - * bytecode-level location and optimization hints computed by the compiler. - */ -public interface XirSite { - - /** - * Gets the {@link CiCodePos code position} associated with this site. This is useful for inserting - * instrumentation at the XIR level. - * @return the code position if it is available; {@code null} otherwise - */ - CiCodePos getCodePos(); - - /** - * Checks whether the specified argument is guaranteed to be non-null at this site. - * @param argument the argument - * @return {@code true} if the argument is non null at this site - */ - boolean isNonNull(XirArgument argument); - - /** - * Checks whether this site requires a null check. - * @return {@code true} if a null check is required - */ - boolean requiresNullCheck(); - - /** - * Checks whether this site requires a range check. - * @return {@code true} if a range check is required - */ - boolean requiresBoundsCheck(); - - /** - * Checks whether this site requires a read barrier. - * @return {@code true} if a read barrier is required - */ - boolean requiresReadBarrier(); - - /** - * Checks whether this site requires a write barrier. - * @return {@code true} if a write barrier is required - */ - boolean requiresWriteBarrier(); - - /** - * Checks whether this site requires an array store check. - * @return {@code true} if an array store check is required - */ - boolean requiresArrayStoreCheck(); - - /** - * Checks whether an approximation of the type for the specified argument is available. - * @param argument the argument - * @return an {@link RiType} indicating the most specific type known for the argument, if any; - * {@code null} if no particular type is known - */ - RiType getApproximateType(XirArgument argument); - - /** - * Checks whether an exact type is known for the specified argument. - * @param argument the argument - * @return an {@link RiType} indicating the exact type known for the argument, if any; - * {@code null} if no particular type is known - */ - RiType getExactType(XirArgument argument); -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/xir/XirSnippet.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,94 +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. - * - * 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.cri.xir; - -import java.util.*; - -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiTargetMethod.Mark; -import com.sun.cri.xir.CiXirAssembler.*; - -/** - * Represents a {@link XirTemplate template of XIR} along with the {@link XirArgument arguments} to be passed to the - * template. The runtime generates such snippets for each bytecode being compiled at the request of the compiler, and - * the compiler can generate machine code for the XIR snippet. - */ -public class XirSnippet { - - public final XirArgument[] arguments; - public final XirTemplate template; - public final Map<XirMark, Mark> marks; - - public XirSnippet(XirTemplate template, XirArgument... inputs) { - assert template != null; - this.template = template; - this.arguments = inputs; - this.marks = (template.marks != null && template.marks.length > 0) ? new HashMap<XirMark, Mark>() : null; - assert assertArgumentsCorrect(); - } - - private boolean assertArgumentsCorrect() { - int argLength = arguments == null ? 0 : arguments.length; - int paramLength = template.parameters == null ? 0 : template.parameters.length; - assert argLength == paramLength : "expected param count: " + paramLength + ", actual: " + argLength; - for (int i = 0; i < arguments.length; i++) { - assert assertArgumentCorrect(template.parameters[i], arguments[i]) : "mismatch in parameter " + i + ": " + arguments[i] + " instead of " + template.parameters[i]; - } - return true; - } - - private static boolean assertArgumentCorrect(XirParameter param, XirArgument arg) { - if (param.kind == CiKind.Illegal || param.kind == CiKind.Void) { - if (arg != null) { - return false; - } - } else { - if (arg == null) { - return false; - } - if (arg.constant != null) { - if (arg.constant != null && arg.constant.kind != param.kind) { - return false; - } - } - } - return true; - } - - @Override - public String toString() { - - StringBuffer sb = new StringBuffer(); - - sb.append(template.toString()); - sb.append("("); - for (XirArgument a : arguments) { - sb.append(" "); - sb.append(a); - } - - sb.append(" )"); - - return sb.toString(); - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/xir/XirTemplate.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,267 +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. - * - * 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.cri.xir; - -import java.io.*; -import java.util.*; - -import com.sun.cri.xir.CiXirAssembler.*; - -/** - * Represents a completed template of XIR code that has been first assembled by - * the runtime, and then verified and preprocessed by the compiler. An {@code XirTemplate} - * instance is immutable. - */ -public class XirTemplate { - - /** - * Flags that indicate key features of the template for quick checking. - */ - public enum GlobalFlags { - /** - * Contains a call to a {@link GlobalFlags#GLOBAL_STUB} template. - */ - HAS_STUB_CALL, - - /** - * Contains a call to the runtime. - */ - HAS_RUNTIME_CALL, - - /** - * Not simply a linear sequence of instructions, contains control transfers. - */ - HAS_CONTROL_FLOW, - - /** - * Is a shared instruction sequence for use by other templates. - */ - GLOBAL_STUB; - - public final int mask = 1 << ordinal(); - } - - /** - * Name of the template. - */ - public final String name; - - public final XirOperand resultOperand; - - /** - * The sequence of instructions for the fast (inline) path. - */ - public final CiXirAssembler.XirInstruction[] fastPath; - - /** - * The sequence of instructions for the slow (out of line) path. - */ - public final CiXirAssembler.XirInstruction[] slowPath; - - /** - * Labels used in control transfers. - */ - public final XirLabel[] labels; - - /** - * Parameters to the template. - */ - public final XirParameter[] parameters; - - /** - * An array of same length as {@link #parameters} where {@code parameterDestroyed[i]} is {@code true} - * iff {@code parameters[i]} is the {@link XirInstruction#result result} of any {@link XirInstruction} in either - * {@link #fastPath} or {@link #slowPath}. - */ - public final boolean[] parameterDestroyed; - - /** - * Temporary variables used by the template. - */ - public final XirTemp[] temps; - - /** - * Constants used in the template. - */ - public final XirConstant[] constants; - - /** - * The total number of variables. (relation to temps/parameters???) - */ - public final int variableCount; - - public final boolean allocateResultOperand; - - public final XirTemplate[] calleeTemplates; - - public final XirMark[] marks; - - public final int outgoingStackSize; - - public final XirOperand[] inputOperands; - public final XirOperand[] inputTempOperands; - public final XirOperand[] tempOperands; - - - /** - * The {@link GlobalFlags} associated with the template. - */ - public final int flags; - - public XirTemplate(String name, - int variableCount, - boolean allocateResultOperand, - XirOperand resultOperand, - CiXirAssembler.XirInstruction[] fastPath, - CiXirAssembler.XirInstruction[] slowPath, - XirLabel[] labels, - XirParameter[] parameters, - XirTemp[] temps, - XirConstant[] constantValues, - int flags, - XirTemplate[] calleeTemplates, - XirMark[] marks, - int outgoingStackSize) { - this.name = name; - this.variableCount = variableCount; - this.resultOperand = resultOperand; - this.fastPath = fastPath; - this.slowPath = slowPath; - this.labels = labels; - this.parameters = parameters; - this.flags = flags; - this.temps = temps; - this.allocateResultOperand = allocateResultOperand; - this.constants = constantValues; - this.calleeTemplates = calleeTemplates; - this.marks = marks; - this.outgoingStackSize = outgoingStackSize; - - assert fastPath != null; - assert labels != null; - assert parameters != null; - - List<XirOperand> inputOperandList = new ArrayList<>(4); - List<XirOperand> inputTempOperandList = new ArrayList<>(4); - List<XirOperand> tempOperandList = new ArrayList<>(4); - - parameterDestroyed = new boolean[parameters.length]; - for (int i = 0; i < parameters.length; i++) { - for (XirInstruction ins : fastPath) { - if (ins.result == parameters[i]) { - parameterDestroyed[i] = true; - break; - } - } - - if (slowPath != null && !parameterDestroyed[i]) { - for (XirInstruction ins : slowPath) { - if (ins.result == parameters[i]) { - parameterDestroyed[i] = true; - } - } - } - - if (parameterDestroyed[i]) { - inputTempOperandList.add(parameters[i]); - } else { - inputOperandList.add(parameters[i]); - } - } - - for (XirTemp temp : temps) { - if (temp.reserve) { - tempOperandList.add(temp); - } - } - - this.inputOperands = inputOperandList.toArray(new XirOperand[inputOperandList.size()]); - this.inputTempOperands = inputTempOperandList.toArray(new XirOperand[inputTempOperandList.size()]); - this.tempOperands = tempOperandList.toArray(new XirOperand[tempOperandList.size()]); - } - - /** - * Convenience getter that returns the value at a given index in the {@link #parameterDestroyed} array. - * @param index - * @return the value at {@code parameterDestroyed[index]} - */ - public boolean isParameterDestroyed(int index) { - return parameterDestroyed[index]; - } - - @Override - public String toString() { - return name; - } - - public void print(PrintStream p) { - final String indent = " "; - - p.println(); - p.println("Template " + name); - - p.print("Param:"); - for (XirParameter param : parameters) { - p.print(" " + param.detailedToString()); - } - p.println(); - - if (temps.length > 0) { - p.print("Temps:"); - for (XirTemp temp : temps) { - p.print(" " + temp.detailedToString()); - } - p.println(); - } - - if (constants.length > 0) { - p.print("Constants:"); - for (XirConstant c : constants) { - p.print(" " + c.detailedToString()); - } - p.println(); - } - - if (flags != 0) { - p.print("Flags:"); - for (XirTemplate.GlobalFlags flag : XirTemplate.GlobalFlags.values()) { - if ((this.flags & flag.mask) != 0) { - p.print(" " + flag.name()); - } - } - p.println(); - } - - p.println("Fast path:"); - for (XirInstruction i : fastPath) { - p.println(indent + i.toString()); - } - - if (slowPath != null) { - p.println("Slow path:"); - for (XirInstruction i : slowPath) { - p.println(indent + i.toString()); - } - } - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/cri/xir/package-info.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,37 +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. - * - * 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. - */ -/** - * XIR defines a domain specific instruction set for expressing the lowering of bytecode operations. The details of the - * lowering operations are entirely encapsulated in the runtime and are provided to the compiler on request using - * {@link com.sun.cri.xir.XirSnippet XIR snippets}. A snippet is a combination of a {@link com.sun.cri.xir.XirTemplate - * template}, which is a sequence of {@link com.sun.cri.xir.CiXirAssembler.XirInstruction XIR instructions} that has - * unbound {@link com.sun.cri.xir.CiXirAssembler.XirParameter parameters}, and site-specific - * {@link com.sun.cri.xir.XirArgument arguments} that are bound to the parameters. - * <p> - * The runtime is responsible for creating the {@link com.sun.cri.xir.XirTemplate templates} and provides these to the - * compiler as part of the initialization process. - * <p> - * The XIR instruction set has no textual representation, and therefore no parser. An assembly is represented by an - * instance of {@link com.sun.cri.xir.CiXirAssembler}, which provides methods to create instructions and operands. - */ -package com.sun.cri.xir;
--- a/graal/com.oracle.max.cri/src/com/sun/max/annotate/CONSTANT.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,37 +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. - * - * 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.max.annotate; -import java.lang.annotation.*; - -/** - * Marker indicating that a field is immutable with respect to all reads of its value. - * That is, it is never updated after the first time it is read. - * - * <b>It is up to the programmer to maintain this invariant!</b> - * - * The value may be the dewfault value of the field's type (e.g. {@code null}, 0, etc). - */ -@Retention(RetentionPolicy.RUNTIME) -@Target(ElementType.FIELD) -public @interface CONSTANT { -}
--- a/graal/com.oracle.max.cri/src/com/sun/max/annotate/CONSTANT_WHEN_NOT_ZERO.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,39 +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. - * - * 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.max.annotate; -import java.lang.annotation.*; - -@Retention(RetentionPolicy.RUNTIME) -@Target(ElementType.FIELD) - -/** - * Marker indicating that a field is quasi 'final' for all practical purposes, - * AFTER it has been set to a value that is not null, 0, etc. - * because it is only initialized once and only inspected after proper initialization. - * It is up to the programmer to maintain this invariant! - * - * Note that reading the field's value can only occur AFTER bootstrapping. - * Therefore, there is no constant folding during bootstrapping. - */ -public @interface CONSTANT_WHEN_NOT_ZERO { -}
--- a/graal/com.oracle.max.cri/src/com/sun/max/annotate/FOLD.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,37 +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. - * - * 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.max.annotate; -import java.lang.annotation.*; - -/** - * Every thus annotated method must must have no arguments (apart from a receiver for a non-static method). - * It must also be purely functional (without side-effects) - * and idempotent (not influenced by any changing state). - * - * If the method is static, it is to be meta-evaluated unconditionally by the compiler. - * If the method is non-static, it will be meta-evaluated whenever its receiver is known at compile time. - */ -@Retention(RetentionPolicy.RUNTIME) -@Target(ElementType.METHOD) -public @interface FOLD { -}
--- a/graal/com.oracle.max.cri/src/com/sun/max/annotate/INLINE.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,70 +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. - * - * 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.max.annotate; -import java.lang.annotation.*; - -/** - * Every thus annotated method is to be inlined unconditionally by the VM's optimizing compiler - * and the receiver is never null-checked. - * - * This annotation exists primarily for annotating methods that <b>must</b> be inlined - * for semantic reasons as opposed to those that could be inlined for performance reasons. - * Using this annotation for the latter should be done very rarely and only when - * profiling highlights a performance bottleneck or such a bottleneck is known <i>a priori</i>. - * - * If the {@linkplain #override() override} element of this annotation is set to true, then - * an annotated method must be {@code static} or {@code final} (implicitly or explicitly). - * Additionally, only a INLINE virtual method with this element set to true can be overridden. - */ -@Retention(RetentionPolicy.RUNTIME) -@Target(ElementType.METHOD) -public @interface INLINE { - - /** - * If true, this element specifies that the annotated method provides the prototypical implementation - * of the functionality expected (in the target VM) of every method that overrides - * the annotated method. That is, the code produced by the compiler for every overriding method - * must be functionality equivalent to the code produced for the prototypical method. - * - * <b>WARNING: Setting this element to true implies that you guarantee that all overriders - * satisfy the above stated invariant.</b> There is no (easy) way to test for violations of - * the invariant. - * - * A method annotated with INLINE should only be overridden for one of the following reasons: - * - * 1. To coerce the value returned by the overridden method to a subtype. - * See {@link MemberActor#holder()} and {@link FieldActor#holder()} for an example. - * - * 2. A method is overridden to make bootstrapping work. - * See {@link ClassActor#toJava()} and {@link ArrayClassActor#toJava()} for an example. - * - * 3. A method is overridden because a subclass can provide a more efficient implementation - * and it is known that certain call sites will be reduced to a constant receiver - * (not just a known receiver type but a known receiver object) via annotation driven - * compile-time {@linkplain FOLD folding}. This is how calls to the {@link GeneralLayout layout} - * interface methods are reduced to monomorphic calls at compile-time. - * - * See {@link ClassActor#toJava()} and {@link ArrayClassActor#toJava()} for an example. - */ - boolean override() default false; -}
--- a/graal/com.oracle.max.cri/src/com/sun/max/annotate/INTRINSIC.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,48 +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. - * - * 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.max.annotate; - -import java.lang.annotation.*; - -/** - * Marks a method as being implemented by a compiler intrinsic. - */ -@Retention(RetentionPolicy.RUNTIME) -@Target(ElementType.METHOD) -public @interface INTRINSIC { - /** - * The id of the intrinsic, which is used by the compiler to lookup an implementation of the intrinsic. - */ - String value(); - - - /** - * Marks a parameter of an intrinsic method as a compile-time parameter. Callers of the intrinsic - * must make sure to pass only constants. This is not checked by the Java compiler or classloader, - * but the compiler will fail when the parameter is not a constant. - */ - @Retention(RetentionPolicy.RUNTIME) - @Target(ElementType.PARAMETER) - public @interface Constant { - } -}
--- a/graal/com.oracle.max.cri/src/com/sun/max/annotate/JavacBug.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,38 +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. - * - * 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.max.annotate; - -/** - * Used to indicate that an otherwise strange looking code pattern is required to work around a bug in javac. - */ -public @interface JavacBug { - /** - * A description of the bug. Only really useful if there is no existing entry for the bug in the <a href="http://bugs.sun.com/bugdatabase/">Bug Database</a>. - */ - String value() default ""; - - /** - * An identifier in the <a href="http://bugs.sun.com/bugdatabase/">Bug Database</a>. - */ - int id() default 0; -}
--- a/graal/com.oracle.max.cri/src/com/sun/max/annotate/NEVER_INLINE.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,46 +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. - * - * 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.max.annotate; - -import java.lang.annotation.*; - -/** - * Every thus annotated method is never to be inlined by the compiler. - * - * This annotation exists primarily for annotating methods that <b>must never</b> be inlined - * for semantic reasons. Typically, this is to ensure that a separate activation frame is - * always used for a call to the method. - * - * This annotation can also be applied to a class in which is equivalent to applying - * it to all the methods in the class <b>except</b> for those explicitly annotated with - * {@link INLINE}. - */ -@Retention(RetentionPolicy.RUNTIME) -@Target({ElementType.METHOD, ElementType.TYPE}) -public @interface NEVER_INLINE { - - /** - * Documents the reason why the annotated code must notbe inlined. - */ - String value() default ""; -}
--- a/graal/com.oracle.max.criutils/src/com/oracle/max/criutils/BaseUnresolvedField.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.criutils/src/com/oracle/max/criutils/BaseUnresolvedField.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.criutils; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; /** * A implementation of {@link RiField} for an unresolved field.
--- a/graal/com.oracle.max.criutils/src/com/oracle/max/criutils/BaseUnresolvedMethod.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.criutils/src/com/oracle/max/criutils/BaseUnresolvedMethod.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.criutils; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; /** * A implementation of {@link RiMethod} for an unresolved method. @@ -66,9 +66,4 @@ public String toString() { return CiUtil.format("%H.%n(%p) [unresolved]", this); } - - @Override - public boolean canBePermanentlyLinked() { - return false; - } }
--- a/graal/com.oracle.max.criutils/src/com/oracle/max/criutils/CompilationPrinter.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.criutils/src/com/oracle/max/criutils/CompilationPrinter.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,8 +24,8 @@ import java.io.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; /** * Utility for printing compilation related data structures at various compilation phases.
--- a/graal/com.oracle.max.criutils/src/com/oracle/max/criutils/HexCodeFile.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.criutils/src/com/oracle/max/criutils/HexCodeFile.java Tue Jan 03 16:47:02 2012 +0100 @@ -27,11 +27,8 @@ import java.util.*; import java.util.regex.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiTargetMethod.CodeAnnotation; -import com.sun.cri.ci.CiTargetMethod.CodeComment; -import com.sun.cri.ci.CiTargetMethod.JumpTable; -import com.sun.cri.ci.CiTargetMethod.LookupTable; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiTargetMethod.*; /**
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/simple/AssignRegisters.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/simple/AssignRegisters.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,12 +24,12 @@ import static com.oracle.max.graal.alloc.util.ValueUtil.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.alloc.util.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.lir.LIRInstruction.ValueProcedure; -import com.sun.cri.ci.*; public abstract class AssignRegisters { public final LIR lir;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/simple/DataFlowAnalysis.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/simple/DataFlowAnalysis.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,14 +26,14 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.alloc.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.lir.LIRInstruction.ValueProcedure; import com.oracle.max.graal.compiler.schedule.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class DataFlowAnalysis { private final GraalContext context;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/simple/ResolveDataFlow.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/simple/ResolveDataFlow.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,6 +26,7 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.alloc.util.*; import com.oracle.max.graal.compiler.*; @@ -33,7 +34,6 @@ import com.oracle.max.graal.compiler.lir.LIRInstruction.ValueProcedure; import com.oracle.max.graal.compiler.lir.LIRPhiMapping.PhiValueProcedure; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public abstract class ResolveDataFlow { public final LIR lir;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/simple/SpillAllAllocator.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/simple/SpillAllAllocator.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,6 +26,9 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiRegister.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.alloc.util.*; import com.oracle.max.graal.alloc.util.MoveResolver; @@ -36,9 +39,6 @@ import com.oracle.max.graal.compiler.lir.LIRInstruction.ValueProcedure; import com.oracle.max.graal.compiler.schedule.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiRegister.RegisterFlag; -import com.sun.cri.ri.*; public class SpillAllAllocator { private final GraalContext context;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/LIRVerifier.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/LIRVerifier.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,14 +26,14 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.alloc.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.lir.LIRInstruction.ValueProcedure; import com.oracle.max.graal.compiler.schedule.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public final class LIRVerifier { private final LIR lir;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/Location.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/Location.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,7 +22,7 @@ */ package com.oracle.max.graal.alloc.util; -import com.sun.cri.ci.*; +import com.oracle.max.cri.ci.*; public class Location extends CiValue { private static final long serialVersionUID = -1786677729152726126L;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/LocationMap.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/LocationMap.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,8 +26,8 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.lir.LIRInstruction.ValueProcedure; -import com.sun.cri.ci.*; public class LocationMap { private final Location[] locations;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/MoveResolver.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/MoveResolver.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,12 +26,12 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.alloc.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public final class MoveResolver { private final FrameMap frameMap; @@ -257,7 +257,7 @@ return count == 0 || (count == 1 && isLocation(from) && asLocation(from).location == to.location); } - private void insertExchange(Location from, Location to) { + private static void insertExchange(Location from, Location to) { trace(3, "mr XCHG %s, %s", from, to); throw Util.unimplemented(); // TODO create XCHG instruction and use it here
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/RegisterVerifier.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/RegisterVerifier.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,13 +26,13 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.lir.LIRInstruction.ValueProcedure; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public final class RegisterVerifier { private final FrameMap frameMap;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/ValueUtil.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/alloc/util/ValueUtil.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,7 +22,7 @@ */ package com.oracle.max.graal.alloc.util; -import com.sun.cri.ci.*; +import com.oracle.max.cri.ci.*; public class ValueUtil extends CiValueUtil {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalCompilation.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalCompilation.java Tue Jan 03 16:47:02 2012 +0100 @@ -23,11 +23,15 @@ package com.oracle.max.graal.compiler; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; import com.oracle.max.asm.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiCompiler.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.alloc.simple.*; import com.oracle.max.graal.compiler.alloc.*; @@ -42,10 +46,6 @@ import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.virtual.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiCompiler.DebugInfoLevel; -import com.sun.cri.ri.*; -import com.sun.cri.xir.*; /** * This class encapsulates global information about the compilation of a particular method,
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalCompiler.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalCompiler.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,15 +24,15 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.phases.*; import com.oracle.max.graal.compiler.stub.*; import com.oracle.max.graal.compiler.target.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.xir.*; public class GraalCompiler {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalContext.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalContext.java Tue Jan 03 16:47:02 2012 +0100 @@ -23,7 +23,6 @@ package com.oracle.max.graal.compiler; import com.oracle.max.criutils.*; -import com.oracle.max.graal.compiler.debug.*; import com.oracle.max.graal.compiler.observer.*; /** @@ -32,7 +31,7 @@ */ public class GraalContext { - public static final GraalContext EMPTY_CONTEXT = new GraalContext(true, "silent context"); + public static final GraalContext EMPTY_CONTEXT = new GraalContext("silent context"); public final ObservableContext observable = new ObservableContext(); public final GraalTimers timers = new GraalTimers(); @@ -40,35 +39,16 @@ private final String name; - private GraalContext(boolean empty, String name) { + public GraalContext(String name) { this.name = name; - if (!empty) { - reset(); - } - } - - public GraalContext(String name) { - this(false, name); } public boolean isObserved() { return observable.isObserved(); } - public void reset() { - observable.clear(); - if (GraalOptions.PrintCFGToFile) { - observable.addCompilationObserver(new CFGPrinterObserver()); - } - if (GraalOptions.PrintIdealGraphLevel != 0 || GraalOptions.Plot || GraalOptions.PlotOnError) { - CompilationObserver observer; - if (GraalOptions.PrintIdealGraphFile) { - observer = new IdealGraphPrinterObserver(); - } else { - observer = new IdealGraphPrinterObserver(GraalOptions.PrintIdealGraphAddress, GraalOptions.PrintIdealGraphPort); - } - observable.addCompilationObserver(observer); - } + public void addCompilationObserver(CompilationObserver observer) { + observable.addCompilationObserver(observer); } public void print() {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/ControlFlowOptimizer.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/ControlFlowOptimizer.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,11 +24,11 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.schedule.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; /** * This class performs basic optimizations on the control flow graph after LIR generation.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/Interval.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/Interval.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,15 +22,15 @@ */ package com.oracle.max.graal.compiler.alloc; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; /** * Represents an interval in the {@linkplain LinearScan linear scan register allocator}.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/LinearScan.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/LinearScan.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,13 @@ */ package com.oracle.max.graal.compiler.alloc; -import static com.sun.cri.ci.CiUtil.*; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.alloc.Interval.RegisterBinding; @@ -39,8 +41,6 @@ import com.oracle.max.graal.compiler.util.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * An implementation of the linear scan register allocator algorithm described
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/LinearScanWalker.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/LinearScanWalker.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,13 @@ */ package com.oracle.max.graal.compiler.alloc; -import static com.sun.cri.ci.CiUtil.*; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiRegister.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.alloc.Interval.RegisterBinding; @@ -35,8 +37,6 @@ import com.oracle.max.graal.compiler.alloc.Interval.State; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiRegister.RegisterFlag; /** */
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/MoveResolver.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/MoveResolver.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,15 +22,15 @@ */ package com.oracle.max.graal.compiler.alloc; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; /** */
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/OperandPool.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/OperandPool.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,14 +22,14 @@ */ package com.oracle.max.graal.compiler.alloc; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; /** * An ordered, 0-based indexable pool of instruction operands for a method being compiled.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/RegisterVerifier.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/RegisterVerifier.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,15 +22,15 @@ */ package com.oracle.max.graal.compiler.alloc; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; /** */
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/asm/TargetMethodAssembler.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/asm/TargetMethodAssembler.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,17 +22,17 @@ */ package com.oracle.max.graal.compiler.asm; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; import com.oracle.max.asm.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class TargetMethodAssembler { public final GraalCompilation compilation;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/debug/BasicIdealGraphPrinter.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,303 +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. - * - * 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.oracle.max.graal.compiler.debug; - -import java.io.*; -import java.util.*; -import java.util.Map.Entry; - -/** - * Elementary, generic generator of Ideal Graph Visualizer input for use in printers for specific data structures. - */ -public class BasicIdealGraphPrinter { - - /** - * Edge between two nodes. - */ - public static class Edge { - final String from; - final int fromIndex; - final String to; - final int toIndex; - final String label; - - public Edge(String from, int fromIndex, String to, int toIndex, String label) { - assert (from != null && to != null); - this.from = from; - this.fromIndex = fromIndex; - this.to = to; - this.toIndex = toIndex; - this.label = label; - } - - @Override - public int hashCode() { - int h = from.hashCode() ^ to.hashCode(); - h = 3 * h + fromIndex; - h = 5 * h + toIndex; - if (label != null) { - h ^= label.hashCode(); - } - return h; - } - - @Override - public boolean equals(Object obj) { - if (obj == this) { - return true; - } - if (obj instanceof Edge) { - Edge other = (Edge) obj; - return from.equals(other.from) - && fromIndex == other.fromIndex - && to.equals(other.to) - && toIndex == other.toIndex - && (label == other.label || (label != null && label.equals(other.label))); - } - return false; - } - } - - private final PrintStream stream; - - /** - * Creates a new {@link IdealGraphPrinter} that writes to the specified output stream. - */ - public BasicIdealGraphPrinter(OutputStream stream) { - this.stream = new PrintStream(stream); - } - - /** - * Flushes any buffered output. - */ - public void flush() { - stream.flush(); - } - - /** - * Starts a new graph document. - */ - public void begin() { - stream.println("<graphDocument>"); - } - - public void beginGroup() { - stream.println("<group>"); - } - - public void beginMethod(String name, String shortName, int bci) { - stream.printf(" <method name='%s' shortName='%s' bci='%d'>%n", escape(name), escape(shortName), bci); - } - - public void beginBytecodes() { - stream.println(" <bytecodes>\n<![CDATA["); - } - - public void printBytecode(int bci, String mnemonic, int[] extra) { - stream.print(bci); - stream.print(' '); - stream.print(mnemonic); - if (extra != null) { - for (int b : extra) { - stream.print(' '); - stream.print(b); - } - } - stream.println(); - } - - public void endBytecodes() { - stream.println(" ]]></bytecodes>"); - } - - public void endMethod() { - stream.println(" </method>"); - } - - public void beginGraph(String title) { - stream.printf(" <graph name='%s'>%n", escape(title)); - } - - public void beginProperties() { - stream.print("<properties>"); - } - - public void printProperty(String name, String value) { - stream.printf("<p name='%s'>%s</p>", escape(name), escape(value)); - } - - public void endProperties() { - stream.print("</properties>"); - } - - public void printProperties(Map<String, String> properties) { - beginProperties(); - for (Entry<String, String> entry : properties.entrySet()) { - printProperty(entry.getKey(), entry.getValue()); - } - endProperties(); - } - - public void beginNodes() { - stream.println(" <nodes>"); - } - - public void beginNode(String id) { - stream.printf(" <node id='%s'>", escape(id)); - } - - public void endNode() { - stream.println(" </node>"); - } - - public void printNode(String id, Map<String, String> properties) { - beginNode(id); - if (properties != null) { - printProperties(properties); - } - endNode(); - } - - public void endNodes() { - stream.println(" </nodes>"); - } - - public void beginEdges() { - stream.println(" <edges>"); - } - - public void printEdge(Edge edge) { - stream.printf(" <edge from='%s' fromIndex='%d' to='%s' toIndex='%d' label='%s' />%n", escape(edge.from), edge.fromIndex, escape(edge.to), edge.toIndex, escape(edge.label)); - } - - public void endEdges() { - stream.println(" </edges>"); - } - - public void beginControlFlow() { - stream.println(" <controlFlow>"); - } - - public void beginBlock(String name) { - stream.printf(" <block name='%s'>%n", escape(name)); - } - - public void beginSuccessors() { - stream.println(" <successors>"); - } - - public void printSuccessor(String name) { - stream.printf(" <successor name='%s'/>%n", escape(name)); - } - - public void endSuccessors() { - stream.println(" </successors>"); - } - - public void beginBlockNodes() { - stream.println(" <nodes>"); - } - - public void printBlockNode(String nodeId) { - stream.printf(" <node id='%s'/>%n", escape(nodeId)); - } - - public void endBlockNodes() { - stream.println(" </nodes>"); - } - - public void endBlock() { - stream.println(" </block>"); - } - - public void endControlFlow() { - stream.println(" </controlFlow>"); - } - - public void endGraph() { - stream.println(" </graph>"); - } - - /** - * Ends the current group. - */ - public void endGroup() { - stream.println("</group>"); - } - - /** - * Finishes the graph document and flushes the output stream. - */ - public void end() { - stream.println("</graphDocument>"); - flush(); - } - - private static String escape(String s) { - StringBuilder str = null; - for (int i = 0; i < s.length(); i++) { - char c = s.charAt(i); - switch (c) { - case '&': - case '<': - case '>': - case '"': - case '\'': - if (str == null) { - str = new StringBuilder(); - str.append(s, 0, i); - } - switch(c) { - case '&': - str.append("&"); - break; - case '<': - str.append("<"); - break; - case '>': - str.append(">"); - break; - case '"': - str.append("""); - break; - case '\'': - str.append("'"); - break; - default: - assert false; - } - break; - default: - if (str != null) { - str.append(c); - } - break; - } - } - if (str == null) { - return s; - } else { - return str.toString(); - } - } -}
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/debug/CFGPrinter.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,480 +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. - * - * 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.oracle.max.graal.compiler.debug; - -import static com.sun.cri.ci.CiValueUtil.*; - -import java.io.*; -import java.util.*; - -import com.oracle.max.criutils.*; -import com.oracle.max.graal.compiler.*; -import com.oracle.max.graal.compiler.alloc.*; -import com.oracle.max.graal.compiler.alloc.Interval.UsePosList; -import com.oracle.max.graal.compiler.graphbuilder.*; -import com.oracle.max.graal.compiler.lir.*; -import com.oracle.max.graal.compiler.schedule.*; -import com.oracle.max.graal.graph.*; -import com.oracle.max.graal.graph.Node.*; -import com.oracle.max.graal.graph.NodeClass.*; -import com.oracle.max.graal.nodes.*; -import com.oracle.max.graal.nodes.calc.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; - -/** - * Utility for printing Graal IR at various compilation phases. - */ -public class CFGPrinter extends CompilationPrinter { - - public final ByteArrayOutputStream buffer; - public final GraalCompilation compilation; - public final CiTarget target; - public final RiRuntime runtime; - - /** - * Creates a control flow graph printer. - * - * @param buffer where the output generated via this printer shown be written - */ - public CFGPrinter(ByteArrayOutputStream buffer, GraalCompilation compilation) { - super(buffer); - this.buffer = buffer; - this.compilation = compilation; - this.target = compilation.compiler.target; - this.runtime = compilation.compiler.runtime; - } - - public CFGPrinter(ByteArrayOutputStream buffer, GraalCompilation compilation, CiTarget target, RiRuntime runtime) { - super(buffer); - this.buffer = buffer; - this.compilation = compilation; - this.target = target; - this.runtime = runtime; - } - - /** - * Prints the control flow graph denoted by a given block map. - * - * @param label A label describing the compilation phase that produced the control flow graph. - * @param blockMap A data structure describing the blocks in a method and how they are connected. - */ - public void printCFG(String label, BlockMap blockMap) { - begin("cfg"); - out.print("name \"").print(label).println('"'); - for (BlockMap.Block block : blockMap.blocks) { - begin("block"); - printBlock(block); - end("block"); - } - end("cfg"); - } - - private void printBlock(BlockMap.Block block) { - out.print("name \"B").print(block.startBci).println('"'); - out.print("from_bci ").println(block.startBci); - out.print("to_bci ").println(block.endBci); - - out.println("predecessors "); - - out.print("successors "); - for (BlockMap.Block succ : block.successors) { - if (!succ.isExceptionEntry) { - out.print("\"B").print(succ.startBci).print("\" "); - } - } - out.println(); - - out.print("xhandlers"); - for (BlockMap.Block succ : block.successors) { - if (succ.isExceptionEntry) { - out.print("\"B").print(succ.startBci).print("\" "); - } - } - out.println(); - - out.print("flags "); - if (block.isExceptionEntry) { - out.print("\"ex\" "); - } - if (block.isLoopHeader) { - out.print("\"plh\" "); - } - out.println(); - - out.print("loop_depth ").println(Long.bitCount(block.loops)); - } - - - /** - * Prints the specified list of blocks. - * - * @param label A label describing the compilation phase that produced the control flow graph. - * @param blocks The list of blocks to be printed. - * @param printNodes If {@code true} the nodes in the block will be printed. - */ - public void printCFG(String label, List<? extends Block> blocks, boolean printNodes) { - begin("cfg"); - out.print("name \"").print(label).println('"'); - for (Block block : blocks) { - printBlock(block, printNodes); - } - end("cfg"); - } - - private void printBlock(Block block, boolean printNodes) { - begin("block"); - - out.print("name \"").print(blockToString(block)).println('"'); - out.println("from_bci -1"); - out.println("to_bci -1"); - - out.print("predecessors "); - for (Block pred : block.getPredecessors()) { - out.print("\"").print(blockToString(pred)).print("\" "); - } - out.println(); - - out.print("successors "); - for (Block succ : block.getSuccessors()) { - if (!succ.isExceptionBlock()) { - out.print("\"").print(blockToString(succ)).print("\" "); - } - } - out.println(); - - out.print("xhandlers"); - for (Block succ : block.getSuccessors()) { - if (succ.isExceptionBlock()) { - out.print("\"").print(blockToString(succ)).print("\" "); - } - } - out.println(); - - out.print("flags "); - if (block.isLoopHeader()) { - out.print("\"llh\" "); - } - if (block.isLoopEnd()) { - out.print("\"lle\" "); - } - if (block.isExceptionBlock()) { - out.print("\"ex\" "); - } - out.println(); - - out.print("loop_index ").println(block.loopIndex()); - out.print("loop_depth ").println(block.loopDepth()); - - if (printNodes) { - printNodes(block); - } - - if (block instanceof LIRBlock) { - printLIR((LIRBlock) block); - } - - end("block"); - } - - private void printNodes(Block block) { - begin("IR"); - out.println("HIR"); - out.disableIndentation(); - - if (block.getPredecessors().size() == 0) { - // Currently method parameters are not in the schedule, so print them separately here. - for (ValueNode param : block.firstNode().graph().getNodes(LocalNode.class)) { - printNode(param); - } - } - if (block.firstNode() instanceof MergeNode) { - // Currently phi functions are not in the schedule, so print them separately here. - for (ValueNode phi : ((MergeNode) block.firstNode()).phis()) { - printNode(phi); - } - } - - for (Node node : block.getInstructions()) { - printNode(node); - } - out.enableIndentation(); - end("IR"); - } - - private void printNode(Node node) { - if (node instanceof FixedWithNextNode) { - out.print("f ").print(HOVER_START).print("#").print(HOVER_SEP).print("fixed with next").print(HOVER_END).println(COLUMN_END); - } else if (node instanceof FixedNode) { - out.print("f ").print(HOVER_START).print("*").print(HOVER_SEP).print("fixed").print(HOVER_END).println(COLUMN_END); - } else if (node instanceof FloatingNode) { - out.print("f ").print(HOVER_START).print("~").print(HOVER_SEP).print("floating").print(HOVER_END).println(COLUMN_END); - } - if (compilation.nodeOperands != null && node instanceof ValueNode) { - CiValue operand = compilation.operand((ValueNode) node); - if (operand != null) { - out.print("result ").print(operand.toString()).println(COLUMN_END); - } - } - out.print("tid ").print(nodeToString(node)).println(COLUMN_END); - - if (node instanceof StateSplit) { - StateSplit stateSplit = (StateSplit) node; - if (stateSplit.stateAfter() != null) { - String state = stateToString(stateSplit.stateAfter()); - out.print("st ").print(HOVER_START).print("st").print(HOVER_SEP).print(state).print(HOVER_END).println(COLUMN_END); - } - } - - Map<Object, Object> props = new TreeMap<>(node.getDebugProperties()); - out.print("d ").print(HOVER_START).print("d").print(HOVER_SEP); - out.println("=== Debug Properties ==="); - for (Map.Entry<Object, Object> entry : props.entrySet()) { - out.print(entry.getKey().toString()).print(": ").print(entry.getValue() == null ? "[null]" : entry.getValue().toString()).println(); - } - out.println("=== Inputs ==="); - printNamedNodes(node, node.inputs().iterator(), "", "\n", null); - out.println("=== Succesors ==="); - printNamedNodes(node, node.successors().iterator(), "", "\n", null); - out.println("=== Usages ==="); - if (!node.usages().isEmpty()) { - for (Node usage : node.usages()) { - out.print(nodeToString(usage)).print(" "); - } - out.println(); - } - out.println("=== Predecessor ==="); - out.print(nodeToString(node.predecessor())).print(" "); - out.print(HOVER_END).println(COLUMN_END); - - out.print("instruction "); - out.print(HOVER_START).print(node.getNodeClass().shortName()).print(HOVER_SEP).print(node.getClass().getName()).print(HOVER_END).print(" "); - printNamedNodes(node, node.inputs().iterator(), "", "", "#NDF"); - printNamedNodes(node, node.successors().iterator(), "#", "", "#NDF"); - for (Map.Entry<Object, Object> entry : props.entrySet()) { - String key = entry.getKey().toString(); - if (key.startsWith("data.") && !key.equals("data.stamp")) { - out.print(key.substring("data.".length())).print(": ").print(entry.getValue() == null ? "[null]" : entry.getValue().toString()).print(" "); - } - } - out.print(COLUMN_END).print(' ').println(COLUMN_END); - } - - private void printNamedNodes(Node node, NodeClassIterator iter, String prefix, String suffix, String hideSuffix) { - int lastIndex = -1; - while (iter.hasNext()) { - Position pos = iter.nextPosition(); - if (hideSuffix != null && node.getNodeClass().getName(pos).endsWith(hideSuffix)) { - continue; - } - - if (pos.index != lastIndex) { - if (lastIndex != -1) { - out.print(suffix); - } - out.print(prefix).print(node.getNodeClass().getName(pos)).print(": "); - lastIndex = pos.index; - } - out.print(nodeToString(node.getNodeClass().get(node, pos))).print(" "); - } - if (lastIndex != -1) { - out.print(suffix); - } - } - - private String stateToString(FrameState state) { - StringBuilder buf = new StringBuilder(); - FrameState curState = state; - do { - buf.append(CiUtil.toLocation(curState.method(), curState.bci)).append('\n'); - - if (curState.stackSize() > 0) { - buf.append("stack: "); - for (int i = 0; i < curState.stackSize(); i++) { - buf.append(stateValueToString(curState.stackAt(i))).append(' '); - } - buf.append("\n"); - } - - if (curState.locksSize() > 0) { - buf.append("locks: "); - for (int i = 0; i < curState.locksSize(); ++i) { - buf.append(stateValueToString(curState.lockAt(i))).append(' '); - } - buf.append("\n"); - } - - buf.append("locals: "); - for (int i = 0; i < curState.localsSize(); i++) { - buf.append(stateValueToString(curState.localAt(i))).append(' '); - } - buf.append("\n"); - - curState = curState.outerFrameState(); - } while (curState != null); - - return buf.toString(); - } - - private String stateValueToString(ValueNode value) { - String result = nodeToString(value); - if (value != null) { - CiValue operand = compilation.operand(value); - if (operand != null) { - result += ": " + operand; - } - } - return result; - } - - /** - * Prints the LIR for each instruction in a given block. - * - * @param block the block to print - */ - private void printLIR(LIRBlock block) { - List<LIRInstruction> lir = block.lir(); - if (lir == null) { - return; - } - - begin("IR"); - out.println("LIR"); - - if (block.phis != null) { - CiValue[] results = block.phis.results(); - for (int i = 0; i < results.length; i++) { - out.print("instruction PHI ").print(results[i].toString()).print(" = ("); - String sep = ""; - for (LIRBlock pred : block.getLIRPredecessors()) { - out.print(sep).print(block.phis.inputs(pred)[i].toString()); - sep = ", "; - } - out.print(")").print(COLUMN_END).println(COLUMN_END); - } - } - - for (int i = 0; i < lir.size(); i++) { - LIRInstruction inst = lir.get(i); - out.printf("nr %4d ", inst.id()).print(COLUMN_END); - - if (inst.info != null) { - int level = out.indentationLevel(); - out.adjustIndentation(-level); - String state; - if (inst.info.hasDebugInfo()) { - state = debugInfoToString(inst.info.debugInfo().codePos, inst.info.debugInfo().registerRefMap, inst.info.debugInfo().frameRefMap, target.arch); - } else { - state = debugInfoToString(inst.info.topFrame, null, null, target.arch); - } - if (state != null) { - out.print(" st ").print(HOVER_START).print("st").print(HOVER_SEP).print(state).print(HOVER_END).print(COLUMN_END); - } - out.adjustIndentation(level); - } - - out.print(" instruction ").print(inst.toString()).print(COLUMN_END); - out.println(COLUMN_END); - } - end("IR"); - } - - private String nodeToString(Node node) { - if (node == null) { - return "-"; - } - String prefix; - if (node instanceof BeginNode && compilation != null && compilation.lir() == null) { - prefix = "B"; - } else if (node instanceof ValueNode) { - ValueNode value = (ValueNode) node; - if (value.kind() == CiKind.Illegal) { - prefix = "v"; - } else { - prefix = String.valueOf(value.kind().typeChar); - } - } else { - prefix = "?"; - } - return prefix + node.toString(Verbosity.Id); - } - - private String blockToString(Block block) { - if (compilation != null && compilation.lir() == null) { - // During all the front-end phases, the block schedule is built only for the debug output. - // Therefore, the block numbers would be different for every CFG printed -> use the id of the first instruction. - return "B" + block.firstNode().toString(Verbosity.Id); - } else { - // LIR instructions contain references to blocks and these blocks are printed as the blockID -> use the blockID. - return "B" + block.blockID(); - } - } - - - public void printIntervals(String label, Interval[] intervals) { - begin("intervals"); - out.println(String.format("name \"%s\"", label)); - - for (Interval interval : intervals) { - if (interval != null) { - printInterval(interval); - } - } - - end("intervals"); - } - - private void printInterval(Interval interval) { - out.printf("%s %s ", interval.operand, (isRegister(interval.operand) ? "fixed" : interval.kind().name())); - if (isRegister(interval.operand)) { - out.printf("\"[%s|%c]\"", interval.operand, interval.operand.kind.typeChar); - } else { - if (interval.location() != null) { - out.printf("\"[%s|%c]\"", interval.location(), interval.location().kind.typeChar); - } - } - - Interval hint = interval.locationHint(false); - out.printf("%s %s ", interval.splitParent().operand, hint != null ? hint.operand : -1); - - // print ranges - Range cur = interval.first(); - while (cur != Range.EndMarker) { - out.printf("[%d, %d[", cur.from, cur.to); - cur = cur.next; - assert cur != null : "range list not closed with range sentinel"; - } - - // print use positions - int prev = 0; - UsePosList usePosList = interval.usePosList(); - for (int i = usePosList.size() - 1; i >= 0; --i) { - assert prev < usePosList.usePos(i) : "use positions not sorted"; - out.printf("%d %s ", usePosList.usePos(i), usePosList.registerPriority(i)); - prev = usePosList.usePos(i); - } - - out.printf(" \"%s\"", interval.spillState()); - out.println(); - } -}
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/debug/CFGPrinterObserver.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,138 +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. - * - * 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.oracle.max.graal.compiler.debug; - -import java.io.*; -import java.util.*; - -import com.oracle.max.criutils.*; -import com.oracle.max.graal.compiler.*; -import com.oracle.max.graal.compiler.alloc.*; -import com.oracle.max.graal.compiler.graphbuilder.*; -import com.oracle.max.graal.compiler.lir.*; -import com.oracle.max.graal.compiler.observer.*; -import com.oracle.max.graal.compiler.schedule.*; -import com.oracle.max.graal.graph.*; -import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; - -/** - * Observes compilation events and uses {@link CFGPrinter} to produce a control flow graph for the <a - * href="http://java.net/projects/c1visualizer/">C1 Visualizer</a>. - */ -public class CFGPrinterObserver implements CompilationObserver { - - /** - * A thread local stack of {@link CFGPrinter}s to support thread-safety and re-entrant compilation. - */ - private ThreadLocal<LinkedList<CFGPrinter>> observations = new ThreadLocal<LinkedList<CFGPrinter>>() { - @Override - protected java.util.LinkedList<CFGPrinter> initialValue() { - return new LinkedList<>(); - } - }; - - @Override - public void compilationStarted(GraalCompilation compilation) { - if (TTY.isSuppressed()) { - return; - } - - CFGPrinter cfgPrinter = new CFGPrinter(new ByteArrayOutputStream(), compilation); - cfgPrinter.printCompilation(compilation.method); - observations.get().push(cfgPrinter); - } - - @Override - public void compilationEvent(CompilationEvent event) { - if (TTY.isSuppressed()) { - return; - } - CFGPrinter cfgPrinter = observations.get().peek(); - if (cfgPrinter == null) { - return; - } - - RiRuntime runtime = cfgPrinter.runtime; - BlockMap blockMap = event.debugObject(BlockMap.class); - Graph graph = event.debugObject(Graph.class); - IdentifyBlocksPhase schedule = event.debugObject(IdentifyBlocksPhase.class); - LIR lir = event.debugObject(LIR.class); - LinearScan allocator = event.debugObject(LinearScan.class); - Interval[] intervals = event.debugObject(Interval[].class); - CiTargetMethod targetMethod = event.debugObject(CiTargetMethod.class); - - if (blockMap != null) { - cfgPrinter.printCFG(event.label, blockMap); - cfgPrinter.printBytecodes(runtime.disassemble(blockMap.method)); - } - if (lir != null) { - cfgPrinter.printCFG(event.label, lir.codeEmittingOrder(), graph != null); - if (targetMethod != null) { - cfgPrinter.printMachineCode(runtime.disassemble(targetMethod), null); - } - } else if (graph != null) { - List<? extends Block> blocks = null; - if (schedule == null) { - try { - schedule = new IdentifyBlocksPhase(true, LIRBlock.FACTORY); - schedule.apply((StructuredGraph) graph, false); - blocks = schedule.getBlocks(); - - ComputeLinearScanOrder clso = new ComputeLinearScanOrder(schedule.getBlocks().size(), schedule.loopCount(), (LIRBlock) schedule.getStartBlock()); - blocks = clso.codeEmittingOrder(); - } catch (Throwable t) { - // nothing to do here... - } - } - if (blocks != null) { - cfgPrinter.printCFG(event.label, blocks, true); - } - } - if (allocator != null && intervals != null) { - cfgPrinter.printIntervals(event.label, intervals); - } - } - - @Override - public void compilationFinished(GraalCompilation compilation) { - if (TTY.isSuppressed()) { - return; - } - CFGPrinter cfgPrinter = observations.get().pop(); - cfgPrinter.flush(); - - OutputStream stream = CompilationPrinter.globalOut(); - if (stream != null) { - synchronized (stream) { - try { - stream.write(cfgPrinter.buffer.toByteArray()); - stream.flush(); - } catch (IOException e) { - TTY.println("WARNING: Error writing CFGPrinter output: %s", e); - } - } - } - } -}
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/debug/IdealGraphPrinter.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,419 +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. - * - * 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.oracle.max.graal.compiler.debug; - -import java.io.*; -import java.util.*; -import java.util.Map.Entry; - -import com.oracle.max.graal.compiler.*; -import com.oracle.max.graal.compiler.debug.BasicIdealGraphPrinter.Edge; -import com.oracle.max.graal.compiler.schedule.*; -import com.oracle.max.graal.compiler.util.*; -import com.oracle.max.graal.compiler.util.LoopUtil.Loop; -import com.oracle.max.graal.graph.*; -import com.oracle.max.graal.graph.Node.Verbosity; -import com.oracle.max.graal.graph.NodeClass.NodeClassIterator; -import com.oracle.max.graal.graph.NodeClass.Position; -import com.oracle.max.graal.nodes.*; -import com.oracle.max.graal.nodes.loop.*; -import com.sun.cri.bytecode.*; -import com.sun.cri.ri.*; - -/** - * Generates a representation of {@link Graph Graphs} that can be visualized and inspected with the <a - * href="http://kenai.com/projects/igv">Ideal Graph Visualizer</a>. - */ -public class IdealGraphPrinter { - - private final BasicIdealGraphPrinter printer; - private final HashSet<Class<?>> omittedClasses = new HashSet<>(); - private final Set<Node> noBlockNodes = new HashSet<>(); - - /** - * Creates a new {@link IdealGraphPrinter} that writes to the specified output stream. - */ - public IdealGraphPrinter(OutputStream stream) { - this.printer = new BasicIdealGraphPrinter(stream); - } - - /** - * Adds a node class that is omitted in the output. - */ - public void addOmittedClass(Class<?> clazz) { - omittedClasses.add(clazz); - } - - /** - * Flushes any buffered output. - */ - public void flush() { - printer.flush(); - } - - /** - * Starts a new graph document. - */ - public void begin() { - printer.begin(); - } - - /** - * Starts a new group of graphs with the given name, short name and method byte code index (BCI) as properties. - */ - public void beginGroup(String name, String shortName, RiResolvedMethod method, int bci, String origin) { - printer.beginGroup(); - printer.beginProperties(); - printer.printProperty("name", name); - printer.printProperty("origin", origin); - printer.endProperties(); - printer.beginMethod(name, shortName, bci); - if (GraalOptions.PrintIdealGraphBytecodes && method != null) { - printer.beginBytecodes(); - BytecodeStream bytecodes = new BytecodeStream(method.code()); - while (bytecodes.currentBC() != Bytecodes.END) { - int startBCI = bytecodes.currentBCI(); - String mnemonic = Bytecodes.nameOf(bytecodes.currentBC()); - int[] extra = null; - if (bytecodes.nextBCI() > startBCI + 1) { - extra = new int[bytecodes.nextBCI() - (startBCI + 1)]; - for (int i = 0; i < extra.length; i++) { - extra[i] = bytecodes.readUByte(startBCI + 1 + i); - } - } - printer.printBytecode(startBCI, mnemonic, extra); - bytecodes.next(); - } - printer.endBytecodes(); - } - printer.endMethod(); - } - - /** - * Ends the current group. - */ - public void endGroup() { - printer.endGroup(); - } - - /** - * Finishes the graph document and flushes the output stream. - */ - public void end() { - printer.end(); - } - - public void print(Graph graph, String title, boolean shortNames) { - print(graph, title, shortNames, null); - } - - /** - * Prints an entire {@link Graph} with the specified title, optionally using short names for nodes. - */ - public void print(Graph graph, String title, boolean shortNames, IdentifyBlocksPhase predefinedSchedule) { - printer.beginGraph(title); - noBlockNodes.clear(); - IdentifyBlocksPhase schedule = predefinedSchedule; - if (schedule == null) { - try { - schedule = new IdentifyBlocksPhase(true); - schedule.apply((StructuredGraph) graph, false); - } catch (Throwable t) { - // nothing to do here... - } - } - List<Loop> loops = null; - try { - loops = LoopUtil.computeLoops((StructuredGraph) graph); - // loop.nodes() does some more calculations which may fail, so execute this here as well (result is cached) - if (loops != null) { - for (Loop loop : loops) { - loop.nodes(); - } - } - } catch (Throwable t) { - t.printStackTrace(); - loops = null; - } - - printer.beginNodes(); - List<Edge> edges = printNodes(graph, shortNames, schedule == null ? null : schedule.getNodeToBlock(), loops); - printer.endNodes(); - - printer.beginEdges(); - for (Edge edge : edges) { - printer.printEdge(edge); - } - printer.endEdges(); - - if (schedule != null) { - printer.beginControlFlow(); - for (Block block : schedule.getBlocks()) { - printBlock(graph, block, schedule.getNodeToBlock()); - } - printNoBlock(); - printer.endControlFlow(); - } - - printer.endGraph(); - flush(); - } - - private List<Edge> printNodes(Graph graph, boolean shortNames, NodeMap<Block> nodeToBlock, List<Loop> loops) { - ArrayList<Edge> edges = new ArrayList<>(); - NodeBitMap loopExits = graph.createNodeBitMap(); - if (loops != null) { - for (Loop loop : loops) { - loopExits.setUnion(loop.exits()); - } - } - - NodeMap<Set<Entry<String, Integer>>> colors = graph.createNodeMap(); - NodeMap<Set<Entry<String, String>>> colorsToString = graph.createNodeMap(); - NodeMap<Set<String>> bits = graph.createNodeMap(); -// TODO This code was never reachable, since there was no code putting a NodeMap or NodeBitMap into the debugObjects. -// If you need to reactivate this code, put the mapping from names to values into a helper object and register it in the new debugObjects array. -// -// if (debugObjects != null) { -// for (Entry<String, Object> entry : debugObjects.entrySet()) { -// String name = entry.getKey(); -// Object obj = entry.getValue(); -// if (obj instanceof NodeMap) { -// Map<Object, Integer> colorNumbers = new HashMap<Object, Integer>(); -// int nextColor = 0; -// NodeMap<?> map = (NodeMap<?>) obj; -// for (Entry<Node, ?> mapEntry : map.entries()) { -// Node node = mapEntry.getKey(); -// Object color = mapEntry.getValue(); -// Integer colorNumber = colorNumbers.get(color); -// if (colorNumber == null) { -// colorNumber = nextColor++; -// colorNumbers.put(color, colorNumber); -// } -// Set<Entry<String, Integer>> nodeColors = colors.get(node); -// if (nodeColors == null) { -// nodeColors = new HashSet<Entry<String, Integer>>(); -// colors.put(node, nodeColors); -// } -// nodeColors.add(new SimpleImmutableEntry<String, Integer>(name + "Color", colorNumber)); -// Set<Entry<String, String>> nodeColorStrings = colorsToString.get(node); -// if (nodeColorStrings == null) { -// nodeColorStrings = new HashSet<Entry<String, String>>(); -// colorsToString.put(node, nodeColorStrings); -// } -// nodeColorStrings.add(new SimpleImmutableEntry<String, String>(name, color.toString())); -// } -// } else if (obj instanceof NodeBitMap) { -// NodeBitMap bitmap = (NodeBitMap) obj; -// for (Node node : bitmap) { -// Set<String> nodeBits = bits.get(node); -// if (nodeBits == null) { -// nodeBits = new HashSet<String>(); -// bits.put(node, nodeBits); -// } -// nodeBits.add(name); -// } -// } -// } -// } - - for (Node node : graph.getNodes()) { - if (omittedClasses.contains(node.getClass())) { - continue; - } - - printer.beginNode(node.toString(Verbosity.Id)); - printer.beginProperties(); - printer.printProperty("idx", node.toString(Verbosity.Id)); - - Map<Object, Object> props = node.getDebugProperties(); - if (!props.containsKey("name") || props.get("name").toString().trim().length() == 0) { - String name; - if (shortNames) { - name = node.toString(Verbosity.Name); - } else { - name = node.toString(); - } - printer.printProperty("name", name); - } - printer.printProperty("class", node.getClass().getSimpleName()); - Block block = nodeToBlock == null ? null : nodeToBlock.get(node); - if (block != null) { - printer.printProperty("block", Integer.toString(block.blockID())); - if (!(node instanceof PhiNode || node instanceof FrameState || node instanceof LocalNode || node instanceof InductionVariableNode) && !block.getInstructions().contains(node)) { - printer.printProperty("notInOwnBlock", "true"); - } - } else { - printer.printProperty("block", "noBlock"); - noBlockNodes.add(node); - } - if (loopExits.isMarked(node)) { - printer.printProperty("loopExit", "true"); - } - StringBuilder sb = new StringBuilder(); - if (loops != null) { - for (Loop loop : loops) { - if (loop.nodes().isMarked(node)) { - if (sb.length() > 0) { - sb.append(", "); - } - sb.append(loop.loopBegin().toString(Verbosity.Id)); - } - } - } - if (sb.length() > 0) { - printer.printProperty("loops", sb.toString()); - } - - Set<Entry<String, Integer>> nodeColors = colors.get(node); - if (nodeColors != null) { - for (Entry<String, Integer> color : nodeColors) { - String name = color.getKey(); - Integer value = color.getValue(); - printer.printProperty(name, Integer.toString(value)); - } - } - Set<Entry<String, String>> nodeColorStrings = colorsToString.get(node); - if (nodeColorStrings != null) { - for (Entry<String, String> color : nodeColorStrings) { - String name = color.getKey(); - String value = color.getValue(); - printer.printProperty(name, value); - } - } - Set<String> nodeBits = bits.get(node); - if (nodeBits != null) { - for (String bit : nodeBits) { - printer.printProperty(bit, "true"); - } - } - - for (Entry<Object, Object> entry : props.entrySet()) { - String key = entry.getKey().toString(); - String value = entry.getValue() == null ? "null" : entry.getValue().toString(); - printer.printProperty(key, value); - } - - printer.endProperties(); - printer.endNode(); - - // successors - int fromIndex = 0; - NodeClassIterator succIter = node.successors().iterator(); - while (succIter.hasNext()) { - Position position = succIter.nextPosition(); - Node successor = node.getNodeClass().get(node, position); - if (successor != null && !omittedClasses.contains(successor.getClass())) { - edges.add(new Edge(node.toString(Verbosity.Id), fromIndex, successor.toString(Verbosity.Id), 0, node.getNodeClass().getName(position))); - } - fromIndex++; - } - - // inputs - int toIndex = 1; - NodeClassIterator inputIter = node.inputs().iterator(); - while (inputIter.hasNext()) { - Position position = inputIter.nextPosition(); - Node input = node.getNodeClass().get(node, position); - if (input != null && !omittedClasses.contains(input.getClass())) { - edges.add(new Edge(input.toString(Verbosity.Id), input.successors().explicitCount(), node.toString(Verbosity.Id), toIndex, node.getNodeClass().getName(position))); - } - toIndex++; - } - } - - return edges; - } - - private void printBlock(Graph graph, Block block, NodeMap<Block> nodeToBlock) { - printer.beginBlock(Integer.toString(block.blockID())); - printer.beginSuccessors(); - for (Block sux : block.getSuccessors()) { - if (sux != null) { - printer.printSuccessor(Integer.toString(sux.blockID())); - } - } - printer.endSuccessors(); - printer.beginBlockNodes(); - - Set<Node> nodes = new HashSet<>(block.getInstructions()); - - if (nodeToBlock != null) { - for (Node n : graph.getNodes()) { - Block blk = nodeToBlock.get(n); - if (blk == block) { - nodes.add(n); - } - } - } - - if (nodes.size() > 0) { - // if this is the first block: add all locals to this block - if (block.getInstructions().size() > 0 && block.getInstructions().get(0) == ((StructuredGraph) graph).start()) { - for (Node node : graph.getNodes()) { - if (node instanceof LocalNode) { - nodes.add(node); - } - } - } - - // add all framestates and phis to their blocks - for (Node node : block.getInstructions()) { - if (node instanceof StateSplit && ((StateSplit) node).stateAfter() != null) { - nodes.add(((StateSplit) node).stateAfter()); - } - if (node instanceof MergeNode) { - for (PhiNode phi : ((MergeNode) node).phis()) { - nodes.add(phi); - } - if (node instanceof LoopBeginNode) { - for (InductionVariableNode iv : ((LoopBeginNode) node).inductionVariables()) { - nodes.add(iv); - } - } - } - } - - for (Node node : nodes) { - if (!omittedClasses.contains(node.getClass())) { - printer.printBlockNode(node.toString(Verbosity.Id)); - } - } - } - printer.endBlockNodes(); - printer.endBlock(); - } - - private void printNoBlock() { - if (!noBlockNodes.isEmpty()) { - printer.beginBlock("noBlock"); - printer.beginBlockNodes(); - for (Node node : noBlockNodes) { - printer.printBlockNode(node.toString(Verbosity.Id)); - } - printer.endBlockNodes(); - printer.endBlock(); - } - } - -}
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/debug/IdealGraphPrinterObserver.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,265 +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. - * - * 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.oracle.max.graal.compiler.debug; - -import java.io.*; -import java.net.*; -import java.util.regex.*; - -import com.oracle.max.criutils.*; -import com.oracle.max.graal.compiler.*; -import com.oracle.max.graal.compiler.observer.*; -import com.oracle.max.graal.compiler.schedule.*; -import com.oracle.max.graal.graph.*; -import com.sun.cri.ri.*; - -/** - * Observes compilation events and uses {@link IdealGraphPrinter} to generate a graph representation that can be - * inspected with the <a href="http://kenai.com/projects/igv">Ideal Graph Visualizer</a>. - */ -public class IdealGraphPrinterObserver implements CompilationObserver { - - private static final Pattern INVALID_CHAR = Pattern.compile("[^A-Za-z0-9_.-]"); - - private final String host; - private final int port; - - private static class PrintingContext { - public IdealGraphPrinter printer; - private OutputStream stream; - private Socket socket; - - } - private final ThreadLocal<PrintingContext> context = new ThreadLocal<PrintingContext>() { - @Override - protected PrintingContext initialValue() { - return new PrintingContext(); - } - }; - - /** - * Creates a new {@link IdealGraphPrinterObserver} that writes output to a file named after the compiled method. - */ - public IdealGraphPrinterObserver() { - this(null, -1); - } - - /** - * Creates a new {@link IdealGraphPrinterObserver} that sends output to a remote IdealGraphVisualizer instance. - */ - public IdealGraphPrinterObserver(String host, int port) { - this.host = host; - this.port = port; - } - - private PrintingContext context() { - return context.get(); - } - - private IdealGraphPrinter printer() { - return context().printer; - } - - private Socket socket() { - return context().socket; - } - - @Override - public void compilationStarted(GraalCompilation compilation) { - openPrinter(compilation, false); - } - - private void openPrinter(GraalCompilation compilation, boolean error) { - assert (context().stream == null && printer() == null); - if ((!TTY.isSuppressed() && GraalOptions.Plot) || (GraalOptions.PlotOnError && error)) { - String name; - if (compilation != null) { - name = compilation.method.holder().name(); - name = name.substring(1, name.length() - 1).replace('/', '.'); - name = name + "." + compilation.method.name(); - } else { - name = "null"; - } - - openPrinter(name, compilation == null ? null : compilation.method); - } - } - - private void openPrinter(String title, RiResolvedMethod method) { - assert (context().stream == null && printer() == null); - if (!TTY.isSuppressed()) { - // Use a filter to suppress a recursive attempt to open a printer - TTY.Filter filter = new TTY.Filter(); - try { - if (host != null) { - openNetworkPrinter(title, method); - } else { - openFilePrinter(title, method); - } - } finally { - filter.remove(); - } - } - } - - private void openFilePrinter(String title, RiResolvedMethod method) { - String filename = title + ".igv.xml"; - filename = INVALID_CHAR.matcher(filename).replaceAll("_"); - - try { - context().stream = new FileOutputStream(filename); - context().printer = new IdealGraphPrinter(context().stream); - printer().begin(); - printer().beginGroup(title, title, method, -1, "Graal"); - } catch (IOException e) { - e.printStackTrace(); - } - } - - public boolean networkAvailable() { - try { - Socket s = new Socket(host, port); - s.setSoTimeout(10); - s.close(); - return true; - } catch (IOException e) { - return false; - } - } - - private void openNetworkPrinter(String title, RiResolvedMethod method) { - try { - context().socket = new Socket(host, port); - if (socket().getInputStream().read() == 'y') { - context().stream = new BufferedOutputStream(socket().getOutputStream(), 0x4000); - } else { - // server currently does not accept any input - socket().close(); - context().socket = null; - return; - } - - context().printer = new IdealGraphPrinter(context().stream); - printer().begin(); - printer().beginGroup(title, title, method, -1, "Graal"); - printer().flush(); - if (socket().getInputStream().read() != 'y') { - // server declines input for this method - socket().close(); - context().socket = null; - context().stream = null; - context().printer = null; - } - } catch (IOException e) { - System.err.println("Error opening connection to " + host + ":" + port + ": " + e); - - if (socket() != null) { - try { - socket().close(); - } catch (IOException ioe) { - } - context().socket = null; - } - context().stream = null; - context().printer = null; - } - } - - @Override - public void compilationEvent(CompilationEvent event) { - boolean lazyStart = false; - if (printer() == null && event.hasDebugObject(CompilationEvent.ERROR)) { - openPrinter(event.debugObject(GraalCompilation.class), true); - lazyStart = true; - } - Graph graph = event.debugObject(Graph.class); - if (printer() != null && graph != null) { - printer().print(graph, event.label, true, event.debugObject(IdentifyBlocksPhase.class)); - } - if (lazyStart && printer() != null) { - closePrinter(); - } - } - - @Override - public void compilationFinished(GraalCompilation compilation) { - if (printer() != null) { - closePrinter(); - } - } - - private void closePrinter() { - assert (printer() != null); - - try { - printer().endGroup(); - printer().end(); - - if (socket() != null) { - socket().close(); // also closes stream - } else { - context().stream.close(); - } - } catch (IOException e) { - e.printStackTrace(); - } finally { - context().printer = null; - context().stream = null; - context().socket = null; - } - } - - public void printGraphs(String groupTitle, Graph... graphs) { - openPrinter(groupTitle, null); - if (printer() != null) { - int i = 0; - for (Graph graph : graphs) { - printer().print(graph, "Graph " + i, true); - i++; - } - closePrinter(); - } - } - - public void compilationStarted(String groupTitle) { - openPrinter(groupTitle, null); - } - - public void printGraph(String graphTitle, Graph graph) { - if (printer() != null) { - printer().print(graph, graphTitle, true); - } - } - - public void printSingleGraph(String title, Graph graph) { - printSingleGraph(title, title, graph); - } - - public void printSingleGraph(String groupTitle, String graphTitle, Graph graph) { - openPrinter(groupTitle, null); - if (printer() != null) { - printer().print(graph, graphTitle, true); - closePrinter(); - } - } -}
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/debug/InstructionPrinter.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,139 +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. - * - * 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.oracle.max.graal.compiler.debug; - -import static com.oracle.max.graal.compiler.debug.InstructionPrinter.InstructionLineColumn.*; - -import com.oracle.max.criutils.*; -import com.oracle.max.graal.nodes.*; - -/** - * A {@link ValueVisitor} for {@linkplain #printInstruction(ValueNode) printing} - * an {@link FixedWithNextNode} as an expression or statement. - */ -public class InstructionPrinter { - - - /** - * The columns printed in a tabulated instruction - * {@linkplain InstructionPrinter#printInstructionListing(ValueNode) listing}. - */ - public enum InstructionLineColumn { - /** - * The instruction's bytecode index. - */ - BCI(2, "bci"), - - /** - * The instruction's use count. - */ - USE(7, "use"), - - /** - * The instruction as a {@linkplain com.oracle.max.graal.compiler.util.Util#valueString(com.oracle.max.graal.compiler.ir.Value) value}. - */ - VALUE(12, "tid"), - - /** - * The instruction formatted as an expression or statement. - */ - INSTRUCTION(19, "instr"), - - END(60, ""); - - final int position; - final String label; - - private InstructionLineColumn(int position, String label) { - this.position = position; - this.label = label; - } - - /** - * Prints this column's label to a given stream after padding the stream with '_' characters - * until its {@linkplain LogStream#position() position} is equal to this column's position. - * @param out the print stream - */ - public void printLabel(LogStream out) { - out.fillTo(position + out.indentationLevel(), '_'); - out.print(label); - } - - /** - * Prints space characters to a given stream until its {@linkplain LogStream#position() position} - * is equal to this column's position. - * @param out the print stream - */ - public void advance(LogStream out) { - out.fillTo(position + out.indentationLevel(), ' '); - } - } - - private final LogStream out; - - public InstructionPrinter(LogStream out) { - this.out = out; - } - - public LogStream out() { - return out; - } - - /** - * Prints a header for the tabulated data printed by {@link #printInstructionListing(ValueNode)}. - */ - public void printInstructionListingHeader() { - BCI.printLabel(out); - USE.printLabel(out); - VALUE.printLabel(out); - INSTRUCTION.printLabel(out); - END.printLabel(out); - out.println(); - } - - /** - * Prints an instruction listing on one line. The instruction listing is composed of the - * columns specified by {@link InstructionLineColumn}. - * - * @param instruction the instruction to print - */ - public void printInstructionListing(ValueNode instruction) { - int indentation = out.indentationLevel(); - out.fillTo(BCI.position + indentation, ' '). - print(0). - fillTo(USE.position + indentation, ' '). - print("0"). - fillTo(VALUE.position + indentation, ' '). - print(ValueUtil.valueString(instruction)). - fillTo(INSTRUCTION.position + indentation, ' '); - printInstruction(instruction); - if (instruction instanceof StateSplit) { - out.print(" [state: " + ((StateSplit) instruction).stateAfter() + "]"); - } - out.println(); - } - - public void printInstruction(ValueNode node) { - out.print(node.toString()); - } -}
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/DebugInfoBuilder.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/DebugInfoBuilder.java Tue Jan 03 16:47:02 2012 +0100 @@ -25,12 +25,12 @@ import java.util.*; import java.util.Map.Entry; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.virtual.*; -import com.sun.cri.ci.*; public class DebugInfoBuilder { public final GraalCompilation compilation;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/InstructionPrinter.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,139 @@ +/* + * 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. + * + * 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.oracle.max.graal.compiler.gen; + +import static com.oracle.max.graal.compiler.gen.InstructionPrinter.InstructionLineColumn.*; + +import com.oracle.max.criutils.*; +import com.oracle.max.graal.nodes.*; + +/** + * A {@link ValueVisitor} for {@linkplain #printInstruction(ValueNode) printing} + * an {@link FixedWithNextNode} as an expression or statement. + */ +public class InstructionPrinter { + + + /** + * The columns printed in a tabulated instruction + * {@linkplain InstructionPrinter#printInstructionListing(ValueNode) listing}. + */ + public enum InstructionLineColumn { + /** + * The instruction's bytecode index. + */ + BCI(2, "bci"), + + /** + * The instruction's use count. + */ + USE(7, "use"), + + /** + * The instruction as a {@linkplain com.oracle.max.graal.compiler.util.Util#valueString(com.oracle.max.graal.compiler.ir.Value) value}. + */ + VALUE(12, "tid"), + + /** + * The instruction formatted as an expression or statement. + */ + INSTRUCTION(19, "instr"), + + END(60, ""); + + final int position; + final String label; + + private InstructionLineColumn(int position, String label) { + this.position = position; + this.label = label; + } + + /** + * Prints this column's label to a given stream after padding the stream with '_' characters + * until its {@linkplain LogStream#position() position} is equal to this column's position. + * @param out the print stream + */ + public void printLabel(LogStream out) { + out.fillTo(position + out.indentationLevel(), '_'); + out.print(label); + } + + /** + * Prints space characters to a given stream until its {@linkplain LogStream#position() position} + * is equal to this column's position. + * @param out the print stream + */ + public void advance(LogStream out) { + out.fillTo(position + out.indentationLevel(), ' '); + } + } + + private final LogStream out; + + public InstructionPrinter(LogStream out) { + this.out = out; + } + + public LogStream out() { + return out; + } + + /** + * Prints a header for the tabulated data printed by {@link #printInstructionListing(ValueNode)}. + */ + public void printInstructionListingHeader() { + BCI.printLabel(out); + USE.printLabel(out); + VALUE.printLabel(out); + INSTRUCTION.printLabel(out); + END.printLabel(out); + out.println(); + } + + /** + * Prints an instruction listing on one line. The instruction listing is composed of the + * columns specified by {@link InstructionLineColumn}. + * + * @param instruction the instruction to print + */ + public void printInstructionListing(ValueNode instruction) { + int indentation = out.indentationLevel(); + out.fillTo(BCI.position + indentation, ' '). + print(0). + fillTo(USE.position + indentation, ' '). + print("0"). + fillTo(VALUE.position + indentation, ' '). + print(ValueUtil.valueString(instruction)). + fillTo(INSTRUCTION.position + indentation, ' '); + printInstruction(instruction); + if (instruction instanceof StateSplit) { + out.print(" [state: " + ((StateSplit) instruction).stateAfter() + "]"); + } + out.println(); + } + + public void printInstruction(ValueNode node) { + out.print(node.toString()); + } +}
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/LIRGenerator.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/LIRGenerator.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,20 +22,24 @@ */ package com.oracle.max.graal.compiler.gen; -import static com.oracle.max.cri.intrinsics.MemoryBarriers.*; +import static com.oracle.max.cri.ci.CiCallingConvention.Type.*; +import static com.oracle.max.cri.ci.CiValue.*; +import static com.oracle.max.cri.util.MemoryBarriers.*; import static com.oracle.max.graal.alloc.util.ValueUtil.*; -import static com.sun.cri.ci.CiCallingConvention.Type.*; -import static com.sun.cri.ci.CiValue.*; import java.lang.reflect.*; import java.util.*; import com.oracle.max.asm.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.ri.RiType.*; +import com.oracle.max.cri.xir.*; +import com.oracle.max.cri.xir.CiXirAssembler.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.alloc.*; import com.oracle.max.graal.compiler.alloc.OperandPool.VariableFlag; -import com.oracle.max.graal.compiler.debug.*; import com.oracle.max.graal.compiler.graphbuilder.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.schedule.*; @@ -49,16 +53,6 @@ import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.ri.RiType.Representation; -import com.sun.cri.xir.CiXirAssembler.XirConstant; -import com.sun.cri.xir.CiXirAssembler.XirInstruction; -import com.sun.cri.xir.CiXirAssembler.XirOperand; -import com.sun.cri.xir.CiXirAssembler.XirParameter; -import com.sun.cri.xir.CiXirAssembler.XirRegister; -import com.sun.cri.xir.CiXirAssembler.XirTemp; -import com.sun.cri.xir.*; /** * This class traverses the HIR instructions and generates LIR instructions from them.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/PhiResolver.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/PhiResolver.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.gen; -import static com.sun.cri.ci.CiValue.*; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValue.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; /** * Converts {@link PhiNode} instructions into moves.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/BlockMap.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/BlockMap.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,15 +22,14 @@ */ package com.oracle.max.graal.compiler.graphbuilder; -import static com.sun.cri.bytecode.Bytecodes.*; +import static com.oracle.max.graal.compiler.graphbuilder.Bytecodes.*; import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.bytecode.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * Builds a mapping between bytecodes and basic blocks and builds a conservative control flow
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/BytecodeLookupSwitch.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,76 @@ +/* + * 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. + * + * 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.oracle.max.graal.compiler.graphbuilder; + +/** + * A utility for processing {@link Bytecodes#LOOKUPSWITCH} bytecodes. + */ +class BytecodeLookupSwitch extends BytecodeSwitch { + private static final int OFFSET_TO_NUMBER_PAIRS = 4; + private static final int OFFSET_TO_FIRST_PAIR_MATCH = 8; + private static final int OFFSET_TO_FIRST_PAIR_OFFSET = 12; + private static final int PAIR_SIZE = 8; + + /** + * Constructor for a {@link BytecodeStream}. + * @param stream the {@code BytecodeStream} containing the switch instruction + * @param bci the index in the stream of the switch instruction + */ + public BytecodeLookupSwitch(BytecodeStream stream, int bci) { + super(stream, bci); + } + + /** + * Constructor for a bytecode array. + * @param code the bytecode array containing the switch instruction. + * @param bci the index in the array of the switch instruction + */ + public BytecodeLookupSwitch(byte[] code, int bci) { + super(code, bci); + } + + @Override + public int defaultOffset() { + return readWord(alignedBci); + } + + @Override + public int offsetAt(int i) { + return readWord(alignedBci + OFFSET_TO_FIRST_PAIR_OFFSET + PAIR_SIZE * i); + } + + @Override + public int keyAt(int i) { + return readWord(alignedBci + OFFSET_TO_FIRST_PAIR_MATCH + PAIR_SIZE * i); + } + + @Override + public int numberOfCases() { + return readWord(alignedBci + OFFSET_TO_NUMBER_PAIRS); + } + + @Override + public int size() { + return alignedBci + OFFSET_TO_FIRST_PAIR_MATCH + PAIR_SIZE * numberOfCases() - bci; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/BytecodeStream.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,197 @@ +/* + * 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. + * + * 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.oracle.max.graal.compiler.graphbuilder; + +/** + * A utility class that makes iterating over bytecodes and reading operands + * simpler and less error prone. For example, it handles the {@link Bytecodes#WIDE} instruction + * and wide variants of instructions internally. + */ +public final class BytecodeStream { + + private final byte[] code; + private int opcode; + private int curBCI; + private int nextBCI; + + /** + * Creates a new {@code BytecodeStream} for the specified bytecode. + * @param code the array of bytes that contains the bytecode + */ + public BytecodeStream(byte[] code) { + assert code != null; + this.code = code; + setBCI(0); + } + + /** + * Advances to the next bytecode. + */ + public void next() { + setBCI(nextBCI); + } + + /** + * Gets the next bytecode index (no side-effects). + * @return the next bytecode index + */ + public int nextBCI() { + return nextBCI; + } + + /** + * Gets the current bytecode index. + * @return the current bytecode index + */ + public int currentBCI() { + return curBCI; + } + + /** + * Gets the bytecode index of the end of the code. + * @return the index of the end of the code + */ + public int endBCI() { + return code.length; + } + + /** + * Gets the current opcode. This method will never return the + * {@link Bytecodes#WIDE WIDE} opcode, but will instead + * return the opcode that is modified by the {@code WIDE} opcode. + * @return the current opcode; {@link Bytecodes#END} if at or beyond the end of the code + */ + public int currentBC() { + if (opcode == Bytecodes.WIDE) { + return Bytes.beU1(code, curBCI + 1); + } else { + return opcode; + } + } + + /** + * Reads the index of a local variable for one of the load or store instructions. + * The WIDE modifier is handled internally. + * @return the index of the local variable + */ + public int readLocalIndex() { + // read local variable index for load/store + if (opcode == Bytecodes.WIDE) { + return Bytes.beU2(code, curBCI + 2); + } + return Bytes.beU1(code, curBCI + 1); + } + + /** + * Read the delta for an {@link Bytecodes#IINC} bytecode. + * @return the delta for the {@code IINC} + */ + public int readIncrement() { + // read the delta for the iinc bytecode + if (opcode == Bytecodes.WIDE) { + return Bytes.beS2(code, curBCI + 4); + } + return Bytes.beS1(code, curBCI + 2); + } + + /** + * Read the destination of a {@link Bytecodes#GOTO} or {@code IF} instructions. + * @return the destination bytecode index + */ + public int readBranchDest() { + // reads the destination for a branch bytecode + return curBCI + Bytes.beS2(code, curBCI + 1); + } + + /** + * Read the destination of a {@link Bytecodes#GOTO_W} or {@link Bytecodes#JSR_W} instructions. + * @return the destination bytecode index + */ + public int readFarBranchDest() { + // reads the destination for a wide branch bytecode + return curBCI + Bytes.beS4(code, curBCI + 1); + } + + /** + * Read a signed 4-byte integer from the bytecode stream at the specified bytecode index. + * @param bci the bytecode index + * @return the integer value + */ + public int readInt(int bci) { + // reads a 4-byte signed value + return Bytes.beS4(code, bci); + } + + /** + * Reads an unsigned, 1-byte value from the bytecode stream at the specified bytecode index. + * @param bci the bytecode index + * @return the byte + */ + public int readUByte(int bci) { + return Bytes.beU1(code, bci); + } + + /** + * Reads a constant pool index for the current instruction. + * @return the constant pool index + */ + public char readCPI() { + if (opcode == Bytecodes.LDC) { + return (char) Bytes.beU1(code, curBCI + 1); + } + return (char) Bytes.beU2(code, curBCI + 1); + } + + /** + * Reads a signed, 1-byte value for the current instruction (e.g. BIPUSH). + * @return the byte + */ + public byte readByte() { + return code[curBCI + 1]; + } + + /** + * Reads a signed, 2-byte short for the current instruction (e.g. SIPUSH). + * @return the short value + */ + public short readShort() { + return (short) Bytes.beS2(code, curBCI + 1); + } + + /** + * Sets the bytecode index to the specified value. + * If {@code bci} is beyond the end of the array, {@link #currentBC} will return + * {@link Bytecodes#END} and other methods may throw {@link ArrayIndexOutOfBoundsException}. + * @param bci the new bytecode index + */ + public void setBCI(int bci) { + curBCI = bci; + if (curBCI < code.length) { + opcode = Bytes.beU1(code, bci); + nextBCI = bci + Bytecodes.lengthOf(code, bci); + } else { + opcode = Bytecodes.END; + nextBCI = curBCI; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/BytecodeSwitch.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,139 @@ +/* + * 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. + * + * 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.oracle.max.graal.compiler.graphbuilder; + +/** + * An abstract class that provides the state and methods common to {@link Bytecodes#LOOKUPSWITCH} + * and {@link Bytecodes#TABLESWITCH} instructions. + */ +public abstract class BytecodeSwitch { + /** + * The {@link BytecodeStream} containing bytecode array or {@code null} if {@link #code} is not {@code null}. + */ + private final BytecodeStream stream; + /** + * The bytecode array or {@code null} if {@link #stream} is not {@code null}. + */ + private final byte[] code; + /** + * Index of start of switch instruction. + */ + protected final int bci; + /** + * Index of the start of the additional data for the switch instruction, aligned to a multiple of four from the method start. + */ + protected final int alignedBci; + + /** + * Constructor for a {@link BytecodeStream}. + * @param stream the {@code BytecodeStream} containing the switch instruction + * @param bci the index in the stream of the switch instruction + */ + public BytecodeSwitch(BytecodeStream stream, int bci) { + this.alignedBci = (bci + 4) & 0xfffffffc; + this.stream = stream; + this.code = null; + this.bci = bci; + } + + /** + * Constructor for a bytecode array. + * @param code the bytecode array containing the switch instruction. + * @param bci the index in the array of the switch instruction + */ + public BytecodeSwitch(byte[] code, int bci) { + this.alignedBci = (bci + 4) & 0xfffffffc; + this.stream = null; + this.code = code; + this.bci = bci; + } + + /** + * Gets the current bytecode index. + * @return the current bytecode index + */ + public int bci() { + return bci; + } + + /** + * Gets the index of the instruction denoted by the {@code i}'th switch target. + * @param i index of the switch target + * @return the index of the instruction denoted by the {@code i}'th switch target + */ + public int targetAt(int i) { + return bci + offsetAt(i); + } + + /** + * Gets the index of the instruction for the default switch target. + * @return the index of the instruction for the default switch target + */ + public int defaultTarget() { + return bci + defaultOffset(); + } + + /** + * Gets the offset from the start of the switch instruction to the default switch target. + * @return the offset to the default switch target + */ + public abstract int defaultOffset(); + + /** + * Gets the key at {@code i}'th switch target index. + * @param i the switch target index + * @return the key at {@code i}'th switch target index + */ + public abstract int keyAt(int i); + + /** + * Gets the offset from the start of the switch instruction for the {@code i}'th switch target. + * @param i the switch target index + * @return the offset to the {@code i}'th switch target + */ + public abstract int offsetAt(int i); + + /** + * Gets the number of switch targets. + * @return the number of switch targets + */ + public abstract int numberOfCases(); + + /** + * Gets the total size in bytes of the switch instruction. + * @return the total size in bytes of the switch instruction + */ + public abstract int size(); + + /** + * Reads the signed value at given bytecode index. + * @param readBci the start index of the value to retrieve + * @return the signed, 4-byte value in the bytecode array starting at {@code bci} + */ + protected int readWord(int readBci) { + if (code != null) { + return Bytes.beS4(code, readBci); + } + return stream.readInt(readBci); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/BytecodeTableSwitch.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,92 @@ +/* + * 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. + * + * 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.oracle.max.graal.compiler.graphbuilder; + +/** + * A utility for processing {@link Bytecodes#TABLESWITCH} bytecodes. + */ +public class BytecodeTableSwitch extends BytecodeSwitch { + private static final int OFFSET_TO_LOW_KEY = 4; + private static final int OFFSET_TO_HIGH_KEY = 8; + private static final int OFFSET_TO_FIRST_JUMP_OFFSET = 12; + private static final int JUMP_OFFSET_SIZE = 4; + + /** + * Constructor for a {@link BytecodeStream}. + * @param stream the {@code BytecodeStream} containing the switch instruction + * @param bci the index in the stream of the switch instruction + */ + public BytecodeTableSwitch(BytecodeStream stream, int bci) { + super(stream, bci); + } + + /** + * Constructor for a bytecode array. + * @param code the bytecode array containing the switch instruction. + * @param bci the index in the array of the switch instruction + */ + public BytecodeTableSwitch(byte[] code, int bci) { + super(code, bci); + } + + /** + * Gets the low key of the table switch. + * @return the low key + */ + public int lowKey() { + return readWord(alignedBci + OFFSET_TO_LOW_KEY); + } + + /** + * Gets the high key of the table switch. + * @return the high key + */ + public int highKey() { + return readWord(alignedBci + OFFSET_TO_HIGH_KEY); + } + + @Override + public int keyAt(int i) { + return lowKey() + i; + } + + @Override + public int defaultOffset() { + return readWord(alignedBci); + } + + @Override + public int offsetAt(int i) { + return readWord(alignedBci + OFFSET_TO_FIRST_JUMP_OFFSET + JUMP_OFFSET_SIZE * i); + } + + @Override + public int numberOfCases() { + return highKey() - lowKey() + 1; + } + + @Override + public int size() { + return alignedBci + OFFSET_TO_FIRST_JUMP_OFFSET + JUMP_OFFSET_SIZE * numberOfCases() - bci; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/Bytecodes.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,961 @@ +/* + * 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. + * + * 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.oracle.max.graal.compiler.graphbuilder; + +import static com.oracle.max.graal.compiler.graphbuilder.Bytecodes.Flags.*; + +import java.io.*; +import java.lang.reflect.*; +import java.util.regex.*; + +/** + * The definitions of the bytecodes that are valid input to the compiler and + * related utility methods. This comprises two groups: the standard Java + * bytecodes defined by <a href= + * "http://java.sun.com/docs/books/jvms/second_edition/html/VMSpecTOC.doc.html"> + * Java Virtual Machine Specification</a>, and a set of <i>extended</i> + * bytecodes that support low-level programming, for example, memory barriers. + * + * The extended bytecodes are one or three bytes in size. The one-byte bytecodes + * follow the values in the standard set, with no gap. The three-byte extended + * bytecodes share a common first byte and carry additional instruction-specific + * information in the second and third bytes. + */ +public class Bytecodes { + public static final int NOP = 0; // 0x00 + public static final int ACONST_NULL = 1; // 0x01 + public static final int ICONST_M1 = 2; // 0x02 + public static final int ICONST_0 = 3; // 0x03 + public static final int ICONST_1 = 4; // 0x04 + public static final int ICONST_2 = 5; // 0x05 + public static final int ICONST_3 = 6; // 0x06 + public static final int ICONST_4 = 7; // 0x07 + public static final int ICONST_5 = 8; // 0x08 + public static final int LCONST_0 = 9; // 0x09 + public static final int LCONST_1 = 10; // 0x0A + public static final int FCONST_0 = 11; // 0x0B + public static final int FCONST_1 = 12; // 0x0C + public static final int FCONST_2 = 13; // 0x0D + public static final int DCONST_0 = 14; // 0x0E + public static final int DCONST_1 = 15; // 0x0F + public static final int BIPUSH = 16; // 0x10 + public static final int SIPUSH = 17; // 0x11 + public static final int LDC = 18; // 0x12 + public static final int LDC_W = 19; // 0x13 + public static final int LDC2_W = 20; // 0x14 + public static final int ILOAD = 21; // 0x15 + public static final int LLOAD = 22; // 0x16 + public static final int FLOAD = 23; // 0x17 + public static final int DLOAD = 24; // 0x18 + public static final int ALOAD = 25; // 0x19 + public static final int ILOAD_0 = 26; // 0x1A + public static final int ILOAD_1 = 27; // 0x1B + public static final int ILOAD_2 = 28; // 0x1C + public static final int ILOAD_3 = 29; // 0x1D + public static final int LLOAD_0 = 30; // 0x1E + public static final int LLOAD_1 = 31; // 0x1F + public static final int LLOAD_2 = 32; // 0x20 + public static final int LLOAD_3 = 33; // 0x21 + public static final int FLOAD_0 = 34; // 0x22 + public static final int FLOAD_1 = 35; // 0x23 + public static final int FLOAD_2 = 36; // 0x24 + public static final int FLOAD_3 = 37; // 0x25 + public static final int DLOAD_0 = 38; // 0x26 + public static final int DLOAD_1 = 39; // 0x27 + public static final int DLOAD_2 = 40; // 0x28 + public static final int DLOAD_3 = 41; // 0x29 + public static final int ALOAD_0 = 42; // 0x2A + public static final int ALOAD_1 = 43; // 0x2B + public static final int ALOAD_2 = 44; // 0x2C + public static final int ALOAD_3 = 45; // 0x2D + public static final int IALOAD = 46; // 0x2E + public static final int LALOAD = 47; // 0x2F + public static final int FALOAD = 48; // 0x30 + public static final int DALOAD = 49; // 0x31 + public static final int AALOAD = 50; // 0x32 + public static final int BALOAD = 51; // 0x33 + public static final int CALOAD = 52; // 0x34 + public static final int SALOAD = 53; // 0x35 + public static final int ISTORE = 54; // 0x36 + public static final int LSTORE = 55; // 0x37 + public static final int FSTORE = 56; // 0x38 + public static final int DSTORE = 57; // 0x39 + public static final int ASTORE = 58; // 0x3A + public static final int ISTORE_0 = 59; // 0x3B + public static final int ISTORE_1 = 60; // 0x3C + public static final int ISTORE_2 = 61; // 0x3D + public static final int ISTORE_3 = 62; // 0x3E + public static final int LSTORE_0 = 63; // 0x3F + public static final int LSTORE_1 = 64; // 0x40 + public static final int LSTORE_2 = 65; // 0x41 + public static final int LSTORE_3 = 66; // 0x42 + public static final int FSTORE_0 = 67; // 0x43 + public static final int FSTORE_1 = 68; // 0x44 + public static final int FSTORE_2 = 69; // 0x45 + public static final int FSTORE_3 = 70; // 0x46 + public static final int DSTORE_0 = 71; // 0x47 + public static final int DSTORE_1 = 72; // 0x48 + public static final int DSTORE_2 = 73; // 0x49 + public static final int DSTORE_3 = 74; // 0x4A + public static final int ASTORE_0 = 75; // 0x4B + public static final int ASTORE_1 = 76; // 0x4C + public static final int ASTORE_2 = 77; // 0x4D + public static final int ASTORE_3 = 78; // 0x4E + public static final int IASTORE = 79; // 0x4F + public static final int LASTORE = 80; // 0x50 + public static final int FASTORE = 81; // 0x51 + public static final int DASTORE = 82; // 0x52 + public static final int AASTORE = 83; // 0x53 + public static final int BASTORE = 84; // 0x54 + public static final int CASTORE = 85; // 0x55 + public static final int SASTORE = 86; // 0x56 + public static final int POP = 87; // 0x57 + public static final int POP2 = 88; // 0x58 + public static final int DUP = 89; // 0x59 + public static final int DUP_X1 = 90; // 0x5A + public static final int DUP_X2 = 91; // 0x5B + public static final int DUP2 = 92; // 0x5C + public static final int DUP2_X1 = 93; // 0x5D + public static final int DUP2_X2 = 94; // 0x5E + public static final int SWAP = 95; // 0x5F + public static final int IADD = 96; // 0x60 + public static final int LADD = 97; // 0x61 + public static final int FADD = 98; // 0x62 + public static final int DADD = 99; // 0x63 + public static final int ISUB = 100; // 0x64 + public static final int LSUB = 101; // 0x65 + public static final int FSUB = 102; // 0x66 + public static final int DSUB = 103; // 0x67 + public static final int IMUL = 104; // 0x68 + public static final int LMUL = 105; // 0x69 + public static final int FMUL = 106; // 0x6A + public static final int DMUL = 107; // 0x6B + public static final int IDIV = 108; // 0x6C + public static final int LDIV = 109; // 0x6D + public static final int FDIV = 110; // 0x6E + public static final int DDIV = 111; // 0x6F + public static final int IREM = 112; // 0x70 + public static final int LREM = 113; // 0x71 + public static final int FREM = 114; // 0x72 + public static final int DREM = 115; // 0x73 + public static final int INEG = 116; // 0x74 + public static final int LNEG = 117; // 0x75 + public static final int FNEG = 118; // 0x76 + public static final int DNEG = 119; // 0x77 + public static final int ISHL = 120; // 0x78 + public static final int LSHL = 121; // 0x79 + public static final int ISHR = 122; // 0x7A + public static final int LSHR = 123; // 0x7B + public static final int IUSHR = 124; // 0x7C + public static final int LUSHR = 125; // 0x7D + public static final int IAND = 126; // 0x7E + public static final int LAND = 127; // 0x7F + public static final int IOR = 128; // 0x80 + public static final int LOR = 129; // 0x81 + public static final int IXOR = 130; // 0x82 + public static final int LXOR = 131; // 0x83 + public static final int IINC = 132; // 0x84 + public static final int I2L = 133; // 0x85 + public static final int I2F = 134; // 0x86 + public static final int I2D = 135; // 0x87 + public static final int L2I = 136; // 0x88 + public static final int L2F = 137; // 0x89 + public static final int L2D = 138; // 0x8A + public static final int F2I = 139; // 0x8B + public static final int F2L = 140; // 0x8C + public static final int F2D = 141; // 0x8D + public static final int D2I = 142; // 0x8E + public static final int D2L = 143; // 0x8F + public static final int D2F = 144; // 0x90 + public static final int I2B = 145; // 0x91 + public static final int I2C = 146; // 0x92 + public static final int I2S = 147; // 0x93 + public static final int LCMP = 148; // 0x94 + public static final int FCMPL = 149; // 0x95 + public static final int FCMPG = 150; // 0x96 + public static final int DCMPL = 151; // 0x97 + public static final int DCMPG = 152; // 0x98 + public static final int IFEQ = 153; // 0x99 + public static final int IFNE = 154; // 0x9A + public static final int IFLT = 155; // 0x9B + public static final int IFGE = 156; // 0x9C + public static final int IFGT = 157; // 0x9D + public static final int IFLE = 158; // 0x9E + public static final int IF_ICMPEQ = 159; // 0x9F + public static final int IF_ICMPNE = 160; // 0xA0 + public static final int IF_ICMPLT = 161; // 0xA1 + public static final int IF_ICMPGE = 162; // 0xA2 + public static final int IF_ICMPGT = 163; // 0xA3 + public static final int IF_ICMPLE = 164; // 0xA4 + public static final int IF_ACMPEQ = 165; // 0xA5 + public static final int IF_ACMPNE = 166; // 0xA6 + public static final int GOTO = 167; // 0xA7 + public static final int JSR = 168; // 0xA8 + public static final int RET = 169; // 0xA9 + public static final int TABLESWITCH = 170; // 0xAA + public static final int LOOKUPSWITCH = 171; // 0xAB + public static final int IRETURN = 172; // 0xAC + public static final int LRETURN = 173; // 0xAD + public static final int FRETURN = 174; // 0xAE + public static final int DRETURN = 175; // 0xAF + public static final int ARETURN = 176; // 0xB0 + public static final int RETURN = 177; // 0xB1 + public static final int GETSTATIC = 178; // 0xB2 + public static final int PUTSTATIC = 179; // 0xB3 + public static final int GETFIELD = 180; // 0xB4 + public static final int PUTFIELD = 181; // 0xB5 + public static final int INVOKEVIRTUAL = 182; // 0xB6 + public static final int INVOKESPECIAL = 183; // 0xB7 + public static final int INVOKESTATIC = 184; // 0xB8 + public static final int INVOKEINTERFACE = 185; // 0xB9 + public static final int XXXUNUSEDXXX = 186; // 0xBA + public static final int NEW = 187; // 0xBB + public static final int NEWARRAY = 188; // 0xBC + public static final int ANEWARRAY = 189; // 0xBD + public static final int ARRAYLENGTH = 190; // 0xBE + public static final int ATHROW = 191; // 0xBF + public static final int CHECKCAST = 192; // 0xC0 + public static final int INSTANCEOF = 193; // 0xC1 + public static final int MONITORENTER = 194; // 0xC2 + public static final int MONITOREXIT = 195; // 0xC3 + public static final int WIDE = 196; // 0xC4 + public static final int MULTIANEWARRAY = 197; // 0xC5 + public static final int IFNULL = 198; // 0xC6 + public static final int IFNONNULL = 199; // 0xC7 + public static final int GOTO_W = 200; // 0xC8 + public static final int JSR_W = 201; // 0xC9 + public static final int BREAKPOINT = 202; // 0xCA + + public static final int ILLEGAL = 255; + public static final int END = 256; + + /** + * The last opcode defined by the JVM specification. To iterate over all JVM bytecodes: + * <pre> + * for (int opcode = 0; opcode <= Bytecodes.LAST_JVM_OPCODE; ++opcode) { + * // + * } + * </pre> + */ + public static final int LAST_JVM_OPCODE = JSR_W; + + /** + * A collection of flags describing various bytecode attributes. + */ + static class Flags { + + /** + * Denotes an instruction that ends a basic block and does not let control flow fall through to its lexical successor. + */ + static final int STOP = 0x00000001; + + /** + * Denotes an instruction that ends a basic block and may let control flow fall through to its lexical successor. + * In practice this means it is a conditional branch. + */ + static final int FALL_THROUGH = 0x00000002; + + /** + * Denotes an instruction that has a 2 or 4 byte operand that is an offset to another instruction in the same method. + * This does not include the {@link Bytecodes#TABLESWITCH} or {@link Bytecodes#LOOKUPSWITCH} instructions. + */ + static final int BRANCH = 0x00000004; + + /** + * Denotes an instruction that reads the value of a static or instance field. + */ + static final int FIELD_READ = 0x00000008; + + /** + * Denotes an instruction that writes the value of a static or instance field. + */ + static final int FIELD_WRITE = 0x00000010; + + /** + * Denotes an instruction that is not defined in the JVM specification. + */ + static final int EXTENSION = 0x00000020; + + /** + * Denotes an instruction that can cause a trap. + */ + static final int TRAP = 0x00000080; + /** + * Denotes an instruction that is commutative. + */ + static final int COMMUTATIVE = 0x00000100; + /** + * Denotes an instruction that is associative. + */ + static final int ASSOCIATIVE = 0x00000200; + /** + * Denotes an instruction that loads an operand. + */ + static final int LOAD = 0x00000400; + /** + * Denotes an instruction that stores an operand. + */ + static final int STORE = 0x00000800; + /** + * Denotes the 4 INVOKE* instructions. + */ + static final int INVOKE = 0x00001000; + } + + // Performs a sanity check that none of the flags overlap. + static { + int allFlags = 0; + try { + for (Field field : Flags.class.getDeclaredFields()) { + int flagsFilter = Modifier.FINAL | Modifier.STATIC; + if ((field.getModifiers() & flagsFilter) == flagsFilter) { + assert field.getType() == int.class : "Only " + field; + final int flag = field.getInt(null); + assert flag != 0; + assert (flag & allFlags) == 0 : field.getName() + " has a value conflicting with another flag"; + allFlags |= flag; + } + } + } catch (Exception e) { + throw new InternalError(e.toString()); + } + } + + /** + * A array that maps from a bytecode value to a {@link String} for the corresponding instruction mnemonic. + * This will include the root instruction for the three-byte extended instructions. + */ + private static final String[] nameArray = new String[256]; + + /** + * A array that maps from a bytecode value to the set of {@link Flags} for the corresponding instruction. + */ + private static final int[] flagsArray = new int[256]; + + /** + * A array that maps from a bytecode value to the length in bytes for the corresponding instruction. + */ + private static final int[] lengthArray = new int[256]; + + // Checkstyle: stop + static { + def(NOP , "nop" , "b" ); + def(ACONST_NULL , "aconst_null" , "b" ); + def(ICONST_M1 , "iconst_m1" , "b" ); + def(ICONST_0 , "iconst_0" , "b" ); + def(ICONST_1 , "iconst_1" , "b" ); + def(ICONST_2 , "iconst_2" , "b" ); + def(ICONST_3 , "iconst_3" , "b" ); + def(ICONST_4 , "iconst_4" , "b" ); + def(ICONST_5 , "iconst_5" , "b" ); + def(LCONST_0 , "lconst_0" , "b" ); + def(LCONST_1 , "lconst_1" , "b" ); + def(FCONST_0 , "fconst_0" , "b" ); + def(FCONST_1 , "fconst_1" , "b" ); + def(FCONST_2 , "fconst_2" , "b" ); + def(DCONST_0 , "dconst_0" , "b" ); + def(DCONST_1 , "dconst_1" , "b" ); + def(BIPUSH , "bipush" , "bc" ); + def(SIPUSH , "sipush" , "bcc" ); + def(LDC , "ldc" , "bi" , TRAP); + def(LDC_W , "ldc_w" , "bii" , TRAP); + def(LDC2_W , "ldc2_w" , "bii" , TRAP); + def(ILOAD , "iload" , "bi" , LOAD); + def(LLOAD , "lload" , "bi" , LOAD); + def(FLOAD , "fload" , "bi" , LOAD); + def(DLOAD , "dload" , "bi" , LOAD); + def(ALOAD , "aload" , "bi" , LOAD); + def(ILOAD_0 , "iload_0" , "b" , LOAD); + def(ILOAD_1 , "iload_1" , "b" , LOAD); + def(ILOAD_2 , "iload_2" , "b" , LOAD); + def(ILOAD_3 , "iload_3" , "b" , LOAD); + def(LLOAD_0 , "lload_0" , "b" , LOAD); + def(LLOAD_1 , "lload_1" , "b" , LOAD); + def(LLOAD_2 , "lload_2" , "b" , LOAD); + def(LLOAD_3 , "lload_3" , "b" , LOAD); + def(FLOAD_0 , "fload_0" , "b" , LOAD); + def(FLOAD_1 , "fload_1" , "b" , LOAD); + def(FLOAD_2 , "fload_2" , "b" , LOAD); + def(FLOAD_3 , "fload_3" , "b" , LOAD); + def(DLOAD_0 , "dload_0" , "b" , LOAD); + def(DLOAD_1 , "dload_1" , "b" , LOAD); + def(DLOAD_2 , "dload_2" , "b" , LOAD); + def(DLOAD_3 , "dload_3" , "b" , LOAD); + def(ALOAD_0 , "aload_0" , "b" , LOAD); + def(ALOAD_1 , "aload_1" , "b" , LOAD); + def(ALOAD_2 , "aload_2" , "b" , LOAD); + def(ALOAD_3 , "aload_3" , "b" , LOAD); + def(IALOAD , "iaload" , "b" , TRAP); + def(LALOAD , "laload" , "b" , TRAP); + def(FALOAD , "faload" , "b" , TRAP); + def(DALOAD , "daload" , "b" , TRAP); + def(AALOAD , "aaload" , "b" , TRAP); + def(BALOAD , "baload" , "b" , TRAP); + def(CALOAD , "caload" , "b" , TRAP); + def(SALOAD , "saload" , "b" , TRAP); + def(ISTORE , "istore" , "bi" , STORE); + def(LSTORE , "lstore" , "bi" , STORE); + def(FSTORE , "fstore" , "bi" , STORE); + def(DSTORE , "dstore" , "bi" , STORE); + def(ASTORE , "astore" , "bi" , STORE); + def(ISTORE_0 , "istore_0" , "b" , STORE); + def(ISTORE_1 , "istore_1" , "b" , STORE); + def(ISTORE_2 , "istore_2" , "b" , STORE); + def(ISTORE_3 , "istore_3" , "b" , STORE); + def(LSTORE_0 , "lstore_0" , "b" , STORE); + def(LSTORE_1 , "lstore_1" , "b" , STORE); + def(LSTORE_2 , "lstore_2" , "b" , STORE); + def(LSTORE_3 , "lstore_3" , "b" , STORE); + def(FSTORE_0 , "fstore_0" , "b" , STORE); + def(FSTORE_1 , "fstore_1" , "b" , STORE); + def(FSTORE_2 , "fstore_2" , "b" , STORE); + def(FSTORE_3 , "fstore_3" , "b" , STORE); + def(DSTORE_0 , "dstore_0" , "b" , STORE); + def(DSTORE_1 , "dstore_1" , "b" , STORE); + def(DSTORE_2 , "dstore_2" , "b" , STORE); + def(DSTORE_3 , "dstore_3" , "b" , STORE); + def(ASTORE_0 , "astore_0" , "b" , STORE); + def(ASTORE_1 , "astore_1" , "b" , STORE); + def(ASTORE_2 , "astore_2" , "b" , STORE); + def(ASTORE_3 , "astore_3" , "b" , STORE); + def(IASTORE , "iastore" , "b" , TRAP); + def(LASTORE , "lastore" , "b" , TRAP); + def(FASTORE , "fastore" , "b" , TRAP); + def(DASTORE , "dastore" , "b" , TRAP); + def(AASTORE , "aastore" , "b" , TRAP); + def(BASTORE , "bastore" , "b" , TRAP); + def(CASTORE , "castore" , "b" , TRAP); + def(SASTORE , "sastore" , "b" , TRAP); + def(POP , "pop" , "b" ); + def(POP2 , "pop2" , "b" ); + def(DUP , "dup" , "b" ); + def(DUP_X1 , "dup_x1" , "b" ); + def(DUP_X2 , "dup_x2" , "b" ); + def(DUP2 , "dup2" , "b" ); + def(DUP2_X1 , "dup2_x1" , "b" ); + def(DUP2_X2 , "dup2_x2" , "b" ); + def(SWAP , "swap" , "b" ); + def(IADD , "iadd" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(LADD , "ladd" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(FADD , "fadd" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(DADD , "dadd" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(ISUB , "isub" , "b" ); + def(LSUB , "lsub" , "b" ); + def(FSUB , "fsub" , "b" ); + def(DSUB , "dsub" , "b" ); + def(IMUL , "imul" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(LMUL , "lmul" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(FMUL , "fmul" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(DMUL , "dmul" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(IDIV , "idiv" , "b" , TRAP); + def(LDIV , "ldiv" , "b" , TRAP); + def(FDIV , "fdiv" , "b" ); + def(DDIV , "ddiv" , "b" ); + def(IREM , "irem" , "b" , TRAP); + def(LREM , "lrem" , "b" , TRAP); + def(FREM , "frem" , "b" ); + def(DREM , "drem" , "b" ); + def(INEG , "ineg" , "b" ); + def(LNEG , "lneg" , "b" ); + def(FNEG , "fneg" , "b" ); + def(DNEG , "dneg" , "b" ); + def(ISHL , "ishl" , "b" ); + def(LSHL , "lshl" , "b" ); + def(ISHR , "ishr" , "b" ); + def(LSHR , "lshr" , "b" ); + def(IUSHR , "iushr" , "b" ); + def(LUSHR , "lushr" , "b" ); + def(IAND , "iand" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(LAND , "land" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(IOR , "ior" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(LOR , "lor" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(IXOR , "ixor" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(LXOR , "lxor" , "b" , COMMUTATIVE | ASSOCIATIVE); + def(IINC , "iinc" , "bic" , LOAD | STORE); + def(I2L , "i2l" , "b" ); + def(I2F , "i2f" , "b" ); + def(I2D , "i2d" , "b" ); + def(L2I , "l2i" , "b" ); + def(L2F , "l2f" , "b" ); + def(L2D , "l2d" , "b" ); + def(F2I , "f2i" , "b" ); + def(F2L , "f2l" , "b" ); + def(F2D , "f2d" , "b" ); + def(D2I , "d2i" , "b" ); + def(D2L , "d2l" , "b" ); + def(D2F , "d2f" , "b" ); + def(I2B , "i2b" , "b" ); + def(I2C , "i2c" , "b" ); + def(I2S , "i2s" , "b" ); + def(LCMP , "lcmp" , "b" ); + def(FCMPL , "fcmpl" , "b" ); + def(FCMPG , "fcmpg" , "b" ); + def(DCMPL , "dcmpl" , "b" ); + def(DCMPG , "dcmpg" , "b" ); + def(IFEQ , "ifeq" , "boo" , FALL_THROUGH | BRANCH); + def(IFNE , "ifne" , "boo" , FALL_THROUGH | BRANCH); + def(IFLT , "iflt" , "boo" , FALL_THROUGH | BRANCH); + def(IFGE , "ifge" , "boo" , FALL_THROUGH | BRANCH); + def(IFGT , "ifgt" , "boo" , FALL_THROUGH | BRANCH); + def(IFLE , "ifle" , "boo" , FALL_THROUGH | BRANCH); + def(IF_ICMPEQ , "if_icmpeq" , "boo" , COMMUTATIVE | FALL_THROUGH | BRANCH); + def(IF_ICMPNE , "if_icmpne" , "boo" , COMMUTATIVE | FALL_THROUGH | BRANCH); + def(IF_ICMPLT , "if_icmplt" , "boo" , FALL_THROUGH | BRANCH); + def(IF_ICMPGE , "if_icmpge" , "boo" , FALL_THROUGH | BRANCH); + def(IF_ICMPGT , "if_icmpgt" , "boo" , FALL_THROUGH | BRANCH); + def(IF_ICMPLE , "if_icmple" , "boo" , FALL_THROUGH | BRANCH); + def(IF_ACMPEQ , "if_acmpeq" , "boo" , COMMUTATIVE | FALL_THROUGH | BRANCH); + def(IF_ACMPNE , "if_acmpne" , "boo" , COMMUTATIVE | FALL_THROUGH | BRANCH); + def(GOTO , "goto" , "boo" , STOP | BRANCH); + def(JSR , "jsr" , "boo" , STOP | BRANCH); + def(RET , "ret" , "bi" , STOP); + def(TABLESWITCH , "tableswitch" , "" , STOP); + def(LOOKUPSWITCH , "lookupswitch" , "" , STOP); + def(IRETURN , "ireturn" , "b" , TRAP | STOP); + def(LRETURN , "lreturn" , "b" , TRAP | STOP); + def(FRETURN , "freturn" , "b" , TRAP | STOP); + def(DRETURN , "dreturn" , "b" , TRAP | STOP); + def(ARETURN , "areturn" , "b" , TRAP | STOP); + def(RETURN , "return" , "b" , TRAP | STOP); + def(GETSTATIC , "getstatic" , "bjj" , TRAP | FIELD_READ); + def(PUTSTATIC , "putstatic" , "bjj" , TRAP | FIELD_WRITE); + def(GETFIELD , "getfield" , "bjj" , TRAP | FIELD_READ); + def(PUTFIELD , "putfield" , "bjj" , TRAP | FIELD_WRITE); + def(INVOKEVIRTUAL , "invokevirtual" , "bjj" , TRAP | INVOKE); + def(INVOKESPECIAL , "invokespecial" , "bjj" , TRAP | INVOKE); + def(INVOKESTATIC , "invokestatic" , "bjj" , TRAP | INVOKE); + def(INVOKEINTERFACE , "invokeinterface" , "bjja_", TRAP | INVOKE); + def(XXXUNUSEDXXX , "xxxunusedxxx" , "" ); + def(NEW , "new" , "bii" , TRAP); + def(NEWARRAY , "newarray" , "bc" , TRAP); + def(ANEWARRAY , "anewarray" , "bii" , TRAP); + def(ARRAYLENGTH , "arraylength" , "b" , TRAP); + def(ATHROW , "athrow" , "b" , TRAP | STOP); + def(CHECKCAST , "checkcast" , "bii" , TRAP); + def(INSTANCEOF , "instanceof" , "bii" , TRAP); + def(MONITORENTER , "monitorenter" , "b" , TRAP); + def(MONITOREXIT , "monitorexit" , "b" , TRAP); + def(WIDE , "wide" , "" ); + def(MULTIANEWARRAY , "multianewarray" , "biic" , TRAP); + def(IFNULL , "ifnull" , "boo" , FALL_THROUGH | BRANCH); + def(IFNONNULL , "ifnonnull" , "boo" , FALL_THROUGH | BRANCH); + def(GOTO_W , "goto_w" , "boooo", STOP | BRANCH); + def(JSR_W , "jsr_w" , "boooo", STOP | BRANCH); + def(BREAKPOINT , "breakpoint" , "b" , TRAP); + } + // Checkstyle: resume + + /** + * Determines if an opcode is commutative. + * @param opcode the opcode to check + * @return {@code true} iff commutative + */ + public static boolean isCommutative(int opcode) { + return (flagsArray[opcode & 0xff] & COMMUTATIVE) != 0; + } + + /** + * Gets the length of an instruction denoted by a given opcode. + * + * @param opcode an instruction opcode + * @return the length of the instruction denoted by {@code opcode}. If {@code opcode} is an illegal instruction or denotes a + * variable length instruction (e.g. {@link #TABLESWITCH}), then 0 is returned. + */ + public static int lengthOf(int opcode) { + return lengthArray[opcode & 0xff]; + } + + /** + * Gets the length of an instruction at a given position in a given bytecode array. + * This methods handles variable length and {@linkplain #WIDE widened} instructions. + * + * @param code an array of bytecode + * @param bci the position in {@code code} of an instruction's opcode + * @return the length of the instruction at position {@code bci} in {@code code} + */ + public static int lengthOf(byte[] code, int bci) { + int opcode = Bytes.beU1(code, bci); + int length = Bytecodes.lengthArray[opcode & 0xff]; + if (length == 0) { + switch (opcode) { + case TABLESWITCH: { + return new BytecodeTableSwitch(code, bci).size(); + } + case LOOKUPSWITCH: { + return new BytecodeLookupSwitch(code, bci).size(); + } + case WIDE: { + int opc = Bytes.beU1(code, bci + 1); + if (opc == RET) { + return 4; + } else if (opc == IINC) { + return 6; + } else { + return 4; // a load or store bytecode + } + } + default: + throw new Error("unknown variable-length bytecode: " + opcode); + } + } + return length; + } + + /** + * Gets the lower-case mnemonic for a given opcode. + * + * @param opcode an opcode + * @return the mnemonic for {@code opcode} or {@code "<illegal opcode: " + opcode + ">"} if {@code opcode} is not a legal opcode + */ + public static String nameOf(int opcode) throws IllegalArgumentException { + String name = nameArray[opcode & 0xff]; + if (name == null) { + return "<illegal opcode: " + opcode + ">"; + } + return name; + } + + /** + * Allocation-free version of {@linkplain #nameOf(int)}. + * @param opcode an opcode. + * @return the mnemonic for {@code opcode} or {@code "<illegal opcode>"} if {@code opcode} is not a legal opcode. + */ + public static String baseNameOf(int opcode) { + String name = nameArray[opcode & 0xff]; + if (name == null) { + return "<illegal opcode>"; + } + return name; + } + + /** + * Gets the opcode corresponding to a given mnemonic. + * + * @param name an opcode mnemonic + * @return the opcode corresponding to {@code mnemonic} + * @throws IllegalArgumentException if {@code name} does not denote a valid opcode + */ + public static int valueOf(String name) { + for (int opcode = 0; opcode < nameArray.length; ++opcode) { + if (name.equalsIgnoreCase(nameArray[opcode])) { + return opcode; + } + } + throw new IllegalArgumentException("No opcode for " + name); + } + + /** + * Determines if a given opcode denotes an instruction that can cause an implicit exception. + * + * @param opcode an opcode to test + * @return {@code true} iff {@code opcode} can cause an implicit exception, {@code false} otherwise + */ + public static boolean canTrap(int opcode) { + return (flagsArray[opcode & 0xff] & TRAP) != 0; + } + + /** + * Determines if a given opcode denotes an instruction that loads a local variable to the operand stack. + * + * @param opcode an opcode to test + * @return {@code true} iff {@code opcode} loads a local variable to the operand stack, {@code false} otherwise + */ + public static boolean isLoad(int opcode) { + return (flagsArray[opcode & 0xff] & LOAD) != 0; + } + + /** + * Determines if a given opcode denotes an instruction that ends a basic block and does not let control flow fall + * through to its lexical successor. + * + * @param opcode an opcode to test + * @return {@code true} iff {@code opcode} properly ends a basic block + */ + public static boolean isStop(int opcode) { + return (flagsArray[opcode & 0xff] & STOP) != 0; + } + + /** + * Determines if a given opcode denotes an instruction that stores a value to a local variable + * after popping it from the operand stack. + * + * @param opcode an opcode to test + * @return {@code true} iff {@code opcode} stores a value to a local variable, {@code false} otherwise + */ + public static boolean isInvoke(int opcode) { + return (flagsArray[opcode & 0xff] & INVOKE) != 0; + } + + /** + * Determines if a given opcode denotes an instruction that stores a value to a local variable + * after popping it from the operand stack. + * + * @param opcode an opcode to test + * @return {@code true} iff {@code opcode} stores a value to a local variable, {@code false} otherwise + */ + public static boolean isStore(int opcode) { + return (flagsArray[opcode & 0xff] & STORE) != 0; + } + + /** + * Determines if a given opcode is an instruction that delimits a basic block. + * + * @param opcode an opcode to test + * @return {@code true} iff {@code opcode} delimits a basic block + */ + public static boolean isBlockEnd(int opcode) { + return (flagsArray[opcode & 0xff] & (STOP | FALL_THROUGH)) != 0; + } + + /** + * Determines if a given opcode is an instruction that has a 2 or 4 byte operand that is an offset to another + * instruction in the same method. This does not include the {@linkplain #TABLESWITCH switch} instructions. + * + * @param opcode an opcode to test + * @return {@code true} iff {@code opcode} is a branch instruction with a single operand + */ + public static boolean isBranch(int opcode) { + return (flagsArray[opcode & 0xff] & BRANCH) != 0; + } + + /** + * Determines if a given opcode denotes a conditional branch. + * @param opcode + * @return {@code true} iff {@code opcode} is a conditional branch + */ + public static boolean isConditionalBranch(int opcode) { + return (flagsArray[opcode & 0xff] & FALL_THROUGH) != 0; + } + + /** + * Determines if a given opcode denotes a standard bytecode. A standard bytecode is + * defined in the JVM specification. + * + * @param opcode an opcode to test + * @return {@code true} iff {@code opcode} is a standard bytecode + */ + public static boolean isStandard(int opcode) { + return (flagsArray[opcode & 0xff] & EXTENSION) == 0; + } + + /** + * Determines if a given opcode denotes an extended bytecode. + * + * @param opcode an opcode to test + * @return {@code true} if {@code opcode} is an extended bytecode + */ + public static boolean isExtended(int opcode) { + return (flagsArray[opcode & 0xff] & EXTENSION) != 0; + } + + /** + * Determines if a given opcode is a three-byte extended bytecode. + * + * @param opcode an opcode to test + * @return {@code true} if {@code (opcode & ~0xff) != 0} + */ + public static boolean isThreeByteExtended(int opcode) { + return (opcode & ~0xff) != 0; + } + + /** + * Gets the arithmetic operator name for a given opcode. If {@code opcode} does not denote an + * arithmetic instruction, then the {@linkplain #nameOf(int) name} of the opcode is returned + * instead. + * + * @param op an opcode + * @return the arithmetic operator name + */ + public static String operator(int op) { + // Checkstyle: stop + switch (op) { + // arithmetic ops + case IADD : // fall through + case LADD : // fall through + case FADD : // fall through + case DADD : return "+"; + case ISUB : // fall through + case LSUB : // fall through + case FSUB : // fall through + case DSUB : return "-"; + case IMUL : // fall through + case LMUL : // fall through + case FMUL : // fall through + case DMUL : return "*"; + case IDIV : // fall through + case LDIV : // fall through + case FDIV : // fall through + case DDIV : return "/"; + case IREM : // fall through + case LREM : // fall through + case FREM : // fall through + case DREM : return "%"; + // shift ops + case ISHL : // fall through + case LSHL : return "<<"; + case ISHR : // fall through + case LSHR : return ">>"; + case IUSHR: // fall through + case LUSHR: return ">>>"; + // logic ops + case IAND : // fall through + case LAND : return "&"; + case IOR : // fall through + case LOR : return "|"; + case IXOR : // fall through + case LXOR : return "^"; + } + // Checkstyle: resume + return nameOf(op); + } + + /** + * Defines a bytecode by entering it into the arrays that record its name, length and flags. + * + * @param name instruction name (should be lower case) + * @param format encodes the length of the instruction + * @param flagsArray the set of {@link Flags} associated with the instruction + */ + private static void def(int opcode, String name, String format) { + def(opcode, name, format, 0); + } + + /** + * Defines a bytecode by entering it into the arrays that record its name, length and flags. + * + * @param name instruction name (lower case) + * @param format encodes the length of the instruction + * @param flags the set of {@link Flags} associated with the instruction + */ + private static void def(int opcode, String name, String format, int flags) { + assert nameArray[opcode] == null : "opcode " + opcode + " is already bound to name " + nameArray[opcode]; + nameArray[opcode] = name; + int instructionLength = format.length(); + lengthArray[opcode] = instructionLength; + Bytecodes.flagsArray[opcode] = flags; + + assert !isConditionalBranch(opcode) || isBranch(opcode) : "a conditional branch must also be a branch"; + } + + /** + * Utility for ensuring that the extended opcodes are contiguous and follow on directly + * from the standard JVM opcodes. If these conditions do not hold for the input source + * file, then it is modified 'in situ' to fix the problem. + * + * @param args {@code args[0]} is the path to this source file + */ + public static void main(String[] args) throws Exception { + Method findWorkspaceDirectory = Class.forName("com.sun.max.ide.JavaProject").getDeclaredMethod("findWorkspaceDirectory"); + File base = new File((File) findWorkspaceDirectory.invoke(null), "com.oracle.max.cri/src"); + File file = new File(base, Bytecodes.class.getName().replace('.', File.separatorChar) + ".java").getAbsoluteFile(); + + Pattern opcodeDecl = Pattern.compile("(\\s*public static final int )(\\w+)(\\s*=\\s*)(\\d+)(;.*)"); + + BufferedReader br = new BufferedReader(new FileReader(file)); + CharArrayWriter buffer = new CharArrayWriter((int) file.length()); + PrintWriter out = new PrintWriter(buffer); + String line; + int lastExtendedOpcode = BREAKPOINT; + boolean modified = false; + int section = 0; + while ((line = br.readLine()) != null) { + if (section == 0) { + if (line.equals(" // Start extended bytecodes")) { + section = 1; + } + } else if (section == 1) { + if (line.equals(" // End extended bytecodes")) { + section = 2; + } else { + Matcher matcher = opcodeDecl.matcher(line); + if (matcher.matches()) { + String name = matcher.group(2); + String value = matcher.group(4); + int opcode = Integer.parseInt(value); + if (nameArray[opcode] == null || !nameArray[opcode].equalsIgnoreCase(name)) { + throw new RuntimeException("Missing definition of name and flags for " + opcode + ":" + name + " -- " + nameArray[opcode]); + } + if (opcode != lastExtendedOpcode + 1) { + System.err.println("Fixed declaration of opcode " + name + " to be " + (lastExtendedOpcode + 1) + " (was " + value + ")"); + opcode = lastExtendedOpcode + 1; + line = line.substring(0, matcher.start(4)) + opcode + line.substring(matcher.end(4)); + modified = true; + } + + if (opcode >= 256) { + throw new RuntimeException("Exceeded maximum opcode value with " + name); + } + + lastExtendedOpcode = opcode; + } + } + } + + out.println(line); + } + if (section == 0) { + throw new RuntimeException("Did not find line starting extended bytecode declarations:\n\n // Start extended bytecodes"); + } else if (section == 1) { + throw new RuntimeException("Did not find line ending extended bytecode declarations:\n\n // End extended bytecodes"); + } + + if (modified) { + out.flush(); + FileWriter fileWriter = new FileWriter(file); + fileWriter.write(buffer.toCharArray()); + fileWriter.close(); + + System.out.println("Modified: " + file); + } + + + // Uncomment to print out visitor method declarations: +// for (int opcode = 0; opcode < flags.length; ++opcode) { +// if (isExtension(opcode)) { +// String visitorParams = length(opcode) == 1 ? "" : "int index"; +// System.out.println("@Override"); +// System.out.println("protected void " + name(opcode) + "(" + visitorParams + ") {"); +// System.out.println("}"); +// System.out.println(); +// } +// } + + // Uncomment to print out visitor method declarations: +// for (int opcode = 0; opcode < flags.length; ++opcode) { +// if (isExtension(opcode)) { +// System.out.println("case " + name(opcode).toUpperCase() + ": {"); +// String arg = ""; +// int length = length(opcode); +// if (length == 2) { +// arg = "readUnsigned1()"; +// } else if (length == 3) { +// arg = "readUnsigned2()"; +// } +// System.out.println(" bytecodeVisitor." + name(opcode) + "(" + arg + ");"); +// System.out.println(" break;"); +// System.out.println("}"); +// } +// } + + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/Bytes.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,93 @@ +/* + * 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. + * + * 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.oracle.max.graal.compiler.graphbuilder; + +/** + * A collection of utility methods for dealing with bytes, particularly in byte arrays. + */ +public class Bytes { + /** + * Gets a signed 1-byte value. + * @param data the array containing the data + * @param bci the start index of the value to retrieve + * @return the signed 1-byte value at index {@code bci} in array {@code data} + */ + public static int beS1(byte[] data, int bci) { + return data[bci]; + } + + /** + * Gets a signed 2-byte big-endian value. + * @param data the array containing the data + * @param bci the start index of the value to retrieve + * @return the signed 2-byte, big-endian, value at index {@code bci} in array {@code data} + */ + public static int beS2(byte[] data, int bci) { + return (data[bci] << 8) | (data[bci + 1] & 0xff); + } + + /** + * Gets an unsigned 1-byte value. + * @param data the array containing the data + * @param bci the start index of the value to retrieve + * @return the unsigned 1-byte value at index {@code bci} in array {@code data} + */ + public static int beU1(byte[] data, int bci) { + return data[bci] & 0xff; + } + + /** + * Gets an unsigned 2-byte big-endian value. + * @param data the array containing the data + * @param bci the start index of the value to retrieve + * @return the unsigned 2-byte, big-endian, value at index {@code bci} in array {@code data} + */ + public static int beU2(byte[] data, int bci) { + return ((data[bci] & 0xff) << 8) | (data[bci + 1] & 0xff); + } + + /** + * Gets a signed 4-byte big-endian value. + * @param data the array containing the data + * @param bci the start index of the value to retrieve + * @return the signed 4-byte, big-endian, value at index {@code bci} in array {@code data} + */ + public static int beS4(byte[] data, int bci) { + return (data[bci] << 24) | ((data[bci + 1] & 0xff) << 16) | ((data[bci + 2] & 0xff) << 8) | (data[bci + 3] & 0xff); + } + + /** + * Gets either a signed 2-byte or a signed 4-byte big-endian value. + * @param data the array containing the data + * @param bci the start index of the value to retrieve + * @param fourByte if true, this method will return a 4-byte value + * @return the signed 2 or 4-byte, big-endian, value at index {@code bci} in array {@code data} + */ + public static int beSVar(byte[] data, int bci, boolean fourByte) { + if (fourByte) { + return beS4(data, bci); + } else { + return beS2(data, bci); + } + } +}
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/FrameStateBuilder.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/FrameStateBuilder.java Tue Jan 03 16:47:02 2012 +0100 @@ -27,12 +27,12 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.PhiNode.PhiType; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class FrameStateBuilder implements FrameStateAccess {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/GraphBuilderPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/GraphBuilderPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,15 @@ */ package com.oracle.max.graal.compiler.graphbuilder; -import static com.sun.cri.bytecode.Bytecodes.*; +import static com.oracle.max.graal.compiler.graphbuilder.Bytecodes.*; import static java.lang.reflect.Modifier.*; import java.lang.reflect.*; import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.ri.RiType.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.graphbuilder.BlockMap.Block; @@ -45,10 +48,6 @@ import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.java.MethodCallTargetNode.InvokeKind; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.bytecode.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.ri.RiType.Representation; /** * The {@code GraphBuilder} class parses the bytecode of a method and builds the IR graph.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/JsrNotSupportedBailout.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/graphbuilder/JsrNotSupportedBailout.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,7 +22,7 @@ */ package com.oracle.max.graal.compiler.graphbuilder; -import com.sun.cri.ci.*; +import com.oracle.max.cri.ci.*; public class JsrNotSupportedBailout extends CiBailout{
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/FrameMap.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/FrameMap.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,11 +26,11 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiCallingConvention.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.compiler.stub.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiCallingConvention.Type; -import com.sun.cri.ri.*; /** * This class is used to build the stack frame layout for a compiled method.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRBranch.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRBranch.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.graal.compiler.lir; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.calc.*; -import com.sun.cri.ci.*; public abstract class LIRBranch extends LIRInstruction {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRCall.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRCall.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,14 +22,14 @@ */ package com.oracle.max.graal.compiler.lir; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiTargetMethod.Mark; -import com.sun.cri.ri.*; -import com.sun.cri.xir.CiXirAssembler.XirMark; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiTargetMethod.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.CiXirAssembler.*; /** * This class represents a call instruction; either to a {@linkplain CiRuntimeCall runtime method},
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRDebugInfo.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRDebugInfo.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,8 +26,8 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.lir.LIRInstruction.ValueProcedure; -import com.sun.cri.ci.*; /** * This class represents garbage collection and deoptimization information attached to a LIR instruction.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRInstruction.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRInstruction.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.compiler.lir; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; /** * The {@code LIRInstruction} class definition.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRPhiMapping.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRPhiMapping.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,11 +24,11 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.gen.*; import com.oracle.max.graal.compiler.lir.LIRInstruction.ValueProcedure; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.PhiNode.*; -import com.sun.cri.ci.*; public class LIRPhiMapping { private final LIRBlock block;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRXirInstruction.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/LIRXirInstruction.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.lir; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.xir.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.*; public abstract class LIRXirInstruction extends LIRInstruction {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/StandardOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/lir/StandardOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,11 +24,11 @@ import java.util.*; -import com.sun.cri.ci.CiTargetMethod.Mark; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.xir.CiXirAssembler.XirMark; -import com.sun.cri.xir.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiTargetMethod.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.*; +import com.oracle.max.cri.xir.CiXirAssembler.*; public class StandardOpcode { // Checkstyle: stop
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/package-info.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/package-info.java Tue Jan 03 16:47:02 2012 +0100 @@ -43,7 +43,7 @@ * While there is only one {@code GraalCompiler} instance, there may be several compilations proceeding concurrently, each of * which is represented by a unique {@code GraalCompilation} instance. The static method {@link com.oracle.max.graal.compiler.GraalCompilation#currentInterval}} returns the * {@code GraalCompilation} instance associated with the current thread, and is managed using a {@link java.lang.ThreadLocal} variable. - * Each {@code GraalCompilation} instance has an associated {@link com.sun.cri.ci.CiStatistics} object that accumulates information about the compilation process. + * Each {@code GraalCompilation} instance has an associated {@link com.oracle.max.cri.ci.CiStatistics} object that accumulates information about the compilation process. * </p> * <H3>Supported backends</H3> *
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/BoxingEliminationPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/BoxingEliminationPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,13 +24,13 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.PhiNode.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.virtual.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class BoxingEliminationPhase extends Phase {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/CanonicalizerPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/CanonicalizerPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,6 +22,8 @@ */ package com.oracle.max.graal.compiler.phases; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.graph.*; @@ -29,8 +31,6 @@ import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class CanonicalizerPhase extends Phase { private static final int MAX_ITERATION_PER_NODE = 10;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/EscapeAnalysisPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/EscapeAnalysisPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,6 +24,7 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.graph.*; @@ -36,7 +37,6 @@ import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.virtual.*; -import com.sun.cri.ci.*; public class EscapeAnalysisPhase extends Phase {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/FindInductionVariablesPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/FindInductionVariablesPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,13 +24,13 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.util.*; import com.oracle.max.graal.compiler.util.LoopUtil.Loop; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.loop.*; -import com.sun.cri.ci.*; /**
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/FloatingReadPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/FloatingReadPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,6 +24,7 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.loop.*; @@ -32,7 +33,6 @@ import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.PhiNode.*; import com.oracle.max.graal.nodes.extended.*; -import com.sun.cri.ci.*; public class FloatingReadPhase extends Phase {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/IdentifyBoxingPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/IdentifyBoxingPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,12 +24,12 @@ import java.lang.reflect.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.java.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class IdentifyBoxingPhase extends Phase {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/InliningPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/InliningPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,6 +24,8 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.graphbuilder.*; @@ -34,8 +36,6 @@ import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class InliningPhase extends Phase implements InliningCallback {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/IntrinsificationPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/IntrinsificationPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.compiler.phases; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.compiler.util.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ri.*; public class IntrinsificationPhase extends Phase {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/Phase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/Phase.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.compiler.phases; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.schedule.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; public abstract class Phase {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/SnippetIntrinsificationPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/phases/SnippetIntrinsificationPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,6 +24,8 @@ import java.lang.reflect.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.graph.Node.ConstantNodeParameter; import com.oracle.max.graal.graph.Node.NodeIntrinsic; @@ -31,8 +33,6 @@ import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class SnippetIntrinsificationPhase extends Phase {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/schedule/IdentifyBlocksPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/schedule/IdentifyBlocksPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,6 +24,7 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.phases.*; @@ -33,7 +34,6 @@ import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.loop.*; import com.oracle.max.graal.nodes.virtual.*; -import com.sun.cri.ci.*; public class IdentifyBlocksPhase extends Phase {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/stub/CompilerStub.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/stub/CompilerStub.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.compiler.stub; -import static com.sun.cri.ci.CiKind.*; +import static com.oracle.max.cri.ci.CiKind.*; -import com.sun.cri.ci.*; +import com.oracle.max.cri.ci.*; /** * A compiler stub is a shared routine that performs an operation on behalf of compiled code.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/Backend.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/Backend.java Tue Jan 03 16:47:02 2012 +0100 @@ -25,13 +25,13 @@ import java.lang.reflect.*; import com.oracle.max.asm.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.gen.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.stub.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.xir.*; /** * The {@code Backend} class represents a compiler backend for Graal.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ArithmeticOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ArithmeticOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64ArithmeticOpcode implements LIROpcode { IADD, ISUB, IAND, IOR, IXOR,
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64Backend.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64Backend.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,16 +24,16 @@ import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiCompiler.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.gen.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.stub.*; import com.oracle.max.graal.compiler.stub.CompilerStub.Id; import com.oracle.max.graal.compiler.target.*; -import com.sun.cri.ci.CiCompiler.DebugInfoLevel; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.xir.*; /** * The {@code X86Backend} class represents the backend for the AMD64 architecture.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64CallOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64CallOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,19 +22,19 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiTargetMethod.*; +import com.oracle.max.cri.xir.CiXirAssembler.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.stub.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiTargetMethod.Mark; -import com.sun.cri.xir.CiXirAssembler.XirMark; public enum AMD64CallOpcode implements StandardOpcode.CallOpcode { DIRECT_CALL, INDIRECT_CALL, NATIVE_CALL;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64CompareOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64CompareOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64CompareOpcode implements LIROpcode { ICMP, LCMP, ACMP, FCMP, DCMP;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64CompareToIntOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64CompareToIntOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,15 +22,15 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.AMD64Assembler.ConditionFlag; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; /** * Implementation of the Java bytecodes that compare a long, float, or double value and produce the
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64CompilerStubEmitter.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64CompilerStubEmitter.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,27 +22,22 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiCallingConvention.Type.*; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiCallingConvention.Type.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.*; import com.oracle.max.asm.target.amd64.AMD64Assembler.ConditionFlag; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiRegister.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.*; +import com.oracle.max.cri.xir.CiXirAssembler.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.stub.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiRegister.RegisterFlag; -import com.sun.cri.ri.*; -import com.sun.cri.xir.*; -import com.sun.cri.xir.CiXirAssembler.XirConstant; -import com.sun.cri.xir.CiXirAssembler.XirConstantOperand; -import com.sun.cri.xir.CiXirAssembler.XirOperand; -import com.sun.cri.xir.CiXirAssembler.XirParameter; -import com.sun.cri.xir.CiXirAssembler.XirRegister; -import com.sun.cri.xir.CiXirAssembler.XirTemp; /** * An object used to produce a single compiler stub.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ControlFlowOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ControlFlowOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,18 +22,18 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.*; import com.oracle.max.asm.target.amd64.AMD64Assembler.ConditionFlag; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiAddress.*; +import com.oracle.max.cri.ci.CiTargetMethod.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; import com.oracle.max.graal.nodes.calc.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiAddress.Scale; -import com.sun.cri.ci.CiTargetMethod.JumpTable; public class AMD64ControlFlowOpcode {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ConvertFIOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ConvertFIOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,16 +22,16 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.AMD64Assembler.ConditionFlag; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.stub.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64ConvertFIOpcode implements LIROpcode { F2I, D2I;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ConvertFLOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ConvertFLOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,16 +22,16 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.AMD64Assembler.ConditionFlag; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.stub.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64ConvertFLOpcode implements LIROpcode { F2L, D2L;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ConvertOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ConvertOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64ConvertOpcode implements LIROpcode { I2L, L2I, I2B, I2C, I2S,
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64DeoptimizationStub.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64DeoptimizationStub.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,12 +26,12 @@ import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; import com.oracle.max.graal.nodes.DeoptimizeNode.DeoptAction; -import com.sun.cri.ci.*; public class AMD64DeoptimizationStub implements LIR.SlowPath { public final Label label = new Label();
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64DivOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64DivOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,15 +22,15 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.*; import com.oracle.max.asm.target.amd64.AMD64Assembler.ConditionFlag; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64DivOpcode implements LIROpcode { IDIV, IREM, UIDIV, UIREM,
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64LIRGenerator.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64LIRGenerator.java Tue Jan 03 16:47:02 2012 +0100 @@ -23,6 +23,7 @@ package com.oracle.max.graal.compiler.target.amd64; +import static com.oracle.max.cri.ci.CiValueUtil.*; import static com.oracle.max.graal.compiler.target.amd64.AMD64ArithmeticOpcode.*; import static com.oracle.max.graal.compiler.target.amd64.AMD64CompareOpcode.*; import static com.oracle.max.graal.compiler.target.amd64.AMD64CompareToIntOpcode.*; @@ -35,10 +36,11 @@ import static com.oracle.max.graal.compiler.target.amd64.AMD64Op1Opcode.*; import static com.oracle.max.graal.compiler.target.amd64.AMD64ShiftOpcode.*; import static com.oracle.max.graal.compiler.target.amd64.AMD64StandardOpcode.*; -import static com.sun.cri.ci.CiValueUtil.*; import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.xir.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.gen.*; import com.oracle.max.graal.compiler.lir.*; @@ -48,8 +50,6 @@ import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.java.*; -import com.sun.cri.ci.*; -import com.sun.cri.xir.*; /** * This class implements the X86-specific portion of the LIR generator.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64LIRInstruction.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64LIRInstruction.java Tue Jan 03 16:47:02 2012 +0100 @@ -23,9 +23,9 @@ package com.oracle.max.graal.compiler.target.amd64; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; -import com.sun.cri.ci.*; /** * Convenience class to cast AbstractAssembler to AMD64MacroAssembler for the {@link #emitCode} method.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64LogicFloatOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64LogicFloatOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64LogicFloatOpcode implements LIROpcode { FAND, FOR, FXOR,
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64MoveOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64MoveOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,15 +22,15 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import static java.lang.Double.*; import static java.lang.Float.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public class AMD64MoveOpcode {
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64MulOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64MulOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64MulOpcode implements LIROpcode { IMUL, LMUL;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64Op1Opcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64Op1Opcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64Op1Opcode implements LIROpcode { INEG, LNEG;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ShiftOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64ShiftOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64ShiftOpcode implements LIROpcode { ISHL, ISHR, UISHR,
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64XirAssembler.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64XirAssembler.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.xir.XirTemplate.GlobalFlags.*; +import static com.oracle.max.cri.xir.XirTemplate.GlobalFlags.*; import java.util.*; import com.oracle.max.asm.target.amd64.*; -import com.sun.cri.ci.*; -import com.sun.cri.xir.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.xir.*; /** * AMD64 version of {@link CiXirAssembler}.
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64XirOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/target/amd64/AMD64XirOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,28 +22,25 @@ */ package com.oracle.max.graal.compiler.target.amd64; -import static com.sun.cri.ci.CiCallingConvention.Type.*; -import static com.sun.cri.ci.CiValue.*; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiCallingConvention.Type.*; +import static com.oracle.max.cri.ci.CiValue.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import java.util.*; import com.oracle.max.asm.*; import com.oracle.max.asm.target.amd64.*; import com.oracle.max.asm.target.amd64.AMD64Assembler.ConditionFlag; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiTargetMethod.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.*; +import com.oracle.max.cri.xir.CiXirAssembler.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiTargetMethod.Mark; -import com.sun.cri.ri.*; -import com.sun.cri.xir.*; -import com.sun.cri.xir.CiXirAssembler.RuntimeCallInformation; -import com.sun.cri.xir.CiXirAssembler.XirInstruction; -import com.sun.cri.xir.CiXirAssembler.XirLabel; -import com.sun.cri.xir.CiXirAssembler.XirMark; public enum AMD64XirOpcode implements StandardOpcode.XirOpcode { XIR;
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/util/InliningUtil.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/util/InliningUtil.java Tue Jan 03 16:47:02 2012 +0100 @@ -25,6 +25,8 @@ import java.lang.reflect.*; import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.graphbuilder.*; @@ -36,8 +38,6 @@ import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.java.MethodCallTargetNode.InvokeKind; import com.oracle.max.graal.nodes.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class InliningUtil { @@ -226,7 +226,7 @@ MethodCallTargetNode callTarget = invoke.callTarget(); if (callTarget.invokeKind() == InvokeKind.Special || callTarget.targetMethod().canBeStaticallyBound()) { - if (checkTargetConditions(callTarget.targetMethod(), runtime)) { + if (checkTargetConditions(callTarget.targetMethod())) { double weight = callback == null ? 0 : callback.inliningWeight(parent, callTarget.targetMethod(), invoke); return new ExactInlineInfo(invoke, weight, level, callTarget.targetMethod()); } @@ -236,7 +236,7 @@ RiResolvedType exact = callTarget.receiver().exactType(); assert exact.isSubtypeOf(callTarget.targetMethod().holder()) : exact + " subtype of " + callTarget.targetMethod().holder(); RiResolvedMethod resolved = exact.resolveMethodImpl(callTarget.targetMethod()); - if (checkTargetConditions(resolved, runtime)) { + if (checkTargetConditions(resolved)) { double weight = callback == null ? 0 : callback.inliningWeight(parent, resolved, invoke); return new ExactInlineInfo(invoke, weight, level, resolved); } @@ -258,7 +258,7 @@ } RiResolvedMethod concrete = holder.uniqueConcreteMethod(callTarget.targetMethod()); if (concrete != null) { - if (checkTargetConditions(concrete, runtime)) { + if (checkTargetConditions(concrete)) { double weight = callback == null ? 0 : callback.inliningWeight(parent, concrete, invoke); return new AssumptionInlineInfo(invoke, weight, level, holder, concrete); } @@ -269,7 +269,7 @@ if (GraalOptions.InlineWithTypeCheck) { // type check and inlining... concrete = profile.types[0].resolveMethodImpl(callTarget.targetMethod()); - if (concrete != null && checkTargetConditions(concrete, runtime)) { + if (concrete != null && checkTargetConditions(concrete)) { double weight = callback == null ? 0 : callback.inliningWeight(parent, concrete, invoke); return new TypeGuardInlineInfo(invoke, weight, level, concrete, profile.types[0], profile.probabilities[0]); } @@ -315,7 +315,7 @@ return true; } - private static boolean checkTargetConditions(RiMethod method, GraalRuntime runtime) { + private static boolean checkTargetConditions(RiMethod method) { if (!(method instanceof RiResolvedMethod)) { if (GraalOptions.TraceInlining) { TTY.println("not inlining %s because it is unresolved", method.toString()); @@ -323,12 +323,6 @@ return false; } RiResolvedMethod resolvedMethod = (RiResolvedMethod) method; - if (runtime.mustNotInline(resolvedMethod)) { - if (GraalOptions.TraceInlining) { - TTY.println("not inlining %s because the CRI set it to be non-inlinable", methodName(resolvedMethod)); - } - return false; - } if (Modifier.isNative(resolvedMethod.accessFlags())) { if (GraalOptions.TraceInlining) { TTY.println("not inlining %s because it is a native method", methodName(resolvedMethod));
--- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/util/Util.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/util/Util.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,11 +24,11 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; /** * The {@code Util} class contains a motley collection of utility methods used throughout the compiler.
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/Compiler.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/Compiler.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,11 @@ */ package com.oracle.max.graal.hotspot; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.cri.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.graal.hotspot.ri.*; public interface Compiler {
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/CompilerImpl.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/CompilerImpl.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,13 +26,16 @@ import java.net.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.xir.*; import com.oracle.max.graal.compiler.*; +import com.oracle.max.graal.compiler.observer.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.hotspot.logging.*; +import com.oracle.max.graal.hotspot.ri.*; import com.oracle.max.graal.hotspot.server.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.xir.*; +import com.oracle.max.graal.printer.*; /** * Singleton class holding the instance of the GraalCompiler. @@ -131,7 +134,7 @@ if (target == null) { final int wordSize = 8; final int stackFrameAlignment = 16; - target = new HotSpotTarget(new AMD64(), true, stackFrameAlignment, config.vmPageSize, wordSize, true); + target = new CiTarget(new AMD64(), true, stackFrameAlignment, config.vmPageSize, wordSize, true, true, true); } return target; @@ -211,6 +214,18 @@ public HotSpotRuntime getRuntime() { if (runtime == null) { context = new GraalContext("Virtual Machine Compiler"); + if (GraalOptions.PrintCFGToFile) { + context.addCompilationObserver(new CFGPrinterObserver()); + } + if (GraalOptions.PrintIdealGraphLevel != 0 || GraalOptions.Plot || GraalOptions.PlotOnError) { + CompilationObserver observer; + if (GraalOptions.PrintIdealGraphFile) { + observer = new IdealGraphPrinterObserver(); + } else { + observer = new IdealGraphPrinterObserver(GraalOptions.PrintIdealGraphAddress, GraalOptions.PrintIdealGraphPort); + } + context.addCompilationObserver(observer); + } runtime = new HotSpotRuntime(context, config, this); } return runtime;
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotCompiledMethod.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotCompiledMethod.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,7 +22,7 @@ */ package com.oracle.max.graal.hotspot; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ri.*; /** * Implementation of RiCompiledMethod for HotSpot. Stores a reference to the nmethod which contains the compiled code.
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotConstantPool.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotConstantPool.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,7 +22,8 @@ */ package com.oracle.max.graal.hotspot; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.ri.*; /** * Implementation of RiConstantPool for HotSpot.
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotExceptionHandler.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotExceptionHandler.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,7 +22,7 @@ */ package com.oracle.max.graal.hotspot; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ri.*; public class HotSpotExceptionHandler extends CompilerObject implements RiExceptionHandler {
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotField.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotField.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,10 +26,10 @@ import java.lang.annotation.*; import java.lang.reflect.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.ri.RiType.*; import com.oracle.max.graal.compiler.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; -import com.sun.cri.ri.RiType.Representation; /** * Represents a field in a HotSpot type.
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotIntrinsic.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,54 +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. - * - * 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.oracle.max.graal.hotspot; - -import com.oracle.max.graal.compiler.*; -import com.oracle.max.graal.compiler.phases.*; -import com.oracle.max.graal.snippets.*; - -/** - * Enumeration of intrinsic methods. - */ -public enum HotSpotIntrinsic { - Thread_currentThread("java.lang.Thread", "currentThread"); - - public final String className; - public final String methodName; - public final Class<?>[] parameterTypes; - - - private HotSpotIntrinsic(String className, String methodName, Class<?>... parameterTypes) { - this.className = className; - this.methodName = methodName; - this.parameterTypes = parameterTypes; - } - - public static void installIntrinsics(HotSpotRuntime runtime) { - assert CompilerImpl.getInstance() != null : "compiler must exist before installing intrinsics"; - if (GraalOptions.Intrinsify) { - GraalIntrinsics.installIntrinsics(runtime, runtime.getCompiler().getTarget(), PhasePlan.DEFAULT); - Snippets.install(runtime, runtime.getCompiler().getTarget(), new SystemSnippets(), GraalOptions.PlotSnippets, PhasePlan.DEFAULT); - Snippets.install(runtime, runtime.getCompiler().getTarget(), new UnsafeSnippets(), GraalOptions.PlotSnippets, PhasePlan.DEFAULT); - } - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotMethod.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,50 +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. - * - * 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.oracle.max.graal.hotspot; - -import com.sun.cri.ri.*; - -public abstract class HotSpotMethod extends CompilerObject implements RiMethod { - - /** - * - */ - private static final long serialVersionUID = 7167491397941960839L; - protected String name; - - protected HotSpotMethod(Compiler compiler) { - super(compiler); - } - - @Override - public final String name() { - return name; - } - - @Override - public boolean canBePermanentlyLinked() { - // relevant in Maxine only - return false; - } - -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotMethodResolved.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,32 +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. - * - * 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.oracle.max.graal.hotspot; - -import com.oracle.max.graal.hotspot.server.*; -import com.sun.cri.ri.*; - -public interface HotSpotMethodResolved extends RiResolvedMethod, Remote { - - RiResolvedMethod uniqueConcreteMethod(); - void dumpProfile(); -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotMethodResolvedImpl.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,309 +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. - * - * 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.oracle.max.graal.hotspot; - -import java.lang.annotation.*; -import java.lang.reflect.*; -import java.util.*; -import java.util.concurrent.*; - -import com.oracle.max.criutils.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; - -/** - * Implementation of RiMethod for resolved HotSpot methods. - */ -public final class HotSpotMethodResolvedImpl extends HotSpotMethod implements HotSpotMethodResolved { - - /** - * - */ - private static final long serialVersionUID = -5486975070147586588L; - - /** DO NOT USE IN JAVA CODE! */ - @SuppressWarnings("unused") - @Deprecated - private Object javaMirror; - - // cached values - private final int codeSize; - private final int accessFlags; - private final int maxLocals; - private final int maxStackSize; - private RiSignature signature; - private Boolean hasBalancedMonitors; - private Map<Object, Object> compilerStorage; - private RiResolvedType holder; - private byte[] code; - - private HotSpotMethodResolvedImpl() { - super(null); - codeSize = -1; - accessFlags = -1; - maxLocals = -1; - maxStackSize = -1; - throw new IllegalStateException("this constructor is never actually called, because the objects are allocated from within the VM"); - } - - @Override - public RiResolvedType holder() { - return holder; - } - - @Override - public int accessFlags() { - return accessFlags; - } - - @Override - public boolean canBeStaticallyBound() { - return isLeafMethod() || Modifier.isStatic(accessFlags()); - } - - @Override - public byte[] code() { - if (code == null) { - code = compiler.getVMEntries().RiMethod_code(this); - assert code.length == codeSize : "expected: " + codeSize + ", actual: " + code.length; - } - return code; - } - - @Override - public int codeSize() { - return codeSize; - } - - @Override - public RiExceptionHandler[] exceptionHandlers() { - return compiler.getVMEntries().RiMethod_exceptionHandlers(this); - } - - @Override - public boolean hasBalancedMonitors() { - if (hasBalancedMonitors == null) { - hasBalancedMonitors = compiler.getVMEntries().RiMethod_hasBalancedMonitors(this); - } - return hasBalancedMonitors; - } - - @Override - public boolean isClassInitializer() { - return "<clinit>".equals(name) && Modifier.isStatic(accessFlags()); - } - - @Override - public boolean isConstructor() { - return "<init>".equals(name) && !Modifier.isStatic(accessFlags()); - } - - @Override - public boolean isLeafMethod() { - return Modifier.isFinal(accessFlags()) || Modifier.isPrivate(accessFlags()); - } - - @Override - public boolean isOverridden() { - throw new UnsupportedOperationException("isOverridden"); - } - - @Override - public boolean noSafepointPolls() { - return false; - } - - @Override - public String jniSymbol() { - throw new UnsupportedOperationException("jniSymbol"); - } - - public CiBitMap[] livenessMap() { - return null; - } - - @Override - public int maxLocals() { - return maxLocals; - } - - @Override - public int maxStackSize() { - return maxStackSize; - } - - @Override - public StackTraceElement toStackTraceElement(int bci) { - return CiUtil.toStackTraceElement(this, bci); - } - - @Override - public RiResolvedMethod uniqueConcreteMethod() { - return (RiResolvedMethod) compiler.getVMEntries().RiMethod_uniqueConcreteMethod(this); - } - - @Override - public RiSignature signature() { - if (signature == null) { - signature = new HotSpotSignature(compiler, compiler.getVMEntries().RiMethod_signature(this)); - } - return signature; - } - - @Override - public String toString() { - return "HotSpotMethod<" + CiUtil.format("%h.%n", this) + ">"; - } - - public boolean hasCompiledCode() { - return compiler.getVMEntries().RiMethod_hasCompiledCode(this); - } - - @Override - public RiResolvedType accessor() { - return null; - } - - @Override - public String intrinsic() { - return null; - } - - public int invocationCount() { - return compiler.getVMEntries().RiMethod_invocationCount(this); - } - - public int exceptionProbability(int bci) { - return compiler.getVMEntries().RiMethod_exceptionProbability(this, bci); - } - - public RiTypeProfile typeProfile(int bci) { - return compiler.getVMEntries().RiMethod_typeProfile(this, bci); - } - - public double branchProbability(int bci) { - return compiler.getVMEntries().RiMethod_branchProbability(this, bci); - } - - public double[] switchProbability(int bci) { - return compiler.getVMEntries().RiMethod_switchProbability(this, bci); - } - - @Override - public Map<Object, Object> compilerStorage() { - if (compilerStorage == null) { - compilerStorage = new ConcurrentHashMap<>(); - } - return compilerStorage; - } - - @Override - public RiConstantPool getConstantPool() { - return ((HotSpotTypeResolvedImpl) holder()).constantPool(); - } - - public void dumpProfile() { - TTY.println("profile info for %s", this); - TTY.println("canBeStaticallyBound: " + canBeStaticallyBound()); - TTY.println("invocationCount: " + invocationCount()); - for (int i = 0; i < codeSize(); i++) { - if (branchProbability(i) != -1) { - TTY.println(" branchProbability@%d: %f", i, branchProbability(i)); - } - if (exceptionProbability(i) > 0) { - TTY.println(" exceptionProbability@%d: %d", i, exceptionProbability(i)); - } - RiTypeProfile profile = typeProfile(i); - if (profile != null && profile.count > 0) { - TTY.print(" profile@%d: count: %d, morphism: %d", i, profile.count, profile.morphism); - if (profile.types != null) { - TTY.print(", types:"); - for (int i2 = 0; i2 < profile.types.length; i2++) { - TTY.print(" %s (%f)", profile.types[i2], profile.probabilities[i2]); - } - } - TTY.println(); - if (exceptionProbability(i) > 0) { - TTY.println(" exceptionProbability@%d: %d", i, exceptionProbability(i)); - } - } - } - } - - - - @Override - public Annotation[][] getParameterAnnotations() { - if (isConstructor()) { - Constructor javaConstructor = toJavaConstructor(); - return javaConstructor == null ? null : javaConstructor.getParameterAnnotations(); - } - Method javaMethod = toJava(); - return javaMethod == null ? null : javaMethod.getParameterAnnotations(); - } - - @Override - public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { - if (isConstructor()) { - Constructor<?> javaConstructor = toJavaConstructor(); - return javaConstructor == null ? null : javaConstructor.getAnnotation(annotationClass); - } - Method javaMethod = toJava(); - return javaMethod == null ? null : javaMethod.getAnnotation(annotationClass); - } - - @Override - public Type getGenericReturnType() { - if (isConstructor()) { - return void.class; - } - Method javaMethod = toJava(); - return javaMethod == null ? null : javaMethod.getGenericReturnType(); - } - - @Override - public Type[] getGenericParameterTypes() { - if (isConstructor()) { - Constructor javaConstructor = toJavaConstructor(); - return javaConstructor == null ? null : javaConstructor.getGenericParameterTypes(); - } - Method javaMethod = toJava(); - return javaMethod == null ? null : javaMethod.getGenericParameterTypes(); - } - - private Method toJava() { - try { - return holder.toJava().getDeclaredMethod(name, CiUtil.signatureToTypes(signature, holder)); - } catch (NoSuchMethodException e) { - return null; - } - } - - private Constructor toJavaConstructor() { - try { - return holder.toJava().getDeclaredConstructor(CiUtil.signatureToTypes(signature, holder)); - } catch (NoSuchMethodException e) { - return null; - } - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotMethodUnresolved.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -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. - * - * 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.oracle.max.graal.hotspot; - -import com.sun.cri.ri.*; - -/** - * Implementation of RiMethod for unresolved HotSpot methods. - */ -public final class HotSpotMethodUnresolved extends HotSpotMethod { - /** - * - */ - private static final long serialVersionUID = 5610263481791970079L; - private final RiSignature signature; - protected RiType holder; - - public HotSpotMethodUnresolved(Compiler compiler, String name, String signature, RiType holder) { - super(compiler); - this.name = name; - this.holder = holder; - this.signature = new HotSpotSignature(compiler, signature); - } - - @Override - public RiSignature signature() { - return signature; - } - - @Override - public RiType holder() { - return holder; - } - - @Override - public String toString() { - return "HotSpotMethod<" + holder.name() + ". " + name + ", unresolved>"; - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotRegisterConfig.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotRegisterConfig.java Tue Jan 03 16:47:02 2012 +0100 @@ -27,11 +27,11 @@ import java.util.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiCallingConvention.*; +import com.oracle.max.cri.ci.CiRegister.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiCallingConvention.Type; -import com.sun.cri.ci.CiRegister.RegisterFlag; -import com.sun.cri.ri.*; public class HotSpotRegisterConfig implements RiRegisterConfig {
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotRuntime.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotRuntime.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,20 +26,20 @@ import java.lang.reflect.*; import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiTargetMethod.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.ri.RiType.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.hotspot.nodes.*; +import com.oracle.max.graal.hotspot.ri.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.snippets.nodes.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiTargetMethod.DataPatch; -import com.sun.cri.ci.CiTargetMethod.Safepoint; -import com.sun.cri.ri.*; -import com.sun.cri.ri.RiType.Representation; import com.sun.max.asm.dis.*; import com.sun.max.lang.*; @@ -52,8 +52,6 @@ final HotSpotRegisterConfig regConfig; final HotSpotRegisterConfig globalStubRegConfig; private final Compiler compiler; - // TODO(ls) this is not a permanent solution - there should be a more sophisticated compiler oracle - private HashSet<RiResolvedMethod> notInlineableMethods = new HashSet<>(); public HotSpotRuntime(GraalContext context, HotSpotVMConfig config, Compiler compiler) { this.context = context; @@ -140,28 +138,6 @@ } @Override - public boolean mustInline(RiResolvedMethod method) { - return false; - } - - @Override - public boolean mustNotCompile(RiResolvedMethod method) { - return false; - } - - @Override - public boolean mustNotInline(RiResolvedMethod method) { - if (notInlineableMethods.contains(method)) { - return true; - } - return Modifier.isNative(method.accessFlags()); - } - - public void makeNotInlineable(RiResolvedMethod method) { - notInlineableMethods.add(method); - } - - @Override public Object registerCompilerStub(CiTargetMethod targetMethod, String name) { return HotSpotTargetMethod.installStub(compiler, targetMethod, name); } @@ -183,15 +159,6 @@ return 8; } - public boolean isFoldable(RiResolvedMethod method) { - return false; - } - - @Override - public CiConstant fold(RiResolvedMethod method, CiConstant[] args) { - return null; - } - @Override public boolean areConstantObjectsEqual(CiConstant x, CiConstant y) { return compiler.getVMEntries().compareConstantObjects(x, y); @@ -207,6 +174,7 @@ */ @Override public int getCustomStackAreaSize() { + // TODO shouldn't be hard coded return 8; }
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotSignature.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotSignature.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,9 +24,10 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.compiler.graphbuilder.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.graal.hotspot.ri.*; /** * Represents a method signature.
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotTarget.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,36 +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. - * - * 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.oracle.max.graal.hotspot; - -import com.sun.cri.ci.*; - -/** - * HotSpot-specific CiTarget. - * TODO currently empty class, so check if it can be deleted. - */ -public class HotSpotTarget extends CiTarget { - - public HotSpotTarget(CiArchitecture arch, boolean isMP, int stackAlignment, int pageSize, int cacheAlignment, boolean inlineObjects) { - super(arch, isMP, stackAlignment, pageSize, cacheAlignment, inlineObjects, true, true); - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotTargetMethod.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotTargetMethod.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,11 +24,10 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiTargetMethod.*; import com.oracle.max.graal.hotspot.logging.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiTargetMethod.ExceptionHandler; -import com.sun.cri.ci.CiTargetMethod.Mark; -import com.sun.cri.ci.CiTargetMethod.Site; +import com.oracle.max.graal.hotspot.ri.*; /** * CiTargetMethod augmented with HotSpot-specific information.
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotType.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,45 +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. - * - * 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.oracle.max.graal.hotspot; - -import com.sun.cri.ri.*; - -/** - * Common interface for all HotSpot RiType-implementations. - */ -public abstract class HotSpotType extends CompilerObject implements RiType { - /** - * - */ - private static final long serialVersionUID = -4252886265301910771L; - protected String name; - - protected HotSpotType(Compiler compiler) { - super(compiler); - } - - @Override - public final String name() { - return name; - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotTypePrimitive.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,168 +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. - * - * 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.oracle.max.graal.hotspot; - -import java.lang.annotation.*; - -import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; - -/** - * Implementation of RiType for primitive HotSpot types. - */ -public final class HotSpotTypePrimitive extends HotSpotType implements RiResolvedType { - - /** - * - */ - private static final long serialVersionUID = -6208552348908071473L; - private CiKind kind; - - - HotSpotTypePrimitive(Compiler compiler, CiKind kind) { - super(compiler); - this.kind = kind; - this.name = kind.toString(); - } - - @Override - public int accessFlags() { - return kind.toJavaClass().getModifiers(); - } - - @Override - public RiResolvedType arrayOf() { - return (RiResolvedType) compiler.getVMEntries().getPrimitiveArrayType(kind); - } - - @Override - public RiResolvedType componentType() { - return null; - } - - @Override - public RiResolvedType exactType() { - return this; - } - - @Override - public RiResolvedType superType() { - return null; - } - - @Override - public CiConstant getEncoding(Representation r) { - throw Util.unimplemented("HotSpotTypePrimitive.getEncoding"); - } - - @Override - public CiKind getRepresentationKind(Representation r) { - return kind; - } - - @Override - public boolean hasFinalizableSubclass() { - return false; - } - - @Override - public boolean hasFinalizer() { - return false; - } - - @Override - public boolean hasSubclass() { - return false; - } - - @Override - public boolean isArrayClass() { - return false; - } - - @Override - public boolean isInitialized() { - return true; - } - - @Override - public boolean isInstance(CiConstant obj) { - return false; - } - - @Override - public boolean isInstanceClass() { - return false; - } - - @Override - public boolean isInterface() { - return false; - } - - @Override - public boolean isSubtypeOf(RiResolvedType other) { - return false; - } - - @Override - public CiKind kind(boolean architecture) { - return kind; - } - - @Override - public RiResolvedMethod resolveMethodImpl(RiResolvedMethod method) { - return null; - } - - @Override - public String toString() { - return "HotSpotTypePrimitive<" + kind + ">"; - } - - @Override - public RiResolvedType uniqueConcreteSubtype() { - return this; - } - - @Override - public RiResolvedMethod uniqueConcreteMethod(RiResolvedMethod method) { - return null; - } - - @Override - public RiResolvedField[] declaredFields() { - return null; - } - - @Override - public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { - return toJava().getAnnotation(annotationClass); - } - - @Override - public Class< ? > toJava() { - return kind.toJavaClass(); - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotTypeResolved.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,38 +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. - * - * 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.oracle.max.graal.hotspot; - -import com.oracle.max.graal.hotspot.server.*; -import com.sun.cri.ri.*; - -public interface HotSpotTypeResolved extends RiResolvedType, Remote { - - String toString(); - - RiConstantPool constantPool(); - - int instanceSize(); - - RiField createRiField(String name, RiType type, int offset, int flags); - -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotTypeResolvedImpl.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,252 +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. - * - * 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.oracle.max.graal.hotspot; - -import java.lang.annotation.*; -import java.lang.reflect.*; -import java.util.*; - -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; - -/** - * Implementation of RiType for resolved non-primitive HotSpot classes. - */ -public final class HotSpotTypeResolvedImpl extends HotSpotType implements HotSpotTypeResolved { - - /** - * - */ - private static final long serialVersionUID = 3481514353553840471L; - private Class javaMirror; - private String simpleName; - private int accessFlags; - private boolean hasFinalizer; - private boolean hasSubclass; - private boolean hasFinalizableSubclass; - private boolean isArrayClass; - private boolean isInstanceClass; - private boolean isInterface; - private int instanceSize; - private HashMap<Long, RiResolvedField> fieldCache; - private RiResolvedType superType; - private boolean superTypeSet; - private RiResolvedField[] fields; - private RiConstantPool constantPool; - private boolean isInitialized; - private RiResolvedType arrayOfType; - - private HotSpotTypeResolvedImpl() { - super(null); - } - - @Override - public int accessFlags() { - return accessFlags; - } - - @Override - public RiResolvedType arrayOf() { - if (arrayOfType == null) { - arrayOfType = (RiResolvedType) compiler.getVMEntries().RiType_arrayOf(this); - } - return arrayOfType; - } - - @Override - public RiResolvedType componentType() { - assert isArrayClass(); - return (RiResolvedType) compiler.getVMEntries().RiType_componentType(this); - } - - @Override - public RiResolvedType uniqueConcreteSubtype() { - return (RiResolvedType) compiler.getVMEntries().RiType_uniqueConcreteSubtype(this); - } - - @Override - public RiResolvedType superType() { - if (!superTypeSet) { - superType = (RiResolvedType) compiler.getVMEntries().RiType_superType(this); - superTypeSet = true; - } - return superType; - } - - @Override - public RiResolvedType exactType() { - if (Modifier.isFinal(accessFlags)) { - return this; - } - return null; - } - - @Override - public CiConstant getEncoding(Representation r) { - switch (r) { - case JavaClass: - return CiConstant.forObject(javaMirror); - case ObjectHub: - return CiConstant.forObject(this); - case StaticFields: - return CiConstant.forObject(javaMirror); - case TypeInfo: - return CiConstant.forObject(this); - default: - return null; - } - } - - @Override - public CiKind getRepresentationKind(Representation r) { - return CiKind.Object; - } - - @Override - public boolean hasFinalizableSubclass() { - return hasFinalizableSubclass; - } - - @Override - public boolean hasFinalizer() { - return hasFinalizer; - } - - @Override - public boolean hasSubclass() { - return hasSubclass; - } - - @Override - public boolean isArrayClass() { - return isArrayClass; - } - - @Override - public boolean isInitialized() { - if (!isInitialized) { - isInitialized = compiler.getVMEntries().RiType_isInitialized(this); - } - return isInitialized; - } - - @Override - public boolean isInstance(CiConstant obj) { - return javaMirror.isInstance(obj); - } - - @Override - public boolean isInstanceClass() { - return isInstanceClass; - } - - @Override - public boolean isInterface() { - return isInterface; - } - - @Override - public boolean isSubtypeOf(RiResolvedType other) { - if (other instanceof HotSpotTypeResolved) { - return compiler.getVMEntries().RiType_isSubtypeOf(this, other); - } - // No resolved type is a subtype of an unresolved type. - return false; - } - - @Override - public CiKind kind(boolean architecture) { - return CiKind.Object; - } - - @Override - public RiResolvedMethod resolveMethodImpl(RiResolvedMethod method) { - assert method instanceof HotSpotMethod; - return (RiResolvedMethod) compiler.getVMEntries().RiType_resolveMethodImpl(this, method.name(), method.signature().asString()); - } - - @Override - public String toString() { - return "HotSpotType<" + simpleName + ", resolved>"; - } - - @Override - public RiConstantPool constantPool() { - if (constantPool == null) { - constantPool = new HotSpotConstantPool(compiler, this); - } - return constantPool; - } - - @Override - public int instanceSize() { - return instanceSize; - } - - @Override - public synchronized RiResolvedField createRiField(String fieldName, RiType type, int offset, int flags) { - RiResolvedField result = null; - - long id = offset + ((long) flags << 32); - - // (tw) Must cache the fields, because the local load elimination only works if the objects from two field lookups are equal. - if (fieldCache == null) { - fieldCache = new HashMap<>(8); - } else { - result = fieldCache.get(id); - } - - if (result == null) { - result = new HotSpotField(compiler, this, fieldName, type, offset, flags); - fieldCache.put(id, result); - } else { - assert result.name().equals(fieldName); - assert result.accessFlags() == flags; - } - - return result; - } - - @Override - public RiResolvedMethod uniqueConcreteMethod(RiResolvedMethod method) { - return ((HotSpotMethodResolved) method).uniqueConcreteMethod(); - } - - @Override - public RiResolvedField[] declaredFields() { - if (fields == null) { - fields = compiler.getVMEntries().RiType_fields(this); - } - return fields; - } - - @Override - public Class< ? > toJava() { - return javaMirror; - } - - @Override - public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { - return toJava().getAnnotation(annotationClass); - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotTypeUnresolved.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,118 +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. - * - * 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.oracle.max.graal.hotspot; - -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; - -/** - * Implementation of RiType for unresolved HotSpot classes. - */ -public class HotSpotTypeUnresolved extends HotSpotType { - - /** - * - */ - private static final long serialVersionUID = -2320936267633521314L; - public final String simpleName; - public final int dimensions; - - /** - * Creates a new unresolved type for a specified type descriptor. - */ - public HotSpotTypeUnresolved(Compiler compiler, String name) { - super(compiler); - assert name.length() > 0 : "name cannot be empty"; - - int dims = 0; - // Decode name if necessary. - if (name.charAt(name.length() - 1) == ';') { - int startIndex = 0; - while (name.charAt(startIndex) == '[') { - startIndex++; - dims++; - } - assert name.charAt(startIndex) == 'L'; - this.simpleName = name.substring(startIndex + 1, name.length() - 1); - this.name = name; - } else { - this.simpleName = name; - this.name = getFullName(name, dims); - } - - this.dimensions = dims; - } - - public HotSpotTypeUnresolved(Compiler compiler, String name, int dimensions) { - super(compiler); - assert dimensions >= 0; - this.simpleName = name; - this.dimensions = dimensions; - this.name = getFullName(name, dimensions); - } - - private static String getFullName(String name, int dimensions) { - StringBuilder str = new StringBuilder(name.length() + dimensions + 2); - for (int i = 0; i < dimensions; i++) { - str.append('['); - } - str.append('L').append(name).append(';'); - return str.toString(); - } - - @Override - public RiType componentType() { - assert dimensions > 0 : "no array class" + name(); - return new HotSpotTypeUnresolved(compiler, simpleName, dimensions - 1); - } - - @Override - public RiType arrayOf() { - return new HotSpotTypeUnresolved(compiler, simpleName, dimensions + 1); - } - - @Override - public CiKind kind(boolean architecture) { - return CiKind.Object; - } - - @Override - public int hashCode() { - return simpleName.hashCode(); - } - - @Override - public boolean equals(Object o) { - return o == this; - } - - @Override - public String toString() { - return "HotSpotType<" + simpleName + ", unresolved>"; - } - - @Override - public CiKind getRepresentationKind(RiType.Representation r) { - return CiKind.Object; - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotVMConfig.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotVMConfig.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,7 +22,7 @@ */ package com.oracle.max.graal.hotspot; -import com.sun.cri.ci.*; +import com.oracle.max.cri.ci.*; /** * Used to communicate configuration details, runtime offsets, etc. to graal upon compileMethod.
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotXirGenerator.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/HotSpotXirGenerator.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,27 +22,24 @@ */ package com.oracle.max.graal.hotspot; +import static com.oracle.max.cri.ci.CiCallingConvention.Type.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import static com.oracle.max.graal.hotspot.TemplateFlag.*; -import static com.sun.cri.ci.CiCallingConvention.Type.*; -import static com.sun.cri.ci.CiValueUtil.*; import java.lang.reflect.*; import java.util.*; import java.util.concurrent.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiAddress.*; +import com.oracle.max.cri.ci.CiRegister.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.ri.RiType.*; +import com.oracle.max.cri.xir.*; +import com.oracle.max.cri.xir.CiXirAssembler.*; import com.oracle.max.graal.compiler.*; -import com.sun.cri.ci.CiAddress.Scale; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiRegister.RegisterFlag; -import com.sun.cri.ri.*; -import com.sun.cri.ri.RiType.Representation; -import com.sun.cri.xir.*; -import com.sun.cri.xir.CiXirAssembler.XirConstant; -import com.sun.cri.xir.CiXirAssembler.XirLabel; -import com.sun.cri.xir.CiXirAssembler.XirMark; -import com.sun.cri.xir.CiXirAssembler.XirOperand; -import com.sun.cri.xir.CiXirAssembler.XirParameter; +import com.oracle.max.graal.hotspot.ri.*; public class HotSpotXirGenerator implements RiXirGenerator {
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/InvocationSocket.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,282 +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. - * - * 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.oracle.max.graal.hotspot; - -import java.io.*; -import java.lang.reflect.*; -import java.util.*; - -import com.oracle.max.graal.hotspot.logging.*; - -/** - * A collection of java.lang.reflect proxies that communicate over a socket connection. - * - * Calling a method sends the method name and the parameters through the socket. Afterwards this class waits for a - * result. While waiting for a result three types of objects can arrive through the socket: a method invocation, a - * method result or an exception. Method invocation can thus be recursive. - */ -public class InvocationSocket { - - private static final boolean DEBUG = false; - private static final boolean COUNT_CALLS = false; - - private static final HashSet<String> cachedMethodNames = new HashSet<>(); - private static final HashSet<String> forbiddenMethodNames = new HashSet<>(); - - static { - cachedMethodNames.add("name"); - cachedMethodNames.add("kind"); - cachedMethodNames.add("isResolved"); - cachedMethodNames.add("getVMEntries"); - cachedMethodNames.add("exactType"); - cachedMethodNames.add("isInitialized"); - forbiddenMethodNames.add("javaClass"); - } - - private final ObjectOutputStream output; - private final ObjectInputStream input; - - private final Map<String, Integer> counts = new HashMap<>(); - - public InvocationSocket(ObjectOutputStream output, ObjectInputStream input) { - this.output = output; - this.input = input; - - if (COUNT_CALLS) { - Runtime.getRuntime().addShutdownHook(new Thread() { - @Override - public void run() { - SortedMap<Integer, String> sorted = new TreeMap<>(); - for (Map.Entry<String, Integer> entry : counts.entrySet()) { - sorted.put(entry.getValue(), entry.getKey()); - } - for (Map.Entry<Integer, String> entry : sorted.entrySet()) { - System.out.println(entry.getKey() + ": " + entry.getValue()); - } - } - }); - } - } - - /** - * Represents one invocation of a method that is transferred via the socket connection. - * - */ - private static class Invocation implements Serializable { - - /** - * - */ - private static final long serialVersionUID = -799162779226626066L; - public Object receiver; - public String methodName; - public Object[] args; - - public Invocation(Object receiver, String methodName, Object[] args) { - this.receiver = receiver; - this.methodName = methodName; - this.args = args; - } - } - - /** - * Represents the result of an invocation that is transferred via the socket connection. - * - */ - private static class Result implements Serializable { - - /** - * - */ - private static final long serialVersionUID = -7496058356272415814L; - public Object result; - - public Result(Object result) { - this.result = result; - } - } - - private void incCount(String name, Object[] args) { - if (COUNT_CALLS) { - String nameAndArgCount = name + (args == null ? 0 : args.length); - if (counts.get(nameAndArgCount) != null) { - counts.put(nameAndArgCount, counts.get(nameAndArgCount) + 1); - } else { - counts.put(nameAndArgCount, 1); - } - } - } - - /** - * Each instance of this class handles remote invocations for one instance of a Remote class. It will forward all - * interface methods to the other end of the socket and cache the results of calls to certain methods. - * - */ - public class Handler implements InvocationHandler { - - private final Object receiver; - private final HashMap<String, Object> cache = new HashMap<>(); - - public Handler(Object receiver) { - this.receiver = receiver; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - // only interface methods can be transferred, java.lang.Object methods - if (method.getDeclaringClass() == Object.class) { - return method.invoke(receiver, args); - } - String methodName = method.getName(); - // check if the result of this zero-arg method was cached - if (args == null || args.length == 0) { - if (cache.containsKey(methodName)) { - return cache.get(methodName); - } - } - if (forbiddenMethodNames.contains(methodName)) { - throw new IllegalAccessException(methodName + " not allowed"); - } - Object result = null; - try { - if (DEBUG) { - Logger.startScope("invoking remote " + methodName); - } - incCount(methodName, args); - - output.writeObject(new Invocation(receiver, methodName, args)); - output.flush(); - result = waitForResult(false); - - // result caching for selected methods - if ((args == null || args.length == 0) && cachedMethodNames.contains(methodName)) { - cache.put(methodName, result); - } - return result; - } catch (Throwable t) { - t.printStackTrace(); - throw t; - } finally { - if (DEBUG) { - Logger.endScope(" = " + result); - } - } - } - } - - /** - * Waits for the result of a remote method invocation. Invocations that should be executed in this VM might arrive - * while waiting for the result, and these invocations will be executed before again waiting fort he result. - */ - @SuppressWarnings("unused") - public Object waitForResult(boolean eofExpected) throws IOException, ClassNotFoundException { - while (true) { - Object in; - try { - in = input.readObject(); - } catch (EOFException e) { - if (eofExpected) { - return null; - } - throw e; - } - if (in instanceof Result) { - return ((Result) in).result; - } else if (in instanceof RuntimeException) { - throw (RuntimeException) in; - } else if (in instanceof Throwable) { - throw new RuntimeException((Throwable) in); - } - - Invocation invoke = (Invocation) in; - Method method = null; - for (Class<?> clazz = invoke.receiver.getClass(); clazz != null; clazz = clazz.getSuperclass()) { - for (Method m : clazz.getDeclaredMethods()) { - if (invoke.methodName.equals(m.getName())) { - method = m; - break; - } - } - } - if (method == null) { - Exception e = new UnsupportedOperationException("unknown method " + invoke.methodName); - e.printStackTrace(); - output.writeObject(e); - output.flush(); - } else { - Object result = null; - try { - if (invoke.args == null) { - if (DEBUG) { - Logger.startScope("invoking local " + invoke.methodName); - } - result = method.invoke(invoke.receiver); - } else { - if (Logger.ENABLED && DEBUG) { - StringBuilder str = new StringBuilder(); - str.append("invoking local " + invoke.methodName + "("); - for (int i = 0; i < invoke.args.length; i++) { - str.append(i == 0 ? "" : ", "); - str.append(Logger.pretty(invoke.args[i])); - } - str.append(")"); - Logger.startScope(str.toString()); - } - result = method.invoke(invoke.receiver, invoke.args); - } - result = new Result(result); - } catch (IllegalArgumentException e) { - System.out.println("error while invoking " + invoke.methodName); - e.getCause().printStackTrace(); - result = e.getCause(); - } catch (InvocationTargetException e) { - System.out.println("error while invoking " + invoke.methodName); - e.getCause().printStackTrace(); - result = e.getCause(); - } catch (IllegalAccessException e) { - System.out.println("error while invoking " + invoke.methodName); - e.getCause().printStackTrace(); - result = e.getCause(); - } finally { - if (DEBUG) { - if (result instanceof Result) { - Logger.endScope(" = " + ((Result) result).result); - } else { - Logger.endScope(" = " + result); - } - } - } - output.writeObject(result); - output.flush(); - } - } - } - - /** - * Sends a result without invoking a method, used by CompilationServer startup code. - */ - public void sendResult(Object obj) throws IOException { - output.writeObject(new Result(obj)); - output.flush(); - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/VMEntries.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/VMEntries.java Tue Jan 03 16:47:02 2012 +0100 @@ -25,8 +25,9 @@ import java.lang.reflect.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.ri.*; /** * Entries into the HotSpot VM from Java code. @@ -105,7 +106,5 @@ long getMaxCallTargetOffset(CiRuntimeCall rtcall); - void notifyJavaQueue(); - // Checkstyle: resume }
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/VMEntriesNative.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/VMEntriesNative.java Tue Jan 03 16:47:02 2012 +0100 @@ -25,9 +25,10 @@ import java.lang.reflect.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.ri.*; import com.oracle.max.graal.hotspot.server.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * Entries into the HotSpot VM from Java code. @@ -151,8 +152,5 @@ @Override public native long getMaxCallTargetOffset(CiRuntimeCall rtcall); - @Override - public native void notifyJavaQueue(); - // Checkstyle: resume }
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/VMExits.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/VMExits.java Tue Jan 03 16:47:02 2012 +0100 @@ -23,8 +23,9 @@ package com.oracle.max.graal.hotspot; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.ri.*; /** * Exits from the HotSpot VM into Java code. @@ -33,6 +34,12 @@ void compileMethod(HotSpotMethodResolved method, int entryBCI, boolean blocking) throws Throwable; + void shutdownCompiler() throws Throwable; + + void startCompiler() throws Throwable; + + void bootstrap() throws Throwable; + RiMethod createRiMethodUnresolved(String name, String signature, RiType holder); RiSignature createRiSignature(String signature); @@ -52,10 +59,4 @@ CiConstant createCiConstantDouble(double value); CiConstant createCiConstantObject(Object object); - - void shutdownCompiler() throws Throwable; - - void startCompiler() throws Throwable; - - void bootstrap() throws Throwable; }
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/VMExitsNative.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/VMExitsNative.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,12 +26,15 @@ import java.lang.reflect.*; import java.util.concurrent.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiCompiler.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.criutils.*; import com.oracle.max.graal.compiler.*; +import com.oracle.max.graal.compiler.phases.*; +import com.oracle.max.graal.hotspot.ri.*; import com.oracle.max.graal.hotspot.server.*; -import com.sun.cri.ci.CiCompiler.DebugInfoLevel; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.graal.snippets.*; /** * Exits from the HotSpot VM into Java code. @@ -85,7 +88,12 @@ TTY.initialize(); // Install intrinsics. - HotSpotIntrinsic.installIntrinsics((HotSpotRuntime) compiler.getCompiler().runtime); + HotSpotRuntime runtime = (HotSpotRuntime) compiler.getCompiler().runtime; + if (GraalOptions.Intrinsify) { + GraalIntrinsics.installIntrinsics(runtime, runtime.getCompiler().getTarget(), PhasePlan.DEFAULT); + Snippets.install(runtime, runtime.getCompiler().getTarget(), new SystemSnippets(), GraalOptions.PlotSnippets, PhasePlan.DEFAULT); + Snippets.install(runtime, runtime.getCompiler().getTarget(), new UnsafeSnippets(), GraalOptions.PlotSnippets, PhasePlan.DEFAULT); + } // Create compilation queue. compileQueue = new ThreadPoolExecutor(GraalOptions.Threads, GraalOptions.Threads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), daemonThreadFactory);
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/nodes/ArrayWriteBarrier.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/nodes/ArrayWriteBarrier.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.hotspot.nodes; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; public final class ArrayWriteBarrier extends WriteBarrier implements LIRLowerable {
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/nodes/CurrentThread.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/nodes/CurrentThread.java Tue Jan 03 16:47:02 2012 +0100 @@ -23,10 +23,10 @@ package com.oracle.max.graal.hotspot.nodes; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; public final class CurrentThread extends FloatingNode implements LIRLowerable {
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/nodes/FieldWriteBarrier.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/nodes/FieldWriteBarrier.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.hotspot.nodes; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; public final class FieldWriteBarrier extends WriteBarrier implements LIRLowerable {
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/nodes/TailcallNode.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,79 +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. - * - * 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.oracle.max.graal.hotspot.nodes; - - import static com.sun.cri.ci.CiCallingConvention.Type.*; - -import java.lang.reflect.*; -import java.util.*; - -import com.oracle.max.graal.compiler.gen.*; -import com.oracle.max.graal.hotspot.*; -import com.oracle.max.graal.hotspot.target.amd64.*; -import com.oracle.max.graal.nodes.*; -import com.oracle.max.graal.nodes.spi.*; -import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; - -/** - * Performs a tail call to the specified target compiled method, with the parameter taken from the supplied FrameState. - */ -public class TailcallNode extends FixedWithNextNode implements LIRLowerable { - - @Input private final FrameState frameState; - @Input private final ValueNode target; - - /** - * Creates a TailcallNode. - * @param target points to the start of an nmethod - * @param frameState the parameters will be taken from this FrameState - */ - public TailcallNode(ValueNode target, FrameState frameState) { - super(StampFactory.illegal()); - this.target = target; - this.frameState = frameState; - } - - @Override - public void generate(LIRGeneratorTool generator) { - LIRGenerator gen = (LIRGenerator) generator; - HotSpotVMConfig config = CompilerImpl.getInstance().getConfig(); - RiResolvedMethod method = frameState.method(); - boolean isStatic = Modifier.isStatic(method.accessFlags()); - - - CiKind[] signature = CiUtil.signatureToKinds(method.signature(), isStatic ? null : method.holder().kind(true)); - CiCallingConvention cc = gen.compilation.registerConfig.getCallingConvention(JavaCall, signature, gen.compilation.compiler.target, false); - gen.compilation.frameMap().callsMethod(cc, JavaCall); - List<ValueNode> parameters = new ArrayList<>(); - for (int i = 0; i < cc.locations.length; i++) { - parameters.add(frameState.localAt(i)); - } - List<CiValue> argList = gen.visitInvokeArguments(cc, parameters, null); - - CiVariable entry = gen.emitLoad(new CiAddress(CiKind.Long, gen.operand(target), config.nmethodEntryOffset), CiKind.Long, false); - - gen.append(AMD64TailcallOpcode.TAILCALL.create(argList, entry, cc.locations)); - } -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/nodes/WriteBarrier.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/nodes/WriteBarrier.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.hotspot.nodes; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.hotspot.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; public abstract class WriteBarrier extends FixedWithNextNode {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/ri/HotSpotMethod.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,45 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.ri; + +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.*; +import com.oracle.max.graal.hotspot.Compiler; + +public abstract class HotSpotMethod extends CompilerObject implements RiMethod { + + /** + * + */ + private static final long serialVersionUID = 7167491397941960839L; + protected String name; + + protected HotSpotMethod(Compiler compiler) { + super(compiler); + } + + @Override + public final String name() { + return name; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/ri/HotSpotMethodResolved.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,32 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.ri; + +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.server.*; + +public interface HotSpotMethodResolved extends RiResolvedMethod, Remote { + + RiResolvedMethod uniqueConcreteMethod(); + void dumpProfile(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/ri/HotSpotMethodResolvedImpl.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,310 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.ri; + +import java.lang.annotation.*; +import java.lang.reflect.*; +import java.util.*; +import java.util.concurrent.*; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.criutils.*; +import com.oracle.max.graal.hotspot.*; + +/** + * Implementation of RiMethod for resolved HotSpot methods. + */ +public final class HotSpotMethodResolvedImpl extends HotSpotMethod implements HotSpotMethodResolved { + + /** + * + */ + private static final long serialVersionUID = -5486975070147586588L; + + /** DO NOT USE IN JAVA CODE! */ + @SuppressWarnings("unused") + @Deprecated + private Object javaMirror; + + // cached values + private final int codeSize; + private final int accessFlags; + private final int maxLocals; + private final int maxStackSize; + private RiSignature signature; + private Boolean hasBalancedMonitors; + private Map<Object, Object> compilerStorage; + private RiResolvedType holder; + private byte[] code; + + private HotSpotMethodResolvedImpl() { + super(null); + codeSize = -1; + accessFlags = -1; + maxLocals = -1; + maxStackSize = -1; + throw new IllegalStateException("this constructor is never actually called, because the objects are allocated from within the VM"); + } + + @Override + public RiResolvedType holder() { + return holder; + } + + @Override + public int accessFlags() { + return accessFlags; + } + + @Override + public boolean canBeStaticallyBound() { + return isLeafMethod() || Modifier.isStatic(accessFlags()); + } + + @Override + public byte[] code() { + if (code == null) { + code = compiler.getVMEntries().RiMethod_code(this); + assert code.length == codeSize : "expected: " + codeSize + ", actual: " + code.length; + } + return code; + } + + @Override + public int codeSize() { + return codeSize; + } + + @Override + public RiExceptionHandler[] exceptionHandlers() { + return compiler.getVMEntries().RiMethod_exceptionHandlers(this); + } + + @Override + public boolean hasBalancedMonitors() { + if (hasBalancedMonitors == null) { + hasBalancedMonitors = compiler.getVMEntries().RiMethod_hasBalancedMonitors(this); + } + return hasBalancedMonitors; + } + + @Override + public boolean isClassInitializer() { + return "<clinit>".equals(name) && Modifier.isStatic(accessFlags()); + } + + @Override + public boolean isConstructor() { + return "<init>".equals(name) && !Modifier.isStatic(accessFlags()); + } + + @Override + public boolean isLeafMethod() { + return Modifier.isFinal(accessFlags()) || Modifier.isPrivate(accessFlags()); + } + + @Override + public boolean isOverridden() { + throw new UnsupportedOperationException("isOverridden"); + } + + @Override + public boolean noSafepointPolls() { + return false; + } + + @Override + public String jniSymbol() { + throw new UnsupportedOperationException("jniSymbol"); + } + + public CiBitMap[] livenessMap() { + return null; + } + + @Override + public int maxLocals() { + return maxLocals; + } + + @Override + public int maxStackSize() { + return maxStackSize; + } + + @Override + public StackTraceElement toStackTraceElement(int bci) { + return CiUtil.toStackTraceElement(this, bci); + } + + @Override + public RiResolvedMethod uniqueConcreteMethod() { + return (RiResolvedMethod) compiler.getVMEntries().RiMethod_uniqueConcreteMethod(this); + } + + @Override + public RiSignature signature() { + if (signature == null) { + signature = new HotSpotSignature(compiler, compiler.getVMEntries().RiMethod_signature(this)); + } + return signature; + } + + @Override + public String toString() { + return "HotSpotMethod<" + CiUtil.format("%h.%n", this) + ">"; + } + + public boolean hasCompiledCode() { + return compiler.getVMEntries().RiMethod_hasCompiledCode(this); + } + + @Override + public RiResolvedType accessor() { + return null; + } + + @Override + public String intrinsic() { + return null; + } + + public int invocationCount() { + return compiler.getVMEntries().RiMethod_invocationCount(this); + } + + public int exceptionProbability(int bci) { + return compiler.getVMEntries().RiMethod_exceptionProbability(this, bci); + } + + public RiTypeProfile typeProfile(int bci) { + return compiler.getVMEntries().RiMethod_typeProfile(this, bci); + } + + public double branchProbability(int bci) { + return compiler.getVMEntries().RiMethod_branchProbability(this, bci); + } + + public double[] switchProbability(int bci) { + return compiler.getVMEntries().RiMethod_switchProbability(this, bci); + } + + @Override + public Map<Object, Object> compilerStorage() { + if (compilerStorage == null) { + compilerStorage = new ConcurrentHashMap<>(); + } + return compilerStorage; + } + + @Override + public RiConstantPool getConstantPool() { + return ((HotSpotTypeResolvedImpl) holder()).constantPool(); + } + + public void dumpProfile() { + TTY.println("profile info for %s", this); + TTY.println("canBeStaticallyBound: " + canBeStaticallyBound()); + TTY.println("invocationCount: " + invocationCount()); + for (int i = 0; i < codeSize(); i++) { + if (branchProbability(i) != -1) { + TTY.println(" branchProbability@%d: %f", i, branchProbability(i)); + } + if (exceptionProbability(i) > 0) { + TTY.println(" exceptionProbability@%d: %d", i, exceptionProbability(i)); + } + RiTypeProfile profile = typeProfile(i); + if (profile != null && profile.count > 0) { + TTY.print(" profile@%d: count: %d, morphism: %d", i, profile.count, profile.morphism); + if (profile.types != null) { + TTY.print(", types:"); + for (int i2 = 0; i2 < profile.types.length; i2++) { + TTY.print(" %s (%f)", profile.types[i2], profile.probabilities[i2]); + } + } + TTY.println(); + if (exceptionProbability(i) > 0) { + TTY.println(" exceptionProbability@%d: %d", i, exceptionProbability(i)); + } + } + } + } + + + + @Override + public Annotation[][] getParameterAnnotations() { + if (isConstructor()) { + Constructor javaConstructor = toJavaConstructor(); + return javaConstructor == null ? null : javaConstructor.getParameterAnnotations(); + } + Method javaMethod = toJava(); + return javaMethod == null ? null : javaMethod.getParameterAnnotations(); + } + + @Override + public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { + if (isConstructor()) { + Constructor<?> javaConstructor = toJavaConstructor(); + return javaConstructor == null ? null : javaConstructor.getAnnotation(annotationClass); + } + Method javaMethod = toJava(); + return javaMethod == null ? null : javaMethod.getAnnotation(annotationClass); + } + + @Override + public Type getGenericReturnType() { + if (isConstructor()) { + return void.class; + } + Method javaMethod = toJava(); + return javaMethod == null ? null : javaMethod.getGenericReturnType(); + } + + @Override + public Type[] getGenericParameterTypes() { + if (isConstructor()) { + Constructor javaConstructor = toJavaConstructor(); + return javaConstructor == null ? null : javaConstructor.getGenericParameterTypes(); + } + Method javaMethod = toJava(); + return javaMethod == null ? null : javaMethod.getGenericParameterTypes(); + } + + private Method toJava() { + try { + return holder.toJava().getDeclaredMethod(name, CiUtil.signatureToTypes(signature, holder)); + } catch (NoSuchMethodException e) { + return null; + } + } + + private Constructor toJavaConstructor() { + try { + return holder.toJava().getDeclaredConstructor(CiUtil.signatureToTypes(signature, holder)); + } catch (NoSuchMethodException e) { + return null; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/ri/HotSpotMethodUnresolved.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,61 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.ri; + +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.*; +import com.oracle.max.graal.hotspot.Compiler; + +/** + * Implementation of RiMethod for unresolved HotSpot methods. + */ +public final class HotSpotMethodUnresolved extends HotSpotMethod { + /** + * + */ + private static final long serialVersionUID = 5610263481791970079L; + private final RiSignature signature; + protected RiType holder; + + public HotSpotMethodUnresolved(Compiler compiler, String name, String signature, RiType holder) { + super(compiler); + this.name = name; + this.holder = holder; + this.signature = new HotSpotSignature(compiler, signature); + } + + @Override + public RiSignature signature() { + return signature; + } + + @Override + public RiType holder() { + return holder; + } + + @Override + public String toString() { + return "HotSpotMethod<" + holder.name() + ". " + name + ", unresolved>"; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/ri/HotSpotType.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,47 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.ri; + +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.*; +import com.oracle.max.graal.hotspot.Compiler; + +/** + * Common interface for all HotSpot RiType-implementations. + */ +public abstract class HotSpotType extends CompilerObject implements RiType { + /** + * + */ + private static final long serialVersionUID = -4252886265301910771L; + protected String name; + + protected HotSpotType(Compiler compiler) { + super(compiler); + } + + @Override + public final String name() { + return name; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/ri/HotSpotTypePrimitive.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,169 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.ri; + +import java.lang.annotation.*; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.compiler.util.*; +import com.oracle.max.graal.hotspot.Compiler; + +/** + * Implementation of RiType for primitive HotSpot types. + */ +public final class HotSpotTypePrimitive extends HotSpotType implements RiResolvedType { + + /** + * + */ + private static final long serialVersionUID = -6208552348908071473L; + private CiKind kind; + + + public HotSpotTypePrimitive(Compiler compiler, CiKind kind) { + super(compiler); + this.kind = kind; + this.name = kind.toString(); + } + + @Override + public int accessFlags() { + return kind.toJavaClass().getModifiers(); + } + + @Override + public RiResolvedType arrayOf() { + return (RiResolvedType) compiler.getVMEntries().getPrimitiveArrayType(kind); + } + + @Override + public RiResolvedType componentType() { + return null; + } + + @Override + public RiResolvedType exactType() { + return this; + } + + @Override + public RiResolvedType superType() { + return null; + } + + @Override + public CiConstant getEncoding(Representation r) { + throw Util.unimplemented("HotSpotTypePrimitive.getEncoding"); + } + + @Override + public CiKind getRepresentationKind(Representation r) { + return kind; + } + + @Override + public boolean hasFinalizableSubclass() { + return false; + } + + @Override + public boolean hasFinalizer() { + return false; + } + + @Override + public boolean hasSubclass() { + return false; + } + + @Override + public boolean isArrayClass() { + return false; + } + + @Override + public boolean isInitialized() { + return true; + } + + @Override + public boolean isInstance(CiConstant obj) { + return false; + } + + @Override + public boolean isInstanceClass() { + return false; + } + + @Override + public boolean isInterface() { + return false; + } + + @Override + public boolean isSubtypeOf(RiResolvedType other) { + return false; + } + + @Override + public CiKind kind(boolean architecture) { + return kind; + } + + @Override + public RiResolvedMethod resolveMethodImpl(RiResolvedMethod method) { + return null; + } + + @Override + public String toString() { + return "HotSpotTypePrimitive<" + kind + ">"; + } + + @Override + public RiResolvedType uniqueConcreteSubtype() { + return this; + } + + @Override + public RiResolvedMethod uniqueConcreteMethod(RiResolvedMethod method) { + return null; + } + + @Override + public RiResolvedField[] declaredFields() { + return null; + } + + @Override + public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { + return toJava().getAnnotation(annotationClass); + } + + @Override + public Class< ? > toJava() { + return kind.toJavaClass(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/ri/HotSpotTypeResolved.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,38 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.ri; + +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.server.*; + +public interface HotSpotTypeResolved extends RiResolvedType, Remote { + + String toString(); + + RiConstantPool constantPool(); + + int instanceSize(); + + RiField createRiField(String name, RiType type, int offset, int flags); + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/ri/HotSpotTypeResolvedImpl.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,253 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.ri; + +import java.lang.annotation.*; +import java.lang.reflect.*; +import java.util.*; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.*; + +/** + * Implementation of RiType for resolved non-primitive HotSpot classes. + */ +public final class HotSpotTypeResolvedImpl extends HotSpotType implements HotSpotTypeResolved { + + /** + * + */ + private static final long serialVersionUID = 3481514353553840471L; + private Class javaMirror; + private String simpleName; + private int accessFlags; + private boolean hasFinalizer; + private boolean hasSubclass; + private boolean hasFinalizableSubclass; + private boolean isArrayClass; + private boolean isInstanceClass; + private boolean isInterface; + private int instanceSize; + private HashMap<Long, RiResolvedField> fieldCache; + private RiResolvedType superType; + private boolean superTypeSet; + private RiResolvedField[] fields; + private RiConstantPool constantPool; + private boolean isInitialized; + private RiResolvedType arrayOfType; + + private HotSpotTypeResolvedImpl() { + super(null); + } + + @Override + public int accessFlags() { + return accessFlags; + } + + @Override + public RiResolvedType arrayOf() { + if (arrayOfType == null) { + arrayOfType = (RiResolvedType) compiler.getVMEntries().RiType_arrayOf(this); + } + return arrayOfType; + } + + @Override + public RiResolvedType componentType() { + assert isArrayClass(); + return (RiResolvedType) compiler.getVMEntries().RiType_componentType(this); + } + + @Override + public RiResolvedType uniqueConcreteSubtype() { + return (RiResolvedType) compiler.getVMEntries().RiType_uniqueConcreteSubtype(this); + } + + @Override + public RiResolvedType superType() { + if (!superTypeSet) { + superType = (RiResolvedType) compiler.getVMEntries().RiType_superType(this); + superTypeSet = true; + } + return superType; + } + + @Override + public RiResolvedType exactType() { + if (Modifier.isFinal(accessFlags)) { + return this; + } + return null; + } + + @Override + public CiConstant getEncoding(Representation r) { + switch (r) { + case JavaClass: + return CiConstant.forObject(javaMirror); + case ObjectHub: + return CiConstant.forObject(this); + case StaticFields: + return CiConstant.forObject(javaMirror); + case TypeInfo: + return CiConstant.forObject(this); + default: + return null; + } + } + + @Override + public CiKind getRepresentationKind(Representation r) { + return CiKind.Object; + } + + @Override + public boolean hasFinalizableSubclass() { + return hasFinalizableSubclass; + } + + @Override + public boolean hasFinalizer() { + return hasFinalizer; + } + + @Override + public boolean hasSubclass() { + return hasSubclass; + } + + @Override + public boolean isArrayClass() { + return isArrayClass; + } + + @Override + public boolean isInitialized() { + if (!isInitialized) { + isInitialized = compiler.getVMEntries().RiType_isInitialized(this); + } + return isInitialized; + } + + @Override + public boolean isInstance(CiConstant obj) { + return javaMirror.isInstance(obj); + } + + @Override + public boolean isInstanceClass() { + return isInstanceClass; + } + + @Override + public boolean isInterface() { + return isInterface; + } + + @Override + public boolean isSubtypeOf(RiResolvedType other) { + if (other instanceof HotSpotTypeResolved) { + return compiler.getVMEntries().RiType_isSubtypeOf(this, other); + } + // No resolved type is a subtype of an unresolved type. + return false; + } + + @Override + public CiKind kind(boolean architecture) { + return CiKind.Object; + } + + @Override + public RiResolvedMethod resolveMethodImpl(RiResolvedMethod method) { + assert method instanceof HotSpotMethod; + return (RiResolvedMethod) compiler.getVMEntries().RiType_resolveMethodImpl(this, method.name(), method.signature().asString()); + } + + @Override + public String toString() { + return "HotSpotType<" + simpleName + ", resolved>"; + } + + @Override + public RiConstantPool constantPool() { + if (constantPool == null) { + constantPool = new HotSpotConstantPool(compiler, this); + } + return constantPool; + } + + @Override + public int instanceSize() { + return instanceSize; + } + + @Override + public synchronized RiResolvedField createRiField(String fieldName, RiType type, int offset, int flags) { + RiResolvedField result = null; + + long id = offset + ((long) flags << 32); + + // (tw) Must cache the fields, because the local load elimination only works if the objects from two field lookups are equal. + if (fieldCache == null) { + fieldCache = new HashMap<>(8); + } else { + result = fieldCache.get(id); + } + + if (result == null) { + result = new HotSpotField(compiler, this, fieldName, type, offset, flags); + fieldCache.put(id, result); + } else { + assert result.name().equals(fieldName); + assert result.accessFlags() == flags; + } + + return result; + } + + @Override + public RiResolvedMethod uniqueConcreteMethod(RiResolvedMethod method) { + return ((HotSpotMethodResolved) method).uniqueConcreteMethod(); + } + + @Override + public RiResolvedField[] declaredFields() { + if (fields == null) { + fields = compiler.getVMEntries().RiType_fields(this); + } + return fields; + } + + @Override + public Class< ? > toJava() { + return javaMirror; + } + + @Override + public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { + return toJava().getAnnotation(annotationClass); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/ri/HotSpotTypeUnresolved.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,119 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.ri; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.hotspot.Compiler; + +/** + * Implementation of RiType for unresolved HotSpot classes. + */ +public class HotSpotTypeUnresolved extends HotSpotType { + + /** + * + */ + private static final long serialVersionUID = -2320936267633521314L; + public final String simpleName; + public final int dimensions; + + /** + * Creates a new unresolved type for a specified type descriptor. + */ + public HotSpotTypeUnresolved(Compiler compiler, String name) { + super(compiler); + assert name.length() > 0 : "name cannot be empty"; + + int dims = 0; + // Decode name if necessary. + if (name.charAt(name.length() - 1) == ';') { + int startIndex = 0; + while (name.charAt(startIndex) == '[') { + startIndex++; + dims++; + } + assert name.charAt(startIndex) == 'L'; + this.simpleName = name.substring(startIndex + 1, name.length() - 1); + this.name = name; + } else { + this.simpleName = name; + this.name = getFullName(name, dims); + } + + this.dimensions = dims; + } + + public HotSpotTypeUnresolved(Compiler compiler, String name, int dimensions) { + super(compiler); + assert dimensions >= 0; + this.simpleName = name; + this.dimensions = dimensions; + this.name = getFullName(name, dimensions); + } + + private static String getFullName(String name, int dimensions) { + StringBuilder str = new StringBuilder(name.length() + dimensions + 2); + for (int i = 0; i < dimensions; i++) { + str.append('['); + } + str.append('L').append(name).append(';'); + return str.toString(); + } + + @Override + public RiType componentType() { + assert dimensions > 0 : "no array class" + name(); + return new HotSpotTypeUnresolved(compiler, simpleName, dimensions - 1); + } + + @Override + public RiType arrayOf() { + return new HotSpotTypeUnresolved(compiler, simpleName, dimensions + 1); + } + + @Override + public CiKind kind(boolean architecture) { + return CiKind.Object; + } + + @Override + public int hashCode() { + return simpleName.hashCode(); + } + + @Override + public boolean equals(Object o) { + return o == this; + } + + @Override + public String toString() { + return "HotSpotType<" + simpleName + ", unresolved>"; + } + + @Override + public CiKind getRepresentationKind(RiType.Representation r) { + return CiKind.Object; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/server/InvocationSocket.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,282 @@ +/* + * 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. + * + * 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.oracle.max.graal.hotspot.server; + +import java.io.*; +import java.lang.reflect.*; +import java.util.*; + +import com.oracle.max.graal.hotspot.logging.*; + +/** + * A collection of java.lang.reflect proxies that communicate over a socket connection. + * + * Calling a method sends the method name and the parameters through the socket. Afterwards this class waits for a + * result. While waiting for a result three types of objects can arrive through the socket: a method invocation, a + * method result or an exception. Method invocation can thus be recursive. + */ +public class InvocationSocket { + + private static final boolean DEBUG = false; + private static final boolean COUNT_CALLS = false; + + private static final HashSet<String> cachedMethodNames = new HashSet<>(); + private static final HashSet<String> forbiddenMethodNames = new HashSet<>(); + + static { + cachedMethodNames.add("name"); + cachedMethodNames.add("kind"); + cachedMethodNames.add("isResolved"); + cachedMethodNames.add("getVMEntries"); + cachedMethodNames.add("exactType"); + cachedMethodNames.add("isInitialized"); + forbiddenMethodNames.add("javaClass"); + } + + private final ObjectOutputStream output; + private final ObjectInputStream input; + + private final Map<String, Integer> counts = new HashMap<>(); + + public InvocationSocket(ObjectOutputStream output, ObjectInputStream input) { + this.output = output; + this.input = input; + + if (COUNT_CALLS) { + Runtime.getRuntime().addShutdownHook(new Thread() { + @Override + public void run() { + SortedMap<Integer, String> sorted = new TreeMap<>(); + for (Map.Entry<String, Integer> entry : counts.entrySet()) { + sorted.put(entry.getValue(), entry.getKey()); + } + for (Map.Entry<Integer, String> entry : sorted.entrySet()) { + System.out.println(entry.getKey() + ": " + entry.getValue()); + } + } + }); + } + } + + /** + * Represents one invocation of a method that is transferred via the socket connection. + * + */ + private static class Invocation implements Serializable { + + /** + * + */ + private static final long serialVersionUID = -799162779226626066L; + public Object receiver; + public String methodName; + public Object[] args; + + public Invocation(Object receiver, String methodName, Object[] args) { + this.receiver = receiver; + this.methodName = methodName; + this.args = args; + } + } + + /** + * Represents the result of an invocation that is transferred via the socket connection. + * + */ + private static class Result implements Serializable { + + /** + * + */ + private static final long serialVersionUID = -7496058356272415814L; + public Object result; + + public Result(Object result) { + this.result = result; + } + } + + private void incCount(String name, Object[] args) { + if (COUNT_CALLS) { + String nameAndArgCount = name + (args == null ? 0 : args.length); + if (counts.get(nameAndArgCount) != null) { + counts.put(nameAndArgCount, counts.get(nameAndArgCount) + 1); + } else { + counts.put(nameAndArgCount, 1); + } + } + } + + /** + * Each instance of this class handles remote invocations for one instance of a Remote class. It will forward all + * interface methods to the other end of the socket and cache the results of calls to certain methods. + * + */ + public class Handler implements InvocationHandler { + + private final Object receiver; + private final HashMap<String, Object> cache = new HashMap<>(); + + public Handler(Object receiver) { + this.receiver = receiver; + } + + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + // only interface methods can be transferred, java.lang.Object methods + if (method.getDeclaringClass() == Object.class) { + return method.invoke(receiver, args); + } + String methodName = method.getName(); + // check if the result of this zero-arg method was cached + if (args == null || args.length == 0) { + if (cache.containsKey(methodName)) { + return cache.get(methodName); + } + } + if (forbiddenMethodNames.contains(methodName)) { + throw new IllegalAccessException(methodName + " not allowed"); + } + Object result = null; + try { + if (DEBUG) { + Logger.startScope("invoking remote " + methodName); + } + incCount(methodName, args); + + output.writeObject(new Invocation(receiver, methodName, args)); + output.flush(); + result = waitForResult(false); + + // result caching for selected methods + if ((args == null || args.length == 0) && cachedMethodNames.contains(methodName)) { + cache.put(methodName, result); + } + return result; + } catch (Throwable t) { + t.printStackTrace(); + throw t; + } finally { + if (DEBUG) { + Logger.endScope(" = " + result); + } + } + } + } + + /** + * Waits for the result of a remote method invocation. Invocations that should be executed in this VM might arrive + * while waiting for the result, and these invocations will be executed before again waiting fort he result. + */ + @SuppressWarnings("unused") + public Object waitForResult(boolean eofExpected) throws IOException, ClassNotFoundException { + while (true) { + Object in; + try { + in = input.readObject(); + } catch (EOFException e) { + if (eofExpected) { + return null; + } + throw e; + } + if (in instanceof Result) { + return ((Result) in).result; + } else if (in instanceof RuntimeException) { + throw (RuntimeException) in; + } else if (in instanceof Throwable) { + throw new RuntimeException((Throwable) in); + } + + Invocation invoke = (Invocation) in; + Method method = null; + for (Class<?> clazz = invoke.receiver.getClass(); clazz != null; clazz = clazz.getSuperclass()) { + for (Method m : clazz.getDeclaredMethods()) { + if (invoke.methodName.equals(m.getName())) { + method = m; + break; + } + } + } + if (method == null) { + Exception e = new UnsupportedOperationException("unknown method " + invoke.methodName); + e.printStackTrace(); + output.writeObject(e); + output.flush(); + } else { + Object result = null; + try { + if (invoke.args == null) { + if (DEBUG) { + Logger.startScope("invoking local " + invoke.methodName); + } + result = method.invoke(invoke.receiver); + } else { + if (Logger.ENABLED && DEBUG) { + StringBuilder str = new StringBuilder(); + str.append("invoking local " + invoke.methodName + "("); + for (int i = 0; i < invoke.args.length; i++) { + str.append(i == 0 ? "" : ", "); + str.append(Logger.pretty(invoke.args[i])); + } + str.append(")"); + Logger.startScope(str.toString()); + } + result = method.invoke(invoke.receiver, invoke.args); + } + result = new Result(result); + } catch (IllegalArgumentException e) { + System.out.println("error while invoking " + invoke.methodName); + e.getCause().printStackTrace(); + result = e.getCause(); + } catch (InvocationTargetException e) { + System.out.println("error while invoking " + invoke.methodName); + e.getCause().printStackTrace(); + result = e.getCause(); + } catch (IllegalAccessException e) { + System.out.println("error while invoking " + invoke.methodName); + e.getCause().printStackTrace(); + result = e.getCause(); + } finally { + if (DEBUG) { + if (result instanceof Result) { + Logger.endScope(" = " + ((Result) result).result); + } else { + Logger.endScope(" = " + result); + } + } + } + output.writeObject(result); + output.flush(); + } + } + } + + /** + * Sends a result without invoking a method, used by CompilationServer startup code. + */ + public void sendResult(Object obj) throws IOException { + output.writeObject(new Result(obj)); + output.flush(); + } +}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/server/ReplacingStreams.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/server/ReplacingStreams.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,8 +26,8 @@ import java.lang.reflect.*; import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.hotspot.*; -import com.sun.cri.ci.*; public class ReplacingStreams {
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/snippets/HotSpotThreadSnippets.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,41 +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. - * - * 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.oracle.max.graal.hotspot.snippets; - -import com.oracle.max.graal.hotspot.nodes.*; -import com.oracle.max.graal.snippets.*; - -@ClassSubstitution(java.lang.Thread.class) -public class HotSpotThreadSnippets implements SnippetsInterface { - - private final int threadObjectOffset; - - public HotSpotThreadSnippets(int threadObjectOffset) { - this.threadObjectOffset = threadObjectOffset; - } - - public Thread currentThread() { - return (Thread) CurrentThread.get(threadObjectOffset); - } - -}
--- a/graal/com.oracle.max.graal.hotspot/src/com/oracle/max/graal/hotspot/target/amd64/AMD64TailcallOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,83 +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. - * - * 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.oracle.max.graal.hotspot.target.amd64; - -import static com.sun.cri.ci.CiValueUtil.*; - -import java.util.*; - -import com.oracle.max.asm.target.amd64.AMD64MacroAssembler; -import com.oracle.max.graal.compiler.asm.TargetMethodAssembler; -import com.oracle.max.graal.compiler.lir.LIRInstruction; -import com.oracle.max.graal.compiler.lir.LIROpcode; -import com.oracle.max.graal.compiler.target.amd64.AMD64LIRInstruction; -import com.oracle.max.graal.compiler.util.Util; -import com.sun.cri.ci.*; - -/** - * Performs a hard-coded tail call to the specified target, which normally should be an RiCompiledCode instance. - */ -public enum AMD64TailcallOpcode implements LIROpcode { - TAILCALL; - - public LIRInstruction create(List<CiValue> parameters, CiValue target, CiValue[] callingConvention) { - CiValue[] inputs = new CiValue[parameters.size() + 1]; - parameters.toArray(inputs); - inputs[parameters.size()] = target; - CiValue[] temps = callingConvention.clone(); - assert inputs.length == temps.length + 1; - - return new AMD64LIRInstruction(this, CiValue.IllegalValue, null, inputs, LIRInstruction.NO_OPERANDS, temps) { - @Override - public void emitCode(TargetMethodAssembler tasm, AMD64MacroAssembler masm) { - emit(tasm, masm, inputs, temps); - } - }; - } - - private void emit(TargetMethodAssembler tasm, AMD64MacroAssembler masm, CiValue[] inputs, CiValue[] temps) { - switch (this) { - case TAILCALL: { - // move all parameters to the correct positions, according to the calling convention - // TODO: These moves should not be part of the TAILCALL opcode, but emitted as separate MOVE instructions before. - for (int i = 0; i < inputs.length - 1; i++) { - assert inputs[i].kind == CiKind.Object || inputs[i].kind == CiKind.Int || inputs[i].kind == CiKind.Long : "only Object, int and long supported for now"; - assert isRegister(temps[i]) : "too many parameters"; - if (isRegister(inputs[i])) { - masm.movq(asRegister(temps[i]), asRegister(inputs[i])); - } else { - masm.movq(asRegister(temps[i]), tasm.asAddress(inputs[i])); - } - } - // destroy the current frame (now the return address is the top of stack) - masm.leave(); - - // jump to the target method - masm.jmp(asRegister(inputs[inputs.length - 1])); - masm.ensureUniquePC(); - break; - } - default: throw Util.shouldNotReachHere(); - } - } -}
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/cri/GraalRuntime.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/cri/GraalRuntime.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,9 +24,9 @@ import java.util.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ri.*; /** * Graal-specific extensions for the runtime interface that must be implemented by the VM.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/CallTargetNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/CallTargetNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public abstract class CallTargetNode extends ValueNode implements LIRLowerable { @Input protected final NodeInputList<ValueNode> arguments;
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/ConstantNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/ConstantNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * The {@code ConstantNode} represents a constant such as an integer value,
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/FrameState.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/FrameState.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,12 +24,12 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.PhiNode.PhiType; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.virtual.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * The {@code FrameState} class encapsulates the frame state (i.e. local variables and
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/InvokeNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/InvokeNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,12 +24,12 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; /** * The {@code InvokeNode} represents all kinds of method calls.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/InvokeWithExceptionNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/InvokeWithExceptionNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,13 +24,13 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.util.*; -import com.sun.cri.ci.*; public class InvokeWithExceptionNode extends ControlSplitNode implements Node.IterableNodeType, Invoke, MemoryCheckpoint, LIRLowerable { private static final int NORMAL_EDGE = 0;
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/LocalNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/LocalNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * The {@code Local} instruction is a placeholder for an incoming argument
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/LoopBeginNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/LoopBeginNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,10 +24,10 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.loop.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; public class LoopBeginNode extends MergeNode implements Node.IterableNodeType, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/PhiNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/PhiNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * The {@code PhiNode} represents the merging of dataflow in the graph. It refers to a merge
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/ReturnNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/ReturnNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; public final class ReturnNode extends FixedNode implements LIRLowerable, Node.IterableNodeType {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/UnwindNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/UnwindNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * Unwind takes an exception object, destroys the current stack frame and passes the exception object to the system's exception dispatch code.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/ValueNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/ValueNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * This class represents a value within the graph, including local variables, phis, and
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/ValueUtil.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/ValueUtil.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,9 +24,9 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.graph.Node.Verbosity; -import com.sun.cri.ci.*; public class ValueUtil { @@ -96,7 +96,7 @@ /** * Converts a given instruction to a value string. The representation of an node as - * a value is formed by concatenating the {@linkplain com.sun.cri.ci.CiKind#typeChar character} denoting its + * a value is formed by concatenating the {@linkplain com.oracle.max.cri.ci.CiKind#typeChar character} denoting its * {@linkplain ValueNode#kind kind} and its {@linkplain Node#id()}. For example, {@code "i13"}. * * @param value the instruction to convert to a value string. If {@code value == null}, then "-" is returned.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/AndNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/AndNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "&") public final class AndNode extends LogicNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/ArithmeticNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/ArithmeticNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; /** * The {@code ArithmeticOp} class represents arithmetic operations such as addition, subtraction, etc.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/BinaryNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/BinaryNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * The {@code BinaryNode} class is the base of arithmetic and logic operations with two inputs.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/CompareNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/CompareNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /* TODO(tw/gd) For high-level optimization purpose the compare node should be a boolean *value* (it is currently only a helper node) * But in the back-end the comparison should not always be materialized (for example in x86 the comparison result will not be in a register but in a flag)
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/Condition.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/Condition.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.calc; -import com.oracle.max.cri.intrinsics.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.cri.util.*; /** * Condition codes used in conditionals.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/ConditionalNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/ConditionalNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.PhiNode.PhiType; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; /** * The {@code ConditionalNode} class represents a comparison that yields one of two values. Note that these nodes are not
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/ConvertNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/ConvertNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.nodes.calc; -import static com.sun.cri.ci.CiKind.*; +import static com.oracle.max.cri.ci.CiKind.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * The {@code ConvertNode} class represents a conversion between primitive types.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatAddNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatAddNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "+") public final class FloatAddNode extends FloatArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatArithmeticNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatArithmeticNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; public abstract class FloatArithmeticNode extends ArithmeticNode {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatDivNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatDivNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "/") public final class FloatDivNode extends FloatArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatMulNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatMulNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "*") public final class FloatMulNode extends FloatArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatRemNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatRemNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "%") public final class FloatRemNode extends FloatArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatSubNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/FloatSubNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "-") public final class FloatSubNode extends FloatArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerAddNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerAddNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "+") public final class IntegerAddNode extends IntegerArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerArithmeticNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerArithmeticNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; public abstract class IntegerArithmeticNode extends ArithmeticNode {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerDivNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerDivNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "/") public final class IntegerDivNode extends IntegerArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerMulNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerMulNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "*") public final class IntegerMulNode extends IntegerArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerRemNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerRemNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "%") public final class IntegerRemNode extends IntegerArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerSubNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/IntegerSubNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "-") public final class IntegerSubNode extends IntegerArithmeticNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/LeftShiftNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/LeftShiftNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "<<") public final class LeftShiftNode extends ShiftNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/LogicNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/LogicNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; /** * The {@code LogicNode} class definition.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/NormalizeCompareNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/NormalizeCompareNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,9 +24,9 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; /** * Returns -1, 0, or 1 if either x > y, x == y, or x < y.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/NullCheckNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/NullCheckNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; public final class NullCheckNode extends BooleanNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/OrNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/OrNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "|") public final class OrNode extends LogicNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/RightShiftNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/RightShiftNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = ">>") public final class RightShiftNode extends ShiftNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/ShiftNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/ShiftNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; /** * The {@code ShiftOp} class represents shift operations.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/UnsignedRightShiftNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/UnsignedRightShiftNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = ">>>") public final class UnsignedRightShiftNode extends ShiftNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/XorNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/calc/XorNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.calc; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; @NodeInfo(shortName = "^") public final class XorNode extends LogicNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/AccessNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/AccessNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; public abstract class AccessNode extends AbstractStateSplit {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/BoxNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/BoxNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.java.MethodCallTargetNode.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public final class BoxNode extends AbstractStateSplit implements Node.IterableNodeType {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/BoxingMethodPool.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/BoxingMethodPool.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,8 +24,8 @@ import java.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; public class BoxingMethodPool {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/IndexedLocationNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/IndexedLocationNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiAddress.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiAddress.Scale; public final class IndexedLocationNode extends LocationNode implements LIRLowerable, Canonicalizable { @Input private ValueNode index;
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/LocationNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/LocationNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,14 +22,14 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ci.CiAddress.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.graph.Node.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ci.CiAddress.Scale; public class LocationNode extends FloatingNode implements LIRLowerable, ValueNumberable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/ReadNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/ReadNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,11 +24,11 @@ import sun.misc.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public final class ReadNode extends AccessNode implements Node.ValueNumberable, Node.IterableNodeType, LIRLowerable, Canonicalizable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/RuntimeCallNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/RuntimeCallNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; public final class RuntimeCallNode extends AbstractCallNode implements LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/SafeAccessNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/SafeAccessNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; public abstract class SafeAccessNode extends AbstractStateSplit {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/SafeReadNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/SafeReadNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; public class SafeReadNode extends SafeAccessNode implements Lowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/SafeWriteNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/SafeWriteNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; public class SafeWriteNode extends SafeAccessNode implements Lowerable{
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/UnboxNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/UnboxNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public final class UnboxNode extends FixedWithNextNode implements Node.IterableNodeType, Canonicalizable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/UnsafeCastNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/UnsafeCastNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ri.*; /** * The {@code UnsafeCastNode} produces the same value as its input, but with a different type.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/UnsafeLoadNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/UnsafeLoadNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * Load of a value from a location specified as an offset relative to an object.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/UnsafeStoreNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/UnsafeStoreNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * Store of a value at a location specified as an offset relative to an object.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/ValueAnchorNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/ValueAnchorNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * The ValueAnchor instruction keeps non-CFG (floating) nodes above a certain point in the graph.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/WriteNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/extended/WriteNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.extended; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; public final class WriteNode extends AccessNode implements LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/AccessFieldNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/AccessFieldNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -25,12 +25,12 @@ import java.lang.reflect.*; import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * The base class of all instructions that access fields.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/AccessIndexedNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/AccessIndexedNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * The {@code AccessIndexedNode} class is the base class of instructions that read or write
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/ArrayLengthNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/ArrayLengthNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * The {@code ArrayLength} instruction gets the length of an array.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/CheckCastNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/CheckCastNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,14 +22,13 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.bytecode.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * The {@code CheckCastNode} represents a {@link Bytecodes#CHECKCAST}.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/CompareAndSwapNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/CompareAndSwapNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * Represents an atomic compare-and-swap operation. If {@link #directResult} is true then the value read from the memory location is produced.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/ExceptionObjectNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/ExceptionObjectNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * The {@code ExceptionObject} instruction represents the incoming exception object to an exception handler.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/InstanceOfNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/InstanceOfNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,13 +22,13 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * The {@code InstanceOfNode} represents an instanceof test.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/IsTypeNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/IsTypeNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,12 +24,12 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public final class IsTypeNode extends BooleanNode implements Canonicalizable, LIRLowerable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/LoadFieldNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/LoadFieldNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * The {@code LoadFieldNode} represents a read of a static or instance field.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/LoadIndexedNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/LoadIndexedNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * The {@code LoadIndexedNode} represents a read from an element of an array.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/MethodCallTargetNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/MethodCallTargetNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public class MethodCallTargetNode extends CallTargetNode implements Node.IterableNodeType, Canonicalizable { public enum InvokeKind {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewArrayNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewArrayNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,12 +24,12 @@ import java.util.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * The {@code NewArrayNode} class is the base of all instructions that allocate arrays.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewInstanceNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewInstanceNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,11 +24,11 @@ import java.util.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ri.*; /** * The {@code NewInstanceNode} represents the allocation of an instance class object.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewMultiArrayNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewMultiArrayNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ri.*; /** * The {@code NewMultiArrayNode} represents an allocation of a multi-dimensional object
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewObjectArrayNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewObjectArrayNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ri.*; /** * The {@code NewObjectArrayNode} represents an allocation of an object array.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewTypeArrayNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/NewTypeArrayNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ri.*; /** * The {@code NewTypeArrayNode} class definition.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/RegisterFinalizerNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/RegisterFinalizerNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; /** * This node is used to perform the finalizer registration at the end of the java.lang.Object constructor.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/StoreFieldNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/StoreFieldNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ri.*; /** * The {@code StoreFieldNode} represents a write to a static or instance field.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/StoreIndexedNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/StoreIndexedNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; /** * The {@code StoreIndexedNode} represents a write to an array element.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/TypeCheckNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/java/TypeCheckNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.java; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ri.*; /** * The {@code TypeCheckNode} is the base class of casts and instanceof tests.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/BasicInductionVariableNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/BasicInductionVariableNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.loop; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.PhiNode.PhiType; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; /** * LinearInductionVariable that is computed in the loops thanks to Phi(init, this + stride).
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/DerivedInductionVariableNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/DerivedInductionVariableNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.loop; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ci.*; /** * LinearInductionVariable that is computed in the loops with offset + scale * base.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/InductionVariableNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/InductionVariableNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.nodes.loop; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.type.*; import com.oracle.max.graal.util.*; -import com.sun.cri.ci.*; /** * This is a base class for all induction variables nodes.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/LinearInductionVariableNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/LinearInductionVariableNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.loop; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; /** * InductionVariable of the form a*x+b.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/LoopCounterNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/loop/LoopCounterNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.loop; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; /** * Counts loop iterations from 0 to Niter.
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/spi/CanonicalizerTool.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/spi/CanonicalizerTool.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.nodes.spi; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; public interface CanonicalizerTool {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/spi/EscapeField.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/spi/EscapeField.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,7 +22,7 @@ */ package com.oracle.max.graal.nodes.spi; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ri.*; public class EscapeField {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/spi/EscapeOp.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/spi/EscapeOp.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,12 +24,12 @@ import java.util.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.virtual.*; -import com.sun.cri.ci.*; public abstract class EscapeOp {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/spi/LIRGeneratorTool.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/spi/LIRGeneratorTool.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,12 +22,12 @@ */ package com.oracle.max.graal.nodes.spi; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.DeoptimizeNode.DeoptAction; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.java.*; -import com.sun.cri.ci.*; public abstract class LIRGeneratorTool { public abstract CiTarget target();
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/type/Stamp.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/type/Stamp.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.graal.nodes.type; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; public interface Stamp {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/type/StampFactory.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/type/StampFactory.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,8 +24,8 @@ import java.util.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; public class StampFactory {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/virtual/BoxedVirtualObjectNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/virtual/BoxedVirtualObjectNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.nodes.virtual; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; -import com.sun.cri.ri.*; public class BoxedVirtualObjectNode extends VirtualObjectNode implements LIRLowerable, Node.ValueNumberable {
--- a/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/virtual/VirtualObjectNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/virtual/VirtualObjectNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,10 +24,10 @@ import java.util.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ri.*; public class VirtualObjectNode extends ValueNode implements LIRLowerable {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.printer/src/com/oracle/max/graal/printer/BasicIdealGraphPrinter.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,303 @@ +/* + * 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. + * + * 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.oracle.max.graal.printer; + +import java.io.*; +import java.util.*; +import java.util.Map.Entry; + +/** + * Elementary, generic generator of Ideal Graph Visualizer input for use in printers for specific data structures. + */ +public class BasicIdealGraphPrinter { + + /** + * Edge between two nodes. + */ + public static class Edge { + final String from; + final int fromIndex; + final String to; + final int toIndex; + final String label; + + public Edge(String from, int fromIndex, String to, int toIndex, String label) { + assert (from != null && to != null); + this.from = from; + this.fromIndex = fromIndex; + this.to = to; + this.toIndex = toIndex; + this.label = label; + } + + @Override + public int hashCode() { + int h = from.hashCode() ^ to.hashCode(); + h = 3 * h + fromIndex; + h = 5 * h + toIndex; + if (label != null) { + h ^= label.hashCode(); + } + return h; + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof Edge) { + Edge other = (Edge) obj; + return from.equals(other.from) + && fromIndex == other.fromIndex + && to.equals(other.to) + && toIndex == other.toIndex + && (label == other.label || (label != null && label.equals(other.label))); + } + return false; + } + } + + private final PrintStream stream; + + /** + * Creates a new {@link IdealGraphPrinter} that writes to the specified output stream. + */ + public BasicIdealGraphPrinter(OutputStream stream) { + this.stream = new PrintStream(stream); + } + + /** + * Flushes any buffered output. + */ + public void flush() { + stream.flush(); + } + + /** + * Starts a new graph document. + */ + public void begin() { + stream.println("<graphDocument>"); + } + + public void beginGroup() { + stream.println("<group>"); + } + + public void beginMethod(String name, String shortName, int bci) { + stream.printf(" <method name='%s' shortName='%s' bci='%d'>%n", escape(name), escape(shortName), bci); + } + + public void beginBytecodes() { + stream.println(" <bytecodes>\n<![CDATA["); + } + + public void printBytecode(int bci, String mnemonic, int[] extra) { + stream.print(bci); + stream.print(' '); + stream.print(mnemonic); + if (extra != null) { + for (int b : extra) { + stream.print(' '); + stream.print(b); + } + } + stream.println(); + } + + public void endBytecodes() { + stream.println(" ]]></bytecodes>"); + } + + public void endMethod() { + stream.println(" </method>"); + } + + public void beginGraph(String title) { + stream.printf(" <graph name='%s'>%n", escape(title)); + } + + public void beginProperties() { + stream.print("<properties>"); + } + + public void printProperty(String name, String value) { + stream.printf("<p name='%s'>%s</p>", escape(name), escape(value)); + } + + public void endProperties() { + stream.print("</properties>"); + } + + public void printProperties(Map<String, String> properties) { + beginProperties(); + for (Entry<String, String> entry : properties.entrySet()) { + printProperty(entry.getKey(), entry.getValue()); + } + endProperties(); + } + + public void beginNodes() { + stream.println(" <nodes>"); + } + + public void beginNode(String id) { + stream.printf(" <node id='%s'>", escape(id)); + } + + public void endNode() { + stream.println(" </node>"); + } + + public void printNode(String id, Map<String, String> properties) { + beginNode(id); + if (properties != null) { + printProperties(properties); + } + endNode(); + } + + public void endNodes() { + stream.println(" </nodes>"); + } + + public void beginEdges() { + stream.println(" <edges>"); + } + + public void printEdge(Edge edge) { + stream.printf(" <edge from='%s' fromIndex='%d' to='%s' toIndex='%d' label='%s' />%n", escape(edge.from), edge.fromIndex, escape(edge.to), edge.toIndex, escape(edge.label)); + } + + public void endEdges() { + stream.println(" </edges>"); + } + + public void beginControlFlow() { + stream.println(" <controlFlow>"); + } + + public void beginBlock(String name) { + stream.printf(" <block name='%s'>%n", escape(name)); + } + + public void beginSuccessors() { + stream.println(" <successors>"); + } + + public void printSuccessor(String name) { + stream.printf(" <successor name='%s'/>%n", escape(name)); + } + + public void endSuccessors() { + stream.println(" </successors>"); + } + + public void beginBlockNodes() { + stream.println(" <nodes>"); + } + + public void printBlockNode(String nodeId) { + stream.printf(" <node id='%s'/>%n", escape(nodeId)); + } + + public void endBlockNodes() { + stream.println(" </nodes>"); + } + + public void endBlock() { + stream.println(" </block>"); + } + + public void endControlFlow() { + stream.println(" </controlFlow>"); + } + + public void endGraph() { + stream.println(" </graph>"); + } + + /** + * Ends the current group. + */ + public void endGroup() { + stream.println("</group>"); + } + + /** + * Finishes the graph document and flushes the output stream. + */ + public void end() { + stream.println("</graphDocument>"); + flush(); + } + + private static String escape(String s) { + StringBuilder str = null; + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + switch (c) { + case '&': + case '<': + case '>': + case '"': + case '\'': + if (str == null) { + str = new StringBuilder(); + str.append(s, 0, i); + } + switch(c) { + case '&': + str.append("&"); + break; + case '<': + str.append("<"); + break; + case '>': + str.append(">"); + break; + case '"': + str.append("""); + break; + case '\'': + str.append("'"); + break; + default: + assert false; + } + break; + default: + if (str != null) { + str.append(c); + } + break; + } + } + if (str == null) { + return s; + } else { + return str.toString(); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.printer/src/com/oracle/max/graal/printer/CFGPrinter.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,480 @@ +/* + * 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. + * + * 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.oracle.max.graal.printer; + +import static com.oracle.max.cri.ci.CiValueUtil.*; + +import java.io.*; +import java.util.*; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.criutils.*; +import com.oracle.max.graal.compiler.*; +import com.oracle.max.graal.compiler.alloc.*; +import com.oracle.max.graal.compiler.alloc.Interval.UsePosList; +import com.oracle.max.graal.compiler.graphbuilder.*; +import com.oracle.max.graal.compiler.lir.*; +import com.oracle.max.graal.compiler.schedule.*; +import com.oracle.max.graal.graph.*; +import com.oracle.max.graal.graph.Node.*; +import com.oracle.max.graal.graph.NodeClass.*; +import com.oracle.max.graal.nodes.*; +import com.oracle.max.graal.nodes.calc.*; + +/** + * Utility for printing Graal IR at various compilation phases. + */ +class CFGPrinter extends CompilationPrinter { + + public final ByteArrayOutputStream buffer; + public final GraalCompilation compilation; + public final CiTarget target; + public final RiRuntime runtime; + + /** + * Creates a control flow graph printer. + * + * @param buffer where the output generated via this printer shown be written + */ + public CFGPrinter(ByteArrayOutputStream buffer, GraalCompilation compilation) { + super(buffer); + this.buffer = buffer; + this.compilation = compilation; + this.target = compilation.compiler.target; + this.runtime = compilation.compiler.runtime; + } + + public CFGPrinter(ByteArrayOutputStream buffer, GraalCompilation compilation, CiTarget target, RiRuntime runtime) { + super(buffer); + this.buffer = buffer; + this.compilation = compilation; + this.target = target; + this.runtime = runtime; + } + + /** + * Prints the control flow graph denoted by a given block map. + * + * @param label A label describing the compilation phase that produced the control flow graph. + * @param blockMap A data structure describing the blocks in a method and how they are connected. + */ + public void printCFG(String label, BlockMap blockMap) { + begin("cfg"); + out.print("name \"").print(label).println('"'); + for (BlockMap.Block block : blockMap.blocks) { + begin("block"); + printBlock(block); + end("block"); + } + end("cfg"); + } + + private void printBlock(BlockMap.Block block) { + out.print("name \"B").print(block.startBci).println('"'); + out.print("from_bci ").println(block.startBci); + out.print("to_bci ").println(block.endBci); + + out.println("predecessors "); + + out.print("successors "); + for (BlockMap.Block succ : block.successors) { + if (!succ.isExceptionEntry) { + out.print("\"B").print(succ.startBci).print("\" "); + } + } + out.println(); + + out.print("xhandlers"); + for (BlockMap.Block succ : block.successors) { + if (succ.isExceptionEntry) { + out.print("\"B").print(succ.startBci).print("\" "); + } + } + out.println(); + + out.print("flags "); + if (block.isExceptionEntry) { + out.print("\"ex\" "); + } + if (block.isLoopHeader) { + out.print("\"plh\" "); + } + out.println(); + + out.print("loop_depth ").println(Long.bitCount(block.loops)); + } + + + /** + * Prints the specified list of blocks. + * + * @param label A label describing the compilation phase that produced the control flow graph. + * @param blocks The list of blocks to be printed. + * @param printNodes If {@code true} the nodes in the block will be printed. + */ + public void printCFG(String label, List<? extends Block> blocks, boolean printNodes) { + begin("cfg"); + out.print("name \"").print(label).println('"'); + for (Block block : blocks) { + printBlock(block, printNodes); + } + end("cfg"); + } + + private void printBlock(Block block, boolean printNodes) { + begin("block"); + + out.print("name \"").print(blockToString(block)).println('"'); + out.println("from_bci -1"); + out.println("to_bci -1"); + + out.print("predecessors "); + for (Block pred : block.getPredecessors()) { + out.print("\"").print(blockToString(pred)).print("\" "); + } + out.println(); + + out.print("successors "); + for (Block succ : block.getSuccessors()) { + if (!succ.isExceptionBlock()) { + out.print("\"").print(blockToString(succ)).print("\" "); + } + } + out.println(); + + out.print("xhandlers"); + for (Block succ : block.getSuccessors()) { + if (succ.isExceptionBlock()) { + out.print("\"").print(blockToString(succ)).print("\" "); + } + } + out.println(); + + out.print("flags "); + if (block.isLoopHeader()) { + out.print("\"llh\" "); + } + if (block.isLoopEnd()) { + out.print("\"lle\" "); + } + if (block.isExceptionBlock()) { + out.print("\"ex\" "); + } + out.println(); + + out.print("loop_index ").println(block.loopIndex()); + out.print("loop_depth ").println(block.loopDepth()); + + if (printNodes) { + printNodes(block); + } + + if (block instanceof LIRBlock) { + printLIR((LIRBlock) block); + } + + end("block"); + } + + private void printNodes(Block block) { + begin("IR"); + out.println("HIR"); + out.disableIndentation(); + + if (block.getPredecessors().size() == 0) { + // Currently method parameters are not in the schedule, so print them separately here. + for (ValueNode param : block.firstNode().graph().getNodes(LocalNode.class)) { + printNode(param); + } + } + if (block.firstNode() instanceof MergeNode) { + // Currently phi functions are not in the schedule, so print them separately here. + for (ValueNode phi : ((MergeNode) block.firstNode()).phis()) { + printNode(phi); + } + } + + for (Node node : block.getInstructions()) { + printNode(node); + } + out.enableIndentation(); + end("IR"); + } + + private void printNode(Node node) { + if (node instanceof FixedWithNextNode) { + out.print("f ").print(HOVER_START).print("#").print(HOVER_SEP).print("fixed with next").print(HOVER_END).println(COLUMN_END); + } else if (node instanceof FixedNode) { + out.print("f ").print(HOVER_START).print("*").print(HOVER_SEP).print("fixed").print(HOVER_END).println(COLUMN_END); + } else if (node instanceof FloatingNode) { + out.print("f ").print(HOVER_START).print("~").print(HOVER_SEP).print("floating").print(HOVER_END).println(COLUMN_END); + } + if (compilation.nodeOperands != null && node instanceof ValueNode) { + CiValue operand = compilation.operand((ValueNode) node); + if (operand != null) { + out.print("result ").print(operand.toString()).println(COLUMN_END); + } + } + out.print("tid ").print(nodeToString(node)).println(COLUMN_END); + + if (node instanceof StateSplit) { + StateSplit stateSplit = (StateSplit) node; + if (stateSplit.stateAfter() != null) { + String state = stateToString(stateSplit.stateAfter()); + out.print("st ").print(HOVER_START).print("st").print(HOVER_SEP).print(state).print(HOVER_END).println(COLUMN_END); + } + } + + Map<Object, Object> props = new TreeMap<>(node.getDebugProperties()); + out.print("d ").print(HOVER_START).print("d").print(HOVER_SEP); + out.println("=== Debug Properties ==="); + for (Map.Entry<Object, Object> entry : props.entrySet()) { + out.print(entry.getKey().toString()).print(": ").print(entry.getValue() == null ? "[null]" : entry.getValue().toString()).println(); + } + out.println("=== Inputs ==="); + printNamedNodes(node, node.inputs().iterator(), "", "\n", null); + out.println("=== Succesors ==="); + printNamedNodes(node, node.successors().iterator(), "", "\n", null); + out.println("=== Usages ==="); + if (!node.usages().isEmpty()) { + for (Node usage : node.usages()) { + out.print(nodeToString(usage)).print(" "); + } + out.println(); + } + out.println("=== Predecessor ==="); + out.print(nodeToString(node.predecessor())).print(" "); + out.print(HOVER_END).println(COLUMN_END); + + out.print("instruction "); + out.print(HOVER_START).print(node.getNodeClass().shortName()).print(HOVER_SEP).print(node.getClass().getName()).print(HOVER_END).print(" "); + printNamedNodes(node, node.inputs().iterator(), "", "", "#NDF"); + printNamedNodes(node, node.successors().iterator(), "#", "", "#NDF"); + for (Map.Entry<Object, Object> entry : props.entrySet()) { + String key = entry.getKey().toString(); + if (key.startsWith("data.") && !key.equals("data.stamp")) { + out.print(key.substring("data.".length())).print(": ").print(entry.getValue() == null ? "[null]" : entry.getValue().toString()).print(" "); + } + } + out.print(COLUMN_END).print(' ').println(COLUMN_END); + } + + private void printNamedNodes(Node node, NodeClassIterator iter, String prefix, String suffix, String hideSuffix) { + int lastIndex = -1; + while (iter.hasNext()) { + Position pos = iter.nextPosition(); + if (hideSuffix != null && node.getNodeClass().getName(pos).endsWith(hideSuffix)) { + continue; + } + + if (pos.index != lastIndex) { + if (lastIndex != -1) { + out.print(suffix); + } + out.print(prefix).print(node.getNodeClass().getName(pos)).print(": "); + lastIndex = pos.index; + } + out.print(nodeToString(node.getNodeClass().get(node, pos))).print(" "); + } + if (lastIndex != -1) { + out.print(suffix); + } + } + + private String stateToString(FrameState state) { + StringBuilder buf = new StringBuilder(); + FrameState curState = state; + do { + buf.append(CiUtil.toLocation(curState.method(), curState.bci)).append('\n'); + + if (curState.stackSize() > 0) { + buf.append("stack: "); + for (int i = 0; i < curState.stackSize(); i++) { + buf.append(stateValueToString(curState.stackAt(i))).append(' '); + } + buf.append("\n"); + } + + if (curState.locksSize() > 0) { + buf.append("locks: "); + for (int i = 0; i < curState.locksSize(); ++i) { + buf.append(stateValueToString(curState.lockAt(i))).append(' '); + } + buf.append("\n"); + } + + buf.append("locals: "); + for (int i = 0; i < curState.localsSize(); i++) { + buf.append(stateValueToString(curState.localAt(i))).append(' '); + } + buf.append("\n"); + + curState = curState.outerFrameState(); + } while (curState != null); + + return buf.toString(); + } + + private String stateValueToString(ValueNode value) { + String result = nodeToString(value); + if (value != null) { + CiValue operand = compilation.operand(value); + if (operand != null) { + result += ": " + operand; + } + } + return result; + } + + /** + * Prints the LIR for each instruction in a given block. + * + * @param block the block to print + */ + private void printLIR(LIRBlock block) { + List<LIRInstruction> lir = block.lir(); + if (lir == null) { + return; + } + + begin("IR"); + out.println("LIR"); + + if (block.phis != null) { + CiValue[] results = block.phis.results(); + for (int i = 0; i < results.length; i++) { + out.print("instruction PHI ").print(results[i].toString()).print(" = ("); + String sep = ""; + for (LIRBlock pred : block.getLIRPredecessors()) { + out.print(sep).print(block.phis.inputs(pred)[i].toString()); + sep = ", "; + } + out.print(")").print(COLUMN_END).println(COLUMN_END); + } + } + + for (int i = 0; i < lir.size(); i++) { + LIRInstruction inst = lir.get(i); + out.printf("nr %4d ", inst.id()).print(COLUMN_END); + + if (inst.info != null) { + int level = out.indentationLevel(); + out.adjustIndentation(-level); + String state; + if (inst.info.hasDebugInfo()) { + state = debugInfoToString(inst.info.debugInfo().codePos, inst.info.debugInfo().registerRefMap, inst.info.debugInfo().frameRefMap, target.arch); + } else { + state = debugInfoToString(inst.info.topFrame, null, null, target.arch); + } + if (state != null) { + out.print(" st ").print(HOVER_START).print("st").print(HOVER_SEP).print(state).print(HOVER_END).print(COLUMN_END); + } + out.adjustIndentation(level); + } + + out.print(" instruction ").print(inst.toString()).print(COLUMN_END); + out.println(COLUMN_END); + } + end("IR"); + } + + private String nodeToString(Node node) { + if (node == null) { + return "-"; + } + String prefix; + if (node instanceof BeginNode && compilation != null && compilation.lir() == null) { + prefix = "B"; + } else if (node instanceof ValueNode) { + ValueNode value = (ValueNode) node; + if (value.kind() == CiKind.Illegal) { + prefix = "v"; + } else { + prefix = String.valueOf(value.kind().typeChar); + } + } else { + prefix = "?"; + } + return prefix + node.toString(Verbosity.Id); + } + + private String blockToString(Block block) { + if (compilation != null && compilation.lir() == null) { + // During all the front-end phases, the block schedule is built only for the debug output. + // Therefore, the block numbers would be different for every CFG printed -> use the id of the first instruction. + return "B" + block.firstNode().toString(Verbosity.Id); + } else { + // LIR instructions contain references to blocks and these blocks are printed as the blockID -> use the blockID. + return "B" + block.blockID(); + } + } + + + public void printIntervals(String label, Interval[] intervals) { + begin("intervals"); + out.println(String.format("name \"%s\"", label)); + + for (Interval interval : intervals) { + if (interval != null) { + printInterval(interval); + } + } + + end("intervals"); + } + + private void printInterval(Interval interval) { + out.printf("%s %s ", interval.operand, (isRegister(interval.operand) ? "fixed" : interval.kind().name())); + if (isRegister(interval.operand)) { + out.printf("\"[%s|%c]\"", interval.operand, interval.operand.kind.typeChar); + } else { + if (interval.location() != null) { + out.printf("\"[%s|%c]\"", interval.location(), interval.location().kind.typeChar); + } + } + + Interval hint = interval.locationHint(false); + out.printf("%s %s ", interval.splitParent().operand, hint != null ? hint.operand : -1); + + // print ranges + Range cur = interval.first(); + while (cur != Range.EndMarker) { + out.printf("[%d, %d[", cur.from, cur.to); + cur = cur.next; + assert cur != null : "range list not closed with range sentinel"; + } + + // print use positions + int prev = 0; + UsePosList usePosList = interval.usePosList(); + for (int i = usePosList.size() - 1; i >= 0; --i) { + assert prev < usePosList.usePos(i) : "use positions not sorted"; + out.printf("%d %s ", usePosList.usePos(i), usePosList.registerPriority(i)); + prev = usePosList.usePos(i); + } + + out.printf(" \"%s\"", interval.spillState()); + out.println(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.printer/src/com/oracle/max/graal/printer/CFGPrinterObserver.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,138 @@ +/* + * 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. + * + * 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.oracle.max.graal.printer; + +import java.io.*; +import java.util.*; + +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; +import com.oracle.max.criutils.*; +import com.oracle.max.graal.compiler.*; +import com.oracle.max.graal.compiler.alloc.*; +import com.oracle.max.graal.compiler.graphbuilder.*; +import com.oracle.max.graal.compiler.lir.*; +import com.oracle.max.graal.compiler.observer.*; +import com.oracle.max.graal.compiler.schedule.*; +import com.oracle.max.graal.graph.*; +import com.oracle.max.graal.nodes.*; + +/** + * Observes compilation events and uses {@link CFGPrinter} to produce a control flow graph for the <a + * href="http://java.net/projects/c1visualizer/">C1 Visualizer</a>. + */ +public class CFGPrinterObserver implements CompilationObserver { + + /** + * A thread local stack of {@link CFGPrinter}s to support thread-safety and re-entrant compilation. + */ + private ThreadLocal<LinkedList<CFGPrinter>> observations = new ThreadLocal<LinkedList<CFGPrinter>>() { + @Override + protected java.util.LinkedList<CFGPrinter> initialValue() { + return new LinkedList<>(); + } + }; + + @Override + public void compilationStarted(GraalCompilation compilation) { + if (TTY.isSuppressed()) { + return; + } + + CFGPrinter cfgPrinter = new CFGPrinter(new ByteArrayOutputStream(), compilation); + cfgPrinter.printCompilation(compilation.method); + observations.get().push(cfgPrinter); + } + + @Override + public void compilationEvent(CompilationEvent event) { + if (TTY.isSuppressed()) { + return; + } + CFGPrinter cfgPrinter = observations.get().peek(); + if (cfgPrinter == null) { + return; + } + + RiRuntime runtime = cfgPrinter.runtime; + BlockMap blockMap = event.debugObject(BlockMap.class); + Graph graph = event.debugObject(Graph.class); + IdentifyBlocksPhase schedule = event.debugObject(IdentifyBlocksPhase.class); + LIR lir = event.debugObject(LIR.class); + LinearScan allocator = event.debugObject(LinearScan.class); + Interval[] intervals = event.debugObject(Interval[].class); + CiTargetMethod targetMethod = event.debugObject(CiTargetMethod.class); + + if (blockMap != null) { + cfgPrinter.printCFG(event.label, blockMap); + cfgPrinter.printBytecodes(runtime.disassemble(blockMap.method)); + } + if (lir != null) { + cfgPrinter.printCFG(event.label, lir.codeEmittingOrder(), graph != null); + if (targetMethod != null) { + cfgPrinter.printMachineCode(runtime.disassemble(targetMethod), null); + } + } else if (graph != null) { + List<? extends Block> blocks = null; + if (schedule == null) { + try { + schedule = new IdentifyBlocksPhase(true, LIRBlock.FACTORY); + schedule.apply((StructuredGraph) graph, false); + blocks = schedule.getBlocks(); + + ComputeLinearScanOrder clso = new ComputeLinearScanOrder(schedule.getBlocks().size(), schedule.loopCount(), (LIRBlock) schedule.getStartBlock()); + blocks = clso.codeEmittingOrder(); + } catch (Throwable t) { + // nothing to do here... + } + } + if (blocks != null) { + cfgPrinter.printCFG(event.label, blocks, true); + } + } + if (allocator != null && intervals != null) { + cfgPrinter.printIntervals(event.label, intervals); + } + } + + @Override + public void compilationFinished(GraalCompilation compilation) { + if (TTY.isSuppressed()) { + return; + } + CFGPrinter cfgPrinter = observations.get().pop(); + cfgPrinter.flush(); + + OutputStream stream = CompilationPrinter.globalOut(); + if (stream != null) { + synchronized (stream) { + try { + stream.write(cfgPrinter.buffer.toByteArray()); + stream.flush(); + } catch (IOException e) { + TTY.println("WARNING: Error writing CFGPrinter output: %s", e); + } + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.printer/src/com/oracle/max/graal/printer/IdealGraphPrinter.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,419 @@ +/* + * 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. + * + * 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.oracle.max.graal.printer; + +import java.io.*; +import java.util.*; +import java.util.Map.Entry; + +import com.oracle.max.cri.ri.*; +import com.oracle.max.graal.compiler.*; +import com.oracle.max.graal.compiler.graphbuilder.*; +import com.oracle.max.graal.compiler.schedule.*; +import com.oracle.max.graal.compiler.util.*; +import com.oracle.max.graal.compiler.util.LoopUtil.Loop; +import com.oracle.max.graal.graph.*; +import com.oracle.max.graal.graph.Node.Verbosity; +import com.oracle.max.graal.graph.NodeClass.NodeClassIterator; +import com.oracle.max.graal.graph.NodeClass.Position; +import com.oracle.max.graal.nodes.*; +import com.oracle.max.graal.nodes.loop.*; +import com.oracle.max.graal.printer.BasicIdealGraphPrinter.*; + +/** + * Generates a representation of {@link Graph Graphs} that can be visualized and inspected with the <a + * href="http://kenai.com/projects/igv">Ideal Graph Visualizer</a>. + */ +class IdealGraphPrinter { + + private final BasicIdealGraphPrinter printer; + private final HashSet<Class<?>> omittedClasses = new HashSet<>(); + private final Set<Node> noBlockNodes = new HashSet<>(); + + /** + * Creates a new {@link IdealGraphPrinter} that writes to the specified output stream. + */ + public IdealGraphPrinter(OutputStream stream) { + this.printer = new BasicIdealGraphPrinter(stream); + } + + /** + * Adds a node class that is omitted in the output. + */ + public void addOmittedClass(Class<?> clazz) { + omittedClasses.add(clazz); + } + + /** + * Flushes any buffered output. + */ + public void flush() { + printer.flush(); + } + + /** + * Starts a new graph document. + */ + public void begin() { + printer.begin(); + } + + /** + * Starts a new group of graphs with the given name, short name and method byte code index (BCI) as properties. + */ + public void beginGroup(String name, String shortName, RiResolvedMethod method, int bci, String origin) { + printer.beginGroup(); + printer.beginProperties(); + printer.printProperty("name", name); + printer.printProperty("origin", origin); + printer.endProperties(); + printer.beginMethod(name, shortName, bci); + if (GraalOptions.PrintIdealGraphBytecodes && method != null) { + printer.beginBytecodes(); + BytecodeStream bytecodes = new BytecodeStream(method.code()); + while (bytecodes.currentBC() != Bytecodes.END) { + int startBCI = bytecodes.currentBCI(); + String mnemonic = Bytecodes.nameOf(bytecodes.currentBC()); + int[] extra = null; + if (bytecodes.nextBCI() > startBCI + 1) { + extra = new int[bytecodes.nextBCI() - (startBCI + 1)]; + for (int i = 0; i < extra.length; i++) { + extra[i] = bytecodes.readUByte(startBCI + 1 + i); + } + } + printer.printBytecode(startBCI, mnemonic, extra); + bytecodes.next(); + } + printer.endBytecodes(); + } + printer.endMethod(); + } + + /** + * Ends the current group. + */ + public void endGroup() { + printer.endGroup(); + } + + /** + * Finishes the graph document and flushes the output stream. + */ + public void end() { + printer.end(); + } + + public void print(Graph graph, String title, boolean shortNames) { + print(graph, title, shortNames, null); + } + + /** + * Prints an entire {@link Graph} with the specified title, optionally using short names for nodes. + */ + public void print(Graph graph, String title, boolean shortNames, IdentifyBlocksPhase predefinedSchedule) { + printer.beginGraph(title); + noBlockNodes.clear(); + IdentifyBlocksPhase schedule = predefinedSchedule; + if (schedule == null) { + try { + schedule = new IdentifyBlocksPhase(true); + schedule.apply((StructuredGraph) graph, false); + } catch (Throwable t) { + // nothing to do here... + } + } + List<Loop> loops = null; + try { + loops = LoopUtil.computeLoops((StructuredGraph) graph); + // loop.nodes() does some more calculations which may fail, so execute this here as well (result is cached) + if (loops != null) { + for (Loop loop : loops) { + loop.nodes(); + } + } + } catch (Throwable t) { + t.printStackTrace(); + loops = null; + } + + printer.beginNodes(); + List<Edge> edges = printNodes(graph, shortNames, schedule == null ? null : schedule.getNodeToBlock(), loops); + printer.endNodes(); + + printer.beginEdges(); + for (Edge edge : edges) { + printer.printEdge(edge); + } + printer.endEdges(); + + if (schedule != null) { + printer.beginControlFlow(); + for (Block block : schedule.getBlocks()) { + printBlock(graph, block, schedule.getNodeToBlock()); + } + printNoBlock(); + printer.endControlFlow(); + } + + printer.endGraph(); + flush(); + } + + private List<Edge> printNodes(Graph graph, boolean shortNames, NodeMap<Block> nodeToBlock, List<Loop> loops) { + ArrayList<Edge> edges = new ArrayList<>(); + NodeBitMap loopExits = graph.createNodeBitMap(); + if (loops != null) { + for (Loop loop : loops) { + loopExits.setUnion(loop.exits()); + } + } + + NodeMap<Set<Entry<String, Integer>>> colors = graph.createNodeMap(); + NodeMap<Set<Entry<String, String>>> colorsToString = graph.createNodeMap(); + NodeMap<Set<String>> bits = graph.createNodeMap(); +// TODO This code was never reachable, since there was no code putting a NodeMap or NodeBitMap into the debugObjects. +// If you need to reactivate this code, put the mapping from names to values into a helper object and register it in the new debugObjects array. +// +// if (debugObjects != null) { +// for (Entry<String, Object> entry : debugObjects.entrySet()) { +// String name = entry.getKey(); +// Object obj = entry.getValue(); +// if (obj instanceof NodeMap) { +// Map<Object, Integer> colorNumbers = new HashMap<Object, Integer>(); +// int nextColor = 0; +// NodeMap<?> map = (NodeMap<?>) obj; +// for (Entry<Node, ?> mapEntry : map.entries()) { +// Node node = mapEntry.getKey(); +// Object color = mapEntry.getValue(); +// Integer colorNumber = colorNumbers.get(color); +// if (colorNumber == null) { +// colorNumber = nextColor++; +// colorNumbers.put(color, colorNumber); +// } +// Set<Entry<String, Integer>> nodeColors = colors.get(node); +// if (nodeColors == null) { +// nodeColors = new HashSet<Entry<String, Integer>>(); +// colors.put(node, nodeColors); +// } +// nodeColors.add(new SimpleImmutableEntry<String, Integer>(name + "Color", colorNumber)); +// Set<Entry<String, String>> nodeColorStrings = colorsToString.get(node); +// if (nodeColorStrings == null) { +// nodeColorStrings = new HashSet<Entry<String, String>>(); +// colorsToString.put(node, nodeColorStrings); +// } +// nodeColorStrings.add(new SimpleImmutableEntry<String, String>(name, color.toString())); +// } +// } else if (obj instanceof NodeBitMap) { +// NodeBitMap bitmap = (NodeBitMap) obj; +// for (Node node : bitmap) { +// Set<String> nodeBits = bits.get(node); +// if (nodeBits == null) { +// nodeBits = new HashSet<String>(); +// bits.put(node, nodeBits); +// } +// nodeBits.add(name); +// } +// } +// } +// } + + for (Node node : graph.getNodes()) { + if (omittedClasses.contains(node.getClass())) { + continue; + } + + printer.beginNode(node.toString(Verbosity.Id)); + printer.beginProperties(); + printer.printProperty("idx", node.toString(Verbosity.Id)); + + Map<Object, Object> props = node.getDebugProperties(); + if (!props.containsKey("name") || props.get("name").toString().trim().length() == 0) { + String name; + if (shortNames) { + name = node.toString(Verbosity.Name); + } else { + name = node.toString(); + } + printer.printProperty("name", name); + } + printer.printProperty("class", node.getClass().getSimpleName()); + Block block = nodeToBlock == null ? null : nodeToBlock.get(node); + if (block != null) { + printer.printProperty("block", Integer.toString(block.blockID())); + if (!(node instanceof PhiNode || node instanceof FrameState || node instanceof LocalNode || node instanceof InductionVariableNode) && !block.getInstructions().contains(node)) { + printer.printProperty("notInOwnBlock", "true"); + } + } else { + printer.printProperty("block", "noBlock"); + noBlockNodes.add(node); + } + if (loopExits.isMarked(node)) { + printer.printProperty("loopExit", "true"); + } + StringBuilder sb = new StringBuilder(); + if (loops != null) { + for (Loop loop : loops) { + if (loop.nodes().isMarked(node)) { + if (sb.length() > 0) { + sb.append(", "); + } + sb.append(loop.loopBegin().toString(Verbosity.Id)); + } + } + } + if (sb.length() > 0) { + printer.printProperty("loops", sb.toString()); + } + + Set<Entry<String, Integer>> nodeColors = colors.get(node); + if (nodeColors != null) { + for (Entry<String, Integer> color : nodeColors) { + String name = color.getKey(); + Integer value = color.getValue(); + printer.printProperty(name, Integer.toString(value)); + } + } + Set<Entry<String, String>> nodeColorStrings = colorsToString.get(node); + if (nodeColorStrings != null) { + for (Entry<String, String> color : nodeColorStrings) { + String name = color.getKey(); + String value = color.getValue(); + printer.printProperty(name, value); + } + } + Set<String> nodeBits = bits.get(node); + if (nodeBits != null) { + for (String bit : nodeBits) { + printer.printProperty(bit, "true"); + } + } + + for (Entry<Object, Object> entry : props.entrySet()) { + String key = entry.getKey().toString(); + String value = entry.getValue() == null ? "null" : entry.getValue().toString(); + printer.printProperty(key, value); + } + + printer.endProperties(); + printer.endNode(); + + // successors + int fromIndex = 0; + NodeClassIterator succIter = node.successors().iterator(); + while (succIter.hasNext()) { + Position position = succIter.nextPosition(); + Node successor = node.getNodeClass().get(node, position); + if (successor != null && !omittedClasses.contains(successor.getClass())) { + edges.add(new Edge(node.toString(Verbosity.Id), fromIndex, successor.toString(Verbosity.Id), 0, node.getNodeClass().getName(position))); + } + fromIndex++; + } + + // inputs + int toIndex = 1; + NodeClassIterator inputIter = node.inputs().iterator(); + while (inputIter.hasNext()) { + Position position = inputIter.nextPosition(); + Node input = node.getNodeClass().get(node, position); + if (input != null && !omittedClasses.contains(input.getClass())) { + edges.add(new Edge(input.toString(Verbosity.Id), input.successors().explicitCount(), node.toString(Verbosity.Id), toIndex, node.getNodeClass().getName(position))); + } + toIndex++; + } + } + + return edges; + } + + private void printBlock(Graph graph, Block block, NodeMap<Block> nodeToBlock) { + printer.beginBlock(Integer.toString(block.blockID())); + printer.beginSuccessors(); + for (Block sux : block.getSuccessors()) { + if (sux != null) { + printer.printSuccessor(Integer.toString(sux.blockID())); + } + } + printer.endSuccessors(); + printer.beginBlockNodes(); + + Set<Node> nodes = new HashSet<>(block.getInstructions()); + + if (nodeToBlock != null) { + for (Node n : graph.getNodes()) { + Block blk = nodeToBlock.get(n); + if (blk == block) { + nodes.add(n); + } + } + } + + if (nodes.size() > 0) { + // if this is the first block: add all locals to this block + if (block.getInstructions().size() > 0 && block.getInstructions().get(0) == ((StructuredGraph) graph).start()) { + for (Node node : graph.getNodes()) { + if (node instanceof LocalNode) { + nodes.add(node); + } + } + } + + // add all framestates and phis to their blocks + for (Node node : block.getInstructions()) { + if (node instanceof StateSplit && ((StateSplit) node).stateAfter() != null) { + nodes.add(((StateSplit) node).stateAfter()); + } + if (node instanceof MergeNode) { + for (PhiNode phi : ((MergeNode) node).phis()) { + nodes.add(phi); + } + if (node instanceof LoopBeginNode) { + for (InductionVariableNode iv : ((LoopBeginNode) node).inductionVariables()) { + nodes.add(iv); + } + } + } + } + + for (Node node : nodes) { + if (!omittedClasses.contains(node.getClass())) { + printer.printBlockNode(node.toString(Verbosity.Id)); + } + } + } + printer.endBlockNodes(); + printer.endBlock(); + } + + private void printNoBlock() { + if (!noBlockNodes.isEmpty()) { + printer.beginBlock("noBlock"); + printer.beginBlockNodes(); + for (Node node : noBlockNodes) { + printer.printBlockNode(node.toString(Verbosity.Id)); + } + printer.endBlockNodes(); + printer.endBlock(); + } + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.max.graal.printer/src/com/oracle/max/graal/printer/IdealGraphPrinterObserver.java Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,265 @@ +/* + * 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. + * + * 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.oracle.max.graal.printer; + +import java.io.*; +import java.net.*; +import java.util.regex.*; + +import com.oracle.max.cri.ri.*; +import com.oracle.max.criutils.*; +import com.oracle.max.graal.compiler.*; +import com.oracle.max.graal.compiler.observer.*; +import com.oracle.max.graal.compiler.schedule.*; +import com.oracle.max.graal.graph.*; + +/** + * Observes compilation events and uses {@link IdealGraphPrinter} to generate a graph representation that can be + * inspected with the <a href="http://kenai.com/projects/igv">Ideal Graph Visualizer</a>. + */ +public class IdealGraphPrinterObserver implements CompilationObserver { + + private static final Pattern INVALID_CHAR = Pattern.compile("[^A-Za-z0-9_.-]"); + + private final String host; + private final int port; + + private static class PrintingContext { + public IdealGraphPrinter printer; + private OutputStream stream; + private Socket socket; + + } + private final ThreadLocal<PrintingContext> context = new ThreadLocal<PrintingContext>() { + @Override + protected PrintingContext initialValue() { + return new PrintingContext(); + } + }; + + /** + * Creates a new {@link IdealGraphPrinterObserver} that writes output to a file named after the compiled method. + */ + public IdealGraphPrinterObserver() { + this(null, -1); + } + + /** + * Creates a new {@link IdealGraphPrinterObserver} that sends output to a remote IdealGraphVisualizer instance. + */ + public IdealGraphPrinterObserver(String host, int port) { + this.host = host; + this.port = port; + } + + private PrintingContext context() { + return context.get(); + } + + private IdealGraphPrinter printer() { + return context().printer; + } + + private Socket socket() { + return context().socket; + } + + @Override + public void compilationStarted(GraalCompilation compilation) { + openPrinter(compilation, false); + } + + private void openPrinter(GraalCompilation compilation, boolean error) { + assert (context().stream == null && printer() == null); + if ((!TTY.isSuppressed() && GraalOptions.Plot) || (GraalOptions.PlotOnError && error)) { + String name; + if (compilation != null) { + name = compilation.method.holder().name(); + name = name.substring(1, name.length() - 1).replace('/', '.'); + name = name + "." + compilation.method.name(); + } else { + name = "null"; + } + + openPrinter(name, compilation == null ? null : compilation.method); + } + } + + private void openPrinter(String title, RiResolvedMethod method) { + assert (context().stream == null && printer() == null); + if (!TTY.isSuppressed()) { + // Use a filter to suppress a recursive attempt to open a printer + TTY.Filter filter = new TTY.Filter(); + try { + if (host != null) { + openNetworkPrinter(title, method); + } else { + openFilePrinter(title, method); + } + } finally { + filter.remove(); + } + } + } + + private void openFilePrinter(String title, RiResolvedMethod method) { + String filename = title + ".igv.xml"; + filename = INVALID_CHAR.matcher(filename).replaceAll("_"); + + try { + context().stream = new FileOutputStream(filename); + context().printer = new IdealGraphPrinter(context().stream); + printer().begin(); + printer().beginGroup(title, title, method, -1, "Graal"); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public boolean networkAvailable() { + try { + Socket s = new Socket(host, port); + s.setSoTimeout(10); + s.close(); + return true; + } catch (IOException e) { + return false; + } + } + + private void openNetworkPrinter(String title, RiResolvedMethod method) { + try { + context().socket = new Socket(host, port); + if (socket().getInputStream().read() == 'y') { + context().stream = new BufferedOutputStream(socket().getOutputStream(), 0x4000); + } else { + // server currently does not accept any input + socket().close(); + context().socket = null; + return; + } + + context().printer = new IdealGraphPrinter(context().stream); + printer().begin(); + printer().beginGroup(title, title, method, -1, "Graal"); + printer().flush(); + if (socket().getInputStream().read() != 'y') { + // server declines input for this method + socket().close(); + context().socket = null; + context().stream = null; + context().printer = null; + } + } catch (IOException e) { + System.err.println("Error opening connection to " + host + ":" + port + ": " + e); + + if (socket() != null) { + try { + socket().close(); + } catch (IOException ioe) { + } + context().socket = null; + } + context().stream = null; + context().printer = null; + } + } + + @Override + public void compilationEvent(CompilationEvent event) { + boolean lazyStart = false; + if (printer() == null && event.hasDebugObject(CompilationEvent.ERROR)) { + openPrinter(event.debugObject(GraalCompilation.class), true); + lazyStart = true; + } + Graph graph = event.debugObject(Graph.class); + if (printer() != null && graph != null) { + printer().print(graph, event.label, true, event.debugObject(IdentifyBlocksPhase.class)); + } + if (lazyStart && printer() != null) { + closePrinter(); + } + } + + @Override + public void compilationFinished(GraalCompilation compilation) { + if (printer() != null) { + closePrinter(); + } + } + + private void closePrinter() { + assert (printer() != null); + + try { + printer().endGroup(); + printer().end(); + + if (socket() != null) { + socket().close(); // also closes stream + } else { + context().stream.close(); + } + } catch (IOException e) { + e.printStackTrace(); + } finally { + context().printer = null; + context().stream = null; + context().socket = null; + } + } + + public void printGraphs(String groupTitle, Graph... graphs) { + openPrinter(groupTitle, null); + if (printer() != null) { + int i = 0; + for (Graph graph : graphs) { + printer().print(graph, "Graph " + i, true); + i++; + } + closePrinter(); + } + } + + public void compilationStarted(String groupTitle) { + openPrinter(groupTitle, null); + } + + public void printGraph(String graphTitle, Graph graph) { + if (printer() != null) { + printer().print(graph, graphTitle, true); + } + } + + public void printSingleGraph(String title, Graph graph) { + printSingleGraph(title, title, graph); + } + + public void printSingleGraph(String groupTitle, String graphTitle, Graph graph) { + openPrinter(groupTitle, null); + if (printer() != null) { + printer().print(graph, graphTitle, true); + closePrinter(); + } + } +}
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/ArrayCopySnippets.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/ArrayCopySnippets.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.snippets; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.snippets.nodes.*; -import com.sun.cri.ci.*; public class ArrayCopySnippets implements SnippetsInterface{
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/DoubleSnippets.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/DoubleSnippets.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.graal.snippets; +import com.oracle.max.cri.util.*; import com.oracle.max.graal.nodes.calc.*; -import com.sun.max.annotate.*; /** * Snippets for {@link java.lang.Double} methods.
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/FloatSnippets.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/FloatSnippets.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.graal.snippets; +import com.oracle.max.cri.util.*; import com.oracle.max.graal.nodes.calc.*; -import com.sun.max.annotate.*; /** * Snippets for {@link java.lang.Float} methods.
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/GraalIntrinsics.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/GraalIntrinsics.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.snippets; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.*; import com.oracle.max.graal.compiler.phases.*; import com.oracle.max.graal.compiler.phases.PhasePlan.PhasePosition; import com.oracle.max.graal.cri.*; -import com.sun.cri.ci.*; /** * Definition of the snippets that are VM-independent and can be intrinsified by Graal in any VM.
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/IntrinsifyArrayCopyPhase.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/IntrinsifyArrayCopyPhase.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,13 +24,13 @@ import java.lang.reflect.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.compiler.phases.*; import com.oracle.max.graal.compiler.util.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.java.*; -import com.sun.cri.ri.*; public class IntrinsifyArrayCopyPhase extends Phase { private final GraalRuntime runtime;
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/MathSnippetsX86.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/MathSnippetsX86.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,10 +22,10 @@ */ package com.oracle.max.graal.snippets; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.snippets.nodes.*; import com.oracle.max.graal.snippets.nodes.MathIntrinsicNode.Operation; -import com.sun.cri.ci.*; /** * Snippets for {@link java.lang.Math} methods.
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/NodeClassSnippets.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/NodeClassSnippets.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,9 +22,9 @@ */ package com.oracle.max.graal.snippets; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.extended.*; -import com.sun.cri.ci.*; /** * Snippets for {@link NodeClass} methods.
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/Snippets.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/Snippets.java Tue Jan 03 16:47:02 2012 +0100 @@ -24,8 +24,9 @@ import java.lang.reflect.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.compiler.*; -import com.oracle.max.graal.compiler.debug.*; import com.oracle.max.graal.compiler.graphbuilder.*; import com.oracle.max.graal.compiler.observer.*; import com.oracle.max.graal.compiler.phases.*; @@ -35,8 +36,7 @@ import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.java.*; -import com.sun.cri.ci.*; -import com.sun.cri.ri.*; +import com.oracle.max.graal.printer.*; /** * Utilities for snippet installation and management.
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/SystemSnippets.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/SystemSnippets.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,8 +22,8 @@ */ package com.oracle.max.graal.snippets; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.nodes.extended.*; -import com.sun.cri.ci.*; /** * Snippets for {@link java.lang.System} methods.
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/UnsafeSnippets.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/UnsafeSnippets.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,10 @@ */ package com.oracle.max.graal.snippets; -import com.oracle.max.cri.intrinsics.*; +import com.oracle.max.cri.ci.*; +import com.oracle.max.cri.util.*; import com.oracle.max.graal.nodes.extended.*; import com.oracle.max.graal.nodes.java.*; -import com.sun.cri.ci.*; -import com.sun.max.annotate.*; /** * Snippets for {@link sun.misc.Unsafe} methods. @@ -46,8 +45,6 @@ return CompareAndSwapNode.compareAndSwap(o, offset, expected, x); } - // TODO: volatile variants of the following methods, e.g. getObjectVolatile() - public Object getObject(Object o, long offset) { return UnsafeLoadNode.load(o, offset, CiKind.Object); }
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/nodes/ArrayHeaderSizeNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/nodes/ArrayHeaderSizeNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,11 +22,11 @@ */ package com.oracle.max.graal.snippets.nodes; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; -import com.sun.cri.ci.*; public class ArrayHeaderSizeNode extends FloatingNode implements Lowerable { @Data private final CiKind elementKind;
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/nodes/MathIntrinsicNode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/nodes/MathIntrinsicNode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,6 +22,7 @@ */ package com.oracle.max.graal.snippets.nodes; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.target.amd64.*; import com.oracle.max.graal.compiler.util.*; import com.oracle.max.graal.graph.*; @@ -30,7 +31,6 @@ import com.oracle.max.graal.nodes.spi.*; import com.oracle.max.graal.nodes.type.*; import com.oracle.max.graal.snippets.target.amd64.*; -import com.sun.cri.ci.*; public class MathIntrinsicNode extends FloatingNode implements Canonicalizable, AMD64LIRLowerable {
--- a/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/target/amd64/AMD64MathIntrinsicOpcode.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.snippets/src/com/oracle/max/graal/snippets/target/amd64/AMD64MathIntrinsicOpcode.java Tue Jan 03 16:47:02 2012 +0100 @@ -22,14 +22,14 @@ */ package com.oracle.max.graal.snippets.target.amd64; -import static com.sun.cri.ci.CiValueUtil.*; +import static com.oracle.max.cri.ci.CiValueUtil.*; import com.oracle.max.asm.target.amd64.*; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.target.amd64.*; import com.oracle.max.graal.compiler.util.*; -import com.sun.cri.ci.*; public enum AMD64MathIntrinsicOpcode implements LIROpcode { SQRT,
--- a/graal/com.oracle.max.graal.tests/src/com/oracle/max/graal/compiler/tests/EscapeAnalysisTest.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.tests/src/com/oracle/max/graal/compiler/tests/EscapeAnalysisTest.java Tue Jan 03 16:47:02 2012 +0100 @@ -26,10 +26,10 @@ import org.junit.Test; +import com.oracle.max.cri.ci.*; import com.oracle.max.graal.compiler.phases.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.java.*; -import com.sun.cri.ci.*; /** * In these test cases the probability of all invokes is set to a high value, such that an InliningPhase should inline them all.
--- a/graal/com.oracle.max.graal.tests/src/com/oracle/max/graal/compiler/tests/GraphTest.java Tue Jan 03 15:49:22 2012 +0100 +++ b/graal/com.oracle.max.graal.tests/src/com/oracle/max/graal/compiler/tests/GraphTest.java Tue Jan 03 16:47:02 2012 +0100 @@ -28,12 +28,12 @@ import junit.framework.Assert; +import com.oracle.max.cri.ri.*; import com.oracle.max.graal.compiler.*; -import com.oracle.max.graal.compiler.debug.*; import com.oracle.max.graal.compiler.graphbuilder.*; import com.oracle.max.graal.cri.*; import com.oracle.max.graal.nodes.*; -import com.sun.cri.ri.*; +import com.oracle.max.graal.printer.*; /** * Base class for Graal compiler unit tests. These are white box tests
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mx.bat Tue Jan 03 16:47:02 2012 +0100 @@ -0,0 +1,1 @@ +python mxtool/mx.py %*
--- a/mx/projects Tue Jan 03 15:49:22 2012 +0100 +++ b/mx/projects Tue Jan 03 16:47:02 2012 +0100 @@ -44,7 +44,7 @@ # graal.hotspot project@com.oracle.max.graal.hotspot@subDir=graal project@com.oracle.max.graal.hotspot@sourceDirs=src -project@com.oracle.max.graal.hotspot@dependencies=com.oracle.max.graal.snippets,com.oracle.max.asmdis +project@com.oracle.max.graal.hotspot@dependencies=com.oracle.max.graal.snippets,com.oracle.max.asmdis,com.oracle.max.graal.printer project@com.oracle.max.graal.hotspot@checkstyle=com.oracle.max.graal.graph # graal.graph @@ -55,7 +55,7 @@ # graal.snippets project@com.oracle.max.graal.snippets@subDir=graal project@com.oracle.max.graal.snippets@sourceDirs=src,test -project@com.oracle.max.graal.snippets@dependencies=com.oracle.max.graal.compiler +project@com.oracle.max.graal.snippets@dependencies=com.oracle.max.graal.printer,com.oracle.max.graal.compiler project@com.oracle.max.graal.snippets@checkstyle=com.oracle.max.graal.graph # graal.nodes @@ -70,10 +70,16 @@ project@com.oracle.max.graal.compiler@dependencies=com.oracle.max.asm,com.oracle.max.graal.nodes project@com.oracle.max.graal.compiler@checkstyle=com.oracle.max.graal.graph +# graal.printer +project@com.oracle.max.graal.printer@subDir=graal +project@com.oracle.max.graal.printer@sourceDirs=src +project@com.oracle.max.graal.printer@dependencies=com.oracle.max.graal.compiler,com.oracle.max.asm,com.oracle.max.graal.nodes +project@com.oracle.max.graal.printer@checkstyle=com.oracle.max.graal.graph + # graal.test project@com.oracle.max.graal.tests@subDir=graal project@com.oracle.max.graal.tests@sourceDirs=src -project@com.oracle.max.graal.tests@dependencies=com.oracle.max.graal.compiler +project@com.oracle.max.graal.tests@dependencies=com.oracle.max.graal.compiler,com.oracle.max.graal.printer project@com.oracle.max.graal.tests@checkstyle=com.oracle.max.graal.graph # max.asm
--- a/src/share/vm/classfile/vmSymbols.hpp Tue Jan 03 15:49:22 2012 +0100 +++ b/src/share/vm/classfile/vmSymbols.hpp Tue Jan 03 16:47:02 2012 +0100 @@ -270,79 +270,79 @@ \ /* support for graal */ \ template(com_sun_hotspot_graal_VMExits, "com/oracle/max/graal/hotspot/VMExits") \ - template(com_sun_hotspot_graal_HotSpotMethodResolved, "com/oracle/max/graal/hotspot/HotSpotMethodResolvedImpl") \ + template(com_sun_hotspot_graal_HotSpotMethodResolved, "com/oracle/max/graal/hotspot/ri/HotSpotMethodResolvedImpl") \ template(com_sun_hotspot_graal_HotSpotTargetMethod, "com/oracle/max/graal/hotspot/HotSpotTargetMethod") \ template(com_sun_hotspot_graal_HotSpotField, "com/oracle/max/graal/hotspot/HotSpotField") \ template(com_sun_hotspot_graal_HotSpotCompiledMethod, "com/oracle/max/graal/hotspot/HotSpotCompiledMethod") \ template(com_sun_graal_graalOptions, "com/sun/graal/graalOptions") \ template(com_sun_hotspot_graal_HotSpotOptions, "com/oracle/max/graal/hotspot/HotSpotOptions") \ - template(com_sun_hotspot_graal_HotSpotTypeResolved, "com/oracle/max/graal/hotspot/HotSpotTypeResolvedImpl") \ - template(com_sun_hotspot_graal_HotSpotType, "com/oracle/max/graal/hotspot/HotSpotType") \ + template(com_sun_hotspot_graal_HotSpotTypeResolved, "com/oracle/max/graal/hotspot/ri/HotSpotTypeResolvedImpl") \ + template(com_sun_hotspot_graal_HotSpotType, "com/oracle/max/graal/hotspot/ri/HotSpotType") \ template(com_sun_hotspot_graal_HotSpotExceptionHandler,"com/oracle/max/graal/hotspot/HotSpotExceptionHandler") \ template(com_sun_hotspot_graal_HotSpotProxy, "com/oracle/max/graal/hotspot/HotSpotProxy") \ template(com_sun_hotspot_graal_Compiler, "com/oracle/max/graal/hotspot/Compiler") \ template(com_sun_hotspot_graal_CompilerImpl, "com/oracle/max/graal/hotspot/CompilerImpl") \ - template(com_sun_cri_ri_RiMethod, "com/sun/cri/ri/RiMethod") \ - template(com_sun_cri_ri_RiResolvedField, "com/sun/cri/ri/RiResolvedField") \ - template(com_sun_cri_ri_RiType, "com/sun/cri/ri/RiType") \ - template(com_sun_cri_ri_RiTypeProfile, "com/sun/cri/ri/RiTypeProfile") \ - template(com_sun_cri_ri_RiConstantPool, "com/sun/cri/ri/RiConstantPool") \ - template(com_sun_cri_ri_RiExceptionHandler, "com/sun/cri/ri/RiExceptionHandler") \ - template(com_sun_cri_ci_CiAssumptions, "com/sun/cri/ci/CiAssumptions") \ - template(com_sun_cri_ci_CiAssumptions_ConcreteSubtype, "com/sun/cri/ci/CiAssumptions$ConcreteSubtype") \ - template(com_sun_cri_ci_CiAssumptions_ConcreteMethod, "com/sun/cri/ci/CiAssumptions$ConcreteMethod") \ - template(com_sun_cri_ci_CiGenericCallback, "com/sun/cri/ci/CiGenericCallback") \ - template(com_sun_cri_ci_CiTargetMethod, "com/sun/cri/ci/CiTargetMethod") \ - template(com_sun_cri_ci_CiTargetMethod_Site, "com/sun/cri/ci/CiTargetMethod$Site") \ - template(com_sun_cri_ci_CiTargetMethod_Call, "com/sun/cri/ci/CiTargetMethod$Call") \ - template(com_sun_cri_ci_CiTargetMethod_DataPatch, "com/sun/cri/ci/CiTargetMethod$DataPatch") \ - template(com_sun_cri_ci_CiTargetMethod_Safepoint, "com/sun/cri/ci/CiTargetMethod$Safepoint") \ - template(com_sun_cri_ci_CiTargetMethod_ExceptionHandler, "com/sun/cri/ci/CiTargetMethod$ExceptionHandler") \ - template(com_sun_cri_ci_CiTargetMethod_Mark, "com/sun/cri/ci/CiTargetMethod$Mark") \ + template(com_sun_cri_ri_RiMethod, "com/oracle/max/cri/ri/RiMethod") \ + template(com_sun_cri_ri_RiResolvedField, "com/oracle/max/cri/ri/RiResolvedField") \ + template(com_sun_cri_ri_RiType, "com/oracle/max/cri/ri/RiType") \ + template(com_sun_cri_ri_RiTypeProfile, "com/oracle/max/cri/ri/RiTypeProfile") \ + template(com_sun_cri_ri_RiConstantPool, "com/oracle/max/cri/ri/RiConstantPool") \ + template(com_sun_cri_ri_RiExceptionHandler, "com/oracle/max/cri/ri/RiExceptionHandler") \ + template(com_sun_cri_ci_CiAssumptions, "com/oracle/max/cri/ci/CiAssumptions") \ + template(com_sun_cri_ci_CiAssumptions_ConcreteSubtype, "com/oracle/max/cri/ci/CiAssumptions$ConcreteSubtype") \ + template(com_sun_cri_ci_CiAssumptions_ConcreteMethod, "com/oracle/max/cri/ci/CiAssumptions$ConcreteMethod") \ + template(com_sun_cri_ci_CiGenericCallback, "com/oracle/max/cri/ci/CiGenericCallback") \ + template(com_sun_cri_ci_CiTargetMethod, "com/oracle/max/cri/ci/CiTargetMethod") \ + template(com_sun_cri_ci_CiTargetMethod_Site, "com/oracle/max/cri/ci/CiTargetMethod$Site") \ + template(com_sun_cri_ci_CiTargetMethod_Call, "com/oracle/max/cri/ci/CiTargetMethod$Call") \ + template(com_sun_cri_ci_CiTargetMethod_DataPatch, "com/oracle/max/cri/ci/CiTargetMethod$DataPatch") \ + template(com_sun_cri_ci_CiTargetMethod_Safepoint, "com/oracle/max/cri/ci/CiTargetMethod$Safepoint") \ + template(com_sun_cri_ci_CiTargetMethod_ExceptionHandler, "com/oracle/max/cri/ci/CiTargetMethod$ExceptionHandler") \ + template(com_sun_cri_ci_CiTargetMethod_Mark, "com/oracle/max/cri/ci/CiTargetMethod$Mark") \ template(com_oracle_max_graal_graph_BitMap, "com/oracle/max/graal/graph/BitMap") \ - template(com_sun_cri_ci_CiBitMap, "com/sun/cri/ci/CiBitMap") \ - template(com_sun_cri_ci_CiDebugInfo, "com/sun/cri/ci/CiDebugInfo") \ - template(com_sun_cri_ci_CiFrame, "com/sun/cri/ci/CiFrame") \ - template(com_sun_cri_ci_CiValue, "com/sun/cri/ci/CiValue") \ - template(com_sun_cri_ci_CiStackSlot, "com/sun/cri/ci/CiStackSlot") \ - template(com_sun_cri_ci_CiRegisterValue, "com/sun/cri/ci/CiRegisterValue") \ - template(com_sun_cri_ci_CiRegister, "com/sun/cri/ci/CiRegister") \ - template(com_sun_cri_ci_CiCodePos, "com/sun/cri/ci/CiCodePos") \ - template(com_sun_cri_ci_CiConstant, "com/sun/cri/ci/CiConstant") \ - template(com_sun_cri_ci_CiVirtualObject, "com/sun/cri/ci/CiVirtualObject") \ - template(com_sun_cri_ci_CiMonitorValue, "com/sun/cri/ci/CiMonitorValue") \ - template(com_sun_cri_ci_CiKind, "com/sun/cri/ci/CiKind") \ - template(com_sun_cri_ci_CiRuntimeCall, "com/sun/cri/ci/CiRuntimeCall") \ + template(com_sun_cri_ci_CiBitMap, "com/oracle/max/cri/ci/CiBitMap") \ + template(com_sun_cri_ci_CiDebugInfo, "com/oracle/max/cri/ci/CiDebugInfo") \ + template(com_sun_cri_ci_CiFrame, "com/oracle/max/cri/ci/CiFrame") \ + template(com_sun_cri_ci_CiValue, "com/oracle/max/cri/ci/CiValue") \ + template(com_sun_cri_ci_CiStackSlot, "com/oracle/max/cri/ci/CiStackSlot") \ + template(com_sun_cri_ci_CiRegisterValue, "com/oracle/max/cri/ci/CiRegisterValue") \ + template(com_sun_cri_ci_CiRegister, "com/oracle/max/cri/ci/CiRegister") \ + template(com_sun_cri_ci_CiCodePos, "com/oracle/max/cri/ci/CiCodePos") \ + template(com_sun_cri_ci_CiConstant, "com/oracle/max/cri/ci/CiConstant") \ + template(com_sun_cri_ci_CiVirtualObject, "com/oracle/max/cri/ci/CiVirtualObject") \ + template(com_sun_cri_ci_CiMonitorValue, "com/oracle/max/cri/ci/CiMonitorValue") \ + template(com_sun_cri_ci_CiKind, "com/oracle/max/cri/ci/CiKind") \ + template(com_sun_cri_ci_CiRuntimeCall, "com/oracle/max/cri/ci/CiRuntimeCall") \ template(startCompiler_name, "startCompiler") \ template(bootstrap_name, "bootstrap") \ template(shutdownCompiler_name, "shutdownCompiler") \ template(compileMethod_name, "compileMethod") \ - template(compileMethod_signature, "(Lcom/oracle/max/graal/hotspot/HotSpotMethodResolved;IZ)V") \ + template(compileMethod_signature, "(Lcom/oracle/max/graal/hotspot/ri/HotSpotMethodResolved;IZ)V") \ template(setOption_name, "setOption") \ template(setDefaultOptions_name, "setDefaultOptions") \ template(setOption_signature, "(Ljava/lang/String;)Z") \ template(createRiMethodResolved_name, "createRiMethodResolved") \ - template(createRiMethodResolved_signature, "(JLjava/lang/String;)Lcom/sun/cri/ri/RiMethod;") \ + template(createRiMethodResolved_signature, "(JLjava/lang/String;)Lcom/oracle/max/cri/ri/RiMethod;") \ template(createRiMethodUnresolved_name, "createRiMethodUnresolved") \ - template(createRiMethodUnresolved_signature, "(Ljava/lang/String;Ljava/lang/String;Lcom/sun/cri/ri/RiType;)Lcom/sun/cri/ri/RiMethod;") \ + template(createRiMethodUnresolved_signature, "(Ljava/lang/String;Ljava/lang/String;Lcom/oracle/max/cri/ri/RiType;)Lcom/oracle/max/cri/ri/RiMethod;") \ template(createRiSignature_name, "createRiSignature") \ - template(createRiSignature_signature, "(Ljava/lang/String;)Lcom/sun/cri/ri/RiSignature;") \ + template(createRiSignature_signature, "(Ljava/lang/String;)Lcom/oracle/max/cri/ri/RiSignature;") \ template(createRiField_name, "createRiField") \ - template(createRiField_signature, "(Lcom/sun/cri/ri/RiType;Ljava/lang/String;Lcom/sun/cri/ri/RiType;II)Lcom/sun/cri/ri/RiField;") \ + template(createRiField_signature, "(Lcom/oracle/max/cri/ri/RiType;Ljava/lang/String;Lcom/oracle/max/cri/ri/RiType;II)Lcom/oracle/max/cri/ri/RiField;") \ template(createRiType_name, "createRiType") \ - template(createRiType_signature, "(JLjava/lang/String;)Lcom/sun/cri/ri/RiType;") \ + template(createRiType_signature, "(JLjava/lang/String;)Lcom/oracle/max/cri/ri/RiType;") \ template(createRiTypePrimitive_name, "createRiTypePrimitive") \ - template(createRiTypePrimitive_signature, "(I)Lcom/sun/cri/ri/RiType;") \ + template(createRiTypePrimitive_signature, "(I)Lcom/oracle/max/cri/ri/RiType;") \ template(createRiTypeUnresolved_name, "createRiTypeUnresolved") \ - template(createRiTypeUnresolved_signature, "(Ljava/lang/String;)Lcom/sun/cri/ri/RiType;") \ + template(createRiTypeUnresolved_signature, "(Ljava/lang/String;)Lcom/oracle/max/cri/ri/RiType;") \ template(createCiConstant_name, "createCiConstant") \ - template(createCiConstant_signature, "(Lcom/sun/cri/ci/CiKind;J)Lcom/sun/cri/ci/CiConstant;") \ + template(createCiConstant_signature, "(Lcom/oracle/max/cri/ci/CiKind;J)Lcom/oracle/max/cri/ci/CiConstant;") \ template(createCiConstantFloat_name, "createCiConstantFloat") \ - template(createCiConstantFloat_signature, "(F)Lcom/sun/cri/ci/CiConstant;") \ + template(createCiConstantFloat_signature, "(F)Lcom/oracle/max/cri/ci/CiConstant;") \ template(createCiConstantDouble_name, "createCiConstantDouble") \ - template(createCiConstantDouble_signature, "(D)Lcom/sun/cri/ci/CiConstant;") \ + template(createCiConstantDouble_signature, "(D)Lcom/oracle/max/cri/ci/CiConstant;") \ template(createCiConstantObject_name, "createCiConstantObject") \ - template(createCiConstantObject_signature, "(Ljava/lang/Object;)Lcom/sun/cri/ci/CiConstant;") \ + template(createCiConstantObject_signature, "(Ljava/lang/Object;)Lcom/oracle/max/cri/ci/CiConstant;") \ template(getVMExits_name, "getVMExits") \ template(getVMExits_signature, "()Lcom/oracle/max/graal/hotspot/VMExits;") \ template(getInstance_name, "getInstance") \
--- a/src/share/vm/graal/graalJavaAccess.hpp Tue Jan 03 15:49:22 2012 +0100 +++ b/src/share/vm/graal/graalJavaAccess.hpp Tue Jan 03 16:47:02 2012 +0100 @@ -61,7 +61,7 @@ start_class(HotSpotMethodResolved) \ oop_field(HotSpotMethodResolved, compiler, "Lcom/oracle/max/graal/hotspot/Compiler;") \ oop_field(HotSpotMethodResolved, name, "Ljava/lang/String;") \ - oop_field(HotSpotMethodResolved, holder, "Lcom/sun/cri/ri/RiResolvedType;") \ + oop_field(HotSpotMethodResolved, holder, "Lcom/oracle/max/cri/ri/RiResolvedType;") \ oop_field(HotSpotMethodResolved, javaMirror, "Ljava/lang/Object;") \ int_field(HotSpotMethodResolved, codeSize) \ int_field(HotSpotMethodResolved, accessFlags) \ @@ -72,79 +72,79 @@ oop_field(HotSpotType, name, "Ljava/lang/String;") \ end_class \ start_class(HotSpotField) \ - oop_field(HotSpotField, constant, "Lcom/sun/cri/ci/CiConstant;") \ + oop_field(HotSpotField, constant, "Lcom/oracle/max/cri/ci/CiConstant;") \ int_field(HotSpotField, offset) \ int_field(HotSpotField, accessFlags) \ end_class \ start_class(HotSpotCompiledMethod) \ long_field(HotSpotCompiledMethod, nmethod) \ - oop_field(HotSpotCompiledMethod, method, "Lcom/sun/cri/ri/RiResolvedMethod;") \ + oop_field(HotSpotCompiledMethod, method, "Lcom/oracle/max/cri/ri/RiResolvedMethod;") \ end_class \ start_class(HotSpotProxy) \ static_oop_field(HotSpotProxy, DUMMY_CONSTANT_OBJ, "Ljava/lang/Long;") \ end_class \ start_class(HotSpotTargetMethod) \ - oop_field(HotSpotTargetMethod, targetMethod, "Lcom/sun/cri/ci/CiTargetMethod;") \ - oop_field(HotSpotTargetMethod, method, "Lcom/oracle/max/graal/hotspot/HotSpotMethodResolved;") \ + oop_field(HotSpotTargetMethod, targetMethod, "Lcom/oracle/max/cri/ci/CiTargetMethod;") \ + oop_field(HotSpotTargetMethod, method, "Lcom/oracle/max/graal/hotspot/ri/HotSpotMethodResolved;") \ oop_field(HotSpotTargetMethod, name, "Ljava/lang/String;") \ - oop_field(HotSpotTargetMethod, sites, "[Lcom/sun/cri/ci/CiTargetMethod$Site;") \ - oop_field(HotSpotTargetMethod, exceptionHandlers, "[Lcom/sun/cri/ci/CiTargetMethod$ExceptionHandler;") \ + oop_field(HotSpotTargetMethod, sites, "[Lcom/oracle/max/cri/ci/CiTargetMethod$Site;") \ + oop_field(HotSpotTargetMethod, exceptionHandlers, "[Lcom/oracle/max/cri/ci/CiTargetMethod$ExceptionHandler;") \ end_class \ start_class(HotSpotExceptionHandler) \ int_field(HotSpotExceptionHandler, startBci) \ int_field(HotSpotExceptionHandler, endBci) \ int_field(HotSpotExceptionHandler, handlerBci) \ int_field(HotSpotExceptionHandler, catchClassIndex) \ - oop_field(HotSpotExceptionHandler, catchClass, "Lcom/sun/cri/ri/RiType;") \ + oop_field(HotSpotExceptionHandler, catchClass, "Lcom/oracle/max/cri/ri/RiType;") \ end_class \ start_class(CiTargetMethod) \ int_field(CiTargetMethod, frameSize) \ int_field(CiTargetMethod, customStackAreaOffset) \ oop_field(CiTargetMethod, targetCode, "[B") \ - oop_field(CiTargetMethod, assumptions, "Lcom/sun/cri/ci/CiAssumptions;") \ + oop_field(CiTargetMethod, assumptions, "Lcom/oracle/max/cri/ci/CiAssumptions;") \ int_field(CiTargetMethod, targetCodeSize) \ end_class \ start_class(CiAssumptions) \ - oop_field(CiAssumptions, list, "[Lcom/sun/cri/ci/CiAssumptions$Assumption;") \ + oop_field(CiAssumptions, list, "[Lcom/oracle/max/cri/ci/CiAssumptions$Assumption;") \ end_class \ start_class(CiAssumptions_ConcreteSubtype) \ - oop_field(CiAssumptions_ConcreteSubtype, context, "Lcom/sun/cri/ri/RiResolvedType;")\ - oop_field(CiAssumptions_ConcreteSubtype, subtype, "Lcom/sun/cri/ri/RiResolvedType;")\ + oop_field(CiAssumptions_ConcreteSubtype, context, "Lcom/oracle/max/cri/ri/RiResolvedType;")\ + oop_field(CiAssumptions_ConcreteSubtype, subtype, "Lcom/oracle/max/cri/ri/RiResolvedType;")\ end_class \ start_class(CiAssumptions_ConcreteMethod) \ - oop_field(CiAssumptions_ConcreteMethod, method, "Lcom/sun/cri/ri/RiResolvedMethod;") \ - oop_field(CiAssumptions_ConcreteMethod, context, "Lcom/sun/cri/ri/RiResolvedType;") \ - oop_field(CiAssumptions_ConcreteMethod, impl, "Lcom/sun/cri/ri/RiResolvedMethod;") \ + oop_field(CiAssumptions_ConcreteMethod, method, "Lcom/oracle/max/cri/ri/RiResolvedMethod;") \ + oop_field(CiAssumptions_ConcreteMethod, context, "Lcom/oracle/max/cri/ri/RiResolvedType;") \ + oop_field(CiAssumptions_ConcreteMethod, impl, "Lcom/oracle/max/cri/ri/RiResolvedMethod;") \ end_class \ start_class(CiTargetMethod_Site) \ int_field(CiTargetMethod_Site, pcOffset) \ end_class \ start_class(CiTargetMethod_Call) \ oop_field(CiTargetMethod_Call, target, "Ljava/lang/Object;") \ - oop_field(CiTargetMethod_Call, debugInfo, "Lcom/sun/cri/ci/CiDebugInfo;") \ + oop_field(CiTargetMethod_Call, debugInfo, "Lcom/oracle/max/cri/ci/CiDebugInfo;") \ end_class \ start_class(CiTargetMethod_DataPatch) \ - oop_field(CiTargetMethod_DataPatch, constant, "Lcom/sun/cri/ci/CiConstant;") \ + oop_field(CiTargetMethod_DataPatch, constant, "Lcom/oracle/max/cri/ci/CiConstant;") \ int_field(CiTargetMethod_DataPatch, alignment) \ end_class \ start_class(CiTargetMethod_Safepoint) \ - oop_field(CiTargetMethod_Safepoint, debugInfo, "Lcom/sun/cri/ci/CiDebugInfo;") \ + oop_field(CiTargetMethod_Safepoint, debugInfo, "Lcom/oracle/max/cri/ci/CiDebugInfo;") \ end_class \ start_class(CiTargetMethod_ExceptionHandler) \ int_field(CiTargetMethod_ExceptionHandler, handlerPos) \ int_field(CiTargetMethod_ExceptionHandler, handlerBci) \ int_field(CiTargetMethod_ExceptionHandler, bci) \ int_field(CiTargetMethod_ExceptionHandler, scopeLevel) \ - oop_field(CiTargetMethod_ExceptionHandler, exceptionType, "Lcom/sun/cri/ri/RiType;")\ + oop_field(CiTargetMethod_ExceptionHandler, exceptionType, "Lcom/oracle/max/cri/ri/RiType;")\ end_class \ start_class(CiTargetMethod_Mark) \ oop_field(CiTargetMethod_Mark, id, "Ljava/lang/Object;") \ - oop_field(CiTargetMethod_Mark, references, "[Lcom/sun/cri/ci/CiTargetMethod$Mark;") \ + oop_field(CiTargetMethod_Mark, references, "[Lcom/oracle/max/cri/ci/CiTargetMethod$Mark;") \ end_class \ start_class(CiDebugInfo) \ - oop_field(CiDebugInfo, codePos, "Lcom/sun/cri/ci/CiCodePos;") \ - oop_field(CiDebugInfo, registerRefMap, "Lcom/sun/cri/ci/CiBitMap;") \ - oop_field(CiDebugInfo, frameRefMap, "Lcom/sun/cri/ci/CiBitMap;") \ + oop_field(CiDebugInfo, codePos, "Lcom/oracle/max/cri/ci/CiCodePos;") \ + oop_field(CiDebugInfo, registerRefMap, "Lcom/oracle/max/cri/ci/CiBitMap;") \ + oop_field(CiDebugInfo, frameRefMap, "Lcom/oracle/max/cri/ci/CiBitMap;") \ end_class \ start_class(GraalBitMap) \ int_field(GraalBitMap, size) \ @@ -152,62 +152,62 @@ oop_field(GraalBitMap, extra, "[J") \ end_class \ start_class(CiFrame) \ - oop_field(CiFrame, values, "[Lcom/sun/cri/ci/CiValue;") \ + oop_field(CiFrame, values, "[Lcom/oracle/max/cri/ci/CiValue;") \ int_field(CiFrame, numLocals) \ int_field(CiFrame, numStack) \ int_field(CiFrame, numLocks) \ boolean_field(CiFrame, rethrowException) \ end_class \ start_class(CiCodePos) \ - oop_field(CiCodePos, caller, "Lcom/sun/cri/ci/CiCodePos;") \ - oop_field(CiCodePos, method, "Lcom/sun/cri/ri/RiResolvedMethod;") \ + oop_field(CiCodePos, caller, "Lcom/oracle/max/cri/ci/CiCodePos;") \ + oop_field(CiCodePos, method, "Lcom/oracle/max/cri/ri/RiResolvedMethod;") \ int_field(CiCodePos, bci) \ end_class \ start_class(CiConstant) \ - oop_field(CiConstant, kind, "Lcom/sun/cri/ci/CiKind;") \ + oop_field(CiConstant, kind, "Lcom/oracle/max/cri/ci/CiKind;") \ oop_field(CiConstant, object, "Ljava/lang/Object;") \ long_field(CiConstant, primitive) \ end_class \ start_class(CiKind) \ char_field(CiKind, typeChar) \ - static_oop_field(CiKind, Boolean, "Lcom/sun/cri/ci/CiKind;"); \ - static_oop_field(CiKind, Byte, "Lcom/sun/cri/ci/CiKind;"); \ - static_oop_field(CiKind, Char, "Lcom/sun/cri/ci/CiKind;"); \ - static_oop_field(CiKind, Short, "Lcom/sun/cri/ci/CiKind;"); \ - static_oop_field(CiKind, Int, "Lcom/sun/cri/ci/CiKind;"); \ - static_oop_field(CiKind, Long, "Lcom/sun/cri/ci/CiKind;"); \ + static_oop_field(CiKind, Boolean, "Lcom/oracle/max/cri/ci/CiKind;"); \ + static_oop_field(CiKind, Byte, "Lcom/oracle/max/cri/ci/CiKind;"); \ + static_oop_field(CiKind, Char, "Lcom/oracle/max/cri/ci/CiKind;"); \ + static_oop_field(CiKind, Short, "Lcom/oracle/max/cri/ci/CiKind;"); \ + static_oop_field(CiKind, Int, "Lcom/oracle/max/cri/ci/CiKind;"); \ + static_oop_field(CiKind, Long, "Lcom/oracle/max/cri/ci/CiKind;"); \ end_class \ start_class(CiRuntimeCall) \ - static_oop_field(CiRuntimeCall, UnwindException, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, RegisterFinalizer, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, HandleException, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, SetDeoptInfo, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, CreateNullPointerException, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, CreateOutOfBoundsException, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, OSRMigrationEnd, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, JavaTimeMillis, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, JavaTimeNanos, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, Debug, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, ArithmethicLrem, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, ArithmeticLdiv, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, ArithmeticFrem, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, ArithmeticDrem, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, ArithmeticCos, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, ArithmeticTan, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, ArithmeticLog, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, ArithmeticLog10, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, ArithmeticSin, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, Deoptimize, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ - static_oop_field(CiRuntimeCall, GenericCallback, "Lcom/sun/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, UnwindException, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, RegisterFinalizer, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, HandleException, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, SetDeoptInfo, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, CreateNullPointerException, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, CreateOutOfBoundsException, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, OSRMigrationEnd, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, JavaTimeMillis, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, JavaTimeNanos, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, Debug, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, ArithmethicLrem, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, ArithmeticLdiv, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, ArithmeticFrem, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, ArithmeticDrem, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, ArithmeticCos, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, ArithmeticTan, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, ArithmeticLog, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, ArithmeticLog10, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, ArithmeticSin, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, Deoptimize, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ + static_oop_field(CiRuntimeCall, GenericCallback, "Lcom/oracle/max/cri/ci/CiRuntimeCall;"); \ end_class \ start_class(RiMethod) \ end_class \ start_class(CiValue) \ - oop_field(CiValue, kind, "Lcom/sun/cri/ci/CiKind;") \ - static_oop_field(CiValue, IllegalValue, "Lcom/sun/cri/ci/CiValue;"); \ + oop_field(CiValue, kind, "Lcom/oracle/max/cri/ci/CiKind;") \ + static_oop_field(CiValue, IllegalValue, "Lcom/oracle/max/cri/ci/CiValue;"); \ end_class \ start_class(CiRegisterValue) \ - oop_field(CiRegisterValue, reg, "Lcom/sun/cri/ci/CiRegister;") \ + oop_field(CiRegisterValue, reg, "Lcom/oracle/max/cri/ci/CiRegister;") \ end_class \ start_class(CiRegister) \ int_field(CiRegister, number) \ @@ -218,19 +218,19 @@ end_class \ start_class(CiVirtualObject) \ int_field(CiVirtualObject, id) \ - oop_field(CiVirtualObject, type, "Lcom/sun/cri/ri/RiType;") \ - oop_field(CiVirtualObject, values, "[Lcom/sun/cri/ci/CiValue;") \ + oop_field(CiVirtualObject, type, "Lcom/oracle/max/cri/ri/RiType;") \ + oop_field(CiVirtualObject, values, "[Lcom/oracle/max/cri/ci/CiValue;") \ end_class \ start_class(CiMonitorValue) \ - oop_field(CiMonitorValue, owner, "Lcom/sun/cri/ci/CiValue;") \ - oop_field(CiMonitorValue, lockData, "Lcom/sun/cri/ci/CiValue;") \ + oop_field(CiMonitorValue, owner, "Lcom/oracle/max/cri/ci/CiValue;") \ + oop_field(CiMonitorValue, lockData, "Lcom/oracle/max/cri/ci/CiValue;") \ boolean_field(CiMonitorValue, eliminated) \ end_class \ start_class(RiTypeProfile) \ int_field(RiTypeProfile, count) \ int_field(RiTypeProfile, morphism) \ oop_field(RiTypeProfile, probabilities, "[F") \ - oop_field(RiTypeProfile, types, "[Lcom/sun/cri/ri/RiResolvedType;") \ + oop_field(RiTypeProfile, types, "[Lcom/oracle/max/cri/ri/RiResolvedType;") \ end_class \ /* end*/
--- a/src/share/vm/graal/graalVMEntries.cpp Tue Jan 03 15:49:22 2012 +0100 +++ b/src/share/vm/graal/graalVMEntries.cpp Tue Jan 03 16:47:02 2012 +0100 @@ -980,24 +980,24 @@ #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) #define PROXY "J" -#define TYPE "Lcom/sun/cri/ri/RiType;" -#define RESOLVED_TYPE "Lcom/oracle/max/graal/hotspot/HotSpotTypeResolved;" -#define METHOD "Lcom/sun/cri/ri/RiMethod;" -#define RESOLVED_METHOD "Lcom/oracle/max/graal/hotspot/HotSpotMethodResolved;" +#define TYPE "Lcom/oracle/max/cri/ri/RiType;" +#define RESOLVED_TYPE "Lcom/oracle/max/graal/hotspot/ri/HotSpotTypeResolved;" +#define METHOD "Lcom/oracle/max/cri/ri/RiMethod;" +#define RESOLVED_METHOD "Lcom/oracle/max/graal/hotspot/ri/HotSpotMethodResolved;" #define REFLECT_METHOD "Ljava/lang/reflect/Method;" -#define TYPE_PROFILE "Lcom/sun/cri/ri/RiTypeProfile;" -#define SIGNATURE "Lcom/sun/cri/ri/RiSignature;" -#define FIELD "Lcom/sun/cri/ri/RiField;" -#define RESOLVED_FIELD "Lcom/sun/cri/ri/RiResolvedField;" -#define CONSTANT_POOL "Lcom/sun/cri/ri/RiConstantPool;" -#define EXCEPTION_HANDLERS "[Lcom/sun/cri/ri/RiExceptionHandler;" +#define TYPE_PROFILE "Lcom/oracle/max/cri/ri/RiTypeProfile;" +#define SIGNATURE "Lcom/oracle/max/cri/ri/RiSignature;" +#define FIELD "Lcom/oracle/max/cri/ri/RiField;" +#define RESOLVED_FIELD "Lcom/oracle/max/cri/ri/RiResolvedField;" +#define CONSTANT_POOL "Lcom/oracle/max/cri/ri/RiConstantPool;" +#define EXCEPTION_HANDLERS "[Lcom/oracle/max/cri/ri/RiExceptionHandler;" #define TARGET_METHOD "Lcom/oracle/max/graal/hotspot/HotSpotTargetMethod;" #define CONFIG "Lcom/oracle/max/graal/hotspot/HotSpotVMConfig;" -#define HS_METHOD "Lcom/oracle/max/graal/hotspot/HotSpotMethod;" +#define HS_METHOD "Lcom/oracle/max/graal/hotspot/ri/HotSpotMethod;" #define HS_COMP_METHOD "Lcom/oracle/max/graal/hotspot/HotSpotCompiledMethod;" -#define CI_CONSTANT "Lcom/sun/cri/ci/CiConstant;" -#define CI_KIND "Lcom/sun/cri/ci/CiKind;" -#define CI_RUNTIME_CALL "Lcom/sun/cri/ci/CiRuntimeCall;" +#define CI_CONSTANT "Lcom/oracle/max/cri/ci/CiConstant;" +#define CI_KIND "Lcom/oracle/max/cri/ci/CiKind;" +#define CI_RUNTIME_CALL "Lcom/oracle/max/cri/ci/CiRuntimeCall;" #define STRING "Ljava/lang/String;" #define OBJECT "Ljava/lang/Object;" #define CLASS "Ljava/lang/Class;"