/*
* $Id$
*
* Copyright (C) 2003-2014 JNode.org
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; If not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
package org.jnode.vm.x86.compiler.l1a;
import org.jnode.assembler.NativeStream;
import org.jnode.assembler.ObjectResolver;
import org.jnode.assembler.x86.X86BinaryAssembler;
import org.jnode.vm.classmgr.VmClassLoader;
import org.jnode.vm.classmgr.VmMethod;
import org.jnode.vm.compiler.CompiledMethod;
import org.jnode.vm.compiler.CompilerBytecodeVisitor;
import org.jnode.vm.compiler.EntryPoints;
import org.jnode.vm.compiler.GCMapIterator;
import org.jnode.vm.compiler.InlineBytecodeVisitor;
import org.jnode.vm.compiler.OptimizingBytecodeVisitor;
import org.jnode.vm.isolate.VmIsolateLocal;
import org.jnode.vm.scheduler.VmProcessor;
import org.jnode.vm.x86.X86CpuID;
import org.jnode.vm.x86.compiler.AbstractX86Compiler;
import static org.jnode.vm.x86.compiler.X86CompilerConstants.L1A_COMPILER_MAGIC;
/**
* Native code compiler for the Intel x86 architecture.
* <p/>
* <pre>
* <p/>
* <p/>
* <p/>
* <p/>
* <p/>
* HIGH VALUES first-arg ... last-arg old EIP old EBP magic method local 0 ... local n calculation stack LOW VALUES
* <p/>
* <p/>
* <p/>
* <p/>
* <p/>
* <p/>
* <h1>
* <p/>
* <p/>
* <p/>
* <p/>
* long entries
* <p/>
* <p/>
* <p/>
* <p/>
* </h1>
* <p/>
* <p/>
* <p/>
* <p/>
* <p/>
* PUSH: MSB, LSB POP: LSB, MSB
* <p/>
* <p/>
* <p/>
* <p/>
* <p/>
* </pre>
*/
public final class X86Level1ACompiler extends AbstractX86Compiler {
/**
* Should this compiler try to inline methods?
*/
private final boolean inlineMethods = true;
private final VmIsolateLocal<MagicHelper> magicHelperHolder = new VmIsolateLocal<MagicHelper>();
/**
* Initialize this instance.
*/
public X86Level1ACompiler() {
}
private final ThreadLocal<X86BytecodeVisitor> byteCodeVisitorHolder = new ThreadLocal<X86BytecodeVisitor>();
/**
* Create the visitor that converts bytecodes into native code.
*
* @param method
* @param cm
* @param os
* @param level
* @param isBootstrap
* @return The new bytecode visitor.
*/
protected CompilerBytecodeVisitor createBytecodeVisitor(VmMethod method,
CompiledMethod cm, NativeStream os, int level,
boolean isBootstrap) {
final InlineBytecodeVisitor cbv;
final EntryPoints entryPoints = getEntryPoints();
X86BytecodeVisitor byteCodeVisitor = byteCodeVisitorHolder.get();
if (byteCodeVisitor == null) {
byteCodeVisitor = new X86BytecodeVisitor(os, cm, isBootstrap, entryPoints, getMagicHelper(),
getTypeSizeInfo());
} else {
byteCodeVisitorHolder.remove();
byteCodeVisitor.reset(os, cm, isBootstrap, entryPoints, getMagicHelper(), getTypeSizeInfo());
}
cbv = byteCodeVisitor;
if (inlineMethods) {
final VmClassLoader loader = method.getDeclaringClass().getLoader();
return new OptimizingBytecodeVisitor(entryPoints, cbv, loader);
} else {
return cbv;
}
}
@Override
protected synchronized void releaseBytecodeVisitor(CompilerBytecodeVisitor visitor) {
X86BytecodeVisitor bv;
if (inlineMethods) {
bv = (X86BytecodeVisitor) ((OptimizingBytecodeVisitor) visitor).getDelegate();
} else {
bv = (X86BytecodeVisitor) visitor;
}
byteCodeVisitorHolder.set(bv);
}
private MagicHelper getMagicHelper() {
final MagicHelper helper = magicHelperHolder.get();
if (helper != null) {
return helper;
} else {
magicHelperHolder.set(new MagicHelper());
return magicHelperHolder.get();
}
}
/**
* Create a native stream for the current architecture.
*
* @param resolver
* @return NativeStream
*/
public NativeStream createNativeStream(ObjectResolver resolver) {
X86CpuID cpuid = (X86CpuID) VmProcessor.current().getCPUID();
X86BinaryAssembler os = new X86BinaryAssembler(cpuid, getMode(), 0);
os.setResolver(resolver);
return os;
}
/**
* @see org.jnode.vm.compiler.NativeCodeCompiler#getMagic()
*/
public final int getMagic() {
return L1A_COMPILER_MAGIC;
}
/**
* Gets the name of this compiler.
*
* @return The name of this compiler
*/
public String getName() {
return "X86-L1A";
}
/**
* @see org.jnode.vm.compiler.NativeCodeCompiler#createGCMapIterator()
*/
@Override
public GCMapIterator createGCMapIterator() {
return new X86GCMapIterator();
}
/**
* @see org.jnode.vm.compiler.NativeCodeCompiler#getCompilerPackages()
*/
@Override
public String[] getCompilerPackages() {
return new String[]{"org.jnode.vm.x86.compiler", "org.jnode.vm.x86.compiler.l1a"};
}
}