16cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner//===- CodeGenInstruction.cpp - CodeGen Instruction Class Wrapper ---------===// 26cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner// 36cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner// The LLVM Compiler Infrastructure 46cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner// 56cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner// This file is distributed under the University of Illinois Open Source 66cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner// License. See LICENSE.TXT for details. 76cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner// 86cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner//===----------------------------------------------------------------------===// 96cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner// 106cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner// This file implements the CodeGenInstruction class. 116cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner// 126cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner//===----------------------------------------------------------------------===// 136cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner 146cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner#include "CodeGenInstruction.h" 159414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner#include "CodeGenTarget.h" 164ffd89fa4d2788611187d1a534d2ed46adf1702cChandler Carruth#include "llvm/ADT/STLExtras.h" 176cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner#include "llvm/ADT/StringExtras.h" 183f2c8e474b8775aa1f3c2c0cb817b7f9f564e068Chris Lattner#include "llvm/ADT/StringMap.h" 194ffd89fa4d2788611187d1a534d2ed46adf1702cChandler Carruth#include "llvm/TableGen/Error.h" 204ffd89fa4d2788611187d1a534d2ed46adf1702cChandler Carruth#include "llvm/TableGen/Record.h" 216cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner#include <set> 226cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattnerusing namespace llvm; 236cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner 24c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner//===----------------------------------------------------------------------===// 25c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner// CGIOperandList Implementation 26c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner//===----------------------------------------------------------------------===// 276cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner 28c240bb0ede0541426254d0e0dc81d891beda4b22Chris LattnerCGIOperandList::CGIOperandList(Record *R) : TheDef(R) { 29c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isPredicable = false; 306cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner hasOptionalDef = false; 318f707e15fbd09ca948b86419bcb0c92470827ac9Chris Lattner isVariadic = false; 32e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3305bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *OutDI = R->getValueAsDag("OutOperandList"); 34e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 356cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *Init = dyn_cast<DefInit>(OutDI->getOperator())) { 36b0be4d261b1ebd0e364e3e8b5e5f124c1e7b96b5Chris Lattner if (Init->getDef()->getName() != "outs") 3761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getName() + ": invalid def name for output list: use 'outs'"); 38cedef1ccf0d53693b5e62d524e7ba6b2122231c7Chris Lattner } else 3961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getName() + ": invalid output list: use 'outs'"); 40e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 41f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner NumDefs = OutDI->getNumArgs(); 42c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 4305bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *InDI = R->getValueAsDag("InOperandList"); 446cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *Init = dyn_cast<DefInit>(InDI->getOperator())) { 45b0be4d261b1ebd0e364e3e8b5e5f124c1e7b96b5Chris Lattner if (Init->getDef()->getName() != "ins") 4661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getName() + ": invalid def name for input list: use 'ins'"); 47cedef1ccf0d53693b5e62d524e7ba6b2122231c7Chris Lattner } else 4861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getName() + ": invalid input list: use 'ins'"); 49e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 506cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner unsigned MIOperandNo = 0; 516cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner std::set<std::string> OperandNames; 52f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner for (unsigned i = 0, e = InDI->getNumArgs()+OutDI->getNumArgs(); i != e; ++i){ 5305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *ArgInit; 54f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner std::string ArgName; 55f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner if (i < NumDefs) { 56f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner ArgInit = OutDI->getArg(i); 57f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner ArgName = OutDI->getArgName(i); 58f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner } else { 59f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner ArgInit = InDI->getArg(i-NumDefs); 60f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner ArgName = InDI->getArgName(i-NumDefs); 61f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner } 62e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 636cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *Arg = dyn_cast<DefInit>(ArgInit); 646cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (!Arg) 6561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Illegal operand for the '" + R->getName() + "' instruction!"); 66e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 676cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner Record *Rec = Arg->getDef(); 686cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner std::string PrintMethod = "printOperand"; 695013f7469ec44adba127de65517e699180ee532fJim Grosbach std::string EncoderMethod; 705196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer std::string OperandType = "OPERAND_UNKNOWN"; 716cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner unsigned NumOps = 1; 72dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines DagInit *MIOpInfo = nullptr; 73bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (Rec->isSubClassOf("RegisterOperand")) { 74bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson PrintMethod = Rec->getValueAsString("PrintMethod"); 75bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } else if (Rec->isSubClassOf("Operand")) { 766cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner PrintMethod = Rec->getValueAsString("PrintMethod"); 775196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer OperandType = Rec->getValueAsString("OperandType"); 785013f7469ec44adba127de65517e699180ee532fJim Grosbach // If there is an explicit encoder method, use it. 792ac190238e88b21e716e2853900b5076c9013410Chris Lattner EncoderMethod = Rec->getValueAsString("EncoderMethod"); 806cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner MIOpInfo = Rec->getValueAsDag("MIOperandInfo"); 81e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 826cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Verify that MIOpInfo has an 'ops' root value. 833f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (!isa<DefInit>(MIOpInfo->getOperator()) || 843f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva cast<DefInit>(MIOpInfo->getOperator())->getDef()->getName() != "ops") 8561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Bad value for MIOperandInfo in operand '" + Rec->getName() + 8661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "'\n"); 87e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 886cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // If we have MIOpInfo, then we have #operands equal to number of entries 896cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // in MIOperandInfo. 906cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (unsigned NumArgs = MIOpInfo->getNumArgs()) 916cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner NumOps = NumArgs; 92e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 93f7ab3a84b3e1b5a647ae9456a5edb99d86b35329Tim Northover if (Rec->isSubClassOf("PredicateOp")) 946cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner isPredicable = true; 956cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner else if (Rec->isSubClassOf("OptionalDefOperand")) 966cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner hasOptionalDef = true; 976cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner } else if (Rec->getName() == "variable_ops") { 988f707e15fbd09ca948b86419bcb0c92470827ac9Chris Lattner isVariadic = true; 996cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner continue; 1005196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer } else if (Rec->isSubClassOf("RegisterClass")) { 1015196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer OperandType = "OPERAND_REGISTER"; 1025196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer } else if (!Rec->isSubClassOf("PointerLikeRegClass") && 10383c0eefa3b4698edd007a4cb24d550fd42566063Owen Anderson !Rec->isSubClassOf("unknown_class")) 10461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Unknown operand class '" + Rec->getName() + 10561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' in '" + R->getName() + "' instruction!"); 106e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1076cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Check that the operand has a name and that it's unique. 108f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner if (ArgName.empty()) 10936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PrintFatalError("In instruction '" + R->getName() + "', operand #" + 11036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Twine(i) + " has no name!"); 111f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner if (!OperandNames.insert(ArgName).second) 11236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PrintFatalError("In instruction '" + R->getName() + "', operand #" + 11336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Twine(i) + " has the same name as a previous operand!"); 114e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1155013f7469ec44adba127de65517e699180ee532fJim Grosbach OperandList.push_back(OperandInfo(Rec, ArgName, PrintMethod, EncoderMethod, 1165196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer OperandType, MIOperandNo, NumOps, 1175196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer MIOpInfo)); 1186cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner MIOperandNo += NumOps; 1196cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner } 120e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 121e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 122b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner // Make sure the constraints list for each operand is large enough to hold 123b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner // constraint info, even if none is present. 124b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner for (unsigned i = 0, e = OperandList.size(); i != e; ++i) 125b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner OperandList[i].Constraints.resize(OperandList[i].MINumOperands); 1266cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner} 1276cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner 128c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 1296cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner/// getOperandNamed - Return the index of the operand with the specified 1306cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner/// non-empty name. If the instruction does not have an operand with the 13161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// specified name, abort. 1326cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner/// 133c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattnerunsigned CGIOperandList::getOperandNamed(StringRef Name) const { 13401855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach unsigned OpIdx; 13501855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach if (hasOperandNamed(Name, OpIdx)) return OpIdx; 13636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PrintFatalError("'" + TheDef->getName() + 13736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "' does not have an operand named '$" + Name + "'!"); 1386cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner} 1396cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner 14001855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach/// hasOperandNamed - Query whether the instruction has an operand of the 14101855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach/// given name. If so, return true and set OpIdx to the index of the 14201855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach/// operand. Otherwise, return false. 143c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattnerbool CGIOperandList::hasOperandNamed(StringRef Name, unsigned &OpIdx) const { 14401855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach assert(!Name.empty() && "Cannot search for operand with no name!"); 14501855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach for (unsigned i = 0, e = OperandList.size(); i != e; ++i) 14601855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach if (OperandList[i].Name == Name) { 14701855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach OpIdx = i; 14801855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach return true; 14901855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach } 15001855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach return false; 15101855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach} 15201855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach 153f0a4fad9957bf5c088d61ff78067d83d23fae19cJim Grosbachstd::pair<unsigned,unsigned> 154c240bb0ede0541426254d0e0dc81d891beda4b22Chris LattnerCGIOperandList::ParseOperandName(const std::string &Op, bool AllowWholeOp) { 1556cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (Op.empty() || Op[0] != '$') 15661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(TheDef->getName() + ": Illegal operand name: '" + Op + "'"); 157e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1586cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner std::string OpName = Op.substr(1); 1596cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner std::string SubOpName; 160e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1616cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Check to see if this is $foo.bar. 1626cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner std::string::size_type DotIdx = OpName.find_first_of("."); 1636cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (DotIdx != std::string::npos) { 1646cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner SubOpName = OpName.substr(DotIdx+1); 1656cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (SubOpName.empty()) 16661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(TheDef->getName() + ": illegal empty suboperand name in '" +Op +"'"); 1676cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner OpName = OpName.substr(0, DotIdx); 1686cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner } 169e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1706cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner unsigned OpIdx = getOperandNamed(OpName); 171e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1726cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (SubOpName.empty()) { // If no suboperand name was specified: 1736cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // If one was needed, throw. 1746cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (OperandList[OpIdx].MINumOperands > 1 && !AllowWholeOp && 1756cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner SubOpName.empty()) 17661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(TheDef->getName() + ": Illegal to refer to" 17761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger " whole operand part of complex operand '" + Op + "'"); 178e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1796cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Otherwise, return the operand. 1806cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner return std::make_pair(OpIdx, 0U); 1816cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner } 182e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1836cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Find the suboperand number involved. 18405bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo; 185dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!MIOpInfo) 18661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(TheDef->getName() + ": unknown suboperand name in '" + Op + "'"); 187e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1886cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Find the operand with the right name. 1896cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner for (unsigned i = 0, e = MIOpInfo->getNumArgs(); i != e; ++i) 1906cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (MIOpInfo->getArgName(i) == SubOpName) 1916cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner return std::make_pair(OpIdx, i); 192e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1936cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Otherwise, didn't find it! 19461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(TheDef->getName() + ": unknown suboperand name in '" + Op + "'"); 1953369599db29739cd94087c34d0f7df8d00c00eb1Aaron Ballman return std::make_pair(0U, 0U); 1966cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner} 1979414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner 198c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattnerstatic void ParseConstraint(const std::string &CStr, CGIOperandList &Ops) { 199c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // EARLY_CLOBBER: @early $reg 200c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::string::size_type wpos = CStr.find_first_of(" \t"); 201c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::string::size_type start = CStr.find_first_not_of(" \t"); 202c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::string Tok = CStr.substr(start, wpos - start); 203c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (Tok == "@earlyclobber") { 204c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::string Name = CStr.substr(wpos+1); 205c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner wpos = Name.find_first_not_of(" \t"); 206c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (wpos == std::string::npos) 20761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Illegal format for @earlyclobber constraint: '" + CStr + "'"); 208c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Name = Name.substr(wpos); 209c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::pair<unsigned,unsigned> Op = Ops.ParseOperandName(Name, false); 210e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 211c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Build the string for the operand 212c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (!Ops[Op.first].Constraints[Op.second].isNone()) 21361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Operand '" + Name + "' cannot have multiple constraints!"); 214c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Ops[Op.first].Constraints[Op.second] = 215c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner CGIOperandList::ConstraintInfo::getEarlyClobber(); 216c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner return; 217c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner } 218e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 219c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Only other constraint is "TIED_TO" for now. 220c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::string::size_type pos = CStr.find_first_of('='); 221c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner assert(pos != std::string::npos && "Unrecognized constraint"); 222c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner start = CStr.find_first_not_of(" \t"); 223c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::string Name = CStr.substr(start, pos - start); 224e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 225c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // TIED_TO: $src1 = $dst 226c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner wpos = Name.find_first_of(" \t"); 227c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (wpos == std::string::npos) 22861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Illegal format for tied-to constraint: '" + CStr + "'"); 229c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::string DestOpName = Name.substr(0, wpos); 230c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::pair<unsigned,unsigned> DestOp = Ops.ParseOperandName(DestOpName, false); 231e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 232c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Name = CStr.substr(pos+1); 233c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner wpos = Name.find_first_not_of(" \t"); 234c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (wpos == std::string::npos) 23561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Illegal format for tied-to constraint: '" + CStr + "'"); 236e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 23764486737d59c835725c61c96511beeff7e31f403Lang Hames std::string SrcOpName = Name.substr(wpos); 23864486737d59c835725c61c96511beeff7e31f403Lang Hames std::pair<unsigned,unsigned> SrcOp = Ops.ParseOperandName(SrcOpName, false); 23964486737d59c835725c61c96511beeff7e31f403Lang Hames if (SrcOp > DestOp) { 24064486737d59c835725c61c96511beeff7e31f403Lang Hames std::swap(SrcOp, DestOp); 24164486737d59c835725c61c96511beeff7e31f403Lang Hames std::swap(SrcOpName, DestOpName); 24264486737d59c835725c61c96511beeff7e31f403Lang Hames } 243e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 244c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner unsigned FlatOpNo = Ops.getFlattenedOperandNumber(SrcOp); 245e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 246c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (!Ops[DestOp.first].Constraints[DestOp.second].isNone()) 24761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Operand '" + DestOpName + 24861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "' cannot have multiple constraints!"); 249c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Ops[DestOp.first].Constraints[DestOp.second] = 2502a8cd57566dd0eb62831b4c7429e46947a52a879Jim Grosbach CGIOperandList::ConstraintInfo::getTied(FlatOpNo); 251c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner} 252c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 253c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattnerstatic void ParseConstraints(const std::string &CStr, CGIOperandList &Ops) { 254c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (CStr.empty()) return; 255e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 256c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner const std::string delims(","); 257c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::string::size_type bidx, eidx; 258e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 259c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner bidx = CStr.find_first_not_of(delims); 260c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner while (bidx != std::string::npos) { 261c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner eidx = CStr.find_first_of(delims, bidx); 262c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (eidx == std::string::npos) 263c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner eidx = CStr.length(); 264e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 265c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner ParseConstraint(CStr.substr(bidx, eidx - bidx), Ops); 266c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner bidx = CStr.find_first_not_of(delims, eidx); 267c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner } 268c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner} 269c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 270c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattnervoid CGIOperandList::ProcessDisableEncoding(std::string DisableEncoding) { 271c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner while (1) { 272c30a38f34bdfecb99ce49e3ffa479039c9bf0209Chris Lattner std::pair<StringRef, StringRef> P = getToken(DisableEncoding, " ,\t"); 273c30a38f34bdfecb99ce49e3ffa479039c9bf0209Chris Lattner std::string OpName = P.first; 274c30a38f34bdfecb99ce49e3ffa479039c9bf0209Chris Lattner DisableEncoding = P.second; 275c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (OpName.empty()) break; 276e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 277c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Figure out which operand this is. 278c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::pair<unsigned,unsigned> Op = ParseOperandName(OpName, false); 279e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 280c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Mark the operand as not-to-be encoded. 281c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (Op.second >= OperandList[Op.first].DoNotEncode.size()) 282c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner OperandList[Op.first].DoNotEncode.resize(Op.second+1); 283c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner OperandList[Op.first].DoNotEncode[Op.second] = true; 284c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner } 285e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 286c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner} 287c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 288c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner//===----------------------------------------------------------------------===// 289c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner// CodeGenInstruction Implementation 290c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner//===----------------------------------------------------------------------===// 291c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 292912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund OlesenCodeGenInstruction::CodeGenInstruction(Record *R) 293dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : TheDef(R), Operands(R), InferredFrom(nullptr) { 294c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Namespace = R->getValueAsString("Namespace"); 295c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner AsmString = R->getValueAsString("AsmString"); 296c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 297c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isReturn = R->getValueAsBit("isReturn"); 298c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isBranch = R->getValueAsBit("isBranch"); 299c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isIndirectBranch = R->getValueAsBit("isIndirectBranch"); 300c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isCompare = R->getValueAsBit("isCompare"); 301c4af4638dfdab0dc3b6257276cfad2ee45053060Evan Cheng isMoveImm = R->getValueAsBit("isMoveImm"); 3020f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng isBitcast = R->getValueAsBit("isBitcast"); 303f2c64ef519b38a4328809b27b4a3a8e0c26e9709Jakob Stoklund Olesen isSelect = R->getValueAsBit("isSelect"); 304c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isBarrier = R->getValueAsBit("isBarrier"); 305c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isCall = R->getValueAsBit("isCall"); 306c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner canFoldAsLoad = R->getValueAsBit("canFoldAsLoad"); 307c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isPredicable = Operands.isPredicable || R->getValueAsBit("isPredicable"); 308c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isConvertibleToThreeAddress = R->getValueAsBit("isConvertibleToThreeAddress"); 309c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isCommutable = R->getValueAsBit("isCommutable"); 310c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isTerminator = R->getValueAsBit("isTerminator"); 311c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isReMaterializable = R->getValueAsBit("isReMaterializable"); 312c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner hasDelaySlot = R->getValueAsBit("hasDelaySlot"); 313c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner usesCustomInserter = R->getValueAsBit("usesCustomInserter"); 31483a8031336a1155e6b0c3e9a84164324e08d1c8bAndrew Trick hasPostISelHook = R->getValueAsBit("hasPostISelHook"); 315c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner hasCtrlDep = R->getValueAsBit("hasCtrlDep"); 316c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isNotDuplicable = R->getValueAsBit("isNotDuplicable"); 317c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 31836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool Unset; 31936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines mayLoad = R->getValueAsBitOrUnset("mayLoad", Unset); 32036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines mayLoad_Unset = Unset; 32136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines mayStore = R->getValueAsBitOrUnset("mayStore", Unset); 32236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines mayStore_Unset = Unset; 32336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines hasSideEffects = R->getValueAsBitOrUnset("hasSideEffects", Unset); 32436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines hasSideEffects_Unset = Unset; 325c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner neverHasSideEffects = R->getValueAsBit("neverHasSideEffects"); 326c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 327c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isAsCheapAsAMove = R->getValueAsBit("isAsCheapAsAMove"); 328c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner hasExtraSrcRegAllocReq = R->getValueAsBit("hasExtraSrcRegAllocReq"); 329c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner hasExtraDefRegAllocReq = R->getValueAsBit("hasExtraDefRegAllocReq"); 330e727d67c585ae8d4779ddd29490d9009cfc8e845Jim Grosbach isCodeGenOnly = R->getValueAsBit("isCodeGenOnly"); 331806fcc040e0bc7962891f12d6e09fc86f0bc2184Jim Grosbach isPseudo = R->getValueAsBit("isPseudo"); 332c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner ImplicitDefs = R->getValueAsListOfDefs("Defs"); 333c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner ImplicitUses = R->getValueAsListOfDefs("Uses"); 334c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 335c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (neverHasSideEffects + hasSideEffects > 1) 33661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getName() + ": multiple conflicting side-effect flags set!"); 337c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 338c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Parse Constraints. 339c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner ParseConstraints(R->getValueAsString("Constraints"), Operands); 340c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 341c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Parse the DisableEncoding field. 342c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Operands.ProcessDisableEncoding(R->getValueAsString("DisableEncoding")); 343715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly 344715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly // First check for a ComplexDeprecationPredicate. 345715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly if (R->getValue("ComplexDeprecationPredicate")) { 346715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly HasComplexDeprecationPredicate = true; 347715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly DeprecatedReason = R->getValueAsString("ComplexDeprecationPredicate"); 348715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly } else if (RecordVal *Dep = R->getValue("DeprecatedFeatureMask")) { 349715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly // Check if we have a Subtarget feature mask. 350715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly HasComplexDeprecationPredicate = false; 351715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly DeprecatedReason = Dep->getValue()->getAsString(); 352715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly } else { 353715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly // This instruction isn't deprecated. 354715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly HasComplexDeprecationPredicate = false; 355715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly DeprecatedReason = ""; 356715d98d657491b3fb8ea0e14643e9801b2f9628cJoey Gouly } 357c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner} 3589414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner 3599414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner/// HasOneImplicitDefWithKnownVT - If the instruction has at least one 3609414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner/// implicit def and it has a known VT, return the VT, otherwise return 3619414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner/// MVT::Other. 3629414ae52911f1d62cabd5108e0381b9d17476157Chris LattnerMVT::SimpleValueType CodeGenInstruction:: 3639414ae52911f1d62cabd5108e0381b9d17476157Chris LattnerHasOneImplicitDefWithKnownVT(const CodeGenTarget &TargetInfo) const { 3649414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (ImplicitDefs.empty()) return MVT::Other; 365e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3669414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // Check to see if the first implicit def has a resolvable type. 3679414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner Record *FirstImplicitDef = ImplicitDefs[0]; 3689414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner assert(FirstImplicitDef->isSubClassOf("Register")); 369e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi const std::vector<MVT::SimpleValueType> &RegVTs = 3709414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner TargetInfo.getRegisterVTs(FirstImplicitDef); 3719414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (RegVTs.size() == 1) 3729414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner return RegVTs[0]; 3739414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner return MVT::Other; 3749414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner} 3759414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner 3764d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner 3774d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner/// FlattenAsmStringVariants - Flatten the specified AsmString to only 3784d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner/// include text from the specified variant, returning the new string. 3794d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattnerstd::string CodeGenInstruction:: 3804d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris LattnerFlattenAsmStringVariants(StringRef Cur, unsigned Variant) { 3814d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner std::string Res = ""; 382e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3834d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner for (;;) { 3844d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner // Find the start of the next variant string. 3854d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner size_t VariantsStart = 0; 3864d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner for (size_t e = Cur.size(); VariantsStart != e; ++VariantsStart) 3874d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner if (Cur[VariantsStart] == '{' && 3884d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner (VariantsStart == 0 || (Cur[VariantsStart-1] != '$' && 3894d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Cur[VariantsStart-1] != '\\'))) 3904d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner break; 391e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3924d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner // Add the prefix to the result. 3934d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Res += Cur.slice(0, VariantsStart); 3944d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner if (VariantsStart == Cur.size()) 3954d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner break; 396e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3974d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner ++VariantsStart; // Skip the '{'. 398e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3994d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner // Scan to the end of the variants string. 4004d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner size_t VariantsEnd = VariantsStart; 4014d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner unsigned NestedBraces = 1; 4024d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner for (size_t e = Cur.size(); VariantsEnd != e; ++VariantsEnd) { 4034d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner if (Cur[VariantsEnd] == '}' && Cur[VariantsEnd-1] != '\\') { 4044d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner if (--NestedBraces == 0) 4054d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner break; 4064d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner } else if (Cur[VariantsEnd] == '{') 4074d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner ++NestedBraces; 4084d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner } 409e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 4104d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner // Select the Nth variant (or empty). 4114d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner StringRef Selection = Cur.slice(VariantsStart, VariantsEnd); 4124d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner for (unsigned i = 0; i != Variant; ++i) 4134d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Selection = Selection.split('|').second; 4144d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Res += Selection.split('|').first; 415e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 4164d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner assert(VariantsEnd != Cur.size() && 4174d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner "Unterminated variants in assembly string!"); 4184d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Cur = Cur.substr(VariantsEnd + 1); 4194d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner } 420e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 4214d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner return Res; 4224d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner} 4234d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner 424c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner 425c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner//===----------------------------------------------------------------------===// 426c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner/// CodeGenInstAlias Implementation 427c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner//===----------------------------------------------------------------------===// 428c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner 429a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson/// tryAliasOpMatch - This is a helper function for the CodeGenInstAlias 430a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson/// constructor. It checks if an argument in an InstAlias pattern matches 431a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson/// the corresponding operand of the instruction. It returns true on a 432a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson/// successful match, with ResOp set to the result operand to be used. 43305bce0beee87512e52428d4b80f5a8e79a949576David Greenebool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo, 434a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson Record *InstOpRec, bool hasSubOps, 435376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen ArrayRef<SMLoc> Loc, CodeGenTarget &T, 436a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResultOperand &ResOp) { 43705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Arg = Result->getArg(AliasOpNo); 4386cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *ADI = dyn_cast<DefInit>(Arg); 439dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Record *ResultRecord = ADI ? ADI->getDef() : nullptr; 440a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 441a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (ADI && ADI->getDef() == InstOpRec) { 442a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // If the operand is a record, it must have a name, and the record type 443a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // must match up with the instruction's argument type. 444a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (Result->getArgName(AliasOpNo).empty()) 44536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PrintFatalError(Loc, "result argument #" + Twine(AliasOpNo) + 44636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines " must have a name!"); 44736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ResOp = ResultOperand(Result->getArgName(AliasOpNo), ResultRecord); 448a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return true; 449a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 450a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 451be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach // For register operands, the source register class can be a subclass 452be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach // of the instruction register class, not just an exact match. 45336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (InstOpRec->isSubClassOf("RegisterOperand")) 45436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines InstOpRec = InstOpRec->getValueAsDef("RegClass"); 45536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 45636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (ADI && ADI->getDef()->isSubClassOf("RegisterOperand")) 45736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ADI = ADI->getDef()->getValueAsDef("RegClass")->getDefInit(); 45836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 459be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach if (ADI && ADI->getDef()->isSubClassOf("RegisterClass")) { 460be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach if (!InstOpRec->isSubClassOf("RegisterClass")) 461be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach return false; 46248c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach if (!T.getRegisterClass(InstOpRec) 46348c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach .hasSubClass(&T.getRegisterClass(ADI->getDef()))) 46448c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach return false; 46536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ResOp = ResultOperand(Result->getArgName(AliasOpNo), ResultRecord); 46648c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach return true; 467be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach } 468be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach 469a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // Handle explicit registers. 470a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (ADI && ADI->getDef()->isSubClassOf("Register")) { 471c68e927488819efd671207786baadce6cae7266cJim Grosbach if (InstOpRec->isSubClassOf("OptionalDefOperand")) { 472c68e927488819efd671207786baadce6cae7266cJim Grosbach DagInit *DI = InstOpRec->getValueAsDag("MIOperandInfo"); 473c68e927488819efd671207786baadce6cae7266cJim Grosbach // The operand info should only have a single (register) entry. We 474c68e927488819efd671207786baadce6cae7266cJim Grosbach // want the register class of it. 4753f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva InstOpRec = cast<DefInit>(DI->getArg(0))->getDef(); 476c68e927488819efd671207786baadce6cae7266cJim Grosbach } 477c68e927488819efd671207786baadce6cae7266cJim Grosbach 478a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (!InstOpRec->isSubClassOf("RegisterClass")) 479a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return false; 480a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 481ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen if (!T.getRegisterClass(InstOpRec) 482ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen .contains(T.getRegBank().getReg(ADI->getDef()))) 48361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(Loc, "fixed register " + ADI->getDef()->getName() + 48461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger " is not a member of the " + InstOpRec->getName() + 48561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger " register class!"); 486a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 487a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (!Result->getArgName(AliasOpNo).empty()) 48861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(Loc, "result fixed register argument must " 48961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "not have a name!"); 490a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 49136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ResOp = ResultOperand(ResultRecord); 492a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return true; 493a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 494a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 495a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // Handle "zero_reg" for optional def operands. 496a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (ADI && ADI->getDef()->getName() == "zero_reg") { 497a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 498a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // Check if this is an optional def. 499bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // Tied operands where the source is a sub-operand of a complex operand 500bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // need to represent both operands in the alias destination instruction. 501bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // Allow zero_reg for the tied portion. This can and should go away once 502bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // the MC representation of things doesn't use tied operands at all. 503bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach //if (!InstOpRec->isSubClassOf("OptionalDefOperand")) 504bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // throw TGError(Loc, "reg0 used for result that is not an " 505bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // "OptionalDefOperand!"); 506a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 507dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ResOp = ResultOperand(static_cast<Record*>(nullptr)); 508a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return true; 509a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 510a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 51148c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // Literal integers. 5126cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(Arg)) { 513a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (hasSubOps || !InstOpRec->isSubClassOf("Operand")) 514a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return false; 515a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // Integer arguments can't have names. 516a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (!Result->getArgName(AliasOpNo).empty()) 51736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PrintFatalError(Loc, "result argument #" + Twine(AliasOpNo) + 51861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger " must not have a name!"); 519a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResOp = ResultOperand(II->getValue()); 520a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return true; 521a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 522a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 52348c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // If both are Operands with the same MVT, allow the conversion. It's 52448c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // up to the user to make sure the values are appropriate, just like 52548c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // for isel Pat's. 52648c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach if (InstOpRec->isSubClassOf("Operand") && 52748c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach ADI->getDef()->isSubClassOf("Operand")) { 52848c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // FIXME: What other attributes should we check here? Identical 52948c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // MIOperandInfo perhaps? 53048c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach if (InstOpRec->getValueInit("Type") != ADI->getDef()->getValueInit("Type")) 53148c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach return false; 53248c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach ResOp = ResultOperand(Result->getArgName(AliasOpNo), ADI->getDef()); 53348c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach return true; 53448c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach } 53548c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach 536a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return false; 537a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson} 538a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 539dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesunsigned CodeGenInstAlias::ResultOperand::getMINumOperands() const { 540dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!isRecord()) 541dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return 1; 542dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 543dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Record *Rec = getRecord(); 544dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Rec->isSubClassOf("Operand")) 545dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return 1; 546dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 547dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines DagInit *MIOpInfo = Rec->getValueAsDag("MIOperandInfo"); 548dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (MIOpInfo->getNumArgs() == 0) { 549dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Unspecified, so it defaults to 1 550dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return 1; 551dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 552dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 553dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return MIOpInfo->getNumArgs(); 554dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines} 555dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 556dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen HinesCodeGenInstAlias::CodeGenInstAlias(Record *R, unsigned Variant, 557dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CodeGenTarget &T) 558dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : TheDef(R) { 559b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner Result = R->getValueAsDag("ResultInst"); 560dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines AsmString = R->getValueAsString("AsmString"); 561dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines AsmString = CodeGenInstruction::FlattenAsmStringVariants(AsmString, Variant); 562dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 563225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner 564225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner // Verify that the root of the result is an instruction. 5656cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *DI = dyn_cast<DefInit>(Result->getOperator()); 566dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!DI || !DI->getDef()->isSubClassOf("Instruction")) 56761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getLoc(), 56861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger "result of inst alias should be an instruction"); 569225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner 570225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner ResultInst = &T.getInstruction(DI->getDef()); 571e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 5723f2c8e474b8775aa1f3c2c0cb817b7f9f564e068Chris Lattner // NameClass - If argument names are repeated, we need to verify they have 5733f2c8e474b8775aa1f3c2c0cb817b7f9f564e068Chris Lattner // the same class. 5743f2c8e474b8775aa1f3c2c0cb817b7f9f564e068Chris Lattner StringMap<Record*> NameClass; 57555931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson for (unsigned i = 0, e = Result->getNumArgs(); i != e; ++i) { 5766cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *ADI = dyn_cast<DefInit>(Result->getArg(i)); 57755931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson if (!ADI || Result->getArgName(i).empty()) 57855931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson continue; 57955931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson // Verify we don't have something like: (someinst GR16:$foo, GR32:$foo) 58055931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson // $foo can exist multiple times in the result list, but it must have the 58155931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson // same type. 58255931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson Record *&Entry = NameClass[Result->getArgName(i)]; 58355931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson if (Entry && Entry != ADI->getDef()) 58461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getLoc(), "result value $" + Result->getArgName(i) + 58561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger " is both " + Entry->getName() + " and " + 58661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger ADI->getDef()->getName() + "!"); 58755931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson Entry = ADI->getDef(); 58855931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson } 589e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 590d0f225cafc76ee2d4982c207c6afb25aaf176d12Chris Lattner // Decode and validate the arguments of the result. 591414098571b19fc248fda2be194082cfd012d2729Chris Lattner unsigned AliasOpNo = 0; 592414098571b19fc248fda2be194082cfd012d2729Chris Lattner for (unsigned i = 0, e = ResultInst->Operands.size(); i != e; ++i) { 593a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 594bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // Tied registers don't have an entry in the result dag unless they're part 595bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // of a complex operand, in which case we include them anyways, as we 596bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // don't have any other way to specify the whole operand. 597bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach if (ResultInst->Operands[i].MINumOperands == 1 && 598bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach ResultInst->Operands[i].getTiedRegister() != -1) 599414098571b19fc248fda2be194082cfd012d2729Chris Lattner continue; 600414098571b19fc248fda2be194082cfd012d2729Chris Lattner 601414098571b19fc248fda2be194082cfd012d2729Chris Lattner if (AliasOpNo >= Result->getNumArgs()) 60261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getLoc(), "not enough arguments for instruction!"); 603a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 604a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson Record *InstOpRec = ResultInst->Operands[i].Rec; 605a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson unsigned NumSubOps = ResultInst->Operands[i].MINumOperands; 606a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResultOperand ResOp(static_cast<int64_t>(0)); 607a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (tryAliasOpMatch(Result, AliasOpNo, InstOpRec, (NumSubOps > 1), 608a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson R->getLoc(), T, ResOp)) { 6097e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // If this is a simple operand, or a complex operand with a custom match 6107e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // class, then we can match is verbatim. 6117e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson if (NumSubOps == 1 || 6127e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson (InstOpRec->getValue("ParserMatchClass") && 6137e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson InstOpRec->getValueAsDef("ParserMatchClass") 6147e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ->getValueAsString("Name") != "Imm")) { 6157e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultOperands.push_back(ResOp); 6167e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultInstOperandIndex.push_back(std::make_pair(i, -1)); 6177e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ++AliasOpNo; 6187e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson 6197e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // Otherwise, we need to match each of the suboperands individually. 6207e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson } else { 6217e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo; 6227e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { 6233f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef(); 6247e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson 6257e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // Take care to instantiate each of the suboperands with the correct 6267e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // nomenclature: $foo.bar 6277e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultOperands.push_back( 6287e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultOperand(Result->getArgName(AliasOpNo) + "." + 6297e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson MIOI->getArgName(SubOp), SubRec)); 6307e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultInstOperandIndex.push_back(std::make_pair(i, SubOp)); 6317e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson } 6327e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ++AliasOpNo; 6337e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson } 634d0f225cafc76ee2d4982c207c6afb25aaf176d12Chris Lattner continue; 635d0f225cafc76ee2d4982c207c6afb25aaf176d12Chris Lattner } 636e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 637a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // If the argument did not match the instruction operand, and the operand 638a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // is composed of multiple suboperands, try matching the suboperands. 639a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (NumSubOps > 1) { 64005bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo; 641a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { 642a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (AliasOpNo >= Result->getNumArgs()) 64361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getLoc(), "not enough arguments for instruction!"); 6443f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva Record *SubRec = cast<DefInit>(MIOI->getArg(SubOp))->getDef(); 645a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false, 646a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson R->getLoc(), T, ResOp)) { 647a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResultOperands.push_back(ResOp); 648a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResultInstOperandIndex.push_back(std::make_pair(i, SubOp)); 649a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ++AliasOpNo; 650a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } else { 65136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PrintFatalError(R->getLoc(), "result argument #" + Twine(AliasOpNo) + 652a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson " does not match instruction operand class " + 653a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson (SubOp == 0 ? InstOpRec->getName() :SubRec->getName())); 654a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 655a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 65698c870f87b7f0c996a9ba67003d88d434d6dbcd0Chris Lattner continue; 65798c870f87b7f0c996a9ba67003d88d434d6dbcd0Chris Lattner } 65836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PrintFatalError(R->getLoc(), "result argument #" + Twine(AliasOpNo) + 65961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger " does not match instruction operand class " + 66061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger InstOpRec->getName()); 661d0f225cafc76ee2d4982c207c6afb25aaf176d12Chris Lattner } 662e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 663414098571b19fc248fda2be194082cfd012d2729Chris Lattner if (AliasOpNo != Result->getNumArgs()) 66461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getLoc(), "too many operands for instruction!"); 665c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner} 666