Mercurial > hg > truffle
changeset 9599:ffbb0a365039
Merge.
| author | Doug Simon <doug.simon@oracle.com> |
|---|---|
| date | Tue, 07 May 2013 11:37:23 +0200 |
| parents | 0fc67e300471 (diff) 08af000f4b69 (current diff) |
| children | 20c09d314168 |
| files | graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotVMConfig.java src/share/vm/graal/graalCompilerToVM.cpp |
| diffstat | 22 files changed, 769 insertions(+), 1168 deletions(-) [+] |
line wrap: on
line diff
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotRuntime.java Tue May 07 10:39:54 2013 +0200 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotRuntime.java Tue May 07 11:37:23 2013 +0200 @@ -24,11 +24,6 @@ import static com.oracle.graal.amd64.AMD64.*; import static com.oracle.graal.hotspot.HotSpotBackend.*; -import static com.oracle.graal.hotspot.nodes.MonitorEnterStubCall.*; -import static com.oracle.graal.hotspot.nodes.MonitorExitStubCall.*; -import static com.oracle.graal.hotspot.nodes.VMErrorNode.*; -import static com.oracle.graal.hotspot.nodes.WriteBarrierPostStubCall.*; -import static com.oracle.graal.hotspot.nodes.WriteBarrierPreStubCall.*; import static com.oracle.graal.hotspot.replacements.AESCryptSubstitutions.DecryptBlockStubCall.*; import static com.oracle.graal.hotspot.replacements.AESCryptSubstitutions.EncryptBlockStubCall.*; import static com.oracle.graal.hotspot.replacements.CipherBlockChainingSubstitutions.DecryptAESCryptStubCall.*; @@ -64,35 +59,6 @@ /* arg0: exception */ rax.asValue(Kind.Object), /* arg1: exceptionPc */ rdx.asValue(word)); - addRuntimeCall(MONITORENTER, config.monitorEnterStub, - /* temps */ null, - /* ret */ ret(Kind.Void), - /* arg0: object */ javaCallingConvention(Kind.Object, - /* arg1: lock */ word)); - - addRuntimeCall(WBPRECALL, config.wbPreCallStub, - /* temps */ null, - /* ret */ ret(Kind.Void), - /* arg0: object */ javaCallingConvention(Kind.Object)); - - addRuntimeCall(WBPOSTCALL, config.wbPostCallStub, - /* temps */ null, - /* ret */ ret(Kind.Void), - /* arg0: object */ javaCallingConvention(Kind.Object, word)); - - addRuntimeCall(MONITOREXIT, config.monitorExitStub, - /* temps */ null, - /* ret */ ret(Kind.Void), - /* arg0: object */ javaCallingConvention(Kind.Object, - /* arg1: lock */ word)); - - addRuntimeCall(VM_ERROR, config.vmErrorStub, - /* temps */ null, - /* ret */ ret(Kind.Void), - /* arg0: where */ javaCallingConvention(Kind.Object, - /* arg1: format */ Kind.Object, - /* arg2: value */ Kind.Long)); - addRuntimeCall(ENCRYPT_BLOCK, config.aescryptEncryptBlockStub, /* temps */ null, /* ret */ ret(Kind.Void),
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotVMConfig.java Tue May 07 10:39:54 2013 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotVMConfig.java Tue May 07 11:37:23 2013 +0200 @@ -369,24 +369,14 @@ // runtime stubs public long inlineCacheMissStub; public long handleDeoptStub; - public long monitorEnterStub; - public long monitorExitStub; - public long wbPreCallStub; - public long wbPostCallStub; - public long vmErrorStub; public long uncommonTrapStub; public long unwindExceptionStub; - public long createNullPointerExceptionStub; - public long createOutOfBoundsExceptionStub; public long javaTimeMillisStub; public long javaTimeNanosStub; public long arithmeticSinStub; public long arithmeticCosStub; public long arithmeticTanStub; - public long logPrimitiveStub; - public long logObjectStub; - public long logPrintfStub; public int deoptReasonNone; public long aescryptEncryptBlockStub; public long aescryptDecryptBlockStub; @@ -403,6 +393,16 @@ public long exceptionHandlerForPcAddress; public long exceptionHandlerForReturnAddressAddress; public long osrMigrationEndAddress; + public long monitorenterAddress; + public long monitorexitAddress; + public long createNullPointerExceptionAddress; + public long createOutOfBoundsExceptionAddress; + public long logPrimitiveAddress; + public long logObjectAddress; + public long logPrintfAddress; + public long vmErrorAddress; + public long writeBarrierPreAddress; + public long writeBarrierPostAddress; public int deoptReasonNullCheck; public int deoptReasonRangeCheck;
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotRuntime.java Tue May 07 10:39:54 2013 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotRuntime.java Tue May 07 11:37:23 2013 +0200 @@ -31,20 +31,36 @@ import static com.oracle.graal.hotspot.HotSpotBackend.*; import static com.oracle.graal.hotspot.HotSpotGraalRuntime.*; import static com.oracle.graal.hotspot.nodes.IdentityHashCodeStubCall.*; +import static com.oracle.graal.hotspot.nodes.MonitorEnterStubCall.*; +import static com.oracle.graal.hotspot.nodes.MonitorExitStubCall.*; import static com.oracle.graal.hotspot.nodes.NewArrayStubCall.*; import static com.oracle.graal.hotspot.nodes.NewInstanceStubCall.*; import static com.oracle.graal.hotspot.nodes.NewMultiArrayStubCall.*; import static com.oracle.graal.hotspot.nodes.ThreadIsInterruptedStubCall.*; +import static com.oracle.graal.hotspot.nodes.VMErrorNode.*; import static com.oracle.graal.hotspot.nodes.VerifyOopStubCall.*; +import static com.oracle.graal.hotspot.nodes.WriteBarrierPostStubCall.*; +import static com.oracle.graal.hotspot.nodes.WriteBarrierPreStubCall.*; import static com.oracle.graal.hotspot.replacements.SystemSubstitutions.*; +import static com.oracle.graal.hotspot.stubs.CreateNullPointerExceptionStub.*; +import static com.oracle.graal.hotspot.stubs.CreateOutOfBoundsExceptionStub.*; import static com.oracle.graal.hotspot.stubs.ExceptionHandlerStub.*; import static com.oracle.graal.hotspot.stubs.IdentityHashCodeStub.*; +import static com.oracle.graal.hotspot.stubs.LogObjectStub.*; +import static com.oracle.graal.hotspot.stubs.LogPrimitiveStub.*; +import static com.oracle.graal.hotspot.stubs.LogPrintfStub.*; +import static com.oracle.graal.hotspot.stubs.MonitorEnterStub.*; +import static com.oracle.graal.hotspot.stubs.MonitorExitStub.*; import static com.oracle.graal.hotspot.stubs.NewArrayStub.*; import static com.oracle.graal.hotspot.stubs.NewInstanceStub.*; import static com.oracle.graal.hotspot.stubs.NewMultiArrayStub.*; +import static com.oracle.graal.hotspot.stubs.OSRMigrationEndStub.*; import static com.oracle.graal.hotspot.stubs.RegisterFinalizerStub.*; import static com.oracle.graal.hotspot.stubs.ThreadIsInterruptedStub.*; import static com.oracle.graal.hotspot.stubs.UnwindExceptionToCallerStub.*; +import static com.oracle.graal.hotspot.stubs.VMErrorStub.*; +import static com.oracle.graal.hotspot.stubs.WriteBarrierPostStub.*; +import static com.oracle.graal.hotspot.stubs.WriteBarrierPreStub.*; import static com.oracle.graal.java.GraphBuilderPhase.RuntimeCalls.*; import static com.oracle.graal.nodes.java.RegisterFinalizerNode.*; import static com.oracle.graal.replacements.Log.*; @@ -226,7 +242,7 @@ /* ret */ ret(Kind.Void), /* arg0: buffer */ javaCallingConvention(word)); - addCRuntimeCall(OSRMigrationEndStub.OSR_MIGRATION_END_C, config.osrMigrationEndAddress, + addCRuntimeCall(OSR_MIGRATION_END_C, config.osrMigrationEndAddress, /* ret */ ret(Kind.Void), /* arg0: buffer */ nativeCallingConvention(word)); @@ -289,15 +305,6 @@ /* arg2: rank */ Kind.Int, /* arg3: dims */ word)); - addRuntimeCall(CREATE_NULL_POINTER_EXCEPTION, config.createNullPointerExceptionStub, - /* temps */ null, - /* ret */ ret(Kind.Object)); - - addRuntimeCall(CREATE_OUT_OF_BOUNDS_EXCEPTION, config.createOutOfBoundsExceptionStub, - /* temps */ null, - /* ret */ ret(Kind.Object), - /* arg0: index */ javaCallingConvention(Kind.Int)); - addRuntimeCall(JAVA_TIME_MILLIS, config.javaTimeMillisStub, /* temps */ this.regConfig.getCallerSaveRegisters(), /* ret */ ret(Kind.Long)); @@ -321,21 +328,34 @@ /* ret */ ret(Kind.Double), /* arg0: index */ javaCallingConvention(Kind.Double)); - addRuntimeCall(LOG_PRIMITIVE, config.logPrimitiveStub, - /* temps */ null, + addStubCall(LOG_PRIMITIVE, /* ret */ ret(Kind.Void), /* arg0: typeChar */ javaCallingConvention(Kind.Int, /* arg1: value */ Kind.Long, /* arg2: newline */ Kind.Boolean)); - addRuntimeCall(LOG_PRINTF, config.logPrintfStub, - /* temps */ null, + addCRuntimeCall(LOG_PRIMITIVE_C, config.logPrimitiveAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word, + /* arg1: typeChar */ Kind.Char, + /* arg2: value */ Kind.Long, + /* arg3: newline */ Kind.Boolean)); + + addStubCall(LOG_PRINTF, /* ret */ ret(Kind.Void), /* arg0: format */ javaCallingConvention(Kind.Object, /* arg1: value */ Kind.Long, /* arg2: value */ Kind.Long, /* arg3: value */ Kind.Long)); + addCRuntimeCall(LOG_PRINTF_C, config.logObjectAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word, + /* arg1: format */ Kind.Object, + /* arg2: v1 */ Kind.Long, + /* arg3: v2 */ Kind.Long, + /* arg4: v3 */ Kind.Long)); + addCRuntimeCall(VM_MESSAGE_C, config.vmMessageAddress, /* ret */ ret(Kind.Void), /* arg0: vmError */ nativeCallingConvention(Kind.Boolean, @@ -344,12 +364,17 @@ /* arg3: value */ Kind.Long, /* arg4: value */ Kind.Long)); - addRuntimeCall(LOG_OBJECT, config.logObjectStub, - /* temps */ null, + addStubCall(LOG_OBJECT, /* ret */ ret(Kind.Void), /* arg0: object */ javaCallingConvention(Kind.Object, /* arg1: flags */ Kind.Int)); + addCRuntimeCall(LOG_OBJECT_C, config.logObjectAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word, + /* arg1: object */ Kind.Object, + /* arg2: flags */ Kind.Int)); + addStubCall(THREAD_IS_INTERRUPTED, /* ret */ ret(Kind.Boolean), /* arg0: thread */ javaCallingConvention(Kind.Object, @@ -378,6 +403,76 @@ /* arg0: thread */ nativeCallingConvention(word, /* arg1: object */ Kind.Object)); + addStubCall(MONITORENTER, + /* ret */ ret(Kind.Void), + /* arg0: object */ javaCallingConvention(Kind.Object, + /* arg1: lock */ word)); + + addCRuntimeCall(MONITORENTER_C, config.monitorenterAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word, + /* arg1: object */ Kind.Object, + /* arg1: lock */ word)); + + addStubCall(MONITOREXIT, + /* ret */ ret(Kind.Void), + /* arg0: object */ javaCallingConvention(Kind.Object, + /* arg1: lock */ word)); + + addCRuntimeCall(MONITOREXIT_C, config.monitorexitAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word, + /* arg1: object */ Kind.Object, + /* arg1: lock */ word)); + + addStubCall(CREATE_NULL_POINTER_EXCEPTION, + /* ret */ ret(Kind.Object)); + + addCRuntimeCall(CREATE_NULL_POINTER_EXCEPTION_C, config.createNullPointerExceptionAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word)); + + addStubCall(CREATE_OUT_OF_BOUNDS_EXCEPTION, + /* ret */ ret(Kind.Object), + /* arg0: index */ javaCallingConvention(Kind.Int)); + + addCRuntimeCall(CREATE_OUT_OF_BOUNDS_C, config.createOutOfBoundsExceptionAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word, + /* arg1: index */ Kind.Int)); + + addStubCall(VM_ERROR, + /* ret */ ret(Kind.Void), + /* arg0: where */ javaCallingConvention(Kind.Object, + /* arg1: format */ Kind.Object, + /* arg2: value */ Kind.Long)); + + addCRuntimeCall(VM_ERROR_C, config.vmErrorAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word, + /* arg0: where */ Kind.Object, + /* arg1: format */ Kind.Object, + /* arg2: value */ Kind.Long)); + + addStubCall(WRITE_BARRIER_PRE, + /* ret */ ret(Kind.Void), + /* arg0: object */ javaCallingConvention(Kind.Object)); + + addCRuntimeCall(WRITE_BARRIER_PRE_C, config.writeBarrierPreAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word, + /* arg1: object */ Kind.Object)); + + addStubCall(WRITE_BARRIER_POST, + /* ret */ ret(Kind.Void), + /* arg0: object */ javaCallingConvention(Kind.Object, + /* arg1: card */ word)); + + addCRuntimeCall(WRITE_BARRIER_POST_C, config.writeBarrierPostAddress, + /* ret */ ret(Kind.Void), + /* arg0: thread */ nativeCallingConvention(word, + /* arg1: object */ Kind.Object, + /* arg2: card */ word)); // @formatter:on } @@ -410,6 +505,8 @@ * @param args where arguments are passed to the call */ protected RuntimeCallTarget addCRuntimeCall(Descriptor descriptor, long address, AllocatableValue ret, AllocatableValue... args) { + assert descriptor.getResultType().isPrimitive() || Word.class.isAssignableFrom(descriptor.getResultType()) : "C runtime call cannot have Object return type - objects must be returned via thread local storage: " + + descriptor; return addRuntimeCall(descriptor, address, true, null, ret, args); } @@ -497,6 +594,16 @@ registerStub(new UnwindExceptionToCallerStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(UNWIND_EXCEPTION_TO_CALLER))); registerStub(new VerifyOopStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(VERIFY_OOP))); registerStub(new OSRMigrationEndStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(OSR_MIGRATION_END))); + registerStub(new MonitorEnterStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(MONITORENTER))); + registerStub(new MonitorExitStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(MONITOREXIT))); + registerStub(new CreateNullPointerExceptionStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(CREATE_NULL_POINTER_EXCEPTION))); + registerStub(new CreateOutOfBoundsExceptionStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(CREATE_OUT_OF_BOUNDS_EXCEPTION))); + registerStub(new LogPrimitiveStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(LOG_PRIMITIVE))); + registerStub(new LogObjectStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(LOG_OBJECT))); + registerStub(new LogPrintfStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(LOG_PRINTF))); + registerStub(new VMErrorStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(VM_ERROR))); + registerStub(new WriteBarrierPreStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(WRITE_BARRIER_PRE))); + registerStub(new WriteBarrierPostStub(this, replacements, graalRuntime.getTarget(), runtimeCalls.get(WRITE_BARRIER_POST))); } private void registerStub(Stub stub) {
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/WriteBarrierPostStubCall.java Tue May 07 10:39:54 2013 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/WriteBarrierPostStubCall.java Tue May 07 11:37:23 2013 +0200 @@ -26,18 +26,19 @@ import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; import com.oracle.graal.compiler.gen.*; import com.oracle.graal.compiler.target.*; +import com.oracle.graal.hotspot.stubs.*; import com.oracle.graal.nodes.*; import com.oracle.graal.nodes.type.*; import com.oracle.graal.word.*; /** - * Node implementing a call to HotSpot's {@code graal_monitorenter} stub. + * Node implementing a call to {@link WriteBarrierPostStub}. */ public class WriteBarrierPostStubCall extends FixedWithNextNode implements LIRGenLowerable { @Input private ValueNode object; @Input private ValueNode card; - public static final Descriptor WBPOSTCALL = new Descriptor("wbpostcall", true, void.class, Object.class, Word.class); + public static final Descriptor WRITE_BARRIER_POST = new Descriptor("writeBarrierPost", true, void.class, Object.class, Word.class); public WriteBarrierPostStubCall(ValueNode object, ValueNode card) { super(StampFactory.forVoid()); @@ -47,7 +48,7 @@ @Override public void generate(LIRGenerator gen) { - RuntimeCallTarget stub = gen.getRuntime().lookupRuntimeCall(WriteBarrierPostStubCall.WBPOSTCALL); + RuntimeCallTarget stub = gen.getRuntime().lookupRuntimeCall(WriteBarrierPostStubCall.WRITE_BARRIER_POST); gen.emitCall(stub, stub.getCallingConvention(), null, gen.operand(object), gen.operand(card)); }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/WriteBarrierPreStubCall.java Tue May 07 10:39:54 2013 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/WriteBarrierPreStubCall.java Tue May 07 11:37:23 2013 +0200 @@ -26,16 +26,17 @@ import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; import com.oracle.graal.compiler.gen.*; import com.oracle.graal.compiler.target.*; +import com.oracle.graal.hotspot.stubs.*; import com.oracle.graal.nodes.*; import com.oracle.graal.nodes.type.*; /** - * Node implementing a call to HotSpot's {@code graal_monitorenter} stub. + * Node implementing a call to {@link WriteBarrierPreStub}. */ public class WriteBarrierPreStubCall extends FixedWithNextNode implements LIRGenLowerable { @Input private ValueNode object; - public static final Descriptor WBPRECALL = new Descriptor("wbprecall", true, void.class, Object.class); + public static final Descriptor WRITE_BARRIER_PRE = new Descriptor("writeBarrierPre", true, void.class, Object.class); public WriteBarrierPreStubCall(ValueNode object) { super(StampFactory.forVoid()); @@ -44,7 +45,7 @@ @Override public void generate(LIRGenerator gen) { - RuntimeCallTarget stub = gen.getRuntime().lookupRuntimeCall(WriteBarrierPreStubCall.WBPRECALL); + RuntimeCallTarget stub = gen.getRuntime().lookupRuntimeCall(WriteBarrierPreStubCall.WRITE_BARRIER_PRE); gen.emitCall(stub, stub.getCallingConvention(), null, gen.operand(object)); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/CreateNullPointerExceptionStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.code.RuntimeCallTarget.*; +import com.oracle.graal.graph.Node.*; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called to create a {@link NullPointerException}. + */ +public class CreateNullPointerExceptionStub extends CRuntimeStub { + + public CreateNullPointerExceptionStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static Object createNullPointerException() { + createNullPointerExceptionC(CREATE_NULL_POINTER_EXCEPTION_C, thread()); + handlePendingException(true); + return verifyObject(getAndClearObjectResult(thread())); + } + + public static final Descriptor CREATE_NULL_POINTER_EXCEPTION_C = descriptorFor(CreateNullPointerExceptionStub.class, "createNullPointerExceptionC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void createNullPointerExceptionC(@ConstantNodeParameter Descriptor createNullPointerExceptionC, Word thread); + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/CreateOutOfBoundsExceptionStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.code.RuntimeCallTarget.*; +import com.oracle.graal.graph.Node.*; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called to create a {@link ArrayIndexOutOfBoundsException}. + */ +public class CreateOutOfBoundsExceptionStub extends CRuntimeStub { + + public CreateOutOfBoundsExceptionStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static Object createOutOfBoundsException(int index) { + createOutOfBoundsExceptionC(CREATE_OUT_OF_BOUNDS_C, thread(), index); + handlePendingException(true); + return verifyObject(getAndClearObjectResult(thread())); + } + + public static final Descriptor CREATE_OUT_OF_BOUNDS_C = descriptorFor(CreateOutOfBoundsExceptionStub.class, "createOutOfBoundsExceptionC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void createOutOfBoundsExceptionC(@ConstantNodeParameter Descriptor createOutOfBoundsExceptionC, Word thread, int index); + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/LogObjectStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; +import com.oracle.graal.api.code.*; +import com.oracle.graal.graph.Node.ConstantNodeParameter; +import com.oracle.graal.graph.Node.NodeIntrinsic; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called from {@link Log}. + */ +public class LogObjectStub extends CRuntimeStub { + + public LogObjectStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static void logObject(Object object, int flags) { + logObjectC(LOG_OBJECT_C, thread(), object, flags); + } + + public static final Descriptor LOG_OBJECT_C = descriptorFor(LogObjectStub.class, "logObjectC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void logObjectC(@ConstantNodeParameter Descriptor logObjectC, Word thread, Object object, int flags); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/LogPrimitiveStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; +import com.oracle.graal.api.code.*; +import com.oracle.graal.graph.Node.ConstantNodeParameter; +import com.oracle.graal.graph.Node.NodeIntrinsic; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called from {@link Log}. + */ +public class LogPrimitiveStub extends CRuntimeStub { + + public LogPrimitiveStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static void logPrimitive(char typeChar, long value, boolean newline) { + logPrimitivefC(LOG_PRIMITIVE_C, thread(), typeChar, value, newline); + } + + public static final Descriptor LOG_PRIMITIVE_C = descriptorFor(LogPrimitiveStub.class, "logPrimitivefC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void logPrimitivefC(@ConstantNodeParameter Descriptor logPrimitivefC, Word thread, char typeChar, long value, boolean newline); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/LogPrintfStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; +import com.oracle.graal.api.code.*; +import com.oracle.graal.graph.Node.ConstantNodeParameter; +import com.oracle.graal.graph.Node.NodeIntrinsic; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called from {@link Log}. + */ +public class LogPrintfStub extends CRuntimeStub { + + public LogPrintfStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static void logPrintf(String format, long v1, long v2, long v3) { + logPrintfC(LOG_PRINTF_C, thread(), format, v1, v2, v3); + } + + public static final Descriptor LOG_PRINTF_C = descriptorFor(LogPrintfStub.class, "logPrintfC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void logPrintfC(@ConstantNodeParameter Descriptor logPrintfC, Word thread, String format, long v1, long v2, long v3); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/MonitorEnterStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; +import com.oracle.graal.api.code.*; +import com.oracle.graal.graph.Node.ConstantNodeParameter; +import com.oracle.graal.graph.Node.NodeIntrinsic; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called from {@link MonitorEnterStubCall}. + */ +public class MonitorEnterStub extends CRuntimeStub { + + public MonitorEnterStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static void monitorenter(Object object, Word lock) { + monitorenterC(MONITORENTER_C, thread(), object, lock); + handlePendingException(false); + } + + public static final Descriptor MONITORENTER_C = descriptorFor(MonitorEnterStub.class, "monitorenterC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void monitorenterC(@ConstantNodeParameter Descriptor monitorenterC, Word thread, Object object, Word lock); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/MonitorExitStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; +import com.oracle.graal.api.code.*; +import com.oracle.graal.graph.Node.ConstantNodeParameter; +import com.oracle.graal.graph.Node.NodeIntrinsic; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called from {@link MonitorExitStubCall}. + */ +public class MonitorExitStub extends CRuntimeStub { + + public MonitorExitStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static void monitorexit(Object object, Word lock) { + monitorexitC(MONITOREXIT_C, thread(), object, lock); + } + + public static final Descriptor MONITOREXIT_C = descriptorFor(MonitorExitStub.class, "monitorexitC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void monitorexitC(@ConstantNodeParameter Descriptor monitorexitC, Word thread, Object object, Word lock); +}
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/ThreadIsInterruptedStub.java Tue May 07 10:39:54 2013 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/ThreadIsInterruptedStub.java Tue May 07 11:37:23 2013 +0200 @@ -54,5 +54,5 @@ public static final Descriptor THREAD_IS_INTERRUPTED_C = descriptorFor(ThreadIsInterruptedStub.class, "threadIsInterruptedC", false); @NodeIntrinsic(CRuntimeCall.class) - public static native boolean threadIsInterruptedC(@ConstantNodeParameter Descriptor newArrayC, Word thread, Thread receiverThread, boolean clearIsInterrupted); + public static native boolean threadIsInterruptedC(@ConstantNodeParameter Descriptor threadIsInterruptedC, Word thread, Thread receiverThread, boolean clearIsInterrupted); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/VMErrorStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; +import com.oracle.graal.api.code.*; +import com.oracle.graal.graph.Node.ConstantNodeParameter; +import com.oracle.graal.graph.Node.NodeIntrinsic; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called from {@link VMErrorNode}. + */ +public class VMErrorStub extends CRuntimeStub { + + public VMErrorStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static void vmError(String where, String format, long value) { + vmErrorC(VM_ERROR_C, thread(), where, format, value); + } + + public static final Descriptor VM_ERROR_C = descriptorFor(VMErrorStub.class, "vmErrorC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void vmErrorC(@ConstantNodeParameter Descriptor vmErrorC, Word thread, String where, String format, long value); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/WriteBarrierPostStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; +import com.oracle.graal.api.code.*; +import com.oracle.graal.graph.Node.ConstantNodeParameter; +import com.oracle.graal.graph.Node.NodeIntrinsic; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called from {@link WriteBarrierPostStubCall}. + */ +public class WriteBarrierPostStub extends CRuntimeStub { + + public WriteBarrierPostStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static void writeBarrierPost(Object object, Word card) { + writeBarrierPostC(WRITE_BARRIER_POST_C, thread(), object, card); + } + + public static final Descriptor WRITE_BARRIER_POST_C = descriptorFor(WriteBarrierPostStub.class, "writeBarrierPostC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void writeBarrierPostC(@ConstantNodeParameter Descriptor vmErrorC, Word thread, Object object, Word card); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/stubs/WriteBarrierPreStub.java Tue May 07 11:37:23 2013 +0200 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.hotspot.stubs; + +import static com.oracle.graal.hotspot.replacements.HotSpotReplacementsUtil.*; + +import com.oracle.graal.api.code.RuntimeCallTarget.Descriptor; +import com.oracle.graal.api.code.*; +import com.oracle.graal.graph.Node.ConstantNodeParameter; +import com.oracle.graal.graph.Node.NodeIntrinsic; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.replacements.*; +import com.oracle.graal.word.*; + +/** + * Stub called from {@link WriteBarrierPreStubCall}. + */ +public class WriteBarrierPreStub extends CRuntimeStub { + + public WriteBarrierPreStub(final HotSpotRuntime runtime, Replacements replacements, TargetDescription target, HotSpotRuntimeCallTarget linkage) { + super(runtime, replacements, target, linkage); + } + + @Snippet + private static void writeBarrierPre(Object object) { + writeBarrierPreC(WRITE_BARRIER_PRE_C, thread(), object); + } + + public static final Descriptor WRITE_BARRIER_PRE_C = descriptorFor(WriteBarrierPreStub.class, "writeBarrierPreC", false); + + @NodeIntrinsic(CRuntimeCall.class) + public static native void writeBarrierPreC(@ConstantNodeParameter Descriptor vmErrorC, Word thread, Object object); +}
--- a/mx/commands.py Tue May 07 10:39:54 2013 +0200 +++ b/mx/commands.py Tue May 07 11:37:23 2013 +0200 @@ -829,30 +829,47 @@ if os.environ.get('MX_TESTFILE') is None: os.remove(testfile) -def unittest(args): - """run the JUnit tests (all testcases) +_unittestHelpSuffix = """ If filters are supplied, only tests whose fully qualified name - include a filter as a substring are run. Negative filters are - those with a '-' prefix. VM args should have a @ prefix.""" + includes a filter as a substring are run. Negative filters are + those with a '-' prefix. + + Options with a '@' prefix are passed to the VM. + + For example, this command line: + + mx unittest BC_aload @-G:Dump= @-G:MethodFilter=BC_aload.* @-G:+PrintCFG + + will run all JUnit test classes that contain 'BC_aload' in their + fully qualified name and will pass these options to the VM: + + -G:Dump= -G:MethodFilter=BC_aload.* -G:+PrintCFG + + To get around command line length limitations on some OSes, the + JUnit class names to be executed are written to a file that a + custom JUnit wrapper reads and passes onto JUnit proper. The + MX_TESTFILE environment variable can be set to specify a + file which will not be deleted once the unittests are done + (unlike the temporary file otherwise used). + + As with all other commands, using the global '-v' before 'unittest' + command will cause mx to show the complete shell command line + it uses to run the VM. +""" + +def unittest(args): + """run the JUnit tests (all testcases){0}""" _unittest(args, ['@Test', '@LongTest']) def shortunittest(args): - """run the JUnit tests (short testcases only) - - If filters are supplied, only tests whose fully qualified name - include a filter as a substring are run. Negative filters are - those with a '-' prefix. VM args should have a @ prefix.""" + """run the JUnit tests (short testcases only){0}""" _unittest(args, ['@Test']) def longunittest(args): - """run the JUnit tests (long testcases only) - - If filters are supplied, only tests whose fully qualified name - include a filter as a substring are run. Negative filters are - those with a '-' prefix. VM args should have a @ prefix.""" + """run the JUnit tests (long testcases only){0}""" _unittest(args, ['@LongTest']) @@ -1341,9 +1358,9 @@ 'gate' : [gate, '[-options]'], 'gv' : [gv, ''], 'bench' : [bench, '[-resultfile file] [all(default)|dacapo|specjvm2008|bootstrap]'], - 'unittest' : [unittest, '[filters...]'], - 'longunittest' : [longunittest, '[filters...]'], - 'shortunittest' : [shortunittest, '[filters...]'], + 'unittest' : [unittest, '[filters...|@VM options]', _unittestHelpSuffix], + 'longunittest' : [longunittest, '[filters...|@VM options]', _unittestHelpSuffix], + 'shortunittest' : [shortunittest, '[filters...|@VM options]', _unittestHelpSuffix], 'jacocoreport' : [jacocoreport, '[output directory]'], 'site' : [site, '[-options]'], 'vm': [vm, '[-options] class [args...]'],
--- a/src/cpu/x86/vm/graalRuntime_x86.cpp Tue May 07 10:39:54 2013 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,785 +0,0 @@ -/* - * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#include "precompiled.hpp" -#include "asm/assembler.hpp" -#include "graal/graalRuntime.hpp" -#include "interpreter/interpreter.hpp" -#include "nativeInst_x86.hpp" -#include "oops/compiledICHolder.hpp" -#include "oops/oop.inline.hpp" -#include "prims/jvmtiExport.hpp" -#include "register_x86.hpp" -#include "runtime/sharedRuntime.hpp" -#include "runtime/signature.hpp" -#include "runtime/vframeArray.hpp" -#include "vmreg_x86.inline.hpp" - -static void restore_live_registers(GraalStubAssembler* sasm, bool restore_fpu_registers = true); - -// Implementation of GraalStubAssembler - -int GraalStubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, int args_size) { - // setup registers - const Register thread = NOT_LP64(rdi) LP64_ONLY(r15_thread); // is callee-saved register (Visual C++ calling conventions) - assert(!(oop_result1->is_valid() || metadata_result->is_valid()) || oop_result1 != metadata_result, "registers must be different"); - assert(oop_result1 != thread && metadata_result != thread, "registers must be different"); - assert(args_size >= 0, "illegal args_size"); - -#ifdef _LP64 - mov(c_rarg0, thread); - set_num_rt_args(0); // Nothing on stack -#else - set_num_rt_args(1 + args_size); - - // push java thread (becomes first argument of C function) - get_thread(thread); - push(thread); -#endif // _LP64 - - int call_offset; - set_last_Java_frame(thread, rsp, noreg, NULL); - - // do the call - call(RuntimeAddress(entry)); - call_offset = offset(); - // verify callee-saved register -#ifdef ASSERT - guarantee(thread != rax, "change this code"); - push(rax); - { Label L; - get_thread(rax); - cmpptr(thread, rax); - jcc(Assembler::equal, L); - int3(); - stop("GraalStubAssembler::call_RT: rdi not callee saved?"); - bind(L); - } - pop(rax); -#endif - reset_last_Java_frame(thread, true, false); - - // discard thread and arguments - NOT_LP64(addptr(rsp, num_rt_args()*BytesPerWord)); - - // check for pending exceptions - { Label L; - cmpptr(Address(thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD); - jcc(Assembler::equal, L); - // exception pending => remove activation and forward to exception handler - movptr(rax, Address(thread, Thread::pending_exception_offset())); - // make sure that the vm_results are cleared - if (oop_result1->is_valid()) { - movptr(Address(thread, JavaThread::vm_result_offset()), NULL_WORD); - } - if (metadata_result->is_valid()) { - movptr(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD); - } - // (thomaswue) Deoptimize in case of an exception. - restore_live_registers(this, false); - movptr(Address(thread, Thread::pending_exception_offset()), NULL_WORD); - leave(); - movl(Address(thread, ThreadShadow::pending_deoptimization_offset()), Deoptimization::make_trap_request(Deoptimization::Reason_constraint, Deoptimization::Action_reinterpret)); - jump(RuntimeAddress(SharedRuntime::deopt_blob()->uncommon_trap())); - bind(L); - } - // get oop results if there are any and reset the values in the thread - if (oop_result1->is_valid()) { - get_vm_result(oop_result1, thread); - } - if (metadata_result->is_valid()) { - get_vm_result_2(metadata_result, thread); - } - return call_offset; -} - - -int GraalStubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1) { -#ifdef _LP64 - mov(c_rarg1, arg1); -#else - push(arg1); -#endif // _LP64 - return call_RT(oop_result1, metadata_result, entry, 1); -} - - -int GraalStubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2) { -#ifdef _LP64 - if (c_rarg1 == arg2) { - if (c_rarg2 == arg1) { - xchgq(arg1, arg2); - } else { - mov(c_rarg2, arg2); - mov(c_rarg1, arg1); - } - } else { - mov(c_rarg1, arg1); - mov(c_rarg2, arg2); - } -#else - push(arg2); - push(arg1); -#endif // _LP64 - return call_RT(oop_result1, metadata_result, entry, 2); -} - - -int GraalStubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2, Register arg3) { -#ifdef _LP64 - // if there is any conflict use the stack - if (arg1 == c_rarg2 || arg1 == c_rarg3 || - arg2 == c_rarg1 || arg1 == c_rarg3 || - arg3 == c_rarg1 || arg1 == c_rarg2) { - push(arg3); - push(arg2); - push(arg1); - pop(c_rarg1); - pop(c_rarg2); - pop(c_rarg3); - } else { - mov(c_rarg1, arg1); - mov(c_rarg2, arg2); - mov(c_rarg3, arg3); - } -#else - push(arg3); - push(arg2); - push(arg1); -#endif // _LP64 - return call_RT(oop_result1, metadata_result, entry, 3); -} - -int GraalStubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2, Register arg3, Register arg4) { -#ifdef _LP64 - #ifdef _WIN64 - // on windows we only have the registers c_rarg0 to c_rarg3 for transferring parameters -> remaining parameters are on the stack - if (arg1 == c_rarg2 || arg1 == c_rarg3 || - arg2 == c_rarg1 || arg2 == c_rarg3 || - arg3 == c_rarg1 || arg3 == c_rarg2 || - arg4 == c_rarg1 || arg4 == c_rarg2) { - push(arg4); - push(arg3); - push(arg2); - push(arg1); - pop(c_rarg1); - pop(c_rarg2); - pop(c_rarg3); - } else { - mov(c_rarg1, arg1); - mov(c_rarg2, arg2); - mov(c_rarg3, arg3); - push(arg4); - } - #else - // if there is any conflict use the stack - if (arg1 == c_rarg2 || arg1 == c_rarg3 || arg1 == c_rarg4 || - arg2 == c_rarg1 || arg2 == c_rarg3 || arg2 == c_rarg4 || - arg3 == c_rarg1 || arg3 == c_rarg2 || arg3 == c_rarg4 || - arg4 == c_rarg1 || arg4 == c_rarg2 || arg4 == c_rarg3) { - push(arg4); - push(arg3); - push(arg2); - push(arg1); - pop(c_rarg1); - pop(c_rarg2); - pop(c_rarg3); - pop(c_rarg4); - } else { - mov(c_rarg1, arg1); - mov(c_rarg2, arg2); - mov(c_rarg3, arg3); - mov(c_rarg4, arg4); - } - #endif -#else - push(arg4); - push(arg3); - push(arg2); - push(arg1); -#endif // _LP64 - return call_RT(oop_result1, metadata_result, entry, 4); -} - -// Implementation of GraalStubFrame - -class GraalStubFrame: public StackObj { - private: - GraalStubAssembler* _sasm; - - public: - GraalStubFrame(GraalStubAssembler* sasm, const char* name, bool must_gc_arguments); - ~GraalStubFrame(); -}; - - -#define __ _sasm-> - -GraalStubFrame::GraalStubFrame(GraalStubAssembler* sasm, const char* name, bool must_gc_arguments) { - _sasm = sasm; - __ set_info(name, must_gc_arguments); - __ enter(); -} - -GraalStubFrame::~GraalStubFrame() { - __ leave(); - __ ret(0); -} - -#undef __ - - -// Implementation of GraalRuntime - -const int float_regs_as_doubles_size_in_slots = FloatRegisterImpl::number_of_registers * 2; -const int xmm_regs_as_doubles_size_in_slots = XMMRegisterImpl::number_of_registers * 2; - -// Stack layout for saving/restoring all the registers needed during a runtime -// call (this includes deoptimization) -// Note: note that users of this frame may well have arguments to some runtime -// while these values are on the stack. These positions neglect those arguments -// but the code in save_live_registers will take the argument count into -// account. -// -#ifdef _LP64 - #define SLOT2(x) x, - #define SLOT_PER_WORD 2 -#else - #define SLOT2(x) - #define SLOT_PER_WORD 1 -#endif // _LP64 - -enum reg_save_layout { - // 64bit needs to keep stack 16 byte aligned. So we add some alignment dummies to make that - // happen and will assert if the stack size we create is misaligned -#ifdef _LP64 - align_dummy_0, align_dummy_1, -#endif // _LP64 -#ifdef _WIN64 - // Windows always allocates space for it's argument registers (see - // frame::arg_reg_save_area_bytes). - arg_reg_save_1, arg_reg_save_1H, // 0, 4 - arg_reg_save_2, arg_reg_save_2H, // 8, 12 - arg_reg_save_3, arg_reg_save_3H, // 16, 20 - arg_reg_save_4, arg_reg_save_4H, // 24, 28 -#endif // _WIN64 - xmm_regs_as_doubles_off, // 32 - float_regs_as_doubles_off = xmm_regs_as_doubles_off + xmm_regs_as_doubles_size_in_slots, // 160 - fpu_state_off = float_regs_as_doubles_off + float_regs_as_doubles_size_in_slots, // 224 - // fpu_state_end_off is exclusive - fpu_state_end_off = fpu_state_off + (FPUStateSizeInWords / SLOT_PER_WORD), // 352 - marker = fpu_state_end_off, SLOT2(markerH) // 352, 356 - extra_space_offset, // 360 -#ifdef _LP64 - r15_off = extra_space_offset, r15H_off, // 360, 364 - r14_off, r14H_off, // 368, 372 - r13_off, r13H_off, // 376, 380 - r12_off, r12H_off, // 384, 388 - r11_off, r11H_off, // 392, 396 - r10_off, r10H_off, // 400, 404 - r9_off, r9H_off, // 408, 412 - r8_off, r8H_off, // 416, 420 - rdi_off, rdiH_off, // 424, 428 -#else - rdi_off = extra_space_offset, -#endif // _LP64 - rsi_off, SLOT2(rsiH_off) // 432, 436 - rbp_off, SLOT2(rbpH_off) // 440, 444 - rsp_off, SLOT2(rspH_off) // 448, 452 - rbx_off, SLOT2(rbxH_off) // 456, 460 - rdx_off, SLOT2(rdxH_off) // 464, 468 - rcx_off, SLOT2(rcxH_off) // 472, 476 - rax_off, SLOT2(raxH_off) // 480, 484 - saved_rbp_off, SLOT2(saved_rbpH_off) // 488, 492 - return_off, SLOT2(returnH_off) // 496, 500 - reg_save_frame_size // As noted: neglects any parameters to runtime // 504 -}; - -// Save registers which might be killed by calls into the runtime. -// Tries to smart about FP registers. In particular we separate -// saving and describing the FPU registers for deoptimization since we -// have to save the FPU registers twice if we describe them and on P4 -// saving FPU registers which don't contain anything appears -// expensive. The deopt blob is the only thing which needs to -// describe FPU registers. In all other cases it should be sufficient -// to simply save their current value. - -static OopMap* generate_oop_map(GraalStubAssembler* sasm, int num_rt_args, - bool save_fpu_registers = true) { - - // In 64bit all the args are in regs so there are no additional stack slots - LP64_ONLY(num_rt_args = 0); - LP64_ONLY(assert((reg_save_frame_size * VMRegImpl::stack_slot_size) % 16 == 0, "must be 16 byte aligned");) - int frame_size_in_slots = reg_save_frame_size + num_rt_args; // args + thread - sasm->set_frame_size(frame_size_in_slots / VMRegImpl::slots_per_word ); - - // record saved value locations in an OopMap - // locations are offsets from sp after runtime call; num_rt_args is number of arguments in call, including thread - OopMap* map = new OopMap(frame_size_in_slots, 0); - map->set_callee_saved(VMRegImpl::stack2reg(rax_off + num_rt_args), rax->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(rcx_off + num_rt_args), rcx->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(rdx_off + num_rt_args), rdx->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(rbx_off + num_rt_args), rbx->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(rbp_off + num_rt_args), rbp->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(rsi_off + num_rt_args), rsi->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(rdi_off + num_rt_args), rdi->as_VMReg()); -#ifdef _LP64 - map->set_callee_saved(VMRegImpl::stack2reg(r8_off + num_rt_args), r8->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(r9_off + num_rt_args), r9->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(r10_off + num_rt_args), r10->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(r11_off + num_rt_args), r11->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(r12_off + num_rt_args), r12->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(r13_off + num_rt_args), r13->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(r14_off + num_rt_args), r14->as_VMReg()); - map->set_callee_saved(VMRegImpl::stack2reg(r15_off + num_rt_args), r15->as_VMReg()); - - // This is stupid but needed. - map->set_callee_saved(VMRegImpl::stack2reg(raxH_off + num_rt_args), rax->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(rcxH_off + num_rt_args), rcx->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(rdxH_off + num_rt_args), rdx->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(rbxH_off + num_rt_args), rbx->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(rbpH_off + num_rt_args), rbp->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(rsiH_off + num_rt_args), rsi->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(rdiH_off + num_rt_args), rdi->as_VMReg()->next()); - - map->set_callee_saved(VMRegImpl::stack2reg(r8H_off + num_rt_args), r8->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(r9H_off + num_rt_args), r9->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(r10H_off + num_rt_args), r10->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(r11H_off + num_rt_args), r11->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(r12H_off + num_rt_args), r12->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(r13H_off + num_rt_args), r13->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(r14H_off + num_rt_args), r14->as_VMReg()->next()); - map->set_callee_saved(VMRegImpl::stack2reg(r15H_off + num_rt_args), r15->as_VMReg()->next()); -#endif // _LP64 - - if (save_fpu_registers) { - if (UseSSE < 2) { - int fpu_off = float_regs_as_doubles_off; - for (int n = 0; n < FloatRegisterImpl::number_of_registers; n++) { - VMReg fpu_name_0 = as_FloatRegister(n)->as_VMReg(); - map->set_callee_saved(VMRegImpl::stack2reg(fpu_off + num_rt_args), fpu_name_0); - // %%% This is really a waste but we'll keep things as they were for now - if (true) { - map->set_callee_saved(VMRegImpl::stack2reg(fpu_off + 1 + num_rt_args), fpu_name_0->next()); - } - fpu_off += 2; - } - assert(fpu_off == fpu_state_off, "incorrect number of fpu stack slots"); - } - - if (UseSSE >= 2) { - int xmm_off = xmm_regs_as_doubles_off; - for (int n = 0; n < XMMRegisterImpl::number_of_registers; n++) { - VMReg xmm_name_0 = as_XMMRegister(n)->as_VMReg(); - map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + num_rt_args), xmm_name_0); - // %%% This is really a waste but we'll keep things as they were for now - if (true) { - map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + 1 + num_rt_args), xmm_name_0->next()); - } - xmm_off += 2; - } - assert(xmm_off == float_regs_as_doubles_off, "incorrect number of xmm registers"); - - } else if (UseSSE == 1) { - int xmm_off = xmm_regs_as_doubles_off; - for (int n = 0; n < XMMRegisterImpl::number_of_registers; n++) { - VMReg xmm_name_0 = as_XMMRegister(n)->as_VMReg(); - map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + num_rt_args), xmm_name_0); - xmm_off += 2; - } - assert(xmm_off == float_regs_as_doubles_off, "incorrect number of xmm registers"); - } - } - - return map; -} - -#define __ sasm-> - -static OopMap* save_live_registers(GraalStubAssembler* sasm, int num_rt_args, - bool save_fpu_registers = true) { - __ block_comment("save_live_registers"); - - __ pusha(); // integer registers - - // assert(float_regs_as_doubles_off % 2 == 0, "misaligned offset"); - // assert(xmm_regs_as_doubles_off % 2 == 0, "misaligned offset"); - - __ subptr(rsp, extra_space_offset * VMRegImpl::stack_slot_size); - -#ifdef ASSERT - __ movptr(Address(rsp, marker * VMRegImpl::stack_slot_size), (int32_t)0xfeedbeef); -#endif - - if (save_fpu_registers) { - if (UseSSE < 2) { - // save FPU stack - __ fnsave(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size)); - __ fwait(); - -#ifdef ASSERT - Label ok; - __ cmpw(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size), StubRoutines::fpu_cntrl_wrd_std()); - __ jccb(Assembler::equal, ok); - __ stop("corrupted control word detected"); - __ bind(ok); -#endif - - // Reset the control word to guard against exceptions being unmasked - // since fstp_d can cause FPU stack underflow exceptions. Write it - // into the on stack copy and then reload that to make sure that the - // current and future values are correct. - __ movw(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size), StubRoutines::fpu_cntrl_wrd_std()); - __ frstor(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size)); - - // Save the FPU registers in de-opt-able form - __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0)); - __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8)); - __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16)); - __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24)); - __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32)); - __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40)); - __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48)); - __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56)); - } - - if (UseSSE >= 2) { - // save XMM registers - // XMM registers can contain float or double values, but this is not known here, - // so always save them as doubles. - // note that float values are _not_ converted automatically, so for float values - // the second word contains only garbage data. - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0), xmm0); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8), xmm1); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16), xmm2); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24), xmm3); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32), xmm4); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40), xmm5); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48), xmm6); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56), xmm7); -#ifdef _LP64 - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 64), xmm8); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 72), xmm9); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 80), xmm10); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 88), xmm11); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 96), xmm12); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 104), xmm13); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 112), xmm14); - __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 120), xmm15); -#endif // _LP64 - } else if (UseSSE == 1) { - // save XMM registers as float because double not supported without SSE2 - __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0), xmm0); - __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8), xmm1); - __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16), xmm2); - __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24), xmm3); - __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32), xmm4); - __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40), xmm5); - __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48), xmm6); - __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56), xmm7); - } - } - - // FPU stack must be empty now - __ verify_FPU(0, "save_live_registers"); - - return generate_oop_map(sasm, num_rt_args, save_fpu_registers); -} - - -static void restore_fpu(GraalStubAssembler* sasm, bool restore_fpu_registers = true) { - if (restore_fpu_registers) { - if (UseSSE >= 2) { - // restore XMM registers - __ movdbl(xmm0, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0)); - __ movdbl(xmm1, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8)); - __ movdbl(xmm2, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16)); - __ movdbl(xmm3, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24)); - __ movdbl(xmm4, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32)); - __ movdbl(xmm5, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40)); - __ movdbl(xmm6, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48)); - __ movdbl(xmm7, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56)); -#ifdef _LP64 - __ movdbl(xmm8, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 64)); - __ movdbl(xmm9, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 72)); - __ movdbl(xmm10, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 80)); - __ movdbl(xmm11, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 88)); - __ movdbl(xmm12, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 96)); - __ movdbl(xmm13, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 104)); - __ movdbl(xmm14, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 112)); - __ movdbl(xmm15, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 120)); -#endif // _LP64 - } else if (UseSSE == 1) { - // restore XMM registers - __ movflt(xmm0, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0)); - __ movflt(xmm1, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8)); - __ movflt(xmm2, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16)); - __ movflt(xmm3, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24)); - __ movflt(xmm4, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32)); - __ movflt(xmm5, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40)); - __ movflt(xmm6, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48)); - __ movflt(xmm7, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56)); - } - - if (UseSSE < 2) { - __ frstor(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size)); - } else { - // check that FPU stack is really empty - __ verify_FPU(0, "restore_live_registers"); - } - - } else { - // check that FPU stack is really empty - __ verify_FPU(0, "restore_live_registers"); - } - -#ifdef ASSERT - { - Label ok; - __ cmpptr(Address(rsp, marker * VMRegImpl::stack_slot_size), (int32_t)0xfeedbeef); - __ jcc(Assembler::equal, ok); - __ stop("bad offsets in frame"); - __ bind(ok); - } -#endif // ASSERT - - __ addptr(rsp, extra_space_offset * VMRegImpl::stack_slot_size); -} - - -static void restore_live_registers(GraalStubAssembler* sasm, bool restore_fpu_registers/* = true*/) { - __ block_comment("restore_live_registers"); - - restore_fpu(sasm, restore_fpu_registers); - __ popa(); -} - - -static void restore_live_registers_except_rax(GraalStubAssembler* sasm, bool restore_fpu_registers = true) { - __ block_comment("restore_live_registers_except_rax"); - - restore_fpu(sasm, restore_fpu_registers); - -#ifdef _LP64 - __ movptr(r15, Address(rsp, 0)); - __ movptr(r14, Address(rsp, wordSize)); - __ movptr(r13, Address(rsp, 2 * wordSize)); - __ movptr(r12, Address(rsp, 3 * wordSize)); - __ movptr(r11, Address(rsp, 4 * wordSize)); - __ movptr(r10, Address(rsp, 5 * wordSize)); - __ movptr(r9, Address(rsp, 6 * wordSize)); - __ movptr(r8, Address(rsp, 7 * wordSize)); - __ movptr(rdi, Address(rsp, 8 * wordSize)); - __ movptr(rsi, Address(rsp, 9 * wordSize)); - __ movptr(rbp, Address(rsp, 10 * wordSize)); - // skip rsp - __ movptr(rbx, Address(rsp, 12 * wordSize)); - __ movptr(rdx, Address(rsp, 13 * wordSize)); - __ movptr(rcx, Address(rsp, 14 * wordSize)); - - __ addptr(rsp, 16 * wordSize); -#else - - __ pop(rdi); - __ pop(rsi); - __ pop(rbp); - __ pop(rbx); // skip this value - __ pop(rbx); - __ pop(rdx); - __ pop(rcx); - __ addptr(rsp, BytesPerWord); -#endif // _LP64 -} - -OopMapSet* GraalRuntime::generate_code_for(StubID id, GraalStubAssembler* sasm) { - - // for better readability - const bool must_gc_arguments = true; - const bool dont_gc_arguments = false; - - // default value; overwritten for some optimized stubs that are called from methods that do not use the fpu - bool save_fpu_registers = true; - - // stub code & info for the different stubs - OopMapSet* oop_maps = NULL; - switch (id) { - - case create_null_pointer_exception_id: { - __ enter(); - oop_maps = new OopMapSet(); - OopMap* oop_map = save_live_registers(sasm, 0); - int call_offset = __ call_RT(rax, noreg, (address)create_null_exception, 0); - oop_maps->add_gc_map(call_offset, oop_map); - restore_live_registers_except_rax(sasm); - __ leave(); - __ ret(0); - break; - } - - case create_out_of_bounds_exception_id: { - __ enter(); - oop_maps = new OopMapSet(); - OopMap* oop_map = save_live_registers(sasm, 1); - int call_offset = __ call_RT(rax, noreg, (address)create_out_of_bounds_exception, j_rarg0); - oop_maps->add_gc_map(call_offset, oop_map); - restore_live_registers_except_rax(sasm); - __ leave(); - __ ret(0); - break; - } - - case vm_error_id: { - __ enter(); - oop_maps = new OopMapSet(); - OopMap* oop_map = save_live_registers(sasm, 3); - int call_offset = __ call_RT(noreg, noreg, (address)vm_error, j_rarg0, j_rarg1, j_rarg2); - oop_maps->add_gc_map(call_offset, oop_map); - restore_live_registers(sasm); - __ leave(); - __ ret(0); - break; - } - - case log_printf_id: { - __ enter(); - oop_maps = new OopMapSet(); - OopMap* oop_map = save_live_registers(sasm, 4); - int call_offset = __ call_RT(noreg, noreg, (address)log_printf, j_rarg0, j_rarg1, j_rarg2, j_rarg3); - oop_maps->add_gc_map(call_offset, oop_map); - restore_live_registers(sasm); - __ leave(); - __ ret(0); - break; - } - - case log_primitive_id: { - __ enter(); - oop_maps = new OopMapSet(); - OopMap* oop_map = save_live_registers(sasm, 3); - int call_offset = __ call_RT(noreg, noreg, (address)log_primitive, j_rarg0, j_rarg1, j_rarg2); - oop_maps->add_gc_map(call_offset, oop_map); - restore_live_registers(sasm); - __ leave(); - __ ret(0); - break; - } - - case log_object_id: { - __ enter(); - oop_maps = new OopMapSet(); - OopMap* oop_map = save_live_registers(sasm, 2); - int call_offset = __ call_RT(noreg, noreg, (address)log_object, j_rarg0, j_rarg1); - oop_maps->add_gc_map(call_offset, oop_map); - restore_live_registers(sasm); - __ leave(); - __ ret(0); - break; - } - - case monitorenter_id: { - Register obj = j_rarg0; - Register lock = j_rarg1; - { - GraalStubFrame f(sasm, "monitorenter", dont_gc_arguments); - OopMap* map = save_live_registers(sasm, 2, save_fpu_registers); - - // Called with store_parameter and not C abi - int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorenter), obj, lock); - - oop_maps = new OopMapSet(); - oop_maps->add_gc_map(call_offset, map); - restore_live_registers(sasm, save_fpu_registers); - } - __ ret(0); - break; - } - case monitorexit_id: { - Register obj = j_rarg0; - Register lock = j_rarg1; - { - GraalStubFrame f(sasm, "monitorexit", dont_gc_arguments); - OopMap* map = save_live_registers(sasm, 2, save_fpu_registers); - - // note: really a leaf routine but must setup last java sp - // => use call_RT for now (speed can be improved by - // doing last java sp setup manually) - int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorexit), obj, lock); - - oop_maps = new OopMapSet(); - oop_maps->add_gc_map(call_offset, map); - restore_live_registers(sasm, save_fpu_registers); - } - __ ret(0); - break; - } - case wb_pre_call_id: { - Register obj = j_rarg0; - { - GraalStubFrame f(sasm, "graal_wb_pre_call", dont_gc_arguments); - OopMap* map = save_live_registers(sasm, 2, save_fpu_registers); - - // note: really a leaf routine but must setup last java sp - // => use call_RT for now (speed can be improved by - // doing last java sp setup manually) - int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, wb_pre_call), obj); - - oop_maps = new OopMapSet(); - oop_maps->add_gc_map(call_offset, map); - restore_live_registers(sasm); - } - __ ret(0); - break; - } - case wb_post_call_id: { - Register obj = j_rarg0; - Register caddr = j_rarg1; - { - GraalStubFrame f(sasm, "graal_wb_post_call", dont_gc_arguments); - OopMap* map = save_live_registers(sasm, 2, save_fpu_registers); - - // note: really a leaf routine but must setup last java sp - // => use call_RT for now (speed can be improved by - // doing last java sp setup manually) - int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, wb_post_call), obj, caddr); - - oop_maps = new OopMapSet(); - oop_maps->add_gc_map(call_offset, map); - restore_live_registers(sasm); - } - __ ret(0); - break; - } - - default: - { GraalStubFrame f(sasm, "unimplemented entry", dont_gc_arguments); - __ movptr(rax, (int)id); - __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), rax); - __ should_not_reach_here(); - } - break; - } - return oop_maps; -} - -#undef __
--- a/src/share/vm/graal/graalCompiler.cpp Tue May 07 10:39:54 2013 +0200 +++ b/src/share/vm/graal/graalCompiler.cpp Tue May 07 11:37:23 2013 +0200 @@ -57,7 +57,6 @@ _deopted_leaf_graph_count = 0; initialize_buffer_blob(); - GraalRuntime::initialize(THREAD->get_buffer_blob()); JNIEnv *env = ((JavaThread *) Thread::current())->jni_environment(); jclass klass = env->FindClass("com/oracle/graal/hotspot/bridge/CompilerToVMImpl");
--- a/src/share/vm/graal/graalCompilerToVM.cpp Tue May 07 10:39:54 2013 +0200 +++ b/src/share/vm/graal/graalCompilerToVM.cpp Tue May 07 11:37:23 2013 +0200 @@ -766,25 +766,13 @@ set_int("layoutHelperHeaderSizeMask", Klass::_lh_header_size_mask); set_int("layoutHelperOffset", in_bytes(Klass::layout_helper_offset())); - - set_address("wbPreCallStub", GraalRuntime::entry_for(GraalRuntime::wb_pre_call_id)); - set_address("wbPostCallStub", GraalRuntime::entry_for(GraalRuntime::wb_post_call_id)); - set_address("inlineCacheMissStub", SharedRuntime::get_ic_miss_stub()); set_address("handleDeoptStub", SharedRuntime::deopt_blob()->unpack()); - set_address("monitorEnterStub", GraalRuntime::entry_for(GraalRuntime::monitorenter_id)); - set_address("monitorExitStub", GraalRuntime::entry_for(GraalRuntime::monitorexit_id)); - set_address("vmErrorStub", GraalRuntime::entry_for(GraalRuntime::vm_error_id)); - set_address("createNullPointerExceptionStub", GraalRuntime::entry_for(GraalRuntime::create_null_pointer_exception_id)); - set_address("createOutOfBoundsExceptionStub", GraalRuntime::entry_for(GraalRuntime::create_out_of_bounds_exception_id)); set_address("javaTimeMillisStub", CAST_FROM_FN_PTR(address, os::javaTimeMillis)); set_address("javaTimeNanosStub", CAST_FROM_FN_PTR(address, os::javaTimeNanos)); set_address("arithmeticSinStub", CAST_FROM_FN_PTR(address, SharedRuntime::dsin)); set_address("arithmeticCosStub", CAST_FROM_FN_PTR(address, SharedRuntime::dcos)); set_address("arithmeticTanStub", CAST_FROM_FN_PTR(address, SharedRuntime::dtan)); - set_address("logPrimitiveStub", GraalRuntime::entry_for(GraalRuntime::log_primitive_id)); - set_address("logObjectStub", GraalRuntime::entry_for(GraalRuntime::log_object_id)); - set_address("logPrintfStub", GraalRuntime::entry_for(GraalRuntime::log_printf_id)); set_address("aescryptEncryptBlockStub", StubRoutines::aescrypt_encryptBlock()); set_address("aescryptDecryptBlockStub", StubRoutines::aescrypt_decryptBlock()); set_address("cipherBlockChainingEncryptAESCryptStub", StubRoutines::cipherBlockChaining_encryptAESCrypt()); @@ -801,6 +789,16 @@ set_address("exceptionHandlerForPcAddress", GraalRuntime::exception_handler_for_pc); set_address("exceptionHandlerForReturnAddressAddress", SharedRuntime::exception_handler_for_return_address); set_address("osrMigrationEndAddress", SharedRuntime::OSR_migration_end); + set_address("monitorenterAddress", GraalRuntime::monitorenter); + set_address("monitorexitAddress", GraalRuntime::monitorexit); + set_address("createNullPointerExceptionAddress", GraalRuntime::create_null_exception); + set_address("createOutOfBoundsExceptionAddress", GraalRuntime::create_out_of_bounds_exception); + set_address("logPrimitiveAddress", GraalRuntime::log_primitive); + set_address("logObjectAddress", GraalRuntime::log_object); + set_address("logPrintfAddress", GraalRuntime::log_printf); + set_address("vmErrorAddress", GraalRuntime::vm_error); + set_address("writeBarrierPreAddress", GraalRuntime::write_barrier_pre); + set_address("writeBarrierPostAddress", GraalRuntime::write_barrier_post); set_int("deoptReasonNone", Deoptimization::Reason_none); set_int("deoptReasonNullCheck", Deoptimization::Reason_null_check);
--- a/src/share/vm/graal/graalRuntime.cpp Tue May 07 10:39:54 2013 +0200 +++ b/src/share/vm/graal/graalRuntime.cpp Tue May 07 11:37:23 2013 +0200 @@ -30,44 +30,6 @@ #include "runtime/biasedLocking.hpp" #include "runtime/interfaceSupport.hpp" #include "utilities/debug.hpp" -// Implementation of GraalStubAssembler - -GraalStubAssembler::GraalStubAssembler(CodeBuffer* code, const char * name, int stub_id) : MacroAssembler(code) { - _name = name; - _must_gc_arguments = false; - _frame_size = no_frame_size; - _num_rt_args = 0; - _stub_id = stub_id; -} - - -void GraalStubAssembler::set_info(const char* name, bool must_gc_arguments) { - _name = name; - _must_gc_arguments = must_gc_arguments; -} - - -void GraalStubAssembler::set_frame_size(int size) { - if (_frame_size == no_frame_size) { - _frame_size = size; - } - assert(_frame_size == size, "can't change the frame size"); -} - - -void GraalStubAssembler::set_num_rt_args(int args) { - if (_num_rt_args == 0) { - _num_rt_args = args; - } - assert(_num_rt_args == args, "can't change the number of args"); -} - -// Implementation of GraalRuntime - -CodeBlob* GraalRuntime::_blobs[GraalRuntime::number_of_ids]; -const char *GraalRuntime::_blob_names[] = { - GRAAL_STUBS(STUB_NAME, LAST_STUB_NAME) -}; // Simple helper to see if the caller of a runtime stub which // entered the VM has been deoptimized @@ -93,131 +55,6 @@ } } -static bool setup_code_buffer(CodeBuffer* code) { - // Preinitialize the consts section to some large size: - int locs_buffer_size = 1 * (relocInfo::length_limit + sizeof(relocInfo)); - char* locs_buffer = NEW_RESOURCE_ARRAY(char, locs_buffer_size); - code->insts()->initialize_shared_locs((relocInfo*)locs_buffer, - locs_buffer_size / sizeof(relocInfo)); - - // Global stubs have neither constants nor local stubs - code->initialize_consts_size(0); - code->initialize_stubs_size(0); - - return true; -} - -void GraalRuntime::generate_blob_for(BufferBlob* buffer_blob, StubID id) { - assert(0 <= id && id < number_of_ids, "illegal stub id"); - ResourceMark rm; - // create code buffer for code storage - CodeBuffer code(buffer_blob); - - setup_code_buffer(&code); - - // create assembler for code generation - GraalStubAssembler* sasm = new GraalStubAssembler(&code, name_for(id), id); - // generate code for runtime stub - OopMapSet* oop_maps; - oop_maps = generate_code_for(id, sasm); - assert(oop_maps == NULL || sasm->frame_size() != GraalStubAssembler::no_frame_size, - "if stub has an oop map it must have a valid frame size"); - -#ifdef ASSERT - // Make sure that stubs that need oopmaps have them - assert(oop_maps != NULL, "must have an oopmap"); -#endif - - // align so printing shows nop's instead of random code at the end (SimpleStubs are aligned) - sasm->align(BytesPerWord); - // make sure all code is in code buffer - sasm->flush(); - // create blob - distinguish a few special cases - CodeBlob* blob = RuntimeStub::new_runtime_stub(name_for(id), - &code, - CodeOffsets::frame_never_safe, - sasm->frame_size(), - oop_maps, - sasm->must_gc_arguments()); - // install blob - assert(blob != NULL, "blob must exist"); - _blobs[id] = blob; -} - - -void GraalRuntime::initialize(BufferBlob* blob) { - // generate stubs - for (int id = 0; id < number_of_ids; id++) generate_blob_for(blob, (StubID)id); - // printing -#ifndef PRODUCT - if (GraalPrintSimpleStubs) { - ResourceMark rm; - for (int id = 0; id < number_of_ids; id++) { - _blobs[id]->print(); - if (_blobs[id]->oop_maps() != NULL) { - _blobs[id]->oop_maps()->print(); - } - } - } -#endif -} - - -CodeBlob* GraalRuntime::blob_for(StubID id) { - assert(0 <= id && id < number_of_ids, "illegal stub id"); - return _blobs[id]; -} - - -const char* GraalRuntime::name_for(StubID id) { - assert(0 <= id && id < number_of_ids, "illegal stub id"); - return _blob_names[id]; -} - -const char* GraalRuntime::name_for_address(address entry) { - for (int id = 0; id < number_of_ids; id++) { - if (entry == entry_for((StubID)id)) return name_for((StubID)id); - } - -#define FUNCTION_CASE(a, f) \ - if ((intptr_t)a == CAST_FROM_FN_PTR(intptr_t, f)) return #f - - FUNCTION_CASE(entry, os::javaTimeMillis); - FUNCTION_CASE(entry, os::javaTimeNanos); - FUNCTION_CASE(entry, SharedRuntime::OSR_migration_end); - FUNCTION_CASE(entry, SharedRuntime::d2f); - FUNCTION_CASE(entry, SharedRuntime::d2i); - FUNCTION_CASE(entry, SharedRuntime::d2l); - FUNCTION_CASE(entry, SharedRuntime::dcos); - FUNCTION_CASE(entry, SharedRuntime::dexp); - FUNCTION_CASE(entry, SharedRuntime::dlog); - FUNCTION_CASE(entry, SharedRuntime::dlog10); - FUNCTION_CASE(entry, SharedRuntime::dpow); - FUNCTION_CASE(entry, SharedRuntime::drem); - FUNCTION_CASE(entry, SharedRuntime::dsin); - FUNCTION_CASE(entry, SharedRuntime::dtan); - FUNCTION_CASE(entry, SharedRuntime::f2i); - FUNCTION_CASE(entry, SharedRuntime::f2l); - FUNCTION_CASE(entry, SharedRuntime::frem); - FUNCTION_CASE(entry, SharedRuntime::l2d); - FUNCTION_CASE(entry, SharedRuntime::l2f); - FUNCTION_CASE(entry, SharedRuntime::ldiv); - FUNCTION_CASE(entry, SharedRuntime::lmul); - FUNCTION_CASE(entry, SharedRuntime::lrem); - FUNCTION_CASE(entry, SharedRuntime::lrem); - FUNCTION_CASE(entry, SharedRuntime::dtrace_method_entry); - FUNCTION_CASE(entry, SharedRuntime::dtrace_method_exit); -#ifdef TRACE_HAVE_INTRINSICS - FUNCTION_CASE(entry, TRACE_TIME_METHOD); -#endif - - ShouldNotReachHere(); - return NULL; - -#undef FUNCTION_CASE -} - - JRT_ENTRY(void, GraalRuntime::new_instance(JavaThread* thread, Klass* klass)) assert(klass->is_klass(), "not a class"); instanceKlassHandle h(thread, klass); @@ -264,10 +101,6 @@ thread->set_vm_result(obj); JRT_END -JRT_ENTRY(void, GraalRuntime::unimplemented_entry(JavaThread* thread, StubID id)) - tty->print_cr("GraalRuntime::entry_for(%d) returned unimplemented entry point", id); -JRT_END - extern void vm_exit(int code); // Enter this method from compiled code handler below. This is where we transition @@ -471,11 +304,11 @@ } JRT_END -JRT_LEAF(void, GraalRuntime::wb_pre_call(JavaThread* thread, oopDesc* obj)) +JRT_LEAF(void, GraalRuntime::write_barrier_pre(JavaThread* thread, oopDesc* obj)) thread->satb_mark_queue().enqueue(obj); JRT_END -JRT_LEAF(void, GraalRuntime::wb_post_call(JavaThread* thread, oopDesc* obj, void* card_addr)) +JRT_LEAF(void, GraalRuntime::write_barrier_post(JavaThread* thread, oopDesc* obj, void* card_addr)) thread->dirty_card_queue().enqueue(card_addr); JRT_END
--- a/src/share/vm/graal/graalRuntime.hpp Tue May 07 10:39:54 2013 +0200 +++ b/src/share/vm/graal/graalRuntime.hpp Tue May 07 11:37:23 2013 +0200 @@ -24,119 +24,11 @@ #ifndef SHARE_VM_GRAAL_GRAAL_RUNTIME_HPP #define SHARE_VM_GRAAL_GRAAL_RUNTIME_HPP -#include "code/stubs.hpp" #include "interpreter/interpreter.hpp" #include "memory/allocation.hpp" #include "runtime/deoptimization.hpp" -// A GraalStubAssembler is a MacroAssembler w/ extra functionality for runtime -// stubs. Currently it 'knows' some stub info. Eventually, the information -// may be set automatically or can be asserted when using specialised -// GraalStubAssembler functions. - -class GraalStubAssembler: public MacroAssembler { - private: - const char* _name; - bool _must_gc_arguments; - int _frame_size; - int _num_rt_args; - int _stub_id; - - public: - - enum { - no_frame_size = -1 - }; - - // creation - GraalStubAssembler(CodeBuffer* code, const char * name, int stub_id); - void set_info(const char* name, bool must_gc_arguments); - - void set_frame_size(int size); - void set_num_rt_args(int args); - - // accessors - const char* name() const { return _name; } - bool must_gc_arguments() const { return _must_gc_arguments; } - int frame_size() const { return _frame_size; } - int num_rt_args() const { return _num_rt_args; } - int stub_id() const { return _stub_id; } - - // runtime calls (return offset of call to be used by GC map) - int call_RT(Register oop_result1, Register metadata_result, address entry, int args_size = 0); - int call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1); - int call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2); - int call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2, Register arg3); - int call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2, Register arg3, Register arg4); -}; - -// set frame size and return address offset to these values in blobs -// (if the compiled frame uses ebp as link pointer on IA; otherwise, -// the frame size must be fixed) - -// Holds all assembly stubs and VM -// runtime routines needed by code code generated -// by Graal. -#define GRAAL_STUBS(stub, last_entry) \ - stub(monitorenter) \ - stub(monitorexit) \ - stub(vm_error) \ - stub(create_null_pointer_exception) \ - stub(create_out_of_bounds_exception) \ - stub(log_object) \ - stub(log_printf) \ - stub(log_primitive) \ - stub(wb_pre_call) \ - stub(wb_post_call) \ - last_entry(number_of_ids) - -#define DECLARE_STUB_ID(x) x ## _id , -#define DECLARE_LAST_STUB_ID(x) x -#define STUB_NAME(x) #x " GraalRuntime stub", -#define LAST_STUB_NAME(x) #x " GraalRuntime stub" - class GraalRuntime: public AllStatic { - friend class VMStructs; - - public: - enum StubID { - GRAAL_STUBS(DECLARE_STUB_ID, DECLARE_LAST_STUB_ID) - }; - - private: - static CodeBlob* _blobs[number_of_ids]; - static const char* _blob_names[]; - - // stub generation - static void generate_blob_for(BufferBlob* blob, StubID id); - static OopMapSet* generate_code_for(StubID id, GraalStubAssembler* sasm); - static void generate_unwind_exception(GraalStubAssembler *sasm); - - static OopMapSet* generate_stub_call(GraalStubAssembler* sasm, Register result, address entry, - Register arg1 = noreg, Register arg2 = noreg, Register arg3 = noreg); - - // runtime entry points - static void unimplemented_entry(JavaThread* thread, StubID id); - - static void create_null_exception(JavaThread* thread); - static void create_out_of_bounds_exception(JavaThread* thread, jint index); - static void monitorenter(JavaThread* thread, oopDesc* obj, BasicLock* lock); - static void monitorexit (JavaThread* thread, oopDesc* obj, BasicLock* lock); - static void vm_error(JavaThread* thread, oop where, oop format, jlong value); - static void log_printf(JavaThread* thread, oop format, jlong v1, jlong v2, jlong v3); - static void log_primitive(JavaThread* thread, jchar typeChar, jlong value, jboolean newline); - static void wb_pre_call(JavaThread* thread, oopDesc* obj); - static void wb_post_call(JavaThread* thread, oopDesc* obj, void* card); - - - // Note: Must be kept in sync with constants in com.oracle.graal.replacements.Log - enum { - LOG_OBJECT_NEWLINE = 0x01, - LOG_OBJECT_STRING = 0x02, - LOG_OBJECT_ADDRESS = 0x04 - }; - static void log_object(JavaThread* thread, oop msg, jint flags); - public: static void new_instance(JavaThread* thread, Klass* klass); static void new_array(JavaThread* thread, Klass* klass, jint length); @@ -145,15 +37,22 @@ static void vm_message(jboolean vmError, jlong format, jlong v1, jlong v2, jlong v3); static jint identity_hash_code(JavaThread* thread, oopDesc* objd); static address exception_handler_for_pc(JavaThread* thread); - - // initialization - static void initialize(BufferBlob* blob); - - // stubs - static CodeBlob* blob_for (StubID id); - static address entry_for(StubID id) { return blob_for(id)->code_begin(); } - static const char* name_for (StubID id); - static const char* name_for_address(address entry); + static void monitorenter(JavaThread* thread, oopDesc* obj, BasicLock* lock); + static void monitorexit (JavaThread* thread, oopDesc* obj, BasicLock* lock); + static void create_null_exception(JavaThread* thread); + static void create_out_of_bounds_exception(JavaThread* thread, jint index); + static void vm_error(JavaThread* thread, oop where, oop format, jlong value); + static void log_printf(JavaThread* thread, oop format, jlong v1, jlong v2, jlong v3); + static void log_primitive(JavaThread* thread, jchar typeChar, jlong value, jboolean newline); + // Note: Must be kept in sync with constants in com.oracle.graal.replacements.Log + enum { + LOG_OBJECT_NEWLINE = 0x01, + LOG_OBJECT_STRING = 0x02, + LOG_OBJECT_ADDRESS = 0x04 + }; + static void log_object(JavaThread* thread, oop msg, jint flags); + static void write_barrier_pre(JavaThread* thread, oopDesc* obj); + static void write_barrier_post(JavaThread* thread, oopDesc* obj, void* card); }; #endif // SHARE_VM_GRAAL_GRAAL_RUNTIME_HPP