mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 20:23:11 +01:00
135 lines
4.8 KiB
C++
135 lines
4.8 KiB
C++
//===- SparcV9InstrForest.h - SparcV9 BURG Instruction Selector Trees -----===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// A forest of BURG instruction trees (class InstrForest) which represents
|
|
// a function to the BURG-based instruction selector, and a bunch of constants
|
|
// and declarations used by the generated BURG code.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SPARCV9INSTRFOREST_H
|
|
#define SPARCV9INSTRFOREST_H
|
|
|
|
#include "llvm/Instruction.h"
|
|
using namespace llvm;
|
|
|
|
/// OpLabel values for special-case nodes created for instruction selection.
|
|
/// All op-labels not defined here are identical to the instruction
|
|
/// opcode returned by Instruction::getOpcode().
|
|
///
|
|
static const int
|
|
InvalidOp = -1,
|
|
VRegListOp = 97,
|
|
VRegNodeOp = 98,
|
|
ConstantNodeOp = 99,
|
|
LabelNodeOp = 100,
|
|
RetValueOp = 100 + Instruction::Ret, // 101
|
|
BrCondOp = 100 + Instruction::Br, // 102
|
|
BAndOp = 100 + Instruction::And, // 111
|
|
BOrOp = 100 + Instruction::Or, // 112
|
|
BXorOp = 100 + Instruction::Xor, // 113
|
|
BNotOp = 200 + Instruction::Xor, // 213
|
|
NotOp = 300 + Instruction::Xor, // 313
|
|
SetCCOp = 100 + Instruction::SetEQ, // 114
|
|
AllocaN = 100 + Instruction::Alloca, // 122
|
|
LoadIdx = 100 + Instruction::Load, // 123
|
|
GetElemPtrIdx = 100 + Instruction::GetElementPtr, // 125
|
|
ToBoolTy = 100 + Instruction::Cast; // 127
|
|
static const int
|
|
ToUByteTy = ToBoolTy + 1,
|
|
ToSByteTy = ToBoolTy + 2,
|
|
ToUShortTy = ToBoolTy + 3,
|
|
ToShortTy = ToBoolTy + 4,
|
|
ToUIntTy = ToBoolTy + 5,
|
|
ToIntTy = ToBoolTy + 6,
|
|
ToULongTy = ToBoolTy + 7,
|
|
ToLongTy = ToBoolTy + 8,
|
|
ToFloatTy = ToBoolTy + 9,
|
|
ToDoubleTy = ToBoolTy + 10,
|
|
ToArrayTy = ToBoolTy + 11,
|
|
ToPointerTy = ToBoolTy + 12;
|
|
|
|
/// Data types needed by BURG
|
|
///
|
|
typedef int OpLabel;
|
|
typedef int StateLabel;
|
|
|
|
/// Declarations of data and functions created by BURG
|
|
///
|
|
namespace llvm {
|
|
class InstrTreeNode;
|
|
};
|
|
extern short* burm_nts[];
|
|
extern StateLabel burm_label (InstrTreeNode* p);
|
|
extern StateLabel burm_state (OpLabel op, StateLabel leftState,
|
|
StateLabel rightState);
|
|
extern StateLabel burm_rule (StateLabel state, int goalNT);
|
|
extern InstrTreeNode** burm_kids (InstrTreeNode* p, int eruleno,
|
|
InstrTreeNode* kids[]);
|
|
extern void printcover (InstrTreeNode*, int, int);
|
|
extern void printtree (InstrTreeNode*);
|
|
extern int treecost (InstrTreeNode*, int, int);
|
|
extern void printMatches (InstrTreeNode*);
|
|
|
|
namespace llvm {
|
|
|
|
/// InstrTreeNode - A single tree node in the instruction tree used for
|
|
/// instruction selection via BURG.
|
|
///
|
|
class InstrTreeNode {
|
|
InstrTreeNode(const InstrTreeNode &); // DO NOT IMPLEMENT
|
|
void operator=(const InstrTreeNode &); // DO NOT IMPLEMENT
|
|
public:
|
|
enum InstrTreeNodeType { NTInstructionNode,
|
|
NTVRegListNode,
|
|
NTVRegNode,
|
|
NTConstNode,
|
|
NTLabelNode };
|
|
InstrTreeNode* LeftChild;
|
|
InstrTreeNode* RightChild;
|
|
InstrTreeNode* Parent;
|
|
OpLabel opLabel;
|
|
StateLabel state;
|
|
|
|
protected:
|
|
InstrTreeNodeType treeNodeType;
|
|
Value* val;
|
|
|
|
public:
|
|
InstrTreeNode(InstrTreeNodeType nodeType, Value* _val)
|
|
: treeNodeType(nodeType), val(_val) {
|
|
LeftChild = RightChild = Parent = 0;
|
|
opLabel = InvalidOp;
|
|
}
|
|
virtual ~InstrTreeNode() {
|
|
delete LeftChild;
|
|
delete RightChild;
|
|
}
|
|
InstrTreeNodeType getNodeType () const { return treeNodeType; }
|
|
Value* getValue () const { return val; }
|
|
inline OpLabel getOpLabel () const { return opLabel; }
|
|
inline InstrTreeNode *leftChild () const { return LeftChild; }
|
|
inline InstrTreeNode *parent () const { return Parent; }
|
|
|
|
// If right child is a list node, recursively get its *left* child
|
|
inline InstrTreeNode* rightChild() const {
|
|
return (!RightChild ? 0 :
|
|
(RightChild->getOpLabel() == VRegListOp
|
|
? RightChild->LeftChild : RightChild));
|
|
}
|
|
void dump(int dumpChildren, int indent) const;
|
|
protected:
|
|
virtual void dumpNode(int indent) const = 0;
|
|
friend class InstrForest;
|
|
};
|
|
|
|
} // end namespace llvm.
|
|
|
|
#endif
|