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: 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->empty()) 132 PrintFatalError(MapRec->getLoc(), "InstrMapping record `" + 133 MapRec->getName() + "' has empty " + "`ValueCols' field!"); 134 135 for (Init *I : ColValList->getValues()) { 136 ListInit *ColI = dyn_cast<ListInit>(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->size() != ColFields->size()) 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 148 std::string getName() const { 149 return Name; 150 } 151 152 std::string getFilterClass() { 153 return FilterClass; 154 } 155 156 ListInit *getRowFields() const { 157 return RowFields; 158 } 159 160 ListInit *getColFields() const { 161 return ColFields; 162 } 163 164 ListInit *getKeyCol() const { 165 return KeyCol; 166 } 167 168 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: 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 241 void MapTableEmitter::buildRowInstrMap() { 242 for (Record *CurInstr : InstrDefs) { 243 std::vector<Init*> KeyValue; 244 ListInit *RowFields = InstrMapDesc.getRowFields(); 245 for (Init *RowField : RowFields->getValues()) { 246 Init *CurInstrVal = CurInstr->getValue(RowField)->getValue(); 247 KeyValue.push_back(CurInstrVal); 248 } 249 250 // Collect key instructions into KeyInstrVec. Later, these instructions are 251 // processed to assign column position to the instructions sharing 252 // their KeyValue in RowInstrMap. 253 if (isKeyColInstr(CurInstr)) 254 KeyInstrVec.push_back(CurInstr); 255 256 RowInstrMap[KeyValue].push_back(CurInstr); 257 } 258 } 259 260 //===----------------------------------------------------------------------===// 261 // Return true if an instruction is a KeyCol instruction. 262 //===----------------------------------------------------------------------===// 263 264 bool MapTableEmitter::isKeyColInstr(Record* CurInstr) { 265 ListInit *ColFields = InstrMapDesc.getColFields(); 266 ListInit *KeyCol = InstrMapDesc.getKeyCol(); 267 268 // Check if the instruction is a KeyCol instruction. 269 bool MatchFound = true; 270 for (unsigned j = 0, endCF = ColFields->size(); 271 (j < endCF) && MatchFound; j++) { 272 RecordVal *ColFieldName = CurInstr->getValue(ColFields->getElement(j)); 273 std::string CurInstrVal = ColFieldName->getValue()->getAsUnquotedString(); 274 std::string KeyColValue = KeyCol->getElement(j)->getAsUnquotedString(); 275 MatchFound = (CurInstrVal == KeyColValue); 276 } 277 return MatchFound; 278 } 279 280 //===----------------------------------------------------------------------===// 281 // Build a map to link key instructions with the column instructions arranged 282 // according to their column positions. 283 //===----------------------------------------------------------------------===// 284 285 void MapTableEmitter::buildMapTable() { 286 // Find column instructions for a given key based on the ColField 287 // constraints. 288 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols(); 289 unsigned NumOfCols = ValueCols.size(); 290 for (Record *CurKeyInstr : KeyInstrVec) { 291 std::vector<Record*> ColInstrVec(NumOfCols); 292 293 // Find the column instruction based on the constraints for the column. 294 for (unsigned ColIdx = 0; ColIdx < NumOfCols; ColIdx++) { 295 ListInit *CurValueCol = ValueCols[ColIdx]; 296 Record *ColInstr = getInstrForColumn(CurKeyInstr, CurValueCol); 297 ColInstrVec[ColIdx] = ColInstr; 298 } 299 MapTable[CurKeyInstr] = ColInstrVec; 300 } 301 } 302 303 //===----------------------------------------------------------------------===// 304 // Find column instruction based on the constraints for that column. 305 //===----------------------------------------------------------------------===// 306 307 Record *MapTableEmitter::getInstrForColumn(Record *KeyInstr, 308 ListInit *CurValueCol) { 309 ListInit *RowFields = InstrMapDesc.getRowFields(); 310 std::vector<Init*> KeyValue; 311 312 // Construct KeyValue using KeyInstr's values for RowFields. 313 for (Init *RowField : RowFields->getValues()) { 314 Init *KeyInstrVal = KeyInstr->getValue(RowField)->getValue(); 315 KeyValue.push_back(KeyInstrVal); 316 } 317 318 // Get all the instructions that share the same KeyValue as the KeyInstr 319 // in RowInstrMap. We search through these instructions to find a match 320 // for the current column, i.e., the instruction which has the same values 321 // as CurValueCol for all the fields in ColFields. 322 const std::vector<Record*> &RelatedInstrVec = RowInstrMap[KeyValue]; 323 324 ListInit *ColFields = InstrMapDesc.getColFields(); 325 Record *MatchInstr = nullptr; 326 327 for (unsigned i = 0, e = RelatedInstrVec.size(); i < e; i++) { 328 bool MatchFound = true; 329 Record *CurInstr = RelatedInstrVec[i]; 330 for (unsigned j = 0, endCF = ColFields->size(); 331 (j < endCF) && MatchFound; j++) { 332 Init *ColFieldJ = ColFields->getElement(j); 333 Init *CurInstrInit = CurInstr->getValue(ColFieldJ)->getValue(); 334 std::string CurInstrVal = CurInstrInit->getAsUnquotedString(); 335 Init *ColFieldJVallue = CurValueCol->getElement(j); 336 MatchFound = (CurInstrVal == ColFieldJVallue->getAsUnquotedString()); 337 } 338 339 if (MatchFound) { 340 if (MatchInstr) { 341 // Already had a match 342 // Error if multiple matches are found for a column. 343 std::string KeyValueStr; 344 for (Init *Value : KeyValue) { 345 if (!KeyValueStr.empty()) 346 KeyValueStr += ", "; 347 KeyValueStr += Value->getAsString(); 348 } 349 350 PrintFatalError("Multiple matches found for `" + KeyInstr->getName() + 351 "', for the relation `" + InstrMapDesc.getName() + "', row fields [" + 352 KeyValueStr + "], column `" + CurValueCol->getAsString() + "'"); 353 } 354 MatchInstr = CurInstr; 355 } 356 } 357 return MatchInstr; 358 } 359 360 //===----------------------------------------------------------------------===// 361 // Emit one table per relation. Only instructions with a valid relation of a 362 // given type are included in the table sorted by their enum values (opcodes). 363 // Binary search is used for locating instructions in the table. 364 //===----------------------------------------------------------------------===// 365 366 unsigned MapTableEmitter::emitBinSearchTable(raw_ostream &OS) { 367 368 ArrayRef<const CodeGenInstruction*> NumberedInstructions = 369 Target.getInstructionsByEnumValue(); 370 std::string TargetName = Target.getName(); 371 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols(); 372 unsigned NumCol = ValueCols.size(); 373 unsigned TotalNumInstr = NumberedInstructions.size(); 374 unsigned TableSize = 0; 375 376 OS << "static const uint16_t "<<InstrMapDesc.getName(); 377 // Number of columns in the table are NumCol+1 because key instructions are 378 // emitted as first column. 379 OS << "Table[]["<< NumCol+1 << "] = {\n"; 380 for (unsigned i = 0; i < TotalNumInstr; i++) { 381 Record *CurInstr = NumberedInstructions[i]->TheDef; 382 std::vector<Record*> ColInstrs = MapTable[CurInstr]; 383 std::string OutStr(""); 384 unsigned RelExists = 0; 385 if (!ColInstrs.empty()) { 386 for (unsigned j = 0; j < NumCol; j++) { 387 if (ColInstrs[j] != nullptr) { 388 RelExists = 1; 389 OutStr += ", "; 390 OutStr += TargetName; 391 OutStr += "::"; 392 OutStr += ColInstrs[j]->getName(); 393 } else { OutStr += ", (uint16_t)-1U";} 394 } 395 396 if (RelExists) { 397 OS << " { " << TargetName << "::" << CurInstr->getName(); 398 OS << OutStr <<" },\n"; 399 TableSize++; 400 } 401 } 402 } 403 if (!TableSize) { 404 OS << " { " << TargetName << "::" << "INSTRUCTION_LIST_END, "; 405 OS << TargetName << "::" << "INSTRUCTION_LIST_END }"; 406 } 407 OS << "}; // End of " << InstrMapDesc.getName() << "Table\n\n"; 408 return TableSize; 409 } 410 411 //===----------------------------------------------------------------------===// 412 // Emit binary search algorithm as part of the functions used to query 413 // relation tables. 414 //===----------------------------------------------------------------------===// 415 416 void MapTableEmitter::emitBinSearch(raw_ostream &OS, unsigned TableSize) { 417 OS << " unsigned mid;\n"; 418 OS << " unsigned start = 0;\n"; 419 OS << " unsigned end = " << TableSize << ";\n"; 420 OS << " while (start < end) {\n"; 421 OS << " mid = start + (end - start)/2;\n"; 422 OS << " if (Opcode == " << InstrMapDesc.getName() << "Table[mid][0]) {\n"; 423 OS << " break;\n"; 424 OS << " }\n"; 425 OS << " if (Opcode < " << InstrMapDesc.getName() << "Table[mid][0])\n"; 426 OS << " end = mid;\n"; 427 OS << " else\n"; 428 OS << " start = mid + 1;\n"; 429 OS << " }\n"; 430 OS << " if (start == end)\n"; 431 OS << " return -1; // Instruction doesn't exist in this table.\n\n"; 432 } 433 434 //===----------------------------------------------------------------------===// 435 // Emit functions to query relation tables. 436 //===----------------------------------------------------------------------===// 437 438 void MapTableEmitter::emitMapFuncBody(raw_ostream &OS, 439 unsigned TableSize) { 440 441 ListInit *ColFields = InstrMapDesc.getColFields(); 442 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols(); 443 444 // Emit binary search algorithm to locate instructions in the 445 // relation table. If found, return opcode value from the appropriate column 446 // of the table. 447 emitBinSearch(OS, TableSize); 448 449 if (ValueCols.size() > 1) { 450 for (unsigned i = 0, e = ValueCols.size(); i < e; i++) { 451 ListInit *ColumnI = ValueCols[i]; 452 for (unsigned j = 0, ColSize = ColumnI->size(); j < ColSize; ++j) { 453 std::string ColName = ColFields->getElement(j)->getAsUnquotedString(); 454 OS << " if (in" << ColName; 455 OS << " == "; 456 OS << ColName << "_" << ColumnI->getElement(j)->getAsUnquotedString(); 457 if (j < ColumnI->size() - 1) OS << " && "; 458 else OS << ")\n"; 459 } 460 OS << " return " << InstrMapDesc.getName(); 461 OS << "Table[mid]["<<i+1<<"];\n"; 462 } 463 OS << " return -1;"; 464 } 465 else 466 OS << " return " << InstrMapDesc.getName() << "Table[mid][1];\n"; 467 468 OS <<"}\n\n"; 469 } 470 471 //===----------------------------------------------------------------------===// 472 // Emit relation tables and the functions to query them. 473 //===----------------------------------------------------------------------===// 474 475 void MapTableEmitter::emitTablesWithFunc(raw_ostream &OS) { 476 477 // Emit function name and the input parameters : mostly opcode value of the 478 // current instruction. However, if a table has multiple columns (more than 2 479 // since first column is used for the key instructions), then we also need 480 // to pass another input to indicate the column to be selected. 481 482 ListInit *ColFields = InstrMapDesc.getColFields(); 483 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols(); 484 OS << "// "<< InstrMapDesc.getName() << "\nLLVM_READONLY\n"; 485 OS << "int "<< InstrMapDesc.getName() << "(uint16_t Opcode"; 486 if (ValueCols.size() > 1) { 487 for (Init *CF : ColFields->getValues()) { 488 std::string ColName = CF->getAsUnquotedString(); 489 OS << ", enum " << ColName << " in" << ColName << ") {\n"; 490 } 491 } else { OS << ") {\n"; } 492 493 // Emit map table. 494 unsigned TableSize = emitBinSearchTable(OS); 495 496 // Emit rest of the function body. 497 emitMapFuncBody(OS, TableSize); 498 } 499 500 //===----------------------------------------------------------------------===// 501 // Emit enums for the column fields across all the instruction maps. 502 //===----------------------------------------------------------------------===// 503 504 static void emitEnums(raw_ostream &OS, RecordKeeper &Records) { 505 506 std::vector<Record*> InstrMapVec; 507 InstrMapVec = Records.getAllDerivedDefinitions("InstrMapping"); 508 std::map<std::string, std::vector<Init*> > ColFieldValueMap; 509 510 // Iterate over all InstrMapping records and create a map between column 511 // fields and their possible values across all records. 512 for (Record *CurMap : InstrMapVec) { 513 ListInit *ColFields; 514 ColFields = CurMap->getValueAsListInit("ColFields"); 515 ListInit *List = CurMap->getValueAsListInit("ValueCols"); 516 std::vector<ListInit*> ValueCols; 517 unsigned ListSize = List->size(); 518 519 for (unsigned j = 0; j < ListSize; j++) { 520 ListInit *ListJ = dyn_cast<ListInit>(List->getElement(j)); 521 522 if (ListJ->size() != ColFields->size()) 523 PrintFatalError("Record `" + CurMap->getName() + "', field " 524 "`ValueCols' entries don't match with the entries in 'ColFields' !"); 525 ValueCols.push_back(ListJ); 526 } 527 528 for (unsigned j = 0, endCF = ColFields->size(); j < endCF; j++) { 529 for (unsigned k = 0; k < ListSize; k++){ 530 std::string ColName = ColFields->getElement(j)->getAsUnquotedString(); 531 ColFieldValueMap[ColName].push_back((ValueCols[k])->getElement(j)); 532 } 533 } 534 } 535 536 for (auto &Entry : ColFieldValueMap) { 537 std::vector<Init*> FieldValues = Entry.second; 538 539 // Delete duplicate entries from ColFieldValueMap 540 for (unsigned i = 0; i < FieldValues.size() - 1; i++) { 541 Init *CurVal = FieldValues[i]; 542 for (unsigned j = i+1; j < FieldValues.size(); j++) { 543 if (CurVal == FieldValues[j]) { 544 FieldValues.erase(FieldValues.begin()+j); 545 } 546 } 547 } 548 549 // Emit enumerated values for the column fields. 550 OS << "enum " << Entry.first << " {\n"; 551 for (unsigned i = 0, endFV = FieldValues.size(); i < endFV; i++) { 552 OS << "\t" << Entry.first << "_" << FieldValues[i]->getAsUnquotedString(); 553 if (i != endFV - 1) 554 OS << ",\n"; 555 else 556 OS << "\n};\n\n"; 557 } 558 } 559 } 560 561 namespace llvm { 562 //===----------------------------------------------------------------------===// 563 // Parse 'InstrMapping' records and use the information to form relationship 564 // between instructions. These relations are emitted as a tables along with the 565 // functions to query them. 566 //===----------------------------------------------------------------------===// 567 void EmitMapTable(RecordKeeper &Records, raw_ostream &OS) { 568 CodeGenTarget Target(Records); 569 std::string TargetName = Target.getName(); 570 std::vector<Record*> InstrMapVec; 571 InstrMapVec = Records.getAllDerivedDefinitions("InstrMapping"); 572 573 if (InstrMapVec.empty()) 574 return; 575 576 OS << "#ifdef GET_INSTRMAP_INFO\n"; 577 OS << "#undef GET_INSTRMAP_INFO\n"; 578 OS << "namespace llvm {\n\n"; 579 OS << "namespace " << TargetName << " {\n\n"; 580 581 // Emit coulumn field names and their values as enums. 582 emitEnums(OS, Records); 583 584 // Iterate over all instruction mapping records and construct relationship 585 // maps based on the information specified there. 586 // 587 for (Record *CurMap : InstrMapVec) { 588 MapTableEmitter IMap(Target, Records, CurMap); 589 590 // Build RowInstrMap to group instructions based on their values for 591 // RowFields. In the process, also collect key instructions into 592 // KeyInstrVec. 593 IMap.buildRowInstrMap(); 594 595 // Build MapTable to map key instructions with the corresponding column 596 // instructions. 597 IMap.buildMapTable(); 598 599 // Emit map tables and the functions to query them. 600 IMap.emitTablesWithFunc(OS); 601 } 602 OS << "} // End " << TargetName << " namespace\n"; 603 OS << "} // End llvm namespace\n"; 604 OS << "#endif // GET_INSTRMAP_INFO\n\n"; 605 } 606 607 } // End llvm namespace 608