1 //===- CodeGenMapTable.cpp - Instruction Mapping Table Generator ----------===//
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 // CodeGenMapTable provides functionality for the TabelGen to create
10 // relation mapping between instructions. Relation models are defined using
11 // InstrMapping as a base class. This file implements the functionality which
12 // parses these definitions and generates relation maps using the information
13 // specified there. These maps are emitted as tables in the XXXGenInstrInfo.inc
14 // file along with the functions to query them.
15 //
16 // A relationship model to relate non-predicate instructions with their
17 // predicated true/false forms can be defined as follows:
18 //
19 // def getPredOpcode : InstrMapping {
20 // let FilterClass = "PredRel";
21 // let RowFields = ["BaseOpcode"];
22 // let ColFields = ["PredSense"];
23 // let KeyCol = ["none"];
24 // let ValueCols = [["true"], ["false"]]; }
25 //
26 // CodeGenMapTable parses this map and generates a table in XXXGenInstrInfo.inc
27 // file that contains the instructions modeling this relationship. This table
28 // is defined in the function
29 // "int getPredOpcode(uint16_t Opcode, enum PredSense inPredSense)"
30 // that can be used to retrieve the predicated form of the instruction by
31 // passing its opcode value and the predicate sense (true/false) of the desired
32 // instruction as arguments.
33 //
34 // Short description of the algorithm:
35 //
36 // 1) Iterate through all the records that derive from "InstrMapping" class.
37 // 2) For each record, filter out instructions based on the FilterClass value.
38 // 3) Iterate through this set of instructions and insert them into
39 // RowInstrMap map based on their RowFields values. RowInstrMap is keyed by the
40 // vector of RowFields values and contains vectors of Records (instructions) as
41 // values. RowFields is a list of fields that are required to have the same
42 // values for all the instructions appearing in the same row of the relation
43 // table. All the instructions in a given row of the relation table have some
44 // sort of relationship with the key instruction defined by the corresponding
45 // relationship model.
46 //
47 // Ex: RowInstrMap(RowVal1, RowVal2, ...) -> [Instr1, Instr2, Instr3, ... ]
48 // Here Instr1, Instr2, Instr3 have same values (RowVal1, RowVal2) for
49 // RowFields. These groups of instructions are later matched against ValueCols
50 // to determine the column they belong to, if any.
51 //
52 // While building the RowInstrMap map, collect all the key instructions in
53 // KeyInstrVec. These are the instructions having the same values as KeyCol
54 // for all the fields listed in ColFields.
55 //
56 // For Example:
57 //
58 // Relate non-predicate instructions with their predicated true/false forms.
59 //
60 // def getPredOpcode : InstrMapping {
61 // let FilterClass = "PredRel";
62 // let RowFields = ["BaseOpcode"];
63 // let ColFields = ["PredSense"];
64 // let KeyCol = ["none"];
65 // let ValueCols = [["true"], ["false"]]; }
66 //
67 // Here, only instructions that have "none" as PredSense will be selected as key
68 // instructions.
69 //
70 // 4) For each key instruction, get the group of instructions that share the
71 // same key-value as the key instruction from RowInstrMap. Iterate over the list
72 // of columns in ValueCols (it is defined as a list<list<string> >. Therefore,
73 // it can specify multi-column relationships). For each column, find the
74 // instruction from the group that matches all the values for the column.
75 // Multiple matches are not allowed.
76 //
77 //===----------------------------------------------------------------------===//
78
79 #include "CodeGenTarget.h"
80 #include "llvm/Support/Format.h"
81 #include "llvm/TableGen/Error.h"
82 using namespace llvm;
83 typedef std::map<std::string, std::vector<Record*> > InstrRelMapTy;
84
85 typedef std::map<std::vector<Init*>, std::vector<Record*> > RowInstrMapTy;
86
87 namespace {
88
89 //===----------------------------------------------------------------------===//
90 // This class is used to represent InstrMapping class defined in Target.td file.
91 class InstrMap {
92 private:
93 std::string Name;
94 std::string FilterClass;
95 ListInit *RowFields;
96 ListInit *ColFields;
97 ListInit *KeyCol;
98 std::vector<ListInit*> ValueCols;
99
100 public:
InstrMap(Record * MapRec)101 InstrMap(Record* MapRec) {
102 Name = MapRec->getName();
103
104 // FilterClass - It's used to reduce the search space only to the
105 // instructions that define the kind of relationship modeled by
106 // this InstrMapping object/record.
107 const RecordVal *Filter = MapRec->getValue("FilterClass");
108 FilterClass = Filter->getValue()->getAsUnquotedString();
109
110 // List of fields/attributes that need to be same across all the
111 // instructions in a row of the relation table.
112 RowFields = MapRec->getValueAsListInit("RowFields");
113
114 // List of fields/attributes that are constant across all the instruction
115 // in a column of the relation table. Ex: ColFields = 'predSense'
116 ColFields = MapRec->getValueAsListInit("ColFields");
117
118 // Values for the fields/attributes listed in 'ColFields'.
119 // Ex: KeyCol = 'noPred' -- key instruction is non-predicated
120 KeyCol = MapRec->getValueAsListInit("KeyCol");
121
122 // List of values for the fields/attributes listed in 'ColFields', one for
123 // each column in the relation table.
124 //
125 // Ex: ValueCols = [['true'],['false']] -- it results two columns in the
126 // table. First column requires all the instructions to have predSense
127 // set to 'true' and second column requires it to be 'false'.
128 ListInit *ColValList = MapRec->getValueAsListInit("ValueCols");
129
130 // Each instruction map must specify at least one column for it to be valid.
131 if (ColValList->getSize() == 0)
132 PrintFatalError(MapRec->getLoc(), "InstrMapping record `" +
133 MapRec->getName() + "' has empty " + "`ValueCols' field!");
134
135 for (unsigned i = 0, e = ColValList->getSize(); i < e; i++) {
136 ListInit *ColI = dyn_cast<ListInit>(ColValList->getElement(i));
137
138 // Make sure that all the sub-lists in 'ValueCols' have same number of
139 // elements as the fields in 'ColFields'.
140 if (ColI->getSize() != ColFields->getSize())
141 PrintFatalError(MapRec->getLoc(), "Record `" + MapRec->getName() +
142 "', field `ValueCols' entries don't match with " +
143 " the entries in 'ColFields'!");
144 ValueCols.push_back(ColI);
145 }
146 }
147
getName() const148 std::string getName() const {
149 return Name;
150 }
151
getFilterClass()152 std::string getFilterClass() {
153 return FilterClass;
154 }
155
getRowFields() const156 ListInit *getRowFields() const {
157 return RowFields;
158 }
159
getColFields() const160 ListInit *getColFields() const {
161 return ColFields;
162 }
163
getKeyCol() const164 ListInit *getKeyCol() const {
165 return KeyCol;
166 }
167
getValueCols() const168 const std::vector<ListInit*> &getValueCols() const {
169 return ValueCols;
170 }
171 };
172 } // End anonymous namespace.
173
174
175 //===----------------------------------------------------------------------===//
176 // class MapTableEmitter : It builds the instruction relation maps using
177 // the information provided in InstrMapping records. It outputs these
178 // relationship maps as tables into XXXGenInstrInfo.inc file along with the
179 // functions to query them.
180
181 namespace {
182 class MapTableEmitter {
183 private:
184 // std::string TargetName;
185 const CodeGenTarget &Target;
186 // InstrMapDesc - InstrMapping record to be processed.
187 InstrMap InstrMapDesc;
188
189 // InstrDefs - list of instructions filtered using FilterClass defined
190 // in InstrMapDesc.
191 std::vector<Record*> InstrDefs;
192
193 // RowInstrMap - maps RowFields values to the instructions. It's keyed by the
194 // values of the row fields and contains vector of records as values.
195 RowInstrMapTy RowInstrMap;
196
197 // KeyInstrVec - list of key instructions.
198 std::vector<Record*> KeyInstrVec;
199 DenseMap<Record*, std::vector<Record*> > MapTable;
200
201 public:
MapTableEmitter(CodeGenTarget & Target,RecordKeeper & Records,Record * IMRec)202 MapTableEmitter(CodeGenTarget &Target, RecordKeeper &Records, Record *IMRec):
203 Target(Target), InstrMapDesc(IMRec) {
204 const std::string FilterClass = InstrMapDesc.getFilterClass();
205 InstrDefs = Records.getAllDerivedDefinitions(FilterClass);
206 }
207
208 void buildRowInstrMap();
209
210 // Returns true if an instruction is a key instruction, i.e., its ColFields
211 // have same values as KeyCol.
212 bool isKeyColInstr(Record* CurInstr);
213
214 // Find column instruction corresponding to a key instruction based on the
215 // constraints for that column.
216 Record *getInstrForColumn(Record *KeyInstr, ListInit *CurValueCol);
217
218 // Find column instructions for each key instruction based
219 // on ValueCols and store them into MapTable.
220 void buildMapTable();
221
222 void emitBinSearch(raw_ostream &OS, unsigned TableSize);
223 void emitTablesWithFunc(raw_ostream &OS);
224 unsigned emitBinSearchTable(raw_ostream &OS);
225
226 // Lookup functions to query binary search tables.
227 void emitMapFuncBody(raw_ostream &OS, unsigned TableSize);
228
229 };
230 } // End anonymous namespace.
231
232
233 //===----------------------------------------------------------------------===//
234 // Process all the instructions that model this relation (alreday present in
235 // InstrDefs) and insert them into RowInstrMap which is keyed by the values of
236 // the fields listed as RowFields. It stores vectors of records as values.
237 // All the related instructions have the same values for the RowFields thus are
238 // part of the same key-value pair.
239 //===----------------------------------------------------------------------===//
240
buildRowInstrMap()241 void MapTableEmitter::buildRowInstrMap() {
242 for (unsigned i = 0, e = InstrDefs.size(); i < e; i++) {
243 Record *CurInstr = InstrDefs[i];
244 std::vector<Init*> KeyValue;
245 ListInit *RowFields = InstrMapDesc.getRowFields();
246 for (unsigned j = 0, endRF = RowFields->getSize(); j < endRF; j++) {
247 Init *RowFieldsJ = RowFields->getElement(j);
248 Init *CurInstrVal = CurInstr->getValue(RowFieldsJ)->getValue();
249 KeyValue.push_back(CurInstrVal);
250 }
251
252 // Collect key instructions into KeyInstrVec. Later, these instructions are
253 // processed to assign column position to the instructions sharing
254 // their KeyValue in RowInstrMap.
255 if (isKeyColInstr(CurInstr))
256 KeyInstrVec.push_back(CurInstr);
257
258 RowInstrMap[KeyValue].push_back(CurInstr);
259 }
260 }
261
262 //===----------------------------------------------------------------------===//
263 // Return true if an instruction is a KeyCol instruction.
264 //===----------------------------------------------------------------------===//
265
isKeyColInstr(Record * CurInstr)266 bool MapTableEmitter::isKeyColInstr(Record* CurInstr) {
267 ListInit *ColFields = InstrMapDesc.getColFields();
268 ListInit *KeyCol = InstrMapDesc.getKeyCol();
269
270 // Check if the instruction is a KeyCol instruction.
271 bool MatchFound = true;
272 for (unsigned j = 0, endCF = ColFields->getSize();
273 (j < endCF) && MatchFound; j++) {
274 RecordVal *ColFieldName = CurInstr->getValue(ColFields->getElement(j));
275 std::string CurInstrVal = ColFieldName->getValue()->getAsUnquotedString();
276 std::string KeyColValue = KeyCol->getElement(j)->getAsUnquotedString();
277 MatchFound = (CurInstrVal == KeyColValue);
278 }
279 return MatchFound;
280 }
281
282 //===----------------------------------------------------------------------===//
283 // Build a map to link key instructions with the column instructions arranged
284 // according to their column positions.
285 //===----------------------------------------------------------------------===//
286
buildMapTable()287 void MapTableEmitter::buildMapTable() {
288 // Find column instructions for a given key based on the ColField
289 // constraints.
290 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols();
291 unsigned NumOfCols = ValueCols.size();
292 for (unsigned j = 0, endKI = KeyInstrVec.size(); j < endKI; j++) {
293 Record *CurKeyInstr = KeyInstrVec[j];
294 std::vector<Record*> ColInstrVec(NumOfCols);
295
296 // Find the column instruction based on the constraints for the column.
297 for (unsigned ColIdx = 0; ColIdx < NumOfCols; ColIdx++) {
298 ListInit *CurValueCol = ValueCols[ColIdx];
299 Record *ColInstr = getInstrForColumn(CurKeyInstr, CurValueCol);
300 ColInstrVec[ColIdx] = ColInstr;
301 }
302 MapTable[CurKeyInstr] = ColInstrVec;
303 }
304 }
305
306 //===----------------------------------------------------------------------===//
307 // Find column instruction based on the constraints for that column.
308 //===----------------------------------------------------------------------===//
309
getInstrForColumn(Record * KeyInstr,ListInit * CurValueCol)310 Record *MapTableEmitter::getInstrForColumn(Record *KeyInstr,
311 ListInit *CurValueCol) {
312 ListInit *RowFields = InstrMapDesc.getRowFields();
313 std::vector<Init*> KeyValue;
314
315 // Construct KeyValue using KeyInstr's values for RowFields.
316 for (unsigned j = 0, endRF = RowFields->getSize(); j < endRF; j++) {
317 Init *RowFieldsJ = RowFields->getElement(j);
318 Init *KeyInstrVal = KeyInstr->getValue(RowFieldsJ)->getValue();
319 KeyValue.push_back(KeyInstrVal);
320 }
321
322 // Get all the instructions that share the same KeyValue as the KeyInstr
323 // in RowInstrMap. We search through these instructions to find a match
324 // for the current column, i.e., the instruction which has the same values
325 // as CurValueCol for all the fields in ColFields.
326 const std::vector<Record*> &RelatedInstrVec = RowInstrMap[KeyValue];
327
328 ListInit *ColFields = InstrMapDesc.getColFields();
329 Record *MatchInstr = nullptr;
330
331 for (unsigned i = 0, e = RelatedInstrVec.size(); i < e; i++) {
332 bool MatchFound = true;
333 Record *CurInstr = RelatedInstrVec[i];
334 for (unsigned j = 0, endCF = ColFields->getSize();
335 (j < endCF) && MatchFound; j++) {
336 Init *ColFieldJ = ColFields->getElement(j);
337 Init *CurInstrInit = CurInstr->getValue(ColFieldJ)->getValue();
338 std::string CurInstrVal = CurInstrInit->getAsUnquotedString();
339 Init *ColFieldJVallue = CurValueCol->getElement(j);
340 MatchFound = (CurInstrVal == ColFieldJVallue->getAsUnquotedString());
341 }
342
343 if (MatchFound) {
344 if (MatchInstr) // Already had a match
345 // Error if multiple matches are found for a column.
346 PrintFatalError("Multiple matches found for `" + KeyInstr->getName() +
347 "', for the relation `" + InstrMapDesc.getName());
348 MatchInstr = CurInstr;
349 }
350 }
351 return MatchInstr;
352 }
353
354 //===----------------------------------------------------------------------===//
355 // Emit one table per relation. Only instructions with a valid relation of a
356 // given type are included in the table sorted by their enum values (opcodes).
357 // Binary search is used for locating instructions in the table.
358 //===----------------------------------------------------------------------===//
359
emitBinSearchTable(raw_ostream & OS)360 unsigned MapTableEmitter::emitBinSearchTable(raw_ostream &OS) {
361
362 const std::vector<const CodeGenInstruction*> &NumberedInstructions =
363 Target.getInstructionsByEnumValue();
364 std::string TargetName = Target.getName();
365 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols();
366 unsigned NumCol = ValueCols.size();
367 unsigned TotalNumInstr = NumberedInstructions.size();
368 unsigned TableSize = 0;
369
370 OS << "static const uint16_t "<<InstrMapDesc.getName();
371 // Number of columns in the table are NumCol+1 because key instructions are
372 // emitted as first column.
373 OS << "Table[]["<< NumCol+1 << "] = {\n";
374 for (unsigned i = 0; i < TotalNumInstr; i++) {
375 Record *CurInstr = NumberedInstructions[i]->TheDef;
376 std::vector<Record*> ColInstrs = MapTable[CurInstr];
377 std::string OutStr("");
378 unsigned RelExists = 0;
379 if (ColInstrs.size()) {
380 for (unsigned j = 0; j < NumCol; j++) {
381 if (ColInstrs[j] != nullptr) {
382 RelExists = 1;
383 OutStr += ", ";
384 OutStr += TargetName;
385 OutStr += "::";
386 OutStr += ColInstrs[j]->getName();
387 } else { OutStr += ", (uint16_t)-1U";}
388 }
389
390 if (RelExists) {
391 OS << " { " << TargetName << "::" << CurInstr->getName();
392 OS << OutStr <<" },\n";
393 TableSize++;
394 }
395 }
396 }
397 if (!TableSize) {
398 OS << " { " << TargetName << "::" << "INSTRUCTION_LIST_END, ";
399 OS << TargetName << "::" << "INSTRUCTION_LIST_END }";
400 }
401 OS << "}; // End of " << InstrMapDesc.getName() << "Table\n\n";
402 return TableSize;
403 }
404
405 //===----------------------------------------------------------------------===//
406 // Emit binary search algorithm as part of the functions used to query
407 // relation tables.
408 //===----------------------------------------------------------------------===//
409
emitBinSearch(raw_ostream & OS,unsigned TableSize)410 void MapTableEmitter::emitBinSearch(raw_ostream &OS, unsigned TableSize) {
411 OS << " unsigned mid;\n";
412 OS << " unsigned start = 0;\n";
413 OS << " unsigned end = " << TableSize << ";\n";
414 OS << " while (start < end) {\n";
415 OS << " mid = start + (end - start)/2;\n";
416 OS << " if (Opcode == " << InstrMapDesc.getName() << "Table[mid][0]) {\n";
417 OS << " break;\n";
418 OS << " }\n";
419 OS << " if (Opcode < " << InstrMapDesc.getName() << "Table[mid][0])\n";
420 OS << " end = mid;\n";
421 OS << " else\n";
422 OS << " start = mid + 1;\n";
423 OS << " }\n";
424 OS << " if (start == end)\n";
425 OS << " return -1; // Instruction doesn't exist in this table.\n\n";
426 }
427
428 //===----------------------------------------------------------------------===//
429 // Emit functions to query relation tables.
430 //===----------------------------------------------------------------------===//
431
emitMapFuncBody(raw_ostream & OS,unsigned TableSize)432 void MapTableEmitter::emitMapFuncBody(raw_ostream &OS,
433 unsigned TableSize) {
434
435 ListInit *ColFields = InstrMapDesc.getColFields();
436 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols();
437
438 // Emit binary search algorithm to locate instructions in the
439 // relation table. If found, return opcode value from the appropriate column
440 // of the table.
441 emitBinSearch(OS, TableSize);
442
443 if (ValueCols.size() > 1) {
444 for (unsigned i = 0, e = ValueCols.size(); i < e; i++) {
445 ListInit *ColumnI = ValueCols[i];
446 for (unsigned j = 0, ColSize = ColumnI->getSize(); j < ColSize; j++) {
447 std::string ColName = ColFields->getElement(j)->getAsUnquotedString();
448 OS << " if (in" << ColName;
449 OS << " == ";
450 OS << ColName << "_" << ColumnI->getElement(j)->getAsUnquotedString();
451 if (j < ColumnI->getSize() - 1) OS << " && ";
452 else OS << ")\n";
453 }
454 OS << " return " << InstrMapDesc.getName();
455 OS << "Table[mid]["<<i+1<<"];\n";
456 }
457 OS << " return -1;";
458 }
459 else
460 OS << " return " << InstrMapDesc.getName() << "Table[mid][1];\n";
461
462 OS <<"}\n\n";
463 }
464
465 //===----------------------------------------------------------------------===//
466 // Emit relation tables and the functions to query them.
467 //===----------------------------------------------------------------------===//
468
emitTablesWithFunc(raw_ostream & OS)469 void MapTableEmitter::emitTablesWithFunc(raw_ostream &OS) {
470
471 // Emit function name and the input parameters : mostly opcode value of the
472 // current instruction. However, if a table has multiple columns (more than 2
473 // since first column is used for the key instructions), then we also need
474 // to pass another input to indicate the column to be selected.
475
476 ListInit *ColFields = InstrMapDesc.getColFields();
477 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols();
478 OS << "// "<< InstrMapDesc.getName() << "\n";
479 OS << "int "<< InstrMapDesc.getName() << "(uint16_t Opcode";
480 if (ValueCols.size() > 1) {
481 for (unsigned i = 0, e = ColFields->getSize(); i < e; i++) {
482 std::string ColName = ColFields->getElement(i)->getAsUnquotedString();
483 OS << ", enum " << ColName << " in" << ColName << ") {\n";
484 }
485 } else { OS << ") {\n"; }
486
487 // Emit map table.
488 unsigned TableSize = emitBinSearchTable(OS);
489
490 // Emit rest of the function body.
491 emitMapFuncBody(OS, TableSize);
492 }
493
494 //===----------------------------------------------------------------------===//
495 // Emit enums for the column fields across all the instruction maps.
496 //===----------------------------------------------------------------------===//
497
emitEnums(raw_ostream & OS,RecordKeeper & Records)498 static void emitEnums(raw_ostream &OS, RecordKeeper &Records) {
499
500 std::vector<Record*> InstrMapVec;
501 InstrMapVec = Records.getAllDerivedDefinitions("InstrMapping");
502 std::map<std::string, std::vector<Init*> > ColFieldValueMap;
503
504 // Iterate over all InstrMapping records and create a map between column
505 // fields and their possible values across all records.
506 for (unsigned i = 0, e = InstrMapVec.size(); i < e; i++) {
507 Record *CurMap = InstrMapVec[i];
508 ListInit *ColFields;
509 ColFields = CurMap->getValueAsListInit("ColFields");
510 ListInit *List = CurMap->getValueAsListInit("ValueCols");
511 std::vector<ListInit*> ValueCols;
512 unsigned ListSize = List->getSize();
513
514 for (unsigned j = 0; j < ListSize; j++) {
515 ListInit *ListJ = dyn_cast<ListInit>(List->getElement(j));
516
517 if (ListJ->getSize() != ColFields->getSize())
518 PrintFatalError("Record `" + CurMap->getName() + "', field "
519 "`ValueCols' entries don't match with the entries in 'ColFields' !");
520 ValueCols.push_back(ListJ);
521 }
522
523 for (unsigned j = 0, endCF = ColFields->getSize(); j < endCF; j++) {
524 for (unsigned k = 0; k < ListSize; k++){
525 std::string ColName = ColFields->getElement(j)->getAsUnquotedString();
526 ColFieldValueMap[ColName].push_back((ValueCols[k])->getElement(j));
527 }
528 }
529 }
530
531 for (std::map<std::string, std::vector<Init*> >::iterator
532 II = ColFieldValueMap.begin(), IE = ColFieldValueMap.end();
533 II != IE; II++) {
534 std::vector<Init*> FieldValues = (*II).second;
535
536 // Delete duplicate entries from ColFieldValueMap
537 for (unsigned i = 0; i < FieldValues.size() - 1; i++) {
538 Init *CurVal = FieldValues[i];
539 for (unsigned j = i+1; j < FieldValues.size(); j++) {
540 if (CurVal == FieldValues[j]) {
541 FieldValues.erase(FieldValues.begin()+j);
542 }
543 }
544 }
545
546 // Emit enumerated values for the column fields.
547 OS << "enum " << (*II).first << " {\n";
548 for (unsigned i = 0, endFV = FieldValues.size(); i < endFV; i++) {
549 OS << "\t" << (*II).first << "_" << FieldValues[i]->getAsUnquotedString();
550 if (i != endFV - 1)
551 OS << ",\n";
552 else
553 OS << "\n};\n\n";
554 }
555 }
556 }
557
558 namespace llvm {
559 //===----------------------------------------------------------------------===//
560 // Parse 'InstrMapping' records and use the information to form relationship
561 // between instructions. These relations are emitted as a tables along with the
562 // functions to query them.
563 //===----------------------------------------------------------------------===//
EmitMapTable(RecordKeeper & Records,raw_ostream & OS)564 void EmitMapTable(RecordKeeper &Records, raw_ostream &OS) {
565 CodeGenTarget Target(Records);
566 std::string TargetName = Target.getName();
567 std::vector<Record*> InstrMapVec;
568 InstrMapVec = Records.getAllDerivedDefinitions("InstrMapping");
569
570 if (!InstrMapVec.size())
571 return;
572
573 OS << "#ifdef GET_INSTRMAP_INFO\n";
574 OS << "#undef GET_INSTRMAP_INFO\n";
575 OS << "namespace llvm {\n\n";
576 OS << "namespace " << TargetName << " {\n\n";
577
578 // Emit coulumn field names and their values as enums.
579 emitEnums(OS, Records);
580
581 // Iterate over all instruction mapping records and construct relationship
582 // maps based on the information specified there.
583 //
584 for (unsigned i = 0, e = InstrMapVec.size(); i < e; i++) {
585 MapTableEmitter IMap(Target, Records, InstrMapVec[i]);
586
587 // Build RowInstrMap to group instructions based on their values for
588 // RowFields. In the process, also collect key instructions into
589 // KeyInstrVec.
590 IMap.buildRowInstrMap();
591
592 // Build MapTable to map key instructions with the corresponding column
593 // instructions.
594 IMap.buildMapTable();
595
596 // Emit map tables and the functions to query them.
597 IMap.emitTablesWithFunc(OS);
598 }
599 OS << "} // End " << TargetName << " namespace\n";
600 OS << "} // End llvm namespace\n";
601 OS << "#endif // GET_INSTRMAP_INFO\n\n";
602 }
603
604 } // End llvm namespace
605