com.oracle.graal.compiler.sparc

Class SPARCLIRGenerator

java.lang.Object

com.oracle.graal.lir.gen.LIRGenerator

com.oracle.graal.compiler.sparc.SPARCLIRGenerator

All Implemented Interfaces:

ArithmeticLIRGenerator, BenchmarkCounterFactory, LIRGeneratorTool

Direct Known Subclasses:

SPARCHotSpotLIRGenerator

public abstract class SPARCLIRGenerator
extends LIRGenerator

This class implements the SPARC specific portion of the LIR generator.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	SPARCLIRGenerator.SPARCSpillMoveFactory

Nested classes/interfaces inherited from class com.oracle.graal.lir.gen.LIRGenerator

LIRGenerator.Options

Nested classes/interfaces inherited from interface com.oracle.graal.lir.gen.LIRGeneratorTool

LIRGeneratorTool.BlockScope, LIRGeneratorTool.SpillMoveFactory

Field Summary

Fields

Modifier and Type	Field and Description
private Variable	constantTableBase
private SPARCLoadConstantTableBaseOp	loadConstantTableBaseOp
private SPARCLIRGenerator.SPARCSpillMoveFactory	moveFactory
private StackSlotValue	tmpStackSlot
(package private) boolean	useConstantTableBase

Constructor Summary

Constructors

Constructor and Description
SPARCLIRGenerator(LIRKindTool lirKindTool, Providers providers, CallingConvention cc, LIRGenerationResult lirGenRes)

Method Summary

Modifier and Type	Method and Description
protected SPARCAddressValue	asAddressValue(Value address)
void	beforeRegisterAllocation() Called just before register allocation is performed on the LIR owned by this generator.
boolean	canInlineConstant(JavaConstant c) Checks whether the supplied constant can be used without loading it into a register for most operations, i.e., for commonly used arithmetic, logical, and comparison operations.
protected SPARCLIRInstruction	createMove(AllocatableValue dst, Value src)
protected LIRInstruction	createStackMove(AllocatableValue result, Value input)
Variable	emitAdd(LIRKind resultKind, Value a, Value b, boolean setFlags)
Variable	emitAddress(StackSlotValue address)
Variable	emitAnd(Value a, Value b)
Variable	emitArrayEquals(Kind kind, Value array1, Value array2, Value length)
private Variable	emitBinary(LIRKind resultKind, SPARCArithmetic op, boolean commutative, Value a, Value b)
private Variable	emitBinary(LIRKind resultKind, SPARCArithmetic op, boolean commutative, Value a, Value b, LIRFrameState state)
private Variable	emitBinaryConst(LIRKind resultKind, SPARCArithmetic op, AllocatableValue a, JavaConstant b, LIRFrameState state)
private Variable	emitBinaryVar(LIRKind resultKind, SPARCArithmetic op, AllocatableValue a, AllocatableValue b, LIRFrameState state)
Variable	emitBitCount(Value operand)
Variable	emitBitScanForward(Value operand)
Variable	emitBitScanReverse(Value operand)
Variable	emitByteSwap(Value input)
protected boolean	emitCompare(PlatformKind cmpKind, Value a, Value b) This method emits the compare instruction, and may reorder the operands.
void	emitCompareBranch(PlatformKind cmpKind, Value x, Value y, Condition cond, boolean unorderedIsTrue, LabelRef trueDestination, LabelRef falseDestination, double trueDestinationProbability)
Variable	emitConditionalMove(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, Value trueValue, Value falseValue)
private AllocatableValue	emitConvert2Op(LIRKind kind, SPARCArithmetic op, AllocatableValue input)
private AllocatableValue	emitConvertMove(LIRKind kind, AllocatableValue input)
void	emitData(AllocatableValue dst, byte[] data) Emits an op that loads the address of some raw data.
void	emitDeoptimize(Value actionAndReason, Value speculation, LIRFrameState state)
Value	emitDiv(Value a, Value b, LIRFrameState state)
Value	emitFloatConvert(FloatConvert op, Value inputVal)
protected void	emitForeignCallOp(ForeignCallLinkage linkage, Value result, Value[] arguments, Value[] temps, LIRFrameState info) Emits the single call operation at the heart of generating LIR for a foreign call.
private void	emitIntegerTest(Value a, Value b)
void	emitIntegerTestBranch(Value left, Value right, LabelRef trueDestination, LabelRef falseDestination, double trueDestinationProbability)
Variable	emitIntegerTestMove(Value left, Value right, Value trueValue, Value falseValue)
void	emitJump(LabelRef label)
void	emitLoadConstantTableBase()
Value	emitMathAbs(Value input)
Value	emitMathSqrt(Value input)
void	emitMembar(int barriers)
void	emitMove(AllocatableValue dst, Value src)
Variable	emitMul(Value a, Value b, boolean setFlags)
private Value	emitMulHigh(SPARCArithmetic opcode, Value a, Value b)
Value	emitMulHigh(Value a, Value b)
Value	emitNarrow(Value inputVal, int bits)
Value	emitNegate(Value input)
Value	emitNot(Value input)
void	emitNullCheck(Value address, LIRFrameState state)
Variable	emitOr(Value a, Value b)
void	emitOverflowCheckBranch(LabelRef overflow, LabelRef noOverflow, LIRKind cmpLIRKind, double overflowProbability)
AllocatableValue	emitReinterpret(LIRKind to, Value inputVal)
Value	emitRem(Value a, Value b, LIRFrameState state)
void	emitReturn(Value input) Emits a return instruction.
private Variable	emitShift(SPARCArithmetic op, Value a, Value b)
Variable	emitShl(Value a, Value b)
Variable	emitShr(Value a, Value b)
Value	emitSignExtend(Value inputVal, int fromBits, int toBits)
Value	emitSignExtendLoad(LIRKind kind, Value address, LIRFrameState state)
void	emitStrategySwitch(SwitchStrategy strategy, Variable key, LabelRef[] keyTargets, LabelRef defaultTarget)
Variable	emitSub(LIRKind resultKind, Value a, Value b, boolean setFlags)
protected void	emitTableSwitch(int lowKey, LabelRef defaultTarget, LabelRef[] targets, Value key)
Value	emitUDiv(Value a, Value b, LIRFrameState state)
Value	emitUMulHigh(Value a, Value b)
private Variable	emitUnary(SPARCArithmetic op, Value input)
Value	emitURem(Value a, Value b, LIRFrameState state)
Variable	emitUShr(Value a, Value b)
Variable	emitXor(Value a, Value b)
Value	emitZeroExtend(Value inputVal, int fromBits, int toBits)
protected SPARC	getArchitecture()
protected Variable	getConstantTableBase()
LIRGeneratorTool.SpillMoveFactory	getSpillMoveFactory()
private StackSlotValue	getTempSlot(LIRKind kind)
private Value	loadSimm11(Value value)
private void	moveBetweenFpGp(AllocatableValue dst, AllocatableValue src)

Methods inherited from class com.oracle.graal.lir.gen.LIRGenerator

append, asAllocatable, attributes, createBenchmarkCounter, createMultiBenchmarkCounter, emitAdd, emitBlackhole, emitForeignCall, emitIncomingValues, emitLoadConstant, emitMove, emitStrategySwitch, emitSub, getAddressKind, getBlockScope, getCallingConvention, getCodeCache, getCurrentBlock, getForeignCalls, getLIRKind, getLIRKindTool, getMetaAccess, getProviders, getResult, hasBlockEnd, load, loadNonConst, needOnlyOopMaps, newVariable, resultOperandFor, target, toStackKind, zapValueForKind

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.oracle.graal.lir.gen.LIRGeneratorTool

emitAtomicReadAndAdd, emitAtomicReadAndWrite, emitCompareAndSwap, emitCountLeadingZeros, emitCountTrailingZeros, emitLoad, emitStore, emitUnwind

Field Detail

tmpStackSlot

private StackSlotValue tmpStackSlot

moveFactory

private SPARCLIRGenerator.SPARCSpillMoveFactory moveFactory

constantTableBase

private Variable constantTableBase

loadConstantTableBaseOp

private SPARCLoadConstantTableBaseOp loadConstantTableBaseOp

useConstantTableBase

boolean useConstantTableBase

Constructor Detail

SPARCLIRGenerator

public SPARCLIRGenerator(LIRKindTool lirKindTool,
                         Providers providers,
                         CallingConvention cc,
                         LIRGenerationResult lirGenRes)

Method Detail

getSpillMoveFactory

public LIRGeneratorTool.SpillMoveFactory getSpillMoveFactory()

canInlineConstant

public boolean canInlineConstant(JavaConstant c)

Description copied from class: LIRGenerator

Checks whether the supplied constant can be used without loading it into a register for most operations, i.e., for commonly used arithmetic, logical, and comparison operations.

Specified by:

canInlineConstant in class LIRGenerator

Parameters:

c - The constant to check.

Returns:

True if the constant can be used directly, false if the constant needs to be in a register.

createMove

protected SPARCLIRInstruction createMove(AllocatableValue dst,
                                         Value src)

createStackMove

protected LIRInstruction createStackMove(AllocatableValue result,
                                         Value input)

emitMove

public void emitMove(AllocatableValue dst,
                     Value src)

emitData

public void emitData(AllocatableValue dst,
                     byte[] data)

Description copied from interface: LIRGeneratorTool

Emits an op that loads the address of some raw data.

Parameters:

dst - the variable into which the address is loaded

data - the data to be installed with the generated code

asAddressValue

protected SPARCAddressValue asAddressValue(Value address)

emitAddress

public Variable emitAddress(StackSlotValue address)

emitReturn

public void emitReturn(Value input)

Description copied from interface: LIRGeneratorTool

Emits a return instruction. Implementations need to insert a move if the input is not in the correct location.

emitJump

public void emitJump(LabelRef label)

Specified by:

emitJump in interface LIRGeneratorTool

Specified by:

emitJump in class LIRGenerator

emitCompareBranch

public void emitCompareBranch(PlatformKind cmpKind,
                              Value x,
                              Value y,
                              Condition cond,
                              boolean unorderedIsTrue,
                              LabelRef trueDestination,
                              LabelRef falseDestination,
                              double trueDestinationProbability)

Specified by:

emitCompareBranch in interface LIRGeneratorTool

Specified by:

emitCompareBranch in class LIRGenerator

emitOverflowCheckBranch

public void emitOverflowCheckBranch(LabelRef overflow,
                                    LabelRef noOverflow,
                                    LIRKind cmpLIRKind,
                                    double overflowProbability)

Specified by:

emitOverflowCheckBranch in interface LIRGeneratorTool

Specified by:

emitOverflowCheckBranch in class LIRGenerator

emitIntegerTestBranch

public void emitIntegerTestBranch(Value left,
                                  Value right,
                                  LabelRef trueDestination,
                                  LabelRef falseDestination,
                                  double trueDestinationProbability)

Specified by:

emitIntegerTestBranch in interface LIRGeneratorTool

Specified by:

emitIntegerTestBranch in class LIRGenerator

emitIntegerTest

private void emitIntegerTest(Value a,
                             Value b)

loadSimm11

private Value loadSimm11(Value value)

emitConditionalMove

public Variable emitConditionalMove(PlatformKind cmpKind,
                                    Value left,
                                    Value right,
                                    Condition cond,
                                    boolean unorderedIsTrue,
                                    Value trueValue,
                                    Value falseValue)

Specified by:

emitConditionalMove in interface LIRGeneratorTool

Specified by:

emitConditionalMove in class LIRGenerator

emitCompare

protected boolean emitCompare(PlatformKind cmpKind,
                              Value a,
                              Value b)

This method emits the compare instruction, and may reorder the operands. It returns true if it did so.

Parameters:

cmpKind - Kind how a and b have to be compared

a - the left operand of the comparison

b - the right operand of the comparison

Returns:

true if the left and right operands were switched, false otherwise

emitIntegerTestMove

public Variable emitIntegerTestMove(Value left,
                                    Value right,
                                    Value trueValue,
                                    Value falseValue)

Specified by:

emitIntegerTestMove in interface LIRGeneratorTool

Specified by:

emitIntegerTestMove in class LIRGenerator

emitForeignCallOp

protected void emitForeignCallOp(ForeignCallLinkage linkage,
                                 Value result,
                                 Value[] arguments,
                                 Value[] temps,
                                 LIRFrameState info)

Description copied from class: LIRGenerator

Emits the single call operation at the heart of generating LIR for a foreign call.

Specified by:

emitForeignCallOp in class LIRGenerator

emitStrategySwitch

public void emitStrategySwitch(SwitchStrategy strategy,
                               Variable key,
                               LabelRef[] keyTargets,
                               LabelRef defaultTarget)

Specified by:

emitStrategySwitch in interface LIRGeneratorTool

Specified by:

emitStrategySwitch in class LIRGenerator

emitTableSwitch

protected void emitTableSwitch(int lowKey,
                               LabelRef defaultTarget,
                               LabelRef[] targets,
                               Value key)

Specified by:

emitTableSwitch in class LIRGenerator

emitBitCount

public Variable emitBitCount(Value operand)

emitBitScanForward

public Variable emitBitScanForward(Value operand)

emitBitScanReverse

public Variable emitBitScanReverse(Value operand)

emitMathAbs

public Value emitMathAbs(Value input)

emitMathSqrt

public Value emitMathSqrt(Value input)

emitByteSwap

public Variable emitByteSwap(Value input)

emitArrayEquals

public Variable emitArrayEquals(Kind kind,
                                Value array1,
                                Value array2,
                                Value length)

emitNegate

public Value emitNegate(Value input)

emitNot

public Value emitNot(Value input)

emitUnary

private Variable emitUnary(SPARCArithmetic op,
                           Value input)

emitBinary

private Variable emitBinary(LIRKind resultKind,
                            SPARCArithmetic op,
                            boolean commutative,
                            Value a,
                            Value b)

emitBinary

private Variable emitBinary(LIRKind resultKind,
                            SPARCArithmetic op,
                            boolean commutative,
                            Value a,
                            Value b,
                            LIRFrameState state)

emitBinaryConst

private Variable emitBinaryConst(LIRKind resultKind,
                                 SPARCArithmetic op,
                                 AllocatableValue a,
                                 JavaConstant b,
                                 LIRFrameState state)

emitBinaryVar

private Variable emitBinaryVar(LIRKind resultKind,
                               SPARCArithmetic op,
                               AllocatableValue a,
                               AllocatableValue b,
                               LIRFrameState state)

emitAdd

public Variable emitAdd(LIRKind resultKind,
                        Value a,
                        Value b,
                        boolean setFlags)

Specified by:

emitAdd in class LIRGenerator

emitSub

public Variable emitSub(LIRKind resultKind,
                        Value a,
                        Value b,
                        boolean setFlags)

Specified by:

emitSub in class LIRGenerator

emitMul

public Variable emitMul(Value a,
                        Value b,
                        boolean setFlags)

emitMulHigh

public Value emitMulHigh(Value a,
                         Value b)

emitUMulHigh

public Value emitUMulHigh(Value a,
                          Value b)

emitMulHigh

private Value emitMulHigh(SPARCArithmetic opcode,
                          Value a,
                          Value b)

emitDiv

public Value emitDiv(Value a,
                     Value b,
                     LIRFrameState state)

emitRem

public Value emitRem(Value a,
                     Value b,
                     LIRFrameState state)

emitURem

public Value emitURem(Value a,
                      Value b,
                      LIRFrameState state)

emitUDiv

public Value emitUDiv(Value a,
                      Value b,
                      LIRFrameState state)

emitAnd

public Variable emitAnd(Value a,
                        Value b)

emitOr

public Variable emitOr(Value a,
                       Value b)

emitXor

public Variable emitXor(Value a,
                        Value b)

emitShift

private Variable emitShift(SPARCArithmetic op,
                           Value a,
                           Value b)

emitShl

public Variable emitShl(Value a,
                        Value b)

emitShr

public Variable emitShr(Value a,
                        Value b)

emitUShr

public Variable emitUShr(Value a,
                         Value b)

emitConvertMove

private AllocatableValue emitConvertMove(LIRKind kind,
                                         AllocatableValue input)

emitConvert2Op

private AllocatableValue emitConvert2Op(LIRKind kind,
                                        SPARCArithmetic op,
                                        AllocatableValue input)

emitFloatConvert

public Value emitFloatConvert(FloatConvert op,
                              Value inputVal)

moveBetweenFpGp

private void moveBetweenFpGp(AllocatableValue dst,
                             AllocatableValue src)

getTempSlot

private StackSlotValue getTempSlot(LIRKind kind)

getArchitecture

protected SPARC getArchitecture()

emitNarrow

public Value emitNarrow(Value inputVal,
                        int bits)

emitSignExtend

public Value emitSignExtend(Value inputVal,
                            int fromBits,
                            int toBits)

emitZeroExtend

public Value emitZeroExtend(Value inputVal,
                            int fromBits,
                            int toBits)

emitReinterpret

public AllocatableValue emitReinterpret(LIRKind to,
                                        Value inputVal)

emitMembar

public void emitMembar(int barriers)

emitDeoptimize

public void emitDeoptimize(Value actionAndReason,
                           Value speculation,
                           LIRFrameState state)

emitSignExtendLoad

public Value emitSignExtendLoad(LIRKind kind,
                                Value address,
                                LIRFrameState state)

emitNullCheck

public void emitNullCheck(Value address,
                          LIRFrameState state)

emitLoadConstantTableBase

public void emitLoadConstantTableBase()

getConstantTableBase

protected Variable getConstantTableBase()

beforeRegisterAllocation

public void beforeRegisterAllocation()

Description copied from interface: LIRGeneratorTool

Called just before register allocation is performed on the LIR owned by this generator. Overriding implementations of this method must call the overridden method.

Specified by:

beforeRegisterAllocation in interface LIRGeneratorTool

Overrides:

beforeRegisterAllocation in class LIRGenerator