mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-26 04:32:44 +01:00
c83118d53f
Needs to be bottom up because constant values may be forward-substituted to their uses (i.e., into the parent in the BURG tree). 2. Move most of the constant-fixup code into machine-indepedent file InstrSelectionSupport.cpp. llvm-svn: 860
141 lines
5.1 KiB
C++
141 lines
5.1 KiB
C++
// $Id$ -*-c++-*-
|
|
//***************************************************************************
|
|
// File:
|
|
// InstrSelectionSupport.h
|
|
//
|
|
// Purpose:
|
|
// Target-independent instruction selection code.
|
|
// See SparcInstrSelection.cpp for usage.
|
|
//
|
|
// History:
|
|
// 10/10/01 - Vikram Adve - Created
|
|
//**************************************************************************/
|
|
|
|
#ifndef LLVM_CODEGEN_INSTR_SELECTION_SUPPORT_H
|
|
#define LLVM_CODEGEN_INSTR_SELECTION_SUPPORT_H
|
|
|
|
#include "llvm/Instruction.h"
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
|
class Method;
|
|
class InstrForest;
|
|
class MachineInstr;
|
|
class InstructionNode;
|
|
class TmpInstruction;
|
|
class ConstPoolVal;
|
|
class TargetMachine;
|
|
|
|
//************************ Exported Functions ******************************/
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Function GetConstantValueAsSignedInt
|
|
//
|
|
// Convenience function to get the value of an integer constant, for an
|
|
// appropriate integer or non-integer type that can be held in an integer.
|
|
// 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.
|
|
//---------------------------------------------------------------------------
|
|
|
|
int64_t GetConstantValueAsSignedInt (const Value *V,
|
|
bool &isValidConstant);
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Function: FoldGetElemChain
|
|
//
|
|
// Purpose:
|
|
// Fold a chain of GetElementPtr instructions into an equivalent
|
|
// (Pointer, IndexVector) pair. Returns the pointer Value, and
|
|
// stores the resulting IndexVector in argument chainIdxVec.
|
|
//---------------------------------------------------------------------------
|
|
|
|
Value* FoldGetElemChain (const InstructionNode* getElemInstrNode,
|
|
vector<ConstPoolVal*>& chainIdxVec);
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
// 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);
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Function: ChooseRegOrImmed
|
|
//
|
|
// Purpose:
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
MachineOperand::MachineOperandType
|
|
ChooseRegOrImmed (Value* val,
|
|
MachineOpCode opCode,
|
|
const TargetMachine& targetMachine,
|
|
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'.
|
|
//---------------------------------------------------------------------------
|
|
|
|
vector<MachineInstr*> FixConstantOperandsForInstr (Instruction* vmInstr,
|
|
MachineInstr* minstr,
|
|
TargetMachine& target);
|
|
|
|
|
|
//**************************************************************************/
|
|
|
|
#endif
|