CodeGenDAGPatterns.cpp revision 901b85888c2de6bf982c47ab69b7e83908b6a216
1fe71893183f504feff290e343bf740bd32432129Chris Lattner//===- CodeGenDAGPatterns.cpp - Read DAG patterns from .td file -----------===// 26cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 36cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// The LLVM Compiler Infrastructure 46cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 56cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// This file is distributed under the University of Illinois Open Source 66cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// License. See LICENSE.TXT for details. 76cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 86cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 96cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 10fe71893183f504feff290e343bf740bd32432129Chris Lattner// This file implements the CodeGenDAGPatterns class, which is used to read and 116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// represent the patterns present in a .td file for instructions. 126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1593c7e418257bd65fcf8f5d9faa9487dd99358430Chris Lattner#include "CodeGenDAGPatterns.h" 167c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#include "llvm/TableGen/Error.h" 177c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#include "llvm/TableGen/Record.h" 186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#include "llvm/ADT/StringExtras.h" 192cacec55f947c716b058a39038889550d7e39b3cChris Lattner#include "llvm/ADT/STLExtras.h" 206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#include "llvm/Support/Debug.h" 21fdebc38523b397743973ff6a2d2e93b112dd96e5David Blaikie#include "llvm/Support/ErrorHandling.h" 229a79de3d091978cfee5264ee2563fc5dedd33cb7Chuck Rose III#include <algorithm> 23901b85888c2de6bf982c47ab69b7e83908b6a216Benjamin Kramer#include <cstdio> 24901b85888c2de6bf982c47ab69b7e83908b6a216Benjamin Kramer#include <set> 256cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerusing namespace llvm; 266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 282cacec55f947c716b058a39038889550d7e39b3cChris Lattner// EEVT::TypeSet Implementation 292cacec55f947c716b058a39038889550d7e39b3cChris Lattner//===----------------------------------------------------------------------===// 306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonstatic inline bool isInteger(MVT::SimpleValueType VT) { 32e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson return EVT(VT).isInteger(); 3383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands} 34825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonstatic inline bool isFloatingPoint(MVT::SimpleValueType VT) { 35e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson return EVT(VT).isFloatingPoint(); 3683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands} 37825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonstatic inline bool isVector(MVT::SimpleValueType VT) { 38e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson return EVT(VT).isVector(); 3983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands} 40774ce29399364823dba62217ebf7bc8701005140Chris Lattnerstatic inline bool isScalar(MVT::SimpleValueType VT) { 41774ce29399364823dba62217ebf7bc8701005140Chris Lattner return !EVT(VT).isVector(); 42774ce29399364823dba62217ebf7bc8701005140Chris Lattner} 4383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands 442cacec55f947c716b058a39038889550d7e39b3cChris LattnerEEVT::TypeSet::TypeSet(MVT::SimpleValueType VT, TreePattern &TP) { 452cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VT == MVT::iAny) 462cacec55f947c716b058a39038889550d7e39b3cChris Lattner EnforceInteger(TP); 472cacec55f947c716b058a39038889550d7e39b3cChris Lattner else if (VT == MVT::fAny) 482cacec55f947c716b058a39038889550d7e39b3cChris Lattner EnforceFloatingPoint(TP); 492cacec55f947c716b058a39038889550d7e39b3cChris Lattner else if (VT == MVT::vAny) 502cacec55f947c716b058a39038889550d7e39b3cChris Lattner EnforceVector(TP); 512cacec55f947c716b058a39038889550d7e39b3cChris Lattner else { 522cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert((VT < MVT::LAST_VALUETYPE || VT == MVT::iPTR || 532cacec55f947c716b058a39038889550d7e39b3cChris Lattner VT == MVT::iPTRAny) && "Not a concrete type!"); 542cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.push_back(VT); 552cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 582cacec55f947c716b058a39038889550d7e39b3cChris Lattner 592cacec55f947c716b058a39038889550d7e39b3cChris LattnerEEVT::TypeSet::TypeSet(const std::vector<MVT::SimpleValueType> &VTList) { 602cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(!VTList.empty() && "empty list?"); 612cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.append(VTList.begin(), VTList.end()); 62fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 632cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!VTList.empty()) 642cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(VTList[0] != MVT::iAny && VTList[0] != MVT::vAny && 652cacec55f947c716b058a39038889550d7e39b3cChris Lattner VTList[0] != MVT::fAny); 66fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 670d7952ed5ac10b6159d0e8e2449f0f471d117e0fChris Lattner // Verify no duplicates. 682cacec55f947c716b058a39038889550d7e39b3cChris Lattner array_pod_sort(TypeVec.begin(), TypeVec.end()); 690d7952ed5ac10b6159d0e8e2449f0f471d117e0fChris Lattner assert(std::unique(TypeVec.begin(), TypeVec.end()) == TypeVec.end()); 706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 725a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner/// FillWithPossibleTypes - Set to all legal types and return true, only valid 735a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner/// on completely unknown type sets. 74774ce29399364823dba62217ebf7bc8701005140Chris Lattnerbool EEVT::TypeSet::FillWithPossibleTypes(TreePattern &TP, 75774ce29399364823dba62217ebf7bc8701005140Chris Lattner bool (*Pred)(MVT::SimpleValueType), 76774ce29399364823dba62217ebf7bc8701005140Chris Lattner const char *PredicateName) { 775a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner assert(isCompletelyUnknown()); 78fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach const std::vector<MVT::SimpleValueType> &LegalTypes = 79774ce29399364823dba62217ebf7bc8701005140Chris Lattner TP.getDAGPatterns().getTargetInfo().getLegalValueTypes(); 80fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 81774ce29399364823dba62217ebf7bc8701005140Chris Lattner for (unsigned i = 0, e = LegalTypes.size(); i != e; ++i) 82774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (Pred == 0 || Pred(LegalTypes[i])) 83774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeVec.push_back(LegalTypes[i]); 84774ce29399364823dba62217ebf7bc8701005140Chris Lattner 85774ce29399364823dba62217ebf7bc8701005140Chris Lattner // If we have nothing that matches the predicate, bail out. 86774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (TypeVec.empty()) 87774ce29399364823dba62217ebf7bc8701005140Chris Lattner TP.error("Type inference contradiction found, no " + 88fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach std::string(PredicateName) + " types found"); 89774ce29399364823dba62217ebf7bc8701005140Chris Lattner // No need to sort with one element. 90774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (TypeVec.size() == 1) return true; 91774ce29399364823dba62217ebf7bc8701005140Chris Lattner 92774ce29399364823dba62217ebf7bc8701005140Chris Lattner // Remove duplicates. 93774ce29399364823dba62217ebf7bc8701005140Chris Lattner array_pod_sort(TypeVec.begin(), TypeVec.end()); 94774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeVec.erase(std::unique(TypeVec.begin(), TypeVec.end()), TypeVec.end()); 95fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 965a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner return true; 975a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner} 982cacec55f947c716b058a39038889550d7e39b3cChris Lattner 992cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// hasIntegerTypes - Return true if this TypeSet contains iAny or an 1002cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// integer value type. 1012cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::hasIntegerTypes() const { 1022cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 1032cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isInteger(TypeVec[i])) 1042cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1052cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 106fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach} 1072cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1082cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// hasFloatingPointTypes - Return true if this TypeSet contains an fAny or 1092cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// a floating point value type. 1102cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::hasFloatingPointTypes() const { 1112cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 1122cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isFloatingPoint(TypeVec[i])) 1132cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1142cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 115fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach} 1162cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1172cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// hasVectorTypes - Return true if this TypeSet contains a vAny or a vector 1182cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// value type. 1192cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::hasVectorTypes() const { 1202cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 1212cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isVector(TypeVec[i])) 1222cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1232cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 1246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 12561fc4cf7aa0b87ceab62082cee8ef5ce3f574ffcBob Wilson 1262cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1272cacec55f947c716b058a39038889550d7e39b3cChris Lattnerstd::string EEVT::TypeSet::getName() const { 128aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner if (TypeVec.empty()) return "<empty>"; 129fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1302cacec55f947c716b058a39038889550d7e39b3cChris Lattner std::string Result; 131fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1322cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) { 1332cacec55f947c716b058a39038889550d7e39b3cChris Lattner std::string VTName = llvm::getEnumName(TypeVec[i]); 1342cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Strip off MVT:: prefix if present. 1352cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VTName.substr(0,5) == "MVT::") 1362cacec55f947c716b058a39038889550d7e39b3cChris Lattner VTName = VTName.substr(5); 1372cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (i) Result += ':'; 1382cacec55f947c716b058a39038889550d7e39b3cChris Lattner Result += VTName; 1392cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 140fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1412cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.size() == 1) 1422cacec55f947c716b058a39038889550d7e39b3cChris Lattner return Result; 1432cacec55f947c716b058a39038889550d7e39b3cChris Lattner return "{" + Result + "}"; 14461fc4cf7aa0b87ceab62082cee8ef5ce3f574ffcBob Wilson} 1452cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1462cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// MergeInTypeInfo - This merges in type information from the specified 1472cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// argument. If 'this' changes, it returns true. If the two types are 1482cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// contradictory (e.g. merge f32 into i32) then this throws an exception. 1492cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::MergeInTypeInfo(const EEVT::TypeSet &InVT, TreePattern &TP){ 1502cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InVT.isCompletelyUnknown() || *this == InVT) 1512cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 152fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1532cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isCompletelyUnknown()) { 1542cacec55f947c716b058a39038889550d7e39b3cChris Lattner *this = InVT; 1552cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1562cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 157fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1582cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(TypeVec.size() >= 1 && InVT.TypeVec.size() >= 1 && "No unknowns"); 159fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1602cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Handle the abstract cases, seeing if we can resolve them better. 1612cacec55f947c716b058a39038889550d7e39b3cChris Lattner switch (TypeVec[0]) { 1622cacec55f947c716b058a39038889550d7e39b3cChris Lattner default: break; 1632cacec55f947c716b058a39038889550d7e39b3cChris Lattner case MVT::iPTR: 1642cacec55f947c716b058a39038889550d7e39b3cChris Lattner case MVT::iPTRAny: 1652cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InVT.hasIntegerTypes()) { 1662cacec55f947c716b058a39038889550d7e39b3cChris Lattner EEVT::TypeSet InCopy(InVT); 1672cacec55f947c716b058a39038889550d7e39b3cChris Lattner InCopy.EnforceInteger(TP); 1682cacec55f947c716b058a39038889550d7e39b3cChris Lattner InCopy.EnforceScalar(TP); 169fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1702cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InCopy.isConcrete()) { 1712cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If the RHS has one integer type, upgrade iPTR to i32. 1722cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec[0] = InVT.TypeVec[0]; 1732cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1742cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 175fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1762cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If the input has multiple scalar integers, this doesn't add any info. 1772cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!InCopy.isCompletelyUnknown()) 1782cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 1792cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1802cacec55f947c716b058a39038889550d7e39b3cChris Lattner break; 1812cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 182fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1832cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If the input constraint is iAny/iPTR and this is an integer type list, 1842cacec55f947c716b058a39038889550d7e39b3cChris Lattner // remove non-integer types from the list. 1852cacec55f947c716b058a39038889550d7e39b3cChris Lattner if ((InVT.TypeVec[0] == MVT::iPTR || InVT.TypeVec[0] == MVT::iPTRAny) && 1862cacec55f947c716b058a39038889550d7e39b3cChris Lattner hasIntegerTypes()) { 1872cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = EnforceInteger(TP); 188fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1892cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we're merging in iPTR/iPTRAny and the node currently has a list of 1902cacec55f947c716b058a39038889550d7e39b3cChris Lattner // multiple different integer types, replace them with a single iPTR. 1912cacec55f947c716b058a39038889550d7e39b3cChris Lattner if ((InVT.TypeVec[0] == MVT::iPTR || InVT.TypeVec[0] == MVT::iPTRAny) && 1922cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.size() != 1) { 1932cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.resize(1); 1942cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec[0] = InVT.TypeVec[0]; 1952cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange = true; 1962cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 197fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1982cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 1992cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 200fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2012cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this is a type list and the RHS is a typelist as well, eliminate entries 2022cacec55f947c716b058a39038889550d7e39b3cChris Lattner // from this list that aren't in the other one. 2032cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = false; 2042cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeSet InputSet(*this); 2052cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2062cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) { 2072cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool InInVT = false; 2082cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned j = 0, e = InVT.TypeVec.size(); j != e; ++j) 2092cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec[i] == InVT.TypeVec[j]) { 2102cacec55f947c716b058a39038889550d7e39b3cChris Lattner InInVT = true; 2112cacec55f947c716b058a39038889550d7e39b3cChris Lattner break; 2122cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 213fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2142cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InInVT) continue; 2152cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 2162cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange = true; 2172cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 218fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2192cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we removed all of our types, we have a type contradiction. 2202cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!TypeVec.empty()) 2212cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 222fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2232cacec55f947c716b058a39038889550d7e39b3cChris Lattner // FIXME: Really want an SMLoc here! 2242cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, merging '" + 2252cacec55f947c716b058a39038889550d7e39b3cChris Lattner InVT.getName() + "' into '" + InputSet.getName() + "'"); 2262cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; // unreachable 2272cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2282cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2292cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceInteger - Remove all non-integer types from this set. 2302cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceInteger(TreePattern &TP) { 2312cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2325a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 233774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isInteger, "integer"); 2342cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!hasFloatingPointTypes()) 235774ce29399364823dba62217ebf7bc8701005140Chris Lattner return false; 236774ce29399364823dba62217ebf7bc8701005140Chris Lattner 237774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 238fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2392cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the fp types. 2402cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 241774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isInteger(TypeVec[i])) 2422cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 243fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2442cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) 2452cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 2462cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be integer"); 247774ce29399364823dba62217ebf7bc8701005140Chris Lattner return true; 2482cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2492cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2502cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceFloatingPoint - Remove all integer types from this set. 2512cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceFloatingPoint(TreePattern &TP) { 2522cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2535a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 254774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isFloatingPoint, "floating point"); 255774ce29399364823dba62217ebf7bc8701005140Chris Lattner 2562cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!hasIntegerTypes()) 257774ce29399364823dba62217ebf7bc8701005140Chris Lattner return false; 258774ce29399364823dba62217ebf7bc8701005140Chris Lattner 259774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 260fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2612cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the fp types. 2622cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 263774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isFloatingPoint(TypeVec[i])) 2642cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 265fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2662cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) 2672cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 2682cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be floating point"); 269774ce29399364823dba62217ebf7bc8701005140Chris Lattner return true; 2702cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2712cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2722cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceScalar - Remove all vector types from this. 2732cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceScalar(TreePattern &TP) { 2742cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2755a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 276774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isScalar, "scalar"); 277774ce29399364823dba62217ebf7bc8701005140Chris Lattner 2782cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!hasVectorTypes()) 279774ce29399364823dba62217ebf7bc8701005140Chris Lattner return false; 280774ce29399364823dba62217ebf7bc8701005140Chris Lattner 281774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 282fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2832cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the vector types. 2842cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 285774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isScalar(TypeVec[i])) 2862cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 287fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2882cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) 2892cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 2902cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be scalar"); 291774ce29399364823dba62217ebf7bc8701005140Chris Lattner return true; 2922cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2932cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2942cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceVector - Remove all vector types from this. 2952cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceVector(TreePattern &TP) { 2962cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2975a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 298774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isVector, "vector"); 299774ce29399364823dba62217ebf7bc8701005140Chris Lattner 300774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 301774ce29399364823dba62217ebf7bc8701005140Chris Lattner bool MadeChange = false; 302fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3032cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the scalar types. 3042cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 305774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isVector(TypeVec[i])) { 3062cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 307774ce29399364823dba62217ebf7bc8701005140Chris Lattner MadeChange = true; 308774ce29399364823dba62217ebf7bc8701005140Chris Lattner } 309fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3102cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) 3112cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 3122cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be a vector"); 3132cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 3142cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 3152cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3162cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3175a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3182cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceSmallerThan - 'this' must be a smaller VT than Other. Update 3192cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// this an other based on this information. 3202cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceSmallerThan(EEVT::TypeSet &Other, TreePattern &TP) { 3212cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Both operands must be integer or FP, but we don't care which. 3222cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = false; 323fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3245a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (isCompletelyUnknown()) 3255a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MadeChange = FillWithPossibleTypes(TP); 3265a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3275a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (Other.isCompletelyUnknown()) 3285a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MadeChange = Other.FillWithPossibleTypes(TP); 329fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3302cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If one side is known to be integer or known to be FP but the other side has 3312cacec55f947c716b058a39038889550d7e39b3cChris Lattner // no information, get at least the type integrality info in there. 3325a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!hasFloatingPointTypes()) 3332cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= Other.EnforceInteger(TP); 3345a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner else if (!hasIntegerTypes()) 3352cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= Other.EnforceFloatingPoint(TP); 3365a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!Other.hasFloatingPointTypes()) 3372cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= EnforceInteger(TP); 3385a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner else if (!Other.hasIntegerTypes()) 3392cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= EnforceFloatingPoint(TP); 340fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3412cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(!isCompletelyUnknown() && !Other.isCompletelyUnknown() && 3422cacec55f947c716b058a39038889550d7e39b3cChris Lattner "Should have a type list now"); 343fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3442cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If one contains vectors but the other doesn't pull vectors out. 3455a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!hasVectorTypes()) 3462cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= Other.EnforceScalar(TP); 3475a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!hasVectorTypes()) 3482cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= EnforceScalar(TP); 349fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3509d7f0111100d863f2722deab952711a5496abad4David Greene if (TypeVec.size() == 1 && Other.TypeVec.size() == 1) { 3519d7f0111100d863f2722deab952711a5496abad4David Greene // If we are down to concrete types, this code does not currently 3529d7f0111100d863f2722deab952711a5496abad4David Greene // handle nodes which have multiple types, where some types are 3539d7f0111100d863f2722deab952711a5496abad4David Greene // integer, and some are fp. Assert that this is not the case. 3549d7f0111100d863f2722deab952711a5496abad4David Greene assert(!(hasIntegerTypes() && hasFloatingPointTypes()) && 3559d7f0111100d863f2722deab952711a5496abad4David Greene !(Other.hasIntegerTypes() && Other.hasFloatingPointTypes()) && 3569d7f0111100d863f2722deab952711a5496abad4David Greene "SDTCisOpSmallerThanOp does not handle mixed int/fp types!"); 3579d7f0111100d863f2722deab952711a5496abad4David Greene 3589d7f0111100d863f2722deab952711a5496abad4David Greene // Otherwise, if these are both vector types, either this vector 3599d7f0111100d863f2722deab952711a5496abad4David Greene // must have a larger bitsize than the other, or this element type 3609d7f0111100d863f2722deab952711a5496abad4David Greene // must be larger than the other. 3619d7f0111100d863f2722deab952711a5496abad4David Greene EVT Type(TypeVec[0]); 3629d7f0111100d863f2722deab952711a5496abad4David Greene EVT OtherType(Other.TypeVec[0]); 3639d7f0111100d863f2722deab952711a5496abad4David Greene 3649d7f0111100d863f2722deab952711a5496abad4David Greene if (hasVectorTypes() && Other.hasVectorTypes()) { 3659d7f0111100d863f2722deab952711a5496abad4David Greene if (Type.getSizeInBits() >= OtherType.getSizeInBits()) 3669d7f0111100d863f2722deab952711a5496abad4David Greene if (Type.getVectorElementType().getSizeInBits() 3679d7f0111100d863f2722deab952711a5496abad4David Greene >= OtherType.getVectorElementType().getSizeInBits()) 3689d7f0111100d863f2722deab952711a5496abad4David Greene TP.error("Type inference contradiction found, '" + 3699d7f0111100d863f2722deab952711a5496abad4David Greene getName() + "' element type not smaller than '" + 3709d7f0111100d863f2722deab952711a5496abad4David Greene Other.getName() +"'!"); 3719d7f0111100d863f2722deab952711a5496abad4David Greene } 3729d7f0111100d863f2722deab952711a5496abad4David Greene else 3739d7f0111100d863f2722deab952711a5496abad4David Greene // For scalar types, the bitsize of this type must be larger 3749d7f0111100d863f2722deab952711a5496abad4David Greene // than that of the other. 3759d7f0111100d863f2722deab952711a5496abad4David Greene if (Type.getSizeInBits() >= OtherType.getSizeInBits()) 3769d7f0111100d863f2722deab952711a5496abad4David Greene TP.error("Type inference contradiction found, '" + 3779d7f0111100d863f2722deab952711a5496abad4David Greene getName() + "' is not smaller than '" + 3789d7f0111100d863f2722deab952711a5496abad4David Greene Other.getName() +"'!"); 3799d7f0111100d863f2722deab952711a5496abad4David Greene 3809d7f0111100d863f2722deab952711a5496abad4David Greene } 3819d7f0111100d863f2722deab952711a5496abad4David Greene 3829d7f0111100d863f2722deab952711a5496abad4David Greene 3839d7f0111100d863f2722deab952711a5496abad4David Greene // Handle int and fp as disjoint sets. This won't work for patterns 3849d7f0111100d863f2722deab952711a5496abad4David Greene // that have mixed fp/int types but those are likely rare and would 3859d7f0111100d863f2722deab952711a5496abad4David Greene // not have been accepted by this code previously. 386fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3875a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // Okay, find the smallest type from the current set and remove it from the 3885a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // largest set. 389c83e20375746c2910331ed29f5d976d80fe728e4David Greene MVT::SimpleValueType SmallestInt = MVT::LAST_VALUETYPE; 3909d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 3919d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(TypeVec[i])) { 3929d7f0111100d863f2722deab952711a5496abad4David Greene SmallestInt = TypeVec[i]; 3939d7f0111100d863f2722deab952711a5496abad4David Greene break; 3949d7f0111100d863f2722deab952711a5496abad4David Greene } 3955a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner for (unsigned i = 1, e = TypeVec.size(); i != e; ++i) 3969d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(TypeVec[i]) && TypeVec[i] < SmallestInt) 3979d7f0111100d863f2722deab952711a5496abad4David Greene SmallestInt = TypeVec[i]; 3989d7f0111100d863f2722deab952711a5496abad4David Greene 399c83e20375746c2910331ed29f5d976d80fe728e4David Greene MVT::SimpleValueType SmallestFP = MVT::LAST_VALUETYPE; 4009d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 4019d7f0111100d863f2722deab952711a5496abad4David Greene if (isFloatingPoint(TypeVec[i])) { 4029d7f0111100d863f2722deab952711a5496abad4David Greene SmallestFP = TypeVec[i]; 4039d7f0111100d863f2722deab952711a5496abad4David Greene break; 4049d7f0111100d863f2722deab952711a5496abad4David Greene } 4059d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 1, e = TypeVec.size(); i != e; ++i) 4069d7f0111100d863f2722deab952711a5496abad4David Greene if (isFloatingPoint(TypeVec[i]) && TypeVec[i] < SmallestFP) 4079d7f0111100d863f2722deab952711a5496abad4David Greene SmallestFP = TypeVec[i]; 4089d7f0111100d863f2722deab952711a5496abad4David Greene 4099d7f0111100d863f2722deab952711a5496abad4David Greene int OtherIntSize = 0; 4109d7f0111100d863f2722deab952711a5496abad4David Greene int OtherFPSize = 0; 4119d7f0111100d863f2722deab952711a5496abad4David Greene for (SmallVector<MVT::SimpleValueType, 2>::iterator TVI = 4129d7f0111100d863f2722deab952711a5496abad4David Greene Other.TypeVec.begin(); 4139d7f0111100d863f2722deab952711a5496abad4David Greene TVI != Other.TypeVec.end(); 4149d7f0111100d863f2722deab952711a5496abad4David Greene /* NULL */) { 4159d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(*TVI)) { 4169d7f0111100d863f2722deab952711a5496abad4David Greene ++OtherIntSize; 4179d7f0111100d863f2722deab952711a5496abad4David Greene if (*TVI == SmallestInt) { 4189d7f0111100d863f2722deab952711a5496abad4David Greene TVI = Other.TypeVec.erase(TVI); 4199d7f0111100d863f2722deab952711a5496abad4David Greene --OtherIntSize; 4209d7f0111100d863f2722deab952711a5496abad4David Greene MadeChange = true; 4219d7f0111100d863f2722deab952711a5496abad4David Greene continue; 4229d7f0111100d863f2722deab952711a5496abad4David Greene } 4239d7f0111100d863f2722deab952711a5496abad4David Greene } 4249d7f0111100d863f2722deab952711a5496abad4David Greene else if (isFloatingPoint(*TVI)) { 4259d7f0111100d863f2722deab952711a5496abad4David Greene ++OtherFPSize; 4269d7f0111100d863f2722deab952711a5496abad4David Greene if (*TVI == SmallestFP) { 4279d7f0111100d863f2722deab952711a5496abad4David Greene TVI = Other.TypeVec.erase(TVI); 4289d7f0111100d863f2722deab952711a5496abad4David Greene --OtherFPSize; 4299d7f0111100d863f2722deab952711a5496abad4David Greene MadeChange = true; 4309d7f0111100d863f2722deab952711a5496abad4David Greene continue; 4319d7f0111100d863f2722deab952711a5496abad4David Greene } 4329d7f0111100d863f2722deab952711a5496abad4David Greene } 4339d7f0111100d863f2722deab952711a5496abad4David Greene ++TVI; 4349d7f0111100d863f2722deab952711a5496abad4David Greene } 435fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 4365a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // If this is the only type in the large set, the constraint can never be 4375a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // satisfied. 4389d7f0111100d863f2722deab952711a5496abad4David Greene if ((Other.hasIntegerTypes() && OtherIntSize == 0) 4399d7f0111100d863f2722deab952711a5496abad4David Greene || (Other.hasFloatingPointTypes() && OtherFPSize == 0)) 4405a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner TP.error("Type inference contradiction found, '" + 4415a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner Other.getName() + "' has nothing larger than '" + getName() +"'!"); 442fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 4435a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // Okay, find the largest type in the Other set and remove it from the 4445a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // current set. 445c83e20375746c2910331ed29f5d976d80fe728e4David Greene MVT::SimpleValueType LargestInt = MVT::Other; 4469d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 0, e = Other.TypeVec.size(); i != e; ++i) 4479d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(Other.TypeVec[i])) { 4489d7f0111100d863f2722deab952711a5496abad4David Greene LargestInt = Other.TypeVec[i]; 4499d7f0111100d863f2722deab952711a5496abad4David Greene break; 4509d7f0111100d863f2722deab952711a5496abad4David Greene } 4515a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner for (unsigned i = 1, e = Other.TypeVec.size(); i != e; ++i) 4529d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(Other.TypeVec[i]) && Other.TypeVec[i] > LargestInt) 4539d7f0111100d863f2722deab952711a5496abad4David Greene LargestInt = Other.TypeVec[i]; 4549d7f0111100d863f2722deab952711a5496abad4David Greene 455c83e20375746c2910331ed29f5d976d80fe728e4David Greene MVT::SimpleValueType LargestFP = MVT::Other; 4569d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 0, e = Other.TypeVec.size(); i != e; ++i) 4579d7f0111100d863f2722deab952711a5496abad4David Greene if (isFloatingPoint(Other.TypeVec[i])) { 4589d7f0111100d863f2722deab952711a5496abad4David Greene LargestFP = Other.TypeVec[i]; 4599d7f0111100d863f2722deab952711a5496abad4David Greene break; 4609d7f0111100d863f2722deab952711a5496abad4David Greene } 4619d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 1, e = Other.TypeVec.size(); i != e; ++i) 4629d7f0111100d863f2722deab952711a5496abad4David Greene if (isFloatingPoint(Other.TypeVec[i]) && Other.TypeVec[i] > LargestFP) 4639d7f0111100d863f2722deab952711a5496abad4David Greene LargestFP = Other.TypeVec[i]; 4649d7f0111100d863f2722deab952711a5496abad4David Greene 4659d7f0111100d863f2722deab952711a5496abad4David Greene int IntSize = 0; 4669d7f0111100d863f2722deab952711a5496abad4David Greene int FPSize = 0; 4679d7f0111100d863f2722deab952711a5496abad4David Greene for (SmallVector<MVT::SimpleValueType, 2>::iterator TVI = 4689d7f0111100d863f2722deab952711a5496abad4David Greene TypeVec.begin(); 4699d7f0111100d863f2722deab952711a5496abad4David Greene TVI != TypeVec.end(); 4709d7f0111100d863f2722deab952711a5496abad4David Greene /* NULL */) { 4719d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(*TVI)) { 4729d7f0111100d863f2722deab952711a5496abad4David Greene ++IntSize; 4739d7f0111100d863f2722deab952711a5496abad4David Greene if (*TVI == LargestInt) { 4749d7f0111100d863f2722deab952711a5496abad4David Greene TVI = TypeVec.erase(TVI); 4759d7f0111100d863f2722deab952711a5496abad4David Greene --IntSize; 4769d7f0111100d863f2722deab952711a5496abad4David Greene MadeChange = true; 4779d7f0111100d863f2722deab952711a5496abad4David Greene continue; 4789d7f0111100d863f2722deab952711a5496abad4David Greene } 4799d7f0111100d863f2722deab952711a5496abad4David Greene } 4809d7f0111100d863f2722deab952711a5496abad4David Greene else if (isFloatingPoint(*TVI)) { 4819d7f0111100d863f2722deab952711a5496abad4David Greene ++FPSize; 4829d7f0111100d863f2722deab952711a5496abad4David Greene if (*TVI == LargestFP) { 4839d7f0111100d863f2722deab952711a5496abad4David Greene TVI = TypeVec.erase(TVI); 4849d7f0111100d863f2722deab952711a5496abad4David Greene --FPSize; 4859d7f0111100d863f2722deab952711a5496abad4David Greene MadeChange = true; 4869d7f0111100d863f2722deab952711a5496abad4David Greene continue; 4879d7f0111100d863f2722deab952711a5496abad4David Greene } 4889d7f0111100d863f2722deab952711a5496abad4David Greene } 4899d7f0111100d863f2722deab952711a5496abad4David Greene ++TVI; 4909d7f0111100d863f2722deab952711a5496abad4David Greene } 491fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 4925a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // If this is the only type in the small set, the constraint can never be 4935a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // satisfied. 4949d7f0111100d863f2722deab952711a5496abad4David Greene if ((hasIntegerTypes() && IntSize == 0) 4959d7f0111100d863f2722deab952711a5496abad4David Greene || (hasFloatingPointTypes() && FPSize == 0)) 4965a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner TP.error("Type inference contradiction found, '" + 4975a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner getName() + "' has nothing smaller than '" + Other.getName()+"'!"); 498fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 4995a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner return MadeChange; 5002cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 5012cacec55f947c716b058a39038889550d7e39b3cChris Lattner 5022cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceVectorEltTypeIs - 'this' is now constrainted to be a vector type 50366fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner/// whose element is specified by VTOperand. 50466fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattnerbool EEVT::TypeSet::EnforceVectorEltTypeIs(EEVT::TypeSet &VTOperand, 5052cacec55f947c716b058a39038889550d7e39b3cChris Lattner TreePattern &TP) { 50666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // "This" must be a vector and "VTOperand" must be a scalar. 5072cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = false; 50866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner MadeChange |= EnforceVector(TP); 50966fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner MadeChange |= VTOperand.EnforceScalar(TP); 51066fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner 51166fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // If we know the vector type, it forces the scalar to agree. 51266fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner if (isConcrete()) { 51366fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner EVT IVT = getConcrete(); 51466fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner IVT = IVT.getVectorElementType(); 515fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach return MadeChange | 51666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner VTOperand.MergeInTypeInfo(IVT.getSimpleVT().SimpleTy, TP); 51766fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner } 51866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner 51966fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // If the scalar type is known, filter out vector types whose element types 52066fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // disagree. 52166fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner if (!VTOperand.isConcrete()) 52266fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner return MadeChange; 523fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 52466fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner MVT::SimpleValueType VT = VTOperand.getConcrete(); 525fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 52666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner TypeSet InputSet(*this); 527fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 52866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // Filter out all the types which don't have the right element type. 52966fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) { 53066fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner assert(isVector(TypeVec[i]) && "EnforceVector didn't work"); 53166fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner if (EVT(TypeVec[i]).getVectorElementType().getSimpleVT().SimpleTy != VT) { 5322cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 5332cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange = true; 5342cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 53566fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner } 536fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 5372cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) // FIXME: Really want an SMLoc here! 5382cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, forcing '" + 5392cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' to have a vector element"); 5402cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 5412cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 5422cacec55f947c716b058a39038889550d7e39b3cChris Lattner 5436032269837c08a94b70b0e36f8e473c293ff5fd4David Greene/// EnforceVectorSubVectorTypeIs - 'this' is now constrainted to be a 5446032269837c08a94b70b0e36f8e473c293ff5fd4David Greene/// vector type specified by VTOperand. 5456032269837c08a94b70b0e36f8e473c293ff5fd4David Greenebool EEVT::TypeSet::EnforceVectorSubVectorTypeIs(EEVT::TypeSet &VTOperand, 5466032269837c08a94b70b0e36f8e473c293ff5fd4David Greene TreePattern &TP) { 5476032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // "This" must be a vector and "VTOperand" must be a vector. 5486032269837c08a94b70b0e36f8e473c293ff5fd4David Greene bool MadeChange = false; 5496032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= EnforceVector(TP); 5506032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= VTOperand.EnforceVector(TP); 5516032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 5526032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // "This" must be larger than "VTOperand." 5536032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= VTOperand.EnforceSmallerThan(*this, TP); 5546032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 5556032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // If we know the vector type, it forces the scalar types to agree. 5566032269837c08a94b70b0e36f8e473c293ff5fd4David Greene if (isConcrete()) { 5576032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EVT IVT = getConcrete(); 5586032269837c08a94b70b0e36f8e473c293ff5fd4David Greene IVT = IVT.getVectorElementType(); 5596032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 5606032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EEVT::TypeSet EltTypeSet(IVT.getSimpleVT().SimpleTy, TP); 5616032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= VTOperand.EnforceVectorEltTypeIs(EltTypeSet, TP); 5626032269837c08a94b70b0e36f8e473c293ff5fd4David Greene } else if (VTOperand.isConcrete()) { 5636032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EVT IVT = VTOperand.getConcrete(); 5646032269837c08a94b70b0e36f8e473c293ff5fd4David Greene IVT = IVT.getVectorElementType(); 5656032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 5666032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EEVT::TypeSet EltTypeSet(IVT.getSimpleVT().SimpleTy, TP); 5676032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= EnforceVectorEltTypeIs(EltTypeSet, TP); 5686032269837c08a94b70b0e36f8e473c293ff5fd4David Greene } 5696032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 5706032269837c08a94b70b0e36f8e473c293ff5fd4David Greene return MadeChange; 5716032269837c08a94b70b0e36f8e473c293ff5fd4David Greene} 5726032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 5732cacec55f947c716b058a39038889550d7e39b3cChris Lattner//===----------------------------------------------------------------------===// 5742cacec55f947c716b058a39038889550d7e39b3cChris Lattner// Helpers for working with extended types. 5756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5766f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbarbool RecordPtrCmp::operator()(const Record *LHS, const Record *RHS) const { 5776f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar return LHS->getID() < RHS->getID(); 5786f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar} 579327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 580327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// Dependent variable map for CodeGenDAGPattern variant generation 581327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Micheltypedef std::map<std::string, int> DepVarMap; 582327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 583327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// Const iterator shorthand for DepVarMap 584327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Micheltypedef DepVarMap::const_iterator DepVarMap_citer; 585327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 586543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstatic void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) { 587327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (N->isLeaf()) { 58805bce0beee87512e52428d4b80f5a8e79a949576David Greene if (dynamic_cast<DefInit*>(N->getLeafValue()) != NULL) 589327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DepMap[N->getName()]++; 590327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } else { 591327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (size_t i = 0, e = N->getNumChildren(); i != e; ++i) 592327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVarsOf(N->getChild(i), DepMap); 593327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 594327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 595543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 596543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// Find dependent variables within child patterns 597543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstatic void FindDepVars(TreePatternNode *N, MultipleUseVarSet &DepVars) { 598327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DepVarMap depcounts; 599327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVarsOf(N, depcounts); 600327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (DepVarMap_citer i = depcounts.begin(); i != depcounts.end(); ++i) { 601543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (i->second > 1) // std::pair<std::string, int> 602327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DepVars.insert(i->first); 603327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 604327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 605327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 6066aa526bf76ba74b79ebf4d96d2c1f12d59067530Daniel Dunbar#ifndef NDEBUG 607543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// Dump the dependent variable set: 608543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstatic void DumpDepVars(MultipleUseVarSet &DepVars) { 609327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (DepVars.empty()) { 610569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "<empty set>"); 611327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } else { 612569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "[ "); 613bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach for (MultipleUseVarSet::const_iterator i = DepVars.begin(), 614bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach e = DepVars.end(); i != e; ++i) { 615569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << (*i) << " "); 616327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 617569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "]"); 618327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 619327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 6206aa526bf76ba74b79ebf4d96d2c1f12d59067530Daniel Dunbar#endif 6216aa526bf76ba74b79ebf4d96d2c1f12d59067530Daniel Dunbar 622543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 623543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner//===----------------------------------------------------------------------===// 624543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner// TreePredicateFn Implementation 625543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner//===----------------------------------------------------------------------===// 626543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 6277ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner/// TreePredicateFn constructor. Here 'N' is a subclass of PatFrag. 6287ed1391ff66012e4963081cfb20b6166e8784f50Chris LattnerTreePredicateFn::TreePredicateFn(TreePattern *N) : PatFragRec(N) { 6297ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner assert((getPredCode().empty() || getImmCode().empty()) && 6307ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner ".td file corrupt: can't have a node predicate *and* an imm predicate"); 6317ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner} 6327ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner 633543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstd::string TreePredicateFn::getPredCode() const { 6348dd6f0c8353f80de6526810899f271d539f6929cJakob Stoklund Olesen return PatFragRec->getRecord()->getValueAsString("PredicateCode"); 635543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner} 636543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 6377ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattnerstd::string TreePredicateFn::getImmCode() const { 6388dd6f0c8353f80de6526810899f271d539f6929cJakob Stoklund Olesen return PatFragRec->getRecord()->getValueAsString("ImmediateCode"); 6397ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner} 6407ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner 641543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 642543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// isAlwaysTrue - Return true if this is a noop predicate. 643543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerbool TreePredicateFn::isAlwaysTrue() const { 6447ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner return getPredCode().empty() && getImmCode().empty(); 645543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner} 646543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 647543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// Return the name to use in the generated code to reference this, this is 648543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// "Predicate_foo" if from a pattern fragment "foo". 649543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstd::string TreePredicateFn::getFnName() const { 650543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner return "Predicate_" + PatFragRec->getRecord()->getName(); 651543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner} 652543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 653543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// getCodeToRunOnSDNode - Return the code for the function body that 654543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// evaluates this predicate. The argument is expected to be in "Node", 655543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// not N. This handles casting and conversion to a concrete node type as 656543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// appropriate. 657543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstd::string TreePredicateFn::getCodeToRunOnSDNode() const { 6587ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner // Handle immediate predicates first. 6597ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner std::string ImmCode = getImmCode(); 6607ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner if (!ImmCode.empty()) { 6617ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner std::string Result = 6627ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner " int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();\n"; 6637ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner return Result + ImmCode; 6647ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner } 6657ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner 6667ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner // Handle arbitrary node predicates. 6677ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner assert(!getPredCode().empty() && "Don't have any predicate code!"); 668543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner std::string ClassName; 669543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (PatFragRec->getOnlyTree()->isLeaf()) 670543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner ClassName = "SDNode"; 671543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner else { 672543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner Record *Op = PatFragRec->getOnlyTree()->getOperator(); 673543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner ClassName = PatFragRec->getDAGPatterns().getSDNodeInfo(Op).getSDClassName(); 674543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner } 675543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner std::string Result; 676543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (ClassName == "SDNode") 677543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner Result = " SDNode *N = Node;\n"; 678543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner else 679543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner Result = " " + ClassName + "*N = cast<" + ClassName + ">(Node);\n"; 680543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 681543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner return Result + getPredCode(); 682327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 683327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 6846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 68522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman// PatternToMatch implementation 68622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman// 68722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 68848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 68948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// getPatternSize - Return the 'size' of this pattern. We want to match large 69048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// patterns before small ones. This is used to determine the size of a 69148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// pattern. 69248e86dbe29e331357b0df11075b7974009c65f34Chris Lattnerstatic unsigned getPatternSize(const TreePatternNode *P, 69348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner const CodeGenDAGPatterns &CGP) { 69448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner unsigned Size = 3; // The node itself. 69548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // If the root node is a ConstantSDNode, increases its size. 69648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // e.g. (set R32:$dst, 0). 69705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue())) 69848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += 2; 699fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 70048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // FIXME: This is a hack to statically increase the priority of patterns 70148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // which maps a sub-dag to a complex pattern. e.g. favors LEA over ADD. 70248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // Later we can allow complexity / cost for each pattern to be (optionally) 70348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // specified. To get best possible pattern match we'll need to dynamically 70448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // calculate the complexity of all patterns a dag can potentially map to. 70548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner const ComplexPattern *AM = P->getComplexPatternInfo(CGP); 70648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (AM) 70748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += AM->getNumOperands() * 3; 708fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 70948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // If this node has some predicate function that must match, it adds to the 71048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // complexity of this node. 71148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (!P->getPredicateFns().empty()) 71248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner ++Size; 713fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 71448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // Count children in the count if they are also nodes. 71548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) { 71648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner TreePatternNode *Child = P->getChild(i); 71748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (!Child->isLeaf() && Child->getNumTypes() && 71848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Child->getType(0) != MVT::Other) 71948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += getPatternSize(Child, CGP); 72048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner else if (Child->isLeaf()) { 72105bce0beee87512e52428d4b80f5a8e79a949576David Greene if (dynamic_cast<IntInit*>(Child->getLeafValue())) 72248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2). 72348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner else if (Child->getComplexPatternInfo(CGP)) 72448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += getPatternSize(Child, CGP); 72548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner else if (!Child->getPredicateFns().empty()) 72648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner ++Size; 72748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner } 72848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner } 729fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 73048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner return Size; 73148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner} 73248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 73348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// Compute the complexity metric for the input pattern. This roughly 73448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// corresponds to the number of nodes that are covered. 73548e86dbe29e331357b0df11075b7974009c65f34Chris Lattnerunsigned PatternToMatch:: 73648e86dbe29e331357b0df11075b7974009c65f34Chris LattnergetPatternComplexity(const CodeGenDAGPatterns &CGP) const { 73748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner return getPatternSize(getSrcPattern(), CGP) + getAddedComplexity(); 73848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner} 73948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 74048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 74122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// getPredicateCheck - Return a single string containing all of this 74222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// pattern's predicates concatenated with "&&" operators. 74322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// 74422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohmanstd::string PatternToMatch::getPredicateCheck() const { 74522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman std::string PredicateCheck; 74622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) { 74705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *Pred = dynamic_cast<DefInit*>(Predicates->getElement(i))) { 74822bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman Record *Def = Pred->getDef(); 74922bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (!Def->isSubClassOf("Predicate")) { 75022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman#ifndef NDEBUG 75122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman Def->dump(); 75222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman#endif 753655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper llvm_unreachable("Unknown predicate type!"); 75422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 75522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (!PredicateCheck.empty()) 75622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman PredicateCheck += " && "; 75722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman PredicateCheck += "(" + Def->getValueAsString("CondString") + ")"; 75822bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 75922bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 76022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 76122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman return PredicateCheck; 76222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman} 76322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 76422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman//===----------------------------------------------------------------------===// 7656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// SDTypeConstraint implementation 7666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 7676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7686cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSDTypeConstraint::SDTypeConstraint(Record *R) { 7696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OperandNo = R->getValueAsInt("OperandNum"); 770fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 7716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("SDTCisVT")) { 7726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisVT; 7736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisVT_Info.VT = getValueType(R->getValueAsDef("VT")); 774c812261221040ac991f0c9710036a079f208281eChris Lattner if (x.SDTCisVT_Info.VT == MVT::isVoid) 775c812261221040ac991f0c9710036a079f208281eChris Lattner throw TGError(R->getLoc(), "Cannot use 'Void' as type to SDTCisVT"); 776fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 7776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisPtrTy")) { 7786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisPtrTy; 7796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisInt")) { 7806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisInt; 7816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisFP")) { 7826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisFP; 78336e3e668be0c4914660575d7cea800b0d51a4116Bob Wilson } else if (R->isSubClassOf("SDTCisVec")) { 78436e3e668be0c4914660575d7cea800b0d51a4116Bob Wilson ConstraintType = SDTCisVec; 7856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisSameAs")) { 7866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisSameAs; 7876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisSameAs_Info.OtherOperandNum = R->getValueAsInt("OtherOperandNum"); 7886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisVTSmallerThanOp")) { 7896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisVTSmallerThanOp; 790fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach x.SDTCisVTSmallerThanOp_Info.OtherOperandNum = 7916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->getValueAsInt("OtherOperandNum"); 7926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisOpSmallerThanOp")) { 7936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisOpSmallerThanOp; 794fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach x.SDTCisOpSmallerThanOp_Info.BigOperandNum = 7956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->getValueAsInt("BigOperandNum"); 796b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman } else if (R->isSubClassOf("SDTCisEltOfVec")) { 797b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman ConstraintType = SDTCisEltOfVec; 7982cacec55f947c716b058a39038889550d7e39b3cChris Lattner x.SDTCisEltOfVec_Info.OtherOperandNum = R->getValueAsInt("OtherOpNum"); 7996032269837c08a94b70b0e36f8e473c293ff5fd4David Greene } else if (R->isSubClassOf("SDTCisSubVecOfVec")) { 8006032269837c08a94b70b0e36f8e473c293ff5fd4David Greene ConstraintType = SDTCisSubVecOfVec; 8016032269837c08a94b70b0e36f8e473c293ff5fd4David Greene x.SDTCisSubVecOfVec_Info.OtherOperandNum = 8026032269837c08a94b70b0e36f8e473c293ff5fd4David Greene R->getValueAsInt("OtherOpNum"); 8036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 8041a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Unrecognized SDTypeConstraint '" << R->getName() << "'!\n"; 8056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 8066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// getOperandNum - Return the node corresponding to operand #OpNo in tree 8102e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner/// N, and the result number in ResNo. 8112e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattnerstatic TreePatternNode *getOperandNum(unsigned OpNo, TreePatternNode *N, 8122e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner const SDNodeInfo &NodeInfo, 8132e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned &ResNo) { 8142e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned NumResults = NodeInfo.getNumResults(); 8152e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner if (OpNo < NumResults) { 8162e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner ResNo = OpNo; 8172e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner return N; 8182e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner } 819fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8202e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner OpNo -= NumResults; 821fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8222e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner if (OpNo >= N->getNumChildren()) { 823fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach errs() << "Invalid operand number in type constraint " 8242e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner << (OpNo+NumResults) << " "; 8256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->dump(); 8261a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << '\n'; 8276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 8286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8302e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner return N->getChild(OpNo); 8316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ApplyTypeConstraint - Given a node in a pattern, apply this type 8346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// constraint to the nodes operands. This returns true if it makes a 8356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// change, false otherwise. If a type contradiction is found, throw an 8366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// exception. 8376cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N, 8386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo, 8396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern &TP) const { 8402e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned ResNo = 0; // The result number being referenced. 8412e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner TreePatternNode *NodeToApply = getOperandNum(OperandNo, N, NodeInfo, ResNo); 842fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner switch (ConstraintType) { 8446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisVT: 8456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Operand must be a particular type. 846d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(ResNo, x.SDTCisVT_Info.VT, TP); 8472cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisPtrTy: 8486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Operand must be same as target pointer type. 849d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(ResNo, MVT::iPTR, TP); 8502cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisInt: 8512cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal integer VTs. 852d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceInteger(TP); 8532cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisFP: 8542cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal fp VTs. 855d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceFloatingPoint(TP); 8562cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisVec: 8572cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal vector VTs. 858d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceVector(TP); 8596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisSameAs: { 8602e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned OResNo = 0; 8616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OtherNode = 8622e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisSameAs_Info.OtherOperandNum, N, NodeInfo, OResNo); 863d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(OResNo, OtherNode->getExtType(ResNo),TP)| 864d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OtherNode->UpdateNodeType(ResNo,NodeToApply->getExtType(OResNo),TP); 8656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisVTSmallerThanOp: { 8676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The NodeToApply must be a leaf node that is a VT. OtherOperandNum must 8686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // have an integer type that is smaller than the VT. 8696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!NodeToApply->isLeaf() || 87005bce0beee87512e52428d4b80f5a8e79a949576David Greene !dynamic_cast<DefInit*>(NodeToApply->getLeafValue()) || 87105bce0beee87512e52428d4b80f5a8e79a949576David Greene !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef() 8726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ->isSubClassOf("ValueType")) 8736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error(N->getOperator()->getName() + " expects a VT operand!"); 874825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::SimpleValueType VT = 87505bce0beee87512e52428d4b80f5a8e79a949576David Greene getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()); 876fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 877cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner EEVT::TypeSet TypeListTmp(VT, TP); 878fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8792e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned OResNo = 0; 8806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OtherNode = 8812e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisVTSmallerThanOp_Info.OtherOperandNum, N, NodeInfo, 8822e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner OResNo); 8832cacec55f947c716b058a39038889550d7e39b3cChris Lattner 884cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner return TypeListTmp.EnforceSmallerThan(OtherNode->getExtType(OResNo), TP); 8856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisOpSmallerThanOp: { 8872e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned BResNo = 0; 8886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *BigOperand = 8892e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisOpSmallerThanOp_Info.BigOperandNum, N, NodeInfo, 8902e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner BResNo); 891d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo). 892d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner EnforceSmallerThan(BigOperand->getExtType(BResNo), TP); 8936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 894b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman case SDTCisEltOfVec: { 8952e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned VResNo = 0; 8962cacec55f947c716b058a39038889550d7e39b3cChris Lattner TreePatternNode *VecOperand = 8972e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisEltOfVec_Info.OtherOperandNum, N, NodeInfo, 8982e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner VResNo); 899fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 90066fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // Filter vector types out of VecOperand that don't have the right element 90166fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // type. 90266fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner return VecOperand->getExtType(VResNo). 90366fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner EnforceVectorEltTypeIs(NodeToApply->getExtType(ResNo), TP); 904b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman } 9056032269837c08a94b70b0e36f8e473c293ff5fd4David Greene case SDTCisSubVecOfVec: { 9066032269837c08a94b70b0e36f8e473c293ff5fd4David Greene unsigned VResNo = 0; 9076032269837c08a94b70b0e36f8e473c293ff5fd4David Greene TreePatternNode *BigVecOperand = 9086032269837c08a94b70b0e36f8e473c293ff5fd4David Greene getOperandNum(x.SDTCisSubVecOfVec_Info.OtherOperandNum, N, NodeInfo, 9096032269837c08a94b70b0e36f8e473c293ff5fd4David Greene VResNo); 9106032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 9116032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // Filter vector types out of BigVecOperand that don't have the 9126032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // right subvector type. 9136032269837c08a94b70b0e36f8e473c293ff5fd4David Greene return BigVecOperand->getExtType(VResNo). 9146032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EnforceVectorSubVectorTypeIs(NodeToApply->getExtType(ResNo), TP); 9156032269837c08a94b70b0e36f8e473c293ff5fd4David Greene } 916fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach } 91758bd1510a4fea29b1ea57d6a6c4038eeea0264a2David Blaikie llvm_unreachable("Invalid ConstraintType!"); 9186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 9196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 9216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// SDNodeInfo implementation 9226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 9236cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSDNodeInfo::SDNodeInfo(Record *R) : Def(R) { 9246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner EnumName = R->getValueAsString("Opcode"); 9256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SDClassName = R->getValueAsString("SDClass"); 9266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *TypeProfile = R->getValueAsDef("TypeProfile"); 9276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NumResults = TypeProfile->getValueAsInt("NumResults"); 9286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NumOperands = TypeProfile->getValueAsInt("NumOperands"); 929fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 9306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the properties. 9316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties = 0; 9326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> PropList = R->getValueAsListOfDefs("Properties"); 9336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = PropList.size(); i != e; ++i) { 9346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (PropList[i]->getName() == "SDNPCommutative") { 9356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPCommutative; 9366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPAssociative") { 9376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPAssociative; 9386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPHasChain") { 9396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPHasChain; 940036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner } else if (PropList[i]->getName() == "SDNPOutGlue") { 941036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner Properties |= 1 << SDNPOutGlue; 942036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner } else if (PropList[i]->getName() == "SDNPInGlue") { 943036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner Properties |= 1 << SDNPInGlue; 944036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner } else if (PropList[i]->getName() == "SDNPOptInGlue") { 945036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner Properties |= 1 << SDNPOptInGlue; 946c8478d8b12c2d7e4cea32d0c9940f5cac2baa4ddChris Lattner } else if (PropList[i]->getName() == "SDNPMayStore") { 947c8478d8b12c2d7e4cea32d0c9940f5cac2baa4ddChris Lattner Properties |= 1 << SDNPMayStore; 948710e995889c71812743f3f33861c24273f4569a7Chris Lattner } else if (PropList[i]->getName() == "SDNPMayLoad") { 949710e995889c71812743f3f33861c24273f4569a7Chris Lattner Properties |= 1 << SDNPMayLoad; 950bc0b9f70ae072d695e0eb7ceb729b3306b0679feChris Lattner } else if (PropList[i]->getName() == "SDNPSideEffect") { 951bc0b9f70ae072d695e0eb7ceb729b3306b0679feChris Lattner Properties |= 1 << SDNPSideEffect; 95228873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang } else if (PropList[i]->getName() == "SDNPMemOperand") { 95328873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang Properties |= 1 << SDNPMemOperand; 954e8cabf3c2eb835f9189a39c810654d9bd302f7eeChris Lattner } else if (PropList[i]->getName() == "SDNPVariadic") { 955e8cabf3c2eb835f9189a39c810654d9bd302f7eeChris Lattner Properties |= 1 << SDNPVariadic; 9566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 9571a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Unknown SD Node property '" << PropList[i]->getName() 9581a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar << "' on node '" << R->getName() << "'!\n"; 9596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 9606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 962fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 963fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 9646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the type constraints. 9656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> ConstraintList = 9666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TypeProfile->getValueAsListOfDefs("Constraints"); 9676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TypeConstraints.assign(ConstraintList.begin(), ConstraintList.end()); 9686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 9696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 970225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner/// getKnownType - If the type constraints on this node imply a fixed type 971225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner/// (e.g. all stores return void, etc), then return it as an 972aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner/// MVT::SimpleValueType. Otherwise, return EEVT::Other. 973084df627c82fdf4e1829723edf0a833b5bc31f89Chris LattnerMVT::SimpleValueType SDNodeInfo::getKnownType(unsigned ResNo) const { 974225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner unsigned NumResults = getNumResults(); 975225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner assert(NumResults <= 1 && 976225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner "We only work with nodes with zero or one result so far!"); 977084df627c82fdf4e1829723edf0a833b5bc31f89Chris Lattner assert(ResNo == 0 && "Only handles single result nodes so far"); 978fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 979225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner for (unsigned i = 0, e = TypeConstraints.size(); i != e; ++i) { 980225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner // Make sure that this applies to the correct node result. 981225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner if (TypeConstraints[i].OperandNo >= NumResults) // FIXME: need value # 982225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner continue; 983fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 984225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner switch (TypeConstraints[i].ConstraintType) { 985225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner default: break; 986225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner case SDTypeConstraint::SDTCisVT: 987225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner return TypeConstraints[i].x.SDTCisVT_Info.VT; 988225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner case SDTypeConstraint::SDTCisPtrTy: 989225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner return MVT::iPTR; 990225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner } 991225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner } 992aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner return MVT::Other; 993225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner} 994225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner 9956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 9966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// TreePatternNode implementation 9976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 9986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9996cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode::~TreePatternNode() { 10006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#if 0 // FIXME: implement refcounted tree nodes! 10016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 10026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete getChild(i); 10036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#endif 10046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 10056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1006d7349194650386d97a1d779369cb46f20ba9f252Chris Lattnerstatic unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) { 1007d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->getName() == "set" || 1008310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner Operator->getName() == "implicit") 1009d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return 0; // All return nothing. 1010fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 101193dc92e412fd06250e46951bffb6040eca9baebdChris Lattner if (Operator->isSubClassOf("Intrinsic")) 101293dc92e412fd06250e46951bffb6040eca9baebdChris Lattner return CDP.getIntrinsic(Operator).IS.RetVTs.size(); 1013fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1014d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("SDNode")) 1015d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return CDP.getSDNodeInfo(Operator).getNumResults(); 1016fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1017d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("PatFrag")) { 1018d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // If we've already parsed this pattern fragment, get it. Otherwise, handle 1019d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // the forward reference case where one pattern fragment references another 1020d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // before it is processed. 1021d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (TreePattern *PFRec = CDP.getPatternFragmentIfRead(Operator)) 1022d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return PFRec->getOnlyTree()->getNumTypes(); 1023fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1024d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // Get the result tree. 102505bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *Tree = Operator->getValueAsDag("Fragment"); 1026d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Record *Op = 0; 102705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (Tree && dynamic_cast<DefInit*>(Tree->getOperator())) 102805bce0beee87512e52428d4b80f5a8e79a949576David Greene Op = dynamic_cast<DefInit*>(Tree->getOperator())->getDef(); 1029d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(Op && "Invalid Fragment"); 1030d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return GetNumNodeResults(Op, CDP); 1031d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 1032fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1033d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("Instruction")) { 1034d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CodeGenInstruction &InstInfo = CDP.getTargetInfo().getInstruction(Operator); 10350be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 10360be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: Should allow access to all the results here. 1037c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner unsigned NumDefsToAdd = InstInfo.Operands.NumDefs ? 1 : 0; 1038fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 10399414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // Add on one implicit def if it has a resolvable type. 10409414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()) !=MVT::Other) 10419414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner ++NumDefsToAdd; 10420be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner return NumDefsToAdd; 1043d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 1044fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1045d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("SDNodeXForm")) 1046d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return 1; // FIXME: Generalize SDNodeXForm 1047fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1048d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Operator->dump(); 1049d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner errs() << "Unhandled node in GetNumNodeResults\n"; 1050d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner exit(1); 1051d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner} 10526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10531a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePatternNode::print(raw_ostream &OS) const { 1054d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (isLeaf()) 10556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << *getLeafValue(); 1056d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner else 1057ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner OS << '(' << getOperator()->getName(); 1058d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1059d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1060d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OS << ':' << getExtType(i).getName(); 10616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isLeaf()) { 10636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getNumChildren() != 0) { 10646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << " "; 10656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(0)->print(OS); 10666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 1, e = getNumChildren(); i != e; ++i) { 10676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ", "; 10686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(i)->print(OS); 10696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 10706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 10716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ")"; 10726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1073fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 10740540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = PredicateFns.size(); i != e; ++i) 1075543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner OS << "<<P:" << PredicateFns[i].getFnName() << ">>"; 10766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (TransformFn) 10776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "<<X:" << TransformFn->getName() << ">>"; 10786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getName().empty()) 10796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ":$" << getName(); 10806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 10826cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePatternNode::dump() const { 10831a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar print(errs()); 10846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 10856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1086327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isIsomorphicTo - Return true if this node is recursively 1087327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isomorphic to the specified node. For this comparison, the node's 1088327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// entire state is considered. The assigned name is ignored, since 1089327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// nodes with differing names are considered isomorphic. However, if 1090327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// the assigned name is present in the dependent variable set, then 1091327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// the assigned name is considered significant and the node is 1092327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isomorphic if the names match. 1093327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michelbool TreePatternNode::isIsomorphicTo(const TreePatternNode *N, 1094327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) const { 10956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N == this) return true; 1096d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->isLeaf() != isLeaf() || getExtTypes() != N->getExtTypes() || 10970540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman getPredicateFns() != N->getPredicateFns() || 10986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getTransformFn() != N->getTransformFn()) 10996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 11006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 110205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { 110305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *NDI = dynamic_cast<DefInit*>(N->getLeafValue())) { 110471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner return ((DI->getDef() == NDI->getDef()) 110571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner && (DepVars.find(getName()) == DepVars.end() 110671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner || getName() == N->getName())); 1107327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 1108327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 11096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return getLeafValue() == N->getLeafValue(); 11106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1111fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 11126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getOperator() != getOperator() || 11136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->getNumChildren() != getNumChildren()) return false; 11146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 1115327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (!getChild(i)->isIsomorphicTo(N->getChild(i), DepVars)) 11166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 11176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 11186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 11196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// clone - Make a copy of this tree and all of its children. 11216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 11226cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode *TreePatternNode::clone() const { 11236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *New; 11246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 1125d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(getLeafValue(), getNumTypes()); 11266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 11276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CChildren; 11286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CChildren.reserve(Children.size()); 11296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 11306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CChildren.push_back(getChild(i)->clone()); 1131d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(getOperator(), CChildren, getNumTypes()); 11326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner New->setName(getName()); 1134d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New->Types = Types; 11350540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman New->setPredicateFns(getPredicateFns()); 11366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner New->setTransformFn(getTransformFn()); 11376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return New; 11386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 11396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 114047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// RemoveAllTypes - Recursively strip all the types of this tree. 114147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnervoid TreePatternNode::RemoveAllTypes() { 1142d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1143d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Types[i] = EEVT::TypeSet(); // Reset to unknown type. 114447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (isLeaf()) return; 114547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 114647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner getChild(i)->RemoveAllTypes(); 114747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 114847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 114947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 11506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// SubstituteFormalArguments - Replace the formal arguments in this tree 11516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// with actual values specified by ArgMap. 11526cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePatternNode:: 11536cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) { 11546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return; 1155fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 11566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { 11576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = getChild(i); 11586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Child->isLeaf()) { 115905bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = Child->getLeafValue(); 116005bce0beee87512e52428d4b80f5a8e79a949576David Greene if (dynamic_cast<DefInit*>(Val) && 116105bce0beee87512e52428d4b80f5a8e79a949576David Greene static_cast<DefInit*>(Val)->getDef()->getName() == "node") { 11626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // We found a use of a formal argument, replace it with its value. 11630540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *NewChild = ArgMap[Child->getName()]; 11640540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert(NewChild && "Couldn't find formal argument!"); 11650540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert((Child->getPredicateFns().empty() || 11660540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman NewChild->getPredicateFns() == Child->getPredicateFns()) && 11670540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman "Non-empty child predicate clobbered!"); 11680540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman setChild(i, NewChild); 11696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 11716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(i)->SubstituteFormalArguments(ArgMap); 11726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 11756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// InlinePatternFragments - If this pattern refers to any pattern 11786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// fragments, inline them into place, giving us a pattern without any 11796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// PatFrag references. 11806cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode *TreePatternNode::InlinePatternFragments(TreePattern &TP) { 11816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return this; // nothing to do. 11826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Op = getOperator(); 1183fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 11846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Op->isSubClassOf("PatFrag")) { 11856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Just recursively inline children nodes. 11860540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { 11870540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *Child = getChild(i); 11880540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *NewChild = Child->InlinePatternFragments(TP); 11890540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 11900540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert((Child->getPredicateFns().empty() || 11910540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman NewChild->getPredicateFns() == Child->getPredicateFns()) && 11920540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman "Non-empty child predicate clobbered!"); 11930540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 11940540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman setChild(i, NewChild); 11950540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman } 11966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return this; 11976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, we found a reference to a fragment. First, look up its 12006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // TreePattern record. 12016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *Frag = TP.getDAGPatterns().getPatternFragment(Op); 1202fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 12036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we are passing the right number of operands. 12046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Frag->getNumArgs() != Children.size()) 12056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("'" + Op->getName() + "' fragment requires " + 12066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner utostr(Frag->getNumArgs()) + " operands!"); 12076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *FragTree = Frag->getOnlyTree()->clone(); 12096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1210543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner TreePredicateFn PredFn(Frag); 1211543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (!PredFn.isAlwaysTrue()) 1212543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner FragTree->addPredicateFn(PredFn); 12130540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 12146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Resolve formal arguments to their actual value. 12156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Frag->getNumArgs()) { 12166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Compute the map of formal to actual arguments. 12176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> ArgMap; 12186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Frag->getNumArgs(); i != e; ++i) 12196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ArgMap[Frag->getArgName(i)] = getChild(i)->InlinePatternFragments(TP); 1220fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 12216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FragTree->SubstituteFormalArguments(ArgMap); 12226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1223fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 12246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FragTree->setName(getName()); 1225d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1226d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner FragTree->UpdateNodeType(i, getExtType(i), TP); 12270540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 12280540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman // Transfer in the old predicates. 12290540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = getPredicateFns().size(); i != e; ++i) 12300540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman FragTree->addPredicateFn(getPredicateFns()[i]); 12310540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 12326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Get a new copy of this fragment to stitch into here. 12336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner //delete this; // FIXME: implement refcounting! 1234fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 12352ca698df93421327a459987b33b045756cb47d4dChris Lattner // The fragment we inlined could have recursive inlining that is needed. See 12362ca698df93421327a459987b33b045756cb47d4dChris Lattner // if there are any pattern fragments in it and inline them as needed. 12372ca698df93421327a459987b33b045756cb47d4dChris Lattner return FragTree->InlinePatternFragments(TP); 12386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 12396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// getImplicitType - Check to see if the specified record has an implicit 1241fc4c25530412907f566519dd4d0979a6570222b3Nick Lewycky/// type which should be applied to it. This will infer the type of register 12426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// references from the register file information, for example. 12436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 1244d7349194650386d97a1d779369cb46f20ba9f252Chris Lattnerstatic EEVT::TypeSet getImplicitType(Record *R, unsigned ResNo, 1245d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool NotRegisters, TreePattern &TP) { 1246bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson // Check to see if this is a register operand. 1247bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (R->isSubClassOf("RegisterOperand")) { 1248bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson assert(ResNo == 0 && "Regoperand ref only has one result!"); 1249bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (NotRegisters) 1250bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return EEVT::TypeSet(); // Unknown. 1251bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Record *RegClass = R->getValueAsDef("RegClass"); 1252bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 1253bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return EEVT::TypeSet(T.getRegisterClass(RegClass).getValueTypes()); 1254bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1255bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 12562cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Check to see if this is a register or a register class. 12576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("RegisterClass")) { 1258640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Regclass ref only has one result!"); 1259fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach if (NotRegisters) 12602cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 12612cacec55f947c716b058a39038889550d7e39b3cChris Lattner const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 12622cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(T.getRegisterClass(R).getValueTypes()); 1263640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1264fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1265640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("PatFrag")) { 1266640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "FIXME: PatFrag with multiple results?"); 12676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Pattern fragment types will be resolved when they are inlined. 12682cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 1269640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1270fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1271640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("Register")) { 1272640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Registers only produce one result!"); 1273fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach if (NotRegisters) 12742cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 12756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 12762cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(T.getRegisterVTs(R)); 1277640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 127873ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen 127973ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen if (R->isSubClassOf("SubRegIndex")) { 128073ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen assert(ResNo == 0 && "SubRegisterIndices only produce one result!"); 128173ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen return EEVT::TypeSet(); 128273ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen } 1283fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1284640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("ValueType") || R->isSubClassOf("CondCode")) { 1285640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "This node only has one result!"); 12866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Using a VTSDNode or CondCodeSDNode. 12872cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::Other, TP); 1288640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1289fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1290640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("ComplexPattern")) { 1291640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "FIXME: ComplexPattern with multiple results?"); 1292fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach if (NotRegisters) 12932cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 12942cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(TP.getDAGPatterns().getComplexPattern(R).getValueType(), 12952cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP); 1296640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1297640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("PointerLikeRegClass")) { 1298640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Regclass can only have one result!"); 12992cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::iPTR, TP); 1300640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1301fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1302640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->getName() == "node" || R->getName() == "srcvalue" || 1303640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner R->getName() == "zero_reg") { 13046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Placeholder. 13052cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 13066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1307fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 13086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Unknown node flavor used in pattern: " + R->getName()); 13092cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::Other, TP); 13106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 13116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1312e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 1313e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner/// getIntrinsicInfo - If this node corresponds to an intrinsic, return the 1314e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner/// CodeGenIntrinsic information for it, otherwise return a null pointer. 1315e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattnerconst CodeGenIntrinsic *TreePatternNode:: 1316e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris LattnergetIntrinsicInfo(const CodeGenDAGPatterns &CDP) const { 1317e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner if (getOperator() != CDP.get_intrinsic_void_sdnode() && 1318e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner getOperator() != CDP.get_intrinsic_w_chain_sdnode() && 1319e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner getOperator() != CDP.get_intrinsic_wo_chain_sdnode()) 1320e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner return 0; 1321fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1322fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach unsigned IID = 132305bce0beee87512e52428d4b80f5a8e79a949576David Greene dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue(); 1324e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner return &CDP.getIntrinsicInfo(IID); 1325e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner} 1326e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 132747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// getComplexPatternInfo - If this node corresponds to a ComplexPattern, 132847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// return the ComplexPattern information, otherwise return null. 132947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerconst ComplexPattern * 133047661320363a8bf0bb1401a8c1893755fb77c8f6Chris LattnerTreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const { 133147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (!isLeaf()) return 0; 1332fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 133305bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *DI = dynamic_cast<DefInit*>(getLeafValue()); 133447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (DI && DI->getDef()->isSubClassOf("ComplexPattern")) 133547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return &CGP.getComplexPattern(DI->getDef()); 133647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return 0; 133747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 133847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 133947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// NodeHasProperty - Return true if this node has the specified property. 134047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerbool TreePatternNode::NodeHasProperty(SDNP Property, 1341751d5aa1eadf041f00acf76f3b641549c8be3998Chris Lattner const CodeGenDAGPatterns &CGP) const { 134247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (isLeaf()) { 134347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (const ComplexPattern *CP = getComplexPatternInfo(CGP)) 134447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return CP->hasProperty(Property); 134547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return false; 134647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner } 1347fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 134847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner Record *Operator = getOperator(); 134947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (!Operator->isSubClassOf("SDNode")) return false; 1350fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 135147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return CGP.getSDNodeInfo(Operator).hasProperty(Property); 135247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 135347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 135447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 135547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 135647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 135747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// TreeHasProperty - Return true if any node in this tree has the specified 135847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// property. 135947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerbool TreePatternNode::TreeHasProperty(SDNP Property, 1360751d5aa1eadf041f00acf76f3b641549c8be3998Chris Lattner const CodeGenDAGPatterns &CGP) const { 136147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (NodeHasProperty(Property, CGP)) 136247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return true; 136347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 136447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (getChild(i)->TreeHasProperty(Property, CGP)) 136547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return true; 136647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return false; 1367fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach} 136847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 13696bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng/// isCommutativeIntrinsic - Return true if the node corresponds to a 13706bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng/// commutative intrinsic. 13716bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Chengbool 13726bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan ChengTreePatternNode::isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const { 13736bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) 13746bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng return Int->isCommutative; 13756bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng return false; 13766bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng} 13776bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng 1378e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 13796c01ca9e29816e36e96112ed541ecf3414a7aad2Bob Wilson/// ApplyTypeConstraints - Apply all of the type constraints relevant to 13806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// this node and its children in the tree. This returns true if it makes a 13816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// change, false otherwise. If a type contradiction is found, throw an 13826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// exception. 13836cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) { 1384fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &CDP = TP.getDAGPatterns(); 13856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 138605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { 13876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If it's a regclass or something else known, include the type. 1388d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = false; 1389d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1390d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(i, getImplicitType(DI->getDef(), i, 1391d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner NotRegisters, TP), TP); 1392d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return MadeChange; 1393523f6a5848194c135168112751c36884dc704e54Chris Lattner } 1394fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 139505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) { 1396d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(Types.size() == 1 && "Invalid IntInit"); 1397fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 13986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Int inits are always integers. :) 1399d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = Types[0].EnforceInteger(TP); 1400fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1401d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (!Types[0].isConcrete()) 14022cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 1403fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1404d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType VT = getType(0); 14052cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VT == MVT::iPTR || VT == MVT::iPTRAny) 14062cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 1407fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14082cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned Size = EVT(VT).getSizeInBits(); 14092cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Make sure that the value is representable for this type. 14102cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Size >= 32) return MadeChange; 1411fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14122cacec55f947c716b058a39038889550d7e39b3cChris Lattner int Val = (II->getValue() << (32-Size)) >> (32-Size); 14132cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Val == II->getValue()) return MadeChange; 1414fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14152cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If sign-extended doesn't fit, does it fit as unsigned? 14162cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned ValueMask; 14172cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned UnsignedVal; 14182cacec55f947c716b058a39038889550d7e39b3cChris Lattner ValueMask = unsigned(~uint32_t(0UL) >> (32-Size)); 14192cacec55f947c716b058a39038889550d7e39b3cChris Lattner UnsignedVal = unsigned(II->getValue()); 14202cacec55f947c716b058a39038889550d7e39b3cChris Lattner 14212cacec55f947c716b058a39038889550d7e39b3cChris Lattner if ((ValueMask & UnsignedVal) == UnsignedVal) 14222cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 1423fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14242cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Integer value '" + itostr(II->getValue())+ 1425d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "' is out of range for type '" + getEnumName(getType(0)) + "'!"); 14266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 14276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 14296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1430fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // special handling for set, which isn't really an SDNode. 14326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getOperator()->getName() == "set") { 1433d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumTypes() == 0 && "Set doesn't produce a value"); 1434d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumChildren() >= 2 && "Missing RHS of a set?"); 14356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NC = getNumChildren(); 1436fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1437d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *SetVal = getChild(NC-1); 1438d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = SetVal->ApplyTypeConstraints(TP, NotRegisters); 1439d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 14406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i < NC-1; ++i) { 1441d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Child = getChild(i); 1442d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Child->ApplyTypeConstraints(TP, NotRegisters); 1443fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Types of operands must match. 1445d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Child->UpdateNodeType(0, SetVal->getExtType(i), TP); 1446d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= SetVal->UpdateNodeType(i, Child->getExtType(0), TP); 14476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 14496eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 1450fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1451310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner if (getOperator()->getName() == "implicit") { 1452d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumTypes() == 0 && "Node doesn't produce a value"); 1453d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 14546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = false; 14556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i < getNumChildren(); ++i) 14566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange = getChild(i)->ApplyTypeConstraints(TP, NotRegisters); 14576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 14586eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 1459fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14606eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->getName() == "COPY_TO_REGCLASS") { 1461f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman bool MadeChange = false; 1462f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman MadeChange |= getChild(0)->ApplyTypeConstraints(TP, NotRegisters); 1463f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman MadeChange |= getChild(1)->ApplyTypeConstraints(TP, NotRegisters); 1464fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1465d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(0)->getNumTypes() == 1 && 1466d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner getChild(1)->getNumTypes() == 1 && "Unhandled case"); 1467fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14682cacec55f947c716b058a39038889550d7e39b3cChris Lattner // child #1 of COPY_TO_REGCLASS should be a register class. We don't care 14692cacec55f947c716b058a39038889550d7e39b3cChris Lattner // what type it gets, so if it didn't get a concrete type just give it the 14702cacec55f947c716b058a39038889550d7e39b3cChris Lattner // first viable type from the reg class. 1471d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (!getChild(1)->hasTypeSet(0) && 1472d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner !getChild(1)->getExtType(0).isCompletelyUnknown()) { 1473d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType RCVT = getChild(1)->getExtType(0).getTypeList()[0]; 1474d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(1)->UpdateNodeType(0, RCVT, TP); 14752cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1476f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman return MadeChange; 14776eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 1478fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14796eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) { 14806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = false; 148183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands 14826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the result type to the node. 1483cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling unsigned NumRetVTs = Int->IS.RetVTs.size(); 1484cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling unsigned NumParamVTs = Int->IS.ParamVTs.size(); 1485fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1486cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling for (unsigned i = 0, e = NumRetVTs; i != e; ++i) 1487d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(i, Int->IS.RetVTs[i], TP); 1488cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling 1489d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (getNumChildren() != NumParamVTs + 1) 1490e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner TP.error("Intrinsic '" + Int->Name + "' expects " + 1491d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner utostr(NumParamVTs) + " operands, not " + 1492cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling utostr(getNumChildren() - 1) + " operands!"); 14936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply type info to the intrinsic ID. 1495d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(0)->UpdateNodeType(0, MVT::iPTR, TP); 1496fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1497d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = getNumChildren()-1; i != e; ++i) { 1498d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(i+1)->ApplyTypeConstraints(TP, NotRegisters); 1499fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1500d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType OpVT = Int->IS.ParamVTs[i]; 1501d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(i+1)->getNumTypes() == 1 && "Unhandled case"); 1502d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(i+1)->UpdateNodeType(0, OpVT, TP); 15036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 15056eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 1506fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15076eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->isSubClassOf("SDNode")) { 15086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NI = CDP.getSDNodeInfo(getOperator()); 1509fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15102a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner // Check that the number of operands is sane. Negative operands -> varargs. 15112a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner if (NI.getNumOperands() >= 0 && 15122a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner getNumChildren() != (unsigned)NI.getNumOperands()) 15132a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner TP.error(getOperator()->getName() + " node requires exactly " + 15142a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner itostr(NI.getNumOperands()) + " operands!"); 1515fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = NI.ApplyTypeConstraints(this, TP); 15176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 15186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters); 1519d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return MadeChange; 15206eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 1521fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15226eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->isSubClassOf("Instruction")) { 15236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const DAGInstruction &Inst = CDP.getInstruction(getOperator()); 15246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CodeGenInstruction &InstInfo = 1525f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CDP.getTargetInfo().getInstruction(getOperator()); 1526fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15270be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner bool MadeChange = false; 15280be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 15290be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // Apply the result types to the node, these come from the things in the 15300be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // (outs) list of the instruction. 15310be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: Cap at one result so far. 1532c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner unsigned NumResultsToAdd = InstInfo.Operands.NumDefs ? 1 : 0; 15330be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner for (unsigned ResNo = 0; ResNo != NumResultsToAdd; ++ResNo) { 15340be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner Record *ResultNode = Inst.getResult(ResNo); 1535fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1536a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner if (ResultNode->isSubClassOf("PointerLikeRegClass")) { 15370be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= UpdateNodeType(ResNo, MVT::iPTR, TP); 1538bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } else if (ResultNode->isSubClassOf("RegisterOperand")) { 1539bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Record *RegClass = ResultNode->getValueAsDef("RegClass"); 1540bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson const CodeGenRegisterClass &RC = 1541bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson CDP.getTargetInfo().getRegisterClass(RegClass); 1542bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson MadeChange |= UpdateNodeType(ResNo, RC.getValueTypes(), TP); 15435b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb } else if (ResultNode->getName() == "unknown") { 15442cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Nothing to do. 15456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 15466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(ResultNode->isSubClassOf("RegisterClass") && 15476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "Operands should be register classes!"); 1548fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach const CodeGenRegisterClass &RC = 15496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CDP.getTargetInfo().getRegisterClass(ResultNode); 15500be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= UpdateNodeType(ResNo, RC.getValueTypes(), TP); 15516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15520be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner } 1553fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15540be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // If the instruction has implicit defs, we apply the first one as a result. 15550be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: This sucks, it should apply all implicit defs. 15560be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner if (!InstInfo.ImplicitDefs.empty()) { 15570be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned ResNo = NumResultsToAdd; 1558fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15599414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // FIXME: Generalize to multiple possible types and multiple possible 15609414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // ImplicitDefs. 15619414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner MVT::SimpleValueType VT = 15629414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()); 1563fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15649414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (VT != MVT::Other) 15659414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner MadeChange |= UpdateNodeType(ResNo, VT, TP); 15666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1567fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15682cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this is an INSERT_SUBREG, constrain the source and destination VTs to 15692cacec55f947c716b058a39038889550d7e39b3cChris Lattner // be the same. 15702cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (getOperator()->getName() == "INSERT_SUBREG") { 1571d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(0)->getNumTypes() == 1 && "FIXME: Unhandled"); 1572d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(0, getChild(0)->getExtType(0), TP); 1573d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(0)->UpdateNodeType(0, getExtType(0), TP); 15742cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 15756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned ChildNo = 0; 15776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Inst.getNumOperands(); i != e; ++i) { 15786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *OperandNode = Inst.getOperand(i); 1579fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the instruction expects a predicate or optional def operand, we 15816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // codegen this by setting the operand to it's default value if it has a 15826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // non-empty DefaultOps field. 15836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if ((OperandNode->isSubClassOf("PredicateOperand") || 15846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OperandNode->isSubClassOf("OptionalDefOperand")) && 15856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !CDP.getDefaultOperand(OperandNode).DefaultOps.empty()) 15866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 1587fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we didn't run out of provided operands. 15896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (ChildNo >= getNumChildren()) 15906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Instruction '" + getOperator()->getName() + 15916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' expects more operands than were provided."); 1592fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1593825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::SimpleValueType VT; 15946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = getChild(ChildNo++); 15950be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned ChildResNo = 0; // Instructions always use res #0 of their op. 1596fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OperandNode->isSubClassOf("RegisterClass")) { 1598fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach const CodeGenRegisterClass &RC = 15996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CDP.getTargetInfo().getRegisterClass(OperandNode); 16000be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= Child->UpdateNodeType(ChildResNo, RC.getValueTypes(), TP); 1601bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } else if (OperandNode->isSubClassOf("RegisterOperand")) { 1602bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Record *RegClass = OperandNode->getValueAsDef("RegClass"); 1603bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson const CodeGenRegisterClass &RC = 1604bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson CDP.getTargetInfo().getRegisterClass(RegClass); 1605bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson MadeChange |= Child->UpdateNodeType(ChildResNo, RC.getValueTypes(), TP); 16066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (OperandNode->isSubClassOf("Operand")) { 16076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner VT = getValueType(OperandNode->getValueAsDef("Type")); 16080be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= Child->UpdateNodeType(ChildResNo, VT, TP); 1609a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner } else if (OperandNode->isSubClassOf("PointerLikeRegClass")) { 16100be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= Child->UpdateNodeType(ChildResNo, MVT::iPTR, TP); 16115b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb } else if (OperandNode->getName() == "unknown") { 16122cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Nothing to do. 1613655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper } else 1614655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper llvm_unreachable("Unknown operand type!"); 1615655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper 16166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= Child->ApplyTypeConstraints(TP, NotRegisters); 16176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 16185b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb 161902f693708d0731cfd31f8ab69766f150c169231eChristopher Lamb if (ChildNo != getNumChildren()) 16206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Instruction '" + getOperator()->getName() + 16216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' was provided too many operands!"); 1622fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 16246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1625fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16266eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner assert(getOperator()->isSubClassOf("SDNodeXForm") && "Unknown node type!"); 1627fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16286eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // Node transforms always take one operand. 16296eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getNumChildren() != 1) 16306eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner TP.error("Node transform '" + getOperator()->getName() + 16316eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner "' requires one operand!"); 16326eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 16332cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = getChild(0)->ApplyTypeConstraints(TP, NotRegisters); 16342cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1635fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16366eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // If either the output or input of the xform does not have exact 16376eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // type info. We assume they must be the same. Otherwise, it is perfectly 16386eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // legal to transform from one type to a completely different type. 16392cacec55f947c716b058a39038889550d7e39b3cChris Lattner#if 0 16406eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (!hasTypeSet() || !getChild(0)->hasTypeSet()) { 16412cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = UpdateNodeType(getChild(0)->getExtType(), TP); 16422cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= getChild(0)->UpdateNodeType(getExtType(), TP); 16436eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner return MadeChange; 16446eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 16452cacec55f947c716b058a39038889550d7e39b3cChris Lattner#endif 16462cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 16476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 16486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// OnlyOnRHSOfCommutative - Return true if this value is only allowed on the 16506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// RHS of a commutative operation, not the on LHS. 16516cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic bool OnlyOnRHSOfCommutative(TreePatternNode *N) { 16526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!N->isLeaf() && N->getOperator()->getName() == "imm") 16536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 165405bce0beee87512e52428d4b80f5a8e79a949576David Greene if (N->isLeaf() && dynamic_cast<IntInit*>(N->getLeafValue())) 16556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 16566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 16576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 16586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// canPatternMatch - If it is impossible for this pattern to match on this 16616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// target, fill in Reason and return false. Otherwise, return true. This is 1662da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach/// used as a sanity check for .td files (to prevent people from writing stuff 16636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// that can never possibly work), and to prevent the pattern permuter from 16646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// generating stuff that is useless. 1665fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbachbool TreePatternNode::canPatternMatch(std::string &Reason, 1666ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP) { 16676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return true; 16686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 16706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getChild(i)->canPatternMatch(Reason, CDP)) 16716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 16726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is an intrinsic, handle cases that would make it not match. For 16746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // example, if an operand is required to be an immediate. 16756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getOperator()->isSubClassOf("Intrinsic")) { 16766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // TODO: 16776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 16786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1679fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this node is a commutative operator, check that the LHS isn't an 16816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // immediate. 16826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(getOperator()); 16836bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool isCommIntrinsic = isCommutativeIntrinsic(CDP); 16846bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { 16856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan all of the operands of the node and make sure that only the last one 16866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // is a constant node, unless the RHS also is. 16876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OnlyOnRHSOfCommutative(getChild(getNumChildren()-1))) { 16886bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool Skip = isCommIntrinsic ? 1 : 0; // First operand is intrinsic id. 16896bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng for (unsigned i = Skip, e = getNumChildren()-1; i != e; ++i) 16906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OnlyOnRHSOfCommutative(getChild(i))) { 16916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Reason="Immediate value must be on the RHS of commutative operators!"; 16926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 16936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 16946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 16956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1696fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 16986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 16996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 17016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// TreePattern implementation 17026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 17036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 170405bce0beee87512e52428d4b80f5a8e79a949576David GreeneTreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput, 1705fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ 17062cacec55f947c716b058a39038889550d7e39b3cChris Lattner isInputPattern = isInput; 17072cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = RawPat->getSize(); i != e; ++i) 1708c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Trees.push_back(ParseTreePattern(RawPat->getElement(i), "")); 17096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 171105bce0beee87512e52428d4b80f5a8e79a949576David GreeneTreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput, 1712fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ 17136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner isInputPattern = isInput; 1714c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Trees.push_back(ParseTreePattern(Pat, "")); 17156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17176cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePattern::TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput, 1718fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ 17196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner isInputPattern = isInput; 17206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Trees.push_back(Pat); 17216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17236cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePattern::error(const std::string &Msg) const { 17246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner dump(); 1725a14b1ded69dc76f4e41ef60eeab89dc8575af44bChris Lattner throw TGError(TheRecord->getLoc(), "In " + TheRecord->getName() + ": " + Msg); 17266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17282cacec55f947c716b058a39038889550d7e39b3cChris Lattnervoid TreePattern::ComputeNamedNodes() { 17292cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) 17302cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(Trees[i]); 17312cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 17322cacec55f947c716b058a39038889550d7e39b3cChris Lattner 17332cacec55f947c716b058a39038889550d7e39b3cChris Lattnervoid TreePattern::ComputeNamedNodes(TreePatternNode *N) { 17342cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!N->getName().empty()) 17352cacec55f947c716b058a39038889550d7e39b3cChris Lattner NamedNodes[N->getName()].push_back(N); 1736fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 17372cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 17382cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(N->getChild(i)); 17392cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 17402cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1741d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 174205bce0beee87512e52428d4b80f5a8e79a949576David GreeneTreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){ 174305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *DI = dynamic_cast<DefInit*>(TheInit)) { 1744c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Record *R = DI->getDef(); 1745fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1746c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Direct reference to a leaf DagNode or PatFrag? Turn it into a 174766c9ee7e6d7072a5ecc0131b9dd78a20e72cb597Jim Grosbach // TreePatternNode of its own. For example: 1748c217305f764447eb65e7bf7f9205c14632885969Chris Lattner /// (foo GPR, imm) -> (foo GPR, (imm)) 1749c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag")) 1750dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ParseTreePattern( 1751dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene DagInit::get(DI, "", 175205bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<Init*, std::string> >()), 1753dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene OpName); 1754fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1755c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Input argument? 1756c217305f764447eb65e7bf7f9205c14632885969Chris Lattner TreePatternNode *Res = new TreePatternNode(DI, 1); 17572a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner if (R->getName() == "node" && !OpName.empty()) { 1758c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (OpName.empty()) 1759c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("'node' argument requires a name to match with operand list"); 1760c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Args.push_back(OpName); 1761c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1762c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1763c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Res->setName(OpName); 1764c217305f764447eb65e7bf7f9205c14632885969Chris Lattner return Res; 1765c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1766fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 176705bce0beee87512e52428d4b80f5a8e79a949576David Greene if (IntInit *II = dynamic_cast<IntInit*>(TheInit)) { 1768c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!OpName.empty()) 1769c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("Constant int argument should not have a name!"); 1770c217305f764447eb65e7bf7f9205c14632885969Chris Lattner return new TreePatternNode(II, 1); 1771c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1772fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 177305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (BitsInit *BI = dynamic_cast<BitsInit*>(TheInit)) { 1774c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Turn this into an IntInit. 177505bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *II = BI->convertInitializerTo(IntRecTy::get()); 177605bce0beee87512e52428d4b80f5a8e79a949576David Greene if (II == 0 || !dynamic_cast<IntInit*>(II)) 1777c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("Bits value must be constants!"); 1778b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner return ParseTreePattern(II, OpName); 1779c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1780c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 178105bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *Dag = dynamic_cast<DagInit*>(TheInit); 1782c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!Dag) { 1783c217305f764447eb65e7bf7f9205c14632885969Chris Lattner TheInit->dump(); 1784c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("Pattern has unexpected init kind!"); 1785c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 178605bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator()); 17876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OpDef) error("Pattern has unexpected operator type!"); 17886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Operator = OpDef->getDef(); 1789fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 17906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Operator->isSubClassOf("ValueType")) { 17916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the operator is a ValueType, then this must be "type cast" of a leaf 17926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // node. 17936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Dag->getNumArgs() != 1) 17946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Type cast only takes one operand!"); 1795fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1796c217305f764447eb65e7bf7f9205c14632885969Chris Lattner TreePatternNode *New = ParseTreePattern(Dag->getArg(0), Dag->getArgName(0)); 1797fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 17986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the type cast. 1799d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(New->getNumTypes() == 1 && "FIXME: Unhandled"); 1800d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New->UpdateNodeType(0, getValueType(Operator), *this); 1801fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1802c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!OpName.empty()) 1803c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("ValueType cast should not have a name!"); 18046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return New; 18056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1806fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 18076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that this is something that makes sense for an operator. 1808fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach if (!Operator->isSubClassOf("PatFrag") && 18097cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman !Operator->isSubClassOf("SDNode") && 1810fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach !Operator->isSubClassOf("Instruction") && 18116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("SDNodeXForm") && 18126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("Intrinsic") && 18136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator->getName() != "set" && 1814310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner Operator->getName() != "implicit") 18156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Unrecognized node '" + Operator->getName() + "'!"); 1816fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 18176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check to see if this is something that is illegal in an input pattern. 1818b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (isInputPattern) { 1819b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (Operator->isSubClassOf("Instruction") || 1820b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->isSubClassOf("SDNodeXForm")) 1821b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner error("Cannot use '" + Operator->getName() + "' in an input pattern!"); 1822b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner } else { 1823b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (Operator->isSubClassOf("Intrinsic")) 1824b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner error("Cannot use '" + Operator->getName() + "' in an output pattern!"); 1825fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1826b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (Operator->isSubClassOf("SDNode") && 1827b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "imm" && 1828b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "fpimm" && 1829b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tglobaltlsaddr" && 1830b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tconstpool" && 1831b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tjumptable" && 1832b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tframeindex" && 1833b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "texternalsym" && 1834b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tblockaddress" && 1835b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tglobaladdr" && 1836b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "bb" && 1837b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "vt") 1838b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner error("Cannot use '" + Operator->getName() + "' in an output pattern!"); 1839b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner } 1840fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 18416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 1842c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1843c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Parse all the operands. 1844c217305f764447eb65e7bf7f9205c14632885969Chris Lattner for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) 1845c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Children.push_back(ParseTreePattern(Dag->getArg(i), Dag->getArgName(i))); 1846fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 18476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the operator is an intrinsic, then this is just syntactic sugar for for 1848fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach // (intrinsic_* <number>, ..children..). Pick the right intrinsic node, and 18496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // convert the intrinsic name to a number. 18506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Operator->isSubClassOf("Intrinsic")) { 18516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenIntrinsic &Int = getDAGPatterns().getIntrinsic(Operator); 18526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned IID = getDAGPatterns().getIntrinsicID(Operator)+1; 18536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this intrinsic returns void, it must have side-effects and thus a 18556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // chain. 1856c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (Int.IS.RetVTs.empty()) 18576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_void_sdnode(); 1858c217305f764447eb65e7bf7f9205c14632885969Chris Lattner else if (Int.ModRef != CodeGenIntrinsic::NoMem) 18596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Has side-effects, requires chain. 18606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_w_chain_sdnode(); 1861c217305f764447eb65e7bf7f9205c14632885969Chris Lattner else // Otherwise, no chain. 18626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode(); 1863fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1864dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene TreePatternNode *IIDNode = new TreePatternNode(IntInit::get(IID), 1); 18656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.insert(Children.begin(), IIDNode); 18666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1867fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1868d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner unsigned NumResults = GetNumNodeResults(Operator, CDP); 1869d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Result = new TreePatternNode(Operator, Children, NumResults); 1870c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Result->setName(OpName); 1871fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1872c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!Dag->getName().empty()) { 1873c217305f764447eb65e7bf7f9205c14632885969Chris Lattner assert(Result->getName().empty()); 1874c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Result->setName(Dag->getName()); 1875c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 18767cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman return Result; 18776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18797a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// SimplifyTree - See if we can simplify this tree to eliminate something that 18807a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// will never match in favor of something obvious that will. This is here 18817a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// strictly as a convenience to target authors because it allows them to write 18827a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// more type generic things and have useless type casts fold away. 18837a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// 18847a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// This returns true if any change is made. 18857a0eb91b4c238542a11ca805af15933cc8290786Chris Lattnerstatic bool SimplifyTree(TreePatternNode *&N) { 18867a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner if (N->isLeaf()) 18877a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner return false; 18887a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 18897a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner // If we have a bitconvert with a resolved type and if the source and 18907a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner // destination types are the same, then the bitconvert is useless, remove it. 18917a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner if (N->getOperator()->getName() == "bitconvert" && 18927a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->getExtType(0).isConcrete() && 18937a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->getExtType(0) == N->getChild(0)->getExtType(0) && 18947a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->getName().empty()) { 18957a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N = N->getChild(0); 18967a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner SimplifyTree(N); 18977a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner return true; 18987a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner } 18997a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 19007a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner // Walk all children. 19017a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner bool MadeChange = false; 19027a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { 19037a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner TreePatternNode *Child = N->getChild(i); 19047a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner MadeChange |= SimplifyTree(Child); 19057a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->setChild(i, Child); 19067a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner } 19077a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner return MadeChange; 19087a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner} 19097a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 19107a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 19117a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 19126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// InferAllTypes - Infer/propagate as many types throughout the expression 1913da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach/// patterns as possible. Return true if all types are inferred, false 19146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// otherwise. Throw an exception if a type contradiction is found. 19152cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool TreePattern:: 19162cacec55f947c716b058a39038889550d7e39b3cChris LattnerInferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) { 19172cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (NamedNodes.empty()) 19182cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(); 19192cacec55f947c716b058a39038889550d7e39b3cChris Lattner 19206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = true; 19216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (MadeChange) { 19226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange = false; 19237a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) { 19246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= Trees[i]->ApplyTypeConstraints(*this, false); 19257a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner MadeChange |= SimplifyTree(Trees[i]); 19267a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner } 19272cacec55f947c716b058a39038889550d7e39b3cChris Lattner 19282cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If there are constraints on our named nodes, apply them. 1929fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach for (StringMap<SmallVector<TreePatternNode*,1> >::iterator 19302cacec55f947c716b058a39038889550d7e39b3cChris Lattner I = NamedNodes.begin(), E = NamedNodes.end(); I != E; ++I) { 19312cacec55f947c716b058a39038889550d7e39b3cChris Lattner SmallVectorImpl<TreePatternNode*> &Nodes = I->second; 1932fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19332cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we have input named node types, propagate their types to the named 19342cacec55f947c716b058a39038889550d7e39b3cChris Lattner // values here. 19352cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InNamedTypes) { 19362cacec55f947c716b058a39038889550d7e39b3cChris Lattner // FIXME: Should be error? 19372cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(InNamedTypes->count(I->getKey()) && 19382cacec55f947c716b058a39038889550d7e39b3cChris Lattner "Named node in output pattern but not input pattern?"); 19392cacec55f947c716b058a39038889550d7e39b3cChris Lattner 19402cacec55f947c716b058a39038889550d7e39b3cChris Lattner const SmallVectorImpl<TreePatternNode*> &InNodes = 19412cacec55f947c716b058a39038889550d7e39b3cChris Lattner InNamedTypes->find(I->getKey())->second; 19422cacec55f947c716b058a39038889550d7e39b3cChris Lattner 19432cacec55f947c716b058a39038889550d7e39b3cChris Lattner // The input types should be fully resolved by now. 19442cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Nodes.size(); i != e; ++i) { 19452cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this node is a register class, and it is the root of the pattern 19462cacec55f947c716b058a39038889550d7e39b3cChris Lattner // then we're mapping something onto an input register. We allow 19472cacec55f947c716b058a39038889550d7e39b3cChris Lattner // changing the type of the input register in this case. This allows 19482cacec55f947c716b058a39038889550d7e39b3cChris Lattner // us to match things like: 19492cacec55f947c716b058a39038889550d7e39b3cChris Lattner // def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>; 19502cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) { 195105bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *DI = dynamic_cast<DefInit*>(Nodes[i]->getLeafValue()); 1952bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || 1953bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson DI->getDef()->isSubClassOf("RegisterOperand"))) 19542cacec55f947c716b058a39038889550d7e39b3cChris Lattner continue; 19552cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1956fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 195732f6a8b8bb9de0180036eaf7f7ac6dc030d85655Daniel Dunbar assert(Nodes[i]->getNumTypes() == 1 && 1958d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner InNodes[0]->getNumTypes() == 1 && 1959d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "FIXME: cannot name multiple result nodes yet"); 1960d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Nodes[i]->UpdateNodeType(0, InNodes[0]->getExtType(0), 1961d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner *this); 19622cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 19632cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1964fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19652cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If there are multiple nodes with the same name, they must all have the 19662cacec55f947c716b058a39038889550d7e39b3cChris Lattner // same type. 19672cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (I->second.size() > 1) { 19682cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Nodes.size()-1; i != e; ++i) { 1969d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *N1 = Nodes[i], *N2 = Nodes[i+1]; 197032f6a8b8bb9de0180036eaf7f7ac6dc030d85655Daniel Dunbar assert(N1->getNumTypes() == 1 && N2->getNumTypes() == 1 && 1971d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "FIXME: cannot name multiple result nodes yet"); 1972fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1973d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= N1->UpdateNodeType(0, N2->getExtType(0), *this); 1974d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= N2->UpdateNodeType(0, N1->getExtType(0), *this); 19752cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 19762cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 19772cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 19786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1979fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool HasUnresolvedTypes = false; 19816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) 19826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner HasUnresolvedTypes |= Trees[i]->ContainsUnresolvedType(); 19836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return !HasUnresolvedTypes; 19846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 19856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19861a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePattern::print(raw_ostream &OS) const { 19876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << getRecord()->getName(); 19886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Args.empty()) { 19896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "(" << Args[0]; 19906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) 19916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ", " << Args[i]; 19926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ")"; 19936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ": "; 1995fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Trees.size() > 1) 19976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "[\n"; 19986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) { 19996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "\t"; 20006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Trees[i]->print(OS); 20016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "\n"; 20026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Trees.size() > 1) 20056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "]\n"; 20066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20081a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePattern::dump() const { print(errs()); } 20096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 2011fe71893183f504feff290e343bf740bd32432129Chris Lattner// CodeGenDAGPatterns implementation 20126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 20136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2014fbadcd0826c2e69ed21c2d535310ba958acb4359Jim GrosbachCodeGenDAGPatterns::CodeGenDAGPatterns(RecordKeeper &R) : 201567db883487fca3472fdde51e931657e22d4d0495Chris Lattner Records(R), Target(R) { 201667db883487fca3472fdde51e931657e22d4d0495Chris Lattner 201749de98214b82fefeb8f16efbf8cdd8813a85469bDale Johannesen Intrinsics = LoadIntrinsics(Records, false); 201849de98214b82fefeb8f16efbf8cdd8813a85469bDale Johannesen TgtIntrinsics = LoadIntrinsics(Records, true); 20196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseNodeInfo(); 2020443e3f9dd61b8d0974bb13d484195ce1a9b7536cChris Lattner ParseNodeTransforms(); 20216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseComplexPatterns(); 2022dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner ParsePatternFragments(); 20236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseDefaultOperands(); 20246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseInstructions(); 20256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParsePatterns(); 2026fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 20276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Generate variants. For example, commutative patterns can match 20286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // multiple ways. Add them to PatternsToMatch as well. 20296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GenerateVariants(); 2030ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2031ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Infer instruction flags. For example, we can detect loads, 2032ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // stores, and side effects in many cases by examining an 2033ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // instruction's pattern. 2034ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InferInstructionFlags(); 20356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2037fe71893183f504feff290e343bf740bd32432129Chris LattnerCodeGenDAGPatterns::~CodeGenDAGPatterns() { 20385b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer for (pf_iterator I = PatternFragments.begin(), 20396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner E = PatternFragments.end(); I != E; ++I) 20406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete I->second; 20416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2044fe71893183f504feff290e343bf740bd32432129Chris LattnerRecord *CodeGenDAGPatterns::getSDNodeNamed(const std::string &Name) const { 20456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *N = Records.getDef(Name); 20466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!N || !N->isSubClassOf("SDNode")) { 20471a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Error getting SDNode '" << Name << "'!\n"; 20486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 20496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return N; 20516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// Parse all of the SDNode definitions for the target, populating SDNodes. 2054fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseNodeInfo() { 20556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("SDNode"); 20566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!Nodes.empty()) { 20576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SDNodes.insert(std::make_pair(Nodes.back(), Nodes.back())); 20586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Nodes.pop_back(); 20596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2061da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // Get the builtin intrinsic nodes. 20626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_void_sdnode = getSDNodeNamed("intrinsic_void"); 20636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_w_chain_sdnode = getSDNodeNamed("intrinsic_w_chain"); 20646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_wo_chain_sdnode = getSDNodeNamed("intrinsic_wo_chain"); 20656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParseNodeTransforms - Parse all SDNodeXForm instances into the SDNodeXForms 20686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// map, and emit them to the file as functions. 2069fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseNodeTransforms() { 20706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Xforms = Records.getAllDerivedDefinitions("SDNodeXForm"); 20716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!Xforms.empty()) { 20726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *XFormNode = Xforms.back(); 20736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *SDNode = XFormNode->getValueAsDef("Opcode"); 20748dd6f0c8353f80de6526810899f271d539f6929cJakob Stoklund Olesen std::string Code = XFormNode->getValueAsString("XFormFunction"); 2075443e3f9dd61b8d0974bb13d484195ce1a9b7536cChris Lattner SDNodeXForms.insert(std::make_pair(XFormNode, NodeXForm(SDNode, Code))); 20766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Xforms.pop_back(); 20786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2081fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseComplexPatterns() { 20826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> AMs = Records.getAllDerivedDefinitions("ComplexPattern"); 20836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!AMs.empty()) { 20846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ComplexPatterns.insert(std::make_pair(AMs.back(), AMs.back())); 20856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AMs.pop_back(); 20866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParsePatternFragments - Parse all of the PatFrag definitions in the .td 20916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// file, building up the PatternFragments map. After we've collected them all, 20926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// inline fragments together as necessary, so that there are no references left 20936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// inside a pattern fragment to a pattern fragment. 20946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 2095fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParsePatternFragments() { 20966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Fragments = Records.getAllDerivedDefinitions("PatFrag"); 2097fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2098dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // First step, parse all of the fragments. 20996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { 210005bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *Tree = Fragments[i]->getValueAsDag("Fragment"); 21016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this); 21026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternFragments[Fragments[i]] = P; 2103fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2104dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // Validate the argument list, converting it to set, to discard duplicates. 21056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::string> &Args = P->getArgList(); 2106dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner std::set<std::string> OperandsSet(Args.begin(), Args.end()); 2107fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2108dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (OperandsSet.count("")) 21096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Cannot have unnamed 'node' values in pattern fragment!"); 2110fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the operands list. 211205bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *OpsList = Fragments[i]->getValueAsDag("Operands"); 211305bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *OpsOp = dynamic_cast<DefInit*>(OpsList->getOperator()); 21146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Special cases: ops == outs == ins. Different names are used to 2115da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // improve readability. 21166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OpsOp || 21176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner (OpsOp->getDef()->getName() != "ops" && 21186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpsOp->getDef()->getName() != "outs" && 21196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpsOp->getDef()->getName() != "ins")) 21206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should start with '(ops ... '!"); 2121fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2122fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach // Copy over the arguments. 21236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Args.clear(); 21246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) { 212505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (!dynamic_cast<DefInit*>(OpsList->getArg(j)) || 212605bce0beee87512e52428d4b80f5a8e79a949576David Greene static_cast<DefInit*>(OpsList->getArg(j))-> 21276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getDef()->getName() != "node") 21286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should all be 'node' values."); 21296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OpsList->getArgName(j).empty()) 21306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should have names for each operand!"); 2131dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!OperandsSet.count(OpsList->getArgName(j))) 21326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("'" + OpsList->getArgName(j) + 21336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' does not occur in pattern or was multiply specified!"); 2134dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner OperandsSet.erase(OpsList->getArgName(j)); 21356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Args.push_back(OpsList->getArgName(j)); 21366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2137fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2138dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!OperandsSet.empty()) 21396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list does not contain an entry for operand '" + 2140dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner *OperandsSet.begin() + "'!"); 21416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2142dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // If there is a code init for this fragment, keep track of the fact that 2143dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // this fragment uses it. 2144543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner TreePredicateFn PredFn(P); 2145543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (!PredFn.isAlwaysTrue()) 2146543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner P->getOnlyTree()->addPredicateFn(PredFn); 2147fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If there is a node transformation corresponding to this, keep track of 21496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // it. 21506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Transform = Fragments[i]->getValueAsDef("OperandTransform"); 21516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getSDNodeTransform(Transform).second.empty()) // not noop xform? 21526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->getOnlyTree()->setTransformFn(Transform); 21536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2154fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Now that we've parsed all of the tree fragments, do a closure on them so 21566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // that there are not references to PatFrags left inside of them. 21572ca698df93421327a459987b33b045756cb47d4dChris Lattner for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { 21582ca698df93421327a459987b33b045756cb47d4dChris Lattner TreePattern *ThePat = PatternFragments[Fragments[i]]; 21596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ThePat->InlinePatternFragments(); 2160fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. Don't worry about it if we don't infer 21626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // all of them, some may depend on the inputs of the pattern. 21636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner try { 21646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ThePat->InferAllTypes(); 21656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } catch (...) { 21666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this pattern fragment is not supported by this target (no types can 21676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // satisfy its constraints), just ignore it. If the bogus pattern is 21686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // actually used by instructions, the type consistency error will be 21696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // reported there. 21706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2171fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If debugging, print out the pattern fragment result. 21736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DEBUG(ThePat->dump()); 21746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 21756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 21766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2177fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseDefaultOperands() { 21786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> DefaultOps[2]; 21796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOps[0] = Records.getAllDerivedDefinitions("PredicateOperand"); 21806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOps[1] = Records.getAllDerivedDefinitions("OptionalDefOperand"); 21816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find some SDNode. 21836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(!SDNodes.empty() && "No SDNodes parsed?"); 218405bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *SomeSDNode = DefInit::get(SDNodes.begin()->first); 2185fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned iter = 0; iter != 2; ++iter) { 21876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = DefaultOps[iter].size(); i != e; ++i) { 218805bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps"); 2189fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Clone the DefaultInfo dag node, changing the operator from 'ops' to 21916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // SomeSDnode so that we can parse this. 219205bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<Init*, std::string> > Ops; 21936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned op = 0, e = DefaultInfo->getNumArgs(); op != e; ++op) 21946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Ops.push_back(std::make_pair(DefaultInfo->getArg(op), 21956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultInfo->getArgName(op))); 219605bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *DI = DagInit::get(SomeSDNode, "", Ops); 2197fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create a TreePattern to parse this. 21996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern P(DefaultOps[iter][i], DI, false, *this); 22006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(P.getNumTrees() == 1 && "This ctor can only produce one tree!"); 22016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy the operands over into a DAGDefaultOperand. 22036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGDefaultOperand DefaultOpInfo; 2204fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 22056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *T = P.getTree(0); 22066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned op = 0, e = T->getNumChildren(); op != e; ++op) { 22076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *TPN = T->getChild(op); 22086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (TPN->ApplyTypeConstraints(P, false)) 22096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner /* Resolve all types */; 2210fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2211ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov if (TPN->ContainsUnresolvedType()) { 22126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (iter == 0) 22136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner throw "Value #" + utostr(i) + " of PredicateOperand '" + 221453d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner DefaultOps[iter][i]->getName() +"' doesn't have a concrete type!"; 22156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 22166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner throw "Value #" + utostr(i) + " of OptionalDefOperand '" + 221753d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner DefaultOps[iter][i]->getName() +"' doesn't have a concrete type!"; 2218ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov } 22196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOpInfo.DefaultOps.push_back(TPN); 22206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Insert it into the DefaultOperands map so we can find it later. 22236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOperands[DefaultOps[iter][i]] = DefaultOpInfo; 22246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 22276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// HandleUse - Given "Pat" a leaf in the pattern, check to see if it is an 22296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// instruction input. Return true if this is a real use. 22306cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic bool HandleUse(TreePattern *I, TreePatternNode *Pat, 2231acfb70f75061975deda1deb167da8e83249f92edChris Lattner std::map<std::string, TreePatternNode*> &InstInputs) { 22326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // No name -> not interesting. 22336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getName().empty()) { 22346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 223505bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); 2236bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || 2237bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson DI->getDef()->isSubClassOf("RegisterOperand"))) 22386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Input " + DI->getDef()->getName() + " must be named!"); 22396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 22416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Rec; 22446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 224505bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); 22466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!"); 22476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Rec = DI->getDef(); 22486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 22496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Rec = Pat->getOperator(); 22506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // SRCVALUE nodes are ignored. 22536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Rec->getName() == "srcvalue") 22546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 22556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *&Slot = InstInputs[Pat->getName()]; 22576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Slot) { 22586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Slot = Pat; 225953d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner return true; 226053d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner } 226153d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner Record *SlotRec; 226253d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner if (Slot->isLeaf()) { 226305bce0beee87512e52428d4b80f5a8e79a949576David Greene SlotRec = dynamic_cast<DefInit*>(Slot->getLeafValue())->getDef(); 22646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 226553d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner assert(Slot->getNumChildren() == 0 && "can't be a use with children!"); 226653d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner SlotRec = Slot->getOperator(); 22676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2268fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 226953d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner // Ensure that the inputs agree if we've already seen this input. 227053d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner if (Rec != SlotRec) 227153d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner I->error("All $" + Pat->getName() + " inputs must agree with each other"); 2272d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Slot->getExtTypes() != Pat->getExtTypes()) 227353d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner I->error("All $" + Pat->getName() + " inputs must agree with each other"); 22746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 22756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 22766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// FindPatternInputsAndOutputs - Scan the specified TreePatternNode (which is 22786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// part of "I", the instruction), computing the set of inputs and outputs of 22796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// the pattern. Report errors if we see anything naughty. 2280fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns:: 22816cefb77a7073057fecd721ae141140d75ce76512Chris LattnerFindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat, 22826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> &InstInputs, 22836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*>&InstResults, 22846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> &InstImpResults) { 22856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 2286acfb70f75061975deda1deb167da8e83249f92edChris Lattner bool isUse = HandleUse(I, Pat, InstInputs); 22876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isUse && Pat->getTransformFn()) 22886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function for a non-input value!"); 22896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 229084aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 2291fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 229284aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner if (Pat->getOperator()->getName() == "implicit") { 22936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { 22946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Dest = Pat->getChild(i); 22956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dest->isLeaf()) 22966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("implicitly defined value should be a register!"); 2297fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 229805bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); 22996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Val || !Val->getDef()->isSubClassOf("Register")) 23006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("implicitly defined value should be a register!"); 23016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpResults.push_back(Val->getDef()); 23026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 230484aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 2305fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 230684aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner if (Pat->getOperator()->getName() != "set") { 23076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is not a set, verify that the children nodes are not void typed, 23086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // and recurse. 23096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { 2310d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Pat->getChild(i)->getNumTypes() == 0) 23116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot have void nodes inside of patterns!"); 23126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat->getChild(i), InstInputs, InstResults, 2313acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstImpResults); 23146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2315fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 23166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is a non-leaf node with no children, treat it basically as if 23176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // it were a leaf. This handles nodes like (imm). 2318acfb70f75061975deda1deb167da8e83249f92edChris Lattner bool isUse = HandleUse(I, Pat, InstInputs); 2319fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 23206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isUse && Pat->getTransformFn()) 23216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function for a non-input value!"); 23226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 232384aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 2324fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 23256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, this is a set, validate and collect instruction results. 23266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getNumChildren() == 0) 23276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set requires operands!"); 2328fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 23296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getTransformFn()) 23306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function on a set node!"); 2331fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 23326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check the set destinations. 23336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NumDests = Pat->getNumChildren()-1; 23346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i != NumDests; ++i) { 23356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Dest = Pat->getChild(i); 23366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dest->isLeaf()) 23376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 2338fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 233905bce0beee87512e52428d4b80f5a8e79a949576David Greene DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); 23406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Val) 23416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 23426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Val->getDef()->isSubClassOf("RegisterClass") || 2344bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Val->getDef()->isSubClassOf("RegisterOperand") || 2345a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner Val->getDef()->isSubClassOf("PointerLikeRegClass")) { 23466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Dest->getName().empty()) 23476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination must have a name!"); 23486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InstResults.count(Dest->getName())) 23496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("cannot set '" + Dest->getName() +"' multiple times"); 23506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstResults[Dest->getName()] = Dest; 23516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (Val->getDef()->isSubClassOf("Register")) { 23526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpResults.push_back(Val->getDef()); 23536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 23546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 23556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2357fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 23586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify and collect info from the computation. 23596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat->getChild(NumDests), 2360acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstInputs, InstResults, InstImpResults); 23616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 23626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2363ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman//===----------------------------------------------------------------------===// 2364ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman// Instruction Analysis 2365ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman//===----------------------------------------------------------------------===// 2366ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2367ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanclass InstAnalyzer { 2368ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP; 2369ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &mayStore; 2370ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &mayLoad; 23710f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng bool &IsBitcast; 2372ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &HasSideEffects; 23731e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool &IsVariadic; 2374ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanpublic: 2375ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstAnalyzer(const CodeGenDAGPatterns &cdp, 23760f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng bool &maystore, bool &mayload, bool &isbc, bool &hse, bool &isv) 23770f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng : CDP(cdp), mayStore(maystore), mayLoad(mayload), IsBitcast(isbc), 23780f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng HasSideEffects(hse), IsVariadic(isv) { 2379ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2380ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2381ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman /// Analyze - Analyze the specified instruction, returning true if the 2382ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman /// instruction had a pattern. 2383ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool Analyze(Record *InstRecord) { 2384ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const TreePattern *Pattern = CDP.getInstruction(InstRecord).getPattern(); 2385ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Pattern == 0) { 2386ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = 1; 2387ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return false; // No pattern. 2388ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2389ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2390ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // FIXME: Assume only the first tree is the pattern. The others are clobber 2391ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // nodes. 2392ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman AnalyzeNode(Pattern->getTree(0)); 2393ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return true; 2394ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2395ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2396ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanprivate: 23970f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng bool IsNodeBitcast(const TreePatternNode *N) const { 23980f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (HasSideEffects || mayLoad || mayStore || IsVariadic) 23990f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 24000f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 24010f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (N->getNumChildren() != 2) 24020f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 24030f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 24040f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng const TreePatternNode *N0 = N->getChild(0); 240505bce0beee87512e52428d4b80f5a8e79a949576David Greene if (!N0->isLeaf() || !dynamic_cast<DefInit*>(N0->getLeafValue())) 24060f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 24070f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 24080f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng const TreePatternNode *N1 = N->getChild(1); 24090f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (N1->isLeaf()) 24100f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 24110f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (N1->getNumChildren() != 1 || !N1->getChild(0)->isLeaf()) 24120f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 24130f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 24140f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng const SDNodeInfo &OpInfo = CDP.getSDNodeInfo(N1->getOperator()); 24150f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (OpInfo.getNumResults() != 1 || OpInfo.getNumOperands() != 1) 24160f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 24170f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return OpInfo.getEnumName() == "ISD::BITCAST"; 24180f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng } 24190f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 2420ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman void AnalyzeNode(const TreePatternNode *N) { 2421ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (N->isLeaf()) { 242205bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) { 2423ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Record *LeafRec = DI->getDef(); 2424ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Handle ComplexPattern leaves. 2425ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (LeafRec->isSubClassOf("ComplexPattern")) { 2426ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const ComplexPattern &CP = CDP.getComplexPattern(LeafRec); 2427ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPMayStore)) mayStore = true; 2428ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPMayLoad)) mayLoad = true; 2429ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPSideEffect)) HasSideEffects = true; 2430ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2431ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2432ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return; 2433ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2434ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2435ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Analyze children. 2436ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 2437ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman AnalyzeNode(N->getChild(i)); 2438ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2439ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Ignore set nodes, which are not SDNodes. 24400f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (N->getOperator()->getName() == "set") { 24410f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng IsBitcast = IsNodeBitcast(N); 2442ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return; 24430f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng } 2444ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2445ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Get information about the SDNode for the operator. 2446ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const SDNodeInfo &OpInfo = CDP.getSDNodeInfo(N->getOperator()); 2447ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2448ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Notice properties of the node. 2449ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPMayStore)) mayStore = true; 2450ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPMayLoad)) mayLoad = true; 2451ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPSideEffect)) HasSideEffects = true; 24521e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner if (OpInfo.hasProperty(SDNPVariadic)) IsVariadic = true; 2453ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2454ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (const CodeGenIntrinsic *IntInfo = N->getIntrinsicInfo(CDP)) { 2455ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If this is an intrinsic, analyze it. 2456ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadArgMem) 2457ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman mayLoad = true;// These may load memory. 2458ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 24597365c091f92db5e68c98d7faedc6c34e1bbbc898Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadWriteArgMem) 2460ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman mayStore = true;// Intrinsics that can write to memory are 'mayStore'. 2461ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 24627365c091f92db5e68c98d7faedc6c34e1bbbc898Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadWriteMem) 2463ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // WriteMem intrinsics can have other strange effects. 2464ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = true; 2465ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2466ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2467ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2468ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman}; 2469ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2470ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanstatic void InferFromPattern(const CodeGenInstruction &Inst, 2471ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &MayStore, bool &MayLoad, 24720f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng bool &IsBitcast, 24731e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool &HasSideEffects, bool &IsVariadic, 2474ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP) { 24750f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng MayStore = MayLoad = IsBitcast = HasSideEffects = IsVariadic = false; 2476ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2477ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool HadPattern = 24780f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng InstAnalyzer(CDP, MayStore, MayLoad, IsBitcast, HasSideEffects, IsVariadic) 24791e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner .Analyze(Inst.TheDef); 2480ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2481ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // InstAnalyzer only correctly analyzes mayStore/mayLoad so far. 2482ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.mayStore) { // If the .td file explicitly sets mayStore, use it. 2483ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If we decided that this is a store from the pattern, then the .td file 2484ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // entry is redundant. 2485ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (MayStore) 2486ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, 2487ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "Warning: mayStore flag explicitly set on instruction '%s'" 2488ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman " but flag already inferred from pattern.\n", 2489ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Inst.TheDef->getName().c_str()); 2490ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman MayStore = true; 2491ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2492ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2493ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.mayLoad) { // If the .td file explicitly sets mayLoad, use it. 2494ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If we decided that this is a load from the pattern, then the .td file 2495ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // entry is redundant. 2496ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (MayLoad) 2497ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, 2498ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "Warning: mayLoad flag explicitly set on instruction '%s'" 2499ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman " but flag already inferred from pattern.\n", 2500ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Inst.TheDef->getName().c_str()); 2501ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman MayLoad = true; 2502ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2503ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2504ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.neverHasSideEffects) { 2505ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (HadPattern) 2506ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, "Warning: neverHasSideEffects set on instruction '%s' " 2507ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "which already has a pattern\n", Inst.TheDef->getName().c_str()); 2508ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = false; 2509ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2510ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2511ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.hasSideEffects) { 2512ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (HasSideEffects) 2513ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, "Warning: hasSideEffects set on instruction '%s' " 2514ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "which already inferred this.\n", Inst.TheDef->getName().c_str()); 2515ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = true; 2516ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2517fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2518c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (Inst.Operands.isVariadic) 25191e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner IsVariadic = true; // Can warn if we want. 2520ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman} 2521ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 25226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParseInstructions - Parse all of the instructions, inlining and resolving 25236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// any fragments involved. This populates the Instructions list with fully 25246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// resolved instructions. 2525fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseInstructions() { 25266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction"); 2527fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 25286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Instrs.size(); i != e; ++i) { 252905bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LI = 0; 2530fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 253105bce0beee87512e52428d4b80f5a8e79a949576David Greene if (dynamic_cast<ListInit*>(Instrs[i]->getValueInit("Pattern"))) 25326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner LI = Instrs[i]->getValueAsListInit("Pattern"); 2533fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 25346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If there is no pattern, only collect minimal information about the 25356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // instruction for its operand list. We have to assume that there is one 25366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // result, as we have no detailed info. 25376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!LI || LI->getSize() == 0) { 25386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Results; 25396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Operands; 2540fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2541f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CodeGenInstruction &InstInfo = Target.getInstruction(Instrs[i]); 25426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2543c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (InstInfo.Operands.size() != 0) { 2544c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (InstInfo.Operands.NumDefs == 0) { 25456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // These produce no results 2546c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner for (unsigned j = 0, e = InstInfo.Operands.size(); j < e; ++j) 2547c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Operands.push_back(InstInfo.Operands[j].Rec); 25486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 25496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Assume the first operand is the result. 2550c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Results.push_back(InstInfo.Operands[0].Rec); 2551fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 25526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The rest are inputs. 2553c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner for (unsigned j = 1, e = InstInfo.Operands.size(); j < e; ++j) 2554c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Operands.push_back(InstInfo.Operands[j].Rec); 25556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 25566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2557fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 25586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create and insert the instruction. 25596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> ImpResults; 2560fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach Instructions.insert(std::make_pair(Instrs[i], 256162bcec82b2762d5cdc84fe39c7d634c784ed6673Chris Lattner DAGInstruction(0, Results, Operands, ImpResults))); 25626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; // no pattern. 25636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2564fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 25656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the instruction. 25666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *I = new TreePattern(Instrs[i], LI, true, *this); 25676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 25686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->InlinePatternFragments(); 2569fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 25706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we can 25716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // never do anything with this instruction pattern: report it to the user. 25726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!I->InferAllTypes()) 25736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Could not infer all types in pattern!"); 2574fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2575fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach // InstInputs - Keep track of all of the inputs of the instruction, along 25766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // with the record they are declared as. 25776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputs; 2578fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 25796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // InstResults - Keep track of all the virtual registers that are 'set' 25806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // in the instruction, including what reg class they are. 25816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstResults; 25826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpResults; 2584fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 25856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that the top-level forms in the instruction are of void type, and 25866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // fill in the InstResults map. 25876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = I->getNumTrees(); j != e; ++j) { 25886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Pat = I->getTree(j); 2589d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Pat->getNumTypes() != 0) 25906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Top-level forms in instruction pattern should have" 25916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " void types"); 25926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find inputs and outputs, and verify the structure of the uses/defs. 25946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat, InstInputs, InstResults, 2595acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstImpResults); 25966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 25976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Now that we have inputs and outputs of the pattern, inspect the operands 25996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // list for the instruction. This determines the order that operands are 26006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // added to the machine instruction the node corresponds to. 26016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NumResults = InstResults.size(); 26026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the operands list from the (ops) list, validating it. 26046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(I->getArgList().empty() && "Args list should still be empty here!"); 2605f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CodeGenInstruction &CGI = Target.getInstruction(Instrs[i]); 26066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check that all of the results occur first in the list. 26086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Results; 2609d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Res0Node = 0; 26106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i != NumResults; ++i) { 2611c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (i == CGI.Operands.size()) 26126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("'" + InstResults.begin()->first + 26136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' set but does not appear in operand list!"); 2614c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner const std::string &OpName = CGI.Operands[i].Name; 2615fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check that it exists in InstResults. 26176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *RNode = InstResults[OpName]; 26186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (RNode == 0) 26196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " does not exist in operand list!"); 2620fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (i == 0) 26226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Res0Node = RNode; 262305bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *R = dynamic_cast<DefInit*>(RNode->getLeafValue())->getDef(); 26246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R == 0) 26256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " should be a set destination: all " 26266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "outputs must occur before inputs in operand list!"); 2627fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2628c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (CGI.Operands[i].Rec != R) 26296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " class mismatch!"); 2630fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Remember the return type. 2632c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Results.push_back(CGI.Operands[i].Rec); 2633fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Okay, this one checks out. 26356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstResults.erase(OpName); 26366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 26376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Loop over the inputs next. Make a copy of InstInputs so we can destroy 26396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // the copy while we're checking the inputs. 26406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputsCheck(InstInputs); 26416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ResultNodeOperands; 26436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Operands; 2644c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner for (unsigned i = NumResults, e = CGI.Operands.size(); i != e; ++i) { 2645c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner CGIOperandList::OperandInfo &Op = CGI.Operands[i]; 26466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::string &OpName = Op.Name; 26476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OpName.empty()) 26486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand #" + utostr(i) + " in operands list has no name!"); 26496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InstInputsCheck.count(OpName)) { 26516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is an predicate operand or optional def operand with an 26526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // DefaultOps set filled in, we can ignore this. When we codegen it, 26536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // we will do so as always executed. 26546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Op.Rec->isSubClassOf("PredicateOperand") || 26556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Op.Rec->isSubClassOf("OptionalDefOperand")) { 26566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Does it have a non-empty DefaultOps field? If so, ignore this 26576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // operand. 26586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getDefaultOperand(Op.Rec).DefaultOps.empty()) 26596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 26606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 26616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + 26626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " does not appear in the instruction pattern"); 26636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 26646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *InVal = InstInputsCheck[OpName]; 26656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstInputsCheck.erase(OpName); // It occurred, remove from map. 2666fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InVal->isLeaf() && 266805bce0beee87512e52428d4b80f5a8e79a949576David Greene dynamic_cast<DefInit*>(InVal->getLeafValue())) { 266905bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef(); 26706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Op.Rec != InRec && !InRec->isSubClassOf("ComplexPattern")) 26716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + "'s register class disagrees" 26726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " between the operand and pattern"); 26736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 26746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operands.push_back(Op.Rec); 2675fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Construct the result for the dest-pattern operand list. 26776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OpNode = InVal->clone(); 2678fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // No predicate is useful on the result. 26800540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman OpNode->clearPredicateFns(); 2681fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Promote the xform function to be an explicit node if set. 26836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Record *Xform = OpNode->getTransformFn()) { 26846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpNode->setTransformFn(0); 26856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 26866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(OpNode); 2687d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); 26886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2689fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ResultNodeOperands.push_back(OpNode); 26916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2692fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InstInputsCheck.empty()) 26946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Input operand $" + InstInputsCheck.begin()->first + 26956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " occurs in pattern but not in operands list!"); 26966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *ResultPattern = 2698d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner new TreePatternNode(I->getRecord(), ResultNodeOperands, 2699d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner GetNumNodeResults(I->getRecord(), *this)); 27006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy fully inferred output node type to instruction result pattern. 2701d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0; i != NumResults; ++i) 2702d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ResultPattern->setType(i, Res0Node->getExtType(i)); 27036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create and insert the instruction. 2705acfb70f75061975deda1deb167da8e83249f92edChris Lattner // FIXME: InstImpResults should not be part of DAGInstruction. 270662bcec82b2762d5cdc84fe39c7d634c784ed6673Chris Lattner DAGInstruction TheInst(I, Results, Operands, InstImpResults); 27076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Instructions.insert(std::make_pair(I->getRecord(), TheInst)); 27086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Use a temporary tree pattern to infer all types and make sure that the 27106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // constructed result is correct. This depends on the instruction already 27116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // being inserted into the Instructions map. 27126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern Temp(I->getRecord(), ResultPattern, false, *this); 27132cacec55f947c716b058a39038889550d7e39b3cChris Lattner Temp.InferAllTypes(&I->getNamedNodesMap()); 27146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction &TheInsertedInst = Instructions.find(I->getRecord())->second; 27166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TheInsertedInst.setResultPattern(Temp.getOnlyTree()); 2717fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DEBUG(I->dump()); 27196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2720fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If we can, convert the instructions to be patterns that are matched! 27225b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer for (std::map<Record*, DAGInstruction, RecordPtrCmp>::iterator II = 27235b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer Instructions.begin(), 27246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner E = Instructions.end(); II != E; ++II) { 27256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction &TheInst = II->second; 2726f1ab4f18aad3950d0b9ff1273a276bb8d195d2d6Chris Lattner const TreePattern *I = TheInst.getPattern(); 27276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (I == 0) continue; // No pattern. 27286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // FIXME: Assume only the first tree is the pattern. The others are clobber 27306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // nodes. 27316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Pattern = I->getTree(0); 27326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *SrcPattern; 27336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pattern->getOperator()->getName() == "set") { 27346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SrcPattern = Pattern->getChild(Pattern->getNumChildren()-1)->clone(); 27356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else{ 27366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Not a set (store or something?) 27376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SrcPattern = Pattern; 27386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2739fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Instr = II->first; 274125b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner AddPatternToMatch(I, 2742997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach PatternToMatch(Instr, 2743997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach Instr->getValueAsListInit("Predicates"), 2744967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner SrcPattern, 2745967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner TheInst.getResultPattern(), 274625b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner TheInst.getImpResults(), 2747117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Instr->getValueAsInt("AddedComplexity"), 2748117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Instr->getID())); 27496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 27516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27524ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 27534ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattnertypedef std::pair<const TreePatternNode*, unsigned> NameRecord; 27544ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 2755fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbachstatic void FindNames(const TreePatternNode *P, 2756a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner std::map<std::string, NameRecord> &Names, 2757a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner const TreePattern *PatternTop) { 27584ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (!P->getName().empty()) { 27594ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner NameRecord &Rec = Names[P->getName()]; 27604ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // If this is the first instance of the name, remember the node. 27614ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (Rec.second++ == 0) 27624ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner Rec.first = P; 2763d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner else if (Rec.first->getExtTypes() != P->getExtTypes()) 2764a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner PatternTop->error("repetition of value: $" + P->getName() + 2765a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner " where different uses have different types!"); 27664ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner } 2767fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2768967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner if (!P->isLeaf()) { 2769967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) 2770a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(P->getChild(i), Names, PatternTop); 2771967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner } 2772967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner} 2773967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 277425b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattnervoid CodeGenDAGPatterns::AddPatternToMatch(const TreePattern *Pattern, 277525b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner const PatternToMatch &PTM) { 2776967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Do some sanity checking on the pattern we're about to match. 277725b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner std::string Reason; 277825b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner if (!PTM.getSrcPattern()->canPatternMatch(Reason, *this)) 2779967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner Pattern->error("Pattern can never match: " + Reason); 2780fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2781405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner // If the source pattern's root is a complex pattern, that complex pattern 2782405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner // must specify the nodes it can potentially match. 2783405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner if (const ComplexPattern *CP = 2784405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner PTM.getSrcPattern()->getComplexPatternInfo(*this)) 2785405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner if (CP->getRootNodes().empty()) 2786405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner Pattern->error("ComplexPattern at root must specify list of opcodes it" 2787405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner " could match"); 2788fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2789fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2790967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Find all of the named values in the input and output, ensure they have the 2791967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // same type. 27924ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner std::map<std::string, NameRecord> SrcNames, DstNames; 2793a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(PTM.getSrcPattern(), SrcNames, Pattern); 2794a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(PTM.getDstPattern(), DstNames, Pattern); 2795967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 2796967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Scan all of the named values in the destination pattern, rejecting them if 2797967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // they don't exist in the input pattern. 27984ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner for (std::map<std::string, NameRecord>::iterator 2799ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner I = DstNames.begin(), E = DstNames.end(); I != E; ++I) { 28004ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (SrcNames[I->first].first == 0) 2801967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner Pattern->error("Pattern has input without matching name in output: $" + 2802967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner I->first); 2803ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner } 2804fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28054ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // Scan all of the named values in the source pattern, rejecting them if the 28064ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // name isn't used in the dest, and isn't used to tie two values together. 28074ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner for (std::map<std::string, NameRecord>::iterator 28084ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner I = SrcNames.begin(), E = SrcNames.end(); I != E; ++I) 28094ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (DstNames[I->first].first == 0 && SrcNames[I->first].second == 1) 28104ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner Pattern->error("Pattern has dead named input: $" + I->first); 2811fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 281225b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner PatternsToMatch.push_back(PTM); 281325b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner} 281425b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 281525b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 2816ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2817ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanvoid CodeGenDAGPatterns::InferInstructionFlags() { 2818f65027842e82027dd6e8020586a299aaa548e355Chris Lattner const std::vector<const CodeGenInstruction*> &Instructions = 2819f65027842e82027dd6e8020586a299aaa548e355Chris Lattner Target.getInstructionsByEnumValue(); 2820b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner for (unsigned i = 0, e = Instructions.size(); i != e; ++i) { 2821b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner CodeGenInstruction &InstInfo = 2822b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner const_cast<CodeGenInstruction &>(*Instructions[i]); 2823ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Determine properties of the instruction from its pattern. 28240f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng bool MayStore, MayLoad, IsBitcast, HasSideEffects, IsVariadic; 28250f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng InferFromPattern(InstInfo, MayStore, MayLoad, IsBitcast, 28260f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng HasSideEffects, IsVariadic, *this); 2827ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstInfo.mayStore = MayStore; 2828ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstInfo.mayLoad = MayLoad; 28290f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng InstInfo.isBitcast = IsBitcast; 2830ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstInfo.hasSideEffects = HasSideEffects; 2831c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner InstInfo.Operands.isVariadic = IsVariadic; 2832ccbe603869681aa71b4140e3bf4b4459caf60622Jakob Stoklund Olesen 2833ccbe603869681aa71b4140e3bf4b4459caf60622Jakob Stoklund Olesen // Sanity checks. 2834ccbe603869681aa71b4140e3bf4b4459caf60622Jakob Stoklund Olesen if (InstInfo.isReMaterializable && InstInfo.hasSideEffects) 2835ccbe603869681aa71b4140e3bf4b4459caf60622Jakob Stoklund Olesen throw TGError(InstInfo.TheDef->getLoc(), "The instruction " + 2836ccbe603869681aa71b4140e3bf4b4459caf60622Jakob Stoklund Olesen InstInfo.TheDef->getName() + 2837ccbe603869681aa71b4140e3bf4b4459caf60622Jakob Stoklund Olesen " is rematerializable AND has unmodeled side effects?"); 2838ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2839ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman} 2840ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 28412cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// Given a pattern result with an unresolved type, see if we can find one 28422cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// instruction with an unresolved result type. Force this result type to an 28432cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// arbitrary element if it's possible types to converge results. 28442cacec55f947c716b058a39038889550d7e39b3cChris Lattnerstatic bool ForceArbitraryInstResultType(TreePatternNode *N, TreePattern &TP) { 28452cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (N->isLeaf()) 28462cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 2847fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28482cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Analyze children. 28492cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 28502cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (ForceArbitraryInstResultType(N->getChild(i), TP)) 28512cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 28522cacec55f947c716b058a39038889550d7e39b3cChris Lattner 28532cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!N->getOperator()->isSubClassOf("Instruction")) 28542cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 28552cacec55f947c716b058a39038889550d7e39b3cChris Lattner 28562cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this type is already concrete or completely unknown we can't do 28572cacec55f947c716b058a39038889550d7e39b3cChris Lattner // anything. 2858d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = N->getNumTypes(); i != e; ++i) { 2859d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->getExtType(i).isCompletelyUnknown() || N->getExtType(i).isConcrete()) 2860d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner continue; 2861fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2862d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // Otherwise, force its type to the first possibility (an arbitrary choice). 2863d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->getExtType(i).MergeInTypeInfo(N->getExtType(i).getTypeList()[0], TP)) 2864d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return true; 2865d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 2866fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2867d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return false; 28682cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 28692cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2870fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParsePatterns() { 28716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Patterns = Records.getAllDerivedDefinitions("Pattern"); 28726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Patterns.size(); i != e; ++i) { 2874d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Record *CurPattern = Patterns[i]; 287505bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch"); 2876310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this); 28776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 28796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Pattern->InlinePatternFragments(); 2880fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 288105bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs"); 28826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (LI->getSize() == 0) continue; // no pattern. 2883fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the instruction. 2885d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePattern *Result = new TreePattern(CurPattern, LI, false, *this); 2886fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 28886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->InlinePatternFragments(); 28896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Result->getNumTrees() != 1) 28916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->error("Cannot handle instructions producing instructions " 28926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "with temporaries yet!"); 2893fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool IterateInference; 28956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool InferredAllPatternTypes, InferredAllResultTypes; 28966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner do { 28976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we 28986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // can never do anything with this pattern: report it to the user. 28992cacec55f947c716b058a39038889550d7e39b3cChris Lattner InferredAllPatternTypes = 29002cacec55f947c716b058a39038889550d7e39b3cChris Lattner Pattern->InferAllTypes(&Pattern->getNamedNodesMap()); 2901fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 29026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we 29036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // can never do anything with this pattern: report it to the user. 29042cacec55f947c716b058a39038889550d7e39b3cChris Lattner InferredAllResultTypes = 29052cacec55f947c716b058a39038889550d7e39b3cChris Lattner Result->InferAllTypes(&Pattern->getNamedNodesMap()); 29066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29076c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference = false; 2908fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 29096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the type of the result to the source pattern. This helps us 29106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // resolve cases where the input type is known to be a pointer type (which 29116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // is considered resolved), but the result knows it needs to be 32- or 29126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 64-bits. Infer the other way for good measure. 2913d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = std::min(Result->getTree(0)->getNumTypes(), 2914d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Pattern->getTree(0)->getNumTypes()); 2915d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner i != e; ++i) { 29166c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference = Pattern->getTree(0)-> 2917d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner UpdateNodeType(i, Result->getTree(0)->getExtType(i), *Result); 29186c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference |= Result->getTree(0)-> 2919d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner UpdateNodeType(i, Pattern->getTree(0)->getExtType(i), *Result); 29206c6ba364931acb113973ad3e6d69736969c59299Chris Lattner } 2921fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 29222cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If our iteration has converged and the input pattern's types are fully 29232cacec55f947c716b058a39038889550d7e39b3cChris Lattner // resolved but the result pattern is not fully resolved, we may have a 29242cacec55f947c716b058a39038889550d7e39b3cChris Lattner // situation where we have two instructions in the result pattern and 29252cacec55f947c716b058a39038889550d7e39b3cChris Lattner // the instructions require a common register class, but don't care about 29262cacec55f947c716b058a39038889550d7e39b3cChris Lattner // what actual MVT is used. This is actually a bug in our modelling: 29272cacec55f947c716b058a39038889550d7e39b3cChris Lattner // output patterns should have register classes, not MVTs. 29282cacec55f947c716b058a39038889550d7e39b3cChris Lattner // 29292cacec55f947c716b058a39038889550d7e39b3cChris Lattner // In any case, to handle this, we just go through and disambiguate some 29302cacec55f947c716b058a39038889550d7e39b3cChris Lattner // arbitrary types to the result pattern's nodes. 29312cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!IterateInference && InferredAllPatternTypes && 29322cacec55f947c716b058a39038889550d7e39b3cChris Lattner !InferredAllResultTypes) 29332cacec55f947c716b058a39038889550d7e39b3cChris Lattner IterateInference = ForceArbitraryInstResultType(Result->getTree(0), 29342cacec55f947c716b058a39038889550d7e39b3cChris Lattner *Result); 29356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } while (IterateInference); 2936fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 29376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we inferred enough types that we can do something with the 29386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // pattern and result. If these fire the user has to add type casts. 29396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InferredAllPatternTypes) 29406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Pattern->error("Could not infer all types in pattern!"); 29412cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!InferredAllResultTypes) { 29422cacec55f947c716b058a39038889550d7e39b3cChris Lattner Pattern->dump(); 29436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->error("Could not infer all types in pattern result!"); 29442cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 2945fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 29466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Validate that the input pattern is correct. 29476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputs; 29486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstResults; 29496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpResults; 29506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, ee = Pattern->getNumTrees(); j != ee; ++j) 29516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(Pattern, Pattern->getTree(j), 29526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstInputs, InstResults, 2953acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstImpResults); 29546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Promote the xform function to be an explicit node if set. 29566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *DstPattern = Result->getOnlyTree(); 29576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ResultNodeOperands; 29586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned ii = 0, ee = DstPattern->getNumChildren(); ii != ee; ++ii) { 29596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OpNode = DstPattern->getChild(ii); 29606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Record *Xform = OpNode->getTransformFn()) { 29616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpNode->setTransformFn(0); 29626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 29636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(OpNode); 2964d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); 29656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ResultNodeOperands.push_back(OpNode); 29676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DstPattern = Result->getOnlyTree(); 29696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!DstPattern->isLeaf()) 29706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DstPattern = new TreePatternNode(DstPattern->getOperator(), 2971d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ResultNodeOperands, 2972d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DstPattern->getNumTypes()); 2973fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2974d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Result->getOnlyTree()->getNumTypes(); i != e; ++i) 2975d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DstPattern->setType(i, Result->getOnlyTree()->getExtType(i)); 2976fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 29776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern Temp(Result->getRecord(), DstPattern, false, *this); 29786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Temp.InferAllTypes(); 29796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2980fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 298125b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner AddPatternToMatch(Pattern, 2982997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach PatternToMatch(CurPattern, 2983997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach CurPattern->getValueAsListInit("Predicates"), 2984d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Pattern->getTree(0), 2985d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Temp.getOnlyTree(), InstImpResults, 2986d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CurPattern->getValueAsInt("AddedComplexity"), 2987d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CurPattern->getID())); 29886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 29906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// CombineChildVariants - Given a bunch of permutations of each child of the 29926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 'operator' node, put them together in all possible ways. 2993fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbachstatic void CombineChildVariants(TreePatternNode *Orig, 29946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<std::vector<TreePatternNode*> > &ChildVariants, 29956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 2996327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 2997327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 29986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Make sure that each operand has at least one variant to choose from. 29996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i) 30006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (ChildVariants[i].empty()) 30016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 3002fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 30036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The end result is an all-pairs construction of the resultant pattern. 30046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<unsigned> Idxs; 30056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Idxs.resize(ChildVariants.size()); 3006327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel bool NotDone; 3007327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel do { 3008327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel#ifndef NDEBUG 3009aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner DEBUG(if (!Idxs.empty()) { 3010aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << Orig->getOperator()->getName() << ": Idxs = [ "; 3011aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner for (unsigned i = 0; i < Idxs.size(); ++i) { 3012aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << Idxs[i] << " "; 3013aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner } 3014aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << "]\n"; 3015aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner }); 3016327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel#endif 30176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create the variant and add it to the output list. 30186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> NewChildren; 30196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i) 30206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NewChildren.push_back(ChildVariants[i][Idxs[i]]); 3021d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *R = new TreePatternNode(Orig->getOperator(), NewChildren, 3022d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Orig->getNumTypes()); 3023fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 30246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy over properties. 30256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->setName(Orig->getName()); 30260540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman R->setPredicateFns(Orig->getPredicateFns()); 30276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->setTransformFn(Orig->getTransformFn()); 3028d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Orig->getNumTypes(); i != e; ++i) 3029d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner R->setType(i, Orig->getExtType(i)); 3030fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3031327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // If this pattern cannot match, do not include it as a variant. 30326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::string ErrString; 30336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!R->canPatternMatch(ErrString, CDP)) { 30346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete R; 30356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 30366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool AlreadyExists = false; 3037fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 30386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan to see if this pattern has already been emitted. We can get 30396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // duplication due to things like commuting: 30406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (and GPRC:$a, GPRC:$b) -> (and GPRC:$b, GPRC:$a) 30416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // which are the same pattern. Ignore the dups. 30426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = OutVariants.size(); i != e; ++i) 3043327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (R->isIsomorphicTo(OutVariants[i], DepVars)) { 30446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AlreadyExists = true; 30456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 30466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 3047fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 30486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (AlreadyExists) 30496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete R; 30506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 30516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OutVariants.push_back(R); 30526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 3053fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3054327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // Increment indices to the next permutation by incrementing the 3055327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // indicies from last index backward, e.g., generate the sequence 3056327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // [0, 0], [0, 1], [1, 0], [1, 1]. 3057327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel int IdxsIdx; 3058327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (IdxsIdx = Idxs.size() - 1; IdxsIdx >= 0; --IdxsIdx) { 3059327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (++Idxs[IdxsIdx] == ChildVariants[IdxsIdx].size()) 3060327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel Idxs[IdxsIdx] = 0; 3061327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel else 30626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 30636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 3064327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel NotDone = (IdxsIdx >= 0); 3065327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } while (NotDone); 30666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 30676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 30686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// CombineChildVariants - A helper function for binary operators. 30696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 3070fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbachstatic void CombineChildVariants(TreePatternNode *Orig, 30716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<TreePatternNode*> &LHS, 30726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<TreePatternNode*> &RHS, 30736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 3074327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 3075327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 30766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::vector<TreePatternNode*> > ChildVariants; 30776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.push_back(LHS); 30786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.push_back(RHS); 3079327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(Orig, ChildVariants, OutVariants, CDP, DepVars); 3080fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach} 30816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 30826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 30836cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void GatherChildrenOfAssociativeOpcode(TreePatternNode *N, 30846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode *> &Children) { 30856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(N->getNumChildren()==2 &&"Associative but doesn't have 2 children!"); 30866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Operator = N->getOperator(); 3087fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 30886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Only permit raw nodes. 30890540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman if (!N->getName().empty() || !N->getPredicateFns().empty() || 30906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->getTransformFn()) { 30916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N); 30926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 30936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 30946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 30956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getChild(0)->isLeaf() || N->getChild(0)->getOperator() != Operator) 30966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N->getChild(0)); 30976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 30986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N->getChild(0), Children); 30996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getChild(1)->isLeaf() || N->getChild(1)->getOperator() != Operator) 31016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N->getChild(1)); 31026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 31036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N->getChild(1), Children); 31046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 31056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// GenerateVariantsOf - Given a pattern N, generate all permutations we can of 31076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// the (potentially recursive) pattern by using algebraic laws. 31086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 31096cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void GenerateVariantsOf(TreePatternNode *N, 31106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 3111327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 3112327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 31136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // We cannot permute leaves. 31146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->isLeaf()) { 31156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OutVariants.push_back(N); 31166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 31176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 31186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Look up interesting info about the node. 31206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(N->getOperator()); 31216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3122da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // If this node is associative, re-associate. 31236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NodeInfo.hasProperty(SDNPAssociative)) { 3124fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach // Re-associate by pulling together all of the linked operators 31256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> MaximalChildren; 31266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N, MaximalChildren); 31276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Only handle child sizes of 3. Otherwise we'll end up trying too many 31296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // permutations. 31306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (MaximalChildren.size() == 3) { 31316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find the variants of all of our maximal children. 31326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> AVariants, BVariants, CVariants; 3133327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[0], AVariants, CDP, DepVars); 3134327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[1], BVariants, CDP, DepVars); 3135327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[2], CVariants, CDP, DepVars); 3136fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 31376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // There are only two ways we can permute the tree: 31386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (A op B) op C and A op (B op C) 31396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Within these forms, we can also permute A/B/C. 3140fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 31416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Generate legal pair permutations of A/B/C. 31426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ABVariants; 31436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> BAVariants; 31446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ACVariants; 31456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CAVariants; 31466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> BCVariants; 31476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CBVariants; 3148327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, BVariants, ABVariants, CDP, DepVars); 3149327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, AVariants, BAVariants, CDP, DepVars); 3150327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, CVariants, ACVariants, CDP, DepVars); 3151327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, AVariants, CAVariants, CDP, DepVars); 3152327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, CVariants, BCVariants, CDP, DepVars); 3153327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, BVariants, CBVariants, CDP, DepVars); 31546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Combine those into the result: (x op x) op x 3156327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ABVariants, CVariants, OutVariants, CDP, DepVars); 3157327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BAVariants, CVariants, OutVariants, CDP, DepVars); 3158327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ACVariants, BVariants, OutVariants, CDP, DepVars); 3159327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CAVariants, BVariants, OutVariants, CDP, DepVars); 3160327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BCVariants, AVariants, OutVariants, CDP, DepVars); 3161327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CBVariants, AVariants, OutVariants, CDP, DepVars); 31626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Combine those into the result: x op (x op x) 3164327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, ABVariants, OutVariants, CDP, DepVars); 3165327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, BAVariants, OutVariants, CDP, DepVars); 3166327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, ACVariants, OutVariants, CDP, DepVars); 3167327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, CAVariants, OutVariants, CDP, DepVars); 3168327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, BCVariants, OutVariants, CDP, DepVars); 3169327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, CBVariants, OutVariants, CDP, DepVars); 31706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 31716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 31726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 3173fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 31746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Compute permutations of all children. 31756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::vector<TreePatternNode*> > ChildVariants; 31766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.resize(N->getNumChildren()); 31776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 3178327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(N->getChild(i), ChildVariants[i], CDP, DepVars); 31796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Build all permutations based on how the children were formed. 3181327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ChildVariants, OutVariants, CDP, DepVars); 31826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this node is commutative, consider the commuted order. 31846bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool isCommIntrinsic = N->isCommutativeIntrinsic(CDP); 31856bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { 31866bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng assert((N->getNumChildren()==2 || isCommIntrinsic) && 31876bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng "Commutative but doesn't have 2 children!"); 31886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Don't count children which are actually register references. 31896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NC = 0; 31906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { 31916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = N->getChild(i); 31926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Child->isLeaf()) 319305bce0beee87512e52428d4b80f5a8e79a949576David Greene if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) { 31946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *RR = DI->getDef(); 31956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (RR->isSubClassOf("Register")) 31966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 31976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 31986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NC++; 31996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 32006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Consider the commuted order. 32016bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (isCommIntrinsic) { 32026bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // Commutative intrinsic. First operand is the intrinsic id, 2nd and 3rd 32036bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // operands are the commutative operands, and there might be more operands 32046bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // after those. 32056bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng assert(NC >= 3 && 32066bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng "Commutative intrinsic should have at least 3 childrean!"); 32076bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng std::vector<std::vector<TreePatternNode*> > Variants; 32086bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[0]); // Intrinsic id. 32096bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[2]); 32106bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[1]); 32116bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng for (unsigned i = 3; i != NC; ++i) 32126bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[i]); 32136bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng CombineChildVariants(N, Variants, OutVariants, CDP, DepVars); 32146bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng } else if (NC == 2) 32156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CombineChildVariants(N, ChildVariants[1], ChildVariants[0], 3216327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel OutVariants, CDP, DepVars); 32176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 32186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 32196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// GenerateVariants - Generate variants. For example, commutative patterns can 32226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// match multiple ways. Add them to PatternsToMatch as well. 3223fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::GenerateVariants() { 3224569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "Generating instruction variants.\n"); 3225fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 32266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Loop over all of the patterns we've collected, checking to see if we can 32276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // generate variants of the instruction, through the exploitation of 3228da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // identities. This permits the target to provide aggressive matching without 32296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // the .td file having to contain tons of variants of instructions. 32306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 32316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Note that this loop adds new patterns to the PatternsToMatch list, but we 32326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // intentionally do not reconsider these. Any variants of added patterns have 32336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // already been added. 32346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 32356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = PatternsToMatch.size(); i != e; ++i) { 3236327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel MultipleUseVarSet DepVars; 32376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Variants; 3238327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVars(PatternsToMatch[i].getSrcPattern(), DepVars); 3239569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "Dependent/multiply used variables: "); 3240327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DEBUG(DumpDepVars(DepVars)); 3241569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "\n"); 3242bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach GenerateVariantsOf(PatternsToMatch[i].getSrcPattern(), Variants, *this, 3243bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach DepVars); 32446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(!Variants.empty() && "Must create at least original variant!"); 32466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Variants.erase(Variants.begin()); // Remove the original pattern. 32476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Variants.empty()) // No variants for this pattern. 32496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 32506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3251569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "FOUND VARIANTS OF: "; 3252569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner PatternsToMatch[i].getSrcPattern()->dump(); 3253569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner errs() << "\n"); 32546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned v = 0, e = Variants.size(); v != e; ++v) { 32566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Variant = Variants[v]; 32576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3258569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << " VAR#" << v << ": "; 3259569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner Variant->dump(); 3260569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner errs() << "\n"); 3261fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 32626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan to see if an instruction or explicit pattern already matches this. 32636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool AlreadyExists = false; 32646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned p = 0, e = PatternsToMatch.size(); p != e; ++p) { 3265c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng // Skip if the top level predicates do not match. 3266c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng if (PatternsToMatch[i].getPredicates() != 3267c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng PatternsToMatch[p].getPredicates()) 3268c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng continue; 32696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check to see if this variant already exists. 3270bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach if (Variant->isIsomorphicTo(PatternsToMatch[p].getSrcPattern(), 3271bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach DepVars)) { 3272569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << " *** ALREADY EXISTS, ignoring variant.\n"); 32736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AlreadyExists = true; 32746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 32756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 32766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 32776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If we already have it, ignore the variant. 32786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (AlreadyExists) continue; 32796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, add it to the list of patterns we have. 32816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternsToMatch. 3282997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach push_back(PatternToMatch(PatternsToMatch[i].getSrcRecord(), 3283997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach PatternsToMatch[i].getPredicates(), 32846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Variant, PatternsToMatch[i].getDstPattern(), 32856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternsToMatch[i].getDstRegs(), 3286117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner PatternsToMatch[i].getAddedComplexity(), 3287117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Record::getNewUID())); 32886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 32896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3290569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "\n"); 32916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 32926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 32936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3294