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" 167c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#include "llvm/TableGen/Error.h" 177c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#include "llvm/TableGen/Record.h" 186cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner#include "llvm/ADT/StringExtras.h" 193f2c8e474b8775aa1f3c2c0cb817b7f9f564e068Chris Lattner#include "llvm/ADT/StringMap.h" 20d4f195999a7774611e5f9e457a86f14d5e257324Benjamin Kramer#include "llvm/ADT/STLExtras.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 3505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *Init = dynamic_cast<DefInit*>(OutDI->getOperator())) { 36b0be4d261b1ebd0e364e3e8b5e5f124c1e7b96b5Chris Lattner if (Init->getDef()->getName() != "outs") 37cedef1ccf0d53693b5e62d524e7ba6b2122231c7Chris Lattner throw R->getName() + ": invalid def name for output list: use 'outs'"; 38cedef1ccf0d53693b5e62d524e7ba6b2122231c7Chris Lattner } else 39cedef1ccf0d53693b5e62d524e7ba6b2122231c7Chris Lattner throw R->getName() + ": invalid output list: use 'outs'"; 40e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 41f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner NumDefs = OutDI->getNumArgs(); 42c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 4305bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *InDI = R->getValueAsDag("InOperandList"); 4405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *Init = dynamic_cast<DefInit*>(InDI->getOperator())) { 45b0be4d261b1ebd0e364e3e8b5e5f124c1e7b96b5Chris Lattner if (Init->getDef()->getName() != "ins") 46cedef1ccf0d53693b5e62d524e7ba6b2122231c7Chris Lattner throw R->getName() + ": invalid def name for input list: use 'ins'"; 47cedef1ccf0d53693b5e62d524e7ba6b2122231c7Chris Lattner } else 48cedef1ccf0d53693b5e62d524e7ba6b2122231c7Chris Lattner throw 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 6305bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *Arg = dynamic_cast<DefInit*>(ArgInit); 646cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (!Arg) 656cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw "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; 7205bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *MIOpInfo = 0; 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. 8305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (!dynamic_cast<DefInit*>(MIOpInfo->getOperator()) || 8405bce0beee87512e52428d4b80f5a8e79a949576David Greene dynamic_cast<DefInit*>(MIOpInfo->getOperator()) 85c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner ->getDef()->getName() != "ops") 866cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw "Bad value for MIOperandInfo in operand '" + Rec->getName() + 87c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner "'\n"; 88e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 896cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // If we have MIOpInfo, then we have #operands equal to number of entries 906cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // in MIOperandInfo. 916cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (unsigned NumArgs = MIOpInfo->getNumArgs()) 926cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner NumOps = NumArgs; 93e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 946cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (Rec->isSubClassOf("PredicateOperand")) 956cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner isPredicable = true; 966cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner else if (Rec->isSubClassOf("OptionalDefOperand")) 976cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner hasOptionalDef = true; 986cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner } else if (Rec->getName() == "variable_ops") { 998f707e15fbd09ca948b86419bcb0c92470827ac9Chris Lattner isVariadic = true; 1006cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner continue; 1015196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer } else if (Rec->isSubClassOf("RegisterClass")) { 1025196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer OperandType = "OPERAND_REGISTER"; 1035196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer } else if (!Rec->isSubClassOf("PointerLikeRegClass") && 10436c3bc431b92f1573b3f3bd75b644774681998eeNAKAMURA Takumi Rec->getName() != "unknown") 1056cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw "Unknown operand class '" + Rec->getName() + 106c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner "' in '" + R->getName() + "' instruction!"; 107e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1086cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Check that the operand has a name and that it's unique. 109f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner if (ArgName.empty()) 1106cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw "In instruction '" + R->getName() + "', operand #" + utostr(i) + 111c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner " has no name!"; 112f55eed299b84a9312c3c112d59ff4e6cb048b795Chris Lattner if (!OperandNames.insert(ArgName).second) 1136cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw "In instruction '" + R->getName() + "', operand #" + utostr(i) + 114c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner " has the same name as a previous operand!"; 115e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1165013f7469ec44adba127de65517e699180ee532fJim Grosbach OperandList.push_back(OperandInfo(Rec, ArgName, PrintMethod, EncoderMethod, 1175196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer OperandType, MIOperandNo, NumOps, 1185196c12e9fdec9ef3c63d96cb529c1c1cb732773Benjamin Kramer MIOpInfo)); 1196cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner MIOperandNo += NumOps; 1206cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner } 121e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 122e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 123b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner // Make sure the constraints list for each operand is large enough to hold 124b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner // constraint info, even if none is present. 125b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner for (unsigned i = 0, e = OperandList.size(); i != e; ++i) 126b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner OperandList[i].Constraints.resize(OperandList[i].MINumOperands); 1276cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner} 1286cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner 129c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 1306cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner/// getOperandNamed - Return the index of the operand with the specified 1316cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner/// non-empty name. If the instruction does not have an operand with the 1326cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner/// specified name, throw an exception. 1336cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner/// 134c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattnerunsigned CGIOperandList::getOperandNamed(StringRef Name) const { 13501855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach unsigned OpIdx; 13601855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach if (hasOperandNamed(Name, OpIdx)) return OpIdx; 137e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi throw "'" + TheDef->getName() + "' does not have an operand named '$" + 138c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Name.str() + "'!"; 1396cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner} 1406cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner 14101855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach/// hasOperandNamed - Query whether the instruction has an operand of the 14201855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach/// given name. If so, return true and set OpIdx to the index of the 14301855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach/// operand. Otherwise, return false. 144c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattnerbool CGIOperandList::hasOperandNamed(StringRef Name, unsigned &OpIdx) const { 14501855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach assert(!Name.empty() && "Cannot search for operand with no name!"); 14601855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach for (unsigned i = 0, e = OperandList.size(); i != e; ++i) 14701855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach if (OperandList[i].Name == Name) { 14801855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach OpIdx = i; 14901855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach return true; 15001855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach } 15101855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach return false; 15201855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach} 15301855071e24e0e3e75306b82267d3ad0b13a0c15Jim Grosbach 154f0a4fad9957bf5c088d61ff78067d83d23fae19cJim Grosbachstd::pair<unsigned,unsigned> 155c240bb0ede0541426254d0e0dc81d891beda4b22Chris LattnerCGIOperandList::ParseOperandName(const std::string &Op, bool AllowWholeOp) { 1566cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (Op.empty() || Op[0] != '$') 1576cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw TheDef->getName() + ": Illegal operand name: '" + Op + "'"; 158e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1596cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner std::string OpName = Op.substr(1); 1606cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner std::string SubOpName; 161e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1626cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Check to see if this is $foo.bar. 1636cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner std::string::size_type DotIdx = OpName.find_first_of("."); 1646cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (DotIdx != std::string::npos) { 1656cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner SubOpName = OpName.substr(DotIdx+1); 1666cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (SubOpName.empty()) 1676cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw TheDef->getName() + ": illegal empty suboperand name in '" +Op +"'"; 1686cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner OpName = OpName.substr(0, DotIdx); 1696cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner } 170e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1716cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner unsigned OpIdx = getOperandNamed(OpName); 172e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1736cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (SubOpName.empty()) { // If no suboperand name was specified: 1746cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // If one was needed, throw. 1756cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (OperandList[OpIdx].MINumOperands > 1 && !AllowWholeOp && 1766cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner SubOpName.empty()) 1776cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw TheDef->getName() + ": Illegal to refer to" 178c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner " whole operand part of complex operand '" + Op + "'"; 179e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1806cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Otherwise, return the operand. 1816cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner return std::make_pair(OpIdx, 0U); 1826cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner } 183e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1846cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Find the suboperand number involved. 18505bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo; 1866cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (MIOpInfo == 0) 1876cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw TheDef->getName() + ": unknown suboperand name in '" + Op + "'"; 188e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1896cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Find the operand with the right name. 1906cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner for (unsigned i = 0, e = MIOpInfo->getNumArgs(); i != e; ++i) 1916cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner if (MIOpInfo->getArgName(i) == SubOpName) 1926cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner return std::make_pair(OpIdx, i); 193e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 1946cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner // Otherwise, didn't find it! 1956cc654b27a9d392ac7660afcb23e3c8136e9ab28Chris Lattner throw TheDef->getName() + ": unknown suboperand name in '" + Op + "'"; 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) 207c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner throw "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()) 213c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner throw "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) 228c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner throw "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) 235c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner throw "Illegal format for tied-to constraint: '" + CStr + "'"; 236e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 237c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::pair<unsigned,unsigned> SrcOp = 238c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Ops.ParseOperandName(Name.substr(wpos), false); 239c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (SrcOp > DestOp) 240c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner throw "Illegal tied-to operand constraint '" + CStr + "'"; 241e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 242e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 243c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner unsigned FlatOpNo = Ops.getFlattenedOperandNumber(SrcOp); 244e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 245c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (!Ops[DestOp.first].Constraints[DestOp.second].isNone()) 246c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner throw "Operand '" + DestOpName + "' cannot have multiple constraints!"; 247c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Ops[DestOp.first].Constraints[DestOp.second] = 2482a8cd57566dd0eb62831b4c7429e46947a52a879Jim Grosbach CGIOperandList::ConstraintInfo::getTied(FlatOpNo); 249c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner} 250c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 251c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattnerstatic void ParseConstraints(const std::string &CStr, CGIOperandList &Ops) { 252c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (CStr.empty()) return; 253e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 254c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner const std::string delims(","); 255c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::string::size_type bidx, eidx; 256e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 257c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner bidx = CStr.find_first_not_of(delims); 258c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner while (bidx != std::string::npos) { 259c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner eidx = CStr.find_first_of(delims, bidx); 260c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (eidx == std::string::npos) 261c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner eidx = CStr.length(); 262e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 263c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner ParseConstraint(CStr.substr(bidx, eidx - bidx), Ops); 264c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner bidx = CStr.find_first_not_of(delims, eidx); 265c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner } 266c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner} 267c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 268c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattnervoid CGIOperandList::ProcessDisableEncoding(std::string DisableEncoding) { 269c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner while (1) { 270c30a38f34bdfecb99ce49e3ffa479039c9bf0209Chris Lattner std::pair<StringRef, StringRef> P = getToken(DisableEncoding, " ,\t"); 271c30a38f34bdfecb99ce49e3ffa479039c9bf0209Chris Lattner std::string OpName = P.first; 272c30a38f34bdfecb99ce49e3ffa479039c9bf0209Chris Lattner DisableEncoding = P.second; 273c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (OpName.empty()) break; 274e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 275c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Figure out which operand this is. 276c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner std::pair<unsigned,unsigned> Op = ParseOperandName(OpName, false); 277e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 278c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Mark the operand as not-to-be encoded. 279c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (Op.second >= OperandList[Op.first].DoNotEncode.size()) 280c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner OperandList[Op.first].DoNotEncode.resize(Op.second+1); 281c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner OperandList[Op.first].DoNotEncode[Op.second] = true; 282c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner } 283e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 284c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner} 285c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 286c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner//===----------------------------------------------------------------------===// 287c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner// CodeGenInstruction Implementation 288c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner//===----------------------------------------------------------------------===// 289c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 290912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund OlesenCodeGenInstruction::CodeGenInstruction(Record *R) 291912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen : TheDef(R), Operands(R), InferredFrom(0) { 292c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Namespace = R->getValueAsString("Namespace"); 293c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner AsmString = R->getValueAsString("AsmString"); 294c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 295c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isReturn = R->getValueAsBit("isReturn"); 296c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isBranch = R->getValueAsBit("isBranch"); 297c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isIndirectBranch = R->getValueAsBit("isIndirectBranch"); 298c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isCompare = R->getValueAsBit("isCompare"); 299c4af4638dfdab0dc3b6257276cfad2ee45053060Evan Cheng isMoveImm = R->getValueAsBit("isMoveImm"); 3000f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng isBitcast = R->getValueAsBit("isBitcast"); 301f2c64ef519b38a4328809b27b4a3a8e0c26e9709Jakob Stoklund Olesen isSelect = R->getValueAsBit("isSelect"); 302c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isBarrier = R->getValueAsBit("isBarrier"); 303c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isCall = R->getValueAsBit("isCall"); 304c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner canFoldAsLoad = R->getValueAsBit("canFoldAsLoad"); 305c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isPredicable = Operands.isPredicable || R->getValueAsBit("isPredicable"); 306c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isConvertibleToThreeAddress = R->getValueAsBit("isConvertibleToThreeAddress"); 307c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isCommutable = R->getValueAsBit("isCommutable"); 308c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isTerminator = R->getValueAsBit("isTerminator"); 309c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isReMaterializable = R->getValueAsBit("isReMaterializable"); 310c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner hasDelaySlot = R->getValueAsBit("hasDelaySlot"); 311c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner usesCustomInserter = R->getValueAsBit("usesCustomInserter"); 31283a8031336a1155e6b0c3e9a84164324e08d1c8bAndrew Trick hasPostISelHook = R->getValueAsBit("hasPostISelHook"); 313c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner hasCtrlDep = R->getValueAsBit("hasCtrlDep"); 314c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isNotDuplicable = R->getValueAsBit("isNotDuplicable"); 315c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 316c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen mayLoad = R->getValueAsBitOrUnset("mayLoad", mayLoad_Unset); 317c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen mayStore = R->getValueAsBitOrUnset("mayStore", mayStore_Unset); 318c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen hasSideEffects = R->getValueAsBitOrUnset("hasSideEffects", 319c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen hasSideEffects_Unset); 320c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner neverHasSideEffects = R->getValueAsBit("neverHasSideEffects"); 321c1f10fd5b9a780d1c42dca7143d7a8acd9bd9377Jakob Stoklund Olesen 322c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner isAsCheapAsAMove = R->getValueAsBit("isAsCheapAsAMove"); 323c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner hasExtraSrcRegAllocReq = R->getValueAsBit("hasExtraSrcRegAllocReq"); 324c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner hasExtraDefRegAllocReq = R->getValueAsBit("hasExtraDefRegAllocReq"); 325e727d67c585ae8d4779ddd29490d9009cfc8e845Jim Grosbach isCodeGenOnly = R->getValueAsBit("isCodeGenOnly"); 326806fcc040e0bc7962891f12d6e09fc86f0bc2184Jim Grosbach isPseudo = R->getValueAsBit("isPseudo"); 327c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner ImplicitDefs = R->getValueAsListOfDefs("Defs"); 328c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner ImplicitUses = R->getValueAsListOfDefs("Uses"); 329c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 330c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (neverHasSideEffects + hasSideEffects > 1) 331c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner throw R->getName() + ": multiple conflicting side-effect flags set!"; 332c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 333c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Parse Constraints. 334c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner ParseConstraints(R->getValueAsString("Constraints"), Operands); 335c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner 336c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner // Parse the DisableEncoding field. 337c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Operands.ProcessDisableEncoding(R->getValueAsString("DisableEncoding")); 338c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner} 3399414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner 3409414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner/// HasOneImplicitDefWithKnownVT - If the instruction has at least one 3419414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner/// implicit def and it has a known VT, return the VT, otherwise return 3429414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner/// MVT::Other. 3439414ae52911f1d62cabd5108e0381b9d17476157Chris LattnerMVT::SimpleValueType CodeGenInstruction:: 3449414ae52911f1d62cabd5108e0381b9d17476157Chris LattnerHasOneImplicitDefWithKnownVT(const CodeGenTarget &TargetInfo) const { 3459414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (ImplicitDefs.empty()) return MVT::Other; 346e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3479414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // Check to see if the first implicit def has a resolvable type. 3489414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner Record *FirstImplicitDef = ImplicitDefs[0]; 3499414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner assert(FirstImplicitDef->isSubClassOf("Register")); 350e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi const std::vector<MVT::SimpleValueType> &RegVTs = 3519414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner TargetInfo.getRegisterVTs(FirstImplicitDef); 3529414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (RegVTs.size() == 1) 3539414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner return RegVTs[0]; 3549414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner return MVT::Other; 3559414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner} 3569414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner 3574d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner 3584d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner/// FlattenAsmStringVariants - Flatten the specified AsmString to only 3594d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner/// include text from the specified variant, returning the new string. 3604d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattnerstd::string CodeGenInstruction:: 3614d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris LattnerFlattenAsmStringVariants(StringRef Cur, unsigned Variant) { 3624d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner std::string Res = ""; 363e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3644d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner for (;;) { 3654d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner // Find the start of the next variant string. 3664d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner size_t VariantsStart = 0; 3674d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner for (size_t e = Cur.size(); VariantsStart != e; ++VariantsStart) 3684d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner if (Cur[VariantsStart] == '{' && 3694d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner (VariantsStart == 0 || (Cur[VariantsStart-1] != '$' && 3704d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Cur[VariantsStart-1] != '\\'))) 3714d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner break; 372e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3734d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner // Add the prefix to the result. 3744d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Res += Cur.slice(0, VariantsStart); 3754d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner if (VariantsStart == Cur.size()) 3764d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner break; 377e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3784d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner ++VariantsStart; // Skip the '{'. 379e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3804d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner // Scan to the end of the variants string. 3814d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner size_t VariantsEnd = VariantsStart; 3824d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner unsigned NestedBraces = 1; 3834d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner for (size_t e = Cur.size(); VariantsEnd != e; ++VariantsEnd) { 3844d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner if (Cur[VariantsEnd] == '}' && Cur[VariantsEnd-1] != '\\') { 3854d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner if (--NestedBraces == 0) 3864d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner break; 3874d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner } else if (Cur[VariantsEnd] == '{') 3884d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner ++NestedBraces; 3894d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner } 390e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3914d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner // Select the Nth variant (or empty). 3924d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner StringRef Selection = Cur.slice(VariantsStart, VariantsEnd); 3934d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner for (unsigned i = 0; i != Variant; ++i) 3944d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Selection = Selection.split('|').second; 3954d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Res += Selection.split('|').first; 396e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 3974d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner assert(VariantsEnd != Cur.size() && 3984d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner "Unterminated variants in assembly string!"); 3994d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner Cur = Cur.substr(VariantsEnd + 1); 4004d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner } 401e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 4024d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner return Res; 4034d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner} 4044d43d0fd996a01c2cd21fd51082bc1bba783ef3cChris Lattner 405c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner 406c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner//===----------------------------------------------------------------------===// 407c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner/// CodeGenInstAlias Implementation 408c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner//===----------------------------------------------------------------------===// 409c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner 410a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson/// tryAliasOpMatch - This is a helper function for the CodeGenInstAlias 411a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson/// constructor. It checks if an argument in an InstAlias pattern matches 412a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson/// the corresponding operand of the instruction. It returns true on a 413a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson/// successful match, with ResOp set to the result operand to be used. 41405bce0beee87512e52428d4b80f5a8e79a949576David Greenebool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo, 415a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson Record *InstOpRec, bool hasSubOps, 416376a8a773e38fdcd9102a40e08ab1e0661d645d9Jakob Stoklund Olesen ArrayRef<SMLoc> Loc, CodeGenTarget &T, 417a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResultOperand &ResOp) { 41805bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Arg = Result->getArg(AliasOpNo); 41905bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *ADI = dynamic_cast<DefInit*>(Arg); 420a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 421a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (ADI && ADI->getDef() == InstOpRec) { 422a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // If the operand is a record, it must have a name, and the record type 423a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // must match up with the instruction's argument type. 424a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (Result->getArgName(AliasOpNo).empty()) 425a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson throw TGError(Loc, "result argument #" + utostr(AliasOpNo) + 426a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson " must have a name!"); 427a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResOp = ResultOperand(Result->getArgName(AliasOpNo), ADI->getDef()); 428a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return true; 429a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 430a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 431be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach // For register operands, the source register class can be a subclass 432be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach // of the instruction register class, not just an exact match. 433be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach if (ADI && ADI->getDef()->isSubClassOf("RegisterClass")) { 434be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach if (!InstOpRec->isSubClassOf("RegisterClass")) 435be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach return false; 43648c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach if (!T.getRegisterClass(InstOpRec) 43748c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach .hasSubClass(&T.getRegisterClass(ADI->getDef()))) 43848c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach return false; 43948c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach ResOp = ResultOperand(Result->getArgName(AliasOpNo), ADI->getDef()); 44048c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach return true; 441be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach } 442be5d6bcfc6ad4d5b771bb491c8ec6c87fcd3c425Jim Grosbach 443a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // Handle explicit registers. 444a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (ADI && ADI->getDef()->isSubClassOf("Register")) { 445c68e927488819efd671207786baadce6cae7266cJim Grosbach if (InstOpRec->isSubClassOf("OptionalDefOperand")) { 446c68e927488819efd671207786baadce6cae7266cJim Grosbach DagInit *DI = InstOpRec->getValueAsDag("MIOperandInfo"); 447c68e927488819efd671207786baadce6cae7266cJim Grosbach // The operand info should only have a single (register) entry. We 448c68e927488819efd671207786baadce6cae7266cJim Grosbach // want the register class of it. 449c68e927488819efd671207786baadce6cae7266cJim Grosbach InstOpRec = dynamic_cast<DefInit*>(DI->getArg(0))->getDef(); 450c68e927488819efd671207786baadce6cae7266cJim Grosbach } 451c68e927488819efd671207786baadce6cae7266cJim Grosbach 452bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (InstOpRec->isSubClassOf("RegisterOperand")) 453bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson InstOpRec = InstOpRec->getValueAsDef("RegClass"); 454bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 455a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (!InstOpRec->isSubClassOf("RegisterClass")) 456a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return false; 457a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 458ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen if (!T.getRegisterClass(InstOpRec) 459ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen .contains(T.getRegBank().getReg(ADI->getDef()))) 460f2764c89083183e0e5da800af18b23bc67937734Jim Grosbach throw TGError(Loc, "fixed register " + ADI->getDef()->getName() + 461f2764c89083183e0e5da800af18b23bc67937734Jim Grosbach " is not a member of the " + InstOpRec->getName() + 462a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson " register class!"); 463a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 464a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (!Result->getArgName(AliasOpNo).empty()) 465a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson throw TGError(Loc, "result fixed register argument must " 466a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson "not have a name!"); 467a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 468a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResOp = ResultOperand(ADI->getDef()); 469a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return true; 470a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 471a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 472a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // Handle "zero_reg" for optional def operands. 473a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (ADI && ADI->getDef()->getName() == "zero_reg") { 474a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 475a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // Check if this is an optional def. 476bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // Tied operands where the source is a sub-operand of a complex operand 477bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // need to represent both operands in the alias destination instruction. 478bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // Allow zero_reg for the tied portion. This can and should go away once 479bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // the MC representation of things doesn't use tied operands at all. 480bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach //if (!InstOpRec->isSubClassOf("OptionalDefOperand")) 481bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // throw TGError(Loc, "reg0 used for result that is not an " 482bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // "OptionalDefOperand!"); 483a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 484a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResOp = ResultOperand(static_cast<Record*>(0)); 485a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return true; 486a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 487a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 48848c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // Literal integers. 48905bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IntInit *II = dynamic_cast<IntInit*>(Arg)) { 490a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (hasSubOps || !InstOpRec->isSubClassOf("Operand")) 491a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return false; 492a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // Integer arguments can't have names. 493a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (!Result->getArgName(AliasOpNo).empty()) 494a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson throw TGError(Loc, "result argument #" + utostr(AliasOpNo) + 495a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson " must not have a name!"); 496a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResOp = ResultOperand(II->getValue()); 497a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return true; 498a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 499a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 50048c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // If both are Operands with the same MVT, allow the conversion. It's 50148c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // up to the user to make sure the values are appropriate, just like 50248c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // for isel Pat's. 50348c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach if (InstOpRec->isSubClassOf("Operand") && 50448c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach ADI->getDef()->isSubClassOf("Operand")) { 50548c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // FIXME: What other attributes should we check here? Identical 50648c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach // MIOperandInfo perhaps? 50748c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach if (InstOpRec->getValueInit("Type") != ADI->getDef()->getValueInit("Type")) 50848c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach return false; 50948c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach ResOp = ResultOperand(Result->getArgName(AliasOpNo), ADI->getDef()); 51048c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach return true; 51148c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach } 51248c1f84b104fd32109d809a56f5ebbf461c0910cJim Grosbach 513a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson return false; 514a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson} 515a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 516662e5a30e864e71111b885d3da3cdd184772035dChris LattnerCodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) { 517c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner AsmString = R->getValueAsString("AsmString"); 518b501d4f673c0db267a76800339f9943f2ce6fe33Chris Lattner Result = R->getValueAsDag("ResultInst"); 519225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner 520225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner // Verify that the root of the result is an instruction. 52105bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *DI = dynamic_cast<DefInit*>(Result->getOperator()); 522225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner if (DI == 0 || !DI->getDef()->isSubClassOf("Instruction")) 523225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner throw TGError(R->getLoc(), "result of inst alias should be an instruction"); 524225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner 525225549f775db61c5dba10e14758f4b43c53ef593Chris Lattner ResultInst = &T.getInstruction(DI->getDef()); 526e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 5273f2c8e474b8775aa1f3c2c0cb817b7f9f564e068Chris Lattner // NameClass - If argument names are repeated, we need to verify they have 5283f2c8e474b8775aa1f3c2c0cb817b7f9f564e068Chris Lattner // the same class. 5293f2c8e474b8775aa1f3c2c0cb817b7f9f564e068Chris Lattner StringMap<Record*> NameClass; 53055931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson for (unsigned i = 0, e = Result->getNumArgs(); i != e; ++i) { 53105bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *ADI = dynamic_cast<DefInit*>(Result->getArg(i)); 53255931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson if (!ADI || Result->getArgName(i).empty()) 53355931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson continue; 53455931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson // Verify we don't have something like: (someinst GR16:$foo, GR32:$foo) 53555931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson // $foo can exist multiple times in the result list, but it must have the 53655931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson // same type. 53755931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson Record *&Entry = NameClass[Result->getArgName(i)]; 53855931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson if (Entry && Entry != ADI->getDef()) 53955931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson throw TGError(R->getLoc(), "result value $" + Result->getArgName(i) + 54055931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson " is both " + Entry->getName() + " and " + 54155931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson ADI->getDef()->getName() + "!"); 54255931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson Entry = ADI->getDef(); 54355931ab992d8f7fd23d1e8fa994cd8b03b98569fBob Wilson } 544e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 545d0f225cafc76ee2d4982c207c6afb25aaf176d12Chris Lattner // Decode and validate the arguments of the result. 546414098571b19fc248fda2be194082cfd012d2729Chris Lattner unsigned AliasOpNo = 0; 547414098571b19fc248fda2be194082cfd012d2729Chris Lattner for (unsigned i = 0, e = ResultInst->Operands.size(); i != e; ++i) { 548a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 549bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // Tied registers don't have an entry in the result dag unless they're part 550bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // of a complex operand, in which case we include them anyways, as we 551bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach // don't have any other way to specify the whole operand. 552bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach if (ResultInst->Operands[i].MINumOperands == 1 && 553bfc9429c2b814469adf3930dda31539d1c3319d8Jim Grosbach ResultInst->Operands[i].getTiedRegister() != -1) 554414098571b19fc248fda2be194082cfd012d2729Chris Lattner continue; 555414098571b19fc248fda2be194082cfd012d2729Chris Lattner 556414098571b19fc248fda2be194082cfd012d2729Chris Lattner if (AliasOpNo >= Result->getNumArgs()) 557a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson throw TGError(R->getLoc(), "not enough arguments for instruction!"); 558a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson 559a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson Record *InstOpRec = ResultInst->Operands[i].Rec; 560a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson unsigned NumSubOps = ResultInst->Operands[i].MINumOperands; 561a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResultOperand ResOp(static_cast<int64_t>(0)); 562a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (tryAliasOpMatch(Result, AliasOpNo, InstOpRec, (NumSubOps > 1), 563a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson R->getLoc(), T, ResOp)) { 5647e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // If this is a simple operand, or a complex operand with a custom match 5657e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // class, then we can match is verbatim. 5667e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson if (NumSubOps == 1 || 5677e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson (InstOpRec->getValue("ParserMatchClass") && 5687e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson InstOpRec->getValueAsDef("ParserMatchClass") 5697e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ->getValueAsString("Name") != "Imm")) { 5707e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultOperands.push_back(ResOp); 5717e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultInstOperandIndex.push_back(std::make_pair(i, -1)); 5727e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ++AliasOpNo; 5737e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson 5747e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // Otherwise, we need to match each of the suboperands individually. 5757e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson } else { 5767e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo; 5777e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { 5787e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson Record *SubRec = dynamic_cast<DefInit*>(MIOI->getArg(SubOp))->getDef(); 5797e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson 5807e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // Take care to instantiate each of the suboperands with the correct 5817e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson // nomenclature: $foo.bar 5827e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultOperands.push_back( 5837e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultOperand(Result->getArgName(AliasOpNo) + "." + 5847e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson MIOI->getArgName(SubOp), SubRec)); 5857e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ResultInstOperandIndex.push_back(std::make_pair(i, SubOp)); 5867e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson } 5877e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson ++AliasOpNo; 5887e8921b0d17db6a2a0f98dcc791f136750b825c9Owen Anderson } 589d0f225cafc76ee2d4982c207c6afb25aaf176d12Chris Lattner continue; 590d0f225cafc76ee2d4982c207c6afb25aaf176d12Chris Lattner } 591e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 592a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // If the argument did not match the instruction operand, and the operand 593a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson // is composed of multiple suboperands, try matching the suboperands. 594a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (NumSubOps > 1) { 59505bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo; 596a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { 597a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (AliasOpNo >= Result->getNumArgs()) 598a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson throw TGError(R->getLoc(), "not enough arguments for instruction!"); 59905bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *SubRec = dynamic_cast<DefInit*>(MIOI->getArg(SubOp))->getDef(); 600a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false, 601a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson R->getLoc(), T, ResOp)) { 602a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResultOperands.push_back(ResOp); 603a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ResultInstOperandIndex.push_back(std::make_pair(i, SubOp)); 604a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson ++AliasOpNo; 605a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } else { 606a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson throw TGError(R->getLoc(), "result argument #" + utostr(AliasOpNo) + 607a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson " does not match instruction operand class " + 608a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson (SubOp == 0 ? InstOpRec->getName() :SubRec->getName())); 609a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 610a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson } 61198c870f87b7f0c996a9ba67003d88d434d6dbcd0Chris Lattner continue; 61298c870f87b7f0c996a9ba67003d88d434d6dbcd0Chris Lattner } 613a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson throw TGError(R->getLoc(), "result argument #" + utostr(AliasOpNo) + 614a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson " does not match instruction operand class " + 615a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson InstOpRec->getName()); 616d0f225cafc76ee2d4982c207c6afb25aaf176d12Chris Lattner } 617e5fffe9c3fa402cb5d5167327783f82b86f52b8fNAKAMURA Takumi 618414098571b19fc248fda2be194082cfd012d2729Chris Lattner if (AliasOpNo != Result->getNumArgs()) 619a49c7dfb360154070c08b8eb94ad31711d1babaeBob Wilson throw TGError(R->getLoc(), "too many operands for instruction!"); 620c76e80ded753b78a72be0db40fcdba543435d818Chris Lattner} 621