mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-11-04 05:17:07 +00:00
054c1f6cb6
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4328 91177308-0d34-0410-b5e6-96231b3b80d8
355 lines
13 KiB
C++
355 lines
13 KiB
C++
//===-- llvm/CodeGen/InstrSelectionSupport.h --------------------*- C++ -*-===//
|
|
//
|
|
// Target-independent instruction selection code. See SparcInstrSelection.cpp
|
|
// for usage.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CODEGEN_INSTR_SELECTION_SUPPORT_H
|
|
#define LLVM_CODEGEN_INSTR_SELECTION_SUPPORT_H
|
|
|
|
#include "llvm/Instruction.h"
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
|
#include "Support/DataTypes.h"
|
|
class InstructionNode;
|
|
class TargetMachine;
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Function GetConstantValueAsUnsignedInt
|
|
// Function GetConstantValueAsSignedInt
|
|
//
|
|
// Convenience functions to get the value of an integer constant, for an
|
|
// appropriate integer or non-integer type that can be held in a signed
|
|
// or unsigned integer respectively. The type of the argument must be
|
|
// the following:
|
|
// Signed or unsigned integer
|
|
// Boolean
|
|
// Pointer
|
|
//
|
|
// isValidConstant is set to true if a valid constant was found.
|
|
//---------------------------------------------------------------------------
|
|
|
|
uint64_t GetConstantValueAsUnsignedInt (const Value *V,
|
|
bool &isValidConstant);
|
|
|
|
int64_t GetConstantValueAsSignedInt (const Value *V,
|
|
bool &isValidConstant);
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Function: GetMemInstArgs
|
|
//
|
|
// Purpose:
|
|
// Get the pointer value and the index vector for a memory operation
|
|
// (GetElementPtr, Load, or Store). If all indices of the given memory
|
|
// operation are constant, fold in constant indices in a chain of
|
|
// preceding GetElementPtr instructions (if any), and return the
|
|
// pointer value of the first instruction in the chain.
|
|
// All folded instructions are marked so no code is generated for them.
|
|
//
|
|
// Return values:
|
|
// Returns the pointer Value to use.
|
|
// Returns the resulting IndexVector in idxVec.
|
|
// Returns true/false in allConstantIndices if all indices are/aren't const.
|
|
//---------------------------------------------------------------------------
|
|
|
|
Value* GetMemInstArgs (InstructionNode* memInstrNode,
|
|
std::vector<Value*>& idxVec,
|
|
bool& allConstantIndices);
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
// Function Set2OperandsFromInstr
|
|
// Function Set3OperandsFromInstr
|
|
//
|
|
// Purpose:
|
|
//
|
|
// For the common case of 2- and 3-operand arithmetic/logical instructions,
|
|
// set the m/c instr. operands directly from the VM instruction's operands.
|
|
// Check whether the first or second operand is 0 and can use a dedicated
|
|
// "0" register.
|
|
// Check whether the second operand should use an immediate field or register.
|
|
// (First and third operands are never immediates for such instructions.)
|
|
//
|
|
// Arguments:
|
|
// canDiscardResult: Specifies that the result operand can be discarded
|
|
// by using the dedicated "0"
|
|
//
|
|
// op1position, op2position and resultPosition: Specify in which position
|
|
// in the machine instruction the 3 operands (arg1, arg2
|
|
// and result) should go.
|
|
//
|
|
// RETURN VALUE: unsigned int flags, where
|
|
// flags & 0x01 => operand 1 is constant and needs a register
|
|
// flags & 0x02 => operand 2 is constant and needs a register
|
|
//------------------------------------------------------------------------
|
|
|
|
void Set2OperandsFromInstr (MachineInstr* minstr,
|
|
InstructionNode* vmInstrNode,
|
|
const TargetMachine& targetMachine,
|
|
bool canDiscardResult = false,
|
|
int op1Position = 0,
|
|
int resultPosition = 1);
|
|
|
|
void Set3OperandsFromInstr (MachineInstr* minstr,
|
|
InstructionNode* vmInstrNode,
|
|
const TargetMachine& targetMachine,
|
|
bool canDiscardResult = false,
|
|
int op1Position = 0,
|
|
int op2Position = 1,
|
|
int resultPosition = 2);
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
// Common machine instruction operand combinations
|
|
// to simplify code generation.
|
|
//------------------------------------------------------------------------
|
|
|
|
inline MachineInstr*
|
|
Create1OperandInstr(MachineOpCode opCode, Value* argVal1)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create1OperandInstr_UImmed(MachineOpCode opCode, unsigned int unextendedImmed)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandConst(0, MachineOperand::MO_UnextendedImmed,
|
|
unextendedImmed);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create1OperandInstr_SImmed(MachineOpCode opCode, int signExtendedImmed)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandConst(0, MachineOperand::MO_SignExtendedImmed,
|
|
signExtendedImmed);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create1OperandInstr_Addr(MachineOpCode opCode, Value* label)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, MachineOperand::MO_PCRelativeDisp, label);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create2OperandInstr(MachineOpCode opCode, Value* argVal1, Value* argVal2)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
|
|
M->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, argVal2);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create2OperandInstr(MachineOpCode opCode,
|
|
Value* argVal1, MachineOperand::MachineOperandType type1,
|
|
Value* argVal2, MachineOperand::MachineOperandType type2)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, type1, argVal1);
|
|
M->SetMachineOperandVal(1, type2, argVal2);
|
|
return M;
|
|
}
|
|
|
|
|
|
inline MachineInstr*
|
|
Create2OperandInstr_UImmed(MachineOpCode opCode,
|
|
unsigned int unextendedImmed, Value* argVal2)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandConst(0, MachineOperand::MO_UnextendedImmed,
|
|
unextendedImmed);
|
|
M->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, argVal2);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create2OperandInstr_SImmed(MachineOpCode opCode,
|
|
int signExtendedImmed, Value* argVal2)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandConst(0, MachineOperand::MO_SignExtendedImmed,
|
|
signExtendedImmed);
|
|
M->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, argVal2);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create2OperandInstr_Addr(MachineOpCode opCode,
|
|
Value* label, Value* argVal2)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, MachineOperand::MO_PCRelativeDisp, label);
|
|
M->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, argVal2);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create2OperandInstr_Reg(MachineOpCode opCode,
|
|
Value* argVal1, unsigned int regNum)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
|
|
M->SetMachineOperandReg(1, regNum);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create2OperandInstr_Reg(MachineOpCode opCode,
|
|
unsigned int regNum1, unsigned int regNum2)
|
|
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandReg(0, regNum1);
|
|
M->SetMachineOperandReg(1, regNum2);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create3OperandInstr(MachineOpCode opCode,
|
|
Value* argVal1, MachineOperand::MachineOperandType type1,
|
|
Value* argVal2, MachineOperand::MachineOperandType type2,
|
|
Value* argVal3, MachineOperand::MachineOperandType type3)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, type1, argVal1);
|
|
M->SetMachineOperandVal(1, type2, argVal2);
|
|
M->SetMachineOperandVal(2, type3, argVal3);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create3OperandInstr(MachineOpCode opCode, Value* argVal1,
|
|
Value* argVal2, Value* argVal3)
|
|
{
|
|
return Create3OperandInstr(opCode,
|
|
argVal1, MachineOperand::MO_VirtualRegister,
|
|
argVal2, MachineOperand::MO_VirtualRegister,
|
|
argVal3, MachineOperand::MO_VirtualRegister);
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create3OperandInstr_UImmed(MachineOpCode opCode, Value* argVal1,
|
|
unsigned int unextendedImmed, Value* argVal3)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
|
|
M->SetMachineOperandConst(1, MachineOperand::MO_UnextendedImmed,
|
|
unextendedImmed);
|
|
M->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister, argVal3);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create3OperandInstr_SImmed(MachineOpCode opCode, Value* argVal1,
|
|
int signExtendedImmed, Value* argVal3)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
|
|
M->SetMachineOperandConst(1, MachineOperand::MO_SignExtendedImmed,
|
|
signExtendedImmed);
|
|
M->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister, argVal3);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create3OperandInstr_Addr(MachineOpCode opCode, Value* argVal1,
|
|
Value* label, Value* argVal3)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
|
|
M->SetMachineOperandVal(1, MachineOperand::MO_PCRelativeDisp, label);
|
|
M->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister, argVal3);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create3OperandInstr_Reg(MachineOpCode opCode, Value* argVal1,
|
|
unsigned int regNum, Value* argVal3)
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
|
|
M->SetMachineOperandReg(1, regNum);
|
|
M->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister, argVal3);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create3OperandInstr_Reg(MachineOpCode opCode, unsigned int regNum1,
|
|
unsigned int regNum2, Value* argVal3)
|
|
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandReg(0, regNum1);
|
|
M->SetMachineOperandReg(1, regNum2);
|
|
M->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister, argVal3);
|
|
return M;
|
|
}
|
|
|
|
inline MachineInstr*
|
|
Create3OperandInstr_Reg(MachineOpCode opCode, unsigned int regNum1,
|
|
unsigned int regNum2, unsigned int regNum3)
|
|
|
|
{
|
|
MachineInstr* M = new MachineInstr(opCode);
|
|
M->SetMachineOperandReg(0, regNum1);
|
|
M->SetMachineOperandReg(1, regNum2);
|
|
M->SetMachineOperandReg(2, regNum3);
|
|
return M;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Function: ChooseRegOrImmed
|
|
//
|
|
// Purpose:
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
MachineOperand::MachineOperandType ChooseRegOrImmed(
|
|
Value* val,
|
|
MachineOpCode opCode,
|
|
const TargetMachine& targetMachine,
|
|
bool canUseImmed,
|
|
unsigned int& getMachineRegNum,
|
|
int64_t& getImmedValue);
|
|
|
|
MachineOperand::MachineOperandType ChooseRegOrImmed(int64_t intValue,
|
|
bool isSigned,
|
|
MachineOpCode opCode,
|
|
const TargetMachine& target,
|
|
bool canUseImmed,
|
|
unsigned int& getMachineRegNum,
|
|
int64_t& getImmedValue);
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Function: FixConstantOperandsForInstr
|
|
//
|
|
// Purpose:
|
|
// Special handling for constant operands of a machine instruction
|
|
// -- if the constant is 0, use the hardwired 0 register, if any;
|
|
// -- if the constant fits in the IMMEDIATE field, use that field;
|
|
// -- else create instructions to put the constant into a register, either
|
|
// directly or by loading explicitly from the constant pool.
|
|
//
|
|
// In the first 2 cases, the operand of `minstr' is modified in place.
|
|
// Returns a vector of machine instructions generated for operands that
|
|
// fall under case 3; these must be inserted before `minstr'.
|
|
//---------------------------------------------------------------------------
|
|
|
|
std::vector<MachineInstr*> FixConstantOperandsForInstr (Instruction* vmInstr,
|
|
MachineInstr* minstr,
|
|
TargetMachine& target);
|
|
|
|
#endif
|