From: Brian Gaeke Date: Wed, 4 Aug 2004 07:37:56 +0000 (+0000) Subject: These headers have been moved/merged into other files. X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=826b19b4ec213806e9791bd8de1f5ee556283efa;p=oota-llvm.git These headers have been moved/merged into other files. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15477 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/CodeGen/InstrForest.h b/include/llvm/CodeGen/InstrForest.h deleted file mode 100644 index 48266715bd1..00000000000 --- a/include/llvm/CodeGen/InstrForest.h +++ /dev/null @@ -1,339 +0,0 @@ -//===-- llvm/CodeGen/InstForest.h -------------------------------*- C++ -*-===// -// -// 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. -// -//===----------------------------------------------------------------------===// -// -// Purpose: -// Convert SSA graph to instruction trees for instruction selection. -// -// Strategy: -// The basic idea is that we would like to group instructions into a single -// tree if one or more of them might be potentially combined into a single -// complex instruction in the target machine. -// Since this grouping is completely machine-independent, it is as -// aggressive as possible. In particular, we group two instructions -// O and I if: -// (1) Instruction O computes an operand of instruction I, and -// (2) O and I are part of the same basic block, and -// (3) O has only a single use, viz., I. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_CODEGEN_INSTRFOREST_H -#define LLVM_CODEGEN_INSTRFOREST_H - -#include "llvm/Instruction.h" -#include "Support/hash_map" - -namespace llvm { - -class Constant; -class Function; -class InstrTreeNode; -class InstrForest; - -} // End llvm namespace - -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() -//-------------------------------------------------------------------------- -// - - -const int InvalidOp = -1; -const int VRegListOp = 97; -const int VRegNodeOp = 98; -const int ConstantNodeOp= 99; -const int LabelNodeOp = 100; - -const int RetValueOp = 100 + Instruction::Ret; // 101 -const int BrCondOp = 100 + Instruction::Br; // 102 - -const int BAndOp = 100 + Instruction::And; // 111 -const int BOrOp = 100 + Instruction::Or; // 112 -const int BXorOp = 100 + Instruction::Xor; // 113 -const int BNotOp = 200 + Instruction::Xor; // 213 -const int NotOp = 300 + Instruction::Xor; // 313 - -const int SetCCOp = 100 + Instruction::SetEQ; // 114 - -const int AllocaN = 100 + Instruction::Alloca; // 122 -const int LoadIdx = 100 + Instruction::Load; // 123 -const int GetElemPtrIdx= 100 + Instruction::GetElementPtr; // 125 - -const int ToBoolTy = 100 + Instruction::Cast; // 127 -const int ToUByteTy = ToBoolTy + 1; -const int ToSByteTy = ToBoolTy + 2; -const int ToUShortTy = ToBoolTy + 3; -const int ToShortTy = ToBoolTy + 4; -const int ToUIntTy = ToBoolTy + 5; -const int ToIntTy = ToBoolTy + 6; -const int ToULongTy = ToBoolTy + 7; -const int ToLongTy = ToBoolTy + 8; -const int ToFloatTy = ToBoolTy + 9; -const int ToDoubleTy = ToBoolTy + 10; -const int ToArrayTy = ToBoolTy + 11; -const int ToPointerTy = ToBoolTy + 12; - -//------------------------------------------------------------------------- -// Data types needed by BURG and implemented by us -//------------------------------------------------------------------------- - -typedef int OpLabel; -typedef int StateLabel; - -//------------------------------------------------------------------------- -// Declarations of data and functions created by BURG -//------------------------------------------------------------------------- - -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 { - -//------------------------------------------------------------------------ -// class 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 }; - - // BASIC TREE NODE START - InstrTreeNode* LeftChild; - InstrTreeNode* RightChild; - InstrTreeNode* Parent; - OpLabel opLabel; - StateLabel state; - // BASIC TREE NODE END - -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; - } - - // 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)); - } - - inline InstrTreeNode *parent() const { - return Parent; - } - - void dump(int dumpChildren, int indent) const; - -protected: - virtual void dumpNode(int indent) const = 0; - - friend class InstrForest; -}; - - -class InstructionNode : public InstrTreeNode { -private: - bool codeIsFoldedIntoParent; - -public: - InstructionNode(Instruction *_instr); - - Instruction *getInstruction() const { - assert(treeNodeType == NTInstructionNode); - return cast(val); - } - - void markFoldedIntoParent() { codeIsFoldedIntoParent = true; } - bool isFoldedIntoParent() { return codeIsFoldedIntoParent; } - - // Methods to support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const InstructionNode *N) { return true; } - static inline bool classof(const InstrTreeNode *N) { - return N->getNodeType() == InstrTreeNode::NTInstructionNode; - } - -protected: - virtual void dumpNode(int indent) const; -}; - - -class VRegListNode : public InstrTreeNode { -public: - VRegListNode() : InstrTreeNode(NTVRegListNode, 0) { - opLabel = VRegListOp; - } - - // Methods to support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const VRegListNode *N) { return true; } - static inline bool classof(const InstrTreeNode *N) { - return N->getNodeType() == InstrTreeNode::NTVRegListNode; - } - -protected: - virtual void dumpNode(int indent) const; -}; - - -class VRegNode : public InstrTreeNode { -public: - VRegNode(Value* _val) : InstrTreeNode(NTVRegNode, _val) { - opLabel = VRegNodeOp; - } - - // Methods to support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const VRegNode *N) { return true; } - static inline bool classof(const InstrTreeNode *N) { - return N->getNodeType() == InstrTreeNode::NTVRegNode; - } - -protected: - virtual void dumpNode(int indent) const; -}; - - -class ConstantNode : public InstrTreeNode { -public: - ConstantNode(Constant *constVal) - : InstrTreeNode(NTConstNode, (Value*)constVal) { - opLabel = ConstantNodeOp; - } - Constant *getConstVal() const { return (Constant*) val;} - - // Methods to support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const ConstantNode *N) { return true; } - static inline bool classof(const InstrTreeNode *N) { - return N->getNodeType() == InstrTreeNode::NTConstNode; - } - -protected: - virtual void dumpNode(int indent) const; -}; - - -class LabelNode : public InstrTreeNode { -public: - LabelNode(BasicBlock* BB) : InstrTreeNode(NTLabelNode, (Value*)BB) { - opLabel = LabelNodeOp; - } - - BasicBlock *getBasicBlock() const { return (BasicBlock*)val;} - - // Methods to support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const LabelNode *N) { return true; } - static inline bool classof(const InstrTreeNode *N) { - return N->getNodeType() == InstrTreeNode::NTLabelNode; - } - -protected: - virtual void dumpNode(int indent) const; -}; - - -//------------------------------------------------------------------------ -// class InstrForest -// -// A forest of instruction trees, usually for a single method. -// -// Methods: -// buildTreesForMethod() Builds the forest of trees for a method -// getTreeNodeForInstr() Returns the tree node for an Instruction -// getRootSet() Returns a set of root nodes for all the trees -// -//------------------------------------------------------------------------ - -class InstrForest : private hash_map { -public: - // Use a vector for the root set to get a deterministic iterator - // for stable code generation. Even though we need to erase nodes - // during forest construction, a vector should still be efficient - // because the elements to erase are nearly always near the end. - typedef std::vector RootSet; - typedef RootSet:: iterator root_iterator; - typedef RootSet::const_iterator const_root_iterator; - -private: - RootSet treeRoots; - -public: - /*ctor*/ InstrForest (Function *F); - /*dtor*/ ~InstrForest (); - - inline InstructionNode *getTreeNodeForInstr(Instruction* instr) { - return (*this)[instr]; - } - - const_root_iterator roots_begin() const { return treeRoots.begin(); } - root_iterator roots_begin() { return treeRoots.begin(); } - const_root_iterator roots_end () const { return treeRoots.end(); } - root_iterator roots_end () { return treeRoots.end(); } - - void dump() const; - -private: - // - // Private methods for buidling the instruction forest - // - void eraseRoot (InstructionNode* node); - void setLeftChild (InstrTreeNode* parent, InstrTreeNode* child); - void setRightChild(InstrTreeNode* parent, InstrTreeNode* child); - void setParent (InstrTreeNode* child, InstrTreeNode* parent); - void noteTreeNodeForInstr(Instruction* instr, InstructionNode* treeNode); - - InstructionNode* buildTreeForInstruction(Instruction* instr); -}; - -} // End llvm namespace - -#endif diff --git a/include/llvm/CodeGen/InstrSelection.h b/include/llvm/CodeGen/InstrSelection.h deleted file mode 100644 index 7b3ddd09195..00000000000 --- a/include/llvm/CodeGen/InstrSelection.h +++ /dev/null @@ -1,110 +0,0 @@ -//===-- llvm/CodeGen/InstrSelection.h ---------------------------*- C++ -*-===// -// -// 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. -// -//===----------------------------------------------------------------------===// -// -// External interface to instruction selection. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_CODEGEN_INSTR_SELECTION_H -#define LLVM_CODEGEN_INSTR_SELECTION_H - -#include "llvm/Instruction.h" - -namespace llvm { - -class Function; -class FunctionPass; -class InstrForest; -class InstructionNode; -class MachineCodeForInstruction; -class MachineInstr; -class TargetMachine; - -//===--------------------- Required Functions --------------------------------- -// Target-dependent functions that MUST be implemented for each target. -// - -extern void GetInstructionsByRule (InstructionNode* subtreeRoot, - int ruleForNode, - short* nts, - TargetMachine &Target, - std::vector& mvec); - -extern bool ThisIsAChainRule (int eruleno); - - - -//--------------------------------------------------------------------------- -// Function: createInstructionSelectionPass -// -// Purpose: -// Entry point for instruction selection using BURG. -// Return a pass that performs machine dependent instruction selection. -//--------------------------------------------------------------------------- - -FunctionPass *createInstructionSelectionPass(TargetMachine &Target); - - - -//--------------------------------------------------------------------------- -// class TmpInstruction -// -// This class represents temporary intermediate values -// used within the machine code for a VM instruction -//--------------------------------------------------------------------------- - -class TmpInstruction : public Instruction { - TmpInstruction(const TmpInstruction &TI) - : Instruction(TI.getType(), TI.getOpcode()) { - if (!TI.Operands.empty()) { - Operands.push_back(Use(TI.Operands[0], this)); - if (TI.Operands.size() == 2) - Operands.push_back(Use(TI.Operands[1], this)); - else - assert(0 && "Bad # operands to TmpInstruction!"); - } - } -public: - // Constructor that uses the type of S1 as the type of the temporary. - // s1 must be a valid value. s2 may be NULL. - TmpInstruction(MachineCodeForInstruction& mcfi, - Value *s1, Value *s2 = 0, const std::string &name = ""); - - // Constructor that uses the type of S1 as the type of the temporary, - // but does not require a MachineCodeForInstruction. - // s1 must be a valid value. s2 may be NULL. - TmpInstruction(Value *s1, Value *s2 = 0, const std::string &name = ""); - - // Constructor that requires the type of the temporary to be specified. - // Both S1 and S2 may be NULL. - TmpInstruction(MachineCodeForInstruction& mcfi, - const Type *Ty, Value *s1 = 0, Value* s2 = 0, - const std::string &name = ""); - - virtual Instruction *clone() const { - assert(0 && "Cannot clone TmpInstructions!"); - return 0; - } - virtual const char *getOpcodeName() const { - return "TempValueForMachineInstr"; - } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const TmpInstruction *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::UserOp1); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -} // End llvm namespace - -#endif