1 //===- CodeGenInstruction.cpp - CodeGen Instruction Class Wrapper ---------===// 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 implements the CodeGenInstruction class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "CodeGenInstruction.h" 15 #include "CodeGenTarget.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/ADT/StringExtras.h" 18 #include "llvm/ADT/StringMap.h" 19 #include "llvm/TableGen/Error.h" 20 #include "llvm/TableGen/Record.h" 21 #include <set> 22 using namespace llvm; 23 24 //===----------------------------------------------------------------------===// 25 // CGIOperandList Implementation 26 //===----------------------------------------------------------------------===// 27 28 CGIOperandList::CGIOperandList(Record *R) : TheDef(R) { 29 isPredicable = false; 30 hasOptionalDef = false; 31 isVariadic = false; 32 33 DagInit *OutDI = R->getValueAsDag("OutOperandList"); 34 35 if (DefInit *Init = dyn_cast<DefInit>(OutDI->getOperator())) { 36 if (Init->getDef()->getName() != "outs") 37 PrintFatalError(R->getName() + ": invalid def name for output list: use 'outs'"); 38 } else 39 PrintFatalError(R->getName() + ": invalid output list: use 'outs'"); 40 41 NumDefs = OutDI->getNumArgs(); 42 43 DagInit *InDI = R->getValueAsDag("InOperandList"); 44 if (DefInit *Init = dyn_cast<DefInit>(InDI->getOperator())) { 45 if (Init->getDef()->getName() != "ins") 46 PrintFatalError(R->getName() + ": invalid def name for input list: use 'ins'"); 47 } else 48 PrintFatalError(R->getName() + ": invalid input list: use 'ins'"); 49 50 unsigned MIOperandNo = 0; 51 std::set<std::string> OperandNames; 52 for (unsigned i = 0, e = InDI->getNumArgs()+OutDI->getNumArgs(); i != e; ++i){ 53 Init *ArgInit; 54 std::string ArgName; 55 if (i < NumDefs) { 56 ArgInit = OutDI->getArg(i); 57 ArgName = OutDI->getArgName(i); 58 } else { 59 ArgInit = InDI->getArg(i-NumDefs); 60 ArgName = InDI->getArgName(i-NumDefs); 61 } 62 63 DefInit *Arg = dyn_cast<DefInit>(ArgInit); 64 if (!Arg) 65 PrintFatalError("Illegal operand for the '" + R->getName() + "' instruction!"); 66 67 Record *Rec = Arg->getDef(); 68 std::string PrintMethod = "printOperand"; 69 std::string EncoderMethod; 70 std::string OperandType = "OPERAND_UNKNOWN"; 71 std::string OperandNamespace = "MCOI"; 72 unsigned NumOps = 1; 73 DagInit *MIOpInfo = nullptr; 74 if (Rec->isSubClassOf("RegisterOperand")) { 75 PrintMethod = Rec->getValueAsString("PrintMethod"); 76 OperandType = Rec->getValueAsString("OperandType"); 77 OperandNamespace = Rec->getValueAsString("OperandNamespace"); 78 } else if (Rec->isSubClassOf("Operand")) { 79 PrintMethod = Rec->getValueAsString("PrintMethod"); 80 OperandType = Rec->getValueAsString("OperandType"); 81 // If there is an explicit encoder method, use it. 82 EncoderMethod = Rec->getValueAsString("EncoderMethod"); 83 MIOpInfo = Rec->getValueAsDag("MIOperandInfo"); 84 85 // Verify that MIOpInfo has an 'ops' root value. 86 if (!isa<DefInit>(MIOpInfo->getOperator()) || 87 cast<DefInit>(MIOpInfo->getOperator())->getDef()->getName() != "ops") 88 PrintFatalError("Bad value for MIOperandInfo in operand '" + Rec->getName() + 89 "'\n"); 90 91 // If we have MIOpInfo, then we have #operands equal to number of entries 92 // in MIOperandInfo. 93 if (unsigned NumArgs = MIOpInfo->getNumArgs()) 94 NumOps = NumArgs; 95 96 if (Rec->isSubClassOf("PredicateOp")) 97 isPredicable = true; 98 else if (Rec->isSubClassOf("OptionalDefOperand")) 99 hasOptionalDef = true; 100 } else if (Rec->getName() == "variable_ops") { 101 isVariadic = true; 102 continue; 103 } else if (Rec->isSubClassOf("RegisterClass")) { 104 OperandType = "OPERAND_REGISTER"; 105 } else if (!Rec->isSubClassOf("PointerLikeRegClass") && 106 !Rec->isSubClassOf("unknown_class")) 107 PrintFatalError("Unknown operand class '" + Rec->getName() + 108 "' in '" + R->getName() + "' instruction!"); 109 110 // Check that the operand has a name and that it's unique. 111 if (ArgName.empty()) 112 PrintFatalError("In instruction '" + R->getName() + "', operand #" + 113 Twine(i) + " has no name!"); 114 if (!OperandNames.insert(ArgName).second) 115 PrintFatalError("In instruction '" + R->getName() + "', operand #" + 116 Twine(i) + " has the same name as a previous operand!"); 117 118 OperandList.push_back(OperandInfo(Rec, ArgName, PrintMethod, EncoderMethod, 119 OperandNamespace + "::" + OperandType, 120 MIOperandNo, NumOps, MIOpInfo)); 121 MIOperandNo += NumOps; 122 } 123 124 125 // Make sure the constraints list for each operand is large enough to hold 126 // constraint info, even if none is present. 127 for (unsigned i = 0, e = OperandList.size(); i != e; ++i) 128 OperandList[i].Constraints.resize(OperandList[i].MINumOperands); 129 } 130 131 132 /// getOperandNamed - Return the index of the operand with the specified 133 /// non-empty name. If the instruction does not have an operand with the 134 /// specified name, abort. 135 /// 136 unsigned CGIOperandList::getOperandNamed(StringRef Name) const { 137 unsigned OpIdx; 138 if (hasOperandNamed(Name, OpIdx)) return OpIdx; 139 PrintFatalError("'" + TheDef->getName() + 140 "' does not have an operand named '$" + Name + "'!"); 141 } 142 143 /// hasOperandNamed - Query whether the instruction has an operand of the 144 /// given name. If so, return true and set OpIdx to the index of the 145 /// operand. Otherwise, return false. 146 bool CGIOperandList::hasOperandNamed(StringRef Name, unsigned &OpIdx) const { 147 assert(!Name.empty() && "Cannot search for operand with no name!"); 148 for (unsigned i = 0, e = OperandList.size(); i != e; ++i) 149 if (OperandList[i].Name == Name) { 150 OpIdx = i; 151 return true; 152 } 153 return false; 154 } 155 156 std::pair<unsigned,unsigned> 157 CGIOperandList::ParseOperandName(const std::string &Op, bool AllowWholeOp) { 158 if (Op.empty() || Op[0] != '$') 159 PrintFatalError(TheDef->getName() + ": Illegal operand name: '" + Op + "'"); 160 161 std::string OpName = Op.substr(1); 162 std::string SubOpName; 163 164 // Check to see if this is $foo.bar. 165 std::string::size_type DotIdx = OpName.find_first_of("."); 166 if (DotIdx != std::string::npos) { 167 SubOpName = OpName.substr(DotIdx+1); 168 if (SubOpName.empty()) 169 PrintFatalError(TheDef->getName() + ": illegal empty suboperand name in '" +Op +"'"); 170 OpName = OpName.substr(0, DotIdx); 171 } 172 173 unsigned OpIdx = getOperandNamed(OpName); 174 175 if (SubOpName.empty()) { // If no suboperand name was specified: 176 // If one was needed, throw. 177 if (OperandList[OpIdx].MINumOperands > 1 && !AllowWholeOp && 178 SubOpName.empty()) 179 PrintFatalError(TheDef->getName() + ": Illegal to refer to" 180 " whole operand part of complex operand '" + Op + "'"); 181 182 // Otherwise, return the operand. 183 return std::make_pair(OpIdx, 0U); 184 } 185 186 // Find the suboperand number involved. 187 DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo; 188 if (!MIOpInfo) 189 PrintFatalError(TheDef->getName() + ": unknown suboperand name in '" + Op + "'"); 190 191 // Find the operand with the right name. 192 for (unsigned i = 0, e = MIOpInfo->getNumArgs(); i != e; ++i) 193 if (MIOpInfo->getArgName(i) == SubOpName) 194 return std::make_pair(OpIdx, i); 195 196 // Otherwise, didn't find it! 197 PrintFatalError(TheDef->getName() + ": unknown suboperand name in '" + Op + "'"); 198 return std::make_pair(0U, 0U); 199 } 200 201 static void ParseConstraint(const std::string &CStr, CGIOperandList &Ops) { 202 // EARLY_CLOBBER: @early $reg 203 std::string::size_type wpos = CStr.find_first_of(" \t"); 204 std::string::size_type start = CStr.find_first_not_of(" \t"); 205 std::string Tok = CStr.substr(start, wpos - start); 206 if (Tok == "@earlyclobber") { 207 std::string Name = CStr.substr(wpos+1); 208 wpos = Name.find_first_not_of(" \t"); 209 if (wpos == std::string::npos) 210 PrintFatalError("Illegal format for @earlyclobber constraint: '" + CStr + "'"); 211 Name = Name.substr(wpos); 212 std::pair<unsigned,unsigned> Op = Ops.ParseOperandName(Name, false); 213 214 // Build the string for the operand 215 if (!Ops[Op.first].Constraints[Op.second].isNone()) 216 PrintFatalError("Operand '" + Name + "' cannot have multiple constraints!"); 217 Ops[Op.first].Constraints[Op.second] = 218 CGIOperandList::ConstraintInfo::getEarlyClobber(); 219 return; 220 } 221 222 // Only other constraint is "TIED_TO" for now. 223 std::string::size_type pos = CStr.find_first_of('='); 224 assert(pos != std::string::npos && "Unrecognized constraint"); 225 start = CStr.find_first_not_of(" \t"); 226 std::string Name = CStr.substr(start, pos - start); 227 228 // TIED_TO: $src1 = $dst 229 wpos = Name.find_first_of(" \t"); 230 if (wpos == std::string::npos) 231 PrintFatalError("Illegal format for tied-to constraint: '" + CStr + "'"); 232 std::string DestOpName = Name.substr(0, wpos); 233 std::pair<unsigned,unsigned> DestOp = Ops.ParseOperandName(DestOpName, false); 234 235 Name = CStr.substr(pos+1); 236 wpos = Name.find_first_not_of(" \t"); 237 if (wpos == std::string::npos) 238 PrintFatalError("Illegal format for tied-to constraint: '" + CStr + "'"); 239 240 std::string SrcOpName = Name.substr(wpos); 241 std::pair<unsigned,unsigned> SrcOp = Ops.ParseOperandName(SrcOpName, false); 242 if (SrcOp > DestOp) { 243 std::swap(SrcOp, DestOp); 244 std::swap(SrcOpName, DestOpName); 245 } 246 247 unsigned FlatOpNo = Ops.getFlattenedOperandNumber(SrcOp); 248 249 if (!Ops[DestOp.first].Constraints[DestOp.second].isNone()) 250 PrintFatalError("Operand '" + DestOpName + 251 "' cannot have multiple constraints!"); 252 Ops[DestOp.first].Constraints[DestOp.second] = 253 CGIOperandList::ConstraintInfo::getTied(FlatOpNo); 254 } 255 256 static void ParseConstraints(const std::string &CStr, CGIOperandList &Ops) { 257 if (CStr.empty()) return; 258 259 const std::string delims(","); 260 std::string::size_type bidx, eidx; 261 262 bidx = CStr.find_first_not_of(delims); 263 while (bidx != std::string::npos) { 264 eidx = CStr.find_first_of(delims, bidx); 265 if (eidx == std::string::npos) 266 eidx = CStr.length(); 267 268 ParseConstraint(CStr.substr(bidx, eidx - bidx), Ops); 269 bidx = CStr.find_first_not_of(delims, eidx); 270 } 271 } 272 273 void CGIOperandList::ProcessDisableEncoding(std::string DisableEncoding) { 274 while (1) { 275 std::pair<StringRef, StringRef> P = getToken(DisableEncoding, " ,\t"); 276 std::string OpName = P.first; 277 DisableEncoding = P.second; 278 if (OpName.empty()) break; 279 280 // Figure out which operand this is. 281 std::pair<unsigned,unsigned> Op = ParseOperandName(OpName, false); 282 283 // Mark the operand as not-to-be encoded. 284 if (Op.second >= OperandList[Op.first].DoNotEncode.size()) 285 OperandList[Op.first].DoNotEncode.resize(Op.second+1); 286 OperandList[Op.first].DoNotEncode[Op.second] = true; 287 } 288 289 } 290 291 //===----------------------------------------------------------------------===// 292 // CodeGenInstruction Implementation 293 //===----------------------------------------------------------------------===// 294 295 CodeGenInstruction::CodeGenInstruction(Record *R) 296 : TheDef(R), Operands(R), InferredFrom(nullptr) { 297 Namespace = R->getValueAsString("Namespace"); 298 AsmString = R->getValueAsString("AsmString"); 299 300 isReturn = R->getValueAsBit("isReturn"); 301 isBranch = R->getValueAsBit("isBranch"); 302 isIndirectBranch = R->getValueAsBit("isIndirectBranch"); 303 isCompare = R->getValueAsBit("isCompare"); 304 isMoveImm = R->getValueAsBit("isMoveImm"); 305 isBitcast = R->getValueAsBit("isBitcast"); 306 isSelect = R->getValueAsBit("isSelect"); 307 isBarrier = R->getValueAsBit("isBarrier"); 308 isCall = R->getValueAsBit("isCall"); 309 canFoldAsLoad = R->getValueAsBit("canFoldAsLoad"); 310 isPredicable = Operands.isPredicable || R->getValueAsBit("isPredicable"); 311 isConvertibleToThreeAddress = R->getValueAsBit("isConvertibleToThreeAddress"); 312 isCommutable = R->getValueAsBit("isCommutable"); 313 isTerminator = R->getValueAsBit("isTerminator"); 314 isReMaterializable = R->getValueAsBit("isReMaterializable"); 315 hasDelaySlot = R->getValueAsBit("hasDelaySlot"); 316 usesCustomInserter = R->getValueAsBit("usesCustomInserter"); 317 hasPostISelHook = R->getValueAsBit("hasPostISelHook"); 318 hasCtrlDep = R->getValueAsBit("hasCtrlDep"); 319 isNotDuplicable = R->getValueAsBit("isNotDuplicable"); 320 isRegSequence = R->getValueAsBit("isRegSequence"); 321 isExtractSubreg = R->getValueAsBit("isExtractSubreg"); 322 isInsertSubreg = R->getValueAsBit("isInsertSubreg"); 323 324 bool Unset; 325 mayLoad = R->getValueAsBitOrUnset("mayLoad", Unset); 326 mayLoad_Unset = Unset; 327 mayStore = R->getValueAsBitOrUnset("mayStore", Unset); 328 mayStore_Unset = Unset; 329 hasSideEffects = R->getValueAsBitOrUnset("hasSideEffects", Unset); 330 hasSideEffects_Unset = Unset; 331 332 isAsCheapAsAMove = R->getValueAsBit("isAsCheapAsAMove"); 333 hasExtraSrcRegAllocReq = R->getValueAsBit("hasExtraSrcRegAllocReq"); 334 hasExtraDefRegAllocReq = R->getValueAsBit("hasExtraDefRegAllocReq"); 335 isCodeGenOnly = R->getValueAsBit("isCodeGenOnly"); 336 isPseudo = R->getValueAsBit("isPseudo"); 337 ImplicitDefs = R->getValueAsListOfDefs("Defs"); 338 ImplicitUses = R->getValueAsListOfDefs("Uses"); 339 340 // Parse Constraints. 341 ParseConstraints(R->getValueAsString("Constraints"), Operands); 342 343 // Parse the DisableEncoding field. 344 Operands.ProcessDisableEncoding(R->getValueAsString("DisableEncoding")); 345 346 // First check for a ComplexDeprecationPredicate. 347 if (R->getValue("ComplexDeprecationPredicate")) { 348 HasComplexDeprecationPredicate = true; 349 DeprecatedReason = R->getValueAsString("ComplexDeprecationPredicate"); 350 } else if (RecordVal *Dep = R->getValue("DeprecatedFeatureMask")) { 351 // Check if we have a Subtarget feature mask. 352 HasComplexDeprecationPredicate = false; 353 DeprecatedReason = Dep->getValue()->getAsString(); 354 } else { 355 // This instruction isn't deprecated. 356 HasComplexDeprecationPredicate = false; 357 DeprecatedReason = ""; 358 } 359 } 360 361 /// HasOneImplicitDefWithKnownVT - If the instruction has at least one 362 /// implicit def and it has a known VT, return the VT, otherwise return 363 /// MVT::Other. 364 MVT::SimpleValueType CodeGenInstruction:: 365 HasOneImplicitDefWithKnownVT(const CodeGenTarget &TargetInfo) const { 366 if (ImplicitDefs.empty()) return MVT::Other; 367 368 // Check to see if the first implicit def has a resolvable type. 369 Record *FirstImplicitDef = ImplicitDefs[0]; 370 assert(FirstImplicitDef->isSubClassOf("Register")); 371 const std::vector<MVT::SimpleValueType> &RegVTs = 372 TargetInfo.getRegisterVTs(FirstImplicitDef); 373 if (RegVTs.size() == 1) 374 return RegVTs[0]; 375 return MVT::Other; 376 } 377 378 379 /// FlattenAsmStringVariants - Flatten the specified AsmString to only 380 /// include text from the specified variant, returning the new string. 381 std::string CodeGenInstruction:: 382 FlattenAsmStringVariants(StringRef Cur, unsigned Variant) { 383 std::string Res = ""; 384 385 for (;;) { 386 // Find the start of the next variant string. 387 size_t VariantsStart = 0; 388 for (size_t e = Cur.size(); VariantsStart != e; ++VariantsStart) 389 if (Cur[VariantsStart] == '{' && 390 (VariantsStart == 0 || (Cur[VariantsStart-1] != '$' && 391 Cur[VariantsStart-1] != '\\'))) 392 break; 393 394 // Add the prefix to the result. 395 Res += Cur.slice(0, VariantsStart); 396 if (VariantsStart == Cur.size()) 397 break; 398 399 ++VariantsStart; // Skip the '{'. 400 401 // Scan to the end of the variants string. 402 size_t VariantsEnd = VariantsStart; 403 unsigned NestedBraces = 1; 404 for (size_t e = Cur.size(); VariantsEnd != e; ++VariantsEnd) { 405 if (Cur[VariantsEnd] == '}' && Cur[VariantsEnd-1] != '\\') { 406 if (--NestedBraces == 0) 407 break; 408 } else if (Cur[VariantsEnd] == '{') 409 ++NestedBraces; 410 } 411 412 // Select the Nth variant (or empty). 413 StringRef Selection = Cur.slice(VariantsStart, VariantsEnd); 414 for (unsigned i = 0; i != Variant; ++i) 415 Selection = Selection.split('|').second; 416 Res += Selection.split('|').first; 417 418 assert(VariantsEnd != Cur.size() && 419 "Unterminated variants in assembly string!"); 420 Cur = Cur.substr(VariantsEnd + 1); 421 } 422 423 return Res; 424 } 425 426 427 //===----------------------------------------------------------------------===// 428 /// CodeGenInstAlias Implementation 429 //===----------------------------------------------------------------------===// 430 431 /// tryAliasOpMatch - This is a helper function for the CodeGenInstAlias 432 /// constructor. It checks if an argument in an InstAlias pattern matches 433 /// the corresponding operand of the instruction. It returns true on a 434 /// successful match, with ResOp set to the result operand to be used. 435 bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo, 436 Record *InstOpRec, bool hasSubOps, 437 ArrayRef<SMLoc> Loc, CodeGenTarget &T, 438 ResultOperand &ResOp) { 439 Init *Arg = Result->getArg(AliasOpNo); 440 DefInit *ADI = dyn_cast<DefInit>(Arg); 441 Record *ResultRecord = ADI ? ADI->getDef() : nullptr; 442 443 if (ADI && ADI->getDef() == InstOpRec) { 444 // If the operand is a record, it must have a name, and the record type 445 // must match up with the instruction's argument type. 446 if (Result->getArgName(AliasOpNo).empty()) 447 PrintFatalError(Loc, "result argument #" + Twine(AliasOpNo) + 448 " must have a name!"); 449 ResOp = ResultOperand(Result->getArgName(AliasOpNo), ResultRecord); 450 return true; 451 } 452 453 // For register operands, the source register class can be a subclass 454 // of the instruction register class, not just an exact match. 455 if (InstOpRec->isSubClassOf("RegisterOperand")) 456 InstOpRec = InstOpRec->getValueAsDef("RegClass"); 457 458 if (ADI && ADI->getDef()->isSubClassOf("RegisterOperand")) 459 ADI = ADI->getDef()->getValueAsDef("RegClass")->getDefInit(); 460 461 if (ADI && ADI->getDef()->isSubClassOf("RegisterClass")) { 462 if (!InstOpRec->isSubClassOf("RegisterClass")) 463 return false; 464 if (!T.getRegisterClass(InstOpRec) 465 .hasSubClass(&T.getRegisterClass(ADI->getDef()))) 466 return false; 467 ResOp = ResultOperand(Result->getArgName(AliasOpNo), ResultRecord); 468 return true; 469 } 470 471 // Handle explicit registers. 472 if (ADI && ADI->getDef()->isSubClassOf("Register")) { 473 if (InstOpRec->isSubClassOf("OptionalDefOperand")) { 474 DagInit *DI = InstOpRec->getValueAsDag("MIOperandInfo"); 475 // The operand info should only have a single (register) entry. We 476 // want the register class of it. 477 InstOpRec = cast<DefInit>(DI->getArg(0))->getDef(); 478 } 479 480 if (!InstOpRec->isSubClassOf("RegisterClass")) 481 return false; 482 483 if (!T.getRegisterClass(InstOpRec) 484 .contains(T.getRegBank().getReg(ADI->getDef()))) 485 PrintFatalError(Loc, "fixed register " + ADI->getDef()->getName() + 486 " is not a member of the " + InstOpRec->getName() + 487 " register class!"); 488 489 if (!Result->getArgName(AliasOpNo).empty()) 490 PrintFatalError(Loc, "result fixed register argument must " 491 "not have a name!"); 492 493 ResOp = ResultOperand(ResultRecord); 494 return true; 495 } 496 497 // Handle "zero_reg" for optional def operands. 498 if (ADI && ADI->getDef()->getName() == "zero_reg") { 499 500 // Check if this is an optional def. 501 // Tied operands where the source is a sub-operand of a complex operand 502 // need to represent both operands in the alias destination instruction. 503 // Allow zero_reg for the tied portion. This can and should go away once 504 // the MC representation of things doesn't use tied operands at all. 505 //if (!InstOpRec->isSubClassOf("OptionalDefOperand")) 506 // throw TGError(Loc, "reg0 used for result that is not an " 507 // "OptionalDefOperand!"); 508 509 ResOp = ResultOperand(static_cast<Record*>(nullptr)); 510 return true; 511 } 512 513 // Literal integers. 514 if (IntInit *II = dyn_cast<IntInit>(Arg)) { 515 if (hasSubOps || !InstOpRec->isSubClassOf("Operand")) 516 return false; 517 // Integer arguments can't have names. 518 if (!Result->getArgName(AliasOpNo).empty()) 519 PrintFatalError(Loc, "result argument #" + Twine(AliasOpNo) + 520 " must not have a name!"); 521 ResOp = ResultOperand(II->getValue()); 522 return true; 523 } 524 525 // Bits<n> (also used for 0bxx literals) 526 if (BitsInit *BI = dyn_cast<BitsInit>(Arg)) { 527 if (hasSubOps || !InstOpRec->isSubClassOf("Operand")) 528 return false; 529 if (!BI->isComplete()) 530 return false; 531 // Convert the bits init to an integer and use that for the result. 532 IntInit *II = 533 dyn_cast_or_null<IntInit>(BI->convertInitializerTo(IntRecTy::get())); 534 if (!II) 535 return false; 536 ResOp = ResultOperand(II->getValue()); 537 return true; 538 } 539 540 // If both are Operands with the same MVT, allow the conversion. It's 541 // up to the user to make sure the values are appropriate, just like 542 // for isel Pat's. 543 if (InstOpRec->isSubClassOf("Operand") && ADI && 544 ADI->getDef()->isSubClassOf("Operand")) { 545 // FIXME: What other attributes should we check here? Identical 546 // MIOperandInfo perhaps? 547 if (InstOpRec->getValueInit("Type") != ADI->getDef()->getValueInit("Type")) 548 return false; 549 ResOp = ResultOperand(Result->getArgName(AliasOpNo), ADI->getDef()); 550 return true; 551 } 552 553 return false; 554 } 555 556 unsigned CodeGenInstAlias::ResultOperand::getMINumOperands() const { 557 if (!isRecord()) 558 return 1; 559 560 Record *Rec = getRecord(); 561 if (!Rec->isSubClassOf("Operand")) 562 return 1; 563 564 DagInit *MIOpInfo = Rec->getValueAsDag("MIOperandInfo"); 565 if (MIOpInfo->getNumArgs() == 0) { 566 // Unspecified, so it defaults to 1 567 return 1; 568 } 569 570 return MIOpInfo->getNumArgs(); 571 } 572 573 CodeGenInstAlias::CodeGenInstAlias(Record *R, unsigned Variant, 574 CodeGenTarget &T) 575 : TheDef(R) { 576 Result = R->getValueAsDag("ResultInst"); 577 AsmString = R->getValueAsString("AsmString"); 578 AsmString = CodeGenInstruction::FlattenAsmStringVariants(AsmString, Variant); 579 580 581 // Verify that the root of the result is an instruction. 582 DefInit *DI = dyn_cast<DefInit>(Result->getOperator()); 583 if (!DI || !DI->getDef()->isSubClassOf("Instruction")) 584 PrintFatalError(R->getLoc(), 585 "result of inst alias should be an instruction"); 586 587 ResultInst = &T.getInstruction(DI->getDef()); 588 589 // NameClass - If argument names are repeated, we need to verify they have 590 // the same class. 591 StringMap<Record*> NameClass; 592 for (unsigned i = 0, e = Result->getNumArgs(); i != e; ++i) { 593 DefInit *ADI = dyn_cast<DefInit>(Result->getArg(i)); 594 if (!ADI || Result->getArgName(i).empty()) 595 continue; 596 // Verify we don't have something like: (someinst GR16:$foo, GR32:$foo) 597 // $foo can exist multiple times in the result list, but it must have the 598 // same type. 599 Record *&Entry = NameClass[Result->getArgName(i)]; 600 if (Entry && Entry != ADI->getDef()) 601 PrintFatalError(R->getLoc(), "result value $" + Result->getArgName(i) + 602 " is both " + Entry->getName() + " and " + 603 ADI->getDef()->getName() + "!"); 604 Entry = ADI->getDef(); 605 } 606 607 // Decode and validate the arguments of the result. 608 unsigned AliasOpNo = 0; 609 for (unsigned i = 0, e = ResultInst->Operands.size(); i != e; ++i) { 610 611 // Tied registers don't have an entry in the result dag unless they're part 612 // of a complex operand, in which case we include them anyways, as we 613 // don't have any other way to specify the whole operand. 614 if (ResultInst->Operands[i].MINumOperands == 1 && 615 ResultInst->Operands[i].getTiedRegister() != -1) 616 continue; 617 618 if (AliasOpNo >= Result->getNumArgs()) 619 PrintFatalError(R->getLoc(), "not enough arguments for instruction!"); 620 621 Record *InstOpRec = ResultInst->Operands[i].Rec; 622 unsigned NumSubOps = ResultInst->Operands[i].MINumOperands; 623 ResultOperand ResOp(static_cast<int64_t>(0)); 624 if (tryAliasOpMatch(Result, AliasOpNo, InstOpRec, (NumSubOps > 1), 625 R->getLoc(), T, ResOp)) { 626 // If this is a simple operand, or a complex operand with a custom match 627 // class, then we can match is verbatim. 628 if (NumSubOps == 1 || 629 (InstOpRec->getValue("ParserMatchClass") && 630 InstOpRec->getValueAsDef("ParserMatchClass") 631 ->getValueAsString("Name") != "Imm")) { 632 ResultOperands.push_back(ResOp); 633 ResultInstOperandIndex.push_back(std::make_pair(i, -1)); 634 ++AliasOpNo; 635 636 // Otherwise, we need to match each of the suboperands individually. 637 } else { 638 DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo; 639 for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { 640 Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef(); 641 642 // Take care to instantiate each of the suboperands with the correct 643 // nomenclature: $foo.bar 644 ResultOperands.push_back( 645 ResultOperand(Result->getArgName(AliasOpNo) + "." + 646 MIOI->getArgName(SubOp), SubRec)); 647 ResultInstOperandIndex.push_back(std::make_pair(i, SubOp)); 648 } 649 ++AliasOpNo; 650 } 651 continue; 652 } 653 654 // If the argument did not match the instruction operand, and the operand 655 // is composed of multiple suboperands, try matching the suboperands. 656 if (NumSubOps > 1) { 657 DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo; 658 for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { 659 if (AliasOpNo >= Result->getNumArgs()) 660 PrintFatalError(R->getLoc(), "not enough arguments for instruction!"); 661 Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef(); 662 if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false, 663 R->getLoc(), T, ResOp)) { 664 ResultOperands.push_back(ResOp); 665 ResultInstOperandIndex.push_back(std::make_pair(i, SubOp)); 666 ++AliasOpNo; 667 } else { 668 PrintFatalError(R->getLoc(), "result argument #" + Twine(AliasOpNo) + 669 " does not match instruction operand class " + 670 (SubOp == 0 ? InstOpRec->getName() :SubRec->getName())); 671 } 672 } 673 continue; 674 } 675 PrintFatalError(R->getLoc(), "result argument #" + Twine(AliasOpNo) + 676 " does not match instruction operand class " + 677 InstOpRec->getName()); 678 } 679 680 if (AliasOpNo != Result->getNumArgs()) 681 PrintFatalError(R->getLoc(), "too many operands for instruction!"); 682 } 683