CodeGenTarget.h revision 2618d07765e94ca12c68c9db31e7843cc69d7178
1//===- CodeGenTarget.h - Target Class Wrapper -------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines wrappers for the Target class and related global 11// functionality. This makes it easier to access the data and provides a single 12// place that needs to check it for validity. All of these classes throw 13// exceptions on error conditions. 14// 15//===----------------------------------------------------------------------===// 16 17#ifndef CODEGEN_TARGET_H 18#define CODEGEN_TARGET_H 19 20#include "CodeGenRegisters.h" 21#include "CodeGenInstruction.h" 22#include <iosfwd> 23#include <map> 24 25namespace llvm { 26 27class Record; 28class RecordKeeper; 29struct CodeGenRegister; 30class CodeGenTarget; 31 32/// getValueType - Return the MVT::ValueType that the specified TableGen record 33/// corresponds to. 34MVT::ValueType getValueType(Record *Rec, const CodeGenTarget *CGT = 0); 35 36std::ostream &operator<<(std::ostream &OS, MVT::ValueType T); 37std::string getName(MVT::ValueType T); 38std::string getEnumName(MVT::ValueType T); 39 40 41/// CodeGenTarget - This class corresponds to the Target class in the .td files. 42/// 43class CodeGenTarget { 44 Record *TargetRec; 45 std::vector<Record*> CalleeSavedRegisters; 46 47 mutable std::map<std::string, CodeGenInstruction> Instructions; 48 mutable std::vector<CodeGenRegister> Registers; 49 mutable std::vector<CodeGenRegisterClass> RegisterClasses; 50 mutable std::vector<MVT::ValueType> LegalValueTypes; 51 void ReadRegisters() const; 52 void ReadRegisterClasses() const; 53 void ReadInstructions() const; 54 void ReadLegalValueTypes() const; 55public: 56 CodeGenTarget(); 57 58 Record *getTargetRecord() const { return TargetRec; } 59 const std::string &getName() const; 60 61 const std::vector<Record*> &getCalleeSavedRegisters() const { 62 return CalleeSavedRegisters; 63 } 64 65 /// getInstructionSet - Return the InstructionSet object. 66 /// 67 Record *getInstructionSet() const; 68 69 /// getAsmWriter - Return the AssemblyWriter definition for this target. 70 /// 71 Record *getAsmWriter() const; 72 73 const std::vector<CodeGenRegister> &getRegisters() const { 74 if (Registers.empty()) ReadRegisters(); 75 return Registers; 76 } 77 78 const std::vector<CodeGenRegisterClass> &getRegisterClasses() const { 79 if (RegisterClasses.empty()) ReadRegisterClasses(); 80 return RegisterClasses; 81 } 82 83 const CodeGenRegisterClass &getRegisterClass(Record *R) const { 84 const std::vector<CodeGenRegisterClass> &RC = getRegisterClasses(); 85 for (unsigned i = 0, e = RC.size(); i != e; ++i) 86 if (RC[i].TheDef == R) 87 return RC[i]; 88 assert(0 && "Didn't find the register class"); 89 abort(); 90 } 91 92 /// getRegisterClassForRegister - Find the register class that contains the 93 /// specified physical register. If there register exists in multiple 94 /// register classes or is not in a register class, return null. 95 const CodeGenRegisterClass *getRegisterClassForRegister(Record *R) const { 96 const std::vector<CodeGenRegisterClass> &RCs = getRegisterClasses(); 97 const CodeGenRegisterClass *FoundRC = 0; 98 for (unsigned i = 0, e = RCs.size(); i != e; ++i) { 99 const CodeGenRegisterClass &RC = RegisterClasses[i]; 100 for (unsigned ei = 0, ee = RC.Elements.size(); ei != ee; ++ei) { 101 if (R == RC.Elements[ei]) { 102 if (FoundRC) return 0; // In multiple RC's 103 FoundRC = &RC; 104 break; 105 } 106 } 107 } 108 return FoundRC; 109 } 110 111 /// getRegisterVTs - Find the union of all possible ValueTypes for the 112 /// specified physical register. 113 std::vector<unsigned char> getRegisterVTs(Record *R) const; 114 115 const std::vector<MVT::ValueType> &getLegalValueTypes() const { 116 if (LegalValueTypes.empty()) ReadLegalValueTypes(); 117 return LegalValueTypes; 118 } 119 120 /// isLegalValueType - Return true if the specified value type is natively 121 /// supported by the target (i.e. there are registers that directly hold it). 122 bool isLegalValueType(MVT::ValueType VT) const { 123 const std::vector<MVT::ValueType> &LegalVTs = getLegalValueTypes(); 124 for (unsigned i = 0, e = LegalVTs.size(); i != e; ++i) 125 if (LegalVTs[i] == VT) return true; 126 return false; 127 } 128 129 /// getInstructions - Return all of the instructions defined for this target. 130 /// 131 const std::map<std::string, CodeGenInstruction> &getInstructions() const { 132 if (Instructions.empty()) ReadInstructions(); 133 return Instructions; 134 } 135 136 CodeGenInstruction &getInstruction(const std::string &Name) const { 137 const std::map<std::string, CodeGenInstruction> &Insts = getInstructions(); 138 assert(Insts.count(Name) && "Not an instruction!"); 139 return const_cast<CodeGenInstruction&>(Insts.find(Name)->second); 140 } 141 142 typedef std::map<std::string, 143 CodeGenInstruction>::const_iterator inst_iterator; 144 inst_iterator inst_begin() const { return getInstructions().begin(); } 145 inst_iterator inst_end() const { return Instructions.end(); } 146 147 /// getInstructionsByEnumValue - Return all of the instructions defined by the 148 /// target, ordered by their enum value. 149 void getInstructionsByEnumValue(std::vector<const CodeGenInstruction*> 150 &NumberedInstructions); 151 152 153 /// isLittleEndianEncoding - are instruction bit patterns defined as [0..n]? 154 /// 155 bool isLittleEndianEncoding() const; 156}; 157 158/// ComplexPattern - ComplexPattern info, corresponding to the ComplexPattern 159/// tablegen class in TargetSelectionDAG.td 160class ComplexPattern { 161 MVT::ValueType Ty; 162 unsigned NumOperands; 163 std::string SelectFunc; 164 std::vector<Record*> RootNodes; 165public: 166 ComplexPattern() : NumOperands(0) {}; 167 ComplexPattern(Record *R); 168 169 MVT::ValueType getValueType() const { return Ty; } 170 unsigned getNumOperands() const { return NumOperands; } 171 const std::string &getSelectFunc() const { return SelectFunc; } 172 const std::vector<Record*> &getRootNodes() const { 173 return RootNodes; 174 } 175}; 176 177} // End llvm namespace 178 179#endif 180