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" 162cacec55f947c716b058a39038889550d7e39b3cChris Lattner#include "llvm/ADT/STLExtras.h" 174ffd89fa4d2788611187d1a534d2ed46adf1702cChandler Carruth#include "llvm/ADT/StringExtras.h" 189b29ea4eb39b5f03ef2405c6355a9c627771c5ddJim Grosbach#include "llvm/ADT/Twine.h" 196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#include "llvm/Support/Debug.h" 20fdebc38523b397743973ff6a2d2e93b112dd96e5David Blaikie#include "llvm/Support/ErrorHandling.h" 214ffd89fa4d2788611187d1a534d2ed46adf1702cChandler Carruth#include "llvm/TableGen/Error.h" 224ffd89fa4d2788611187d1a534d2ed46adf1702cChandler Carruth#include "llvm/TableGen/Record.h" 239a79de3d091978cfee5264ee2563fc5dedd33cb7Chuck Rose III#include <algorithm> 24901b85888c2de6bf982c47ab69b7e83908b6a216Benjamin Kramer#include <cstdio> 25901b85888c2de6bf982c47ab69b7e83908b6a216Benjamin Kramer#include <set> 266cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerusing namespace llvm; 276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 292cacec55f947c716b058a39038889550d7e39b3cChris Lattner// EEVT::TypeSet Implementation 302cacec55f947c716b058a39038889550d7e39b3cChris Lattner//===----------------------------------------------------------------------===// 316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonstatic inline bool isInteger(MVT::SimpleValueType VT) { 33e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson return EVT(VT).isInteger(); 3483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands} 35825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonstatic inline bool isFloatingPoint(MVT::SimpleValueType VT) { 36e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson return EVT(VT).isFloatingPoint(); 3783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands} 38825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonstatic inline bool isVector(MVT::SimpleValueType VT) { 39e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson return EVT(VT).isVector(); 4083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands} 41774ce29399364823dba62217ebf7bc8701005140Chris Lattnerstatic inline bool isScalar(MVT::SimpleValueType VT) { 42774ce29399364823dba62217ebf7bc8701005140Chris Lattner return !EVT(VT).isVector(); 43774ce29399364823dba62217ebf7bc8701005140Chris Lattner} 4483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands 452cacec55f947c716b058a39038889550d7e39b3cChris LattnerEEVT::TypeSet::TypeSet(MVT::SimpleValueType VT, TreePattern &TP) { 462cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VT == MVT::iAny) 472cacec55f947c716b058a39038889550d7e39b3cChris Lattner EnforceInteger(TP); 482cacec55f947c716b058a39038889550d7e39b3cChris Lattner else if (VT == MVT::fAny) 492cacec55f947c716b058a39038889550d7e39b3cChris Lattner EnforceFloatingPoint(TP); 502cacec55f947c716b058a39038889550d7e39b3cChris Lattner else if (VT == MVT::vAny) 512cacec55f947c716b058a39038889550d7e39b3cChris Lattner EnforceVector(TP); 522cacec55f947c716b058a39038889550d7e39b3cChris Lattner else { 532cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert((VT < MVT::LAST_VALUETYPE || VT == MVT::iPTR || 542cacec55f947c716b058a39038889550d7e39b3cChris Lattner VT == MVT::iPTRAny) && "Not a concrete type!"); 552cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.push_back(VT); 562cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 592cacec55f947c716b058a39038889550d7e39b3cChris Lattner 6026369a930c523b75fe8f4ba18456ff86f68d5612Jakob Stoklund OlesenEEVT::TypeSet::TypeSet(ArrayRef<MVT::SimpleValueType> VTList) { 612cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(!VTList.empty() && "empty list?"); 622cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.append(VTList.begin(), VTList.end()); 63fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 642cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!VTList.empty()) 652cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(VTList[0] != MVT::iAny && VTList[0] != MVT::vAny && 662cacec55f947c716b058a39038889550d7e39b3cChris Lattner VTList[0] != MVT::fAny); 67fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 680d7952ed5ac10b6159d0e8e2449f0f471d117e0fChris Lattner // Verify no duplicates. 692cacec55f947c716b058a39038889550d7e39b3cChris Lattner array_pod_sort(TypeVec.begin(), TypeVec.end()); 700d7952ed5ac10b6159d0e8e2449f0f471d117e0fChris Lattner assert(std::unique(TypeVec.begin(), TypeVec.end()) == TypeVec.end()); 716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 735a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner/// FillWithPossibleTypes - Set to all legal types and return true, only valid 745a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner/// on completely unknown type sets. 75774ce29399364823dba62217ebf7bc8701005140Chris Lattnerbool EEVT::TypeSet::FillWithPossibleTypes(TreePattern &TP, 76774ce29399364823dba62217ebf7bc8701005140Chris Lattner bool (*Pred)(MVT::SimpleValueType), 77774ce29399364823dba62217ebf7bc8701005140Chris Lattner const char *PredicateName) { 785a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner assert(isCompletelyUnknown()); 7926369a930c523b75fe8f4ba18456ff86f68d5612Jakob Stoklund Olesen ArrayRef<MVT::SimpleValueType> LegalTypes = 80774ce29399364823dba62217ebf7bc8701005140Chris Lattner TP.getDAGPatterns().getTargetInfo().getLegalValueTypes(); 81fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 8361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 8461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger 85774ce29399364823dba62217ebf7bc8701005140Chris Lattner for (unsigned i = 0, e = LegalTypes.size(); i != e; ++i) 86774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (Pred == 0 || Pred(LegalTypes[i])) 87774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeVec.push_back(LegalTypes[i]); 88774ce29399364823dba62217ebf7bc8701005140Chris Lattner 89774ce29399364823dba62217ebf7bc8701005140Chris Lattner // If we have nothing that matches the predicate, bail out. 9061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TypeVec.empty()) { 91774ce29399364823dba62217ebf7bc8701005140Chris Lattner TP.error("Type inference contradiction found, no " + 92fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach std::string(PredicateName) + " types found"); 9361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 9461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 95774ce29399364823dba62217ebf7bc8701005140Chris Lattner // No need to sort with one element. 96774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (TypeVec.size() == 1) return true; 97774ce29399364823dba62217ebf7bc8701005140Chris Lattner 98774ce29399364823dba62217ebf7bc8701005140Chris Lattner // Remove duplicates. 99774ce29399364823dba62217ebf7bc8701005140Chris Lattner array_pod_sort(TypeVec.begin(), TypeVec.end()); 100774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeVec.erase(std::unique(TypeVec.begin(), TypeVec.end()), TypeVec.end()); 101fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1025a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner return true; 1035a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner} 1042cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1052cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// hasIntegerTypes - Return true if this TypeSet contains iAny or an 1062cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// integer value type. 1072cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::hasIntegerTypes() const { 1082cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 1092cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isInteger(TypeVec[i])) 1102cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1112cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 112fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach} 1132cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1142cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// hasFloatingPointTypes - Return true if this TypeSet contains an fAny or 1152cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// a floating point value type. 1162cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::hasFloatingPointTypes() const { 1172cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 1182cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isFloatingPoint(TypeVec[i])) 1192cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1202cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 121fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach} 1222cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1232cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// hasVectorTypes - Return true if this TypeSet contains a vAny or a vector 1242cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// value type. 1252cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::hasVectorTypes() const { 1262cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 1272cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isVector(TypeVec[i])) 1282cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1292cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 1306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 13161fc4cf7aa0b87ceab62082cee8ef5ce3f574ffcBob Wilson 1322cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1332cacec55f947c716b058a39038889550d7e39b3cChris Lattnerstd::string EEVT::TypeSet::getName() const { 134aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner if (TypeVec.empty()) return "<empty>"; 135fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1362cacec55f947c716b058a39038889550d7e39b3cChris Lattner std::string Result; 137fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1382cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) { 1392cacec55f947c716b058a39038889550d7e39b3cChris Lattner std::string VTName = llvm::getEnumName(TypeVec[i]); 1402cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Strip off MVT:: prefix if present. 1412cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VTName.substr(0,5) == "MVT::") 1422cacec55f947c716b058a39038889550d7e39b3cChris Lattner VTName = VTName.substr(5); 1432cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (i) Result += ':'; 1442cacec55f947c716b058a39038889550d7e39b3cChris Lattner Result += VTName; 1452cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 146fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1472cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.size() == 1) 1482cacec55f947c716b058a39038889550d7e39b3cChris Lattner return Result; 1492cacec55f947c716b058a39038889550d7e39b3cChris Lattner return "{" + Result + "}"; 15061fc4cf7aa0b87ceab62082cee8ef5ce3f574ffcBob Wilson} 1512cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1522cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// MergeInTypeInfo - This merges in type information from the specified 1532cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// argument. If 'this' changes, it returns true. If the two types are 15461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// contradictory (e.g. merge f32 into i32) then this flags an error. 1552cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::MergeInTypeInfo(const EEVT::TypeSet &InVT, TreePattern &TP){ 15661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (InVT.isCompletelyUnknown() || *this == InVT || TP.hasError()) 1572cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 158fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1592cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isCompletelyUnknown()) { 1602cacec55f947c716b058a39038889550d7e39b3cChris Lattner *this = InVT; 1612cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1622cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 163fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1642cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(TypeVec.size() >= 1 && InVT.TypeVec.size() >= 1 && "No unknowns"); 165fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1662cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Handle the abstract cases, seeing if we can resolve them better. 1672cacec55f947c716b058a39038889550d7e39b3cChris Lattner switch (TypeVec[0]) { 1682cacec55f947c716b058a39038889550d7e39b3cChris Lattner default: break; 1692cacec55f947c716b058a39038889550d7e39b3cChris Lattner case MVT::iPTR: 1702cacec55f947c716b058a39038889550d7e39b3cChris Lattner case MVT::iPTRAny: 1712cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InVT.hasIntegerTypes()) { 1722cacec55f947c716b058a39038889550d7e39b3cChris Lattner EEVT::TypeSet InCopy(InVT); 1732cacec55f947c716b058a39038889550d7e39b3cChris Lattner InCopy.EnforceInteger(TP); 1742cacec55f947c716b058a39038889550d7e39b3cChris Lattner InCopy.EnforceScalar(TP); 175fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1762cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InCopy.isConcrete()) { 1772cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If the RHS has one integer type, upgrade iPTR to i32. 1782cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec[0] = InVT.TypeVec[0]; 1792cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1802cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 181fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1822cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If the input has multiple scalar integers, this doesn't add any info. 1832cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!InCopy.isCompletelyUnknown()) 1842cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 1852cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1862cacec55f947c716b058a39038889550d7e39b3cChris Lattner break; 1872cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 188fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1892cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If the input constraint is iAny/iPTR and this is an integer type list, 1902cacec55f947c716b058a39038889550d7e39b3cChris Lattner // remove non-integer types from the list. 1912cacec55f947c716b058a39038889550d7e39b3cChris Lattner if ((InVT.TypeVec[0] == MVT::iPTR || InVT.TypeVec[0] == MVT::iPTRAny) && 1922cacec55f947c716b058a39038889550d7e39b3cChris Lattner hasIntegerTypes()) { 1932cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = EnforceInteger(TP); 194fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1952cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we're merging in iPTR/iPTRAny and the node currently has a list of 1962cacec55f947c716b058a39038889550d7e39b3cChris Lattner // multiple different integer types, replace them with a single iPTR. 1972cacec55f947c716b058a39038889550d7e39b3cChris Lattner if ((InVT.TypeVec[0] == MVT::iPTR || InVT.TypeVec[0] == MVT::iPTRAny) && 1982cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.size() != 1) { 1992cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.resize(1); 2002cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec[0] = InVT.TypeVec[0]; 2012cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange = true; 2022cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 203fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2042cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 2052cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 206fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2072cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this is a type list and the RHS is a typelist as well, eliminate entries 2082cacec55f947c716b058a39038889550d7e39b3cChris Lattner // from this list that aren't in the other one. 2092cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = false; 2102cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeSet InputSet(*this); 2112cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2122cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) { 2132cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool InInVT = false; 2142cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned j = 0, e = InVT.TypeVec.size(); j != e; ++j) 2152cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec[i] == InVT.TypeVec[j]) { 2162cacec55f947c716b058a39038889550d7e39b3cChris Lattner InInVT = true; 2172cacec55f947c716b058a39038889550d7e39b3cChris Lattner break; 2182cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 219fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2202cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InInVT) continue; 2212cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 2222cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange = true; 2232cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 224fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2252cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we removed all of our types, we have a type contradiction. 2262cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!TypeVec.empty()) 2272cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 228fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2292cacec55f947c716b058a39038889550d7e39b3cChris Lattner // FIXME: Really want an SMLoc here! 2302cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, merging '" + 2312cacec55f947c716b058a39038889550d7e39b3cChris Lattner InVT.getName() + "' into '" + InputSet.getName() + "'"); 23261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 2332cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2342cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2352cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceInteger - Remove all non-integer types from this set. 2362cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceInteger(TreePattern &TP) { 23761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 23861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 2392cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2405a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 241774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isInteger, "integer"); 2422cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!hasFloatingPointTypes()) 243774ce29399364823dba62217ebf7bc8701005140Chris Lattner return false; 244774ce29399364823dba62217ebf7bc8701005140Chris Lattner 245774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 246fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2472cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the fp types. 2482cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 249774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isInteger(TypeVec[i])) 2502cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 251fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 25261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TypeVec.empty()) { 2532cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 2542cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be integer"); 25561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 25661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 257774ce29399364823dba62217ebf7bc8701005140Chris Lattner return true; 2582cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2592cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2602cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceFloatingPoint - Remove all integer types from this set. 2612cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceFloatingPoint(TreePattern &TP) { 26261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 26361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 2642cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2655a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 266774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isFloatingPoint, "floating point"); 267774ce29399364823dba62217ebf7bc8701005140Chris Lattner 2682cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!hasIntegerTypes()) 269774ce29399364823dba62217ebf7bc8701005140Chris Lattner return false; 270774ce29399364823dba62217ebf7bc8701005140Chris Lattner 271774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 272fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2732cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the fp types. 2742cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 275774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isFloatingPoint(TypeVec[i])) 2762cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 277fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TypeVec.empty()) { 2792cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 2802cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be floating point"); 28161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 28261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 283774ce29399364823dba62217ebf7bc8701005140Chris Lattner return true; 2842cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2852cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2862cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceScalar - Remove all vector types from this. 2872cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceScalar(TreePattern &TP) { 28861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 28961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 29061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger 2912cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2925a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 293774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isScalar, "scalar"); 294774ce29399364823dba62217ebf7bc8701005140Chris Lattner 2952cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!hasVectorTypes()) 296774ce29399364823dba62217ebf7bc8701005140Chris Lattner return false; 297774ce29399364823dba62217ebf7bc8701005140Chris Lattner 298774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 299fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3002cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the vector types. 3012cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 302774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isScalar(TypeVec[i])) 3032cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 304fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 30561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TypeVec.empty()) { 3062cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 3072cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be scalar"); 30861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 30961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 310774ce29399364823dba62217ebf7bc8701005140Chris Lattner return true; 3112cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 3122cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3132cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceVector - Remove all vector types from this. 3142cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceVector(TreePattern &TP) { 31561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 31661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 31761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger 3182cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 3195a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 320774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isVector, "vector"); 321774ce29399364823dba62217ebf7bc8701005140Chris Lattner 322774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 323774ce29399364823dba62217ebf7bc8701005140Chris Lattner bool MadeChange = false; 324fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3252cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the scalar types. 3262cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 327774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isVector(TypeVec[i])) { 3282cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 329774ce29399364823dba62217ebf7bc8701005140Chris Lattner MadeChange = true; 330774ce29399364823dba62217ebf7bc8701005140Chris Lattner } 331fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 33261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TypeVec.empty()) { 3332cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 3342cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be a vector"); 33561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 33661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 3372cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 3382cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 3392cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3402cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3415a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3422cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceSmallerThan - 'this' must be a smaller VT than Other. Update 3432cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// this an other based on this information. 3442cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceSmallerThan(EEVT::TypeSet &Other, TreePattern &TP) { 34561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 34661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 34761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger 3482cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Both operands must be integer or FP, but we don't care which. 3492cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = false; 350fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3515a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (isCompletelyUnknown()) 3525a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MadeChange = FillWithPossibleTypes(TP); 3535a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3545a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (Other.isCompletelyUnknown()) 3555a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MadeChange = Other.FillWithPossibleTypes(TP); 356fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3572cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If one side is known to be integer or known to be FP but the other side has 3582cacec55f947c716b058a39038889550d7e39b3cChris Lattner // no information, get at least the type integrality info in there. 3595a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!hasFloatingPointTypes()) 3602cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= Other.EnforceInteger(TP); 3615a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner else if (!hasIntegerTypes()) 3622cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= Other.EnforceFloatingPoint(TP); 3635a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!Other.hasFloatingPointTypes()) 3642cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= EnforceInteger(TP); 3655a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner else if (!Other.hasIntegerTypes()) 3662cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= EnforceFloatingPoint(TP); 367fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3682cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(!isCompletelyUnknown() && !Other.isCompletelyUnknown() && 3692cacec55f947c716b058a39038889550d7e39b3cChris Lattner "Should have a type list now"); 370fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3712cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If one contains vectors but the other doesn't pull vectors out. 3725a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!hasVectorTypes()) 3732cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= Other.EnforceScalar(TP); 3745a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!hasVectorTypes()) 3752cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= EnforceScalar(TP); 376fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3779d7f0111100d863f2722deab952711a5496abad4David Greene if (TypeVec.size() == 1 && Other.TypeVec.size() == 1) { 3789d7f0111100d863f2722deab952711a5496abad4David Greene // If we are down to concrete types, this code does not currently 3799d7f0111100d863f2722deab952711a5496abad4David Greene // handle nodes which have multiple types, where some types are 3809d7f0111100d863f2722deab952711a5496abad4David Greene // integer, and some are fp. Assert that this is not the case. 3819d7f0111100d863f2722deab952711a5496abad4David Greene assert(!(hasIntegerTypes() && hasFloatingPointTypes()) && 3829d7f0111100d863f2722deab952711a5496abad4David Greene !(Other.hasIntegerTypes() && Other.hasFloatingPointTypes()) && 3839d7f0111100d863f2722deab952711a5496abad4David Greene "SDTCisOpSmallerThanOp does not handle mixed int/fp types!"); 3849d7f0111100d863f2722deab952711a5496abad4David Greene 3859d7f0111100d863f2722deab952711a5496abad4David Greene // Otherwise, if these are both vector types, either this vector 3869d7f0111100d863f2722deab952711a5496abad4David Greene // must have a larger bitsize than the other, or this element type 3879d7f0111100d863f2722deab952711a5496abad4David Greene // must be larger than the other. 3889d7f0111100d863f2722deab952711a5496abad4David Greene EVT Type(TypeVec[0]); 3899d7f0111100d863f2722deab952711a5496abad4David Greene EVT OtherType(Other.TypeVec[0]); 3909d7f0111100d863f2722deab952711a5496abad4David Greene 3919d7f0111100d863f2722deab952711a5496abad4David Greene if (hasVectorTypes() && Other.hasVectorTypes()) { 3929d7f0111100d863f2722deab952711a5496abad4David Greene if (Type.getSizeInBits() >= OtherType.getSizeInBits()) 3939d7f0111100d863f2722deab952711a5496abad4David Greene if (Type.getVectorElementType().getSizeInBits() 39461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger >= OtherType.getVectorElementType().getSizeInBits()) { 3959d7f0111100d863f2722deab952711a5496abad4David Greene TP.error("Type inference contradiction found, '" + 3969d7f0111100d863f2722deab952711a5496abad4David Greene getName() + "' element type not smaller than '" + 3979d7f0111100d863f2722deab952711a5496abad4David Greene Other.getName() +"'!"); 39861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 39961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 4009d7f0111100d863f2722deab952711a5496abad4David Greene } 4019d7f0111100d863f2722deab952711a5496abad4David Greene else 4029d7f0111100d863f2722deab952711a5496abad4David Greene // For scalar types, the bitsize of this type must be larger 4039d7f0111100d863f2722deab952711a5496abad4David Greene // than that of the other. 40461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (Type.getSizeInBits() >= OtherType.getSizeInBits()) { 4059d7f0111100d863f2722deab952711a5496abad4David Greene TP.error("Type inference contradiction found, '" + 4069d7f0111100d863f2722deab952711a5496abad4David Greene getName() + "' is not smaller than '" + 4079d7f0111100d863f2722deab952711a5496abad4David Greene Other.getName() +"'!"); 40861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 40961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 4109d7f0111100d863f2722deab952711a5496abad4David Greene } 4119d7f0111100d863f2722deab952711a5496abad4David Greene 4129d7f0111100d863f2722deab952711a5496abad4David Greene 4139d7f0111100d863f2722deab952711a5496abad4David Greene // Handle int and fp as disjoint sets. This won't work for patterns 4149d7f0111100d863f2722deab952711a5496abad4David Greene // that have mixed fp/int types but those are likely rare and would 4159d7f0111100d863f2722deab952711a5496abad4David Greene // not have been accepted by this code previously. 416fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 4175a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // Okay, find the smallest type from the current set and remove it from the 4185a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // largest set. 419c83e20375746c2910331ed29f5d976d80fe728e4David Greene MVT::SimpleValueType SmallestInt = MVT::LAST_VALUETYPE; 4209d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 4219d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(TypeVec[i])) { 4229d7f0111100d863f2722deab952711a5496abad4David Greene SmallestInt = TypeVec[i]; 4239d7f0111100d863f2722deab952711a5496abad4David Greene break; 4249d7f0111100d863f2722deab952711a5496abad4David Greene } 4255a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner for (unsigned i = 1, e = TypeVec.size(); i != e; ++i) 4269d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(TypeVec[i]) && TypeVec[i] < SmallestInt) 4279d7f0111100d863f2722deab952711a5496abad4David Greene SmallestInt = TypeVec[i]; 4289d7f0111100d863f2722deab952711a5496abad4David Greene 429c83e20375746c2910331ed29f5d976d80fe728e4David Greene MVT::SimpleValueType SmallestFP = MVT::LAST_VALUETYPE; 4309d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 4319d7f0111100d863f2722deab952711a5496abad4David Greene if (isFloatingPoint(TypeVec[i])) { 4329d7f0111100d863f2722deab952711a5496abad4David Greene SmallestFP = TypeVec[i]; 4339d7f0111100d863f2722deab952711a5496abad4David Greene break; 4349d7f0111100d863f2722deab952711a5496abad4David Greene } 4359d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 1, e = TypeVec.size(); i != e; ++i) 4369d7f0111100d863f2722deab952711a5496abad4David Greene if (isFloatingPoint(TypeVec[i]) && TypeVec[i] < SmallestFP) 4379d7f0111100d863f2722deab952711a5496abad4David Greene SmallestFP = TypeVec[i]; 4389d7f0111100d863f2722deab952711a5496abad4David Greene 4399d7f0111100d863f2722deab952711a5496abad4David Greene int OtherIntSize = 0; 4409d7f0111100d863f2722deab952711a5496abad4David Greene int OtherFPSize = 0; 4416227d5c690504c7ada5780c00a635b282c46e275Craig Topper for (SmallVectorImpl<MVT::SimpleValueType>::iterator TVI = 4429d7f0111100d863f2722deab952711a5496abad4David Greene Other.TypeVec.begin(); 4439d7f0111100d863f2722deab952711a5496abad4David Greene TVI != Other.TypeVec.end(); 4449d7f0111100d863f2722deab952711a5496abad4David Greene /* NULL */) { 4459d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(*TVI)) { 4469d7f0111100d863f2722deab952711a5496abad4David Greene ++OtherIntSize; 4479d7f0111100d863f2722deab952711a5496abad4David Greene if (*TVI == SmallestInt) { 4489d7f0111100d863f2722deab952711a5496abad4David Greene TVI = Other.TypeVec.erase(TVI); 4499d7f0111100d863f2722deab952711a5496abad4David Greene --OtherIntSize; 4509d7f0111100d863f2722deab952711a5496abad4David Greene MadeChange = true; 4519d7f0111100d863f2722deab952711a5496abad4David Greene continue; 4529d7f0111100d863f2722deab952711a5496abad4David Greene } 4539d7f0111100d863f2722deab952711a5496abad4David Greene } 4549d7f0111100d863f2722deab952711a5496abad4David Greene else if (isFloatingPoint(*TVI)) { 4559d7f0111100d863f2722deab952711a5496abad4David Greene ++OtherFPSize; 4569d7f0111100d863f2722deab952711a5496abad4David Greene if (*TVI == SmallestFP) { 4579d7f0111100d863f2722deab952711a5496abad4David Greene TVI = Other.TypeVec.erase(TVI); 4589d7f0111100d863f2722deab952711a5496abad4David Greene --OtherFPSize; 4599d7f0111100d863f2722deab952711a5496abad4David Greene MadeChange = true; 4609d7f0111100d863f2722deab952711a5496abad4David Greene continue; 4619d7f0111100d863f2722deab952711a5496abad4David Greene } 4629d7f0111100d863f2722deab952711a5496abad4David Greene } 4639d7f0111100d863f2722deab952711a5496abad4David Greene ++TVI; 4649d7f0111100d863f2722deab952711a5496abad4David Greene } 465fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 4665a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // If this is the only type in the large set, the constraint can never be 4675a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // satisfied. 4689d7f0111100d863f2722deab952711a5496abad4David Greene if ((Other.hasIntegerTypes() && OtherIntSize == 0) 46961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger || (Other.hasFloatingPointTypes() && OtherFPSize == 0)) { 4705a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner TP.error("Type inference contradiction found, '" + 4715a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner Other.getName() + "' has nothing larger than '" + getName() +"'!"); 47261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 47361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 474fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 4755a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // Okay, find the largest type in the Other set and remove it from the 4765a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // current set. 477c83e20375746c2910331ed29f5d976d80fe728e4David Greene MVT::SimpleValueType LargestInt = MVT::Other; 4789d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 0, e = Other.TypeVec.size(); i != e; ++i) 4799d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(Other.TypeVec[i])) { 4809d7f0111100d863f2722deab952711a5496abad4David Greene LargestInt = Other.TypeVec[i]; 4819d7f0111100d863f2722deab952711a5496abad4David Greene break; 4829d7f0111100d863f2722deab952711a5496abad4David Greene } 4835a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner for (unsigned i = 1, e = Other.TypeVec.size(); i != e; ++i) 4849d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(Other.TypeVec[i]) && Other.TypeVec[i] > LargestInt) 4859d7f0111100d863f2722deab952711a5496abad4David Greene LargestInt = Other.TypeVec[i]; 4869d7f0111100d863f2722deab952711a5496abad4David Greene 487c83e20375746c2910331ed29f5d976d80fe728e4David Greene MVT::SimpleValueType LargestFP = MVT::Other; 4889d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 0, e = Other.TypeVec.size(); i != e; ++i) 4899d7f0111100d863f2722deab952711a5496abad4David Greene if (isFloatingPoint(Other.TypeVec[i])) { 4909d7f0111100d863f2722deab952711a5496abad4David Greene LargestFP = Other.TypeVec[i]; 4919d7f0111100d863f2722deab952711a5496abad4David Greene break; 4929d7f0111100d863f2722deab952711a5496abad4David Greene } 4939d7f0111100d863f2722deab952711a5496abad4David Greene for (unsigned i = 1, e = Other.TypeVec.size(); i != e; ++i) 4949d7f0111100d863f2722deab952711a5496abad4David Greene if (isFloatingPoint(Other.TypeVec[i]) && Other.TypeVec[i] > LargestFP) 4959d7f0111100d863f2722deab952711a5496abad4David Greene LargestFP = Other.TypeVec[i]; 4969d7f0111100d863f2722deab952711a5496abad4David Greene 4979d7f0111100d863f2722deab952711a5496abad4David Greene int IntSize = 0; 4989d7f0111100d863f2722deab952711a5496abad4David Greene int FPSize = 0; 4996227d5c690504c7ada5780c00a635b282c46e275Craig Topper for (SmallVectorImpl<MVT::SimpleValueType>::iterator TVI = 5009d7f0111100d863f2722deab952711a5496abad4David Greene TypeVec.begin(); 5019d7f0111100d863f2722deab952711a5496abad4David Greene TVI != TypeVec.end(); 5029d7f0111100d863f2722deab952711a5496abad4David Greene /* NULL */) { 5039d7f0111100d863f2722deab952711a5496abad4David Greene if (isInteger(*TVI)) { 5049d7f0111100d863f2722deab952711a5496abad4David Greene ++IntSize; 5059d7f0111100d863f2722deab952711a5496abad4David Greene if (*TVI == LargestInt) { 5069d7f0111100d863f2722deab952711a5496abad4David Greene TVI = TypeVec.erase(TVI); 5079d7f0111100d863f2722deab952711a5496abad4David Greene --IntSize; 5089d7f0111100d863f2722deab952711a5496abad4David Greene MadeChange = true; 5099d7f0111100d863f2722deab952711a5496abad4David Greene continue; 5109d7f0111100d863f2722deab952711a5496abad4David Greene } 5119d7f0111100d863f2722deab952711a5496abad4David Greene } 5129d7f0111100d863f2722deab952711a5496abad4David Greene else if (isFloatingPoint(*TVI)) { 5139d7f0111100d863f2722deab952711a5496abad4David Greene ++FPSize; 5149d7f0111100d863f2722deab952711a5496abad4David Greene if (*TVI == LargestFP) { 5159d7f0111100d863f2722deab952711a5496abad4David Greene TVI = TypeVec.erase(TVI); 5169d7f0111100d863f2722deab952711a5496abad4David Greene --FPSize; 5179d7f0111100d863f2722deab952711a5496abad4David Greene MadeChange = true; 5189d7f0111100d863f2722deab952711a5496abad4David Greene continue; 5199d7f0111100d863f2722deab952711a5496abad4David Greene } 5209d7f0111100d863f2722deab952711a5496abad4David Greene } 5219d7f0111100d863f2722deab952711a5496abad4David Greene ++TVI; 5229d7f0111100d863f2722deab952711a5496abad4David Greene } 523fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 5245a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // If this is the only type in the small set, the constraint can never be 5255a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // satisfied. 5269d7f0111100d863f2722deab952711a5496abad4David Greene if ((hasIntegerTypes() && IntSize == 0) 52761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger || (hasFloatingPointTypes() && FPSize == 0)) { 5285a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner TP.error("Type inference contradiction found, '" + 5295a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner getName() + "' has nothing smaller than '" + Other.getName()+"'!"); 53061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 53161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 532fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 5335a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner return MadeChange; 5342cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 5352cacec55f947c716b058a39038889550d7e39b3cChris Lattner 5362cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceVectorEltTypeIs - 'this' is now constrainted to be a vector type 53766fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner/// whose element is specified by VTOperand. 53866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattnerbool EEVT::TypeSet::EnforceVectorEltTypeIs(EEVT::TypeSet &VTOperand, 5392cacec55f947c716b058a39038889550d7e39b3cChris Lattner TreePattern &TP) { 54061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 54161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 54261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger 54366fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // "This" must be a vector and "VTOperand" must be a scalar. 5442cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = false; 54566fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner MadeChange |= EnforceVector(TP); 54666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner MadeChange |= VTOperand.EnforceScalar(TP); 54766fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner 54866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // If we know the vector type, it forces the scalar to agree. 54966fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner if (isConcrete()) { 55066fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner EVT IVT = getConcrete(); 55166fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner IVT = IVT.getVectorElementType(); 552fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach return MadeChange | 55366fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner VTOperand.MergeInTypeInfo(IVT.getSimpleVT().SimpleTy, TP); 55466fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner } 55566fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner 55666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // If the scalar type is known, filter out vector types whose element types 55766fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // disagree. 55866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner if (!VTOperand.isConcrete()) 55966fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner return MadeChange; 560fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 56166fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner MVT::SimpleValueType VT = VTOperand.getConcrete(); 562fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 56366fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner TypeSet InputSet(*this); 564fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 56566fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // Filter out all the types which don't have the right element type. 56666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) { 56766fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner assert(isVector(TypeVec[i]) && "EnforceVector didn't work"); 56866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner if (EVT(TypeVec[i]).getVectorElementType().getSimpleVT().SimpleTy != VT) { 5692cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 5702cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange = true; 5712cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 57266fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner } 573fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 57461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TypeVec.empty()) { // FIXME: Really want an SMLoc here! 5752cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, forcing '" + 5762cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' to have a vector element"); 57761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 57861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 5792cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 5802cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 5812cacec55f947c716b058a39038889550d7e39b3cChris Lattner 5826032269837c08a94b70b0e36f8e473c293ff5fd4David Greene/// EnforceVectorSubVectorTypeIs - 'this' is now constrainted to be a 5836032269837c08a94b70b0e36f8e473c293ff5fd4David Greene/// vector type specified by VTOperand. 5846032269837c08a94b70b0e36f8e473c293ff5fd4David Greenebool EEVT::TypeSet::EnforceVectorSubVectorTypeIs(EEVT::TypeSet &VTOperand, 5856032269837c08a94b70b0e36f8e473c293ff5fd4David Greene TreePattern &TP) { 5866032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // "This" must be a vector and "VTOperand" must be a vector. 5876032269837c08a94b70b0e36f8e473c293ff5fd4David Greene bool MadeChange = false; 5886032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= EnforceVector(TP); 5896032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= VTOperand.EnforceVector(TP); 5906032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 5916032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // "This" must be larger than "VTOperand." 5926032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= VTOperand.EnforceSmallerThan(*this, TP); 5936032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 5946032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // If we know the vector type, it forces the scalar types to agree. 5956032269837c08a94b70b0e36f8e473c293ff5fd4David Greene if (isConcrete()) { 5966032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EVT IVT = getConcrete(); 5976032269837c08a94b70b0e36f8e473c293ff5fd4David Greene IVT = IVT.getVectorElementType(); 5986032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 5996032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EEVT::TypeSet EltTypeSet(IVT.getSimpleVT().SimpleTy, TP); 6006032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= VTOperand.EnforceVectorEltTypeIs(EltTypeSet, TP); 6016032269837c08a94b70b0e36f8e473c293ff5fd4David Greene } else if (VTOperand.isConcrete()) { 6026032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EVT IVT = VTOperand.getConcrete(); 6036032269837c08a94b70b0e36f8e473c293ff5fd4David Greene IVT = IVT.getVectorElementType(); 6046032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 6056032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EEVT::TypeSet EltTypeSet(IVT.getSimpleVT().SimpleTy, TP); 6066032269837c08a94b70b0e36f8e473c293ff5fd4David Greene MadeChange |= EnforceVectorEltTypeIs(EltTypeSet, TP); 6076032269837c08a94b70b0e36f8e473c293ff5fd4David Greene } 6086032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 6096032269837c08a94b70b0e36f8e473c293ff5fd4David Greene return MadeChange; 6106032269837c08a94b70b0e36f8e473c293ff5fd4David Greene} 6116032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 6122cacec55f947c716b058a39038889550d7e39b3cChris Lattner//===----------------------------------------------------------------------===// 6132cacec55f947c716b058a39038889550d7e39b3cChris Lattner// Helpers for working with extended types. 6146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 615327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// Dependent variable map for CodeGenDAGPattern variant generation 616327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Micheltypedef std::map<std::string, int> DepVarMap; 617327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 618327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// Const iterator shorthand for DepVarMap 619327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Micheltypedef DepVarMap::const_iterator DepVarMap_citer; 620327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 621543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstatic void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) { 622327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (N->isLeaf()) { 6233f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (isa<DefInit>(N->getLeafValue())) 624327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DepMap[N->getName()]++; 625327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } else { 626327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (size_t i = 0, e = N->getNumChildren(); i != e; ++i) 627327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVarsOf(N->getChild(i), DepMap); 628327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 629327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 630543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 631543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// Find dependent variables within child patterns 632543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstatic void FindDepVars(TreePatternNode *N, MultipleUseVarSet &DepVars) { 633327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DepVarMap depcounts; 634327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVarsOf(N, depcounts); 635327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (DepVarMap_citer i = depcounts.begin(); i != depcounts.end(); ++i) { 636543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (i->second > 1) // std::pair<std::string, int> 637327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DepVars.insert(i->first); 638327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 639327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 640327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 6416aa526bf76ba74b79ebf4d96d2c1f12d59067530Daniel Dunbar#ifndef NDEBUG 642543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// Dump the dependent variable set: 643543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstatic void DumpDepVars(MultipleUseVarSet &DepVars) { 644327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (DepVars.empty()) { 645569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "<empty set>"); 646327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } else { 647569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "[ "); 648bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach for (MultipleUseVarSet::const_iterator i = DepVars.begin(), 649bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach e = DepVars.end(); i != e; ++i) { 650569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << (*i) << " "); 651327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 652569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "]"); 653327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 654327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 6556aa526bf76ba74b79ebf4d96d2c1f12d59067530Daniel Dunbar#endif 6566aa526bf76ba74b79ebf4d96d2c1f12d59067530Daniel Dunbar 657543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 658543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner//===----------------------------------------------------------------------===// 659543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner// TreePredicateFn Implementation 660543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner//===----------------------------------------------------------------------===// 661543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 6627ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner/// TreePredicateFn constructor. Here 'N' is a subclass of PatFrag. 6637ed1391ff66012e4963081cfb20b6166e8784f50Chris LattnerTreePredicateFn::TreePredicateFn(TreePattern *N) : PatFragRec(N) { 6647ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner assert((getPredCode().empty() || getImmCode().empty()) && 6657ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner ".td file corrupt: can't have a node predicate *and* an imm predicate"); 6667ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner} 6677ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner 668543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstd::string TreePredicateFn::getPredCode() const { 6698dd6f0c8353f80de6526810899f271d539f6929cJakob Stoklund Olesen return PatFragRec->getRecord()->getValueAsString("PredicateCode"); 670543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner} 671543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 6727ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattnerstd::string TreePredicateFn::getImmCode() const { 6738dd6f0c8353f80de6526810899f271d539f6929cJakob Stoklund Olesen return PatFragRec->getRecord()->getValueAsString("ImmediateCode"); 6747ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner} 6757ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner 676543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 677543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// isAlwaysTrue - Return true if this is a noop predicate. 678543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerbool TreePredicateFn::isAlwaysTrue() const { 6797ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner return getPredCode().empty() && getImmCode().empty(); 680543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner} 681543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 682543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// Return the name to use in the generated code to reference this, this is 683543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// "Predicate_foo" if from a pattern fragment "foo". 684543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstd::string TreePredicateFn::getFnName() const { 685543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner return "Predicate_" + PatFragRec->getRecord()->getName(); 686543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner} 687543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 688543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// getCodeToRunOnSDNode - Return the code for the function body that 689543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// evaluates this predicate. The argument is expected to be in "Node", 690543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// not N. This handles casting and conversion to a concrete node type as 691543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner/// appropriate. 692543790673c747ab2793fc657e239ce5f78419dc0Chris Lattnerstd::string TreePredicateFn::getCodeToRunOnSDNode() const { 6937ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner // Handle immediate predicates first. 6947ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner std::string ImmCode = getImmCode(); 6957ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner if (!ImmCode.empty()) { 6967ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner std::string Result = 6977ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner " int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();\n"; 6987ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner return Result + ImmCode; 6997ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner } 7007ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner 7017ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner // Handle arbitrary node predicates. 7027ed1391ff66012e4963081cfb20b6166e8784f50Chris Lattner assert(!getPredCode().empty() && "Don't have any predicate code!"); 703543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner std::string ClassName; 704543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (PatFragRec->getOnlyTree()->isLeaf()) 705543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner ClassName = "SDNode"; 706543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner else { 707543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner Record *Op = PatFragRec->getOnlyTree()->getOperator(); 708543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner ClassName = PatFragRec->getDAGPatterns().getSDNodeInfo(Op).getSDClassName(); 709543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner } 710543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner std::string Result; 711543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (ClassName == "SDNode") 712543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner Result = " SDNode *N = Node;\n"; 713543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner else 714543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner Result = " " + ClassName + "*N = cast<" + ClassName + ">(Node);\n"; 715543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner 716543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner return Result + getPredCode(); 717327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 718327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 7196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 72022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman// PatternToMatch implementation 72122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman// 72222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 72348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 72448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// getPatternSize - Return the 'size' of this pattern. We want to match large 72548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// patterns before small ones. This is used to determine the size of a 72648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// pattern. 72748e86dbe29e331357b0df11075b7974009c65f34Chris Lattnerstatic unsigned getPatternSize(const TreePatternNode *P, 72848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner const CodeGenDAGPatterns &CGP) { 72948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner unsigned Size = 3; // The node itself. 73048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // If the root node is a ConstantSDNode, increases its size. 73148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // e.g. (set R32:$dst, 0). 7323f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (P->isLeaf() && isa<IntInit>(P->getLeafValue())) 73348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += 2; 734fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 73548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // FIXME: This is a hack to statically increase the priority of patterns 73648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // which maps a sub-dag to a complex pattern. e.g. favors LEA over ADD. 73748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // Later we can allow complexity / cost for each pattern to be (optionally) 73848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // specified. To get best possible pattern match we'll need to dynamically 73948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // calculate the complexity of all patterns a dag can potentially map to. 74048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner const ComplexPattern *AM = P->getComplexPatternInfo(CGP); 74148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (AM) 74248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += AM->getNumOperands() * 3; 743fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 74448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // If this node has some predicate function that must match, it adds to the 74548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // complexity of this node. 74648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (!P->getPredicateFns().empty()) 74748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner ++Size; 748fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 74948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // Count children in the count if they are also nodes. 75048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) { 75148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner TreePatternNode *Child = P->getChild(i); 75248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (!Child->isLeaf() && Child->getNumTypes() && 75348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Child->getType(0) != MVT::Other) 75448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += getPatternSize(Child, CGP); 75548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner else if (Child->isLeaf()) { 7563f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (isa<IntInit>(Child->getLeafValue())) 75748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2). 75848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner else if (Child->getComplexPatternInfo(CGP)) 75948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += getPatternSize(Child, CGP); 76048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner else if (!Child->getPredicateFns().empty()) 76148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner ++Size; 76248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner } 76348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner } 764fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 76548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner return Size; 76648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner} 76748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 76848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// Compute the complexity metric for the input pattern. This roughly 76948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// corresponds to the number of nodes that are covered. 77048e86dbe29e331357b0df11075b7974009c65f34Chris Lattnerunsigned PatternToMatch:: 77148e86dbe29e331357b0df11075b7974009c65f34Chris LattnergetPatternComplexity(const CodeGenDAGPatterns &CGP) const { 77248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner return getPatternSize(getSrcPattern(), CGP) + getAddedComplexity(); 77348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner} 77448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 77548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 77622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// getPredicateCheck - Return a single string containing all of this 77722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// pattern's predicates concatenated with "&&" operators. 77822bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// 77922bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohmanstd::string PatternToMatch::getPredicateCheck() const { 78022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman std::string PredicateCheck; 78122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) { 7826cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *Pred = dyn_cast<DefInit>(Predicates->getElement(i))) { 78322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman Record *Def = Pred->getDef(); 78422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (!Def->isSubClassOf("Predicate")) { 78522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman#ifndef NDEBUG 78622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman Def->dump(); 78722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman#endif 788655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper llvm_unreachable("Unknown predicate type!"); 78922bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 79022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (!PredicateCheck.empty()) 79122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman PredicateCheck += " && "; 79222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman PredicateCheck += "(" + Def->getValueAsString("CondString") + ")"; 79322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 79422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 79522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 79622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman return PredicateCheck; 79722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman} 79822bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 79922bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman//===----------------------------------------------------------------------===// 8006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// SDTypeConstraint implementation 8016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 8026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8036cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSDTypeConstraint::SDTypeConstraint(Record *R) { 8046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OperandNo = R->getValueAsInt("OperandNum"); 805fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("SDTCisVT")) { 8076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisVT; 8086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisVT_Info.VT = getValueType(R->getValueAsDef("VT")); 809c812261221040ac991f0c9710036a079f208281eChris Lattner if (x.SDTCisVT_Info.VT == MVT::isVoid) 81061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError(R->getLoc(), "Cannot use 'Void' as type to SDTCisVT"); 811fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisPtrTy")) { 8136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisPtrTy; 8146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisInt")) { 8156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisInt; 8166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisFP")) { 8176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisFP; 81836e3e668be0c4914660575d7cea800b0d51a4116Bob Wilson } else if (R->isSubClassOf("SDTCisVec")) { 81936e3e668be0c4914660575d7cea800b0d51a4116Bob Wilson ConstraintType = SDTCisVec; 8206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisSameAs")) { 8216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisSameAs; 8226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisSameAs_Info.OtherOperandNum = R->getValueAsInt("OtherOperandNum"); 8236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisVTSmallerThanOp")) { 8246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisVTSmallerThanOp; 825fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach x.SDTCisVTSmallerThanOp_Info.OtherOperandNum = 8266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->getValueAsInt("OtherOperandNum"); 8276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisOpSmallerThanOp")) { 8286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisOpSmallerThanOp; 829fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach x.SDTCisOpSmallerThanOp_Info.BigOperandNum = 8306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->getValueAsInt("BigOperandNum"); 831b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman } else if (R->isSubClassOf("SDTCisEltOfVec")) { 832b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman ConstraintType = SDTCisEltOfVec; 8332cacec55f947c716b058a39038889550d7e39b3cChris Lattner x.SDTCisEltOfVec_Info.OtherOperandNum = R->getValueAsInt("OtherOpNum"); 8346032269837c08a94b70b0e36f8e473c293ff5fd4David Greene } else if (R->isSubClassOf("SDTCisSubVecOfVec")) { 8356032269837c08a94b70b0e36f8e473c293ff5fd4David Greene ConstraintType = SDTCisSubVecOfVec; 8366032269837c08a94b70b0e36f8e473c293ff5fd4David Greene x.SDTCisSubVecOfVec_Info.OtherOperandNum = 8376032269837c08a94b70b0e36f8e473c293ff5fd4David Greene R->getValueAsInt("OtherOpNum"); 8386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 8391a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Unrecognized SDTypeConstraint '" << R->getName() << "'!\n"; 8406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 8416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// getOperandNum - Return the node corresponding to operand #OpNo in tree 8452e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner/// N, and the result number in ResNo. 8462e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattnerstatic TreePatternNode *getOperandNum(unsigned OpNo, TreePatternNode *N, 8472e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner const SDNodeInfo &NodeInfo, 8482e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned &ResNo) { 8492e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned NumResults = NodeInfo.getNumResults(); 8502e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner if (OpNo < NumResults) { 8512e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner ResNo = OpNo; 8522e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner return N; 8532e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner } 854fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8552e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner OpNo -= NumResults; 856fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8572e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner if (OpNo >= N->getNumChildren()) { 858fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach errs() << "Invalid operand number in type constraint " 8592e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner << (OpNo+NumResults) << " "; 8606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->dump(); 8611a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << '\n'; 8626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 8636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8652e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner return N->getChild(OpNo); 8666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ApplyTypeConstraint - Given a node in a pattern, apply this type 8696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// constraint to the nodes operands. This returns true if it makes a 87061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// change, false otherwise. If a type contradiction is found, flag an error. 8716cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N, 8726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo, 8736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern &TP) const { 87461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 87561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 87661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger 8772e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned ResNo = 0; // The result number being referenced. 8782e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner TreePatternNode *NodeToApply = getOperandNum(OperandNo, N, NodeInfo, ResNo); 879fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 8806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner switch (ConstraintType) { 8816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisVT: 8826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Operand must be a particular type. 883d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(ResNo, x.SDTCisVT_Info.VT, TP); 8842cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisPtrTy: 8856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Operand must be same as target pointer type. 886d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(ResNo, MVT::iPTR, TP); 8872cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisInt: 8882cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal integer VTs. 889d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceInteger(TP); 8902cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisFP: 8912cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal fp VTs. 892d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceFloatingPoint(TP); 8932cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisVec: 8942cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal vector VTs. 895d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceVector(TP); 8966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisSameAs: { 8972e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned OResNo = 0; 8986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OtherNode = 8992e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisSameAs_Info.OtherOperandNum, N, NodeInfo, OResNo); 900d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(OResNo, OtherNode->getExtType(ResNo),TP)| 901d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OtherNode->UpdateNodeType(ResNo,NodeToApply->getExtType(OResNo),TP); 9026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisVTSmallerThanOp: { 9046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The NodeToApply must be a leaf node that is a VT. OtherOperandNum must 9056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // have an integer type that is smaller than the VT. 9066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!NodeToApply->isLeaf() || 9073f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva !isa<DefInit>(NodeToApply->getLeafValue()) || 90805bce0beee87512e52428d4b80f5a8e79a949576David Greene !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef() 90961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger ->isSubClassOf("ValueType")) { 9106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error(N->getOperator()->getName() + " expects a VT operand!"); 91161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 91261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 913825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::SimpleValueType VT = 91405bce0beee87512e52428d4b80f5a8e79a949576David Greene getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()); 915fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 916cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner EEVT::TypeSet TypeListTmp(VT, TP); 917fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 9182e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned OResNo = 0; 9196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OtherNode = 9202e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisVTSmallerThanOp_Info.OtherOperandNum, N, NodeInfo, 9212e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner OResNo); 9222cacec55f947c716b058a39038889550d7e39b3cChris Lattner 923cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner return TypeListTmp.EnforceSmallerThan(OtherNode->getExtType(OResNo), TP); 9246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisOpSmallerThanOp: { 9262e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned BResNo = 0; 9276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *BigOperand = 9282e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisOpSmallerThanOp_Info.BigOperandNum, N, NodeInfo, 9292e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner BResNo); 930d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo). 931d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner EnforceSmallerThan(BigOperand->getExtType(BResNo), TP); 9326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 933b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman case SDTCisEltOfVec: { 9342e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned VResNo = 0; 9352cacec55f947c716b058a39038889550d7e39b3cChris Lattner TreePatternNode *VecOperand = 9362e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisEltOfVec_Info.OtherOperandNum, N, NodeInfo, 9372e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner VResNo); 938fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 93966fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // Filter vector types out of VecOperand that don't have the right element 94066fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // type. 94166fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner return VecOperand->getExtType(VResNo). 94266fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner EnforceVectorEltTypeIs(NodeToApply->getExtType(ResNo), TP); 943b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman } 9446032269837c08a94b70b0e36f8e473c293ff5fd4David Greene case SDTCisSubVecOfVec: { 9456032269837c08a94b70b0e36f8e473c293ff5fd4David Greene unsigned VResNo = 0; 9466032269837c08a94b70b0e36f8e473c293ff5fd4David Greene TreePatternNode *BigVecOperand = 9476032269837c08a94b70b0e36f8e473c293ff5fd4David Greene getOperandNum(x.SDTCisSubVecOfVec_Info.OtherOperandNum, N, NodeInfo, 9486032269837c08a94b70b0e36f8e473c293ff5fd4David Greene VResNo); 9496032269837c08a94b70b0e36f8e473c293ff5fd4David Greene 9506032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // Filter vector types out of BigVecOperand that don't have the 9516032269837c08a94b70b0e36f8e473c293ff5fd4David Greene // right subvector type. 9526032269837c08a94b70b0e36f8e473c293ff5fd4David Greene return BigVecOperand->getExtType(VResNo). 9536032269837c08a94b70b0e36f8e473c293ff5fd4David Greene EnforceVectorSubVectorTypeIs(NodeToApply->getExtType(ResNo), TP); 9546032269837c08a94b70b0e36f8e473c293ff5fd4David Greene } 955fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach } 95658bd1510a4fea29b1ea57d6a6c4038eeea0264a2David Blaikie llvm_unreachable("Invalid ConstraintType!"); 9576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 9586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9594c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen// Update the node type to match an instruction operand or result as specified 9604c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen// in the ins or outs lists on the instruction definition. Return true if the 9614c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen// type was actually changed. 9624c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesenbool TreePatternNode::UpdateNodeTypeFromInst(unsigned ResNo, 9634c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen Record *Operand, 9644c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen TreePattern &TP) { 9654c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen // The 'unknown' operand indicates that types should be inferred from the 9664c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen // context. 9674c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen if (Operand->isSubClassOf("unknown_class")) 9684c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen return false; 9694c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen 9704c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen // The Operand class specifies a type directly. 9714c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen if (Operand->isSubClassOf("Operand")) 9724c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen return UpdateNodeType(ResNo, getValueType(Operand->getValueAsDef("Type")), 9734c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen TP); 9744c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen 9754c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen // PointerLikeRegClass has a type that is determined at runtime. 9764c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen if (Operand->isSubClassOf("PointerLikeRegClass")) 9774c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen return UpdateNodeType(ResNo, MVT::iPTR, TP); 9784c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen 9794c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen // Both RegisterClass and RegisterOperand operands derive their types from a 9804c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen // register class def. 9814c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen Record *RC = 0; 9824c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen if (Operand->isSubClassOf("RegisterClass")) 9834c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen RC = Operand; 9844c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen else if (Operand->isSubClassOf("RegisterOperand")) 9854c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen RC = Operand->getValueAsDef("RegClass"); 9864c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen 9874c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen assert(RC && "Unknown operand type"); 9884c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen CodeGenTarget &Tgt = TP.getDAGPatterns().getTargetInfo(); 9894c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen return UpdateNodeType(ResNo, Tgt.getRegisterClass(RC).getValueTypes(), TP); 9904c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen} 9914c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen 9924c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen 9936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 9946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// SDNodeInfo implementation 9956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 9966cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSDNodeInfo::SDNodeInfo(Record *R) : Def(R) { 9976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner EnumName = R->getValueAsString("Opcode"); 9986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SDClassName = R->getValueAsString("SDClass"); 9996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *TypeProfile = R->getValueAsDef("TypeProfile"); 10006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NumResults = TypeProfile->getValueAsInt("NumResults"); 10016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NumOperands = TypeProfile->getValueAsInt("NumOperands"); 1002fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 10036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the properties. 10046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties = 0; 10056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> PropList = R->getValueAsListOfDefs("Properties"); 10066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = PropList.size(); i != e; ++i) { 10076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (PropList[i]->getName() == "SDNPCommutative") { 10086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPCommutative; 10096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPAssociative") { 10106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPAssociative; 10116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPHasChain") { 10126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPHasChain; 1013036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner } else if (PropList[i]->getName() == "SDNPOutGlue") { 1014036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner Properties |= 1 << SDNPOutGlue; 1015036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner } else if (PropList[i]->getName() == "SDNPInGlue") { 1016036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner Properties |= 1 << SDNPInGlue; 1017036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner } else if (PropList[i]->getName() == "SDNPOptInGlue") { 1018036609bd7d42ed1f57865969e059eb7d1eb6c392Chris Lattner Properties |= 1 << SDNPOptInGlue; 1019c8478d8b12c2d7e4cea32d0c9940f5cac2baa4ddChris Lattner } else if (PropList[i]->getName() == "SDNPMayStore") { 1020c8478d8b12c2d7e4cea32d0c9940f5cac2baa4ddChris Lattner Properties |= 1 << SDNPMayStore; 1021710e995889c71812743f3f33861c24273f4569a7Chris Lattner } else if (PropList[i]->getName() == "SDNPMayLoad") { 1022710e995889c71812743f3f33861c24273f4569a7Chris Lattner Properties |= 1 << SDNPMayLoad; 1023bc0b9f70ae072d695e0eb7ceb729b3306b0679feChris Lattner } else if (PropList[i]->getName() == "SDNPSideEffect") { 1024bc0b9f70ae072d695e0eb7ceb729b3306b0679feChris Lattner Properties |= 1 << SDNPSideEffect; 102528873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang } else if (PropList[i]->getName() == "SDNPMemOperand") { 102628873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang Properties |= 1 << SDNPMemOperand; 1027e8cabf3c2eb835f9189a39c810654d9bd302f7eeChris Lattner } else if (PropList[i]->getName() == "SDNPVariadic") { 1028e8cabf3c2eb835f9189a39c810654d9bd302f7eeChris Lattner Properties |= 1 << SDNPVariadic; 10296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 10301a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Unknown SD Node property '" << PropList[i]->getName() 10311a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar << "' on node '" << R->getName() << "'!\n"; 10326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 10336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 10346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1035fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1036fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 10376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the type constraints. 10386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> ConstraintList = 10396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TypeProfile->getValueAsListOfDefs("Constraints"); 10406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TypeConstraints.assign(ConstraintList.begin(), ConstraintList.end()); 10416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 10426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1043225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner/// getKnownType - If the type constraints on this node imply a fixed type 1044225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner/// (e.g. all stores return void, etc), then return it as an 1045aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner/// MVT::SimpleValueType. Otherwise, return EEVT::Other. 1046084df627c82fdf4e1829723edf0a833b5bc31f89Chris LattnerMVT::SimpleValueType SDNodeInfo::getKnownType(unsigned ResNo) const { 1047225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner unsigned NumResults = getNumResults(); 1048225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner assert(NumResults <= 1 && 1049225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner "We only work with nodes with zero or one result so far!"); 1050084df627c82fdf4e1829723edf0a833b5bc31f89Chris Lattner assert(ResNo == 0 && "Only handles single result nodes so far"); 1051fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1052225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner for (unsigned i = 0, e = TypeConstraints.size(); i != e; ++i) { 1053225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner // Make sure that this applies to the correct node result. 1054225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner if (TypeConstraints[i].OperandNo >= NumResults) // FIXME: need value # 1055225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner continue; 1056fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1057225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner switch (TypeConstraints[i].ConstraintType) { 1058225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner default: break; 1059225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner case SDTypeConstraint::SDTCisVT: 1060225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner return TypeConstraints[i].x.SDTCisVT_Info.VT; 1061225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner case SDTypeConstraint::SDTCisPtrTy: 1062225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner return MVT::iPTR; 1063225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner } 1064225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner } 1065aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner return MVT::Other; 1066225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner} 1067225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner 10686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 10696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// TreePatternNode implementation 10706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 10716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10726cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode::~TreePatternNode() { 10736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#if 0 // FIXME: implement refcounted tree nodes! 10746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 10756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete getChild(i); 10766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#endif 10776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 10786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1079d7349194650386d97a1d779369cb46f20ba9f252Chris Lattnerstatic unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) { 1080d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->getName() == "set" || 1081310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner Operator->getName() == "implicit") 1082d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return 0; // All return nothing. 1083fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 108493dc92e412fd06250e46951bffb6040eca9baebdChris Lattner if (Operator->isSubClassOf("Intrinsic")) 108593dc92e412fd06250e46951bffb6040eca9baebdChris Lattner return CDP.getIntrinsic(Operator).IS.RetVTs.size(); 1086fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1087d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("SDNode")) 1088d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return CDP.getSDNodeInfo(Operator).getNumResults(); 1089fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1090d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("PatFrag")) { 1091d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // If we've already parsed this pattern fragment, get it. Otherwise, handle 1092d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // the forward reference case where one pattern fragment references another 1093d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // before it is processed. 1094d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (TreePattern *PFRec = CDP.getPatternFragmentIfRead(Operator)) 1095d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return PFRec->getOnlyTree()->getNumTypes(); 1096fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1097d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // Get the result tree. 109805bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *Tree = Operator->getValueAsDag("Fragment"); 1099d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Record *Op = 0; 11003f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (Tree) 11013f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (DefInit *DI = dyn_cast<DefInit>(Tree->getOperator())) 11023f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva Op = DI->getDef(); 1103d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(Op && "Invalid Fragment"); 1104d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return GetNumNodeResults(Op, CDP); 1105d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 1106fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1107d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("Instruction")) { 1108d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CodeGenInstruction &InstInfo = CDP.getTargetInfo().getInstruction(Operator); 11090be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 11100be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: Should allow access to all the results here. 1111c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner unsigned NumDefsToAdd = InstInfo.Operands.NumDefs ? 1 : 0; 1112fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 11139414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // Add on one implicit def if it has a resolvable type. 11149414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()) !=MVT::Other) 11159414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner ++NumDefsToAdd; 11160be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner return NumDefsToAdd; 1117d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 1118fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1119d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("SDNodeXForm")) 1120d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return 1; // FIXME: Generalize SDNodeXForm 1121fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1122d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Operator->dump(); 1123d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner errs() << "Unhandled node in GetNumNodeResults\n"; 1124d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner exit(1); 1125d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner} 11266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11271a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePatternNode::print(raw_ostream &OS) const { 1128d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (isLeaf()) 11296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << *getLeafValue(); 1130d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner else 1131ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner OS << '(' << getOperator()->getName(); 1132d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1133d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1134d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OS << ':' << getExtType(i).getName(); 11356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isLeaf()) { 11376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getNumChildren() != 0) { 11386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << " "; 11396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(0)->print(OS); 11406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 1, e = getNumChildren(); i != e; ++i) { 11416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ", "; 11426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(i)->print(OS); 11436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ")"; 11466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1147fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 11480540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = PredicateFns.size(); i != e; ++i) 1149543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner OS << "<<P:" << PredicateFns[i].getFnName() << ">>"; 11506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (TransformFn) 11516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "<<X:" << TransformFn->getName() << ">>"; 11526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getName().empty()) 11536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ":$" << getName(); 11546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 11566cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePatternNode::dump() const { 11571a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar print(errs()); 11586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 11596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1160327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isIsomorphicTo - Return true if this node is recursively 1161327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isomorphic to the specified node. For this comparison, the node's 1162327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// entire state is considered. The assigned name is ignored, since 1163327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// nodes with differing names are considered isomorphic. However, if 1164327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// the assigned name is present in the dependent variable set, then 1165327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// the assigned name is considered significant and the node is 1166327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isomorphic if the names match. 1167327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michelbool TreePatternNode::isIsomorphicTo(const TreePatternNode *N, 1168327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) const { 11696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N == this) return true; 1170d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->isLeaf() != isLeaf() || getExtTypes() != N->getExtTypes() || 11710540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman getPredicateFns() != N->getPredicateFns() || 11726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getTransformFn() != N->getTransformFn()) 11736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 11746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 11766cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(getLeafValue())) { 11776cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *NDI = dyn_cast<DefInit>(N->getLeafValue())) { 117871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner return ((DI->getDef() == NDI->getDef()) 117971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner && (DepVars.find(getName()) == DepVars.end() 118071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner || getName() == N->getName())); 1181327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 1182327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 11836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return getLeafValue() == N->getLeafValue(); 11846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1185fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 11866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getOperator() != getOperator() || 11876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->getNumChildren() != getNumChildren()) return false; 11886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 1189327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (!getChild(i)->isIsomorphicTo(N->getChild(i), DepVars)) 11906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 11916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 11926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 11936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// clone - Make a copy of this tree and all of its children. 11956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 11966cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode *TreePatternNode::clone() const { 11976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *New; 11986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 1199d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(getLeafValue(), getNumTypes()); 12006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 12016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CChildren; 12026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CChildren.reserve(Children.size()); 12036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 12046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CChildren.push_back(getChild(i)->clone()); 1205d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(getOperator(), CChildren, getNumTypes()); 12066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner New->setName(getName()); 1208d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New->Types = Types; 12090540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman New->setPredicateFns(getPredicateFns()); 12106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner New->setTransformFn(getTransformFn()); 12116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return New; 12126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 12136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 121447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// RemoveAllTypes - Recursively strip all the types of this tree. 121547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnervoid TreePatternNode::RemoveAllTypes() { 1216d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1217d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Types[i] = EEVT::TypeSet(); // Reset to unknown type. 121847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (isLeaf()) return; 121947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 122047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner getChild(i)->RemoveAllTypes(); 122147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 122247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 122347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 12246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// SubstituteFormalArguments - Replace the formal arguments in this tree 12256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// with actual values specified by ArgMap. 12266cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePatternNode:: 12276cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) { 12286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return; 1229fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 12306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { 12316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = getChild(i); 12326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Child->isLeaf()) { 123305bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *Val = Child->getLeafValue(); 12343f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (isa<DefInit>(Val) && 12353f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva cast<DefInit>(Val)->getDef()->getName() == "node") { 12366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // We found a use of a formal argument, replace it with its value. 12370540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *NewChild = ArgMap[Child->getName()]; 12380540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert(NewChild && "Couldn't find formal argument!"); 12390540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert((Child->getPredicateFns().empty() || 12400540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman NewChild->getPredicateFns() == Child->getPredicateFns()) && 12410540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman "Non-empty child predicate clobbered!"); 12420540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman setChild(i, NewChild); 12436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 12456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(i)->SubstituteFormalArguments(ArgMap); 12466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 12496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// InlinePatternFragments - If this pattern refers to any pattern 12526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// fragments, inline them into place, giving us a pattern without any 12536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// PatFrag references. 12546cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode *TreePatternNode::InlinePatternFragments(TreePattern &TP) { 125561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 125650a6102397ca0b2346befeac09299f1fa6b3ca3eKaelyn Uhrain return 0; 125761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger 125861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (isLeaf()) 125961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return this; // nothing to do. 12606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Op = getOperator(); 1261fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 12626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Op->isSubClassOf("PatFrag")) { 12636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Just recursively inline children nodes. 12640540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { 12650540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *Child = getChild(i); 12660540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *NewChild = Child->InlinePatternFragments(TP); 12670540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 12680540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert((Child->getPredicateFns().empty() || 12690540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman NewChild->getPredicateFns() == Child->getPredicateFns()) && 12700540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman "Non-empty child predicate clobbered!"); 12710540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 12720540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman setChild(i, NewChild); 12730540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman } 12746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return this; 12756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, we found a reference to a fragment. First, look up its 12786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // TreePattern record. 12796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *Frag = TP.getDAGPatterns().getPatternFragment(Op); 1280fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 12816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we are passing the right number of operands. 128261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (Frag->getNumArgs() != Children.size()) { 12836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("'" + Op->getName() + "' fragment requires " + 12846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner utostr(Frag->getNumArgs()) + " operands!"); 128550a6102397ca0b2346befeac09299f1fa6b3ca3eKaelyn Uhrain return 0; 128661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 12876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *FragTree = Frag->getOnlyTree()->clone(); 12896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1290543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner TreePredicateFn PredFn(Frag); 1291543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (!PredFn.isAlwaysTrue()) 1292543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner FragTree->addPredicateFn(PredFn); 12930540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 12946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Resolve formal arguments to their actual value. 12956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Frag->getNumArgs()) { 12966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Compute the map of formal to actual arguments. 12976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> ArgMap; 12986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Frag->getNumArgs(); i != e; ++i) 12996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ArgMap[Frag->getArgName(i)] = getChild(i)->InlinePatternFragments(TP); 1300fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 13016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FragTree->SubstituteFormalArguments(ArgMap); 13026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1303fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 13046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FragTree->setName(getName()); 1305d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1306d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner FragTree->UpdateNodeType(i, getExtType(i), TP); 13070540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 13080540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman // Transfer in the old predicates. 13090540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = getPredicateFns().size(); i != e; ++i) 13100540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman FragTree->addPredicateFn(getPredicateFns()[i]); 13110540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 13126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Get a new copy of this fragment to stitch into here. 13136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner //delete this; // FIXME: implement refcounting! 1314fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 13152ca698df93421327a459987b33b045756cb47d4dChris Lattner // The fragment we inlined could have recursive inlining that is needed. See 13162ca698df93421327a459987b33b045756cb47d4dChris Lattner // if there are any pattern fragments in it and inline them as needed. 13172ca698df93421327a459987b33b045756cb47d4dChris Lattner return FragTree->InlinePatternFragments(TP); 13186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 13196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// getImplicitType - Check to see if the specified record has an implicit 1321fc4c25530412907f566519dd4d0979a6570222b3Nick Lewycky/// type which should be applied to it. This will infer the type of register 13226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// references from the register file information, for example. 13236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 13247a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen/// When Unnamed is set, return the type of a DAG operand with no name, such as 13257a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen/// the F8RC register class argument in: 13267a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen/// 13277a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen/// (COPY_TO_REGCLASS GPR:$src, F8RC) 13287a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen/// 13297a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen/// When Unnamed is false, return the type of a named DAG operand such as the 13307a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen/// GPR:$src operand above. 13317a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen/// 1332d7349194650386d97a1d779369cb46f20ba9f252Chris Lattnerstatic EEVT::TypeSet getImplicitType(Record *R, unsigned ResNo, 13337a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen bool NotRegisters, 13347a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen bool Unnamed, 13357a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen TreePattern &TP) { 1336bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson // Check to see if this is a register operand. 1337bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (R->isSubClassOf("RegisterOperand")) { 1338bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson assert(ResNo == 0 && "Regoperand ref only has one result!"); 1339bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (NotRegisters) 1340bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return EEVT::TypeSet(); // Unknown. 1341bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Record *RegClass = R->getValueAsDef("RegClass"); 1342bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 1343bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson return EEVT::TypeSet(T.getRegisterClass(RegClass).getValueTypes()); 1344bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson } 1345bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson 13462cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Check to see if this is a register or a register class. 13476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("RegisterClass")) { 1348640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Regclass ref only has one result!"); 13497a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen // An unnamed register class represents itself as an i32 immediate, for 13507a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen // example on a COPY_TO_REGCLASS instruction. 13517a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen if (Unnamed) 13527a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen return EEVT::TypeSet(MVT::i32, TP); 13537a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen 13547a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen // In a named operand, the register class provides the possible set of 13557a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen // types. 1356fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach if (NotRegisters) 13572cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 13582cacec55f947c716b058a39038889550d7e39b3cChris Lattner const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 13592cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(T.getRegisterClass(R).getValueTypes()); 1360640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1361fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1362640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("PatFrag")) { 1363640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "FIXME: PatFrag with multiple results?"); 13646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Pattern fragment types will be resolved when they are inlined. 13652cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 1366640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1367fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1368640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("Register")) { 1369640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Registers only produce one result!"); 1370fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach if (NotRegisters) 13712cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 13726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 13732cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(T.getRegisterVTs(R)); 1374640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 137573ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen 137673ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen if (R->isSubClassOf("SubRegIndex")) { 137773ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen assert(ResNo == 0 && "SubRegisterIndices only produce one result!"); 137873ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen return EEVT::TypeSet(); 137973ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen } 1380fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1381f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen if (R->isSubClassOf("ValueType")) { 1382640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "This node only has one result!"); 1383f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // An unnamed VTSDNode represents itself as an MVT::Other immediate. 1384f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // 1385f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // (sext_inreg GPR:$src, i16) 1386f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // ~~~ 1387f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen if (Unnamed) 1388f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen return EEVT::TypeSet(MVT::Other, TP); 1389f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // With a name, the ValueType simply provides the type of the named 1390f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // variable. 1391f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // 1392f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // (sext_inreg i32:$src, i16) 1393f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // ~~~~~~~~ 139419209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen if (NotRegisters) 139519209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen return EEVT::TypeSet(); // Unknown. 1396f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen return EEVT::TypeSet(getValueType(R), TP); 1397f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen } 1398f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen 1399f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen if (R->isSubClassOf("CondCode")) { 1400f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen assert(ResNo == 0 && "This node only has one result!"); 1401f0a804df493e28e75cfc4ca930c53199b8d1e985Jakob Stoklund Olesen // Using a CondCodeSDNode. 14022cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::Other, TP); 1403640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1404fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1405640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("ComplexPattern")) { 1406640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "FIXME: ComplexPattern with multiple results?"); 1407fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach if (NotRegisters) 14082cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 14092cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(TP.getDAGPatterns().getComplexPattern(R).getValueType(), 14102cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP); 1411640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1412640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("PointerLikeRegClass")) { 1413640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Regclass can only have one result!"); 14142cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::iPTR, TP); 1415640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1416fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1417640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->getName() == "node" || R->getName() == "srcvalue" || 1418640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner R->getName() == "zero_reg") { 14196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Placeholder. 14202cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 14216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1422fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Unknown node flavor used in pattern: " + R->getName()); 14242cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::Other, TP); 14256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1427e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 1428e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner/// getIntrinsicInfo - If this node corresponds to an intrinsic, return the 1429e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner/// CodeGenIntrinsic information for it, otherwise return a null pointer. 1430e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattnerconst CodeGenIntrinsic *TreePatternNode:: 1431e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris LattnergetIntrinsicInfo(const CodeGenDAGPatterns &CDP) const { 1432e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner if (getOperator() != CDP.get_intrinsic_void_sdnode() && 1433e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner getOperator() != CDP.get_intrinsic_w_chain_sdnode() && 1434e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner getOperator() != CDP.get_intrinsic_wo_chain_sdnode()) 1435e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner return 0; 1436fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14373f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva unsigned IID = cast<IntInit>(getChild(0)->getLeafValue())->getValue(); 1438e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner return &CDP.getIntrinsicInfo(IID); 1439e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner} 1440e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 144147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// getComplexPatternInfo - If this node corresponds to a ComplexPattern, 144247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// return the ComplexPattern information, otherwise return null. 144347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerconst ComplexPattern * 144447661320363a8bf0bb1401a8c1893755fb77c8f6Chris LattnerTreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const { 144547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (!isLeaf()) return 0; 1446fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 14476cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *DI = dyn_cast<DefInit>(getLeafValue()); 144847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (DI && DI->getDef()->isSubClassOf("ComplexPattern")) 144947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return &CGP.getComplexPattern(DI->getDef()); 145047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return 0; 145147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 145247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 145347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// NodeHasProperty - Return true if this node has the specified property. 145447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerbool TreePatternNode::NodeHasProperty(SDNP Property, 1455751d5aa1eadf041f00acf76f3b641549c8be3998Chris Lattner const CodeGenDAGPatterns &CGP) const { 145647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (isLeaf()) { 145747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (const ComplexPattern *CP = getComplexPatternInfo(CGP)) 145847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return CP->hasProperty(Property); 145947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return false; 146047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner } 1461fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 146247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner Record *Operator = getOperator(); 146347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (!Operator->isSubClassOf("SDNode")) return false; 1464fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 146547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return CGP.getSDNodeInfo(Operator).hasProperty(Property); 146647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 146747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 146847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 146947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 147047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 147147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// TreeHasProperty - Return true if any node in this tree has the specified 147247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// property. 147347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerbool TreePatternNode::TreeHasProperty(SDNP Property, 1474751d5aa1eadf041f00acf76f3b641549c8be3998Chris Lattner const CodeGenDAGPatterns &CGP) const { 147547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (NodeHasProperty(Property, CGP)) 147647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return true; 147747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 147847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (getChild(i)->TreeHasProperty(Property, CGP)) 147947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return true; 148047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return false; 1481fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach} 148247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 14836bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng/// isCommutativeIntrinsic - Return true if the node corresponds to a 14846bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng/// commutative intrinsic. 14856bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Chengbool 14866bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan ChengTreePatternNode::isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const { 14876bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) 14886bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng return Int->isCommutative; 14896bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng return false; 14906bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng} 14916bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng 1492e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 14936c01ca9e29816e36e96112ed541ecf3414a7aad2Bob Wilson/// ApplyTypeConstraints - Apply all of the type constraints relevant to 14946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// this node and its children in the tree. This returns true if it makes a 149561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// change, false otherwise. If a type contradiction is found, flag an error. 14966cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) { 149761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (TP.hasError()) 149861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 149961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger 1500fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &CDP = TP.getDAGPatterns(); 15016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 15026cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(getLeafValue())) { 15036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If it's a regclass or something else known, include the type. 1504d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = false; 1505d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1506d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(i, getImplicitType(DI->getDef(), i, 15077a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen NotRegisters, 15087a42fb3b6e729e2446f9d53b547976e5084a59d8Jakob Stoklund Olesen !hasName(), TP), TP); 1509d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return MadeChange; 1510523f6a5848194c135168112751c36884dc704e54Chris Lattner } 1511fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15126cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(getLeafValue())) { 1513d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(Types.size() == 1 && "Invalid IntInit"); 1514fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Int inits are always integers. :) 1516d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = Types[0].EnforceInteger(TP); 1517fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1518d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (!Types[0].isConcrete()) 15192cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 1520fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1521d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType VT = getType(0); 15222cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VT == MVT::iPTR || VT == MVT::iPTRAny) 15232cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 1524fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15252cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned Size = EVT(VT).getSizeInBits(); 15262cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Make sure that the value is representable for this type. 15272cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Size >= 32) return MadeChange; 1528fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15291144af3c9b4da48cd581156e05b24261c8de366aRichard Smith // Check that the value doesn't use more bits than we have. It must either 15301144af3c9b4da48cd581156e05b24261c8de366aRichard Smith // be a sign- or zero-extended equivalent of the original. 15311144af3c9b4da48cd581156e05b24261c8de366aRichard Smith int64_t SignBitAndAbove = II->getValue() >> (Size - 1); 15321144af3c9b4da48cd581156e05b24261c8de366aRichard Smith if (SignBitAndAbove == -1 || SignBitAndAbove == 0 || SignBitAndAbove == 1) 15332cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 1534fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15351144af3c9b4da48cd581156e05b24261c8de366aRichard Smith TP.error("Integer value '" + itostr(II->getValue()) + 1536d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "' is out of range for type '" + getEnumName(getType(0)) + "'!"); 153761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 15386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 15406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1541fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // special handling for set, which isn't really an SDNode. 15436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getOperator()->getName() == "set") { 1544d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumTypes() == 0 && "Set doesn't produce a value"); 1545d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumChildren() >= 2 && "Missing RHS of a set?"); 15466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NC = getNumChildren(); 1547fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1548d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *SetVal = getChild(NC-1); 1549d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = SetVal->ApplyTypeConstraints(TP, NotRegisters); 1550d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 15516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i < NC-1; ++i) { 1552d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Child = getChild(i); 1553d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Child->ApplyTypeConstraints(TP, NotRegisters); 1554fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Types of operands must match. 1556d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Child->UpdateNodeType(0, SetVal->getExtType(i), TP); 1557d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= SetVal->UpdateNodeType(i, Child->getExtType(0), TP); 15586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 15606eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 1561fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1562310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner if (getOperator()->getName() == "implicit") { 1563d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumTypes() == 0 && "Node doesn't produce a value"); 1564d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 15656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = false; 15666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i < getNumChildren(); ++i) 15676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange = getChild(i)->ApplyTypeConstraints(TP, NotRegisters); 15686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 15696eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 1570fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 15716eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) { 15726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = false; 157383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands 15746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the result type to the node. 1575cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling unsigned NumRetVTs = Int->IS.RetVTs.size(); 1576cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling unsigned NumParamVTs = Int->IS.ParamVTs.size(); 1577fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1578cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling for (unsigned i = 0, e = NumRetVTs; i != e; ++i) 1579d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(i, Int->IS.RetVTs[i], TP); 1580cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling 158161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (getNumChildren() != NumParamVTs + 1) { 1582e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner TP.error("Intrinsic '" + Int->Name + "' expects " + 1583d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner utostr(NumParamVTs) + " operands, not " + 1584cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling utostr(getNumChildren() - 1) + " operands!"); 158561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 158661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 15876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply type info to the intrinsic ID. 1589d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(0)->UpdateNodeType(0, MVT::iPTR, TP); 1590fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1591d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = getNumChildren()-1; i != e; ++i) { 1592d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(i+1)->ApplyTypeConstraints(TP, NotRegisters); 1593fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1594d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType OpVT = Int->IS.ParamVTs[i]; 1595d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(i+1)->getNumTypes() == 1 && "Unhandled case"); 1596d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(i+1)->UpdateNodeType(0, OpVT, TP); 15976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 15996eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 1600fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16016eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->isSubClassOf("SDNode")) { 16026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NI = CDP.getSDNodeInfo(getOperator()); 1603fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16042a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner // Check that the number of operands is sane. Negative operands -> varargs. 16052a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner if (NI.getNumOperands() >= 0 && 160661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger getNumChildren() != (unsigned)NI.getNumOperands()) { 16072a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner TP.error(getOperator()->getName() + " node requires exactly " + 16082a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner itostr(NI.getNumOperands()) + " operands!"); 160961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 161061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 1611fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = NI.ApplyTypeConstraints(this, TP); 16136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 16146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters); 1615d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return MadeChange; 16166eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 1617fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16186eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->isSubClassOf("Instruction")) { 16196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const DAGInstruction &Inst = CDP.getInstruction(getOperator()); 16206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CodeGenInstruction &InstInfo = 1621f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CDP.getTargetInfo().getInstruction(getOperator()); 1622fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16230be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner bool MadeChange = false; 16240be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 16250be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // Apply the result types to the node, these come from the things in the 16260be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // (outs) list of the instruction. 16270be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: Cap at one result so far. 1628c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner unsigned NumResultsToAdd = InstInfo.Operands.NumDefs ? 1 : 0; 16294c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen for (unsigned ResNo = 0; ResNo != NumResultsToAdd; ++ResNo) 16304c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen MadeChange |= UpdateNodeTypeFromInst(ResNo, Inst.getResult(ResNo), TP); 1631fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16320be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // If the instruction has implicit defs, we apply the first one as a result. 16330be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: This sucks, it should apply all implicit defs. 16340be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner if (!InstInfo.ImplicitDefs.empty()) { 16350be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned ResNo = NumResultsToAdd; 1636fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16379414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // FIXME: Generalize to multiple possible types and multiple possible 16389414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // ImplicitDefs. 16399414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner MVT::SimpleValueType VT = 16409414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()); 1641fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16429414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (VT != MVT::Other) 16439414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner MadeChange |= UpdateNodeType(ResNo, VT, TP); 16446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1645fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16462cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this is an INSERT_SUBREG, constrain the source and destination VTs to 16472cacec55f947c716b058a39038889550d7e39b3cChris Lattner // be the same. 16482cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (getOperator()->getName() == "INSERT_SUBREG") { 1649d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(0)->getNumTypes() == 1 && "FIXME: Unhandled"); 1650d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(0, getChild(0)->getExtType(0), TP); 1651d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(0)->UpdateNodeType(0, getExtType(0), TP); 16522cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 16536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned ChildNo = 0; 16556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Inst.getNumOperands(); i != e; ++i) { 16566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *OperandNode = Inst.getOperand(i); 1657fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the instruction expects a predicate or optional def operand, we 16596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // codegen this by setting the operand to it's default value if it has a 16606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // non-empty DefaultOps field. 16616d3d7656539188b496089a3313ed4d13759adba3Tom Stellard if (OperandNode->isSubClassOf("OperandWithDefaultOps") && 16626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !CDP.getDefaultOperand(OperandNode).DefaultOps.empty()) 16636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 1664fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we didn't run out of provided operands. 166661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (ChildNo >= getNumChildren()) { 16676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Instruction '" + getOperator()->getName() + 16686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' expects more operands than were provided."); 166961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 167061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 1671fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 16726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = getChild(ChildNo++); 16730be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned ChildResNo = 0; // Instructions always use res #0 of their op. 1674ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand 1675ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand // If the operand has sub-operands, they may be provided by distinct 1676ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand // child patterns, so attempt to match each sub-operand separately. 1677ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand if (OperandNode->isSubClassOf("Operand")) { 1678ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand DagInit *MIOpInfo = OperandNode->getValueAsDag("MIOperandInfo"); 1679ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand if (unsigned NumArgs = MIOpInfo->getNumArgs()) { 1680ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand // But don't do that if the whole operand is being provided by 1681ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand // a single ComplexPattern. 1682ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand const ComplexPattern *AM = Child->getComplexPatternInfo(CDP); 1683ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand if (!AM || AM->getNumOperands() < NumArgs) { 1684ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand // Match first sub-operand against the child we already have. 1685ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand Record *SubRec = cast<DefInit>(MIOpInfo->getArg(0))->getDef(); 1686ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand MadeChange |= 1687ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand Child->UpdateNodeTypeFromInst(ChildResNo, SubRec, TP); 1688ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand 1689ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand // And the remaining sub-operands against subsequent children. 1690ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand for (unsigned Arg = 1; Arg < NumArgs; ++Arg) { 1691ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand if (ChildNo >= getNumChildren()) { 1692ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand TP.error("Instruction '" + getOperator()->getName() + 1693ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand "' expects more operands than were provided."); 1694ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand return false; 1695ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand } 1696ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand Child = getChild(ChildNo++); 1697ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand 1698ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand SubRec = cast<DefInit>(MIOpInfo->getArg(Arg))->getDef(); 1699ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand MadeChange |= 1700ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand Child->UpdateNodeTypeFromInst(ChildResNo, SubRec, TP); 1701ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand } 1702ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand continue; 1703ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand } 1704ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand } 1705ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand } 1706ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand 1707ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand // If we didn't match by pieces above, attempt to match the whole 1708ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand // operand now. 17094c16916883c5012e14a84b186cbfee33bfb14027Jakob Stoklund Olesen MadeChange |= Child->UpdateNodeTypeFromInst(ChildResNo, OperandNode, TP); 17106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17115b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb 171261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (ChildNo != getNumChildren()) { 17136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Instruction '" + getOperator()->getName() + 17146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' was provided too many operands!"); 171561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 171661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 1717fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1718ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 1719ec8d1a5b72b1cb2d230ba52b25a017231393b182Ulrich Weigand MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters); 17206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 17216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1722fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 17236eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner assert(getOperator()->isSubClassOf("SDNodeXForm") && "Unknown node type!"); 1724fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 17256eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // Node transforms always take one operand. 172661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (getNumChildren() != 1) { 17276eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner TP.error("Node transform '" + getOperator()->getName() + 17286eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner "' requires one operand!"); 172961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return false; 173061131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger } 17316eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 17322cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = getChild(0)->ApplyTypeConstraints(TP, NotRegisters); 17332cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1734fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 17356eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // If either the output or input of the xform does not have exact 17366eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // type info. We assume they must be the same. Otherwise, it is perfectly 17376eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // legal to transform from one type to a completely different type. 17382cacec55f947c716b058a39038889550d7e39b3cChris Lattner#if 0 17396eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (!hasTypeSet() || !getChild(0)->hasTypeSet()) { 17402cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = UpdateNodeType(getChild(0)->getExtType(), TP); 17412cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= getChild(0)->UpdateNodeType(getExtType(), TP); 17426eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner return MadeChange; 17436eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 17442cacec55f947c716b058a39038889550d7e39b3cChris Lattner#endif 17452cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 17466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// OnlyOnRHSOfCommutative - Return true if this value is only allowed on the 17496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// RHS of a commutative operation, not the on LHS. 17506cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic bool OnlyOnRHSOfCommutative(TreePatternNode *N) { 17516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!N->isLeaf() && N->getOperator()->getName() == "imm") 17526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 17533f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (N->isLeaf() && isa<IntInit>(N->getLeafValue())) 17546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 17556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 17566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// canPatternMatch - If it is impossible for this pattern to match on this 17606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// target, fill in Reason and return false. Otherwise, return true. This is 1761da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach/// used as a sanity check for .td files (to prevent people from writing stuff 17626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// that can never possibly work), and to prevent the pattern permuter from 17636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// generating stuff that is useless. 1764fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbachbool TreePatternNode::canPatternMatch(std::string &Reason, 1765ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP) { 17666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return true; 17676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 17696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getChild(i)->canPatternMatch(Reason, CDP)) 17706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 17716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is an intrinsic, handle cases that would make it not match. For 17736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // example, if an operand is required to be an immediate. 17746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getOperator()->isSubClassOf("Intrinsic")) { 17756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // TODO: 17766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 17776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1778fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 17796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this node is a commutative operator, check that the LHS isn't an 17806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // immediate. 17816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(getOperator()); 17826bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool isCommIntrinsic = isCommutativeIntrinsic(CDP); 17836bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { 17846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan all of the operands of the node and make sure that only the last one 17856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // is a constant node, unless the RHS also is. 17866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OnlyOnRHSOfCommutative(getChild(getNumChildren()-1))) { 17876bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool Skip = isCommIntrinsic ? 1 : 0; // First operand is intrinsic id. 17886bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng for (unsigned i = Skip, e = getNumChildren()-1; i != e; ++i) 17896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OnlyOnRHSOfCommutative(getChild(i))) { 17906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Reason="Immediate value must be on the RHS of commutative operators!"; 17916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 17926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1795fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 17966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 17976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 18006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// TreePattern implementation 18016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 18026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 180305bce0beee87512e52428d4b80f5a8e79a949576David GreeneTreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput, 180461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp), 180561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger isInputPattern(isInput), HasError(false) { 18062cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = RawPat->getSize(); i != e; ++i) 1807c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Trees.push_back(ParseTreePattern(RawPat->getElement(i), "")); 18086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 181005bce0beee87512e52428d4b80f5a8e79a949576David GreeneTreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput, 181161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp), 181261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger isInputPattern(isInput), HasError(false) { 1813c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Trees.push_back(ParseTreePattern(Pat, "")); 18146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18166cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePattern::TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput, 181761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp), 181861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger isInputPattern(isInput), HasError(false) { 18196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Trees.push_back(Pat); 18206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 182261131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenbergervoid TreePattern::error(const std::string &Msg) { 182361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger if (HasError) 182461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger return; 18256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner dump(); 182661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintError(TheRecord->getLoc(), "In " + TheRecord->getName() + ": " + Msg); 182761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger HasError = true; 18286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18302cacec55f947c716b058a39038889550d7e39b3cChris Lattnervoid TreePattern::ComputeNamedNodes() { 18312cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) 18322cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(Trees[i]); 18332cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 18342cacec55f947c716b058a39038889550d7e39b3cChris Lattner 18352cacec55f947c716b058a39038889550d7e39b3cChris Lattnervoid TreePattern::ComputeNamedNodes(TreePatternNode *N) { 18362cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!N->getName().empty()) 18372cacec55f947c716b058a39038889550d7e39b3cChris Lattner NamedNodes[N->getName()].push_back(N); 1838fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 18392cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 18402cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(N->getChild(i)); 18412cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 18422cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1843d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 184405bce0beee87512e52428d4b80f5a8e79a949576David GreeneTreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){ 18456cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(TheInit)) { 1846c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Record *R = DI->getDef(); 1847fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1848c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Direct reference to a leaf DagNode or PatFrag? Turn it into a 184966c9ee7e6d7072a5ecc0131b9dd78a20e72cb597Jim Grosbach // TreePatternNode of its own. For example: 1850c217305f764447eb65e7bf7f9205c14632885969Chris Lattner /// (foo GPR, imm) -> (foo GPR, (imm)) 1851c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag")) 1852dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene return ParseTreePattern( 1853dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene DagInit::get(DI, "", 185405bce0beee87512e52428d4b80f5a8e79a949576David Greene std::vector<std::pair<Init*, std::string> >()), 1855dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene OpName); 1856fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1857c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Input argument? 1858c217305f764447eb65e7bf7f9205c14632885969Chris Lattner TreePatternNode *Res = new TreePatternNode(DI, 1); 18592a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner if (R->getName() == "node" && !OpName.empty()) { 1860c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (OpName.empty()) 1861c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("'node' argument requires a name to match with operand list"); 1862c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Args.push_back(OpName); 1863c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1864c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1865c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Res->setName(OpName); 1866c217305f764447eb65e7bf7f9205c14632885969Chris Lattner return Res; 1867c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1868fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 18698e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen // ?:$name or just $name. 18708e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen if (TheInit == UnsetInit::get()) { 18718e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen if (OpName.empty()) 18728e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen error("'?' argument requires a name to match with operand list"); 18738e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen TreePatternNode *Res = new TreePatternNode(TheInit, 1); 18748e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen Args.push_back(OpName); 18758e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen Res->setName(OpName); 18768e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen return Res; 18778e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen } 18788e3cb3ee0c6dd582f4ee78135cef2f33f6893395Jakob Stoklund Olesen 18796cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (IntInit *II = dyn_cast<IntInit>(TheInit)) { 1880c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!OpName.empty()) 1881c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("Constant int argument should not have a name!"); 1882c217305f764447eb65e7bf7f9205c14632885969Chris Lattner return new TreePatternNode(II, 1); 1883c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1884fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 18856cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (BitsInit *BI = dyn_cast<BitsInit>(TheInit)) { 1886c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Turn this into an IntInit. 188705bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *II = BI->convertInitializerTo(IntRecTy::get()); 18883f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (II == 0 || !isa<IntInit>(II)) 1889c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("Bits value must be constants!"); 1890b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner return ParseTreePattern(II, OpName); 1891c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1892c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 18936cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *Dag = dyn_cast<DagInit>(TheInit); 1894c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!Dag) { 1895c217305f764447eb65e7bf7f9205c14632885969Chris Lattner TheInit->dump(); 1896c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("Pattern has unexpected init kind!"); 1897c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 18986cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *OpDef = dyn_cast<DefInit>(Dag->getOperator()); 18996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OpDef) error("Pattern has unexpected operator type!"); 19006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Operator = OpDef->getDef(); 1901fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Operator->isSubClassOf("ValueType")) { 19036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the operator is a ValueType, then this must be "type cast" of a leaf 19046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // node. 19056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Dag->getNumArgs() != 1) 19066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Type cast only takes one operand!"); 1907fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1908c217305f764447eb65e7bf7f9205c14632885969Chris Lattner TreePatternNode *New = ParseTreePattern(Dag->getArg(0), Dag->getArgName(0)); 1909fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the type cast. 1911d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(New->getNumTypes() == 1 && "FIXME: Unhandled"); 1912d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New->UpdateNodeType(0, getValueType(Operator), *this); 1913fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1914c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!OpName.empty()) 1915c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("ValueType cast should not have a name!"); 19166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return New; 19176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1918fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that this is something that makes sense for an operator. 1920fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach if (!Operator->isSubClassOf("PatFrag") && 19217cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman !Operator->isSubClassOf("SDNode") && 1922fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach !Operator->isSubClassOf("Instruction") && 19236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("SDNodeXForm") && 19246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("Intrinsic") && 19256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator->getName() != "set" && 1926310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner Operator->getName() != "implicit") 19276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Unrecognized node '" + Operator->getName() + "'!"); 1928fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check to see if this is something that is illegal in an input pattern. 1930b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (isInputPattern) { 1931b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (Operator->isSubClassOf("Instruction") || 1932b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->isSubClassOf("SDNodeXForm")) 1933b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner error("Cannot use '" + Operator->getName() + "' in an input pattern!"); 1934b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner } else { 1935b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (Operator->isSubClassOf("Intrinsic")) 1936b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner error("Cannot use '" + Operator->getName() + "' in an output pattern!"); 1937fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1938b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (Operator->isSubClassOf("SDNode") && 1939b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "imm" && 1940b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "fpimm" && 1941b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tglobaltlsaddr" && 1942b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tconstpool" && 1943b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tjumptable" && 1944b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tframeindex" && 1945b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "texternalsym" && 1946b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tblockaddress" && 1947b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tglobaladdr" && 1948b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "bb" && 1949b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "vt") 1950b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner error("Cannot use '" + Operator->getName() + "' in an output pattern!"); 1951b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner } 1952fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 1954c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1955c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Parse all the operands. 1956c217305f764447eb65e7bf7f9205c14632885969Chris Lattner for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) 1957c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Children.push_back(ParseTreePattern(Dag->getArg(i), Dag->getArgName(i))); 1958fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 19596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the operator is an intrinsic, then this is just syntactic sugar for for 1960fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach // (intrinsic_* <number>, ..children..). Pick the right intrinsic node, and 19616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // convert the intrinsic name to a number. 19626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Operator->isSubClassOf("Intrinsic")) { 19636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenIntrinsic &Int = getDAGPatterns().getIntrinsic(Operator); 19646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned IID = getDAGPatterns().getIntrinsicID(Operator)+1; 19656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this intrinsic returns void, it must have side-effects and thus a 19676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // chain. 1968c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (Int.IS.RetVTs.empty()) 19696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_void_sdnode(); 1970c217305f764447eb65e7bf7f9205c14632885969Chris Lattner else if (Int.ModRef != CodeGenIntrinsic::NoMem) 19716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Has side-effects, requires chain. 19726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_w_chain_sdnode(); 1973c217305f764447eb65e7bf7f9205c14632885969Chris Lattner else // Otherwise, no chain. 19746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode(); 1975fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1976dcd35c797d458d8b1dbc36cf7f1504166d5b2f16David Greene TreePatternNode *IIDNode = new TreePatternNode(IntInit::get(IID), 1); 19776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.insert(Children.begin(), IIDNode); 19786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 1979fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1980d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner unsigned NumResults = GetNumNodeResults(Operator, CDP); 1981d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Result = new TreePatternNode(Operator, Children, NumResults); 1982c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Result->setName(OpName); 1983fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 1984c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!Dag->getName().empty()) { 1985c217305f764447eb65e7bf7f9205c14632885969Chris Lattner assert(Result->getName().empty()); 1986c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Result->setName(Dag->getName()); 1987c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 19887cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman return Result; 19896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 19906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19917a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// SimplifyTree - See if we can simplify this tree to eliminate something that 19927a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// will never match in favor of something obvious that will. This is here 19937a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// strictly as a convenience to target authors because it allows them to write 19947a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// more type generic things and have useless type casts fold away. 19957a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// 19967a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// This returns true if any change is made. 19977a0eb91b4c238542a11ca805af15933cc8290786Chris Lattnerstatic bool SimplifyTree(TreePatternNode *&N) { 19987a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner if (N->isLeaf()) 19997a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner return false; 20007a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 20017a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner // If we have a bitconvert with a resolved type and if the source and 20027a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner // destination types are the same, then the bitconvert is useless, remove it. 20037a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner if (N->getOperator()->getName() == "bitconvert" && 20047a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->getExtType(0).isConcrete() && 20057a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->getExtType(0) == N->getChild(0)->getExtType(0) && 20067a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->getName().empty()) { 20077a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N = N->getChild(0); 20087a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner SimplifyTree(N); 20097a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner return true; 20107a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner } 20117a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 20127a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner // Walk all children. 20137a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner bool MadeChange = false; 20147a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { 20157a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner TreePatternNode *Child = N->getChild(i); 20167a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner MadeChange |= SimplifyTree(Child); 20177a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->setChild(i, Child); 20187a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner } 20197a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner return MadeChange; 20207a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner} 20217a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 20227a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 20237a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 20246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// InferAllTypes - Infer/propagate as many types throughout the expression 2025da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach/// patterns as possible. Return true if all types are inferred, false 202661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger/// otherwise. Flags an error if a type contradiction is found. 20272cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool TreePattern:: 20282cacec55f947c716b058a39038889550d7e39b3cChris LattnerInferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) { 20292cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (NamedNodes.empty()) 20302cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(); 20312cacec55f947c716b058a39038889550d7e39b3cChris Lattner 20326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = true; 20336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (MadeChange) { 20346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange = false; 20357a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) { 20366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= Trees[i]->ApplyTypeConstraints(*this, false); 20377a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner MadeChange |= SimplifyTree(Trees[i]); 20387a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner } 20392cacec55f947c716b058a39038889550d7e39b3cChris Lattner 20402cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If there are constraints on our named nodes, apply them. 2041fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach for (StringMap<SmallVector<TreePatternNode*,1> >::iterator 20422cacec55f947c716b058a39038889550d7e39b3cChris Lattner I = NamedNodes.begin(), E = NamedNodes.end(); I != E; ++I) { 20432cacec55f947c716b058a39038889550d7e39b3cChris Lattner SmallVectorImpl<TreePatternNode*> &Nodes = I->second; 2044fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 20452cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we have input named node types, propagate their types to the named 20462cacec55f947c716b058a39038889550d7e39b3cChris Lattner // values here. 20472cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InNamedTypes) { 20482cacec55f947c716b058a39038889550d7e39b3cChris Lattner // FIXME: Should be error? 20492cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(InNamedTypes->count(I->getKey()) && 20502cacec55f947c716b058a39038889550d7e39b3cChris Lattner "Named node in output pattern but not input pattern?"); 20512cacec55f947c716b058a39038889550d7e39b3cChris Lattner 20522cacec55f947c716b058a39038889550d7e39b3cChris Lattner const SmallVectorImpl<TreePatternNode*> &InNodes = 20532cacec55f947c716b058a39038889550d7e39b3cChris Lattner InNamedTypes->find(I->getKey())->second; 20542cacec55f947c716b058a39038889550d7e39b3cChris Lattner 20552cacec55f947c716b058a39038889550d7e39b3cChris Lattner // The input types should be fully resolved by now. 20562cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Nodes.size(); i != e; ++i) { 20572cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this node is a register class, and it is the root of the pattern 20582cacec55f947c716b058a39038889550d7e39b3cChris Lattner // then we're mapping something onto an input register. We allow 20592cacec55f947c716b058a39038889550d7e39b3cChris Lattner // changing the type of the input register in this case. This allows 20602cacec55f947c716b058a39038889550d7e39b3cChris Lattner // us to match things like: 20612cacec55f947c716b058a39038889550d7e39b3cChris Lattner // def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>; 20622cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) { 20636cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *DI = dyn_cast<DefInit>(Nodes[i]->getLeafValue()); 2064bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || 2065bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson DI->getDef()->isSubClassOf("RegisterOperand"))) 20662cacec55f947c716b058a39038889550d7e39b3cChris Lattner continue; 20672cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 2068fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 206932f6a8b8bb9de0180036eaf7f7ac6dc030d85655Daniel Dunbar assert(Nodes[i]->getNumTypes() == 1 && 2070d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner InNodes[0]->getNumTypes() == 1 && 2071d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "FIXME: cannot name multiple result nodes yet"); 2072d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Nodes[i]->UpdateNodeType(0, InNodes[0]->getExtType(0), 2073d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner *this); 20742cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 20752cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 2076fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 20772cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If there are multiple nodes with the same name, they must all have the 20782cacec55f947c716b058a39038889550d7e39b3cChris Lattner // same type. 20792cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (I->second.size() > 1) { 20802cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Nodes.size()-1; i != e; ++i) { 2081d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *N1 = Nodes[i], *N2 = Nodes[i+1]; 208232f6a8b8bb9de0180036eaf7f7ac6dc030d85655Daniel Dunbar assert(N1->getNumTypes() == 1 && N2->getNumTypes() == 1 && 2083d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "FIXME: cannot name multiple result nodes yet"); 2084fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2085d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= N1->UpdateNodeType(0, N2->getExtType(0), *this); 2086d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= N2->UpdateNodeType(0, N1->getExtType(0), *this); 20872cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 20882cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 20892cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 20906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2091fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 20926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool HasUnresolvedTypes = false; 20936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) 20946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner HasUnresolvedTypes |= Trees[i]->ContainsUnresolvedType(); 20956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return !HasUnresolvedTypes; 20966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20981a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePattern::print(raw_ostream &OS) const { 20996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << getRecord()->getName(); 21006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Args.empty()) { 21016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "(" << Args[0]; 21026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) 21036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ", " << Args[i]; 21046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ")"; 21056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 21066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ": "; 2107fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Trees.size() > 1) 21096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "[\n"; 21106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) { 21116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "\t"; 21126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Trees[i]->print(OS); 21136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "\n"; 21146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 21156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Trees.size() > 1) 21176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "]\n"; 21186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 21196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21201a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePattern::dump() const { print(errs()); } 21216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 2123fe71893183f504feff290e343bf740bd32432129Chris Lattner// CodeGenDAGPatterns implementation 21246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 21256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2126fbadcd0826c2e69ed21c2d535310ba958acb4359Jim GrosbachCodeGenDAGPatterns::CodeGenDAGPatterns(RecordKeeper &R) : 212767db883487fca3472fdde51e931657e22d4d0495Chris Lattner Records(R), Target(R) { 212867db883487fca3472fdde51e931657e22d4d0495Chris Lattner 212949de98214b82fefeb8f16efbf8cdd8813a85469bDale Johannesen Intrinsics = LoadIntrinsics(Records, false); 213049de98214b82fefeb8f16efbf8cdd8813a85469bDale Johannesen TgtIntrinsics = LoadIntrinsics(Records, true); 21316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseNodeInfo(); 2132443e3f9dd61b8d0974bb13d484195ce1a9b7536cChris Lattner ParseNodeTransforms(); 21336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseComplexPatterns(); 2134dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner ParsePatternFragments(); 21356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseDefaultOperands(); 21366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseInstructions(); 21376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParsePatterns(); 2138fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 21396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Generate variants. For example, commutative patterns can match 21406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // multiple ways. Add them to PatternsToMatch as well. 21416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GenerateVariants(); 2142ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2143ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Infer instruction flags. For example, we can detect loads, 2144ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // stores, and side effects in many cases by examining an 2145ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // instruction's pattern. 2146ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InferInstructionFlags(); 2147325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 2148325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Verify that instruction flags match the patterns. 2149325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen VerifyInstructionFlags(); 21506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 21516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2152fe71893183f504feff290e343bf740bd32432129Chris LattnerCodeGenDAGPatterns::~CodeGenDAGPatterns() { 21535b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer for (pf_iterator I = PatternFragments.begin(), 21546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner E = PatternFragments.end(); I != E; ++I) 21556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete I->second; 21566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 21576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2159fe71893183f504feff290e343bf740bd32432129Chris LattnerRecord *CodeGenDAGPatterns::getSDNodeNamed(const std::string &Name) const { 21606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *N = Records.getDef(Name); 21616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!N || !N->isSubClassOf("SDNode")) { 21621a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Error getting SDNode '" << Name << "'!\n"; 21636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 21646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 21656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return N; 21666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 21676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// Parse all of the SDNode definitions for the target, populating SDNodes. 2169fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseNodeInfo() { 21706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("SDNode"); 21716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!Nodes.empty()) { 21726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SDNodes.insert(std::make_pair(Nodes.back(), Nodes.back())); 21736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Nodes.pop_back(); 21746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 21756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2176da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // Get the builtin intrinsic nodes. 21776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_void_sdnode = getSDNodeNamed("intrinsic_void"); 21786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_w_chain_sdnode = getSDNodeNamed("intrinsic_w_chain"); 21796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_wo_chain_sdnode = getSDNodeNamed("intrinsic_wo_chain"); 21806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 21816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParseNodeTransforms - Parse all SDNodeXForm instances into the SDNodeXForms 21836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// map, and emit them to the file as functions. 2184fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseNodeTransforms() { 21856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Xforms = Records.getAllDerivedDefinitions("SDNodeXForm"); 21866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!Xforms.empty()) { 21876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *XFormNode = Xforms.back(); 21886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *SDNode = XFormNode->getValueAsDef("Opcode"); 21898dd6f0c8353f80de6526810899f271d539f6929cJakob Stoklund Olesen std::string Code = XFormNode->getValueAsString("XFormFunction"); 2190443e3f9dd61b8d0974bb13d484195ce1a9b7536cChris Lattner SDNodeXForms.insert(std::make_pair(XFormNode, NodeXForm(SDNode, Code))); 21916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Xforms.pop_back(); 21936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 21946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 21956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2196fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseComplexPatterns() { 21976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> AMs = Records.getAllDerivedDefinitions("ComplexPattern"); 21986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!AMs.empty()) { 21996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ComplexPatterns.insert(std::make_pair(AMs.back(), AMs.back())); 22006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AMs.pop_back(); 22016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 22036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParsePatternFragments - Parse all of the PatFrag definitions in the .td 22066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// file, building up the PatternFragments map. After we've collected them all, 22076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// inline fragments together as necessary, so that there are no references left 22086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// inside a pattern fragment to a pattern fragment. 22096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 2210fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParsePatternFragments() { 22116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Fragments = Records.getAllDerivedDefinitions("PatFrag"); 2212fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2213dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // First step, parse all of the fragments. 22146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { 221505bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *Tree = Fragments[i]->getValueAsDag("Fragment"); 22166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this); 22176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternFragments[Fragments[i]] = P; 2218fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2219dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // Validate the argument list, converting it to set, to discard duplicates. 22206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::string> &Args = P->getArgList(); 2221dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner std::set<std::string> OperandsSet(Args.begin(), Args.end()); 2222fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2223dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (OperandsSet.count("")) 22246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Cannot have unnamed 'node' values in pattern fragment!"); 2225fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 22266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the operands list. 222705bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *OpsList = Fragments[i]->getValueAsDag("Operands"); 22286cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *OpsOp = dyn_cast<DefInit>(OpsList->getOperator()); 22296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Special cases: ops == outs == ins. Different names are used to 2230da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // improve readability. 22316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OpsOp || 22326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner (OpsOp->getDef()->getName() != "ops" && 22336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpsOp->getDef()->getName() != "outs" && 22346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpsOp->getDef()->getName() != "ins")) 22356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should start with '(ops ... '!"); 2236fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2237fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach // Copy over the arguments. 22386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Args.clear(); 22396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) { 22403f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (!isa<DefInit>(OpsList->getArg(j)) || 22413f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva cast<DefInit>(OpsList->getArg(j))->getDef()->getName() != "node") 22426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should all be 'node' values."); 22436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OpsList->getArgName(j).empty()) 22446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should have names for each operand!"); 2245dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!OperandsSet.count(OpsList->getArgName(j))) 22466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("'" + OpsList->getArgName(j) + 22476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' does not occur in pattern or was multiply specified!"); 2248dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner OperandsSet.erase(OpsList->getArgName(j)); 22496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Args.push_back(OpsList->getArgName(j)); 22506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2251fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2252dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!OperandsSet.empty()) 22536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list does not contain an entry for operand '" + 2254dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner *OperandsSet.begin() + "'!"); 22556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2256dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // If there is a code init for this fragment, keep track of the fact that 2257dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // this fragment uses it. 2258543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner TreePredicateFn PredFn(P); 2259543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner if (!PredFn.isAlwaysTrue()) 2260543790673c747ab2793fc657e239ce5f78419dc0Chris Lattner P->getOnlyTree()->addPredicateFn(PredFn); 2261fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 22626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If there is a node transformation corresponding to this, keep track of 22636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // it. 22646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Transform = Fragments[i]->getValueAsDef("OperandTransform"); 22656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getSDNodeTransform(Transform).second.empty()) // not noop xform? 22666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->getOnlyTree()->setTransformFn(Transform); 22676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2268fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 22696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Now that we've parsed all of the tree fragments, do a closure on them so 22706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // that there are not references to PatFrags left inside of them. 22712ca698df93421327a459987b33b045756cb47d4dChris Lattner for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { 22722ca698df93421327a459987b33b045756cb47d4dChris Lattner TreePattern *ThePat = PatternFragments[Fragments[i]]; 22736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ThePat->InlinePatternFragments(); 2274fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 22756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. Don't worry about it if we don't infer 22766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // all of them, some may depend on the inputs of the pattern. 227761131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger ThePat->InferAllTypes(); 227861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger ThePat->resetError(); 2279fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 22806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If debugging, print out the pattern fragment result. 22816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DEBUG(ThePat->dump()); 22826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 22846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2285fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseDefaultOperands() { 22866d3d7656539188b496089a3313ed4d13759adba3Tom Stellard std::vector<Record*> DefaultOps; 22876d3d7656539188b496089a3313ed4d13759adba3Tom Stellard DefaultOps = Records.getAllDerivedDefinitions("OperandWithDefaultOps"); 22886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find some SDNode. 22906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(!SDNodes.empty() && "No SDNodes parsed?"); 229105bce0beee87512e52428d4b80f5a8e79a949576David Greene Init *SomeSDNode = DefInit::get(SDNodes.begin()->first); 2292fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 22936d3d7656539188b496089a3313ed4d13759adba3Tom Stellard for (unsigned i = 0, e = DefaultOps.size(); i != e; ++i) { 22946d3d7656539188b496089a3313ed4d13759adba3Tom Stellard DagInit *DefaultInfo = DefaultOps[i]->getValueAsDag("DefaultOps"); 22956d3d7656539188b496089a3313ed4d13759adba3Tom Stellard 22966d3d7656539188b496089a3313ed4d13759adba3Tom Stellard // Clone the DefaultInfo dag node, changing the operator from 'ops' to 22976d3d7656539188b496089a3313ed4d13759adba3Tom Stellard // SomeSDnode so that we can parse this. 22986d3d7656539188b496089a3313ed4d13759adba3Tom Stellard std::vector<std::pair<Init*, std::string> > Ops; 22996d3d7656539188b496089a3313ed4d13759adba3Tom Stellard for (unsigned op = 0, e = DefaultInfo->getNumArgs(); op != e; ++op) 23006d3d7656539188b496089a3313ed4d13759adba3Tom Stellard Ops.push_back(std::make_pair(DefaultInfo->getArg(op), 23016d3d7656539188b496089a3313ed4d13759adba3Tom Stellard DefaultInfo->getArgName(op))); 23026d3d7656539188b496089a3313ed4d13759adba3Tom Stellard DagInit *DI = DagInit::get(SomeSDNode, "", Ops); 23036d3d7656539188b496089a3313ed4d13759adba3Tom Stellard 23046d3d7656539188b496089a3313ed4d13759adba3Tom Stellard // Create a TreePattern to parse this. 23056d3d7656539188b496089a3313ed4d13759adba3Tom Stellard TreePattern P(DefaultOps[i], DI, false, *this); 23066d3d7656539188b496089a3313ed4d13759adba3Tom Stellard assert(P.getNumTrees() == 1 && "This ctor can only produce one tree!"); 23076d3d7656539188b496089a3313ed4d13759adba3Tom Stellard 23086d3d7656539188b496089a3313ed4d13759adba3Tom Stellard // Copy the operands over into a DAGDefaultOperand. 23096d3d7656539188b496089a3313ed4d13759adba3Tom Stellard DAGDefaultOperand DefaultOpInfo; 23106d3d7656539188b496089a3313ed4d13759adba3Tom Stellard 23116d3d7656539188b496089a3313ed4d13759adba3Tom Stellard TreePatternNode *T = P.getTree(0); 23126d3d7656539188b496089a3313ed4d13759adba3Tom Stellard for (unsigned op = 0, e = T->getNumChildren(); op != e; ++op) { 23136d3d7656539188b496089a3313ed4d13759adba3Tom Stellard TreePatternNode *TPN = T->getChild(op); 23146d3d7656539188b496089a3313ed4d13759adba3Tom Stellard while (TPN->ApplyTypeConstraints(P, false)) 23156d3d7656539188b496089a3313ed4d13759adba3Tom Stellard /* Resolve all types */; 23166d3d7656539188b496089a3313ed4d13759adba3Tom Stellard 23176d3d7656539188b496089a3313ed4d13759adba3Tom Stellard if (TPN->ContainsUnresolvedType()) { 231861131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Value #" + utostr(i) + " of OperandWithDefaultOps '" + 231961131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger DefaultOps[i]->getName() +"' doesn't have a concrete type!"); 23206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23216d3d7656539188b496089a3313ed4d13759adba3Tom Stellard DefaultOpInfo.DefaultOps.push_back(TPN); 23226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23236d3d7656539188b496089a3313ed4d13759adba3Tom Stellard 23246d3d7656539188b496089a3313ed4d13759adba3Tom Stellard // Insert it into the DefaultOperands map so we can find it later. 23256d3d7656539188b496089a3313ed4d13759adba3Tom Stellard DefaultOperands[DefaultOps[i]] = DefaultOpInfo; 23266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 23286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// HandleUse - Given "Pat" a leaf in the pattern, check to see if it is an 23306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// instruction input. Return true if this is a real use. 23316cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic bool HandleUse(TreePattern *I, TreePatternNode *Pat, 2332acfb70f75061975deda1deb167da8e83249f92edChris Lattner std::map<std::string, TreePatternNode*> &InstInputs) { 23336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // No name -> not interesting. 23346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getName().empty()) { 23356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 23366cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *DI = dyn_cast<DefInit>(Pat->getLeafValue()); 2337bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || 2338bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson DI->getDef()->isSubClassOf("RegisterOperand"))) 23396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Input " + DI->getDef()->getName() + " must be named!"); 23406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 23426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Rec; 23456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 23466cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *DI = dyn_cast<DefInit>(Pat->getLeafValue()); 23476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!"); 23486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Rec = DI->getDef(); 23496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 23506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Rec = Pat->getOperator(); 23516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // SRCVALUE nodes are ignored. 23546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Rec->getName() == "srcvalue") 23556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 23566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *&Slot = InstInputs[Pat->getName()]; 23586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Slot) { 23596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Slot = Pat; 236053d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner return true; 236153d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner } 236253d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner Record *SlotRec; 236353d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner if (Slot->isLeaf()) { 23643f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva SlotRec = cast<DefInit>(Slot->getLeafValue())->getDef(); 23656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 236653d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner assert(Slot->getNumChildren() == 0 && "can't be a use with children!"); 236753d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner SlotRec = Slot->getOperator(); 23686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2369fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 237053d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner // Ensure that the inputs agree if we've already seen this input. 237153d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner if (Rec != SlotRec) 237253d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner I->error("All $" + Pat->getName() + " inputs must agree with each other"); 2373d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Slot->getExtTypes() != Pat->getExtTypes()) 237453d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner I->error("All $" + Pat->getName() + " inputs must agree with each other"); 23756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 23766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 23776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// FindPatternInputsAndOutputs - Scan the specified TreePatternNode (which is 23796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// part of "I", the instruction), computing the set of inputs and outputs of 23806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// the pattern. Report errors if we see anything naughty. 2381fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns:: 23826cefb77a7073057fecd721ae141140d75ce76512Chris LattnerFindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat, 23836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> &InstInputs, 23846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*>&InstResults, 23856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> &InstImpResults) { 23866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 2387acfb70f75061975deda1deb167da8e83249f92edChris Lattner bool isUse = HandleUse(I, Pat, InstInputs); 23886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isUse && Pat->getTransformFn()) 23896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function for a non-input value!"); 23906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 239184aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 2392fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 239384aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner if (Pat->getOperator()->getName() == "implicit") { 23946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { 23956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Dest = Pat->getChild(i); 23966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dest->isLeaf()) 23976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("implicitly defined value should be a register!"); 2398fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 23996cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *Val = dyn_cast<DefInit>(Dest->getLeafValue()); 24006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Val || !Val->getDef()->isSubClassOf("Register")) 24016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("implicitly defined value should be a register!"); 24026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpResults.push_back(Val->getDef()); 24036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 240584aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 2406fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 240784aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner if (Pat->getOperator()->getName() != "set") { 24086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is not a set, verify that the children nodes are not void typed, 24096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // and recurse. 24106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { 2411d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Pat->getChild(i)->getNumTypes() == 0) 24126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot have void nodes inside of patterns!"); 24136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat->getChild(i), InstInputs, InstResults, 2414acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstImpResults); 24156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2416fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 24176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is a non-leaf node with no children, treat it basically as if 24186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // it were a leaf. This handles nodes like (imm). 2419acfb70f75061975deda1deb167da8e83249f92edChris Lattner bool isUse = HandleUse(I, Pat, InstInputs); 2420fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 24216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isUse && Pat->getTransformFn()) 24226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function for a non-input value!"); 24236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 242484aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 2425fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 24266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, this is a set, validate and collect instruction results. 24276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getNumChildren() == 0) 24286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set requires operands!"); 2429fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 24306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getTransformFn()) 24316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function on a set node!"); 2432fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 24336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check the set destinations. 24346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NumDests = Pat->getNumChildren()-1; 24356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i != NumDests; ++i) { 24366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Dest = Pat->getChild(i); 24376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dest->isLeaf()) 24386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 2439fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 24406cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *Val = dyn_cast<DefInit>(Dest->getLeafValue()); 24416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Val) 24426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 24436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Val->getDef()->isSubClassOf("RegisterClass") || 244519209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen Val->getDef()->isSubClassOf("ValueType") || 2446bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson Val->getDef()->isSubClassOf("RegisterOperand") || 2447a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner Val->getDef()->isSubClassOf("PointerLikeRegClass")) { 24486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Dest->getName().empty()) 24496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination must have a name!"); 24506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InstResults.count(Dest->getName())) 24516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("cannot set '" + Dest->getName() +"' multiple times"); 24526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstResults[Dest->getName()] = Dest; 24536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (Val->getDef()->isSubClassOf("Register")) { 24546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpResults.push_back(Val->getDef()); 24556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 24566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 24576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2459fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 24606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify and collect info from the computation. 24616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat->getChild(NumDests), 2462acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstInputs, InstResults, InstImpResults); 24636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 24646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2465ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman//===----------------------------------------------------------------------===// 2466ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman// Instruction Analysis 2467ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman//===----------------------------------------------------------------------===// 2468ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2469ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanclass InstAnalyzer { 2470ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP; 2471ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanpublic: 2472912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen bool hasSideEffects; 2473912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen bool mayStore; 2474912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen bool mayLoad; 2475912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen bool isBitcast; 2476912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen bool isVariadic; 2477ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2478912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen InstAnalyzer(const CodeGenDAGPatterns &cdp) 2479912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen : CDP(cdp), hasSideEffects(false), mayStore(false), mayLoad(false), 2480912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen isBitcast(false), isVariadic(false) {} 2481912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen 2482912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen void Analyze(const TreePattern *Pat) { 2483912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // Assume only the first tree is the pattern. The others are clobber nodes. 2484912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen AnalyzeNode(Pat->getTree(0)); 2485ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2486ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 24874ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen void Analyze(const PatternToMatch *Pat) { 24884ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen AnalyzeNode(Pat->getSrcPattern()); 24894ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen } 24904ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen 2491ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanprivate: 24920f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng bool IsNodeBitcast(const TreePatternNode *N) const { 2493912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (hasSideEffects || mayLoad || mayStore || isVariadic) 24940f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 24950f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 24960f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (N->getNumChildren() != 2) 24970f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 24980f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 24990f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng const TreePatternNode *N0 = N->getChild(0); 25003f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (!N0->isLeaf() || !isa<DefInit>(N0->getLeafValue())) 25010f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 25020f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 25030f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng const TreePatternNode *N1 = N->getChild(1); 25040f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (N1->isLeaf()) 25050f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 25060f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (N1->getNumChildren() != 1 || !N1->getChild(0)->isLeaf()) 25070f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 25080f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 25090f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng const SDNodeInfo &OpInfo = CDP.getSDNodeInfo(N1->getOperator()); 25100f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (OpInfo.getNumResults() != 1 || OpInfo.getNumOperands() != 1) 25110f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return false; 25120f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng return OpInfo.getEnumName() == "ISD::BITCAST"; 25130f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng } 25140f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng 2515325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesenpublic: 2516ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman void AnalyzeNode(const TreePatternNode *N) { 2517ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (N->isLeaf()) { 25186cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(N->getLeafValue())) { 2519ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Record *LeafRec = DI->getDef(); 2520ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Handle ComplexPattern leaves. 2521ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (LeafRec->isSubClassOf("ComplexPattern")) { 2522ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const ComplexPattern &CP = CDP.getComplexPattern(LeafRec); 2523ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPMayStore)) mayStore = true; 2524ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPMayLoad)) mayLoad = true; 2525912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (CP.hasProperty(SDNPSideEffect)) hasSideEffects = true; 2526ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2527ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2528ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return; 2529ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2530ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2531ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Analyze children. 2532ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 2533ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman AnalyzeNode(N->getChild(i)); 2534ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2535ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Ignore set nodes, which are not SDNodes. 25360f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng if (N->getOperator()->getName() == "set") { 2537912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen isBitcast = IsNodeBitcast(N); 2538ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return; 25390f040a258ff6a2372fc232212b5e4189e8e7185dEvan Cheng } 2540ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2541ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Get information about the SDNode for the operator. 2542ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const SDNodeInfo &OpInfo = CDP.getSDNodeInfo(N->getOperator()); 2543ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2544ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Notice properties of the node. 2545ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPMayStore)) mayStore = true; 2546ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPMayLoad)) mayLoad = true; 2547912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (OpInfo.hasProperty(SDNPSideEffect)) hasSideEffects = true; 2548912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (OpInfo.hasProperty(SDNPVariadic)) isVariadic = true; 2549ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2550ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (const CodeGenIntrinsic *IntInfo = N->getIntrinsicInfo(CDP)) { 2551ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If this is an intrinsic, analyze it. 2552ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadArgMem) 2553ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman mayLoad = true;// These may load memory. 2554ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 25557365c091f92db5e68c98d7faedc6c34e1bbbc898Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadWriteArgMem) 2556ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman mayStore = true;// Intrinsics that can write to memory are 'mayStore'. 2557ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 25587365c091f92db5e68c98d7faedc6c34e1bbbc898Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadWriteMem) 2559ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // WriteMem intrinsics can have other strange effects. 2560912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen hasSideEffects = true; 2561ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2562ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2563ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2564ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman}; 2565ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 256691f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesenstatic bool InferFromPattern(CodeGenInstruction &InstInfo, 2567912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen const InstAnalyzer &PatInfo, 2568912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen Record *PatDef) { 256991f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen bool Error = false; 257091f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen 2571912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // Remember where InstInfo got its flags. 2572912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (InstInfo.hasUndefFlags()) 2573912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen InstInfo.InferredFrom = PatDef; 2574ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 257591f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen // Check explicitly set flags for consistency. 257691f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen if (InstInfo.hasSideEffects != PatInfo.hasSideEffects && 257791f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen !InstInfo.hasSideEffects_Unset) { 257891f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen // Allow explicitly setting hasSideEffects = 1 on instructions, even when 257991f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen // the pattern has no side effects. That could be useful for div/rem 258091f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen // instructions that may trap. 258191f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen if (!InstInfo.hasSideEffects) { 258291f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen Error = true; 258391f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen PrintError(PatDef->getLoc(), "Pattern doesn't match hasSideEffects = " + 258491f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen Twine(InstInfo.hasSideEffects)); 258591f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen } 258691f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen } 258791f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen 258891f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen if (InstInfo.mayStore != PatInfo.mayStore && !InstInfo.mayStore_Unset) { 258991f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen Error = true; 259091f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen PrintError(PatDef->getLoc(), "Pattern doesn't match mayStore = " + 259191f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen Twine(InstInfo.mayStore)); 259291f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen } 259391f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen 259491f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen if (InstInfo.mayLoad != PatInfo.mayLoad && !InstInfo.mayLoad_Unset) { 259591f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen // Allow explicitly setting mayLoad = 1, even when the pattern has no loads. 259691f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen // Some targets translate imediates to loads. 259791f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen if (!InstInfo.mayLoad) { 259891f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen Error = true; 259991f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen PrintError(PatDef->getLoc(), "Pattern doesn't match mayLoad = " + 260091f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen Twine(InstInfo.mayLoad)); 260191f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen } 260291f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen } 260391f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen 2604912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // Transfer inferred flags. 2605912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen InstInfo.hasSideEffects |= PatInfo.hasSideEffects; 2606912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen InstInfo.mayStore |= PatInfo.mayStore; 2607912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen InstInfo.mayLoad |= PatInfo.mayLoad; 2608ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2609912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // These flags are silently added without any verification. 2610912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen InstInfo.isBitcast |= PatInfo.isBitcast; 2611aaaecfce70c0aaed9225359fc56c67b59dca768eJakob Stoklund Olesen 2612aaaecfce70c0aaed9225359fc56c67b59dca768eJakob Stoklund Olesen // Don't infer isVariadic. This flag means something different on SDNodes and 2613aaaecfce70c0aaed9225359fc56c67b59dca768eJakob Stoklund Olesen // instructions. For example, a CALL SDNode is variadic because it has the 2614aaaecfce70c0aaed9225359fc56c67b59dca768eJakob Stoklund Olesen // call arguments as operands, but a CALL instruction is not variadic - it 2615aaaecfce70c0aaed9225359fc56c67b59dca768eJakob Stoklund Olesen // has argument registers as implicit, not explicit uses. 261691f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen 261791f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen return Error; 2618ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman} 2619ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2620ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach/// hasNullFragReference - Return true if the DAG has any reference to the 2621ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach/// null_frag operator. 2622ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbachstatic bool hasNullFragReference(DagInit *DI) { 26236cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DefInit *OpDef = dyn_cast<DefInit>(DI->getOperator()); 2624ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach if (!OpDef) return false; 2625ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach Record *Operator = OpDef->getDef(); 2626ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach 2627ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach // If this is the null fragment, return true. 2628ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach if (Operator->getName() == "null_frag") return true; 2629ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach // If any of the arguments reference the null fragment, return true. 2630ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach for (unsigned i = 0, e = DI->getNumArgs(); i != e; ++i) { 26316cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *Arg = dyn_cast<DagInit>(DI->getArg(i)); 2632ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach if (Arg && hasNullFragReference(Arg)) 2633ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach return true; 2634ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach } 2635ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach 2636ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach return false; 2637ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach} 2638ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach 2639ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach/// hasNullFragReference - Return true if any DAG in the list references 2640ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach/// the null_frag operator. 2641ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbachstatic bool hasNullFragReference(ListInit *LI) { 2642ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach for (unsigned i = 0, e = LI->getSize(); i != e; ++i) { 26436cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva DagInit *DI = dyn_cast<DagInit>(LI->getElement(i)); 2644ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach assert(DI && "non-dag in an instruction Pattern list?!"); 2645ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach if (hasNullFragReference(DI)) 2646ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach return true; 2647ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach } 2648ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach return false; 2649ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach} 2650ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach 26514ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen/// Get all the instructions in a tree. 26524ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesenstatic void 26534ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund OlesengetInstructionsInTree(TreePatternNode *Tree, SmallVectorImpl<Record*> &Instrs) { 26544ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen if (Tree->isLeaf()) 26554ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen return; 26564ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen if (Tree->getOperator()->isSubClassOf("Instruction")) 26574ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen Instrs.push_back(Tree->getOperator()); 26584ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen for (unsigned i = 0, e = Tree->getNumChildren(); i != e; ++i) 26594ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen getInstructionsInTree(Tree->getChild(i), Instrs); 26604ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen} 26614ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen 266219209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen/// Check the class of a pattern leaf node against the instruction operand it 266319209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen/// represents. 266419209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesenstatic bool checkOperandClass(CGIOperandList::OperandInfo &OI, 266519209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen Record *Leaf) { 266619209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen if (OI.Rec == Leaf) 266719209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen return true; 266819209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen 266919209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen // Allow direct value types to be used in instruction set patterns. 267019209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen // The type will be checked later. 267119209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen if (Leaf->isSubClassOf("ValueType")) 267219209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen return true; 267319209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen 267419209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen // Patterns can also be ComplexPattern instances. 267519209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen if (Leaf->isSubClassOf("ComplexPattern")) 267619209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen return true; 267719209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen 267819209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen return false; 267919209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen} 268019209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen 26816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParseInstructions - Parse all of the instructions, inlining and resolving 26826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// any fragments involved. This populates the Instructions list with fully 26836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// resolved instructions. 2684fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseInstructions() { 26856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction"); 2686fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Instrs.size(); i != e; ++i) { 268805bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LI = 0; 2689fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26903f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (isa<ListInit>(Instrs[i]->getValueInit("Pattern"))) 26916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner LI = Instrs[i]->getValueAsListInit("Pattern"); 2692fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 26936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If there is no pattern, only collect minimal information about the 26946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // instruction for its operand list. We have to assume that there is one 2695ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach // result, as we have no detailed info. A pattern which references the 2696ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach // null_frag operator is as-if no pattern were specified. Normally this 2697ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach // is from a multiclass expansion w/ a SDPatternOperator passed in as 2698ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach // null_frag. 2699ac915b48d8ba73a5d734be5c4a0e1d25cea93252Jim Grosbach if (!LI || LI->getSize() == 0 || hasNullFragReference(LI)) { 27006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Results; 27016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Operands; 2702fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2703f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CodeGenInstruction &InstInfo = Target.getInstruction(Instrs[i]); 27046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2705c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (InstInfo.Operands.size() != 0) { 2706c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (InstInfo.Operands.NumDefs == 0) { 27076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // These produce no results 2708c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner for (unsigned j = 0, e = InstInfo.Operands.size(); j < e; ++j) 2709c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Operands.push_back(InstInfo.Operands[j].Rec); 27106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 27116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Assume the first operand is the result. 2712c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Results.push_back(InstInfo.Operands[0].Rec); 2713fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The rest are inputs. 2715c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner for (unsigned j = 1, e = InstInfo.Operands.size(); j < e; ++j) 2716c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Operands.push_back(InstInfo.Operands[j].Rec); 27176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2719fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create and insert the instruction. 27216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> ImpResults; 2722fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach Instructions.insert(std::make_pair(Instrs[i], 272362bcec82b2762d5cdc84fe39c7d634c784ed6673Chris Lattner DAGInstruction(0, Results, Operands, ImpResults))); 27246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; // no pattern. 27256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2726fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the instruction. 27286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *I = new TreePattern(Instrs[i], LI, true, *this); 27296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 27306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->InlinePatternFragments(); 2731fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we can 27336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // never do anything with this instruction pattern: report it to the user. 27346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!I->InferAllTypes()) 27356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Could not infer all types in pattern!"); 2736fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2737fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach // InstInputs - Keep track of all of the inputs of the instruction, along 27386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // with the record they are declared as. 27396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputs; 2740fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // InstResults - Keep track of all the virtual registers that are 'set' 27426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // in the instruction, including what reg class they are. 27436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstResults; 27446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpResults; 2746fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that the top-level forms in the instruction are of void type, and 27486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // fill in the InstResults map. 27496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = I->getNumTrees(); j != e; ++j) { 27506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Pat = I->getTree(j); 2751d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Pat->getNumTypes() != 0) 27526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Top-level forms in instruction pattern should have" 27536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " void types"); 27546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find inputs and outputs, and verify the structure of the uses/defs. 27566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat, InstInputs, InstResults, 2757acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstImpResults); 27586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Now that we have inputs and outputs of the pattern, inspect the operands 27616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // list for the instruction. This determines the order that operands are 27626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // added to the machine instruction the node corresponds to. 27636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NumResults = InstResults.size(); 27646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the operands list from the (ops) list, validating it. 27666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(I->getArgList().empty() && "Args list should still be empty here!"); 2767f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CodeGenInstruction &CGI = Target.getInstruction(Instrs[i]); 27686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check that all of the results occur first in the list. 27706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Results; 2771d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Res0Node = 0; 27726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i != NumResults; ++i) { 2773c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner if (i == CGI.Operands.size()) 27746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("'" + InstResults.begin()->first + 27756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' set but does not appear in operand list!"); 2776c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner const std::string &OpName = CGI.Operands[i].Name; 2777fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check that it exists in InstResults. 27796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *RNode = InstResults[OpName]; 27806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (RNode == 0) 27816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " does not exist in operand list!"); 2782fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (i == 0) 27846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Res0Node = RNode; 27853f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva Record *R = cast<DefInit>(RNode->getLeafValue())->getDef(); 27866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R == 0) 27876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " should be a set destination: all " 27886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "outputs must occur before inputs in operand list!"); 2789fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 279019209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen if (!checkOperandClass(CGI.Operands[i], R)) 27916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " class mismatch!"); 2792fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Remember the return type. 2794c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner Results.push_back(CGI.Operands[i].Rec); 2795fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 27966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Okay, this one checks out. 27976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstResults.erase(OpName); 27986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Loop over the inputs next. Make a copy of InstInputs so we can destroy 28016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // the copy while we're checking the inputs. 28026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputsCheck(InstInputs); 28036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ResultNodeOperands; 28056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Operands; 2806c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner for (unsigned i = NumResults, e = CGI.Operands.size(); i != e; ++i) { 2807c240bb0ede0541426254d0e0dc81d891beda4b22Chris Lattner CGIOperandList::OperandInfo &Op = CGI.Operands[i]; 28086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::string &OpName = Op.Name; 28096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OpName.empty()) 28106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand #" + utostr(i) + " in operands list has no name!"); 28116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InstInputsCheck.count(OpName)) { 28136d3d7656539188b496089a3313ed4d13759adba3Tom Stellard // If this is an operand with a DefaultOps set filled in, we can ignore 28146d3d7656539188b496089a3313ed4d13759adba3Tom Stellard // this. When we codegen it, we will do so as always executed. 28156d3d7656539188b496089a3313ed4d13759adba3Tom Stellard if (Op.Rec->isSubClassOf("OperandWithDefaultOps")) { 28166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Does it have a non-empty DefaultOps field? If so, ignore this 28176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // operand. 28186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getDefaultOperand(Op.Rec).DefaultOps.empty()) 28196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 28206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + 28226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " does not appear in the instruction pattern"); 28236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *InVal = InstInputsCheck[OpName]; 28256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstInputsCheck.erase(OpName); // It occurred, remove from map. 2826fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28273f7b7f8ce0b050fc6a0100839d9c5a84198b2aedSean Silva if (InVal->isLeaf() && isa<DefInit>(InVal->getLeafValue())) { 282805bce0beee87512e52428d4b80f5a8e79a949576David Greene Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef(); 282919209960b68b194d944a28f4b0f5bb8fd6563145Jakob Stoklund Olesen if (!checkOperandClass(Op, InRec)) 28306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + "'s register class disagrees" 28316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " between the operand and pattern"); 28326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operands.push_back(Op.Rec); 2834fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Construct the result for the dest-pattern operand list. 28366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OpNode = InVal->clone(); 2837fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // No predicate is useful on the result. 28390540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman OpNode->clearPredicateFns(); 2840fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Promote the xform function to be an explicit node if set. 28426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Record *Xform = OpNode->getTransformFn()) { 28436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpNode->setTransformFn(0); 28446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 28456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(OpNode); 2846d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); 28476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2848fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ResultNodeOperands.push_back(OpNode); 28506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2851fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InstInputsCheck.empty()) 28536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Input operand $" + InstInputsCheck.begin()->first + 28546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " occurs in pattern but not in operands list!"); 28556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *ResultPattern = 2857d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner new TreePatternNode(I->getRecord(), ResultNodeOperands, 2858d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner GetNumNodeResults(I->getRecord(), *this)); 28596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy fully inferred output node type to instruction result pattern. 2860d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0; i != NumResults; ++i) 2861d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ResultPattern->setType(i, Res0Node->getExtType(i)); 28626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create and insert the instruction. 2864acfb70f75061975deda1deb167da8e83249f92edChris Lattner // FIXME: InstImpResults should not be part of DAGInstruction. 286562bcec82b2762d5cdc84fe39c7d634c784ed6673Chris Lattner DAGInstruction TheInst(I, Results, Operands, InstImpResults); 28666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Instructions.insert(std::make_pair(I->getRecord(), TheInst)); 28676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Use a temporary tree pattern to infer all types and make sure that the 28696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // constructed result is correct. This depends on the instruction already 28706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // being inserted into the Instructions map. 28716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern Temp(I->getRecord(), ResultPattern, false, *this); 28722cacec55f947c716b058a39038889550d7e39b3cChris Lattner Temp.InferAllTypes(&I->getNamedNodesMap()); 28736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction &TheInsertedInst = Instructions.find(I->getRecord())->second; 28756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TheInsertedInst.setResultPattern(Temp.getOnlyTree()); 2876fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DEBUG(I->dump()); 28786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2879fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If we can, convert the instructions to be patterns that are matched! 288190fee07298bec2e5160a599db850b9553d02377bSean Silva for (std::map<Record*, DAGInstruction, LessRecordByID>::iterator II = 28825b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer Instructions.begin(), 28836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner E = Instructions.end(); II != E; ++II) { 28846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction &TheInst = II->second; 288561131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger TreePattern *I = TheInst.getPattern(); 28866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (I == 0) continue; // No pattern. 28876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // FIXME: Assume only the first tree is the pattern. The others are clobber 28896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // nodes. 28906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Pattern = I->getTree(0); 28916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *SrcPattern; 28926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pattern->getOperator()->getName() == "set") { 28936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SrcPattern = Pattern->getChild(Pattern->getNumChildren()-1)->clone(); 28946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else{ 28956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Not a set (store or something?) 28966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SrcPattern = Pattern; 28976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2898fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 28996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Instr = II->first; 290025b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner AddPatternToMatch(I, 2901997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach PatternToMatch(Instr, 2902997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach Instr->getValueAsListInit("Predicates"), 2903967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner SrcPattern, 2904967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner TheInst.getResultPattern(), 290525b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner TheInst.getImpResults(), 2906117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Instr->getValueAsInt("AddedComplexity"), 2907117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Instr->getID())); 29086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 29106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29114ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 29124ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattnertypedef std::pair<const TreePatternNode*, unsigned> NameRecord; 29134ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 2914fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbachstatic void FindNames(const TreePatternNode *P, 2915a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner std::map<std::string, NameRecord> &Names, 291661131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger TreePattern *PatternTop) { 29174ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (!P->getName().empty()) { 29184ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner NameRecord &Rec = Names[P->getName()]; 29194ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // If this is the first instance of the name, remember the node. 29204ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (Rec.second++ == 0) 29214ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner Rec.first = P; 2922d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner else if (Rec.first->getExtTypes() != P->getExtTypes()) 2923a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner PatternTop->error("repetition of value: $" + P->getName() + 2924a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner " where different uses have different types!"); 29254ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner } 2926fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2927967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner if (!P->isLeaf()) { 2928967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) 2929a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(P->getChild(i), Names, PatternTop); 2930967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner } 2931967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner} 2932967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 293361131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenbergervoid CodeGenDAGPatterns::AddPatternToMatch(TreePattern *Pattern, 293425b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner const PatternToMatch &PTM) { 2935967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Do some sanity checking on the pattern we're about to match. 293625b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner std::string Reason; 2937eb79b545fc347142eba44a7ffd29d426da3281ecOwen Anderson if (!PTM.getSrcPattern()->canPatternMatch(Reason, *this)) { 2938eb79b545fc347142eba44a7ffd29d426da3281ecOwen Anderson PrintWarning(Pattern->getRecord()->getLoc(), 2939eb79b545fc347142eba44a7ffd29d426da3281ecOwen Anderson Twine("Pattern can never match: ") + Reason); 2940eb79b545fc347142eba44a7ffd29d426da3281ecOwen Anderson return; 2941eb79b545fc347142eba44a7ffd29d426da3281ecOwen Anderson } 2942fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2943405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner // If the source pattern's root is a complex pattern, that complex pattern 2944405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner // must specify the nodes it can potentially match. 2945405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner if (const ComplexPattern *CP = 2946405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner PTM.getSrcPattern()->getComplexPatternInfo(*this)) 2947405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner if (CP->getRootNodes().empty()) 2948405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner Pattern->error("ComplexPattern at root must specify list of opcodes it" 2949405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner " could match"); 2950fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2951fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 2952967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Find all of the named values in the input and output, ensure they have the 2953967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // same type. 29544ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner std::map<std::string, NameRecord> SrcNames, DstNames; 2955a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(PTM.getSrcPattern(), SrcNames, Pattern); 2956a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(PTM.getDstPattern(), DstNames, Pattern); 2957967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 2958967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Scan all of the named values in the destination pattern, rejecting them if 2959967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // they don't exist in the input pattern. 29604ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner for (std::map<std::string, NameRecord>::iterator 2961ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner I = DstNames.begin(), E = DstNames.end(); I != E; ++I) { 29624ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (SrcNames[I->first].first == 0) 2963967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner Pattern->error("Pattern has input without matching name in output: $" + 2964967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner I->first); 2965ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner } 2966fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 29674ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // Scan all of the named values in the source pattern, rejecting them if the 29684ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // name isn't used in the dest, and isn't used to tie two values together. 29694ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner for (std::map<std::string, NameRecord>::iterator 29704ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner I = SrcNames.begin(), E = SrcNames.end(); I != E; ++I) 29714ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (DstNames[I->first].first == 0 && SrcNames[I->first].second == 1) 29724ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner Pattern->error("Pattern has dead named input: $" + I->first); 2973fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 297425b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner PatternsToMatch.push_back(PTM); 297525b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner} 297625b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 297725b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 2978ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2979ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanvoid CodeGenDAGPatterns::InferInstructionFlags() { 2980f65027842e82027dd6e8020586a299aaa548e355Chris Lattner const std::vector<const CodeGenInstruction*> &Instructions = 2981f65027842e82027dd6e8020586a299aaa548e355Chris Lattner Target.getInstructionsByEnumValue(); 2982912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen 2983912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // First try to infer flags from the primary instruction pattern, if any. 2984912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen SmallVector<CodeGenInstruction*, 8> Revisit; 298591f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen unsigned Errors = 0; 2986b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner for (unsigned i = 0, e = Instructions.size(); i != e; ++i) { 2987b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner CodeGenInstruction &InstInfo = 2988b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner const_cast<CodeGenInstruction &>(*Instructions[i]); 2989912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen 2990912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // Treat neverHasSideEffects = 1 as the equivalent of hasSideEffects = 0. 2991912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // This flag is obsolete and will be removed. 2992912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (InstInfo.neverHasSideEffects) { 2993912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen assert(!InstInfo.hasSideEffects); 2994912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen InstInfo.hasSideEffects_Unset = false; 2995912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen } 2996912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen 2997912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // Get the primary instruction pattern. 2998912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen const TreePattern *Pattern = getInstruction(InstInfo.TheDef).getPattern(); 2999912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (!Pattern) { 3000912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (InstInfo.hasUndefFlags()) 3001912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen Revisit.push_back(&InstInfo); 3002912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen continue; 3003912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen } 3004912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen InstAnalyzer PatInfo(*this); 3005912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen PatInfo.Analyze(Pattern); 300691f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen Errors += InferFromPattern(InstInfo, PatInfo, InstInfo.TheDef); 3007912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen } 3008912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen 30094ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen // Second, look for single-instruction patterns defined outside the 30104ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen // instruction. 30114ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen for (ptm_iterator I = ptm_begin(), E = ptm_end(); I != E; ++I) { 30124ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen const PatternToMatch &PTM = *I; 30134ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen 30144ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen // We can only infer from single-instruction patterns, otherwise we won't 30154ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen // know which instruction should get the flags. 30164ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen SmallVector<Record*, 8> PatInstrs; 30174ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen getInstructionsInTree(PTM.getDstPattern(), PatInstrs); 30184ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen if (PatInstrs.size() != 1) 30194ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen continue; 30204ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen 30214ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen // Get the single instruction. 30224ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen CodeGenInstruction &InstInfo = Target.getInstruction(PatInstrs.front()); 30234ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen 30244ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen // Only infer properties from the first pattern. We'll verify the others. 30254ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen if (InstInfo.InferredFrom) 30264ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen continue; 30274ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen 30284ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen InstAnalyzer PatInfo(*this); 30294ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen PatInfo.Analyze(&PTM); 30304ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen Errors += InferFromPattern(InstInfo, PatInfo, PTM.getSrcRecord()); 30314ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen } 30324ad27eda29413d45a98912877ab2706efbc1e86eJakob Stoklund Olesen 303391f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen if (Errors) 303461131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("pattern conflicts"); 303591f8dc9baeb35d5812a797d733e689120e041fefJakob Stoklund Olesen 3036912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // Revisit instructions with undefined flags and no pattern. 3037912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (Target.guessInstructionProperties()) { 3038912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen for (unsigned i = 0, e = Revisit.size(); i != e; ++i) { 3039912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen CodeGenInstruction &InstInfo = *Revisit[i]; 3040912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (InstInfo.InferredFrom) 3041912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen continue; 3042912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // The mayLoad and mayStore flags default to false. 3043912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // Conservatively assume hasSideEffects if it wasn't explicit. 3044912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (InstInfo.hasSideEffects_Unset) 3045912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen InstInfo.hasSideEffects = true; 3046912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen } 3047912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen return; 3048912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen } 3049912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen 3050912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen // Complain about any flags that are still undefined. 3051912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen for (unsigned i = 0, e = Revisit.size(); i != e; ++i) { 3052912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen CodeGenInstruction &InstInfo = *Revisit[i]; 3053912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (InstInfo.InferredFrom) 3054912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen continue; 3055912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (InstInfo.hasSideEffects_Unset) 3056912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen PrintError(InstInfo.TheDef->getLoc(), 3057912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen "Can't infer hasSideEffects from patterns"); 3058912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (InstInfo.mayStore_Unset) 3059912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen PrintError(InstInfo.TheDef->getLoc(), 3060912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen "Can't infer mayStore from patterns"); 3061912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen if (InstInfo.mayLoad_Unset) 3062912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen PrintError(InstInfo.TheDef->getLoc(), 3063912519a72eb9ed2d8c957ae8b08d95d9e080dac8Jakob Stoklund Olesen "Can't infer mayLoad from patterns"); 3064ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 3065ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman} 3066ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 3067325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 3068325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen/// Verify instruction flags against pattern node properties. 3069325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesenvoid CodeGenDAGPatterns::VerifyInstructionFlags() { 3070325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen unsigned Errors = 0; 3071325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen for (ptm_iterator I = ptm_begin(), E = ptm_end(); I != E; ++I) { 3072325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen const PatternToMatch &PTM = *I; 3073325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen SmallVector<Record*, 8> Instrs; 3074325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen getInstructionsInTree(PTM.getDstPattern(), Instrs); 3075325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen if (Instrs.empty()) 3076325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen continue; 3077325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 3078325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Count the number of instructions with each flag set. 3079325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen unsigned NumSideEffects = 0; 3080325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen unsigned NumStores = 0; 3081325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen unsigned NumLoads = 0; 3082325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen for (unsigned i = 0, e = Instrs.size(); i != e; ++i) { 3083325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen const CodeGenInstruction &InstInfo = Target.getInstruction(Instrs[i]); 3084325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen NumSideEffects += InstInfo.hasSideEffects; 3085325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen NumStores += InstInfo.mayStore; 3086325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen NumLoads += InstInfo.mayLoad; 3087325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen } 3088325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 3089325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Analyze the source pattern. 3090325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen InstAnalyzer PatInfo(*this); 3091325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen PatInfo.Analyze(&PTM); 3092325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 3093325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Collect error messages. 3094325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen SmallVector<std::string, 4> Msgs; 3095325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 3096325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Check for missing flags in the output. 3097325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Permit extra flags for now at least. 3098325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen if (PatInfo.hasSideEffects && !NumSideEffects) 3099325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen Msgs.push_back("pattern has side effects, but hasSideEffects isn't set"); 3100325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 3101325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Don't verify store flags on instructions with side effects. At least for 3102325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // intrinsics, side effects implies mayStore. 3103325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen if (!PatInfo.hasSideEffects && PatInfo.mayStore && !NumStores) 3104325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen Msgs.push_back("pattern may store, but mayStore isn't set"); 3105325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 3106325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Similarly, mayStore implies mayLoad on intrinsics. 3107325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen if (!PatInfo.mayStore && PatInfo.mayLoad && !NumLoads) 3108325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen Msgs.push_back("pattern may load, but mayLoad isn't set"); 3109325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 3110325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Print error messages. 3111325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen if (Msgs.empty()) 3112325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen continue; 3113325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen ++Errors; 3114325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 3115325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen for (unsigned i = 0, e = Msgs.size(); i != e; ++i) 3116325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen PrintError(PTM.getSrcRecord()->getLoc(), Twine(Msgs[i]) + " on the " + 3117325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen (Instrs.size() == 1 ? 3118325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen "instruction" : "output instructions")); 3119325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen // Provide the location of the relevant instruction definitions. 3120325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen for (unsigned i = 0, e = Instrs.size(); i != e; ++i) { 3121325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen if (Instrs[i] != PTM.getSrcRecord()) 3122325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen PrintError(Instrs[i]->getLoc(), "defined here"); 3123325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen const CodeGenInstruction &InstInfo = Target.getInstruction(Instrs[i]); 3124325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen if (InstInfo.InferredFrom && 3125325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen InstInfo.InferredFrom != InstInfo.TheDef && 3126325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen InstInfo.InferredFrom != PTM.getSrcRecord()) 3127325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen PrintError(InstInfo.InferredFrom->getLoc(), "inferred from patttern"); 3128325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen } 3129325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen } 3130325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen if (Errors) 313161131ab15fd593a2e295d79fe2714e7bc21f2ec8Joerg Sonnenberger PrintFatalError("Errors in DAG patterns"); 3132325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen} 3133325907d0860f8316edcc3bb00bf7b8b04497c177Jakob Stoklund Olesen 31342cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// Given a pattern result with an unresolved type, see if we can find one 31352cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// instruction with an unresolved result type. Force this result type to an 31362cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// arbitrary element if it's possible types to converge results. 31372cacec55f947c716b058a39038889550d7e39b3cChris Lattnerstatic bool ForceArbitraryInstResultType(TreePatternNode *N, TreePattern &TP) { 31382cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (N->isLeaf()) 31392cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 3140fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 31412cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Analyze children. 31422cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 31432cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (ForceArbitraryInstResultType(N->getChild(i), TP)) 31442cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 31452cacec55f947c716b058a39038889550d7e39b3cChris Lattner 31462cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!N->getOperator()->isSubClassOf("Instruction")) 31472cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 31482cacec55f947c716b058a39038889550d7e39b3cChris Lattner 31492cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this type is already concrete or completely unknown we can't do 31502cacec55f947c716b058a39038889550d7e39b3cChris Lattner // anything. 3151d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = N->getNumTypes(); i != e; ++i) { 3152d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->getExtType(i).isCompletelyUnknown() || N->getExtType(i).isConcrete()) 3153d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner continue; 3154fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3155d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // Otherwise, force its type to the first possibility (an arbitrary choice). 3156d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->getExtType(i).MergeInTypeInfo(N->getExtType(i).getTypeList()[0], TP)) 3157d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return true; 3158d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 3159fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3160d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return false; 31612cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 31622cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3163fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParsePatterns() { 31646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Patterns = Records.getAllDerivedDefinitions("Pattern"); 31656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Patterns.size(); i != e; ++i) { 3167d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Record *CurPattern = Patterns[i]; 316805bce0beee87512e52428d4b80f5a8e79a949576David Greene DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch"); 3169d3e31218ef7ccf96b0bc7e06e2ebd279325c97feJim Grosbach 3170d3e31218ef7ccf96b0bc7e06e2ebd279325c97feJim Grosbach // If the pattern references the null_frag, there's nothing to do. 3171d3e31218ef7ccf96b0bc7e06e2ebd279325c97feJim Grosbach if (hasNullFragReference(Tree)) 3172d3e31218ef7ccf96b0bc7e06e2ebd279325c97feJim Grosbach continue; 3173d3e31218ef7ccf96b0bc7e06e2ebd279325c97feJim Grosbach 3174310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this); 31756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 31776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Pattern->InlinePatternFragments(); 3178fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 317905bce0beee87512e52428d4b80f5a8e79a949576David Greene ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs"); 31806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (LI->getSize() == 0) continue; // no pattern. 3181fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 31826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the instruction. 3183d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePattern *Result = new TreePattern(CurPattern, LI, false, *this); 3184fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 31856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 31866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->InlinePatternFragments(); 31876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 31886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Result->getNumTrees() != 1) 31896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->error("Cannot handle instructions producing instructions " 31906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "with temporaries yet!"); 3191fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 31926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool IterateInference; 31936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool InferredAllPatternTypes, InferredAllResultTypes; 31946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner do { 31956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we 31966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // can never do anything with this pattern: report it to the user. 31972cacec55f947c716b058a39038889550d7e39b3cChris Lattner InferredAllPatternTypes = 31982cacec55f947c716b058a39038889550d7e39b3cChris Lattner Pattern->InferAllTypes(&Pattern->getNamedNodesMap()); 3199fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 32006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we 32016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // can never do anything with this pattern: report it to the user. 32022cacec55f947c716b058a39038889550d7e39b3cChris Lattner InferredAllResultTypes = 32032cacec55f947c716b058a39038889550d7e39b3cChris Lattner Result->InferAllTypes(&Pattern->getNamedNodesMap()); 32046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32056c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference = false; 3206fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 32076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the type of the result to the source pattern. This helps us 32086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // resolve cases where the input type is known to be a pointer type (which 32096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // is considered resolved), but the result knows it needs to be 32- or 32106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 64-bits. Infer the other way for good measure. 3211d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = std::min(Result->getTree(0)->getNumTypes(), 3212d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Pattern->getTree(0)->getNumTypes()); 3213d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner i != e; ++i) { 32146c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference = Pattern->getTree(0)-> 3215d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner UpdateNodeType(i, Result->getTree(0)->getExtType(i), *Result); 32166c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference |= Result->getTree(0)-> 3217d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner UpdateNodeType(i, Pattern->getTree(0)->getExtType(i), *Result); 32186c6ba364931acb113973ad3e6d69736969c59299Chris Lattner } 3219fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 32202cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If our iteration has converged and the input pattern's types are fully 32212cacec55f947c716b058a39038889550d7e39b3cChris Lattner // resolved but the result pattern is not fully resolved, we may have a 32222cacec55f947c716b058a39038889550d7e39b3cChris Lattner // situation where we have two instructions in the result pattern and 32232cacec55f947c716b058a39038889550d7e39b3cChris Lattner // the instructions require a common register class, but don't care about 32242cacec55f947c716b058a39038889550d7e39b3cChris Lattner // what actual MVT is used. This is actually a bug in our modelling: 32252cacec55f947c716b058a39038889550d7e39b3cChris Lattner // output patterns should have register classes, not MVTs. 32262cacec55f947c716b058a39038889550d7e39b3cChris Lattner // 32272cacec55f947c716b058a39038889550d7e39b3cChris Lattner // In any case, to handle this, we just go through and disambiguate some 32282cacec55f947c716b058a39038889550d7e39b3cChris Lattner // arbitrary types to the result pattern's nodes. 32292cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!IterateInference && InferredAllPatternTypes && 32302cacec55f947c716b058a39038889550d7e39b3cChris Lattner !InferredAllResultTypes) 32312cacec55f947c716b058a39038889550d7e39b3cChris Lattner IterateInference = ForceArbitraryInstResultType(Result->getTree(0), 32322cacec55f947c716b058a39038889550d7e39b3cChris Lattner *Result); 32336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } while (IterateInference); 3234fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 32356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we inferred enough types that we can do something with the 32366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // pattern and result. If these fire the user has to add type casts. 32376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InferredAllPatternTypes) 32386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Pattern->error("Could not infer all types in pattern!"); 32392cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!InferredAllResultTypes) { 32402cacec55f947c716b058a39038889550d7e39b3cChris Lattner Pattern->dump(); 32416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->error("Could not infer all types in pattern result!"); 32422cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 3243fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 32446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Validate that the input pattern is correct. 32456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputs; 32466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstResults; 32476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpResults; 32486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, ee = Pattern->getNumTrees(); j != ee; ++j) 32496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(Pattern, Pattern->getTree(j), 32506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstInputs, InstResults, 3251acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstImpResults); 32526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Promote the xform function to be an explicit node if set. 32546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *DstPattern = Result->getOnlyTree(); 32556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ResultNodeOperands; 32566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned ii = 0, ee = DstPattern->getNumChildren(); ii != ee; ++ii) { 32576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OpNode = DstPattern->getChild(ii); 32586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Record *Xform = OpNode->getTransformFn()) { 32596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpNode->setTransformFn(0); 32606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 32616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(OpNode); 3262d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); 32636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 32646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ResultNodeOperands.push_back(OpNode); 32656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 32666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DstPattern = Result->getOnlyTree(); 32676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!DstPattern->isLeaf()) 32686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DstPattern = new TreePatternNode(DstPattern->getOperator(), 3269d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ResultNodeOperands, 3270d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DstPattern->getNumTypes()); 3271fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3272d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Result->getOnlyTree()->getNumTypes(); i != e; ++i) 3273d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DstPattern->setType(i, Result->getOnlyTree()->getExtType(i)); 3274fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 32756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern Temp(Result->getRecord(), DstPattern, false, *this); 32766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Temp.InferAllTypes(); 32776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3278fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 327925b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner AddPatternToMatch(Pattern, 3280997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach PatternToMatch(CurPattern, 3281997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach CurPattern->getValueAsListInit("Predicates"), 3282d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Pattern->getTree(0), 3283d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Temp.getOnlyTree(), InstImpResults, 3284d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CurPattern->getValueAsInt("AddedComplexity"), 3285d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CurPattern->getID())); 32866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 32876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 32886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 32896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// CombineChildVariants - Given a bunch of permutations of each child of the 32906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 'operator' node, put them together in all possible ways. 3291fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbachstatic void CombineChildVariants(TreePatternNode *Orig, 32926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<std::vector<TreePatternNode*> > &ChildVariants, 32936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 3294327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 3295327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 32966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Make sure that each operand has at least one variant to choose from. 32976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i) 32986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (ChildVariants[i].empty()) 32996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 3300fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 33016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The end result is an all-pairs construction of the resultant pattern. 33026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<unsigned> Idxs; 33036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Idxs.resize(ChildVariants.size()); 3304327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel bool NotDone; 3305327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel do { 3306327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel#ifndef NDEBUG 3307aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner DEBUG(if (!Idxs.empty()) { 3308aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << Orig->getOperator()->getName() << ": Idxs = [ "; 3309aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner for (unsigned i = 0; i < Idxs.size(); ++i) { 3310aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << Idxs[i] << " "; 3311aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner } 3312aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << "]\n"; 3313aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner }); 3314327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel#endif 33156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create the variant and add it to the output list. 33166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> NewChildren; 33176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i) 33186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NewChildren.push_back(ChildVariants[i][Idxs[i]]); 3319d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *R = new TreePatternNode(Orig->getOperator(), NewChildren, 3320d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Orig->getNumTypes()); 3321fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 33226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy over properties. 33236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->setName(Orig->getName()); 33240540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman R->setPredicateFns(Orig->getPredicateFns()); 33256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->setTransformFn(Orig->getTransformFn()); 3326d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Orig->getNumTypes(); i != e; ++i) 3327d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner R->setType(i, Orig->getExtType(i)); 3328fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3329327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // If this pattern cannot match, do not include it as a variant. 33306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::string ErrString; 33316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!R->canPatternMatch(ErrString, CDP)) { 33326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete R; 33336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 33346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool AlreadyExists = false; 3335fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 33366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan to see if this pattern has already been emitted. We can get 33376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // duplication due to things like commuting: 33386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (and GPRC:$a, GPRC:$b) -> (and GPRC:$b, GPRC:$a) 33396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // which are the same pattern. Ignore the dups. 33406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = OutVariants.size(); i != e; ++i) 3341327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (R->isIsomorphicTo(OutVariants[i], DepVars)) { 33426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AlreadyExists = true; 33436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 33446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 3345fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 33466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (AlreadyExists) 33476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete R; 33486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 33496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OutVariants.push_back(R); 33506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 3351fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 3352327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // Increment indices to the next permutation by incrementing the 3353327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // indicies from last index backward, e.g., generate the sequence 3354327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // [0, 0], [0, 1], [1, 0], [1, 1]. 3355327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel int IdxsIdx; 3356327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (IdxsIdx = Idxs.size() - 1; IdxsIdx >= 0; --IdxsIdx) { 3357327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (++Idxs[IdxsIdx] == ChildVariants[IdxsIdx].size()) 3358327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel Idxs[IdxsIdx] = 0; 3359327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel else 33606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 33616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 3362327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel NotDone = (IdxsIdx >= 0); 3363327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } while (NotDone); 33646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 33656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 33666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// CombineChildVariants - A helper function for binary operators. 33676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 3368fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbachstatic void CombineChildVariants(TreePatternNode *Orig, 33696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<TreePatternNode*> &LHS, 33706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<TreePatternNode*> &RHS, 33716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 3372327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 3373327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 33746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::vector<TreePatternNode*> > ChildVariants; 33756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.push_back(LHS); 33766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.push_back(RHS); 3377327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(Orig, ChildVariants, OutVariants, CDP, DepVars); 3378fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach} 33796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 33806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 33816cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void GatherChildrenOfAssociativeOpcode(TreePatternNode *N, 33826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode *> &Children) { 33836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(N->getNumChildren()==2 &&"Associative but doesn't have 2 children!"); 33846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Operator = N->getOperator(); 3385fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 33866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Only permit raw nodes. 33870540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman if (!N->getName().empty() || !N->getPredicateFns().empty() || 33886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->getTransformFn()) { 33896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N); 33906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 33916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 33926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 33936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getChild(0)->isLeaf() || N->getChild(0)->getOperator() != Operator) 33946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N->getChild(0)); 33956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 33966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N->getChild(0), Children); 33976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 33986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getChild(1)->isLeaf() || N->getChild(1)->getOperator() != Operator) 33996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N->getChild(1)); 34006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 34016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N->getChild(1), Children); 34026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 34036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 34046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// GenerateVariantsOf - Given a pattern N, generate all permutations we can of 34056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// the (potentially recursive) pattern by using algebraic laws. 34066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 34076cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void GenerateVariantsOf(TreePatternNode *N, 34086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 3409327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 3410327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 34116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // We cannot permute leaves. 34126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->isLeaf()) { 34136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OutVariants.push_back(N); 34146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 34156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 34166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 34176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Look up interesting info about the node. 34186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(N->getOperator()); 34196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3420da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // If this node is associative, re-associate. 34216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NodeInfo.hasProperty(SDNPAssociative)) { 3422fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach // Re-associate by pulling together all of the linked operators 34236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> MaximalChildren; 34246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N, MaximalChildren); 34256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 34266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Only handle child sizes of 3. Otherwise we'll end up trying too many 34276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // permutations. 34286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (MaximalChildren.size() == 3) { 34296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find the variants of all of our maximal children. 34306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> AVariants, BVariants, CVariants; 3431327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[0], AVariants, CDP, DepVars); 3432327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[1], BVariants, CDP, DepVars); 3433327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[2], CVariants, CDP, DepVars); 3434fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 34356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // There are only two ways we can permute the tree: 34366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (A op B) op C and A op (B op C) 34376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Within these forms, we can also permute A/B/C. 3438fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 34396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Generate legal pair permutations of A/B/C. 34406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ABVariants; 34416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> BAVariants; 34426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ACVariants; 34436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CAVariants; 34446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> BCVariants; 34456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CBVariants; 3446327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, BVariants, ABVariants, CDP, DepVars); 3447327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, AVariants, BAVariants, CDP, DepVars); 3448327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, CVariants, ACVariants, CDP, DepVars); 3449327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, AVariants, CAVariants, CDP, DepVars); 3450327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, CVariants, BCVariants, CDP, DepVars); 3451327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, BVariants, CBVariants, CDP, DepVars); 34526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 34536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Combine those into the result: (x op x) op x 3454327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ABVariants, CVariants, OutVariants, CDP, DepVars); 3455327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BAVariants, CVariants, OutVariants, CDP, DepVars); 3456327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ACVariants, BVariants, OutVariants, CDP, DepVars); 3457327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CAVariants, BVariants, OutVariants, CDP, DepVars); 3458327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BCVariants, AVariants, OutVariants, CDP, DepVars); 3459327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CBVariants, AVariants, OutVariants, CDP, DepVars); 34606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 34616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Combine those into the result: x op (x op x) 3462327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, ABVariants, OutVariants, CDP, DepVars); 3463327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, BAVariants, OutVariants, CDP, DepVars); 3464327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, ACVariants, OutVariants, CDP, DepVars); 3465327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, CAVariants, OutVariants, CDP, DepVars); 3466327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, BCVariants, OutVariants, CDP, DepVars); 3467327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, CBVariants, OutVariants, CDP, DepVars); 34686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 34696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 34706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 3471fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 34726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Compute permutations of all children. 34736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::vector<TreePatternNode*> > ChildVariants; 34746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.resize(N->getNumChildren()); 34756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 3476327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(N->getChild(i), ChildVariants[i], CDP, DepVars); 34776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 34786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Build all permutations based on how the children were formed. 3479327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ChildVariants, OutVariants, CDP, DepVars); 34806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 34816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this node is commutative, consider the commuted order. 34826bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool isCommIntrinsic = N->isCommutativeIntrinsic(CDP); 34836bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { 34846bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng assert((N->getNumChildren()==2 || isCommIntrinsic) && 34856bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng "Commutative but doesn't have 2 children!"); 34866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Don't count children which are actually register references. 34876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NC = 0; 34886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { 34896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = N->getChild(i); 34906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Child->isLeaf()) 34916cfc806a6b82b60a3e923b6b89f2b4da62cdb50bSean Silva if (DefInit *DI = dyn_cast<DefInit>(Child->getLeafValue())) { 34926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *RR = DI->getDef(); 34936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (RR->isSubClassOf("Register")) 34946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 34956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 34966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NC++; 34976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 34986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Consider the commuted order. 34996bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (isCommIntrinsic) { 35006bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // Commutative intrinsic. First operand is the intrinsic id, 2nd and 3rd 35016bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // operands are the commutative operands, and there might be more operands 35026bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // after those. 35036bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng assert(NC >= 3 && 35046bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng "Commutative intrinsic should have at least 3 childrean!"); 35056bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng std::vector<std::vector<TreePatternNode*> > Variants; 35066bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[0]); // Intrinsic id. 35076bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[2]); 35086bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[1]); 35096bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng for (unsigned i = 3; i != NC; ++i) 35106bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[i]); 35116bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng CombineChildVariants(N, Variants, OutVariants, CDP, DepVars); 35126bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng } else if (NC == 2) 35136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CombineChildVariants(N, ChildVariants[1], ChildVariants[0], 3514327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel OutVariants, CDP, DepVars); 35156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 35166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 35176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 35186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 35196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// GenerateVariants - Generate variants. For example, commutative patterns can 35206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// match multiple ways. Add them to PatternsToMatch as well. 3521fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::GenerateVariants() { 3522569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "Generating instruction variants.\n"); 3523fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 35246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Loop over all of the patterns we've collected, checking to see if we can 35256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // generate variants of the instruction, through the exploitation of 3526da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // identities. This permits the target to provide aggressive matching without 35276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // the .td file having to contain tons of variants of instructions. 35286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 35296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Note that this loop adds new patterns to the PatternsToMatch list, but we 35306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // intentionally do not reconsider these. Any variants of added patterns have 35316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // already been added. 35326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 35336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = PatternsToMatch.size(); i != e; ++i) { 3534327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel MultipleUseVarSet DepVars; 35356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Variants; 3536327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVars(PatternsToMatch[i].getSrcPattern(), DepVars); 3537569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "Dependent/multiply used variables: "); 3538327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DEBUG(DumpDepVars(DepVars)); 3539569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "\n"); 3540bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach GenerateVariantsOf(PatternsToMatch[i].getSrcPattern(), Variants, *this, 3541bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach DepVars); 35426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 35436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(!Variants.empty() && "Must create at least original variant!"); 35446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Variants.erase(Variants.begin()); // Remove the original pattern. 35456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 35466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Variants.empty()) // No variants for this pattern. 35476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 35486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3549569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "FOUND VARIANTS OF: "; 3550569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner PatternsToMatch[i].getSrcPattern()->dump(); 3551569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner errs() << "\n"); 35526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 35536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned v = 0, e = Variants.size(); v != e; ++v) { 35546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Variant = Variants[v]; 35556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3556569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << " VAR#" << v << ": "; 3557569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner Variant->dump(); 3558569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner errs() << "\n"); 3559fbadcd0826c2e69ed21c2d535310ba958acb4359Jim Grosbach 35606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan to see if an instruction or explicit pattern already matches this. 35616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool AlreadyExists = false; 35626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned p = 0, e = PatternsToMatch.size(); p != e; ++p) { 3563c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng // Skip if the top level predicates do not match. 3564c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng if (PatternsToMatch[i].getPredicates() != 3565c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng PatternsToMatch[p].getPredicates()) 3566c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng continue; 35676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check to see if this variant already exists. 3568bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach if (Variant->isIsomorphicTo(PatternsToMatch[p].getSrcPattern(), 3569bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach DepVars)) { 3570569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << " *** ALREADY EXISTS, ignoring variant.\n"); 35716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AlreadyExists = true; 35726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 35736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 35746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 35756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If we already have it, ignore the variant. 35766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (AlreadyExists) continue; 35776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 35786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, add it to the list of patterns we have. 35796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternsToMatch. 3580997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach push_back(PatternToMatch(PatternsToMatch[i].getSrcRecord(), 3581997759ac22dc1de6f324b1c09c0a2a558236c489Jim Grosbach PatternsToMatch[i].getPredicates(), 35826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Variant, PatternsToMatch[i].getDstPattern(), 35836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternsToMatch[i].getDstRegs(), 3584117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner PatternsToMatch[i].getAddedComplexity(), 3585117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Record::getNewUID())); 35866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 35876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3588569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "\n"); 35896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 35906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 3591