replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Eliminate 'BasicNode' from InstrForest. 

llvm-svn: 551
This commit is contained in:
Chris Lattner 2001-09-11 23:52:11 +00:00
parent 706ee8e5ec
commit cc38da77e8
5 changed files with 61 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
llvm/include/llvm/CodeGen/InstrForest.h
View File

@ -78,36 +78,26 @@ const int ToPointerTy = ToBoolTy + 12;
typedef int OpLabel;
typedef int StateLabel;
struct BasicTreeNode {
BasicTreeNode* leftChild;
BasicTreeNode* rightChild;
BasicTreeNode* parent;
OpLabel opLabel;
StateLabel state;
InstrTreeNode *treeNodePtr; // points to the C++ tree node object
// that "contains" this node
};
//-------------------------------------------------------------------------
// Declarations of data and functions created by BURG
//-------------------------------------------------------------------------
extern short* burm_nts[];
extern StateLabel burm_label (BasicTreeNode* p);
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 BasicTreeNode** burm_kids (BasicTreeNode* p, int eruleno,
BasicTreeNode* kids[]);
extern InstrTreeNode** burm_kids (InstrTreeNode* p, int eruleno,
InstrTreeNode* kids[]);
extern void printcover (BasicTreeNode*, int, int);
extern void printtree (BasicTreeNode*);
extern int treecost (BasicTreeNode*, int, int);
extern void printMatches (BasicTreeNode*);
extern void printcover (InstrTreeNode*, int, int);
extern void printtree (InstrTreeNode*);
extern int treecost (InstrTreeNode*, int, int);
extern void printMatches (InstrTreeNode*);
//------------------------------------------------------------------------
@ -125,8 +115,15 @@ public:
NTConstNode,
NTLabelNode };
// BASIC TREE NODE START
InstrTreeNode* LeftChild;
InstrTreeNode* RightChild;
InstrTreeNode* Parent;
OpLabel opLabel;
StateLabel state;
// BASIC TREE NODE END
protected:
BasicTreeNode basicNode;
InstrTreeNodeType treeNodeType;
Value* val;
@ -135,30 +132,25 @@ public:
Value* _val);
/*dtor*/ virtual ~InstrTreeNode () {}
BasicTreeNode* getBasicNode () { return &basicNode; }
InstrTreeNodeType getNodeType () const { return treeNodeType; }
Value* getValue () const { return val; }
inline OpLabel getOpLabel () const { return basicNode.opLabel; }
inline OpLabel getOpLabel () const { return opLabel; }
inline InstrTreeNode* leftChild () const {
return (basicNode.leftChild? basicNode.leftChild->treeNodePtr : NULL);
return LeftChild;
}
// If right child is a list node, recursively get its *left* child
inline InstrTreeNode* rightChild () const {
return (InstrTreeNode*)
(basicNode.rightChild
? (basicNode.rightChild->treeNodePtr->getOpLabel() == VRegListOp
? basicNode.rightChild->treeNodePtr->leftChild()
: basicNode.rightChild->treeNodePtr)
: NULL);
inline InstrTreeNode* rightChild() const {
return (!RightChild ? 0 :
(RightChild->getOpLabel() == VRegListOp
? RightChild->LeftChild : RightChild));
}
inline InstrTreeNode* parent () const {
return (basicNode.parent? basicNode.parent->treeNodePtr : NULL);
inline InstrTreeNode *parent() const {
return Parent;
}
void dump (int dumpChildren,

61
llvm/lib/CodeGen/InstrSelection/InstrForest.cpp
View File

@ -38,23 +38,16 @@
//------------------------------------------------------------------------
InstrTreeNode::InstrTreeNode(InstrTreeNodeType nodeType,
Value* _val)
: treeNodeType(nodeType),
val(_val)
{
basicNode.leftChild = NULL;
basicNode.rightChild = NULL;
basicNode.parent = NULL;
basicNode.opLabel = InvalidOp;
basicNode.treeNodePtr = this;
InstrTreeNode::InstrTreeNode(InstrTreeNodeType nodeType, Value* _val)
: treeNodeType(nodeType), val(_val) {
LeftChild = 0;
RightChild = 0;
Parent = 0;
opLabel = InvalidOp;
}
void
InstrTreeNode::dump(int dumpChildren,
int indent) const
{
this->dumpNode(indent);
void InstrTreeNode::dump(int dumpChildren, int indent) const {
dumpNode(indent);
if (dumpChildren)
{
@ -122,7 +115,7 @@ InstructionNode::InstructionNode(Instruction* _instr)
}
}
basicNode.opLabel = opLabel;
this->opLabel = opLabel;
}
@ -148,10 +141,8 @@ InstructionNode::dumpNode(int indent) const
}
VRegListNode::VRegListNode()
: InstrTreeNode(NTVRegListNode, NULL)
{
basicNode.opLabel = VRegListOp;
VRegListNode::VRegListNode() : InstrTreeNode(NTVRegListNode, 0) {
opLabel = VRegListOp;
}
void
@ -164,10 +155,8 @@ VRegListNode::dumpNode(int indent) const
}
VRegNode::VRegNode(Value* _val)
: InstrTreeNode(NTVRegNode, _val)
{
basicNode.opLabel = VRegNodeOp;
VRegNode::VRegNode(Value* _val) : InstrTreeNode(NTVRegNode, _val) {
opLabel = VRegNodeOp;
}
void
@ -181,10 +170,9 @@ VRegNode::dumpNode(int indent) const
}
ConstantNode::ConstantNode(ConstPoolVal* constVal)
: InstrTreeNode(NTConstNode, constVal)
{
basicNode.opLabel = ConstantNodeOp;
ConstantNode::ConstantNode(ConstPoolVal *constVal)
: InstrTreeNode(NTConstNode, constVal) {
opLabel = ConstantNodeOp;
}
void
@ -198,10 +186,8 @@ ConstantNode::dumpNode(int indent) const
}
LabelNode::LabelNode(BasicBlock* _bblock)
: InstrTreeNode(NTLabelNode, _bblock)
{
basicNode.opLabel = LabelNodeOp;
LabelNode::LabelNode(BasicBlock *BB) : InstrTreeNode(NTLabelNode, BB) {
opLabel = LabelNodeOp;
}
void
@ -255,10 +241,9 @@ InstrForest::noteTreeNodeForInstr(Instruction* instr,
inline void
InstrForest::setLeftChild(InstrTreeNode* parent, InstrTreeNode* child)
{
parent->basicNode.leftChild = & child->basicNode;
child->basicNode.parent = & parent->basicNode;
InstrForest::setLeftChild(InstrTreeNode* parent, InstrTreeNode* child) {
parent->LeftChild = child;
child->Parent = parent;
if (child->getNodeType() == InstrTreeNode::NTInstructionNode)
treeRoots.erase((InstructionNode*) child); // no longer a tree root
}
@ -267,8 +252,8 @@ InstrForest::setLeftChild(InstrTreeNode* parent, InstrTreeNode* child)
inline void
InstrForest::setRightChild(InstrTreeNode* parent, InstrTreeNode* child)
{
parent->basicNode.rightChild = & child->basicNode;
child->basicNode.parent = & parent->basicNode;
parent->RightChild = child;
child->Parent = parent;
if (child->getNodeType() == InstrTreeNode::NTInstructionNode)
treeRoots.erase((InstructionNode*) child); // no longer a tree root
}

29
llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
View File

@ -10,30 +10,19 @@
//**************************************************************************/
//************************** System Include Files ***************************/
//*************************** User Include Files ***************************/
#include "llvm/CodeGen/InstrSelection.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Type.h"
#include "llvm/iMemory.h"
#include "llvm/Instruction.h"
#include "llvm/BasicBlock.h"
#include "llvm/Method.h"
#include "llvm/CodeGen/MachineInstr.h"
//************************* Forward Declarations ***************************/
static bool SelectInstructionsForTree(BasicTreeNode* treeRoot,
int goalnt,
static bool SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
TargetMachine &Target);
//************************* Internal Data Types *****************************/
enum SelectDebugLevel_t {
Select_NoDebugInfo,
Select_PrintMachineCode,
@ -50,8 +39,6 @@ cl::Enum<enum SelectDebugLevel_t> SelectDebugLevel("dselect", cl::NoFlags, // cl
clEnumValN(Select_DebugBurgTrees, "b", "print burg trees"), 0);
//************************** External Functions ****************************/
//---------------------------------------------------------------------------
// Entry point for instruction selection using BURG.
@ -87,7 +74,7 @@ SelectInstructionsForMethod(Method* method,
treeRootIter != treeRoots.end();
++treeRootIter)
{
BasicTreeNode* basicNode = (*treeRootIter)->getBasicNode();
InstrTreeNode* basicNode = *treeRootIter;
// Invoke BURM to label each tree node with a state
(void) burm_label(basicNode);
@ -192,8 +179,7 @@ FoldGetElemChain(const InstructionNode* getElemInstrNode,
//---------------------------------------------------------------------------
bool
SelectInstructionsForTree(BasicTreeNode* treeRoot,
int goalnt,
SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
TargetMachine &Target)
{
// Use a static vector to avoid allocating a new one per VM instruction
@ -220,7 +206,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
//
if (treeRoot->opLabel != VRegListOp)
{
InstructionNode* instrNode = (InstructionNode*)treeRoot->treeNodePtr;
InstructionNode* instrNode = (InstructionNode*)treeRoot;
assert(instrNode->getNodeType() == InstrTreeNode::NTInstructionNode);
unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, Target,
@ -238,7 +224,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
if (nts[0])
{ // i.e., there is at least one kid
BasicTreeNode* kids[2];
InstrTreeNode* kids[2];
int currentRule = ruleForNode;
burm_kids(treeRoot, currentRule, kids);
@ -258,8 +244,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
for (int i = 0; nts[i]; i++)
{
assert(i < 2);
InstrTreeNode::InstrTreeNodeType
nodeType = kids[i]->treeNodePtr->getNodeType();
InstrTreeNode::InstrTreeNodeType nodeType = kids[i]->getNodeType();
if (nodeType == InstrTreeNode::NTVRegListNode ||
nodeType == InstrTreeNode::NTInstructionNode)
{

6
llvm/lib/CodeGen/TargetMachine/Sparc/Sparc.burg
View File

@ -2,10 +2,10 @@
#include <stdio.h>
#include <llvm/CodeGen/InstrForest.h>
typedef BasicTreeNode* NODEPTR_TYPE;
typedef InstrTreeNode* NODEPTR_TYPE;
#define OP_LABEL(p) ((p)->opLabel)
#define LEFT_CHILD(p) ((p)->leftChild)
#define RIGHT_CHILD(p) ((p)->rightChild)
#define LEFT_CHILD(p) ((p)->LeftChild)
#define RIGHT_CHILD(p) ((p)->RightChild)
#define STATE_LABEL(p) ((p)->state)
#define PANIC printf
%}

15
llvm/lib/CodeGen/TargetMachine/Sparc/SparcInstrSelection.cpp
View File

@ -9,23 +9,18 @@
// 7/02/01 - Vikram Adve - Created
//**************************************************************************/
#include "llvm/CodeGen/Sparc.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/InstrForest.h"
#include "llvm/CodeGen/InstrSelection.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Type.h"
#include "llvm/DerivedTypes.h"
#include "llvm/SymbolTable.h"
#include "llvm/Value.h"
#include "llvm/Instruction.h"
#include "llvm/InstrTypes.h"
#include "llvm/iTerminators.h"
#include "llvm/iMemory.h"
#include "llvm/iOther.h"
#include "llvm/BasicBlock.h"
#include "llvm/Method.h"
#include "llvm/ConstPoolVals.h"
#include "llvm/CodeGen/Sparc.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/InstrForest.h"
#include "llvm/CodeGen/InstrSelection.h"
//******************** Internal Data Declarations ************************/
@ -1982,7 +1977,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
assert(ThisIsAChainRule(ruleForNode));
assert(nts[0] && ! nts[1]
&& "A chain rule should have only one RHS non-terminal!");
nextRule = burm_rule(subtreeRoot->getBasicNode()->state, nts[0]);
nextRule = burm_rule(subtreeRoot->state, nts[0]);
nts = burm_nts[nextRule];
numInstr = GetInstructionsByRule(subtreeRoot, nextRule, nts,target,mvec);
break;