1 //===- InstrInfoEmitter.cpp - Generate a Instruction Set Desc. ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This tablegen backend is responsible for emitting a description of the target
11 // instruction set for the code generator.
13 //===----------------------------------------------------------------------===//
15 #include "InstrInfoEmitter.h"
16 #include "CodeGenTarget.h"
18 #include "llvm/ADT/StringExtras.h"
22 static void PrintDefList(const std::vector
<Record
*> &Uses
,
23 unsigned Num
, raw_ostream
&OS
) {
24 OS
<< "static const unsigned ImplicitList" << Num
<< "[] = { ";
25 for (unsigned i
= 0, e
= Uses
.size(); i
!= e
; ++i
)
26 OS
<< getQualifiedName(Uses
[i
]) << ", ";
30 //===----------------------------------------------------------------------===//
31 // Instruction Itinerary Information.
32 //===----------------------------------------------------------------------===//
34 void InstrInfoEmitter::GatherItinClasses() {
35 std::vector
<Record
*> DefList
=
36 Records
.getAllDerivedDefinitions("InstrItinClass");
37 std::sort(DefList
.begin(), DefList
.end(), LessRecord());
39 for (unsigned i
= 0, N
= DefList
.size(); i
< N
; i
++)
40 ItinClassMap
[DefList
[i
]->getName()] = i
;
43 unsigned InstrInfoEmitter::getItinClassNumber(const Record
*InstRec
) {
44 return ItinClassMap
[InstRec
->getValueAsDef("Itinerary")->getName()];
47 //===----------------------------------------------------------------------===//
48 // Operand Info Emission.
49 //===----------------------------------------------------------------------===//
51 std::vector
<std::string
>
52 InstrInfoEmitter::GetOperandInfo(const CodeGenInstruction
&Inst
) {
53 std::vector
<std::string
> Result
;
55 for (unsigned i
= 0, e
= Inst
.Operands
.size(); i
!= e
; ++i
) {
56 // Handle aggregate operands and normal operands the same way by expanding
57 // either case into a list of operands for this op.
58 std::vector
<CGIOperandList::OperandInfo
> OperandList
;
60 // This might be a multiple operand thing. Targets like X86 have
61 // registers in their multi-operand operands. It may also be an anonymous
62 // operand, which has a single operand, but no declared class for the
64 DagInit
*MIOI
= Inst
.Operands
[i
].MIOperandInfo
;
66 if (!MIOI
|| MIOI
->getNumArgs() == 0) {
67 // Single, anonymous, operand.
68 OperandList
.push_back(Inst
.Operands
[i
]);
70 for (unsigned j
= 0, e
= Inst
.Operands
[i
].MINumOperands
; j
!= e
; ++j
) {
71 OperandList
.push_back(Inst
.Operands
[i
]);
73 Record
*OpR
= dynamic_cast<DefInit
*>(MIOI
->getArg(j
))->getDef();
74 OperandList
.back().Rec
= OpR
;
78 for (unsigned j
= 0, e
= OperandList
.size(); j
!= e
; ++j
) {
79 Record
*OpR
= OperandList
[j
].Rec
;
82 if (OpR
->isSubClassOf("RegisterOperand"))
83 OpR
= OpR
->getValueAsDef("RegClass");
84 if (OpR
->isSubClassOf("RegisterClass"))
85 Res
+= getQualifiedName(OpR
) + "RegClassID, ";
86 else if (OpR
->isSubClassOf("PointerLikeRegClass"))
87 Res
+= utostr(OpR
->getValueAsInt("RegClassKind")) + ", ";
89 // -1 means the operand does not have a fixed register class.
92 // Fill in applicable flags.
95 // Ptr value whose register class is resolved via callback.
96 if (OpR
->isSubClassOf("PointerLikeRegClass"))
97 Res
+= "|(1<<MCOI::LookupPtrRegClass)";
99 // Predicate operands. Check to see if the original unexpanded operand
100 // was of type PredicateOperand.
101 if (Inst
.Operands
[i
].Rec
->isSubClassOf("PredicateOperand"))
102 Res
+= "|(1<<MCOI::Predicate)";
104 // Optional def operands. Check to see if the original unexpanded operand
105 // was of type OptionalDefOperand.
106 if (Inst
.Operands
[i
].Rec
->isSubClassOf("OptionalDefOperand"))
107 Res
+= "|(1<<MCOI::OptionalDef)";
109 // Fill in constraint info.
112 const CGIOperandList::ConstraintInfo
&Constraint
=
113 Inst
.Operands
[i
].Constraints
[j
];
114 if (Constraint
.isNone())
116 else if (Constraint
.isEarlyClobber())
117 Res
+= "(1 << MCOI::EARLY_CLOBBER)";
119 assert(Constraint
.isTied());
120 Res
+= "((" + utostr(Constraint
.getTiedOperand()) +
121 " << 16) | (1 << MCOI::TIED_TO))";
124 Result
.push_back(Res
);
131 void InstrInfoEmitter::EmitOperandInfo(raw_ostream
&OS
,
132 OperandInfoMapTy
&OperandInfoIDs
) {
133 // ID #0 is for no operand info.
134 unsigned OperandListNum
= 0;
135 OperandInfoIDs
[std::vector
<std::string
>()] = ++OperandListNum
;
138 const CodeGenTarget
&Target
= CDP
.getTargetInfo();
139 for (CodeGenTarget::inst_iterator II
= Target
.inst_begin(),
140 E
= Target
.inst_end(); II
!= E
; ++II
) {
141 std::vector
<std::string
> OperandInfo
= GetOperandInfo(**II
);
142 unsigned &N
= OperandInfoIDs
[OperandInfo
];
143 if (N
!= 0) continue;
145 N
= ++OperandListNum
;
146 OS
<< "static const MCOperandInfo OperandInfo" << N
<< "[] = { ";
147 for (unsigned i
= 0, e
= OperandInfo
.size(); i
!= e
; ++i
)
148 OS
<< "{ " << OperandInfo
[i
] << " }, ";
153 //===----------------------------------------------------------------------===//
155 //===----------------------------------------------------------------------===//
157 // run - Emit the main instruction description records for the target...
158 void InstrInfoEmitter::run(raw_ostream
&OS
) {
163 EmitSourceFileHeader("Target Instruction Descriptors", OS
);
165 OS
<< "\n#ifdef GET_INSTRINFO_MC_DESC\n";
166 OS
<< "#undef GET_INSTRINFO_MC_DESC\n";
168 OS
<< "namespace llvm {\n\n";
170 CodeGenTarget
&Target
= CDP
.getTargetInfo();
171 const std::string
&TargetName
= Target
.getName();
172 Record
*InstrInfo
= Target
.getInstructionSet();
174 // Keep track of all of the def lists we have emitted already.
175 std::map
<std::vector
<Record
*>, unsigned> EmittedLists
;
176 unsigned ListNumber
= 0;
178 // Emit all of the instruction's implicit uses and defs.
179 for (CodeGenTarget::inst_iterator II
= Target
.inst_begin(),
180 E
= Target
.inst_end(); II
!= E
; ++II
) {
181 Record
*Inst
= (*II
)->TheDef
;
182 std::vector
<Record
*> Uses
= Inst
->getValueAsListOfDefs("Uses");
184 unsigned &IL
= EmittedLists
[Uses
];
185 if (!IL
) PrintDefList(Uses
, IL
= ++ListNumber
, OS
);
187 std::vector
<Record
*> Defs
= Inst
->getValueAsListOfDefs("Defs");
189 unsigned &IL
= EmittedLists
[Defs
];
190 if (!IL
) PrintDefList(Defs
, IL
= ++ListNumber
, OS
);
194 OperandInfoMapTy OperandInfoIDs
;
196 // Emit all of the operand info records.
197 EmitOperandInfo(OS
, OperandInfoIDs
);
199 // Emit all of the MCInstrDesc records in their ENUM ordering.
201 OS
<< "\nstatic const MCInstrDesc " << TargetName
203 const std::vector
<const CodeGenInstruction
*> &NumberedInstructions
=
204 Target
.getInstructionsByEnumValue();
206 for (unsigned i
= 0, e
= NumberedInstructions
.size(); i
!= e
; ++i
)
207 emitRecord(*NumberedInstructions
[i
], i
, InstrInfo
, EmittedLists
,
211 // MCInstrInfo initialization routine.
212 OS
<< "static inline void Init" << TargetName
213 << "MCInstrInfo(MCInstrInfo *II) {\n";
214 OS
<< " II->InitMCInstrInfo(" << TargetName
<< "Insts, "
215 << NumberedInstructions
.size() << ");\n}\n\n";
217 OS
<< "} // End llvm namespace \n";
219 OS
<< "#endif // GET_INSTRINFO_MC_DESC\n\n";
221 // Create a TargetInstrInfo subclass to hide the MC layer initialization.
222 OS
<< "\n#ifdef GET_INSTRINFO_HEADER\n";
223 OS
<< "#undef GET_INSTRINFO_HEADER\n";
225 std::string ClassName
= TargetName
+ "GenInstrInfo";
226 OS
<< "namespace llvm {\n";
227 OS
<< "struct " << ClassName
<< " : public TargetInstrInfoImpl {\n"
228 << " explicit " << ClassName
<< "(int SO = -1, int DO = -1);\n"
230 OS
<< "} // End llvm namespace \n";
232 OS
<< "#endif // GET_INSTRINFO_HEADER\n\n";
234 OS
<< "\n#ifdef GET_INSTRINFO_CTOR\n";
235 OS
<< "#undef GET_INSTRINFO_CTOR\n";
237 OS
<< "namespace llvm {\n";
238 OS
<< ClassName
<< "::" << ClassName
<< "(int SO, int DO)\n"
239 << " : TargetInstrInfoImpl(SO, DO) {\n"
240 << " InitMCInstrInfo(" << TargetName
<< "Insts, "
241 << NumberedInstructions
.size() << ");\n}\n";
242 OS
<< "} // End llvm namespace \n";
244 OS
<< "#endif // GET_INSTRINFO_CTOR\n\n";
247 void InstrInfoEmitter::emitRecord(const CodeGenInstruction
&Inst
, unsigned Num
,
249 std::map
<std::vector
<Record
*>, unsigned> &EmittedLists
,
250 const OperandInfoMapTy
&OpInfo
,
253 if (!Inst
.Operands
.size() == 0)
254 // Each logical operand can be multiple MI operands.
255 MinOperands
= Inst
.Operands
.back().MIOperandNo
+
256 Inst
.Operands
.back().MINumOperands
;
259 OS
<< Num
<< ",\t" << MinOperands
<< ",\t"
260 << Inst
.Operands
.NumDefs
<< ",\t" << getItinClassNumber(Inst
.TheDef
)
261 << ",\t\"" << Inst
.TheDef
->getName() << "\", 0";
263 // Emit all of the target indepedent flags...
264 if (Inst
.isReturn
) OS
<< "|(1<<MCID::Return)";
265 if (Inst
.isBranch
) OS
<< "|(1<<MCID::Branch)";
266 if (Inst
.isIndirectBranch
) OS
<< "|(1<<MCID::IndirectBranch)";
267 if (Inst
.isCompare
) OS
<< "|(1<<MCID::Compare)";
268 if (Inst
.isMoveImm
) OS
<< "|(1<<MCID::MoveImm)";
269 if (Inst
.isBitcast
) OS
<< "|(1<<MCID::Bitcast)";
270 if (Inst
.isBarrier
) OS
<< "|(1<<MCID::Barrier)";
271 if (Inst
.hasDelaySlot
) OS
<< "|(1<<MCID::DelaySlot)";
272 if (Inst
.isCall
) OS
<< "|(1<<MCID::Call)";
273 if (Inst
.canFoldAsLoad
) OS
<< "|(1<<MCID::FoldableAsLoad)";
274 if (Inst
.mayLoad
) OS
<< "|(1<<MCID::MayLoad)";
275 if (Inst
.mayStore
) OS
<< "|(1<<MCID::MayStore)";
276 if (Inst
.isPredicable
) OS
<< "|(1<<MCID::Predicable)";
277 if (Inst
.isConvertibleToThreeAddress
) OS
<< "|(1<<MCID::ConvertibleTo3Addr)";
278 if (Inst
.isCommutable
) OS
<< "|(1<<MCID::Commutable)";
279 if (Inst
.isTerminator
) OS
<< "|(1<<MCID::Terminator)";
280 if (Inst
.isReMaterializable
) OS
<< "|(1<<MCID::Rematerializable)";
281 if (Inst
.isNotDuplicable
) OS
<< "|(1<<MCID::NotDuplicable)";
282 if (Inst
.Operands
.hasOptionalDef
) OS
<< "|(1<<MCID::HasOptionalDef)";
283 if (Inst
.usesCustomInserter
) OS
<< "|(1<<MCID::UsesCustomInserter)";
284 if (Inst
.Operands
.isVariadic
)OS
<< "|(1<<MCID::Variadic)";
285 if (Inst
.hasSideEffects
) OS
<< "|(1<<MCID::UnmodeledSideEffects)";
286 if (Inst
.isAsCheapAsAMove
) OS
<< "|(1<<MCID::CheapAsAMove)";
287 if (Inst
.hasExtraSrcRegAllocReq
) OS
<< "|(1<<MCID::ExtraSrcRegAllocReq)";
288 if (Inst
.hasExtraDefRegAllocReq
) OS
<< "|(1<<MCID::ExtraDefRegAllocReq)";
290 // Emit all of the target-specific flags...
291 BitsInit
*TSF
= Inst
.TheDef
->getValueAsBitsInit("TSFlags");
292 if (!TSF
) throw "no TSFlags?";
294 for (unsigned i
= 0, e
= TSF
->getNumBits(); i
!= e
; ++i
) {
295 if (BitInit
*Bit
= dynamic_cast<BitInit
*>(TSF
->getBit(i
)))
296 Value
|= uint64_t(Bit
->getValue()) << i
;
298 throw "Invalid TSFlags bit in " + Inst
.TheDef
->getName();
304 // Emit the implicit uses and defs lists...
305 std::vector
<Record
*> UseList
= Inst
.TheDef
->getValueAsListOfDefs("Uses");
309 OS
<< "ImplicitList" << EmittedLists
[UseList
] << ", ";
311 std::vector
<Record
*> DefList
= Inst
.TheDef
->getValueAsListOfDefs("Defs");
315 OS
<< "ImplicitList" << EmittedLists
[DefList
] << ", ";
317 // Emit the operand info.
318 std::vector
<std::string
> OperandInfo
= GetOperandInfo(Inst
);
319 if (OperandInfo
.empty())
322 OS
<< "OperandInfo" << OpInfo
.find(OperandInfo
)->second
;
324 OS
<< " }, // Inst #" << Num
<< " = " << Inst
.TheDef
->getName() << "\n";
327 // emitEnums - Print out enum values for all of the instructions.
328 void InstrInfoEmitter::emitEnums(raw_ostream
&OS
) {
329 EmitSourceFileHeader("Target Instruction Enum Values", OS
);
331 OS
<< "\n#ifdef GET_INSTRINFO_ENUM\n";
332 OS
<< "#undef GET_INSTRINFO_ENUM\n";
334 OS
<< "namespace llvm {\n\n";
336 CodeGenTarget
Target(Records
);
338 // We must emit the PHI opcode first...
339 std::string Namespace
= Target
.getInstNamespace();
341 if (Namespace
.empty()) {
342 fprintf(stderr
, "No instructions defined!\n");
346 const std::vector
<const CodeGenInstruction
*> &NumberedInstructions
=
347 Target
.getInstructionsByEnumValue();
349 OS
<< "namespace " << Namespace
<< " {\n";
351 for (unsigned i
= 0, e
= NumberedInstructions
.size(); i
!= e
; ++i
) {
352 OS
<< " " << NumberedInstructions
[i
]->TheDef
->getName()
353 << "\t= " << i
<< ",\n";
355 OS
<< " INSTRUCTION_LIST_END = " << NumberedInstructions
.size() << "\n";
357 OS
<< "} // End llvm namespace \n";
359 OS
<< "#endif // GET_INSTRINFO_ENUM\n\n";