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" 82using namespace llvm; 83typedef std::map<std::string, std::vector<Record*> > InstrRelMapTy; 84 85typedef std::map<std::vector<Init*>, std::vector<Record*> > RowInstrMapTy; 86 87namespace { 88 89//===----------------------------------------------------------------------===// 90// This class is used to represent InstrMapping class defined in Target.td file. 91class InstrMap { 92private: 93 std::string Name; 94 std::string FilterClass; 95 ListInit *RowFields; 96 ListInit *ColFields; 97 ListInit *KeyCol; 98 std::vector<ListInit*> ValueCols; 99 100public: 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 181namespace { 182class MapTableEmitter { 183private: 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 201public: 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 241void 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 264bool 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 285void 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 307Record *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) // Already had a match 341 // Error if multiple matches are found for a column. 342 PrintFatalError("Multiple matches found for `" + KeyInstr->getName() + 343 "', for the relation `" + InstrMapDesc.getName()); 344 MatchInstr = CurInstr; 345 } 346 } 347 return MatchInstr; 348} 349 350//===----------------------------------------------------------------------===// 351// Emit one table per relation. Only instructions with a valid relation of a 352// given type are included in the table sorted by their enum values (opcodes). 353// Binary search is used for locating instructions in the table. 354//===----------------------------------------------------------------------===// 355 356unsigned MapTableEmitter::emitBinSearchTable(raw_ostream &OS) { 357 358 const std::vector<const CodeGenInstruction*> &NumberedInstructions = 359 Target.getInstructionsByEnumValue(); 360 std::string TargetName = Target.getName(); 361 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols(); 362 unsigned NumCol = ValueCols.size(); 363 unsigned TotalNumInstr = NumberedInstructions.size(); 364 unsigned TableSize = 0; 365 366 OS << "static const uint16_t "<<InstrMapDesc.getName(); 367 // Number of columns in the table are NumCol+1 because key instructions are 368 // emitted as first column. 369 OS << "Table[]["<< NumCol+1 << "] = {\n"; 370 for (unsigned i = 0; i < TotalNumInstr; i++) { 371 Record *CurInstr = NumberedInstructions[i]->TheDef; 372 std::vector<Record*> ColInstrs = MapTable[CurInstr]; 373 std::string OutStr(""); 374 unsigned RelExists = 0; 375 if (!ColInstrs.empty()) { 376 for (unsigned j = 0; j < NumCol; j++) { 377 if (ColInstrs[j] != nullptr) { 378 RelExists = 1; 379 OutStr += ", "; 380 OutStr += TargetName; 381 OutStr += "::"; 382 OutStr += ColInstrs[j]->getName(); 383 } else { OutStr += ", (uint16_t)-1U";} 384 } 385 386 if (RelExists) { 387 OS << " { " << TargetName << "::" << CurInstr->getName(); 388 OS << OutStr <<" },\n"; 389 TableSize++; 390 } 391 } 392 } 393 if (!TableSize) { 394 OS << " { " << TargetName << "::" << "INSTRUCTION_LIST_END, "; 395 OS << TargetName << "::" << "INSTRUCTION_LIST_END }"; 396 } 397 OS << "}; // End of " << InstrMapDesc.getName() << "Table\n\n"; 398 return TableSize; 399} 400 401//===----------------------------------------------------------------------===// 402// Emit binary search algorithm as part of the functions used to query 403// relation tables. 404//===----------------------------------------------------------------------===// 405 406void MapTableEmitter::emitBinSearch(raw_ostream &OS, unsigned TableSize) { 407 OS << " unsigned mid;\n"; 408 OS << " unsigned start = 0;\n"; 409 OS << " unsigned end = " << TableSize << ";\n"; 410 OS << " while (start < end) {\n"; 411 OS << " mid = start + (end - start)/2;\n"; 412 OS << " if (Opcode == " << InstrMapDesc.getName() << "Table[mid][0]) {\n"; 413 OS << " break;\n"; 414 OS << " }\n"; 415 OS << " if (Opcode < " << InstrMapDesc.getName() << "Table[mid][0])\n"; 416 OS << " end = mid;\n"; 417 OS << " else\n"; 418 OS << " start = mid + 1;\n"; 419 OS << " }\n"; 420 OS << " if (start == end)\n"; 421 OS << " return -1; // Instruction doesn't exist in this table.\n\n"; 422} 423 424//===----------------------------------------------------------------------===// 425// Emit functions to query relation tables. 426//===----------------------------------------------------------------------===// 427 428void MapTableEmitter::emitMapFuncBody(raw_ostream &OS, 429 unsigned TableSize) { 430 431 ListInit *ColFields = InstrMapDesc.getColFields(); 432 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols(); 433 434 // Emit binary search algorithm to locate instructions in the 435 // relation table. If found, return opcode value from the appropriate column 436 // of the table. 437 emitBinSearch(OS, TableSize); 438 439 if (ValueCols.size() > 1) { 440 for (unsigned i = 0, e = ValueCols.size(); i < e; i++) { 441 ListInit *ColumnI = ValueCols[i]; 442 for (unsigned j = 0, ColSize = ColumnI->size(); j < ColSize; ++j) { 443 std::string ColName = ColFields->getElement(j)->getAsUnquotedString(); 444 OS << " if (in" << ColName; 445 OS << " == "; 446 OS << ColName << "_" << ColumnI->getElement(j)->getAsUnquotedString(); 447 if (j < ColumnI->size() - 1) OS << " && "; 448 else OS << ")\n"; 449 } 450 OS << " return " << InstrMapDesc.getName(); 451 OS << "Table[mid]["<<i+1<<"];\n"; 452 } 453 OS << " return -1;"; 454 } 455 else 456 OS << " return " << InstrMapDesc.getName() << "Table[mid][1];\n"; 457 458 OS <<"}\n\n"; 459} 460 461//===----------------------------------------------------------------------===// 462// Emit relation tables and the functions to query them. 463//===----------------------------------------------------------------------===// 464 465void MapTableEmitter::emitTablesWithFunc(raw_ostream &OS) { 466 467 // Emit function name and the input parameters : mostly opcode value of the 468 // current instruction. However, if a table has multiple columns (more than 2 469 // since first column is used for the key instructions), then we also need 470 // to pass another input to indicate the column to be selected. 471 472 ListInit *ColFields = InstrMapDesc.getColFields(); 473 const std::vector<ListInit*> &ValueCols = InstrMapDesc.getValueCols(); 474 OS << "// "<< InstrMapDesc.getName() << "\nLLVM_READONLY\n"; 475 OS << "int "<< InstrMapDesc.getName() << "(uint16_t Opcode"; 476 if (ValueCols.size() > 1) { 477 for (Init *CF : ColFields->getValues()) { 478 std::string ColName = CF->getAsUnquotedString(); 479 OS << ", enum " << ColName << " in" << ColName << ") {\n"; 480 } 481 } else { OS << ") {\n"; } 482 483 // Emit map table. 484 unsigned TableSize = emitBinSearchTable(OS); 485 486 // Emit rest of the function body. 487 emitMapFuncBody(OS, TableSize); 488} 489 490//===----------------------------------------------------------------------===// 491// Emit enums for the column fields across all the instruction maps. 492//===----------------------------------------------------------------------===// 493 494static void emitEnums(raw_ostream &OS, RecordKeeper &Records) { 495 496 std::vector<Record*> InstrMapVec; 497 InstrMapVec = Records.getAllDerivedDefinitions("InstrMapping"); 498 std::map<std::string, std::vector<Init*> > ColFieldValueMap; 499 500 // Iterate over all InstrMapping records and create a map between column 501 // fields and their possible values across all records. 502 for (unsigned i = 0, e = InstrMapVec.size(); i < e; i++) { 503 Record *CurMap = InstrMapVec[i]; 504 ListInit *ColFields; 505 ColFields = CurMap->getValueAsListInit("ColFields"); 506 ListInit *List = CurMap->getValueAsListInit("ValueCols"); 507 std::vector<ListInit*> ValueCols; 508 unsigned ListSize = List->size(); 509 510 for (unsigned j = 0; j < ListSize; j++) { 511 ListInit *ListJ = dyn_cast<ListInit>(List->getElement(j)); 512 513 if (ListJ->size() != ColFields->size()) 514 PrintFatalError("Record `" + CurMap->getName() + "', field " 515 "`ValueCols' entries don't match with the entries in 'ColFields' !"); 516 ValueCols.push_back(ListJ); 517 } 518 519 for (unsigned j = 0, endCF = ColFields->size(); j < endCF; j++) { 520 for (unsigned k = 0; k < ListSize; k++){ 521 std::string ColName = ColFields->getElement(j)->getAsUnquotedString(); 522 ColFieldValueMap[ColName].push_back((ValueCols[k])->getElement(j)); 523 } 524 } 525 } 526 527 for (std::map<std::string, std::vector<Init*> >::iterator 528 II = ColFieldValueMap.begin(), IE = ColFieldValueMap.end(); 529 II != IE; II++) { 530 std::vector<Init*> FieldValues = (*II).second; 531 532 // Delete duplicate entries from ColFieldValueMap 533 for (unsigned i = 0; i < FieldValues.size() - 1; i++) { 534 Init *CurVal = FieldValues[i]; 535 for (unsigned j = i+1; j < FieldValues.size(); j++) { 536 if (CurVal == FieldValues[j]) { 537 FieldValues.erase(FieldValues.begin()+j); 538 } 539 } 540 } 541 542 // Emit enumerated values for the column fields. 543 OS << "enum " << (*II).first << " {\n"; 544 for (unsigned i = 0, endFV = FieldValues.size(); i < endFV; i++) { 545 OS << "\t" << (*II).first << "_" << FieldValues[i]->getAsUnquotedString(); 546 if (i != endFV - 1) 547 OS << ",\n"; 548 else 549 OS << "\n};\n\n"; 550 } 551 } 552} 553 554namespace llvm { 555//===----------------------------------------------------------------------===// 556// Parse 'InstrMapping' records and use the information to form relationship 557// between instructions. These relations are emitted as a tables along with the 558// functions to query them. 559//===----------------------------------------------------------------------===// 560void EmitMapTable(RecordKeeper &Records, raw_ostream &OS) { 561 CodeGenTarget Target(Records); 562 std::string TargetName = Target.getName(); 563 std::vector<Record*> InstrMapVec; 564 InstrMapVec = Records.getAllDerivedDefinitions("InstrMapping"); 565 566 if (InstrMapVec.empty()) 567 return; 568 569 OS << "#ifdef GET_INSTRMAP_INFO\n"; 570 OS << "#undef GET_INSTRMAP_INFO\n"; 571 OS << "namespace llvm {\n\n"; 572 OS << "namespace " << TargetName << " {\n\n"; 573 574 // Emit coulumn field names and their values as enums. 575 emitEnums(OS, Records); 576 577 // Iterate over all instruction mapping records and construct relationship 578 // maps based on the information specified there. 579 // 580 for (unsigned i = 0, e = InstrMapVec.size(); i < e; i++) { 581 MapTableEmitter IMap(Target, Records, InstrMapVec[i]); 582 583 // Build RowInstrMap to group instructions based on their values for 584 // RowFields. In the process, also collect key instructions into 585 // KeyInstrVec. 586 IMap.buildRowInstrMap(); 587 588 // Build MapTable to map key instructions with the corresponding column 589 // instructions. 590 IMap.buildMapTable(); 591 592 // Emit map tables and the functions to query them. 593 IMap.emitTablesWithFunc(OS); 594 } 595 OS << "} // End " << TargetName << " namespace\n"; 596 OS << "} // End llvm namespace\n"; 597 OS << "#endif // GET_INSTRMAP_INFO\n\n"; 598} 599 600} // End llvm namespace 601