CodeGenTarget.h revision 327952
1//===- CodeGenTarget.h - Target Class Wrapper -------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// 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 abort 13// on error conditions. 14// 15//===----------------------------------------------------------------------===// 16 17#ifndef LLVM_UTILS_TABLEGEN_CODEGENTARGET_H 18#define LLVM_UTILS_TABLEGEN_CODEGENTARGET_H 19 20#include "CodeGenHwModes.h" 21#include "CodeGenInstruction.h" 22#include "CodeGenRegisters.h" 23#include "InfoByHwMode.h" 24#include "SDNodeProperties.h" 25#include "llvm/Support/raw_ostream.h" 26#include "llvm/TableGen/Record.h" 27#include <algorithm> 28 29namespace llvm { 30 31struct CodeGenRegister; 32class CodeGenSchedModels; 33class CodeGenTarget; 34 35/// getValueType - Return the MVT::SimpleValueType that the specified TableGen 36/// record corresponds to. 37MVT::SimpleValueType getValueType(Record *Rec); 38 39StringRef getName(MVT::SimpleValueType T); 40StringRef getEnumName(MVT::SimpleValueType T); 41 42/// getQualifiedName - Return the name of the specified record, with a 43/// namespace qualifier if the record contains one. 44std::string getQualifiedName(const Record *R); 45 46/// CodeGenTarget - This class corresponds to the Target class in the .td files. 47/// 48class CodeGenTarget { 49 RecordKeeper &Records; 50 Record *TargetRec; 51 52 mutable DenseMap<const Record*, 53 std::unique_ptr<CodeGenInstruction>> Instructions; 54 mutable std::unique_ptr<CodeGenRegBank> RegBank; 55 mutable std::vector<Record*> RegAltNameIndices; 56 mutable SmallVector<ValueTypeByHwMode, 8> LegalValueTypes; 57 CodeGenHwModes CGH; 58 void ReadRegAltNameIndices() const; 59 void ReadInstructions() const; 60 void ReadLegalValueTypes() const; 61 62 mutable std::unique_ptr<CodeGenSchedModels> SchedModels; 63 64 mutable std::vector<const CodeGenInstruction*> InstrsByEnum; 65public: 66 CodeGenTarget(RecordKeeper &Records); 67 ~CodeGenTarget(); 68 69 Record *getTargetRecord() const { return TargetRec; } 70 const StringRef getName() const; 71 72 /// getInstNamespace - Return the target-specific instruction namespace. 73 /// 74 StringRef getInstNamespace() const; 75 76 /// getInstructionSet - Return the InstructionSet object. 77 /// 78 Record *getInstructionSet() const; 79 80 /// getAsmParser - Return the AssemblyParser definition for this target. 81 /// 82 Record *getAsmParser() const; 83 84 /// getAsmParserVariant - Return the AssmblyParserVariant definition for 85 /// this target. 86 /// 87 Record *getAsmParserVariant(unsigned i) const; 88 89 /// getAsmParserVariantCount - Return the AssmblyParserVariant definition 90 /// available for this target. 91 /// 92 unsigned getAsmParserVariantCount() const; 93 94 /// getAsmWriter - Return the AssemblyWriter definition for this target. 95 /// 96 Record *getAsmWriter() const; 97 98 /// getRegBank - Return the register bank description. 99 CodeGenRegBank &getRegBank() const; 100 101 /// getRegisterByName - If there is a register with the specific AsmName, 102 /// return it. 103 const CodeGenRegister *getRegisterByName(StringRef Name) const; 104 105 const std::vector<Record*> &getRegAltNameIndices() const { 106 if (RegAltNameIndices.empty()) ReadRegAltNameIndices(); 107 return RegAltNameIndices; 108 } 109 110 const CodeGenRegisterClass &getRegisterClass(Record *R) const { 111 return *getRegBank().getRegClass(R); 112 } 113 114 /// getRegisterVTs - Find the union of all possible SimpleValueTypes for the 115 /// specified physical register. 116 std::vector<ValueTypeByHwMode> getRegisterVTs(Record *R) const; 117 118 ArrayRef<ValueTypeByHwMode> getLegalValueTypes() const { 119 if (LegalValueTypes.empty()) 120 ReadLegalValueTypes(); 121 return LegalValueTypes; 122 } 123 124 CodeGenSchedModels &getSchedModels() const; 125 126 const CodeGenHwModes &getHwModes() const { return CGH; } 127 128private: 129 DenseMap<const Record*, std::unique_ptr<CodeGenInstruction>> & 130 getInstructions() const { 131 if (Instructions.empty()) ReadInstructions(); 132 return Instructions; 133 } 134public: 135 136 CodeGenInstruction &getInstruction(const Record *InstRec) const { 137 if (Instructions.empty()) ReadInstructions(); 138 auto I = Instructions.find(InstRec); 139 assert(I != Instructions.end() && "Not an instruction"); 140 return *I->second; 141 } 142 143 /// getInstructionsByEnumValue - Return all of the instructions defined by the 144 /// target, ordered by their enum value. 145 ArrayRef<const CodeGenInstruction *> 146 getInstructionsByEnumValue() const { 147 if (InstrsByEnum.empty()) ComputeInstrsByEnum(); 148 return InstrsByEnum; 149 } 150 151 typedef ArrayRef<const CodeGenInstruction *>::const_iterator inst_iterator; 152 inst_iterator inst_begin() const{return getInstructionsByEnumValue().begin();} 153 inst_iterator inst_end() const { return getInstructionsByEnumValue().end(); } 154 155 156 /// isLittleEndianEncoding - are instruction bit patterns defined as [0..n]? 157 /// 158 bool isLittleEndianEncoding() const; 159 160 /// reverseBitsForLittleEndianEncoding - For little-endian instruction bit 161 /// encodings, reverse the bit order of all instructions. 162 void reverseBitsForLittleEndianEncoding(); 163 164 /// guessInstructionProperties - should we just guess unset instruction 165 /// properties? 166 bool guessInstructionProperties() const; 167 168private: 169 void ComputeInstrsByEnum() const; 170}; 171 172/// ComplexPattern - ComplexPattern info, corresponding to the ComplexPattern 173/// tablegen class in TargetSelectionDAG.td 174class ComplexPattern { 175 MVT::SimpleValueType Ty; 176 unsigned NumOperands; 177 std::string SelectFunc; 178 std::vector<Record*> RootNodes; 179 unsigned Properties; // Node properties 180 unsigned Complexity; 181public: 182 ComplexPattern(Record *R); 183 184 MVT::SimpleValueType getValueType() const { return Ty; } 185 unsigned getNumOperands() const { return NumOperands; } 186 const std::string &getSelectFunc() const { return SelectFunc; } 187 const std::vector<Record*> &getRootNodes() const { 188 return RootNodes; 189 } 190 bool hasProperty(enum SDNP Prop) const { return Properties & (1 << Prop); } 191 unsigned getComplexity() const { return Complexity; } 192}; 193 194} // End llvm namespace 195 196#endif 197