# HG changeset patch # User Thomas Wuerthinger # Date 1303848101 -7200 # Node ID c89dcda5d1094747c33a045fb66798dcf3815ccd # Parent 72d9b2cd27d6691c996651aafc096250fd82c3fe# Parent 6bc5ec0255dfa03e951d31191040633c965f50b8 Merge. diff -r 72d9b2cd27d6 -r c89dcda5d109 GRAAL_AUTHORS --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/GRAAL_AUTHORS Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,6 @@ +Lukas Stadler (stadler@ssw.jku.at) +* July - September 2011: Initial feature-complete implementation, remote compilation + +Thomas Wuerthinger (thomas.wuerthinger@oracle.com) +* June 2011: Initial prototype +* October 2010 - January 2011: Bug fixes (all DaCapo's pass), better performance on SciMark than C1 diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/.checkstyle_checks.xml --- a/graal/Runtime/.checkstyle_checks.xml Fri Apr 22 23:22:46 2011 +0200 +++ b/graal/Runtime/.checkstyle_checks.xml Tue Apr 26 22:01:41 2011 +0200 @@ -1,182 +1,191 @@ - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/Compiler.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/Compiler.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,33 @@ +/* + * 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.graal.runtime; + +import com.sun.c1x.*; + +public interface Compiler { + + VMEntries getVMEntries(); + VMExits getVMExits(); + C1XCompiler getCompiler(); + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/CompilerImpl.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/CompilerImpl.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,199 @@ +/* + * 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.graal.runtime; + +import java.io.*; +import java.lang.management.*; +import java.net.*; + +import com.oracle.graal.runtime.logging.*; +import com.oracle.graal.runtime.server.*; +import com.sun.c1x.*; +import com.sun.c1x.target.amd64.*; +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; +import com.sun.cri.xir.*; + +/** + * Singleton class holding the instance of the C1XCompiler. + */ +public final class CompilerImpl implements Compiler, Remote { + + private static Compiler theInstance; + private static boolean PrintGCStats = false; + + public static Compiler getInstance() { + return theInstance; + } + + public static void initialize() { + if (theInstance != null) { + throw new IllegalStateException("Compiler already initialized"); + } + + String remote = System.getProperty("c1x.remote"); + if (remote != null) { + // remote compilation (will not create a local Compiler) + try { + System.out.println("C1X compiler started in client/server mode, server: " + remote); + Socket socket = new Socket(remote, 1199); + ReplacingStreams streams = new ReplacingStreams(socket.getOutputStream(), socket.getInputStream()); + streams.getInvocation().sendResult(new VMEntriesNative()); + + theInstance = (Compiler) streams.getInvocation().waitForResult(false); + } catch (IOException e1) { + System.out.println("Connection to compilation server FAILED."); + throw new RuntimeException(e1); + } catch (ClassNotFoundException e2) { + System.out.println("Connection to compilation server FAILED."); + throw new RuntimeException(e2); + } + } else { + // ordinary local compilation + theInstance = new CompilerImpl(null); + Runtime.getRuntime().addShutdownHook(new ShutdownThread()); + } + } + + public static Compiler initializeServer(VMEntries entries) { + assert theInstance == null; + theInstance = new CompilerImpl(entries); + Runtime.getRuntime().addShutdownHook(new ShutdownThread()); + return theInstance; + } + + public static class ShutdownThread extends Thread { + + @Override + public void run() { + VMExitsNative.compileMethods = false; + if (C1XOptions.PrintMetrics) { + C1XMetrics.print(); + } + if (C1XOptions.PrintTimers) { + C1XTimers.print(); + } + if (PrintGCStats) { + printGCStats(); + } + } + } + + public static void printGCStats() { + long totalGarbageCollections = 0; + long garbageCollectionTime = 0; + + for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) { + long count = gc.getCollectionCount(); + if (count >= 0) { + totalGarbageCollections += count; + } + + long time = gc.getCollectionTime(); + if (time >= 0) { + garbageCollectionTime += time; + } + } + + System.out.println("Total Garbage Collections: " + totalGarbageCollections); + System.out.println("Total Garbage Collection Time (ms): " + garbageCollectionTime); + } + + private final VMEntries vmEntries; + private final VMExits vmExits; + private C1XCompiler compiler; + + private final HotSpotRuntime runtime; + private final CiTarget target; + private final RiXirGenerator generator; + private final RiRegisterConfig registerConfig; + + private CompilerImpl(VMEntries entries) { + + // initialize VMEntries + if (entries == null) { + entries = new VMEntriesNative(); + } + + // initialize VMExits + VMExits exits = new VMExitsNative(this); + + // logging, etc. + if (CountingProxy.ENABLED) { + exits = CountingProxy.getProxy(VMExits.class, exits); + entries = CountingProxy.getProxy(VMEntries.class, entries); + } + if (Logger.ENABLED) { + exits = LoggingProxy.getProxy(VMExits.class, exits); + entries = LoggingProxy.getProxy(VMEntries.class, entries); + } + + // set the final fields + vmEntries = entries; + vmExits = exits; + + // initialize compiler and C1XOptions + HotSpotVMConfig config = vmEntries.getConfiguration(); + config.check(); + + // these options are important - c1x4hotspot will not generate correct code without them + C1XOptions.GenSpecialDivChecks = true; + C1XOptions.NullCheckUniquePc = true; + C1XOptions.InvokeSnippetAfterArguments = true; + C1XOptions.StackShadowPages = config.stackShadowPages; + + runtime = new HotSpotRuntime(config, this); + registerConfig = runtime.globalStubRegConfig; + + final int wordSize = 8; + final int stackFrameAlignment = 16; + target = new HotSpotTarget(new AMD64(), true, wordSize, stackFrameAlignment, config.vmPageSize, wordSize, true); + + RiXirGenerator generator = new HotSpotXirGenerator(config, target, registerConfig, this); + if (Logger.ENABLED) { + this.generator = LoggingProxy.getProxy(RiXirGenerator.class, generator); + } else { + this.generator = generator; + } + + } + + @Override + public C1XCompiler getCompiler() { + if (compiler == null) { + compiler = new C1XCompiler(runtime, target, generator, registerConfig); + } + return compiler; + } + + @Override + public VMEntries getVMEntries() { + return vmEntries; + } + + @Override + public VMExits getVMExits() { + return vmExits; + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/CompilerObject.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/CompilerObject.java Tue Apr 26 22:01:41 2011 +0200 @@ -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.graal.runtime; + +import java.io.*; + + +/** + * Parent class for all HotSpot Ri... types. + */ +public abstract class CompilerObject implements Serializable { + protected final Compiler compiler; + + protected CompilerObject(Compiler compiler) { + this.compiler = compiler; + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotConstantPool.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotConstantPool.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,145 @@ +/* + * 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.graal.runtime; + +import java.io.*; +import java.util.*; + +import com.sun.cri.ri.*; + +/** + * Implementation of RiConstantPool for HotSpot. + */ +public class HotSpotConstantPool extends CompilerObject implements RiConstantPool { + + private final long vmId; + + private final FastLRUIntCache methodCache = new FastLRUIntCache(); + private final FastLRUIntCache fieldCache = new FastLRUIntCache(); + private final FastLRUIntCache typeCache = new FastLRUIntCache(); + + public static class FastLRUIntCache implements Serializable { + + private static final int InitialCapacity = 4; + private int lastKey; + private T lastObject; + + private int[] keys; + private Object[] objects; + private int count; + + @SuppressWarnings("unchecked") + private T access(int index) { + return (T) objects[index]; + } + + public T get(int key) { + if (key == lastKey) { + return lastObject; + } else if (count > 1) { + for (int i = 0; i < count; ++i) { + if (keys[i] == key) { + lastObject = access(i); + lastKey = key; + return lastObject; + } + } + } + return null; + } + + public void add(int key, T object) { + count++; + if (count == 1) { + lastKey = key; + lastObject = object; + } else { + ensureSize(); + keys[count - 1] = key; + objects[count - 1] = object; + if (count == 2) { + keys[0] = lastKey; + objects[0] = lastObject; + } + lastKey = key; + lastObject = object; + } + } + + private void ensureSize() { + if (keys == null) { + keys = new int[InitialCapacity]; + objects = new Object[InitialCapacity]; + } else if (count > keys.length) { + keys = Arrays.copyOf(keys, keys.length * 2); + objects = Arrays.copyOf(objects, objects.length * 2); + } + } + } + + public HotSpotConstantPool(Compiler compiler, long vmId) { + super(compiler); + this.vmId = vmId; + } + + @Override + public Object lookupConstant(int cpi) { + Object constant = compiler.getVMEntries().RiConstantPool_lookupConstant(vmId, cpi); + return constant; + } + + @Override + public RiSignature lookupSignature(int cpi) { + return compiler.getVMEntries().RiConstantPool_lookupSignature(vmId, cpi); + } + + @Override + public RiMethod lookupMethod(int cpi, int byteCode) { + RiMethod result = methodCache.get(cpi); + if (result == null) { + result = compiler.getVMEntries().RiConstantPool_lookupMethod(vmId, cpi, (byte) byteCode); + methodCache.add(cpi, result); + } + return result; + } + + @Override + public RiType lookupType(int cpi, int opcode) { + RiType result = typeCache.get(cpi); + if (result == null) { + result = compiler.getVMEntries().RiConstantPool_lookupType(vmId, cpi); + typeCache.add(cpi, result); + } + return result; + } + + @Override + public RiField lookupField(int cpi, int opcode) { + RiField result = fieldCache.get(cpi); + if (result == null) { + result = compiler.getVMEntries().RiConstantPool_lookupField(vmId, cpi, (byte) opcode); + fieldCache.add(cpi, result); + } + return result; + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotExceptionHandler.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotExceptionHandler.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,69 @@ +/* + * 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.graal.runtime; + +import com.sun.cri.ri.*; + + +public class HotSpotExceptionHandler extends CompilerObject implements RiExceptionHandler { + private int startBci; + private int endBci; + private int handlerBci; + private int catchClassIndex; + private RiType catchClass; + + public HotSpotExceptionHandler() { + super(null); + } + + @Override + public int startBCI() { + return startBci; + } + + @Override + public int endBCI() { + return endBci; + } + + @Override + public int handlerBCI() { + return handlerBci; + } + + @Override + public int catchTypeCPI() { + return catchClassIndex; + } + + @Override + public boolean isCatchAll() { + return catchClassIndex == 0; + } + + @Override + public RiType catchType() { + return catchClass; + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotField.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotField.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,136 @@ +/* + * 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.graal.runtime; + +import java.lang.reflect.*; + +import com.sun.c1x.*; +import com.sun.cri.ci.CiConstant; +import com.sun.cri.ci.CiKind; +import com.sun.cri.ri.RiField; +import com.sun.cri.ri.RiType; + +/** + * Represents a field in a HotSpot type. + */ +public class HotSpotField extends CompilerObject implements RiField { + + private final RiType holder; + private final String name; + private final RiType type; + private final int offset; + private final int accessFlags; + private CiConstant constant; + + public HotSpotField(Compiler compiler, RiType holder, String name, RiType type, int offset, int accessFlags) { + super(compiler); + this.holder = holder; + this.name = name; + this.type = type; + this.offset = offset; + this.accessFlags = accessFlags; + } + + @Override + public int accessFlags() { + return accessFlags; + } + + @Override + public CiConstant constantValue(CiConstant receiver) { + if (receiver == null) { + if (constant == null && holder.isResolved() && holder.isSubtypeOf(compiler.getVMEntries().getType(C1XOptions.class))) { + Field f; + try { + f = C1XOptions.class.getField(name); + } catch (SecurityException e1) { + return null; + } catch (NoSuchFieldException e1) { + return null; + } + f.setAccessible(true); + if (Modifier.isStatic(f.getModifiers())) { + CiKind kind = CiKind.fromJavaClass(f.getType()); + Object value; + try { + value = f.get(null); + } catch (IllegalArgumentException e) { + return null; + } catch (IllegalAccessException e) { + return null; + } + constant = CiConstant.forBoxed(kind, value); + } + } + + // Constant part only valid for static fields. + return constant; + } + return null; + } + + @Override + public RiType holder() { + return holder; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof HotSpotField) { + HotSpotField other = (HotSpotField) obj; + return other.offset == offset && other.holder.equals(holder()); + } + return false; + } + + @Override + public boolean isResolved() { + return offset != -1; + } + + @Override + public CiKind kind() { + return type().kind(); + } + + @Override + public String name() { + return name; + } + + @Override + public RiType type() { + return type; + } + + public int offset() { + return offset; + } + + @Override + public String toString() { + return "HotSpotField<" + holder.name() + "." + name + ">"; + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotMethod.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotMethod.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,46 @@ +/* + * 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.graal.runtime; + +import com.sun.cri.ri.*; + + +public abstract class HotSpotMethod extends CompilerObject implements RiMethod { + + protected RiType holder; + protected String name; + + protected HotSpotMethod(Compiler compiler) { + super(compiler); + } + + @Override + public final RiType holder() { + return holder; + } + + @Override + public final String name() { + return name; + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotMethodResolved.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotMethodResolved.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,193 @@ +/* + * 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.graal.runtime; + +import java.lang.reflect.*; + +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; + +/** + * Implementation of RiMethod for resolved HotSpot methods. + */ +public final class HotSpotMethodResolved extends HotSpotMethod { + + private final long vmId; + + // cached values + private byte[] code; + private int accessFlags = -1; + private int maxLocals = -1; + private int maxStackSize = -1; + private RiExceptionHandler[] exceptionHandlers; + private RiSignature signature; + private Boolean hasBalancedMonitors; + + public HotSpotMethodResolved(Compiler compiler, long vmId, String name) { + super(compiler); + this.vmId = vmId; + this.name = name; + this.holder = compiler.getVMEntries().RiMethod_holder(vmId); + } + + @Override + public int accessFlags() { + if (accessFlags == -1) { + accessFlags = compiler.getVMEntries().RiMethod_accessFlags(vmId); + } + return accessFlags; + } + + @Override + public boolean canBeStaticallyBound() { + return isLeafMethod() || Modifier.isStatic(accessFlags()); + } + + @Override + public byte[] code() { + if (code == null) { + code = compiler.getVMEntries().RiMethod_code(vmId); + } + return code; + } + + @Override + public RiExceptionHandler[] exceptionHandlers() { + if (exceptionHandlers == null) { + exceptionHandlers = compiler.getVMEntries().RiMethod_exceptionHandlers(vmId); + } + return exceptionHandlers; + } + + @Override + public boolean hasBalancedMonitors() { + if (hasBalancedMonitors == null) { + hasBalancedMonitors = compiler.getVMEntries().RiMethod_hasBalancedMonitors(vmId); + } + return hasBalancedMonitors; + } + + @Override + public boolean isClassInitializer() { + return "".equals(name); + } + + @Override + public boolean isConstructor() { + return "".equals(name); + } + + @Override + public boolean isLeafMethod() { + return Modifier.isFinal(accessFlags()) || Modifier.isPrivate(accessFlags()); + } + + @Override + public boolean isOverridden() { + throw new UnsupportedOperationException("isOverridden"); + } + + @Override + public boolean noSafepoints() { + return false; + } + + @Override + public boolean isResolved() { + return true; + } + + @Override + public String jniSymbol() { + throw new UnsupportedOperationException("jniSymbol"); + } + + public CiBitMap[] livenessMap() { + return null; + } + + @Override + public int maxLocals() { + if (maxLocals == -1) { + maxLocals = compiler.getVMEntries().RiMethod_maxLocals(vmId); + } + return maxLocals; + } + + @Override + public int maxStackSize() { + if (maxStackSize == -1) { + maxStackSize = compiler.getVMEntries().RiMethod_maxStackSize(vmId); + } + return maxStackSize; + } + + @Override + public RiMethodProfile methodData() { + return null; + } + + @Override + public StackTraceElement toStackTraceElement(int bci) { + return CiUtil.toStackTraceElement(this, bci); + } + + @Override + public RiMethod uniqueConcreteMethod() { + return compiler.getVMEntries().RiMethod_uniqueConcreteMethod(vmId); + } + + @Override + public RiSignature signature() { + if (signature == null) { + signature = new HotSpotSignature(compiler, compiler.getVMEntries().RiMethod_signature(vmId)); + } + return signature; + } + + @Override + public String toString() { + return "HotSpotMethod<" + holder().name() + ". " + name + ">"; + } + + public boolean hasCompiledCode() { + // TODO: needs a VMEntries to go cache the result of that method. + // This isn't used by GRAAL for now, so this is enough. + return false; + } + + @Override + public RiType accessor() { + return null; + } + + @Override + public int intrinsic() { + return 0; + } + + @Override + public boolean minimalDebugInfo() { + return false; + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotMethodUnresolved.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotMethodUnresolved.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,163 @@ +/* + * 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.graal.runtime; + +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; + +/** + * Implementation of RiMethod for unresolved HotSpot methods. + */ +public final class HotSpotMethodUnresolved extends HotSpotMethod { + private final RiSignature signature; + + 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 boolean isResolved() { + return false; + } + + @Override + public byte[] code() { + throw unresolved("code"); + } + + @Override + public RiMethodProfile methodData() { + throw unresolved("methodData"); + } + + @Override + public String jniSymbol() { + throw unresolved("jniSymbol"); + } + + @Override + public int maxLocals() { + throw unresolved("maxLocals"); + } + + @Override + public int maxStackSize() { + throw unresolved("maxStackSize"); + } + + @Override + public boolean hasBalancedMonitors() { + throw unresolved("hasBalancedMonitors"); + } + + @Override + public RiMethod uniqueConcreteMethod() { + throw unresolved("uniqueConcreteMethod()"); + } + + @Override + public int accessFlags() { + throw unresolved("accessFlags"); + } + + @Override + public boolean isLeafMethod() { + throw unresolved("isLeafMethod"); + } + + @Override + public boolean isClassInitializer() { + return "".equals(name); + } + + @Override + public boolean isConstructor() { + return "".equals(name); + } + + @Override + public boolean isOverridden() { + throw unresolved("isOverridden"); + } + + @Override + public boolean noSafepoints() { + return false; + } + + @Override + public CiBitMap[] livenessMap() { + return null; + } + + @Override + public StackTraceElement toStackTraceElement(int bci) { + return CiUtil.toStackTraceElement(this, bci); + } + + @Override + public boolean canBeStaticallyBound() { + throw unresolved("canBeStaticallyBound"); + } + + @Override + public RiExceptionHandler[] exceptionHandlers() { + throw unresolved("exceptionHandlers"); + } + + @Override + public boolean minimalDebugInfo() { + throw unresolved("minimalDebugInfo"); + } + + private CiUnresolvedException unresolved(String operation) { + return new CiUnresolvedException(operation + " not defined for unresolved method " + name); + } + + @Override + public String toString() { + return "HotSpotMethod<" + holder.name() + ". " + name + ", unresolved>"; + } + + public boolean hasCompiledCode() { + return false; + } + + @Override + public RiType accessor() { + return null; + } + + @Override + public int intrinsic() { + return 0; + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotOptions.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotOptions.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,105 @@ +/* + * 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.graal.runtime; + +import java.lang.reflect.*; + +import com.oracle.graal.runtime.logging.*; +import com.sun.c1x.*; + +public class HotSpotOptions { + + public static void setDefaultOptions() { + C1XOptions.setOptimizationLevel(3); + C1XOptions.OptInlineExcept = false; + C1XOptions.OptInlineSynchronized = false; + C1XOptions.DetailedAsserts = false; + C1XOptions.CommentedAssembly = false; + C1XOptions.MethodEndBreakpointGuards = 2; + C1XOptions.ResolveClassBeforeStaticInvoke = false; + } + + public static boolean setOption(String option) { + if (option.length() == 0) { + return false; + } + + Object value = null; + String fieldName = null; + String valueString = null; + + char first = option.charAt(0); + if (first == '+' || first == '-') { + fieldName = option.substring(1); + value = (first == '+'); + } else { + int index = option.indexOf('='); + if (index == -1) { + return false; + } + fieldName = option.substring(0, index); + valueString = option.substring(index + 1); + } + + Field f; + try { + f = C1XOptions.class.getField(fieldName); + + if (value == null) { + if (f.getType() == Float.TYPE) { + value = Float.parseFloat(valueString); + } else if (f.getType() == Double.TYPE) { + value = Double.parseDouble(valueString); + } else if (f.getType() == Integer.TYPE) { + value = Integer.parseInt(valueString); + } else if (f.getType() == Boolean.TYPE) { + value = Boolean.parseBoolean(valueString); + } else if (f.getType() == String.class) { + value = valueString; + } + } + if (value != null) { + f.set(null, value); + Logger.info("Set option " + fieldName + " to " + value); + } else { + Logger.info("Wrong value \"" + valueString + "\" for option " + fieldName); + return false; + } + } catch (SecurityException e) { + Logger.info("Security exception when setting option " + option); + return false; + } catch (NoSuchFieldException e) { + Logger.info("Could not find option " + fieldName); + return false; + } catch (IllegalArgumentException e) { + Logger.info("Illegal value for option " + option); + return false; + } catch (IllegalAccessException e) { + Logger.info("Illegal access exception when setting option " + option); + return false; + } + + return true; + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotProxy.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,92 @@ +/* + * 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.graal.runtime; + +/** + * Provides methods to classify the HotSpot-internal identifiers. + */ +public final class HotSpotProxy { + + private HotSpotProxy() { + } + + private enum CompilerObjectType { + // this enum needs to have the same values as the one in c1x_Compiler.hpp + STUB(0x100000000000000L), + METHOD(0x200000000000000L), + CLASS(0x300000000000000L), + SYMBOL(0x400000000000000L), + CONSTANT_POOL(0x500000000000000L), + CONSTANT(0x600000000000000L), + TYPE_MASK(0xf00000000000000L), + DUMMY_CONSTANT(0x6ffffffffffffffL); + + public final long bits; + + CompilerObjectType(long bits) { + this.bits = bits; + } + } + + public static final Long DUMMY_CONSTANT_OBJ = CompilerObjectType.DUMMY_CONSTANT.bits; + + private static boolean isType(long id, CompilerObjectType type) { + return (id & CompilerObjectType.TYPE_MASK.bits) == type.bits; + } + + public static boolean isStub(long id) { + return isType(id, CompilerObjectType.STUB); + } + + public static boolean isMethod(long id) { + return isType(id, CompilerObjectType.METHOD); + } + + public static boolean isClass(long id) { + return isType(id, CompilerObjectType.CLASS); + } + + public static boolean isSymbol(long id) { + return isType(id, CompilerObjectType.SYMBOL); + } + + public static boolean isConstantPool(long id) { + return isType(id, CompilerObjectType.CONSTANT_POOL); + } + + public static boolean isConstant(long id) { + return isType(id, CompilerObjectType.CONSTANT_POOL); + } + + public static String toString(long id) { + CompilerObjectType type = null; + for (CompilerObjectType t : CompilerObjectType.values()) { + if ((id & CompilerObjectType.TYPE_MASK.bits) == t.bits) { + type = t; + } + } + long num = id & ~CompilerObjectType.TYPE_MASK.bits; + return type + " " + num; + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotRegisterConfig.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotRegisterConfig.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,209 @@ +/* + * 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.graal.runtime; + +import static com.sun.c1x.target.amd64.AMD64.*; + +import java.util.*; + +import com.sun.c1x.target.amd64.*; +import com.sun.c1x.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 { + + // be careful - the contents of this array are duplicated in c1x_CodeInstaller.cpp + private final CiRegister[] allocatable = { + rax, rbx, rcx, rdx, rsi, rdi, r8, r9, /* r10, */r11, r12, r13, r14, /*r15*/ + xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, + xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15 + }; + + private final EnumMap categorized = CiRegister.categorize(allocatable); + + private final RiRegisterAttributes[] attributesMap; + + @Override + public CiRegister[] getAllocatableRegisters() { + return allocatable; + } + + @Override + public EnumMap getCategorizedAllocatableRegisters() { + return categorized; + } + + @Override + public RiRegisterAttributes[] getAttributesMap() { + return attributesMap; + } + + private final CiRegister[] generalParameterRegisters; + private final CiRegister[] xmmParameterRegisters = {xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7}; + private final CiRegister[] allParameterRegisters; + + private final CiRegister[] rsaRegs = { + rax, rcx, rdx, rbx, rsp, rbp, rsi, rdi, + r8, r9, r10, r11, r12, r13, r14, r15, + xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, + xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15 + }; + + private final CiCalleeSaveArea registerSaveArea; + + + public HotSpotRegisterConfig(HotSpotVMConfig config, boolean globalStubConfig) { + if (config.windowsOs) { + generalParameterRegisters = new CiRegister[] {rdx, r8, r9, rdi, rsi, rcx}; + } else { + generalParameterRegisters = new CiRegister[] {rsi, rdx, rcx, r8, r9, rdi}; + } + + if (globalStubConfig) { + registerSaveArea = new CiCalleeSaveArea(-1, 8, rsaRegs); + } else { + registerSaveArea = CiCalleeSaveArea.EMPTY; + } + + attributesMap = RiRegisterAttributes.createMap(this, AMD64.allRegisters); + allParameterRegisters = Arrays.copyOf(generalParameterRegisters, generalParameterRegisters.length + xmmParameterRegisters.length); + System.arraycopy(xmmParameterRegisters, 0, allParameterRegisters, generalParameterRegisters.length, xmmParameterRegisters.length); + } + + @Override + public CiRegister[] getCallerSaveRegisters() { + return getAllocatableRegisters(); + } + + @Override + public CiRegister getRegisterForRole(int index) { + throw new UnsupportedOperationException(); + } + + @Override + public CiCallingConvention getCallingConvention(Type type, CiKind[] parameters, CiTarget target) { + if (type == Type.NativeCall) { + throw new UnsupportedOperationException(); + } + return callingConvention(parameters, type, target); + } + + public CiRegister[] getCallingConventionRegisters(Type type, RegisterFlag flag) { + return allParameterRegisters; + } + + private CiCallingConvention callingConvention(CiKind[] types, Type type, CiTarget target) { + CiValue[] locations = new CiValue[types.length]; + + int currentGeneral = 0; + int currentXMM = 0; + int currentStackIndex = 0; + + for (int i = 0; i < types.length; i++) { + final CiKind kind = types[i]; + + switch (kind) { + case Byte: + case Boolean: + case Short: + case Char: + case Int: + case Long: + case Word: + case Object: + if (currentGeneral < generalParameterRegisters.length) { + CiRegister register = generalParameterRegisters[currentGeneral++]; + locations[i] = register.asValue(kind); + } + break; + case Float: + case Double: + if (currentXMM < xmmParameterRegisters.length) { + CiRegister register = xmmParameterRegisters[currentXMM++]; + locations[i] = register.asValue(kind); + } + break; + default: + throw Util.shouldNotReachHere(); + } + + if (locations[i] == null) { + // we need to adjust for the frame pointer stored on the stack, which shifts incoming arguments by one slot + locations[i] = CiStackSlot.get(kind.stackKind(), currentStackIndex + (type.out ? 0 : 1), !type.out); + currentStackIndex += target.spillSlots(kind); + } + } + + return new CiCallingConvention(locations, currentStackIndex * target.spillSlotSize); + } + + @Override + public CiRegister getReturnRegister(CiKind kind) { + switch (kind) { + case Boolean: + case Byte: + case Char: + case Short: + case Int: + case Long: + case Object: + case Word: + return rax; + case Float: + case Double: + return xmm0; + case Void: + case Illegal: + return null; + default: + throw new UnsupportedOperationException("no return register for type " + kind); + } + } + + @Override + public CiRegister getScratchRegister() { + return r10; + } + + @Override + public CiRegister getFrameRegister() { + return rsp; + } + + public CiCalleeSaveArea getCalleeSaveArea() { + return registerSaveArea; + } + + @Override + public String toString() { + String res = String.format( + "Allocatable: " + Arrays.toString(getAllocatableRegisters()) + "%n" + + "CallerSave: " + Arrays.toString(getCallerSaveRegisters()) + "%n" + + "CalleeSave: " + getCalleeSaveArea() + "%n" + + "Scratch: " + getScratchRegister() + "%n"); + return res; + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotRuntime.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotRuntime.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,260 @@ +/* + * 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.graal.runtime; + +import java.io.*; +import java.lang.reflect.*; +import java.util.*; + +import com.sun.cri.ci.*; +import com.sun.cri.ci.CiTargetMethod.Call; +import com.sun.cri.ci.CiTargetMethod.DataPatch; +import com.sun.cri.ci.CiTargetMethod.Safepoint; +import com.sun.cri.ri.*; +import com.sun.max.asm.dis.*; +import com.sun.max.lang.*; + +/** + * CRI runtime implementation for the HotSpot VM. + */ +public class HotSpotRuntime implements RiRuntime { + + final HotSpotVMConfig config; + final HotSpotRegisterConfig regConfig; + final HotSpotRegisterConfig globalStubRegConfig; + private final Compiler compiler; + + + public HotSpotRuntime(HotSpotVMConfig config, Compiler compiler) { + this.config = config; + this.compiler = compiler; + regConfig = new HotSpotRegisterConfig(config, false); + globalStubRegConfig = new HotSpotRegisterConfig(config, true); + } + + @Override + public int codeOffset() { + return 0; + } + + @Override + public String disassemble(byte[] code, long address) { + return disassemble(code, new DisassemblyPrinter(false), address); + } + + private String disassemble(byte[] code, DisassemblyPrinter disassemblyPrinter, long address) { + final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); + final ISA instructionSet = ISA.AMD64; + Disassembler.disassemble(byteArrayOutputStream, code, instructionSet, WordWidth.BITS_64, address, null, disassemblyPrinter); + return byteArrayOutputStream.toString(); + } + + @Override + public String disassemble(final CiTargetMethod targetMethod) { + + final DisassemblyPrinter disassemblyPrinter = new DisassemblyPrinter(false) { + + private String toString(Call call) { + if (call.runtimeCall != null) { + return "{" + call.runtimeCall.name() + "}"; + } else if (call.symbol != null) { + return "{" + call.symbol + "}"; + } else if (call.globalStubID != null) { + return "{" + call.globalStubID + "}"; + } else { + return "{" + call.method + "}"; + } + } + + private String siteInfo(int pcOffset) { + for (Call call : targetMethod.directCalls) { + if (call.pcOffset == pcOffset) { + return toString(call); + } + } + for (Call call : targetMethod.indirectCalls) { + if (call.pcOffset == pcOffset) { + return toString(call); + } + } + for (Safepoint site : targetMethod.safepoints) { + if (site.pcOffset == pcOffset) { + return "{safepoint}"; + } + } + for (DataPatch site : targetMethod.dataReferences) { + if (site.pcOffset == pcOffset) { + return "{" + site.constant + "}"; + } + } + return null; + } + + @Override + protected String disassembledObjectString(Disassembler disassembler, DisassembledObject disassembledObject) { + final String string = super.disassembledObjectString(disassembler, disassembledObject); + + String site = siteInfo(disassembledObject.startPosition()); + if (site != null) { + return string + " " + site; + } + return string; + } + }; + final byte[] code = Arrays.copyOf(targetMethod.targetCode(), targetMethod.targetCodeSize()); + return disassemble(code, disassemblyPrinter, 0L); + } + + @Override + public String disassemble(RiMethod method) { + return "No disassembler available"; + } + + @Override + public RiConstantPool getConstantPool(RiMethod method) { + return ((HotSpotTypeResolved) method.holder()).constantPool(); + } + + @Override + public RiOsrFrame getOsrFrame(RiMethod method, int bci) { + return null; + } + + public Class getJavaClass(CiConstant c) { + return null; + } + + @Override + public RiType asRiType(CiKind kind) { + return compiler.getVMEntries().getType(kind.toJavaClass()); + } + + @Override + public RiType getTypeOf(CiConstant constant) { + return compiler.getVMEntries().getRiType(constant); + } + + @Override + public boolean isExceptionType(RiType type) { + return type.isSubtypeOf(compiler.getVMEntries().getType(Throwable.class)); + } + + @Override + public RiSnippets getSnippets() { + throw new UnsupportedOperationException("getSnippets"); + } + + @Override + public boolean mustInline(RiMethod method) { + return false; + } + + @Override + public boolean mustNotCompile(RiMethod method) { + return false; + } + + @Override + public boolean mustNotInline(RiMethod method) { + return Modifier.isNative(method.accessFlags()); + } + + @Override + public Object registerGlobalStub(CiTargetMethod targetMethod, String name) { + return HotSpotTargetMethod.installStub(compiler, targetMethod, name); + } + + @Override + public int sizeOfBasicObjectLock() { + // TODO shouldn't be hard coded + return 2 * 8; + } + + @Override + public int basicObjectLockOffsetInBytes() { + return 8; + } + + @Override + public RiField getRiField(Field javaField) { + throw new UnsupportedOperationException("getRiField"); + } + + @Override + public RiMethod getRiMethod(Method javaMethod) { + throw new UnsupportedOperationException("getRiMethod"); + } + + @Override + public RiMethod getRiMethod(Constructor javaConstructor) { + throw new UnsupportedOperationException("getRiMethod"); + } + + @Override + public CiConstant invoke(RiMethod method, CiMethodInvokeArguments args) { + return null; + } + + @Override + public CiConstant foldWordOperation(int opcode, CiMethodInvokeArguments args) { + throw new UnsupportedOperationException("foldWordOperation"); + } + + @Override + public boolean areConstantObjectsEqual(CiConstant x, CiConstant y) { + return compiler.getVMEntries().compareConstantObjects(x, y); + } + + @Override + public RiRegisterConfig getRegisterConfig(RiMethod method) { + return regConfig; + } + + /** + * HotSpots needs an area suitable for storing a program counter for temporary use during the deoptimization process. + */ + @Override + public int getCustomStackAreaSize() { + return 8; + } + + @Override + public boolean supportsArrayIntrinsics() { + return true; + } + + @Override + public int getArrayLength(CiConstant array) { + return compiler.getVMEntries().getArrayLength(array); + } + + @Override + public Class asJavaClass(CiConstant c) { + return null; + } + + @Override + public Object asJavaObject(CiConstant c) { + return null; + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotSignature.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotSignature.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,149 @@ +/* + * 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.graal.runtime; + +import java.util.*; + +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; + +/** + * Represents a method signature. + */ +public class HotSpotSignature extends CompilerObject implements RiSignature { + + private final List arguments = new ArrayList(); + private final String returnType; + private final String originalString; + private RiType[] argumentTypes; + private RiType returnTypeCache; + + public HotSpotSignature(Compiler compiler, String signature) { + super(compiler); + assert signature.length() > 0; + this.originalString = signature; + + if (signature.charAt(0) == '(') { + int cur = 1; + while (cur < signature.length() && signature.charAt(cur) != ')') { + int nextCur = parseSignature(signature, cur); + arguments.add(signature.substring(cur, nextCur)); + cur = nextCur; + } + + cur++; + int nextCur = parseSignature(signature, cur); + returnType = signature.substring(cur, nextCur); + assert nextCur == signature.length(); + } else { + returnType = null; + } + } + + private int parseSignature(String signature, int cur) { + char first; + do { + first = signature.charAt(cur++); + } while (first == '['); + + switch (first) { + case 'L': + while (signature.charAt(cur) != ';') { + cur++; + } + cur++; + break; + case 'V': + case 'I': + case 'B': + case 'C': + case 'D': + case 'F': + case 'J': + case 'S': + case 'Z': + break; + default: + assert false; + } + return cur; + } + + @Override + public int argumentCount(boolean withReceiver) { + return arguments.size() + (withReceiver ? 1 : 0); + } + + @Override + public CiKind argumentKindAt(int index) { + return CiKind.fromTypeString(arguments.get(index)); + } + + @Override + public int argumentSlots(boolean withReceiver) { + + int argSlots = 0; + for (int i = 0; i < argumentCount(false); i++) { + argSlots += argumentKindAt(i).sizeInSlots(); + } + + return argSlots + (withReceiver ? 1 : 0); + } + + @Override + public RiType argumentTypeAt(int index, RiType accessingClass) { + if (argumentTypes == null) { + argumentTypes = new RiType[arguments.size()]; + } + RiType type = argumentTypes[index]; + if (type == null) { + type = compiler.getVMEntries().RiSignature_lookupType(arguments.get(index), (HotSpotTypeResolved) accessingClass); + argumentTypes[index] = type; + } + return type; + } + + @Override + public String asString() { + return originalString; + } + + @Override + public CiKind returnKind() { + return CiKind.fromTypeString(returnType); + } + + @Override + public RiType returnType(RiType accessingClass) { + if (returnTypeCache == null) { + returnTypeCache = compiler.getVMEntries().RiSignature_lookupType(returnType, (HotSpotTypeResolved) accessingClass); + } + return returnTypeCache; + } + + @Override + public String toString() { + return "HotSpotSignature<" + originalString + ">"; + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotTarget.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotTarget.java Tue Apr 26 22:01:41 2011 +0200 @@ -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.graal.runtime; + +import com.sun.cri.ci.*; + +/** + * HotSpot-specific CiTarget that provides the correct stack frame size alignment. + */ +public class HotSpotTarget extends CiTarget { + + public HotSpotTarget(CiArchitecture arch, boolean isMP, int spillSlotSize, int stackAlignment, int pageSize, int cacheAlignment, boolean inlineObjects) { + super(arch, isMP, spillSlotSize, stackAlignment, pageSize, cacheAlignment, inlineObjects, true); + } + + @Override + public int alignFrameSize(int frameSize) { + // account for the stored rbp value + return super.alignFrameSize(frameSize + wordSize) - wordSize; + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotTargetMethod.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotTargetMethod.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,106 @@ +/* + * 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.graal.runtime; + +import java.util.*; + +import com.oracle.graal.runtime.logging.*; +import com.sun.cri.ci.*; +import com.sun.cri.ci.CiTargetMethod.*; + +/** + * CiTargetMethod augmented with HotSpot-specific information. + */ +public final class HotSpotTargetMethod extends CompilerObject { + + public final CiTargetMethod targetMethod; + public final HotSpotMethodResolved method; // used only for methods + public final String name; // used only for stubs + + public final Site[] sites; + public final ExceptionHandler[] exceptionHandlers; + + private HotSpotTargetMethod(Compiler compiler, HotSpotMethodResolved method, CiTargetMethod targetMethod) { + super(compiler); + this.method = method; + this.targetMethod = targetMethod; + this.name = null; + + sites = getSortedSites(targetMethod); + if (targetMethod.exceptionHandlers == null) { + exceptionHandlers = null; + } else { + exceptionHandlers = targetMethod.exceptionHandlers.toArray(new ExceptionHandler[targetMethod.exceptionHandlers.size()]); + } + } + + private HotSpotTargetMethod(Compiler compiler, CiTargetMethod targetMethod, String name) { + super(compiler); + this.method = null; + this.targetMethod = targetMethod; + this.name = name; + + sites = getSortedSites(targetMethod); + assert targetMethod.exceptionHandlers == null || targetMethod.exceptionHandlers.size() == 0; + exceptionHandlers = null; + } + + private Site[] getSortedSites(CiTargetMethod target) { + List[] lists = new List[] {target.directCalls, target.indirectCalls, target.safepoints, target.dataReferences, target.marks}; + int count = 0; + for (List list : lists) { + count += list.size(); + } + Site[] result = new Site[count]; + int pos = 0; + for (List list : lists) { + for (Object elem : list) { + result[pos++] = (Site) elem; + } + } + Arrays.sort(result, new Comparator() { + + public int compare(Site s1, Site s2) { + if (s1.pcOffset == s2.pcOffset && (s1 instanceof Mark ^ s2 instanceof Mark)) { + return s1 instanceof Mark ? -1 : 1; + } + return s1.pcOffset - s2.pcOffset; + } + }); + if (Logger.ENABLED) { + for (Site site : result) { + Logger.log(site.pcOffset + ": " + site); + } + } + return result; + } + + public static void installMethod(Compiler compiler, HotSpotMethodResolved method, CiTargetMethod targetMethod) { + compiler.getVMEntries().installMethod(new HotSpotTargetMethod(compiler, method, targetMethod)); + } + + public static Object installStub(Compiler compiler, CiTargetMethod targetMethod, String name) { + return compiler.getVMEntries().installStub(new HotSpotTargetMethod(compiler, targetMethod, name)); + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotType.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotType.java Tue Apr 26 22:01:41 2011 +0200 @@ -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.graal.runtime; + +import com.sun.cri.ri.*; + +/** + * Common interface for all HotSpot RiType-implementations. + */ +public abstract class HotSpotType extends CompilerObject implements RiType { + protected String name; + + protected HotSpotType(Compiler compiler) { + super(compiler); + } + + @Override + public final String name() { + return name; + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotTypePrimitive.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotTypePrimitive.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,153 @@ +/* + * 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.graal.runtime; + +import com.sun.c1x.util.*; +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; + +/** + * Implementation of RiType for primitive HotSpot types. + */ +public final class HotSpotTypePrimitive extends HotSpotType { + + private CiKind kind; + + + HotSpotTypePrimitive(Compiler compiler, CiKind kind) { + super(compiler); + this.kind = kind; + this.name = kind.toString(); + } + + @Override + public int accessFlags() { + return javaClass().getModifiers(); + } + + @Override + public RiType arrayOf() { + return compiler.getVMEntries().getPrimitiveArrayType(kind); + } + + @Override + public RiType componentType() { + return null; + } + + @Override + public RiType exactType() { + return this; + } + + @Override + public RiType 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 isResolved() { + return true; + } + + @Override + public boolean isSubtypeOf(RiType other) { + return false; + } + + @Override + public Class javaClass() { + return kind.toJavaClass(); + } + + @Override + public CiKind kind() { + return kind; + } + + @Override + public RiMethod resolveMethodImpl(RiMethod method) { + return null; + } + + @Override + public String toString() { + return "HotSpotTypePrimitive<" + kind + ">"; + } + + @Override + public RiType uniqueConcreteSubtype() { + return this; + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotTypeResolved.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotTypeResolved.java Tue Apr 26 22:01:41 2011 +0200 @@ -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.graal.runtime; + +import com.oracle.graal.runtime.server.*; +import com.sun.cri.ri.*; + +public interface HotSpotTypeResolved extends RiType, Remote { + + String toString(); + + RiConstantPool constantPool(); + + int instanceSize(); + + RiField createRiField(String name, RiType type, int offset, int flags); + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotTypeResolvedImpl.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotTypeResolvedImpl.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,219 @@ +/* + * 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.graal.runtime; + +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 Class javaMirror; + private String simpleName; + private int accessFlags; + private boolean hasFinalizer; + private boolean hasSubclass; + private boolean hasFinalizableSubclass; + private boolean isInitialized; + private boolean isArrayClass; + private boolean isInstanceClass; + private boolean isInterface; + private int instanceSize; + private RiType componentType; + private HashMap fieldCache; + private RiConstantPool pool; + + private HotSpotTypeResolvedImpl() { + super(null); + } + + @Override + public int accessFlags() { + return accessFlags; + } + + @Override + public RiType arrayOf() { + return compiler.getVMEntries().RiType_arrayOf(this); + } + + @Override + public RiType componentType() { + return compiler.getVMEntries().RiType_componentType(this); + } + + @Override + public RiType uniqueConcreteSubtype() { + return compiler.getVMEntries().RiType_uniqueConcreteSubtype(this); + } + + @Override + public RiType superType() { + return compiler.getVMEntries().RiType_superType(this); + } + + @Override + public RiType exactType() { + if (Modifier.isFinal(accessFlags)) { + return this; + } + return null; + } + + @Override + public CiConstant getEncoding(Representation r) { + switch (r) { + case JavaClass: + return CiConstant.forObject(javaClass()); + case ObjectHub: + return CiConstant.forObject(this); + case StaticFields: + return CiConstant.forObject(javaClass()); + 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() { + 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 isResolved() { + return true; + } + + @Override + public boolean isSubtypeOf(RiType 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 Class javaClass() { + return javaMirror; + } + + @Override + public CiKind kind() { + return CiKind.Object; + } + + @Override + public RiMethod resolveMethodImpl(RiMethod method) { + assert method instanceof HotSpotMethod; + return compiler.getVMEntries().RiType_resolveMethodImpl(this, method.name(), method.signature().asString()); + } + + @Override + public String toString() { + return "HotSpotType<" + simpleName + ", resolved>"; + } + + @Override + public RiConstantPool constantPool() { + // TODO: Implement constant pool without the need for VmId and cache the constant pool. + return compiler.getVMEntries().RiType_constantPool(this); + } + + @Override + public int instanceSize() { + return instanceSize; + } + + @Override + public RiField createRiField(String name, RiType type, int offset, int flags) { + RiField 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, name, type, offset, flags); + fieldCache.put(id, result); + } else { + assert result.name().equals(name); + assert result.accessFlags() == flags; + } + + return result; + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotTypeUnresolved.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotTypeUnresolved.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,204 @@ +/* + * 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.graal.runtime; + +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; + +/** + * Implementation of RiType for unresolved HotSpot classes. + */ +public class HotSpotTypeUnresolved extends HotSpotType { + + 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 dimensions = 0; + // Decode name if necessary. + if (name.charAt(name.length() - 1) == ';') { + int startIndex = 0; + while (name.charAt(startIndex) == '[') { + startIndex++; + dimensions++; + } + 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, dimensions); + } + + this.dimensions = dimensions; + } + + 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 String getFullName(String name, int dimensions) { + StringBuilder str = new StringBuilder(); + for (int i = 0; i < dimensions; i++) { + str.append('['); + } + str.append('L').append(simpleName).append(';'); + return str.toString(); + } + + @Override + public RiType uniqueConcreteSubtype() { + throw unresolved("uniqueConcreteSubtype"); + } + + @Override + public Class javaClass() { + throw unresolved("javaClass"); + } + + @Override + public boolean hasSubclass() { + throw unresolved("hasSubclass()"); + } + + @Override + public boolean hasFinalizer() { + throw unresolved("hasFinalizer()"); + } + + @Override + public boolean hasFinalizableSubclass() { + throw unresolved("hasFinalizableSubclass()"); + } + + @Override + public boolean isInterface() { + throw unresolved("isInterface()"); + } + + @Override + public boolean isArrayClass() { + return dimensions > 0; + } + + @Override + public boolean isInstanceClass() { + throw unresolved("isInstanceClass()"); + } + + @Override + public int accessFlags() { + throw unresolved("accessFlags()"); + } + + @Override + public boolean isResolved() { + return false; + } + + @Override + public boolean isInitialized() { + throw unresolved("isInitialized()"); + } + + @Override + public boolean isSubtypeOf(RiType other) { + throw unresolved("isSubtypeOf()"); + } + + @Override + public boolean isInstance(CiConstant obj) { + throw unresolved("isInstance()"); + } + + @Override + public RiType componentType() { + assert isArrayClass() : "no array class" + name(); + return new HotSpotTypeUnresolved(compiler, simpleName, dimensions - 1); + } + + @Override + public RiType exactType() { + throw unresolved("exactType()"); + } + + @Override + public RiType superType() { + throw unresolved("superType()"); + } + + @Override + public RiType arrayOf() { + return new HotSpotTypeUnresolved(compiler, simpleName, dimensions + 1); + } + + @Override + public RiMethod resolveMethodImpl(RiMethod method) { + throw unresolved("resolveMethodImpl()"); + } + + @Override + public CiKind kind() { + return CiKind.Object; + } + + private CiUnresolvedException unresolved(String operation) { + throw new CiUnresolvedException(operation + " not defined for unresolved class " + simpleName); + } + + @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 CiConstant getEncoding(RiType.Representation r) { + throw unresolved("getEncoding()"); + } + + @Override + public CiKind getRepresentationKind(RiType.Representation r) { + return CiKind.Object; + } + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotVMConfig.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotVMConfig.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,122 @@ +/* + * 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.graal.runtime; + +import com.sun.cri.ci.*; + +/** + * Used to communicate configuration details, runtime offsets, etc. to c1x upon compileMethod. + */ +public final class HotSpotVMConfig extends CompilerObject { + + private HotSpotVMConfig() { + super(null); + } + + // os information, register layout, code generation, ... + public boolean windowsOs; + public int codeEntryAlignment; + public boolean verifyPointers; + public boolean useFastLocking; + public boolean useFastNewObjectArray; + public boolean useFastNewTypeArray; + + // offsets, ... + public int vmPageSize; + public int stackShadowPages; + public int hubOffset; + public int arrayLengthOffset; + public int klassStateOffset; + public int klassStateFullyInitialized; + public int[] arrayOffsets; + public int arrayClassElementOffset; + public int threadTlabTopOffset; + public int threadTlabEndOffset; + public int threadObjectOffset; + public int instanceHeaderPrototypeOffset; + public int threadExceptionOopOffset; + public int threadExceptionPcOffset; + public int threadMultiNewArrayStorage; + public long cardtableStartAddress; + public int cardtableShift; + public long safepointPollingAddress; + public int classMirrorOffset; + + // runtime stubs + public long debugStub; + public long instanceofStub; + public long newInstanceStub; + public long unresolvedNewInstanceStub; + public long newTypeArrayStub; + public long newObjectArrayStub; + public long newMultiArrayStub; + public long loadKlassStub; + public long accessFieldStub; + public long resolveStaticCallStub; + public long inlineCacheMissStub; + public long unwindExceptionStub; + public long handleExceptionStub; + public long handleDeoptStub; + public long throwClassCastException; + public long throwArrayStoreException; + public long throwArrayIndexException; + public long monitorEnterStub; + public long monitorExitStub; + public long fastMonitorEnterStub; + public long fastMonitorExitStub; + public long verifyPointerStub; + + public void check() { + assert vmPageSize >= 16; + assert codeEntryAlignment > 0; + assert stackShadowPages > 0; + } + + public int getArrayOffset(CiKind kind) { + return arrayOffsets[getKindNumber(kind)]; + } + + private int getKindNumber(CiKind kind) { + if (kind == CiKind.Boolean) { + return 0; + } else if (kind == CiKind.Byte) { + return 1; + } else if (kind == CiKind.Short) { + return 2; + } else if (kind == CiKind.Char) { + return 3; + } else if (kind == CiKind.Int) { + return 4; + } else if (kind == CiKind.Float) { + return 5; + } else if (kind == CiKind.Long) { + return 6; + } else if (kind == CiKind.Double) { + return 7; + } else if (kind == CiKind.Object) { + return 8; + } else { + throw new RuntimeException(kind + " is not a Java kind"); + } + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/HotSpotXirGenerator.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/HotSpotXirGenerator.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,1584 @@ +/* + * 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.graal.runtime; + +import static com.oracle.graal.runtime.TemplateFlag.*; +import static com.sun.cri.ci.CiCallingConvention.Type.*; + +import java.lang.reflect.*; +import java.util.*; +import java.util.concurrent.*; + +import com.sun.c1x.target.amd64.*; +import com.sun.cri.ci.CiAddress.Scale; +import com.sun.cri.ci.CiRegister.*; +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; +import com.sun.cri.ri.RiType.Representation; +import com.sun.cri.xir.*; +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; + +public class HotSpotXirGenerator implements RiXirGenerator { + + // this needs to correspond to c1x_CodeInstaller.hpp + // @formatter:off + private static final Integer MARK_VERIFIED_ENTRY = 0x0001; + private static final Integer MARK_UNVERIFIED_ENTRY = 0x0002; + private static final Integer MARK_OSR_ENTRY = 0x0003; + private static final Integer MARK_UNWIND_ENTRY = 0x0004; + private static final Integer MARK_EXCEPTION_HANDLER_ENTRY = 0x0005; + private static final Integer MARK_DEOPT_HANDLER_ENTRY = 0x0006; + + private static final Integer MARK_STATIC_CALL_STUB = 0x1000; + + private static final Integer MARK_INVOKE_INVALID = 0x2000; + private static final Integer MARK_INVOKEINTERFACE = 0x2001; + private static final Integer MARK_INVOKESTATIC = 0x2002; + private static final Integer MARK_INVOKESPECIAL = 0x2003; + private static final Integer MARK_INVOKEVIRTUAL = 0x2004; + + private static final Integer MARK_IMPLICIT_NULL = 0x3000; + + private static final Integer MARK_KLASS_PATCHING = 0x4000; + private static final Integer MARK_DUMMY_OOP_RELOCATION = 0x4001; + private static final Integer MARK_ACCESS_FIELD_PATCHING = 0x4002; + // @formatter:on + + private final HotSpotVMConfig config; + private final CiTarget target; + private final RiRegisterConfig registerConfig; + private final Compiler compiler; + + private CiXirAssembler globalAsm; + + public HotSpotXirGenerator(HotSpotVMConfig config, CiTarget target, RiRegisterConfig registerConfig, Compiler compiler) { + this.config = config; + this.target = target; + this.registerConfig = registerConfig; + this.compiler = compiler; + } + + private SimpleTemplates prologueTemplates = new SimpleTemplates(STATIC_METHOD) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(CiKind.Void); + XirOperand framePointer = asm.createRegisterTemp("frame pointer", CiKind.Word, AMD64.rbp); + XirOperand stackPointer = asm.createRegisterTemp("stack pointer", CiKind.Word, AMD64.rsp); + XirLabel unverifiedStub = null; + + asm.mark(MARK_OSR_ENTRY); + asm.mark(MARK_UNVERIFIED_ENTRY); + if (!is(STATIC_METHOD, flags)) { + unverifiedStub = asm.createOutOfLineLabel("unverified"); + + XirOperand temp = asm.createRegisterTemp("temp (r10)", CiKind.Word, AMD64.r10); + XirOperand cache = asm.createRegisterTemp("cache (rax)", CiKind.Word, AMD64.rax); + + CiCallingConvention conventions = registerConfig.getCallingConvention(JavaCallee, new CiKind[] {CiKind.Object}, target); + XirOperand receiver = asm.createRegisterTemp("receiver", CiKind.Word, conventions.locations[0].asRegister()); + + asm.pload(CiKind.Word, temp, receiver, asm.i(config.hubOffset), false); + asm.jneq(unverifiedStub, cache, temp); + } + asm.align(config.codeEntryAlignment); + asm.mark(MARK_VERIFIED_ENTRY); + asm.stackOverflowCheck(); + asm.push(framePointer); + asm.mov(framePointer, stackPointer); + asm.pushFrame(); + + // -- out of line ------------------------------------------------------- + XirOperand thread = asm.createRegisterTemp("thread", CiKind.Word, AMD64.r15); + XirOperand exceptionOop = asm.createTemp("exception oop", CiKind.Object); + XirLabel unwind = asm.createOutOfLineLabel("unwind"); + asm.bindOutOfLine(unwind); + + asm.mark(MARK_UNWIND_ENTRY); + + asm.pload(CiKind.Object, exceptionOop, thread, asm.i(config.threadExceptionOopOffset), false); + asm.pstore(CiKind.Object, thread, asm.i(config.threadExceptionOopOffset), asm.createConstant(CiConstant.NULL_OBJECT), false); + asm.pstore(CiKind.Long, thread, asm.i(config.threadExceptionPcOffset), asm.l(0), false); + + asm.callRuntime(config.unwindExceptionStub, null, exceptionOop); + asm.shouldNotReachHere(); + + asm.mark(MARK_EXCEPTION_HANDLER_ENTRY); + asm.callRuntime(config.handleExceptionStub, null); + asm.shouldNotReachHere(); + + asm.nop(1); + asm.mark(MARK_DEOPT_HANDLER_ENTRY); + asm.callRuntime(config.handleDeoptStub, null); + asm.shouldNotReachHere(); + + if (!is(STATIC_METHOD, flags)) { + asm.bindOutOfLine(unverifiedStub); + asm.jmpRuntime(config.inlineCacheMissStub); + } + + return asm.finishTemplate(is(STATIC_METHOD, flags) ? "static prologue" : "prologue"); + } + }; + + private SimpleTemplates epilogueTemplates = new SimpleTemplates(STATIC_METHOD, SYNCHRONIZED) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(CiKind.Void); + XirOperand framePointer = asm.createRegisterTemp("frame pointer", CiKind.Word, AMD64.rbp); + + asm.popFrame(); + asm.pop(framePointer); + + // TODO safepoint check + + return asm.finishTemplate("epilogue"); + } + }; + + private SimpleTemplates safepointTemplates = new SimpleTemplates() { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(CiKind.Void); + + // XirOperand temp = asm.createRegister("temp", CiKind.Word, AMD64.rax); + // asm.pload(CiKind.Word, temp, asm.w(config.safepointPollingAddress), true); + + return asm.finishTemplate("safepoint"); + } + }; + + private SimpleTemplates exceptionObjectTemplates = new SimpleTemplates() { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + XirOperand result = asm.restart(CiKind.Object); + XirOperand thread = asm.createRegisterTemp("thread", CiKind.Word, AMD64.r15); + + asm.pload(CiKind.Object, result, thread, asm.i(config.threadExceptionOopOffset), false); + asm.pstore(CiKind.Object, thread, asm.i(config.threadExceptionOopOffset), asm.o(null), false); + asm.pstore(CiKind.Long, thread, asm.i(config.threadExceptionPcOffset), asm.l(0), false); + + return asm.finishTemplate("exception object"); + } + }; + + private SimpleTemplates resolveClassTemplates = new SimpleTemplates(UNRESOLVED) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + XirOperand result = asm.restart(CiKind.Word); + if (is(UNRESOLVED, flags)) { + UnresolvedClassPatching patching = new UnresolvedClassPatching(asm, result, config); + patching.emitInline(); + // -- out of line ------------------------------------------------------- + patching.emitOutOfLine(); + } else { + XirOperand type = asm.createConstantInputParameter("type", CiKind.Object); + asm.mov(result, type); + } + return asm.finishTemplate(is(UNRESOLVED, flags) ? "resolve class (unresolved)" : "resolve class"); + } + }; + + private SimpleTemplates invokeInterfaceTemplates = new SimpleTemplates(NULL_CHECK) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(); + XirParameter receiver = asm.createInputParameter("receiver", CiKind.Object); + XirParameter addr = asm.createConstantInputParameter("addr", CiKind.Word); + XirOperand temp = asm.createRegisterTemp("temp", CiKind.Word, AMD64.rax); + + if (is(NULL_CHECK, flags)) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + asm.pload(CiKind.Word, temp, receiver, true); + } + asm.mark(MARK_INVOKEINTERFACE); + asm.mov(temp, asm.createConstant(CiConstant.forObject(HotSpotProxy.DUMMY_CONSTANT_OBJ))); + + return asm.finishTemplate(addr, "invokeinterface"); + } + }; + + private SimpleTemplates invokeVirtualTemplates = new SimpleTemplates(NULL_CHECK) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(); + XirParameter receiver = asm.createInputParameter("receiver", CiKind.Object); + XirParameter addr = asm.createConstantInputParameter("addr", CiKind.Word); + XirOperand temp = asm.createRegisterTemp("temp", CiKind.Word, AMD64.rax); + + if (is(NULL_CHECK, flags)) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + asm.pload(CiKind.Word, temp, receiver, true); + } + asm.mark(MARK_INVOKEVIRTUAL); + asm.mov(temp, asm.createConstant(CiConstant.forObject(HotSpotProxy.DUMMY_CONSTANT_OBJ))); + + return asm.finishTemplate(addr, "invokevirtual"); + } + }; + + private SimpleTemplates invokeSpecialTemplates = new SimpleTemplates(NULL_CHECK) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(); + XirParameter receiver = asm.createInputParameter("receiver", CiKind.Object); + XirParameter addr = asm.createConstantInputParameter("addr", CiKind.Word); + XirOperand temp = asm.createRegisterTemp("temp", CiKind.Word, AMD64.rax); + XirLabel stub = asm.createOutOfLineLabel("call stub"); + + if (is(NULL_CHECK, flags)) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + asm.pload(CiKind.Word, temp, receiver, true); + } + asm.mark(MARK_INVOKESPECIAL); + + // -- out of line ------------------------------------------------------- + asm.bindOutOfLine(stub); + XirOperand method = asm.createRegisterTemp("method", CiKind.Word, AMD64.rbx); + asm.mark(MARK_STATIC_CALL_STUB, XirMark.CALLSITE); + asm.mov(method, asm.w(0L)); + XirLabel dummy = asm.createOutOfLineLabel("dummy"); + asm.jmp(dummy); + asm.bindOutOfLine(dummy); + + return asm.finishTemplate(addr, "invokespecial"); + } + }; + + private SimpleTemplates invokeStaticTemplates = new SimpleTemplates() { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(); + XirParameter addr = asm.createConstantInputParameter("addr", CiKind.Word); + + XirLabel stub = asm.createOutOfLineLabel("call stub"); + asm.mark(MARK_INVOKESTATIC); + + // -- out of line ------------------------------------------------------- + asm.bindOutOfLine(stub); + XirOperand method = asm.createRegisterTemp("method", CiKind.Word, AMD64.rbx); + asm.mark(MARK_STATIC_CALL_STUB, XirMark.CALLSITE); + asm.mov(method, asm.w(0L)); + XirLabel dummy = asm.createOutOfLineLabel("dummy"); + asm.jmp(dummy); + asm.bindOutOfLine(dummy); + + return asm.finishTemplate(addr, "invokestatic"); + } + }; + + private SimpleTemplates monitorEnterTemplates = new SimpleTemplates(NULL_CHECK) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(CiKind.Void); + XirParameter object = asm.createInputParameter("object", CiKind.Object); + XirParameter lock = asm.createInputParameter("lock", CiKind.Word); + + if (is(NULL_CHECK, flags)) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + asm.pload(CiKind.Word, asm.createTemp("temp", CiKind.Word), object, true); + } + + + // (tw) It is important to use for this runtime call the debug info AFTER the monitor enter. Otherwise the monitor object + // is not correctly garbage collected. + final boolean useInfoAfter = true; + + if (config.useFastLocking) { + useRegisters(asm, AMD64.rax, AMD64.rbx); + useRegisters(asm, getGeneralParameterRegister(0)); + useRegisters(asm, getGeneralParameterRegister(1)); + asm.callRuntime(config.fastMonitorEnterStub, null, useInfoAfter, object, lock); + } else { + asm.reserveOutgoingStack(target.wordSize * 2); + asm.pstore(CiKind.Object, asm.createRegister("rsp", CiKind.Word, AMD64.RSP.asRegister()), asm.i(target.wordSize), object, false); + asm.pstore(CiKind.Word, asm.createRegister("rsp", CiKind.Word, AMD64.RSP.asRegister()), asm.i(0), lock, false); + asm.callRuntime(config.monitorEnterStub, null, useInfoAfter); + } + + return asm.finishTemplate("monitorEnter"); + } + }; + + private CiRegister getGeneralParameterRegister(int index) { + return registerConfig.getCallingConventionRegisters(CiCallingConvention.Type.RuntimeCall, RegisterFlag.CPU)[index]; + } + + private SimpleTemplates monitorExitTemplates = new SimpleTemplates(NULL_CHECK) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(CiKind.Void); + XirParameter object = asm.createInputParameter("object", CiKind.Object); + XirParameter lock = asm.createInputParameter("lock", CiKind.Word); + + if (config.useFastLocking) { + useRegisters(asm, AMD64.rax, AMD64.rbx); + useRegisters(asm, getGeneralParameterRegister(0)); + useRegisters(asm, getGeneralParameterRegister(1)); + asm.callRuntime(config.fastMonitorExitStub, null, object, lock); + } else { + asm.reserveOutgoingStack(target.wordSize); + asm.pstore(CiKind.Word, asm.createRegister("rsp", CiKind.Word, AMD64.RSP.asRegister()), asm.i(0), lock, false); + asm.callRuntime(config.monitorExitStub, null); + } + + return asm.finishTemplate("monitorExit"); + } + }; + + private KindTemplates getFieldTemplates = new KindTemplates(NULL_CHECK, UNRESOLVED) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags, CiKind kind) { + XirOperand result = asm.restart(kind); + XirParameter object = asm.createInputParameter("object", CiKind.Object); + + if (is(UNRESOLVED, flags)) { + UnresolvedFieldPatching fieldPatching = new UnresolvedFieldPatching(asm, object, result, false, is(NULL_CHECK, flags), config); + fieldPatching.emitInline(); + // -- out of line ------------------------------------------------------- + fieldPatching.emitOutOfLine(); + return asm.finishTemplate("getfield<" + kind + ">"); + } + XirParameter fieldOffset = asm.createConstantInputParameter("fieldOffset", CiKind.Int); + if (is(NULL_CHECK, flags)) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + } + asm.pload(kind, result, object, fieldOffset, is(NULL_CHECK, flags)); + return asm.finishTemplate("getfield<" + kind + ">"); + } + }; + + private KindTemplates writeBarrierTemplate = new KindTemplates() { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags, CiKind kind) { + asm.restart(CiKind.Void); + XirParameter object = asm.createInputParameter("object", CiKind.Object); + + // Need temp operand, because the write barrier destroys the object pointer. + XirOperand temp = asm.createTemp("temp", CiKind.Object); + asm.mov(temp, object); + + writeBarrier(asm, temp); + return asm.finishTemplate("writeBarrier"); + } + }; + + private KindTemplates putFieldTemplates = new KindTemplates(WRITE_BARRIER, NULL_CHECK, UNRESOLVED) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags, CiKind kind) { + asm.restart(CiKind.Void); + XirParameter object = asm.createInputParameter("object", CiKind.Object); + XirParameter value = asm.createInputParameter("value", kind); + + if (is(UNRESOLVED, flags)) { + UnresolvedFieldPatching fieldPatching = new UnresolvedFieldPatching(asm, object, value, true, is(NULL_CHECK, flags), config); + fieldPatching.emitInline(); + // -- out of line ------------------------------------------------------- + fieldPatching.emitOutOfLine(); + return asm.finishTemplate("putfield<" + kind + ">"); + } + XirParameter fieldOffset = asm.createConstantInputParameter("fieldOffset", CiKind.Int); + if (kind == CiKind.Object) { + verifyPointer(asm, value); + } + if (is(NULL_CHECK, flags)) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + } + asm.pstore(kind, object, fieldOffset, value, is(NULL_CHECK, flags)); + if (is(WRITE_BARRIER, flags)) { + XirOperand temp = asm.createTemp("temp", CiKind.Word); + asm.mov(temp, object); + writeBarrier(asm, temp); + } + return asm.finishTemplate("putfield<" + kind + ">"); + } + }; + + private final IndexTemplates newInstanceTemplates = new IndexTemplates() { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags, int size) { + XirOperand result = asm.restart(CiKind.Word); + XirOperand type = asm.createInputParameter("type", CiKind.Object); + + XirOperand temp1 = asm.createRegisterTemp("temp1", CiKind.Word, AMD64.rcx); + XirOperand temp2 = asm.createRegisterTemp("temp2", CiKind.Word, AMD64.rbx); + XirOperand temp2i = asm.createRegisterTemp("temp2i", CiKind.Int, AMD64.rbx); + useRegisters(asm, AMD64.rsi); + XirLabel tlabFull = asm.createOutOfLineLabel("tlab full"); + XirLabel resume = asm.createInlineLabel("resume"); + + // check if the class is already initialized + asm.pload(CiKind.Int, temp2i, type, asm.i(config.klassStateOffset), false); + asm.jneq(tlabFull, temp2i, asm.i(config.klassStateFullyInitialized)); + + XirOperand thread = asm.createRegisterTemp("thread", CiKind.Word, AMD64.r15); + asm.pload(CiKind.Word, result, thread, asm.i(config.threadTlabTopOffset), false); + asm.add(temp1, result, asm.w(size)); + asm.pload(CiKind.Word, temp2, thread, asm.i(config.threadTlabEndOffset), false); + + asm.jgt(tlabFull, temp1, temp2); + asm.pstore(CiKind.Word, thread, asm.i(config.threadTlabTopOffset), temp1, false); + + asm.bindInline(resume); + + asm.pload(CiKind.Word, temp1, type, asm.i(config.instanceHeaderPrototypeOffset), false); + asm.pstore(CiKind.Word, result, temp1, false); + asm.pstore(CiKind.Object, result, asm.i(config.hubOffset), type, false); + + if (size > 2 * target.wordSize) { + asm.mov(temp1, asm.w(0)); + for (int offset = 2 * target.wordSize; offset < size; offset += target.wordSize) { + asm.pstore(CiKind.Word, result, asm.i(offset), temp1, false); + } + } + + // -- out of line ------------------------------------------------------- + asm.bindOutOfLine(tlabFull); + XirOperand arg = asm.createRegisterTemp("runtime call argument", CiKind.Object, AMD64.rdx); + asm.mov(arg, type); + useRegisters(asm, AMD64.rax); + asm.callRuntime(config.newInstanceStub, result); + asm.jmp(resume); + + return asm.finishTemplate("new instance"); + } + }; + + private SimpleTemplates newInstanceUnresolvedTemplates = new SimpleTemplates() { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + XirOperand result = asm.restart(CiKind.Word); + XirOperand arg = asm.createRegisterTemp("runtime call argument", CiKind.Object, AMD64.rdx); + + UnresolvedClassPatching patching = new UnresolvedClassPatching(asm, arg, config); + + patching.emitInline(); + useRegisters(asm, AMD64.rbx, AMD64.rcx, AMD64.rsi, AMD64.rax); + asm.callRuntime(config.unresolvedNewInstanceStub, result); + + // -- out of line ------------------------------------------------------- + patching.emitOutOfLine(); + + return asm.finishTemplate("new instance"); + } + }; + + private SimpleTemplates newObjectArrayCloneTemplates = new SimpleTemplates() { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + XirOperand result = asm.restart(CiKind.Object); + XirParameter lengthParam = asm.createInputParameter("length", CiKind.Int, true); + XirParameter src = asm.createInputParameter("src", CiKind.Object); + + // Set up length and hub. + XirOperand length = asm.createRegisterTemp("length", CiKind.Int, AMD64.rbx); + XirOperand hub = asm.createRegisterTemp("hub", CiKind.Object, AMD64.rdx); + asm.pload(CiKind.Object, hub, src, asm.i(config.hubOffset), false); + asm.mov(length, lengthParam); + + useRegisters(asm, AMD64.rsi, AMD64.rcx, AMD64.rdi, AMD64.rax); + asm.callRuntime(config.newObjectArrayStub, result); + return asm.finishTemplate("objectArrayClone"); + } + }; + + private SimpleTemplates newObjectArrayTemplates = new SimpleTemplates(UNRESOLVED) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + emitNewTypeArray(asm, flags, CiKind.Object, config.useFastNewObjectArray, config.newObjectArrayStub); + return asm.finishTemplate(is(UNRESOLVED, flags) ? "newObjectArray (unresolved)" : "newObjectArray"); + } + }; + + private void emitNewTypeArray(CiXirAssembler asm, long flags, CiKind kind, boolean useFast, long slowPathStub) { + XirOperand result = asm.restart(CiKind.Word); + + XirParameter lengthParam = asm.createInputParameter("length", CiKind.Int, true); + + XirOperand length = asm.createRegisterTemp("length", CiKind.Int, AMD64.rbx); + XirOperand hub = asm.createRegisterTemp("hub", CiKind.Object, AMD64.rdx); + + // Registers rsi, rcx, rdi, and rax are needed by the runtime call. + // Hub needs to be on rdx, length on rbx. + XirOperand temp1 = asm.createRegisterTemp("temp1", CiKind.Word, AMD64.rcx); + XirOperand temp2 = asm.createRegisterTemp("temp2", CiKind.Word, AMD64.rax); + XirOperand temp3 = asm.createRegisterTemp("temp3", CiKind.Word, AMD64.rdi); + XirOperand size = asm.createRegisterTemp("size", CiKind.Int, AMD64.rsi); + + UnresolvedClassPatching patching = null; + if (is(UNRESOLVED, flags)) { + // insert the patching code for class resolving - the hub will end up in "hub" + patching = new UnresolvedClassPatching(asm, hub, config); + patching.emitInline(); + } else { + asm.mov(hub, asm.createConstantInputParameter("hub", CiKind.Object)); + } + + asm.mov(length, lengthParam); + + if (useFast) { + + XirLabel slowPath = asm.createOutOfLineLabel("slowPath"); + + XirLabel done = asm.createInlineLabel("done"); + + // Check for negative array size. + // TODO: Also check for upper bound + asm.jlt(slowPath, length, asm.i(0)); + + final int aligning = target.wordSize; + final int arrayLengthOffset = target.wordSize * 2; + final int arrayElementOffset = config.getArrayOffset(kind); + + // Calculate aligned size + asm.mov(size, length); + int scale = CiUtil.log2(kind.sizeInBytes(target.wordSize)); + if (scale != 0) { + asm.shl(size, size, asm.i(scale)); + } + asm.add(size, size, asm.i(arrayElementOffset + aligning - 1)); + long mask = 0xFFFFFFFFL; + mask <<= CiUtil.log2(aligning); + asm.and(size, size, asm.i((int) mask)); + + // Try tlab allocation + XirOperand thread = asm.createRegisterTemp("thread", CiKind.Word, AMD64.r15); + asm.pload(CiKind.Word, result, thread, asm.i(config.threadTlabTopOffset), false); + asm.add(temp1, result, size); + asm.pload(CiKind.Word, temp2, thread, asm.i(config.threadTlabEndOffset), false); + asm.jgt(slowPath, temp1, temp2); + asm.pstore(CiKind.Word, thread, asm.i(config.threadTlabTopOffset), temp1, false); + + // Now the new object is in result, store mark word and klass + asm.pload(CiKind.Word, temp1, hub, asm.i(config.instanceHeaderPrototypeOffset), false); + asm.pstore(CiKind.Word, result, temp1, false); + asm.pstore(CiKind.Object, result, asm.i(config.hubOffset), hub, false); + + // Store array length + asm.pstore(CiKind.Int, result, asm.i(arrayLengthOffset), length, false); + + // Initialize with 0 + XirLabel top = asm.createInlineLabel("top"); + asm.sub(size, size, asm.i(arrayElementOffset)); + asm.shr(size, size, asm.i(Scale.Times8.log2)); + asm.jeq(done, size, asm.i(0)); + asm.xor(temp3, temp3, temp3); + asm.bindInline(top); + asm.pstore(CiKind.Word, result, size, temp3, arrayElementOffset - target.wordSize, Scale.Times8, false); + asm.decAndJumpNotZero(top, size); + + asm.bindInline(done); + + // Slow path + asm.bindOutOfLine(slowPath); + asm.callRuntime(slowPathStub, result); + asm.jmp(done); + } else { + asm.callRuntime(slowPathStub, result); + } + + if (patching != null) { + patching.emitOutOfLine(); + } + } + + private KindTemplates newTypeArrayTemplates = new KindTemplates() { + @Override + protected XirTemplate create(CiXirAssembler asm, long flags, CiKind kind) { + emitNewTypeArray(asm, flags, kind, config.useFastNewTypeArray, config.newTypeArrayStub); + return asm.finishTemplate("newTypeArray<" + kind.toString() + ">"); + } + }; + + private final IndexTemplates multiNewArrayTemplate = new IndexTemplates(UNRESOLVED) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags, int dimensions) { + XirOperand result = asm.restart(CiKind.Object); + + XirOperand hub = asm.createRegisterTemp("hub", CiKind.Object, AMD64.rax); + XirOperand rank = asm.createRegisterTemp("rank", CiKind.Int, AMD64.rbx); + XirOperand sizes = asm.createRegisterTemp("sizes", CiKind.Long, AMD64.rcx); + XirOperand thread = asm.createRegisterTemp("thread", CiKind.Long, AMD64.r15); + asm.add(sizes, thread, asm.l(config.threadMultiNewArrayStorage)); + for (int i = 0; i < dimensions; i++) { + XirParameter length = asm.createInputParameter("length" + i, CiKind.Int, true); + asm.pstore(CiKind.Int, sizes, asm.i(i * target.sizeInBytes(CiKind.Int)), length, false); + } + + UnresolvedClassPatching patching = null; + if (is(UNRESOLVED, flags)) { + // insert the patching code for class resolving - the hub will end up in "hub" + patching = new UnresolvedClassPatching(asm, hub, config); + patching.emitInline(); + } else { + asm.mov(hub, asm.createConstantInputParameter("hub", CiKind.Object)); + } + + asm.mov(rank, asm.i(dimensions)); + useRegisters(asm, AMD64.rax); + asm.callRuntime(config.newMultiArrayStub, result); + if (is(UNRESOLVED, flags)) { + patching.emitOutOfLine(); + } + return asm.finishTemplate(is(UNRESOLVED, flags) ? "multiNewArray" + dimensions + " (unresolved)" : "multiNewArray" + dimensions); + } + }; + + private SimpleTemplates checkCastTemplates = new SimpleTemplates(NULL_CHECK, UNRESOLVED) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + asm.restart(); + XirParameter object = asm.createInputParameter("object", CiKind.Object); + final XirOperand hub; + final UnresolvedClassPatching patching; + if (is(UNRESOLVED, flags)) { + hub = asm.createTemp("hub", CiKind.Object); + // insert the patching code for class resolving - the hub will end up in "hub" + patching = new UnresolvedClassPatching(asm, hub, config); + patching.emitInline(); + } else { + hub = asm.createConstantInputParameter("hub", CiKind.Object); + patching = null; + } + + XirOperand objHub = asm.createTemp("objHub", CiKind.Object); + + XirLabel end = asm.createInlineLabel("end"); + XirLabel slowPath = asm.createOutOfLineLabel("slow path"); + + if (is(NULL_CHECK, flags)) { + // null can be cast to anything + asm.jeq(end, object, asm.o(null)); + } + + asm.pload(CiKind.Object, objHub, object, asm.i(config.hubOffset), false); + // if we get an exact match: succeed immediately + asm.jneq(slowPath, objHub, hub); + asm.bindInline(end); + + // -- out of line ------------------------------------------------------- + asm.bindOutOfLine(slowPath); + checkSubtype(asm, objHub, objHub, hub); + asm.jneq(end, objHub, asm.o(null)); + XirOperand scratch = asm.createRegisterTemp("scratch", CiKind.Object, AMD64.r10); + asm.mov(scratch, object); + asm.callRuntime(config.throwClassCastException, null); + asm.shouldNotReachHere(); + + if (is(UNRESOLVED, flags)) { + patching.emitOutOfLine(); + } + + return asm.finishTemplate(object, "instanceof"); + } + }; + + private SimpleTemplates instanceOfTemplates = new SimpleTemplates(NULL_CHECK, UNRESOLVED) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + XirOperand result = asm.restart(CiKind.Boolean); + XirParameter object = asm.createInputParameter("object", CiKind.Object); + final XirOperand hub; + final UnresolvedClassPatching patching; + if (is(UNRESOLVED, flags)) { + hub = asm.createTemp("hub", CiKind.Object); + // insert the patching code for class resolving - the hub will end up in "hub" + patching = new UnresolvedClassPatching(asm, hub, config); + patching.emitInline(); + } else { + hub = asm.createConstantInputParameter("hub", CiKind.Object); + patching = null; + } + + XirOperand objHub = asm.createTemp("objHub", CiKind.Object); + + XirLabel end = asm.createInlineLabel("end"); + XirLabel slowPath = asm.createOutOfLineLabel("slow path"); + + if (is(NULL_CHECK, flags)) { + // null isn't "instanceof" anything + asm.mov(result, asm.b(false)); + asm.jeq(end, object, asm.o(null)); + } + + asm.pload(CiKind.Object, objHub, object, asm.i(config.hubOffset), false); + // if we get an exact match: succeed immediately + asm.mov(result, asm.b(true)); + asm.jneq(slowPath, objHub, hub); + asm.bindInline(end); + + // -- out of line ------------------------------------------------------- + asm.bindOutOfLine(slowPath); + checkSubtype(asm, result, objHub, hub); + asm.jmp(end); + + if (is(UNRESOLVED, flags)) { + patching.emitOutOfLine(); + } + + return asm.finishTemplate("instanceof"); + } + }; + + private XirOperand genArrayLength(CiXirAssembler asm, XirOperand array, boolean implicitNullException) { + XirOperand length = asm.createTemp("length", CiKind.Int); + genArrayLength(asm, length, array, implicitNullException); + return length; + } + + private void genArrayLength(CiXirAssembler asm, XirOperand length, XirOperand array, boolean implicitNullException) { + if (implicitNullException) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + } + asm.pload(CiKind.Int, length, array, asm.i(config.arrayLengthOffset), implicitNullException); + } + + private KindTemplates arrayLoadTemplates = new KindTemplates(NULL_CHECK, READ_BARRIER, BOUNDS_CHECK, GIVEN_LENGTH) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags, CiKind kind) { + XirOperand result = asm.restart(kind); + XirParameter array = asm.createInputParameter("array", CiKind.Object); + XirParameter index = asm.createInputParameter("index", CiKind.Int, true); + XirLabel failBoundsCheck = null; + // if the length is known the array cannot be null + boolean implicitNullException = is(NULL_CHECK, flags); + + if (is(BOUNDS_CHECK, flags)) { + // load the array length and check the index + failBoundsCheck = asm.createOutOfLineLabel("failBoundsCheck"); + XirOperand length; + if (is(GIVEN_LENGTH, flags)) { + length = asm.createInputParameter("length", CiKind.Int, true); + } else { + length = genArrayLength(asm, array, implicitNullException); + } + asm.jugteq(failBoundsCheck, index, length); + implicitNullException = false; + } + int elemSize = target.sizeInBytes(kind); + if (implicitNullException) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + } + asm.pload(kind, result, array, index, config.getArrayOffset(kind), Scale.fromInt(elemSize), implicitNullException); + if (is(BOUNDS_CHECK, flags)) { + asm.bindOutOfLine(failBoundsCheck); + asm.callRuntime(config.throwArrayIndexException, null); + asm.shouldNotReachHere(); + } + return asm.finishTemplate("arrayload<" + kind + ">"); + } + }; + + private SimpleTemplates getClassTemplates = new SimpleTemplates() { + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + XirOperand result = asm.restart(CiKind.Object); + XirOperand object = asm.createInputParameter("object", CiKind.Object); + if (is(NULL_CHECK, flags)) { + asm.nop(1); + } + asm.pload(CiKind.Object, result, object, asm.i(config.hubOffset), is(NULL_CHECK, flags)); + asm.pload(CiKind.Object, result, result, asm.i(config.classMirrorOffset), false); + return asm.finishTemplate("currentThread"); + } + }; + + private SimpleTemplates currentThreadTemplates = new SimpleTemplates() { + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + XirOperand result = asm.restart(CiKind.Object); + XirOperand thread = asm.createRegisterTemp("thread", CiKind.Word, AMD64.r15); + asm.pload(CiKind.Object, result, thread, asm.i(config.threadObjectOffset), false); + return asm.finishTemplate("currentThread"); + } + }; + + @Override + public XirSnippet genCurrentThread(XirSite site) { + return new XirSnippet(currentThreadTemplates.get(site)); + } + + @Override + public XirSnippet genGetClass(XirSite site, XirArgument object) { + return new XirSnippet(getClassTemplates.get(site), object); + } + + private KindTemplates arrayCopyTemplates = new KindTemplates() { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags, CiKind kind) { + asm.restart(CiKind.Void); + XirParameter src = asm.createInputParameter("src", CiKind.Object); + XirParameter srcPos = asm.createInputParameter("srcPos", CiKind.Int, true); + XirParameter dest = asm.createInputParameter("dest", CiKind.Object); + XirParameter destPos = asm.createInputParameter("destPos", CiKind.Int, true); + XirParameter length = asm.createInputParameter("length", CiKind.Int, true); + + XirOperand tempSrc = asm.createTemp("tempSrc", CiKind.Word); + XirOperand tempDest = asm.createTemp("tempDest", CiKind.Word); + XirOperand lengthOperand = asm.createRegisterTemp("lengthOperand", CiKind.Int, AMD64.rax); + + XirOperand compHub = null; + XirOperand valueHub = null; + XirOperand temp = null; + XirLabel store = null; + XirLabel slowStoreCheck = null; + + if (is(STORE_CHECK, flags)) { + valueHub = asm.createRegisterTemp("valueHub", CiKind.Word, AMD64.rdi); + compHub = asm.createRegisterTemp("compHub", CiKind.Word, AMD64.rsi); + temp = asm.createRegisterTemp("temp", CiKind.Word, AMD64.r10); + } + + // Calculate the factor for the repeat move instruction. + int elementSize = kind.sizeInBytes(target.wordSize); + int factor; + boolean wordSize; + if (elementSize >= target.wordSize) { + assert elementSize % target.wordSize == 0; + wordSize = true; + factor = elementSize / target.wordSize; + } else { + factor = elementSize; + wordSize = false; + } + + // Adjust the length if the factor is not 1. + if (factor != 1) { + asm.shl(lengthOperand, length, asm.i(CiUtil.log2(factor))); + } else { + asm.mov(lengthOperand, length); + } + + // Set the start and the end pointer. + asm.lea(tempSrc, src, srcPos, config.getArrayOffset(kind), Scale.fromInt(elementSize)); + asm.lea(tempDest, dest, destPos, config.getArrayOffset(kind), Scale.fromInt(elementSize)); + + XirLabel reverse = null; + XirLabel normal = null; + + if (is(STORE_CHECK, flags)) { + reverse = asm.createInlineLabel("reverse"); + asm.jneq(reverse, src, dest); + } + + if (!is(STORE_CHECK, flags) && !is(INPUTS_DIFFERENT, flags) && !is(INPUTS_SAME, flags)) { + normal = asm.createInlineLabel("normal"); + asm.jneq(normal, src, dest); + } + + if (!is(INPUTS_DIFFERENT, flags)) { + if (reverse == null) { + reverse = asm.createInlineLabel("reverse"); + } + asm.jlt(reverse, srcPos, destPos); + } + + if (!is(STORE_CHECK, flags) && !is(INPUTS_DIFFERENT, flags) && !is(INPUTS_SAME, flags)) { + asm.bindInline(normal); + } + + // Everything set up => repeat mov. + if (wordSize) { + asm.repmov(tempSrc, tempDest, lengthOperand); + } else { + asm.repmovb(tempSrc, tempDest, lengthOperand); + } + + if (!is(INPUTS_DIFFERENT, flags) || is(STORE_CHECK, flags)) { + + XirLabel end = asm.createInlineLabel("end"); + asm.jmp(end); + + // Implement reverse copy, because srcPos < destPos and src == dest. + asm.bindInline(reverse); + + if (is(STORE_CHECK, flags)) { + asm.pload(CiKind.Object, compHub, dest, asm.i(config.hubOffset), false); + asm.pload(CiKind.Object, compHub, compHub, asm.i(config.arrayClassElementOffset), false); + } + + CiKind copyKind = wordSize ? CiKind.Object : CiKind.Byte; + XirOperand tempValue = asm.createTemp("tempValue", copyKind); + XirLabel start = asm.createInlineLabel("start"); + asm.bindInline(start); + asm.sub(lengthOperand, lengthOperand, asm.i(1)); + asm.jlt(end, lengthOperand, asm.i(0)); + + Scale scale = wordSize ? Scale.fromInt(target.wordSize) : Scale.Times1; + asm.pload(copyKind, tempValue, tempSrc, lengthOperand, 0, scale, false); + + if (is(STORE_CHECK, flags)) { + slowStoreCheck = asm.createOutOfLineLabel("slowStoreCheck"); + store = asm.createInlineLabel("store"); + asm.jeq(store, tempValue, asm.o(null)); // first check if value is null + asm.pload(CiKind.Object, valueHub, tempValue, asm.i(config.hubOffset), false); + asm.jneq(slowStoreCheck, compHub, valueHub); // then check component hub matches value hub + asm.bindInline(store); + } + + asm.pstore(copyKind, tempDest, lengthOperand, tempValue, 0, scale, false); + + asm.jmp(start); + asm.bindInline(end); + } + + if (kind == CiKind.Object) { + // Do write barriers + asm.lea(tempDest, dest, destPos, config.getArrayOffset(kind), Scale.fromInt(elementSize)); + asm.shr(tempDest, tempDest, asm.i(config.cardtableShift)); + asm.pstore(CiKind.Boolean, asm.w(config.cardtableStartAddress), tempDest, asm.b(false), false); + + XirOperand tempDestEnd = tempSrc; // Reuse src temp + asm.lea(tempDestEnd, dest, destPos, config.getArrayOffset(kind), Scale.fromInt(elementSize)); + asm.add(tempDestEnd, tempDestEnd, length); + asm.shr(tempDestEnd, tempDestEnd, asm.i(config.cardtableShift)); + + // Jump to out-of-line write barrier loop if the array is big. + XirLabel writeBarrierLoop = asm.createOutOfLineLabel("writeBarrierLoop"); + asm.jneq(writeBarrierLoop, tempDest, tempSrc); + XirLabel back = asm.createInlineLabel("back"); + asm.bindInline(back); + + asm.bindOutOfLine(writeBarrierLoop); + asm.pstore(CiKind.Boolean, asm.w(config.cardtableStartAddress), tempDestEnd, asm.b(false), false); + asm.sub(tempDestEnd, tempDestEnd, asm.i(1)); + asm.jneq(writeBarrierLoop, tempDestEnd, tempDest); + asm.jmp(back); + } + + if (is(STORE_CHECK, flags)) { + assert kind == CiKind.Object; + useRegisters(asm, AMD64.rax); + asm.bindOutOfLine(slowStoreCheck); + checkSubtype(asm, temp, valueHub, compHub); + asm.jneq(store, temp, asm.w(0)); + XirOperand scratch = asm.createRegisterTemp("scratch", CiKind.Object, AMD64.r10); + asm.mov(scratch, valueHub); + asm.callRuntime(config.throwArrayStoreException, null); + asm.jmp(store); + } + + return asm.finishTemplate("arraycopy<" + kind + ">"); + } + }; + + private KindTemplates arrayStoreTemplates = new KindTemplates(NULL_CHECK, WRITE_BARRIER, BOUNDS_CHECK, STORE_CHECK, GIVEN_LENGTH) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags, CiKind kind) { + asm.restart(CiKind.Void); + XirParameter array = asm.createInputParameter("array", CiKind.Object); + XirParameter index = asm.createInputParameter("index", CiKind.Int, true); + XirParameter value = asm.createInputParameter("value", kind, kind != CiKind.Object); + XirOperand temp = asm.createTemp("temp", CiKind.Word); + XirOperand valueHub = null; + XirOperand compHub = null; + XirLabel store = asm.createInlineLabel("store"); + XirLabel failBoundsCheck = null; + XirLabel slowStoreCheck = null; + // if the length is known the array cannot be null + boolean implicitNullException = is(NULL_CHECK, flags); + + if (is(BOUNDS_CHECK, flags)) { + // load the array length and check the index + failBoundsCheck = asm.createOutOfLineLabel("failBoundsCheck"); + XirOperand length; + if (is(GIVEN_LENGTH, flags)) { + length = asm.createInputParameter("length", CiKind.Int); + } else { + length = asm.createTemp("length", CiKind.Int); + if (implicitNullException) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + } + asm.pload(CiKind.Int, length, array, asm.i(config.arrayLengthOffset), implicitNullException); + implicitNullException = false; + } + asm.jugteq(failBoundsCheck, index, length); + + } + if (is(STORE_CHECK, flags) && kind == CiKind.Object) { + slowStoreCheck = asm.createOutOfLineLabel("slowStoreCheck"); + asm.jeq(store, value, asm.o(null)); // first check if value is null + valueHub = asm.createTemp("valueHub", CiKind.Object); + compHub = asm.createTemp("compHub", CiKind.Object); + if (implicitNullException) { + asm.mark(MARK_IMPLICIT_NULL); + } + asm.pload(CiKind.Object, compHub, array, asm.i(config.hubOffset), implicitNullException); + asm.pload(CiKind.Object, compHub, compHub, asm.i(config.arrayClassElementOffset), false); + asm.pload(CiKind.Object, valueHub, value, asm.i(config.hubOffset), false); + asm.jneq(slowStoreCheck, compHub, valueHub); // then check component hub matches value hub + + implicitNullException = false; + } + asm.bindInline(store); + int elemSize = target.sizeInBytes(kind); + + if (implicitNullException) { + asm.mark(MARK_IMPLICIT_NULL); + } + int disp = config.getArrayOffset(kind); + Scale scale = Scale.fromInt(elemSize); + if (kind == CiKind.Object) { + verifyPointer(asm, value); + } + if (is(WRITE_BARRIER, flags)) { + asm.lea(temp, array, index, disp, scale); + asm.pstore(kind, temp, value, implicitNullException); + writeBarrier(asm, temp); + } else { + asm.pstore(kind, array, index, value, disp, scale, implicitNullException); + } + + // -- out of line ------------------------------------------------------- + if (is(BOUNDS_CHECK, flags)) { + asm.bindOutOfLine(failBoundsCheck); + asm.callRuntime(config.throwArrayIndexException, null); + asm.shouldNotReachHere(); + } + if (is(STORE_CHECK, flags) && kind == CiKind.Object) { + useRegisters(asm, AMD64.rax); + asm.bindOutOfLine(slowStoreCheck); + checkSubtype(asm, temp, valueHub, compHub); + asm.jneq(store, temp, asm.w(0)); + XirOperand scratch = asm.createRegisterTemp("scratch", CiKind.Object, AMD64.r10); + asm.mov(scratch, valueHub); + asm.callRuntime(config.throwArrayStoreException, null); + asm.jmp(store); + } + return asm.finishTemplate("arraystore<" + kind + ">"); + } + }; + + private SimpleTemplates arrayLengthTemplates = new SimpleTemplates(NULL_CHECK) { + + @Override + protected XirTemplate create(CiXirAssembler asm, long flags) { + XirOperand result = asm.restart(CiKind.Int); + XirParameter object = asm.createInputParameter("object", CiKind.Object); + if (is(NULL_CHECK, flags)) { + asm.nop(1); + asm.mark(MARK_IMPLICIT_NULL); + } + verifyPointer(asm, object); + asm.pload(CiKind.Int, result, object, asm.i(config.arrayLengthOffset), true); + return asm.finishTemplate("arrayLength"); + } + }; + + @Override + public XirSnippet genPrologue(XirSite site, RiMethod method) { + boolean staticMethod = Modifier.isStatic(method.accessFlags()); + return new XirSnippet(staticMethod ? prologueTemplates.get(site, STATIC_METHOD) : prologueTemplates.get(site)); + } + + @Override + public XirSnippet genEpilogue(XirSite site, RiMethod method) { + return new XirSnippet(epilogueTemplates.get(site)); + } + + @Override + public XirSnippet genSafepoint(XirSite site) { + return new XirSnippet(safepointTemplates.get(site)); + } + + @Override + public XirSnippet genExceptionObject(XirSite site) { + return new XirSnippet(exceptionObjectTemplates.get(site)); + } + + @Override + public XirSnippet genResolveClass(XirSite site, RiType type, Representation rep) { + assert rep == Representation.ObjectHub || rep == Representation.StaticFields || rep == Representation.JavaClass : "unexpected representation: " + rep; + if (type.isResolved()) { + return new XirSnippet(resolveClassTemplates.get(site), XirArgument.forObject(type.getEncoding(rep).asObject())); + } + return new XirSnippet(resolveClassTemplates.get(site, UNRESOLVED)); + } + + @Override + public XirSnippet genIntrinsic(XirSite site, XirArgument[] arguments, RiMethod method) { + return null; + } + + @Override + public XirSnippet genInvokeInterface(XirSite site, XirArgument receiver, RiMethod method) { + return new XirSnippet(invokeInterfaceTemplates.get(site), receiver, XirArgument.forWord(0)); + } + + @Override + public XirSnippet genInvokeVirtual(XirSite site, XirArgument receiver, RiMethod method) { + return new XirSnippet(invokeVirtualTemplates.get(site), receiver, XirArgument.forWord(0)); + } + + @Override + public XirSnippet genInvokeSpecial(XirSite site, XirArgument receiver, RiMethod method) { + return new XirSnippet(invokeSpecialTemplates.get(site), receiver, XirArgument.forWord(0)); + } + + @Override + public XirSnippet genInvokeStatic(XirSite site, RiMethod method) { + return new XirSnippet(invokeStaticTemplates.get(site), XirArgument.forWord(0)); + } + + @Override + public XirSnippet genMonitorEnter(XirSite site, XirArgument receiver, XirArgument lockAddress) { + return new XirSnippet(monitorEnterTemplates.get(site), receiver, lockAddress); + } + + @Override + public XirSnippet genMonitorExit(XirSite site, XirArgument receiver, XirArgument lockAddress) { + return new XirSnippet(monitorExitTemplates.get(site), receiver, lockAddress); + } + + @Override + public XirSnippet genGetField(XirSite site, XirArgument object, RiField field) { + if (field.isResolved()) { + return new XirSnippet(getFieldTemplates.get(site, field.kind()), object, XirArgument.forInt(((HotSpotField) field).offset())); + } + return new XirSnippet(getFieldTemplates.get(site, field.kind(), UNRESOLVED), object); + } + + @Override + public XirSnippet genWriteBarrier(XirArgument object) { + return new XirSnippet(writeBarrierTemplate.get(null, CiKind.Void), object); + } + + @Override + public XirSnippet genPutField(XirSite site, XirArgument object, RiField field, XirArgument value) { + if (field.isResolved()) { + return new XirSnippet(putFieldTemplates.get(site, field.kind()), object, value, XirArgument.forInt(((HotSpotField) field).offset())); + } + return new XirSnippet(putFieldTemplates.get(site, field.kind(), UNRESOLVED), object, value); + } + + @Override + public XirSnippet genGetStatic(XirSite site, XirArgument object, RiField field) { + if (field.isResolved()) { + return new XirSnippet(getFieldTemplates.get(site, field.kind()), object, XirArgument.forInt(((HotSpotField) field).offset())); + } + return new XirSnippet(getFieldTemplates.get(site, field.kind(), UNRESOLVED), object); + } + + @Override + public XirSnippet genPutStatic(XirSite site, XirArgument object, RiField field, XirArgument value) { + if (field.isResolved()) { + return new XirSnippet(putFieldTemplates.get(site, field.kind()), object, value, XirArgument.forInt(((HotSpotField) field).offset())); + } + return new XirSnippet(putFieldTemplates.get(site, field.kind(), UNRESOLVED), object, value); + } + + @Override + public XirSnippet genNewInstance(XirSite site, RiType type) { + if (type.isResolved()) { + int instanceSize = ((HotSpotTypeResolved) type).instanceSize(); + return new XirSnippet(newInstanceTemplates.get(site, instanceSize), XirArgument.forObject(type)); + } + return new XirSnippet(newInstanceUnresolvedTemplates.get(site)); + } + + @Override + public XirSnippet genNewArray(XirSite site, XirArgument length, CiKind elementKind, RiType componentType, RiType arrayType) { + if (elementKind == CiKind.Object) { + if (arrayType.isResolved()) { + return new XirSnippet(newObjectArrayTemplates.get(site), length, XirArgument.forObject(arrayType)); + } + return new XirSnippet(newObjectArrayTemplates.get(site, UNRESOLVED), length); + } + assert arrayType == null; + arrayType = compiler.getVMEntries().getPrimitiveArrayType(elementKind); + return new XirSnippet(newTypeArrayTemplates.get(site, elementKind), length, XirArgument.forObject(arrayType)); + } + + @Override + public XirSnippet genNewObjectArrayClone(XirSite site, XirArgument newLength, XirArgument referenceArray) { + return new XirSnippet(newObjectArrayCloneTemplates.get(site), newLength, referenceArray); + } + + @Override + public XirSnippet genNewMultiArray(XirSite site, XirArgument[] lengths, RiType type) { + if (type.isResolved()) { + XirArgument[] params = Arrays.copyOf(lengths, lengths.length + 1); + params[lengths.length] = XirArgument.forObject(type); + return new XirSnippet(multiNewArrayTemplate.get(site, lengths.length), params); + } + return new XirSnippet(multiNewArrayTemplate.get(site, lengths.length, UNRESOLVED), lengths); + } + + @Override + public XirSnippet genCheckCast(XirSite site, XirArgument receiver, XirArgument hub, RiType type) { + if (type.isResolved()) { + return new XirSnippet(checkCastTemplates.get(site), receiver, hub); + } + return new XirSnippet(checkCastTemplates.get(site, UNRESOLVED), receiver); + } + + @Override + public XirSnippet genInstanceOf(XirSite site, XirArgument object, XirArgument hub, RiType type) { + if (type.isResolved()) { + return new XirSnippet(instanceOfTemplates.get(site), object, hub); + } + return new XirSnippet(instanceOfTemplates.get(site, UNRESOLVED), object); + } + + @Override + public XirSnippet genArrayLoad(XirSite site, XirArgument array, XirArgument index, XirArgument length, CiKind elementKind, RiType elementType) { + if (length == null || !site.requiresBoundsCheck()) { + return new XirSnippet(arrayLoadTemplates.get(site, elementKind), array, index); + } + return new XirSnippet(arrayLoadTemplates.get(site, elementKind, GIVEN_LENGTH), array, index, length); + } + + @Override + public XirSnippet genArrayStore(XirSite site, XirArgument array, XirArgument index, XirArgument length, XirArgument value, CiKind elementKind, RiType elementType) { + if (length == null || !site.requiresBoundsCheck()) { + return new XirSnippet(arrayStoreTemplates.get(site, elementKind), array, index, value); + } + return new XirSnippet(arrayStoreTemplates.get(site, elementKind, GIVEN_LENGTH), array, index, value, length); + } + + @Override + public XirSnippet genArrayCopy(XirSite site, XirArgument src, XirArgument srcPos, XirArgument dest, XirArgument destPos, XirArgument length, RiType elementType, boolean inputsSame, boolean inputsDifferent) { + if (elementType == null) { + return null; + } + assert !inputsDifferent || !inputsSame; + XirTemplate template = null; + if (inputsDifferent) { + template = arrayCopyTemplates.get(site, elementType.kind(), INPUTS_DIFFERENT); + } else if (inputsSame) { + template = arrayCopyTemplates.get(site, elementType.kind(), INPUTS_SAME); + } else { + template = arrayCopyTemplates.get(site, elementType.kind()); + } + return new XirSnippet(template, src, srcPos, dest, destPos, length); + } + + @Override + public XirSnippet genArrayLength(XirSite site, XirArgument array) { + return new XirSnippet(arrayLengthTemplates.get(site), array); + } + + @Override + public List buildTemplates(CiXirAssembler asm) { + this.globalAsm = asm; + List templates = new ArrayList(); + return templates; + } + + private static class UnresolvedClassPatching { + + private final XirLabel patchSite; + private final XirLabel replacement; + private final XirLabel patchStub; + private final CiXirAssembler asm; + private final HotSpotVMConfig config; + private final XirOperand arg; + private State state; + + private enum State { + New, Inline, Finished + } + + public UnresolvedClassPatching(CiXirAssembler asm, XirOperand arg, HotSpotVMConfig config) { + this.asm = asm; + this.arg = arg; + this.config = config; + patchSite = asm.createInlineLabel("patch site"); + replacement = asm.createOutOfLineLabel("replacement"); + patchStub = asm.createOutOfLineLabel("patch stub"); + + state = State.New; + } + + public void emitInline() { + assert state == State.New; + + asm.bindInline(patchSite); + asm.mark(MARK_DUMMY_OOP_RELOCATION); + + asm.jmp(patchStub); + + // TODO: make this more generic & safe - this is needed to create space for patching + asm.nop(5); + + state = State.Inline; + } + + public void emitOutOfLine() { + assert state == State.Inline; + + asm.bindOutOfLine(replacement); + XirMark begin = asm.mark(null); + asm.mov(arg, asm.createConstant(CiConstant.NULL_OBJECT)); + XirMark end = asm.mark(null); + // make this piece of data look like an instruction + asm.rawBytes(new byte[] {(byte) 0xb8, 0, 0, 0x05, 0}); + asm.mark(MARK_KLASS_PATCHING, begin, end); + asm.bindOutOfLine(patchStub); + asm.callRuntime(config.loadKlassStub, null); + asm.jmp(patchSite); + + state = State.Finished; + } + } + + private static class UnresolvedFieldPatching { + + private final XirLabel patchSite; + private final XirLabel replacement; + private final XirLabel patchStub; + private final CiXirAssembler asm; + private final HotSpotVMConfig config; + private State state; + private final XirOperand receiver; + private final XirOperand value; + private final boolean put; + private final boolean nullCheck; + + private enum State { + New, Inline, Finished + } + + public UnresolvedFieldPatching(CiXirAssembler asm, XirOperand receiver, XirOperand value, boolean put, boolean nullCheck, HotSpotVMConfig config) { + this.asm = asm; + this.receiver = receiver; + this.value = value; + this.put = put; + this.nullCheck = nullCheck; + this.config = config; + patchSite = asm.createInlineLabel("patch site"); + replacement = asm.createOutOfLineLabel("replacement"); + patchStub = asm.createOutOfLineLabel("patch stub"); + + state = State.New; + } + + public void emitInline() { + assert state == State.New; + if (nullCheck) { + asm.nop(1); + } + asm.bindInline(patchSite); + asm.mark(MARK_DUMMY_OOP_RELOCATION); + if (nullCheck) { + asm.mark(MARK_IMPLICIT_NULL); + } + asm.safepoint(); + asm.jmp(patchStub); + + // TODO: make this more generic & safe - this is needed to create space for patching + asm.nop(5); + + state = State.Inline; + } + + public void emitOutOfLine() { + assert state == State.Inline; + + asm.bindOutOfLine(replacement); + XirMark begin = asm.mark(null); + if (put) { + asm.pstore(value.kind, receiver, asm.i(Integer.MAX_VALUE), value, false); + } else { + asm.pload(value.kind, value, receiver, asm.i(Integer.MAX_VALUE), false); + } + XirMark end = asm.mark(null); + // make this piece of data look like an instruction + asm.rawBytes(new byte[] {(byte) 0xb8, 0, 0, 0x05, 0}); + asm.mark(MARK_ACCESS_FIELD_PATCHING, begin, end); + asm.bindOutOfLine(patchStub); + asm.callRuntime(config.accessFieldStub, null); + asm.jmp(patchSite); + + // Check if we need NOP instructions like in C1 to "not destroy the world". + + state = State.Finished; + } + } + + private void verifyPointer(CiXirAssembler asm, XirOperand pointer) { + if (config.verifyPointers) { + // The verify pointer stub wants the argument in a fixed register. + XirOperand fixed = asm.createRegisterTemp("fixed", CiKind.Object, AMD64.r13); + asm.push(fixed); + asm.mov(fixed, pointer); + asm.callRuntime(config.verifyPointerStub, null); + asm.pop(fixed); + } + } + + private void checkSubtype(CiXirAssembler asm, XirOperand result, XirOperand objHub, XirOperand hub) { + asm.push(objHub); + asm.push(hub); + asm.callRuntime(config.instanceofStub, null); + asm.pop(result); + asm.pop(result); + } + + private void useRegisters(CiXirAssembler asm, CiRegister... registers) { + if (registers != null) { + for (CiRegister register : registers) { + asm.createRegisterTemp("reg", CiKind.Illegal, register); + } + } + } + + private void writeBarrier(CiXirAssembler asm, XirOperand base) { + asm.shr(base, base, asm.i(config.cardtableShift)); + asm.pstore(CiKind.Boolean, asm.w(config.cardtableStartAddress), base, asm.b(false), false); + } + + public boolean is(TemplateFlag check, long flags) { + return (flags & check.bits()) == check.bits(); + } + + /** + * Base class for all the ondemand template generators. It is not normally subclassed directly, but through one of + * its subclasses (SimpleTemplates, KindTemplates, IndexTemplates). + * + * @author Lukas Stadler + */ + private abstract class Templates { + + private ConcurrentHashMap templates = new ConcurrentHashMap(); + private final long mask; + + /** + * Each flag passed to this method will cause templates with and without it to be generated. + */ + public Templates(TemplateFlag... flags) { + this.mask = getBits((int) INDEX_MASK, null, flags); + } + + protected abstract XirTemplate create(CiXirAssembler asm, long flags); + + protected long getBits(int index, XirSite site, TemplateFlag... flags) { + long bits = index; + if (site != null) { + bits |= site.requiresNullCheck() ? NULL_CHECK.bits() : 0; + bits |= site.requiresReadBarrier() ? READ_BARRIER.bits() : 0; + bits |= site.requiresWriteBarrier() ? WRITE_BARRIER.bits() : 0; + bits |= site.requiresArrayStoreCheck() ? STORE_CHECK.bits() : 0; + bits |= site.requiresBoundsCheck() ? BOUNDS_CHECK.bits() : 0; + } + if (flags != null) { + for (TemplateFlag flag : flags) { + bits |= flag.bits(); + } + } + return bits; + } + + protected XirTemplate getInternal(long flags) { + flags = flags & mask; + XirTemplate template = templates.get(flags); + if (template == null) { + template = create(HotSpotXirGenerator.this.globalAsm.copy(), flags); + templates.put(flags, template); + } + return template; + } + } + + private abstract class SimpleTemplates extends Templates { + + public SimpleTemplates(TemplateFlag... flags) { + super(flags); + } + + public XirTemplate get(XirSite site, TemplateFlag... flags) { + return getInternal(getBits(0, site, flags)); + } + } + + private abstract class IndexTemplates extends Templates { + + public IndexTemplates(TemplateFlag... flags) { + super(flags); + } + + @Override + protected final XirTemplate create(CiXirAssembler asm, long flags) { + return create(asm, flags & FLAGS_MASK, (int) (flags & INDEX_MASK)); + } + + protected abstract XirTemplate create(CiXirAssembler asm, long flags, int index); + + public XirTemplate get(XirSite site, int size, TemplateFlag... flags) { + return getInternal(getBits(size, site, flags)); + } + } + + private abstract class KindTemplates extends Templates { + + public KindTemplates(TemplateFlag... flags) { + super(flags); + } + + @Override + protected final XirTemplate create(CiXirAssembler asm, long flags) { + return create(asm, flags & FLAGS_MASK, CiKind.VALUES[(int) (flags & INDEX_MASK)]); + } + + protected abstract XirTemplate create(CiXirAssembler asm, long flags, CiKind kind); + + public XirTemplate get(XirSite site, CiKind kind, TemplateFlag... flags) { + return getInternal(getBits(kind.ordinal(), site, flags)); + } + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/InvocationSocket.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/InvocationSocket.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,276 @@ +/* + * 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.graal.runtime; + +import java.io.*; +import java.lang.reflect.*; +import java.util.*; + +import com.oracle.graal.runtime.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 cachedMethodNames = new HashSet(); + private static final HashSet 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 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 sorted = new TreeMap(); + for (Map.Entry entry : counts.entrySet()) { + sorted.put(entry.getValue(), entry.getKey()); + } + for (Map.Entry entry : sorted.entrySet()) { + System.out.println(entry.getKey() + ": " + entry.getValue()); + } + } + }); + } + } + + /** + * Represents one invocation of a method that is transferred via the socket connection. + * + * @author Lukas Stadler + */ + private static class Invocation implements Serializable { + + 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. + * + * @author Lukas Stadler + */ + private static class Result implements Serializable { + + public Object result; + + public Result(Object result) { + this.result = result; + } + } + + private void incCount(String name, Object[] args) { + if (COUNT_CALLS) { + name = name + (args == null ? 0 : args.length); + if (counts.get(name) != null) { + counts.put(name, counts.get(name) + 1); + } else { + counts.put(name, 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. + * + * @author Lukas Stadler + */ + public class Handler implements InvocationHandler { + + private final Object receiver; + private final HashMap 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. + */ + 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(); + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/TemplateFlag.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/TemplateFlag.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,36 @@ +/* + * 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.graal.runtime; + +enum TemplateFlag { + NULL_CHECK, UNRESOLVED, READ_BARRIER, WRITE_BARRIER, STORE_CHECK, BOUNDS_CHECK, GIVEN_LENGTH, INPUTS_DIFFERENT, INPUTS_SAME, STATIC_METHOD, SYNCHRONIZED; + + private static final long FIRST_FLAG = 0x0000000100000000L; + public static final long FLAGS_MASK = 0x0000FFFF00000000L; + public static final long INDEX_MASK = 0x00000000FFFFFFFFL; + + public long bits() { + assert ((FIRST_FLAG << ordinal()) & FLAGS_MASK) != 0; + return FIRST_FLAG << ordinal(); + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/VMEntries.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/VMEntries.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,99 @@ +/* + * 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.graal.runtime; + +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; + +/** + * Entries into the HotSpot VM from Java code. + */ +public interface VMEntries { + + // Checkstyle: stop + + byte[] RiMethod_code(long vmId); + + int RiMethod_maxStackSize(long vmId); + + int RiMethod_maxLocals(long vmId); + + RiType RiMethod_holder(long vmId); + + String RiMethod_signature(long vmId); + + int RiMethod_accessFlags(long vmId); + + RiType RiSignature_lookupType(String returnType, HotSpotTypeResolved accessingClass); + + Object RiConstantPool_lookupConstant(long vmId, int cpi); + + RiMethod RiConstantPool_lookupMethod(long vmId, int cpi, byte byteCode); + + RiSignature RiConstantPool_lookupSignature(long vmId, int cpi); + + RiType RiConstantPool_lookupType(long vmId, int cpi); + + RiField RiConstantPool_lookupField(long vmId, int cpi, byte byteCode); + + RiConstantPool RiType_constantPool(HotSpotTypeResolved klass); + + void installMethod(HotSpotTargetMethod targetMethod); + + long installStub(HotSpotTargetMethod targetMethod); + + HotSpotVMConfig getConfiguration(); + + RiExceptionHandler[] RiMethod_exceptionHandlers(long vmId); + + RiMethod RiType_resolveMethodImpl(HotSpotTypeResolved klass, String name, String signature); + + boolean RiType_isSubtypeOf(HotSpotTypeResolved klass, RiType other); + + RiType getPrimitiveArrayType(CiKind kind); + + RiType RiType_arrayOf(HotSpotTypeResolved klass); + + RiType RiType_componentType(HotSpotTypeResolved klass); + + RiType getType(Class javaClass); + + boolean RiMethod_hasBalancedMonitors(long vmId); + + RiMethod RiMethod_uniqueConcreteMethod(long vmId); + + void recordBailout(String reason); + + RiType RiType_uniqueConcreteSubtype(HotSpotTypeResolved hotSpotTypeResolved); + + RiType RiType_superType(HotSpotTypeResolved hotSpotTypeResolved); + + int getArrayLength(CiConstant array); + + boolean compareConstantObjects(CiConstant x, CiConstant y); + + RiType getRiType(CiConstant constant); + + // Checkstyle: resume +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/VMEntriesNative.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/VMEntriesNative.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,142 @@ +/* + * 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.graal.runtime; + +import java.lang.reflect.*; + +import com.oracle.graal.runtime.server.*; +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; + +/** + * Entries into the HotSpot VM from Java code. + */ +public class VMEntriesNative implements VMEntries, Remote { + + // Checkstyle: stop + @Override + public native byte[] RiMethod_code(long vmId); + + @Override + public native int RiMethod_maxStackSize(long vmId); + + @Override + public native int RiMethod_maxLocals(long vmId); + + @Override + public native RiType RiMethod_holder(long vmId); + + @Override + public native String RiMethod_signature(long vmId); + + @Override + public native int RiMethod_accessFlags(long vmId); + + @Override + public native RiType RiSignature_lookupType(String returnType, HotSpotTypeResolved accessingClass); + + @Override + public native Object RiConstantPool_lookupConstant(long vmId, int cpi); + + @Override + public native RiMethod RiConstantPool_lookupMethod(long vmId, int cpi, byte byteCode); + + @Override + public native RiSignature RiConstantPool_lookupSignature(long vmId, int cpi); + + @Override + public native RiType RiConstantPool_lookupType(long vmId, int cpi); + + @Override + public native RiField RiConstantPool_lookupField(long vmId, int cpi, byte byteCode); + + @Override + public native RiConstantPool RiType_constantPool(HotSpotTypeResolved klass); + + @Override + public native void installMethod(HotSpotTargetMethod targetMethod); + + @Override + public native long installStub(HotSpotTargetMethod targetMethod); + + @Override + public native HotSpotVMConfig getConfiguration(); + + @Override + public native RiExceptionHandler[] RiMethod_exceptionHandlers(long vmId); + + @Override + public native RiMethod RiType_resolveMethodImpl(HotSpotTypeResolved klass, String name, String signature); + + @Override + public native boolean RiType_isSubtypeOf(HotSpotTypeResolved klass, RiType other); + + @Override + public native RiType getPrimitiveArrayType(CiKind kind); + + @Override + public native RiType RiType_arrayOf(HotSpotTypeResolved klass); + + @Override + public native RiType RiType_componentType(HotSpotTypeResolved klass); + + @Override + public native RiType RiType_uniqueConcreteSubtype(HotSpotTypeResolved klass); + + @Override + public native RiType RiType_superType(HotSpotTypeResolved klass); + + @Override + public native RiType getType(Class javaClass); + + @Override + public native boolean RiMethod_hasBalancedMonitors(long vmId); + + @Override + public native void recordBailout(String reason); + + @Override + public native RiMethod RiMethod_uniqueConcreteMethod(long vmId); + + @Override + public int getArrayLength(CiConstant array) { + return Array.getLength(array.asObject()); + } + + @Override + public boolean compareConstantObjects(CiConstant x, CiConstant y) { + return x.asObject() == y.asObject(); + } + + @Override + public RiType getRiType(CiConstant constant) { + Object o = constant.asObject(); + if (o == null) { + return null; + } + return getType(o.getClass()); + } + + // Checkstyle: resume +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/VMExits.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/VMExits.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,60 @@ +/* + * 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.graal.runtime; + +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; + +/** + * Exits from the HotSpot VM into Java code. + */ +public interface VMExits { + + void compileMethod(long methodVmId, String name, int entryBCI) throws Throwable; + + RiMethod createRiMethodResolved(long vmId, String name); + + RiMethod createRiMethodUnresolved(String name, String signature, RiType holder); + + RiSignature createRiSignature(String signature); + + RiField createRiField(RiType holder, String name, RiType type, int offset, int flags); + + RiType createRiType(long vmId, String name); + + RiType createRiTypePrimitive(int basicType); + + RiType createRiTypeUnresolved(String name); + + RiConstantPool createRiConstantPool(long vmId); + + CiConstant createCiConstant(CiKind kind, long value); + + CiConstant createCiConstantFloat(float value); + + CiConstant createCiConstantDouble(double value); + + CiConstant createCiConstantObject(Object object); + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/VMExitsNative.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/VMExitsNative.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,215 @@ +/* + * 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.graal.runtime; + +import java.io.*; +import java.util.*; + +import com.oracle.graal.runtime.logging.*; +import com.oracle.graal.runtime.server.*; +import com.sun.c1x.debug.*; +import com.sun.cri.ci.*; +import com.sun.cri.ri.*; + +/** + * Exits from the HotSpot VM into Java code. + */ +public class VMExitsNative implements VMExits, Remote { + + public static final boolean LogCompiledMethods = false; + public static boolean compileMethods = true; + + private final Compiler compiler; + + public final HotSpotTypePrimitive typeBoolean; + public final HotSpotTypePrimitive typeChar; + public final HotSpotTypePrimitive typeFloat; + public final HotSpotTypePrimitive typeDouble; + public final HotSpotTypePrimitive typeByte; + public final HotSpotTypePrimitive typeShort; + public final HotSpotTypePrimitive typeInt; + public final HotSpotTypePrimitive typeLong; + public final HotSpotTypePrimitive typeVoid; + + public VMExitsNative(Compiler compiler) { + this.compiler = compiler; + + typeBoolean = new HotSpotTypePrimitive(compiler, CiKind.Boolean); + typeChar = new HotSpotTypePrimitive(compiler, CiKind.Char); + typeFloat = new HotSpotTypePrimitive(compiler, CiKind.Float); + typeDouble = new HotSpotTypePrimitive(compiler, CiKind.Double); + typeByte = new HotSpotTypePrimitive(compiler, CiKind.Byte); + typeShort = new HotSpotTypePrimitive(compiler, CiKind.Short); + typeInt = new HotSpotTypePrimitive(compiler, CiKind.Int); + typeLong = new HotSpotTypePrimitive(compiler, CiKind.Long); + typeVoid = new HotSpotTypePrimitive(compiler, CiKind.Void); + } + + private static Set compiledMethods = new HashSet(); + + @Override + public void compileMethod(long methodVmId, String name, int entryBCI) throws Throwable { + if (!compileMethods) { + return; + } + + try { + HotSpotMethodResolved riMethod = new HotSpotMethodResolved(compiler, methodVmId, name); + CiResult result = compiler.getCompiler().compileMethod(riMethod, -1, null, null); + if (LogCompiledMethods) { + String qualifiedName = CiUtil.toJavaName(riMethod.holder()) + "::" + riMethod.name(); + compiledMethods.add(qualifiedName); + } + + if (result.bailout() != null) { + StringWriter out = new StringWriter(); + result.bailout().printStackTrace(new PrintWriter(out)); + Throwable cause = result.bailout().getCause(); + TTY.println("Bailout:\n" + out.toString()); + if (cause != null) { + Logger.info("Trace for cause: "); + for (StackTraceElement e : cause.getStackTrace()) { + String current = e.getClassName() + "::" + e.getMethodName(); + String type = ""; + if (compiledMethods.contains(current)) { + type = "compiled"; + } + Logger.info(String.format("%-10s %3d %s", type, e.getLineNumber(), current)); + } + } + String s = result.bailout().getMessage(); + if (cause != null) { + s = cause.getMessage(); + } + compiler.getVMEntries().recordBailout(s); + } else { + HotSpotTargetMethod.installMethod(compiler, riMethod, result.targetMethod()); + } + } catch (Throwable t) { + StringWriter out = new StringWriter(); + t.printStackTrace(new PrintWriter(out)); + TTY.println("Compilation interrupted:\n" + out.toString()); + throw t; + } + } + + @Override + public RiMethod createRiMethodResolved(long vmId, String name) { + return new HotSpotMethodResolved(compiler, vmId, name); + } + + @Override + public RiMethod createRiMethodUnresolved(String name, String signature, RiType holder) { + return new HotSpotMethodUnresolved(compiler, name, signature, holder); + } + + @Override + public RiSignature createRiSignature(String signature) { + return new HotSpotSignature(compiler, signature); + } + + @Override + public RiField createRiField(RiType holder, String name, RiType type, int offset, int flags) { + if (offset != -1) { + HotSpotTypeResolved resolved = (HotSpotTypeResolved) holder; + return resolved.createRiField(name, type, offset, flags); + } + return new HotSpotField(compiler, holder, name, type, offset, flags); + } + + @Override + public RiType createRiType(long vmId, String name) { + throw new RuntimeException("not implemented"); + } + + @Override + public RiType createRiTypePrimitive(int basicType) { + switch (basicType) { + case 4: + return typeBoolean; + case 5: + return typeChar; + case 6: + return typeFloat; + case 7: + return typeDouble; + case 8: + return typeByte; + case 9: + return typeShort; + case 10: + return typeInt; + case 11: + return typeLong; + case 14: + return typeVoid; + default: + throw new IllegalArgumentException("Unknown basic type: " + basicType); + } + } + + @Override + public RiType createRiTypeUnresolved(String name) { + return new HotSpotTypeUnresolved(compiler, name); + } + + @Override + public RiConstantPool createRiConstantPool(long vmId) { + return new HotSpotConstantPool(compiler, vmId); + } + + @Override + public CiConstant createCiConstant(CiKind kind, long value) { + if (kind == CiKind.Long) { + return CiConstant.forLong(value); + } else if (kind == CiKind.Int) { + return CiConstant.forInt((int) value); + } else if (kind == CiKind.Short) { + return CiConstant.forShort((short) value); + } else if (kind == CiKind.Char) { + return CiConstant.forChar((char) value); + } else if (kind == CiKind.Byte) { + return CiConstant.forByte((byte) value); + } else if (kind == CiKind.Boolean) { + return (value == 0) ? CiConstant.FALSE : CiConstant.TRUE; + } else { + throw new IllegalArgumentException(); + } + } + + @Override + public CiConstant createCiConstantFloat(float value) { + return CiConstant.forFloat(value); + } + + @Override + public CiConstant createCiConstantDouble(double value) { + return CiConstant.forDouble(value); + } + + @Override + public CiConstant createCiConstantObject(Object object) { + return CiConstant.forObject(object); + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/logging/CountingProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/logging/CountingProxy.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,102 @@ +/* + * 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.graal.runtime.logging; + +import java.lang.reflect.*; +import java.util.*; + +import com.oracle.graal.runtime.server.*; + +/** + * A java.lang.reflect proxy that hierarchically logs all method invocations along with their parameters and return + * values. + */ +public class CountingProxy implements InvocationHandler { + + public static final boolean ENABLED = Boolean.valueOf(System.getProperty("c1x.countcalls")); + + private T delegate; + + private Map calls = new HashMap(); + + public CountingProxy(T delegate) { + assert ENABLED; + System.out.println("Counting proxy for " + delegate.getClass().getSimpleName() + " created"); + this.delegate = delegate; + proxies.add(this); + } + + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + int argCount = args == null ? 0 : args.length; + if (method.getParameterTypes().length != argCount) { + throw new RuntimeException("wrong parameter count"); + } + final Object result; + long count = calls.containsKey(method) ? calls.get(method) : 0; + calls.put(method, count + 1); + try { + if (args == null) { + result = method.invoke(delegate); + } else { + result = method.invoke(delegate, args); + } + } catch (InvocationTargetException e) { + throw e.getCause(); + } + return result; + } + + public static T getProxy(Class interf, T delegate) { + Class[] interfaces = ReplacingStreams.getAllInterfaces(delegate.getClass()); + Object obj = Proxy.newProxyInstance(interf.getClassLoader(), interfaces, new CountingProxy(delegate)); + return interf.cast(obj); + } + + private static ArrayList proxies = new ArrayList(); + + static { + if (ENABLED) { + Runtime.getRuntime().addShutdownHook(new Thread() { + + @Override + public void run() { + for (CountingProxy proxy : proxies) { + proxy.print(); + } + } + }); + } + } + + protected void print() { + long sum = 0; + for (Map.Entry entry : calls.entrySet()) { + Method method = entry.getKey(); + long count = entry.getValue(); + sum += count; + System.out.println(delegate.getClass().getSimpleName() + "." + method.getName() + ": " + count); + } + System.out.println(delegate.getClass().getSimpleName() + " calls: " + sum); + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/logging/Logger.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/logging/Logger.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,170 @@ +/* + * 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.graal.runtime.logging; + +import java.io.*; +import java.lang.reflect.*; +import java.util.*; + +/** + * Scoped logging class used to display the call hierarchy of VMEntries/VMExits calls. + */ +public class Logger { + + public static final boolean ENABLED = Boolean.valueOf(System.getProperty("c1x.debug")); + private static final int SPACING = 4; + private static Deque openStack = new LinkedList(); + private static boolean open = false; + private static int level = 0; + + private static final PrintStream out; + + static { + PrintStream ps = null; + String filename = System.getProperty("c1x.info_file"); + if (filename != null && !"".equals(filename)) { + try { + ps = new PrintStream(new FileOutputStream(filename)); + } catch (FileNotFoundException e) { + e.printStackTrace(); + ps = null; + } + } + out = ps; + if (out != null) { + out.println("start: " + new Date()); + } + } + + public static void info(String message) { + if (ENABLED) { + log(message); + } else { + System.out.println(message); + } + if (out != null) { + out.println(message); + out.flush(); + } + } + + public static void log(String message) { + if (ENABLED) { + for (String line : message.split("\n")) { + if (open) { + System.out.println("..."); + open = false; + } + System.out.print(space(level)); + System.out.println(line); + } + } + } + + public static void startScope(String message) { + if (ENABLED) { + if (open) { + System.out.println("..."); + open = false; + } + System.out.print(space(level)); + System.out.print(message); + openStack.push(open); + open = true; + level++; + } + } + + public static void endScope(String message) { + if (ENABLED) { + level--; + if (open) { + System.out.println(message); + } else { + System.out.println(space(level) + "..." + message); + } + open = openStack.pop(); + } + } + + private static String[] spaces = new String[50]; + + private static String space(int count) { + assert count >= 0; + String result; + if (count >= spaces.length || spaces[count] == null) { + StringBuilder str = new StringBuilder(); + for (int i = 0; i < count * SPACING; i++) { + str.append(' '); + } + result = str.toString(); + if (count < spaces.length) { + spaces[count] = result; + } + } else { + result = spaces[count]; + } + return result; + } + + public static String pretty(Object value) { + if (value == null) { + return "null"; + } + + Class klass = value.getClass(); + if (value instanceof Void) { + return "void"; + } else if (value instanceof String) { + return "\"" + value + "\""; + } else if (value instanceof Method) { + return "method \"" + ((Method) value).getName() + "\""; + } else if (value instanceof Class) { + return "class \"" + ((Class) value).getSimpleName() + "\""; + } else if (value instanceof Integer) { + if ((Integer) value < 10) { + return value.toString(); + } + return value + " (0x" + Integer.toHexString((Integer) value) + ")"; + } else if (value instanceof Long) { + if ((Long) value < 10) { + return value + "l"; + } + return value + "l (0x" + Long.toHexString((Long) value) + "l)"; + } else if (klass.isArray()) { + StringBuilder str = new StringBuilder(); + int dimensions = 0; + while (klass.isArray()) { + dimensions++; + klass = klass.getComponentType(); + } + str.append(klass.getSimpleName()).append('[').append(Array.getLength(value)).append(']'); + for (int i = 1; i < dimensions; i++) { + str.append("[]"); + } + return str.toString(); + } + + return value.toString(); + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/logging/LoggingProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/logging/LoggingProxy.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,77 @@ +/* + * 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.graal.runtime.logging; + +import java.lang.reflect.*; + +import com.oracle.graal.runtime.server.*; + +/** + * A java.lang.reflect proxy that hierarchically logs all method invocations along with their parameters and return values. + */ +public class LoggingProxy implements InvocationHandler { + + private T delegate; + + public LoggingProxy(T delegate) { + this.delegate = delegate; + } + + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + int argCount = args == null ? 0 : args.length; + if (method.getParameterTypes().length != argCount) { + throw new RuntimeException("wrong parameter count"); + } + StringBuilder str = new StringBuilder(); + str.append(method.getReturnType().getSimpleName() + " " + method.getDeclaringClass().getSimpleName() + "." + method.getName() + "("); + for (int i = 0; i < argCount; i++) { + str.append(i == 0 ? "" : ", "); + str.append(Logger.pretty(args[i])); + } + str.append(")"); + Logger.startScope(str.toString()); + final Object result; + try { + if (args == null) { + result = method.invoke(delegate); + } else { + result = method.invoke(delegate, args); + } + } catch (InvocationTargetException e) { + Logger.endScope(" = Exception " + e.getMessage()); + throw e.getCause(); + } + Logger.endScope(" = " + Logger.pretty(result)); + return result; + } + + /** + * The object returned by this method will implement all interfaces that are implemented by delegate. + */ + public static T getProxy(Class interf, T delegate) { + Class[] interfaces = ReplacingStreams.getAllInterfaces(delegate.getClass()); + Object obj = Proxy.newProxyInstance(interf.getClassLoader(), interfaces, new LoggingProxy(delegate)); + return interf.cast(obj); + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/logging/package-info.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/logging/package-info.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,29 @@ +/* + * 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. + */ +/** + * Logging framework for the HotSpot CRI implementation. + * + * @author Lukas Stadler + * @author Thomas Wuerthinger + */ +package com.oracle.graal.runtime.logging; diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/package-info.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/package-info.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,31 @@ +/* + * 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 containing the runtime interface (defined in the CRI project) implementation for HotSpot. + * There is a class that bridges from the C++ to the Java side (VMExitsNative.java) and one that bridges + * from the Java to the C++ side (VMEntriesNative.java). + * + * @author Lukas Stadler + * @author Thomas Wuerthinger + */ +package com.oracle.graal.runtime; diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/server/CompilationServer.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/server/CompilationServer.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,123 @@ +/* + * 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.graal.runtime.server; + +import java.io.*; +import java.net.*; +import java.util.*; + +import javax.net.*; + +import com.oracle.graal.runtime.*; +import com.oracle.graal.runtime.Compiler; +import com.oracle.graal.runtime.logging.*; + +/** + * Server side of the client/server compilation model. The server listens for connections on the hardcoded port 1199. + * + * @author Lukas Stadler + */ +public class CompilationServer implements Runnable { + + public static void main(String[] args) throws Exception { + new CompilationServer(false).run(); + } + + public static interface ConnectionObserver { + + void connectionStarted(Compiler compiler); + + void connectionFinished(Compiler compiler); + } + + private final boolean multiple; + private final ArrayList observers = new ArrayList(); + + /** + * Creates a new Compilation server. The server is activated by calling {@link #run()} directly or via a new + * {@link Thread}. + * + * @param multiple true if the server should server should serve an infinite amount of consecutive connections, + * false if it should terminate after the first connection ends. + */ + public CompilationServer(boolean multiple) { + this.multiple = multiple; + HotSpotOptions.setDefaultOptions(); + } + + public void addConnectionObserver(ConnectionObserver observer) { + observers.add(observer); + } + + public void removeConnectionObserver(ConnectionObserver observer) { + observers.remove(observer); + } + + public void run() { + final ServerSocket serverSocket; + try { + serverSocket = ServerSocketFactory.getDefault().createServerSocket(1199); + } catch (IOException e) { + throw new RuntimeException("Couldn't create compilation server", e); + } + do { + Socket socket = null; + try { + Logger.log("Compilation server ready, waiting for client to connect..."); + socket = serverSocket.accept(); + Logger.log("Connected to " + socket.getRemoteSocketAddress()); + + ReplacingStreams streams = new ReplacingStreams(socket.getOutputStream(), socket.getInputStream()); + + // get the VMEntries proxy from the client + VMEntries entries = (VMEntries) streams.getInvocation().waitForResult(false); + + // return the initialized compiler to the client + Compiler compiler = CompilerImpl.initializeServer(entries); + compiler.getCompiler(); + streams.getInvocation().sendResult(compiler); + + for (ConnectionObserver observer : observers) { + observer.connectionStarted(compiler); + } + + streams.getInvocation().waitForResult(true); + + for (ConnectionObserver observer : observers) { + observer.connectionFinished(compiler); + } + } catch (IOException e) { + e.printStackTrace(); + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } finally { + if (socket != null) { + try { + socket.close(); + } catch (IOException e) { + } + } + } + } while (multiple); + } +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/server/Remote.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/server/Remote.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,28 @@ +/* + * 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.graal.runtime.server; + + +public interface Remote { + +} diff -r 72d9b2cd27d6 -r c89dcda5d109 graal/Runtime/src/com/oracle/graal/runtime/server/ReplacingStreams.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/Runtime/src/com/oracle/graal/runtime/server/ReplacingStreams.java Tue Apr 26 22:01:41 2011 +0200 @@ -0,0 +1,228 @@ +/* + * 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.graal.runtime.server; + +import java.io.*; +import java.lang.reflect.*; +import java.util.*; + +import com.oracle.graal.runtime.*; +import com.oracle.graal.runtime.Compiler; +import com.sun.cri.ci.*; + +public class ReplacingStreams { + + private IdentityHashMap objectMap = new IdentityHashMap(); + private ArrayList