CodeGenDAGPatterns.cpp revision bb16824dc3e2ba660e8b79f49046c418aa8e1be7
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" 166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#include "Record.h" 176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#include "llvm/ADT/StringExtras.h" 182cacec55f947c716b058a39038889550d7e39b3cChris Lattner#include "llvm/ADT/STLExtras.h" 196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#include "llvm/Support/Debug.h" 206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#include <set> 219a79de3d091978cfee5264ee2563fc5dedd33cb7Chuck Rose III#include <algorithm> 226cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerusing namespace llvm; 236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 252cacec55f947c716b058a39038889550d7e39b3cChris Lattner// EEVT::TypeSet Implementation 262cacec55f947c716b058a39038889550d7e39b3cChris Lattner//===----------------------------------------------------------------------===// 276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonstatic inline bool isInteger(MVT::SimpleValueType VT) { 29e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson return EVT(VT).isInteger(); 3083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands} 31825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonstatic inline bool isFloatingPoint(MVT::SimpleValueType VT) { 32e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson return EVT(VT).isFloatingPoint(); 3383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands} 34825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonstatic inline bool isVector(MVT::SimpleValueType VT) { 35e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson return EVT(VT).isVector(); 3683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands} 37774ce29399364823dba62217ebf7bc8701005140Chris Lattnerstatic inline bool isScalar(MVT::SimpleValueType VT) { 38774ce29399364823dba62217ebf7bc8701005140Chris Lattner return !EVT(VT).isVector(); 39774ce29399364823dba62217ebf7bc8701005140Chris Lattner} 4083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands 412cacec55f947c716b058a39038889550d7e39b3cChris LattnerEEVT::TypeSet::TypeSet(MVT::SimpleValueType VT, TreePattern &TP) { 422cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VT == MVT::iAny) 432cacec55f947c716b058a39038889550d7e39b3cChris Lattner EnforceInteger(TP); 442cacec55f947c716b058a39038889550d7e39b3cChris Lattner else if (VT == MVT::fAny) 452cacec55f947c716b058a39038889550d7e39b3cChris Lattner EnforceFloatingPoint(TP); 462cacec55f947c716b058a39038889550d7e39b3cChris Lattner else if (VT == MVT::vAny) 472cacec55f947c716b058a39038889550d7e39b3cChris Lattner EnforceVector(TP); 482cacec55f947c716b058a39038889550d7e39b3cChris Lattner else { 492cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert((VT < MVT::LAST_VALUETYPE || VT == MVT::iPTR || 502cacec55f947c716b058a39038889550d7e39b3cChris Lattner VT == MVT::iPTRAny) && "Not a concrete type!"); 512cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.push_back(VT); 522cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 552cacec55f947c716b058a39038889550d7e39b3cChris Lattner 562cacec55f947c716b058a39038889550d7e39b3cChris LattnerEEVT::TypeSet::TypeSet(const std::vector<MVT::SimpleValueType> &VTList) { 572cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(!VTList.empty() && "empty list?"); 582cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.append(VTList.begin(), VTList.end()); 592cacec55f947c716b058a39038889550d7e39b3cChris Lattner 602cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!VTList.empty()) 612cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(VTList[0] != MVT::iAny && VTList[0] != MVT::vAny && 622cacec55f947c716b058a39038889550d7e39b3cChris Lattner VTList[0] != MVT::fAny); 632cacec55f947c716b058a39038889550d7e39b3cChris Lattner 640d7952ed5ac10b6159d0e8e2449f0f471d117e0fChris Lattner // Verify no duplicates. 652cacec55f947c716b058a39038889550d7e39b3cChris Lattner array_pod_sort(TypeVec.begin(), TypeVec.end()); 660d7952ed5ac10b6159d0e8e2449f0f471d117e0fChris Lattner assert(std::unique(TypeVec.begin(), TypeVec.end()) == TypeVec.end()); 676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 695a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner/// FillWithPossibleTypes - Set to all legal types and return true, only valid 705a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner/// on completely unknown type sets. 71774ce29399364823dba62217ebf7bc8701005140Chris Lattnerbool EEVT::TypeSet::FillWithPossibleTypes(TreePattern &TP, 72774ce29399364823dba62217ebf7bc8701005140Chris Lattner bool (*Pred)(MVT::SimpleValueType), 73774ce29399364823dba62217ebf7bc8701005140Chris Lattner const char *PredicateName) { 745a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner assert(isCompletelyUnknown()); 75774ce29399364823dba62217ebf7bc8701005140Chris Lattner const std::vector<MVT::SimpleValueType> &LegalTypes = 76774ce29399364823dba62217ebf7bc8701005140Chris Lattner TP.getDAGPatterns().getTargetInfo().getLegalValueTypes(); 77774ce29399364823dba62217ebf7bc8701005140Chris Lattner 78774ce29399364823dba62217ebf7bc8701005140Chris Lattner for (unsigned i = 0, e = LegalTypes.size(); i != e; ++i) 79774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (Pred == 0 || Pred(LegalTypes[i])) 80774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeVec.push_back(LegalTypes[i]); 81774ce29399364823dba62217ebf7bc8701005140Chris Lattner 82774ce29399364823dba62217ebf7bc8701005140Chris Lattner // If we have nothing that matches the predicate, bail out. 83774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (TypeVec.empty()) 84774ce29399364823dba62217ebf7bc8701005140Chris Lattner TP.error("Type inference contradiction found, no " + 85774ce29399364823dba62217ebf7bc8701005140Chris Lattner std::string(PredicateName) + " types found"); 86774ce29399364823dba62217ebf7bc8701005140Chris Lattner // No need to sort with one element. 87774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (TypeVec.size() == 1) return true; 88774ce29399364823dba62217ebf7bc8701005140Chris Lattner 89774ce29399364823dba62217ebf7bc8701005140Chris Lattner // Remove duplicates. 90774ce29399364823dba62217ebf7bc8701005140Chris Lattner array_pod_sort(TypeVec.begin(), TypeVec.end()); 91774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeVec.erase(std::unique(TypeVec.begin(), TypeVec.end()), TypeVec.end()); 92774ce29399364823dba62217ebf7bc8701005140Chris Lattner 935a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner return true; 945a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner} 952cacec55f947c716b058a39038889550d7e39b3cChris Lattner 962cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// hasIntegerTypes - Return true if this TypeSet contains iAny or an 972cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// integer value type. 982cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::hasIntegerTypes() const { 992cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 1002cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isInteger(TypeVec[i])) 1012cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1022cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 1032cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 1042cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1052cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// hasFloatingPointTypes - Return true if this TypeSet contains an fAny or 1062cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// a floating point value type. 1072cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::hasFloatingPointTypes() const { 1082cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 1092cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isFloatingPoint(TypeVec[i])) 1102cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1112cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 1122cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 1132cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1142cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// hasVectorTypes - Return true if this TypeSet contains a vAny or a vector 1152cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// value type. 1162cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::hasVectorTypes() const { 1172cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) 1182cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isVector(TypeVec[i])) 1192cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1202cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 1216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 12261fc4cf7aa0b87ceab62082cee8ef5ce3f574ffcBob Wilson 1232cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1242cacec55f947c716b058a39038889550d7e39b3cChris Lattnerstd::string EEVT::TypeSet::getName() const { 125aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner if (TypeVec.empty()) return "<empty>"; 1262cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1272cacec55f947c716b058a39038889550d7e39b3cChris Lattner std::string Result; 1282cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1292cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) { 1302cacec55f947c716b058a39038889550d7e39b3cChris Lattner std::string VTName = llvm::getEnumName(TypeVec[i]); 1312cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Strip off MVT:: prefix if present. 1322cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VTName.substr(0,5) == "MVT::") 1332cacec55f947c716b058a39038889550d7e39b3cChris Lattner VTName = VTName.substr(5); 1342cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (i) Result += ':'; 1352cacec55f947c716b058a39038889550d7e39b3cChris Lattner Result += VTName; 1362cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1372cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1382cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.size() == 1) 1392cacec55f947c716b058a39038889550d7e39b3cChris Lattner return Result; 1402cacec55f947c716b058a39038889550d7e39b3cChris Lattner return "{" + Result + "}"; 14161fc4cf7aa0b87ceab62082cee8ef5ce3f574ffcBob Wilson} 1422cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1432cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// MergeInTypeInfo - This merges in type information from the specified 1442cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// argument. If 'this' changes, it returns true. If the two types are 1452cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// contradictory (e.g. merge f32 into i32) then this throws an exception. 1462cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::MergeInTypeInfo(const EEVT::TypeSet &InVT, TreePattern &TP){ 1472cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InVT.isCompletelyUnknown() || *this == InVT) 1482cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 1492cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1502cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (isCompletelyUnknown()) { 1512cacec55f947c716b058a39038889550d7e39b3cChris Lattner *this = InVT; 1522cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1532cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1542cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1552cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(TypeVec.size() >= 1 && InVT.TypeVec.size() >= 1 && "No unknowns"); 1562cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1572cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Handle the abstract cases, seeing if we can resolve them better. 1582cacec55f947c716b058a39038889550d7e39b3cChris Lattner switch (TypeVec[0]) { 1592cacec55f947c716b058a39038889550d7e39b3cChris Lattner default: break; 1602cacec55f947c716b058a39038889550d7e39b3cChris Lattner case MVT::iPTR: 1612cacec55f947c716b058a39038889550d7e39b3cChris Lattner case MVT::iPTRAny: 1622cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InVT.hasIntegerTypes()) { 1632cacec55f947c716b058a39038889550d7e39b3cChris Lattner EEVT::TypeSet InCopy(InVT); 1642cacec55f947c716b058a39038889550d7e39b3cChris Lattner InCopy.EnforceInteger(TP); 1652cacec55f947c716b058a39038889550d7e39b3cChris Lattner InCopy.EnforceScalar(TP); 1662cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1672cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InCopy.isConcrete()) { 1682cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If the RHS has one integer type, upgrade iPTR to i32. 1692cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec[0] = InVT.TypeVec[0]; 1702cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 1712cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1722cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1732cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If the input has multiple scalar integers, this doesn't add any info. 1742cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!InCopy.isCompletelyUnknown()) 1752cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 1762cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1772cacec55f947c716b058a39038889550d7e39b3cChris Lattner break; 1782cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1792cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1802cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If the input constraint is iAny/iPTR and this is an integer type list, 1812cacec55f947c716b058a39038889550d7e39b3cChris Lattner // remove non-integer types from the list. 1822cacec55f947c716b058a39038889550d7e39b3cChris Lattner if ((InVT.TypeVec[0] == MVT::iPTR || InVT.TypeVec[0] == MVT::iPTRAny) && 1832cacec55f947c716b058a39038889550d7e39b3cChris Lattner hasIntegerTypes()) { 1842cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = EnforceInteger(TP); 1852cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1862cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we're merging in iPTR/iPTRAny and the node currently has a list of 1872cacec55f947c716b058a39038889550d7e39b3cChris Lattner // multiple different integer types, replace them with a single iPTR. 1882cacec55f947c716b058a39038889550d7e39b3cChris Lattner if ((InVT.TypeVec[0] == MVT::iPTR || InVT.TypeVec[0] == MVT::iPTRAny) && 1892cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.size() != 1) { 1902cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.resize(1); 1912cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec[0] = InVT.TypeVec[0]; 1922cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange = true; 1932cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1942cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1952cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 1962cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1972cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1982cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this is a type list and the RHS is a typelist as well, eliminate entries 1992cacec55f947c716b058a39038889550d7e39b3cChris Lattner // from this list that aren't in the other one. 2002cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = false; 2012cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeSet InputSet(*this); 2022cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2032cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) { 2042cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool InInVT = false; 2052cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned j = 0, e = InVT.TypeVec.size(); j != e; ++j) 2062cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec[i] == InVT.TypeVec[j]) { 2072cacec55f947c716b058a39038889550d7e39b3cChris Lattner InInVT = true; 2082cacec55f947c716b058a39038889550d7e39b3cChris Lattner break; 2092cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 2102cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2112cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InInVT) continue; 2122cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 2132cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange = true; 2142cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 2152cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2162cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we removed all of our types, we have a type contradiction. 2172cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!TypeVec.empty()) 2182cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 2192cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2202cacec55f947c716b058a39038889550d7e39b3cChris Lattner // FIXME: Really want an SMLoc here! 2212cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, merging '" + 2222cacec55f947c716b058a39038889550d7e39b3cChris Lattner InVT.getName() + "' into '" + InputSet.getName() + "'"); 2232cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; // unreachable 2242cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2252cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2262cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceInteger - Remove all non-integer types from this set. 2272cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceInteger(TreePattern &TP) { 2282cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2295a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 230774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isInteger, "integer"); 2312cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!hasFloatingPointTypes()) 232774ce29399364823dba62217ebf7bc8701005140Chris Lattner return false; 233774ce29399364823dba62217ebf7bc8701005140Chris Lattner 234774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 2352cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2362cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the fp types. 2372cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 238774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isInteger(TypeVec[i])) 2392cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 2402cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2412cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) 2422cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 2432cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be integer"); 244774ce29399364823dba62217ebf7bc8701005140Chris Lattner return true; 2452cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2462cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2472cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceFloatingPoint - Remove all integer types from this set. 2482cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceFloatingPoint(TreePattern &TP) { 2492cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2505a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 251774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isFloatingPoint, "floating point"); 252774ce29399364823dba62217ebf7bc8701005140Chris Lattner 2532cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!hasIntegerTypes()) 254774ce29399364823dba62217ebf7bc8701005140Chris Lattner return false; 255774ce29399364823dba62217ebf7bc8701005140Chris Lattner 256774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 2572cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2582cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the fp types. 2592cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 260774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isFloatingPoint(TypeVec[i])) 2612cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 2622cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2632cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) 2642cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 2652cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be floating point"); 266774ce29399364823dba62217ebf7bc8701005140Chris Lattner return true; 2672cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2682cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2692cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceScalar - Remove all vector types from this. 2702cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceScalar(TreePattern &TP) { 2712cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2725a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 273774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isScalar, "scalar"); 274774ce29399364823dba62217ebf7bc8701005140Chris Lattner 2752cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!hasVectorTypes()) 276774ce29399364823dba62217ebf7bc8701005140Chris Lattner return false; 277774ce29399364823dba62217ebf7bc8701005140Chris Lattner 278774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 2792cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2802cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the vector types. 2812cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 282774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isScalar(TypeVec[i])) 2832cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 2842cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2852cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) 2862cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 2872cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be scalar"); 288774ce29399364823dba62217ebf7bc8701005140Chris Lattner return true; 2892cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 2902cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2912cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceVector - Remove all vector types from this. 2922cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceVector(TreePattern &TP) { 2932cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we know nothing, then get the full set. 2945a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.empty()) 295774ce29399364823dba62217ebf7bc8701005140Chris Lattner return FillWithPossibleTypes(TP, isVector, "vector"); 296774ce29399364823dba62217ebf7bc8701005140Chris Lattner 297774ce29399364823dba62217ebf7bc8701005140Chris Lattner TypeSet InputSet(*this); 298774ce29399364823dba62217ebf7bc8701005140Chris Lattner bool MadeChange = false; 2992cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3002cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Filter out all the scalar types. 3012cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) 302774ce29399364823dba62217ebf7bc8701005140Chris Lattner if (!isVector(TypeVec[i])) { 3032cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 304774ce29399364823dba62217ebf7bc8701005140Chris Lattner MadeChange = true; 305774ce29399364823dba62217ebf7bc8701005140Chris Lattner } 3062cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3072cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) 3082cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, '" + 3092cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' needs to be a vector"); 3102cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 3112cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 3122cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3132cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3145a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3152cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceSmallerThan - 'this' must be a smaller VT than Other. Update 3162cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// this an other based on this information. 3172cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool EEVT::TypeSet::EnforceSmallerThan(EEVT::TypeSet &Other, TreePattern &TP) { 3182cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Both operands must be integer or FP, but we don't care which. 3192cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = false; 3202cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3215a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (isCompletelyUnknown()) 3225a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MadeChange = FillWithPossibleTypes(TP); 3235a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3245a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (Other.isCompletelyUnknown()) 3255a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MadeChange = Other.FillWithPossibleTypes(TP); 3265a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3272cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If one side is known to be integer or known to be FP but the other side has 3282cacec55f947c716b058a39038889550d7e39b3cChris Lattner // no information, get at least the type integrality info in there. 3295a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!hasFloatingPointTypes()) 3302cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= Other.EnforceInteger(TP); 3315a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner else if (!hasIntegerTypes()) 3322cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= Other.EnforceFloatingPoint(TP); 3335a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!Other.hasFloatingPointTypes()) 3342cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= EnforceInteger(TP); 3355a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner else if (!Other.hasIntegerTypes()) 3362cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= EnforceFloatingPoint(TP); 3372cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3382cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(!isCompletelyUnknown() && !Other.isCompletelyUnknown() && 3392cacec55f947c716b058a39038889550d7e39b3cChris Lattner "Should have a type list now"); 3402cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3412cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If one contains vectors but the other doesn't pull vectors out. 3425a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!hasVectorTypes()) 3432cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= Other.EnforceScalar(TP); 3445a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (!hasVectorTypes()) 3452cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= EnforceScalar(TP); 3462cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3475a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // This code does not currently handle nodes which have multiple types, 3485a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // where some types are integer, and some are fp. Assert that this is not 3495a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // the case. 3505a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner assert(!(hasIntegerTypes() && hasFloatingPointTypes()) && 3515a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner !(Other.hasIntegerTypes() && Other.hasFloatingPointTypes()) && 3525a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner "SDTCisOpSmallerThanOp does not handle mixed int/fp types!"); 3532cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3545a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // Okay, find the smallest type from the current set and remove it from the 3555a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // largest set. 3565a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MVT::SimpleValueType Smallest = TypeVec[0]; 3575a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner for (unsigned i = 1, e = TypeVec.size(); i != e; ++i) 3585a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec[i] < Smallest) 3595a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner Smallest = TypeVec[i]; 3602cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3615a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // If this is the only type in the large set, the constraint can never be 3625a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // satisfied. 3635a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (Other.TypeVec.size() == 1 && Other.TypeVec[0] == Smallest) 3645a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner TP.error("Type inference contradiction found, '" + 3655a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner Other.getName() + "' has nothing larger than '" + getName() +"'!"); 3665a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3675a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner SmallVector<MVT::SimpleValueType, 2>::iterator TVI = 3685a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner std::find(Other.TypeVec.begin(), Other.TypeVec.end(), Smallest); 3695a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TVI != Other.TypeVec.end()) { 3705a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner Other.TypeVec.erase(TVI); 3715a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MadeChange = true; 3725a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner } 3735a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3745a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // Okay, find the largest type in the Other set and remove it from the 3755a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // current set. 3765a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MVT::SimpleValueType Largest = Other.TypeVec[0]; 3775a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner for (unsigned i = 1, e = Other.TypeVec.size(); i != e; ++i) 3785a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (Other.TypeVec[i] > Largest) 3795a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner Largest = Other.TypeVec[i]; 3805a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3815a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // If this is the only type in the small set, the constraint can never be 3825a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner // satisfied. 3835a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TypeVec.size() == 1 && TypeVec[0] == Largest) 3845a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner TP.error("Type inference contradiction found, '" + 3855a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner getName() + "' has nothing smaller than '" + Other.getName()+"'!"); 3865a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3875a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner TVI = std::find(TypeVec.begin(), TypeVec.end(), Largest); 3885a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner if (TVI != TypeVec.end()) { 3895a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner TypeVec.erase(TVI); 3905a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner MadeChange = true; 3915a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner } 3925a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner 3935a9b8fb95c9a4c6fd5e06c1e89fa9263d39cd252Chris Lattner return MadeChange; 3942cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 3952cacec55f947c716b058a39038889550d7e39b3cChris Lattner 3962cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// EnforceVectorEltTypeIs - 'this' is now constrainted to be a vector type 39766fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner/// whose element is specified by VTOperand. 39866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattnerbool EEVT::TypeSet::EnforceVectorEltTypeIs(EEVT::TypeSet &VTOperand, 3992cacec55f947c716b058a39038889550d7e39b3cChris Lattner TreePattern &TP) { 40066fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // "This" must be a vector and "VTOperand" must be a scalar. 4012cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = false; 40266fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner MadeChange |= EnforceVector(TP); 40366fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner MadeChange |= VTOperand.EnforceScalar(TP); 40466fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner 40566fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // If we know the vector type, it forces the scalar to agree. 40666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner if (isConcrete()) { 40766fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner EVT IVT = getConcrete(); 40866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner IVT = IVT.getVectorElementType(); 40966fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner return MadeChange | 41066fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner VTOperand.MergeInTypeInfo(IVT.getSimpleVT().SimpleTy, TP); 41166fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner } 41266fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner 41366fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // If the scalar type is known, filter out vector types whose element types 41466fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // disagree. 41566fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner if (!VTOperand.isConcrete()) 41666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner return MadeChange; 4172cacec55f947c716b058a39038889550d7e39b3cChris Lattner 41866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner MVT::SimpleValueType VT = VTOperand.getConcrete(); 4192cacec55f947c716b058a39038889550d7e39b3cChris Lattner 42066fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner TypeSet InputSet(*this); 42166fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner 42266fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // Filter out all the types which don't have the right element type. 42366fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner for (unsigned i = 0; i != TypeVec.size(); ++i) { 42466fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner assert(isVector(TypeVec[i]) && "EnforceVector didn't work"); 42566fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner if (EVT(TypeVec[i]).getVectorElementType().getSimpleVT().SimpleTy != VT) { 4262cacec55f947c716b058a39038889550d7e39b3cChris Lattner TypeVec.erase(TypeVec.begin()+i--); 4272cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange = true; 4282cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 42966fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner } 4302cacec55f947c716b058a39038889550d7e39b3cChris Lattner 4312cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (TypeVec.empty()) // FIXME: Really want an SMLoc here! 4322cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Type inference contradiction found, forcing '" + 4332cacec55f947c716b058a39038889550d7e39b3cChris Lattner InputSet.getName() + "' to have a vector element"); 4342cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 4352cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 4362cacec55f947c716b058a39038889550d7e39b3cChris Lattner 4372cacec55f947c716b058a39038889550d7e39b3cChris Lattner//===----------------------------------------------------------------------===// 4382cacec55f947c716b058a39038889550d7e39b3cChris Lattner// Helpers for working with extended types. 4396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 4406f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbarbool RecordPtrCmp::operator()(const Record *LHS, const Record *RHS) const { 4416f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar return LHS->getID() < RHS->getID(); 4426f5cc82686d6f25abc3e373b241bc2cb47d87268Daniel Dunbar} 443327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 444327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// Dependent variable map for CodeGenDAGPattern variant generation 445327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Micheltypedef std::map<std::string, int> DepVarMap; 446327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 447327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// Const iterator shorthand for DepVarMap 448327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Micheltypedef DepVarMap::const_iterator DepVarMap_citer; 449327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 450327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michelnamespace { 451327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michelvoid FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) { 452327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (N->isLeaf()) { 453327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (dynamic_cast<DefInit*>(N->getLeafValue()) != NULL) { 454327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DepMap[N->getName()]++; 455327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 456327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } else { 457327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (size_t i = 0, e = N->getNumChildren(); i != e; ++i) 458327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVarsOf(N->getChild(i), DepMap); 459327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 460327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 461327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 462327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel//! Find dependent variables within child patterns 463327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/*! 464327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel */ 465327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michelvoid FindDepVars(TreePatternNode *N, MultipleUseVarSet &DepVars) { 466327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DepVarMap depcounts; 467327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVarsOf(N, depcounts); 468327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (DepVarMap_citer i = depcounts.begin(); i != depcounts.end(); ++i) { 469327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (i->second > 1) { // std::pair<std::string, int> 470327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DepVars.insert(i->first); 471327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 472327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 473327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 474327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 475327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel//! Dump the dependent variable set: 4766aa526bf76ba74b79ebf4d96d2c1f12d59067530Daniel Dunbar#ifndef NDEBUG 477327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michelvoid DumpDepVars(MultipleUseVarSet &DepVars) { 478327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (DepVars.empty()) { 479569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "<empty set>"); 480327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } else { 481569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "[ "); 482bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach for (MultipleUseVarSet::const_iterator i = DepVars.begin(), 483bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach e = DepVars.end(); i != e; ++i) { 484569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << (*i) << " "); 485327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 486569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "]"); 487327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 488327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 4896aa526bf76ba74b79ebf4d96d2c1f12d59067530Daniel Dunbar#endif 4906aa526bf76ba74b79ebf4d96d2c1f12d59067530Daniel Dunbar 491327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 492327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 4936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 49422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman// PatternToMatch implementation 49522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman// 49622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 49748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 49848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// getPatternSize - Return the 'size' of this pattern. We want to match large 49948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// patterns before small ones. This is used to determine the size of a 50048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// pattern. 50148e86dbe29e331357b0df11075b7974009c65f34Chris Lattnerstatic unsigned getPatternSize(const TreePatternNode *P, 50248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner const CodeGenDAGPatterns &CGP) { 50348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner unsigned Size = 3; // The node itself. 50448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // If the root node is a ConstantSDNode, increases its size. 50548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // e.g. (set R32:$dst, 0). 50648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue())) 50748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += 2; 50848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 50948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // FIXME: This is a hack to statically increase the priority of patterns 51048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // which maps a sub-dag to a complex pattern. e.g. favors LEA over ADD. 51148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // Later we can allow complexity / cost for each pattern to be (optionally) 51248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // specified. To get best possible pattern match we'll need to dynamically 51348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // calculate the complexity of all patterns a dag can potentially map to. 51448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner const ComplexPattern *AM = P->getComplexPatternInfo(CGP); 51548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (AM) 51648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += AM->getNumOperands() * 3; 51748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 51848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // If this node has some predicate function that must match, it adds to the 51948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // complexity of this node. 52048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (!P->getPredicateFns().empty()) 52148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner ++Size; 52248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 52348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner // Count children in the count if they are also nodes. 52448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) { 52548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner TreePatternNode *Child = P->getChild(i); 52648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (!Child->isLeaf() && Child->getNumTypes() && 52748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Child->getType(0) != MVT::Other) 52848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += getPatternSize(Child, CGP); 52948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner else if (Child->isLeaf()) { 53048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner if (dynamic_cast<IntInit*>(Child->getLeafValue())) 53148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2). 53248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner else if (Child->getComplexPatternInfo(CGP)) 53348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner Size += getPatternSize(Child, CGP); 53448e86dbe29e331357b0df11075b7974009c65f34Chris Lattner else if (!Child->getPredicateFns().empty()) 53548e86dbe29e331357b0df11075b7974009c65f34Chris Lattner ++Size; 53648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner } 53748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner } 53848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 53948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner return Size; 54048e86dbe29e331357b0df11075b7974009c65f34Chris Lattner} 54148e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 54248e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// Compute the complexity metric for the input pattern. This roughly 54348e86dbe29e331357b0df11075b7974009c65f34Chris Lattner/// corresponds to the number of nodes that are covered. 54448e86dbe29e331357b0df11075b7974009c65f34Chris Lattnerunsigned PatternToMatch:: 54548e86dbe29e331357b0df11075b7974009c65f34Chris LattnergetPatternComplexity(const CodeGenDAGPatterns &CGP) const { 54648e86dbe29e331357b0df11075b7974009c65f34Chris Lattner return getPatternSize(getSrcPattern(), CGP) + getAddedComplexity(); 54748e86dbe29e331357b0df11075b7974009c65f34Chris Lattner} 54848e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 54948e86dbe29e331357b0df11075b7974009c65f34Chris Lattner 55022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// getPredicateCheck - Return a single string containing all of this 55122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// pattern's predicates concatenated with "&&" operators. 55222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// 55322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohmanstd::string PatternToMatch::getPredicateCheck() const { 55422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman std::string PredicateCheck; 55522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) { 55622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (DefInit *Pred = dynamic_cast<DefInit*>(Predicates->getElement(i))) { 55722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman Record *Def = Pred->getDef(); 55822bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (!Def->isSubClassOf("Predicate")) { 55922bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman#ifndef NDEBUG 56022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman Def->dump(); 56122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman#endif 56222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman assert(0 && "Unknown predicate type!"); 56322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 56422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (!PredicateCheck.empty()) 56522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman PredicateCheck += " && "; 56622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman PredicateCheck += "(" + Def->getValueAsString("CondString") + ")"; 56722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 56822bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 56922bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 57022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman return PredicateCheck; 57122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman} 57222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 57322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman//===----------------------------------------------------------------------===// 5746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// SDTypeConstraint implementation 5756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 5766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5776cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSDTypeConstraint::SDTypeConstraint(Record *R) { 5786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OperandNo = R->getValueAsInt("OperandNum"); 5796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("SDTCisVT")) { 5816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisVT; 5826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisVT_Info.VT = getValueType(R->getValueAsDef("VT")); 583c812261221040ac991f0c9710036a079f208281eChris Lattner if (x.SDTCisVT_Info.VT == MVT::isVoid) 584c812261221040ac991f0c9710036a079f208281eChris Lattner throw TGError(R->getLoc(), "Cannot use 'Void' as type to SDTCisVT"); 585c812261221040ac991f0c9710036a079f208281eChris Lattner 5866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisPtrTy")) { 5876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisPtrTy; 5886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisInt")) { 5896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisInt; 5906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisFP")) { 5916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisFP; 59236e3e668be0c4914660575d7cea800b0d51a4116Bob Wilson } else if (R->isSubClassOf("SDTCisVec")) { 59336e3e668be0c4914660575d7cea800b0d51a4116Bob Wilson ConstraintType = SDTCisVec; 5946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisSameAs")) { 5956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisSameAs; 5966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisSameAs_Info.OtherOperandNum = R->getValueAsInt("OtherOperandNum"); 5976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisVTSmallerThanOp")) { 5986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisVTSmallerThanOp; 5996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisVTSmallerThanOp_Info.OtherOperandNum = 6006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->getValueAsInt("OtherOperandNum"); 6016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisOpSmallerThanOp")) { 6026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisOpSmallerThanOp; 6036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisOpSmallerThanOp_Info.BigOperandNum = 6046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->getValueAsInt("BigOperandNum"); 605b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman } else if (R->isSubClassOf("SDTCisEltOfVec")) { 606b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman ConstraintType = SDTCisEltOfVec; 6072cacec55f947c716b058a39038889550d7e39b3cChris Lattner x.SDTCisEltOfVec_Info.OtherOperandNum = R->getValueAsInt("OtherOpNum"); 6086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 6091a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Unrecognized SDTypeConstraint '" << R->getName() << "'!\n"; 6106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 6116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 6126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 6136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 6146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// getOperandNum - Return the node corresponding to operand #OpNo in tree 6152e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner/// N, and the result number in ResNo. 6162e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattnerstatic TreePatternNode *getOperandNum(unsigned OpNo, TreePatternNode *N, 6172e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner const SDNodeInfo &NodeInfo, 6182e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned &ResNo) { 6192e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned NumResults = NodeInfo.getNumResults(); 6202e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner if (OpNo < NumResults) { 6212e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner ResNo = OpNo; 6222e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner return N; 6232e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner } 6242e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner 6252e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner OpNo -= NumResults; 6262e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner 6272e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner if (OpNo >= N->getNumChildren()) { 6282e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner errs() << "Invalid operand number in type constraint " 6292e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner << (OpNo+NumResults) << " "; 6306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->dump(); 6311a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << '\n'; 6326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 6336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 6346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 6352e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner return N->getChild(OpNo); 6366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 6376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 6386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ApplyTypeConstraint - Given a node in a pattern, apply this type 6396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// constraint to the nodes operands. This returns true if it makes a 6406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// change, false otherwise. If a type contradiction is found, throw an 6416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// exception. 6426cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N, 6436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo, 6446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern &TP) const { 6452e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned ResNo = 0; // The result number being referenced. 6462e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner TreePatternNode *NodeToApply = getOperandNum(OperandNo, N, NodeInfo, ResNo); 6476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 6486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner switch (ConstraintType) { 6496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner default: assert(0 && "Unknown constraint type!"); 6506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisVT: 6516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Operand must be a particular type. 652d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(ResNo, x.SDTCisVT_Info.VT, TP); 6532cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisPtrTy: 6546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Operand must be same as target pointer type. 655d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(ResNo, MVT::iPTR, TP); 6562cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisInt: 6572cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal integer VTs. 658d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceInteger(TP); 6592cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisFP: 6602cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal fp VTs. 661d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceFloatingPoint(TP); 6622cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisVec: 6632cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal vector VTs. 664d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceVector(TP); 6656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisSameAs: { 6662e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned OResNo = 0; 6676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OtherNode = 6682e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisSameAs_Info.OtherOperandNum, N, NodeInfo, OResNo); 669d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(OResNo, OtherNode->getExtType(ResNo),TP)| 670d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OtherNode->UpdateNodeType(ResNo,NodeToApply->getExtType(OResNo),TP); 6716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 6726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisVTSmallerThanOp: { 6736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The NodeToApply must be a leaf node that is a VT. OtherOperandNum must 6746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // have an integer type that is smaller than the VT. 6756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!NodeToApply->isLeaf() || 6766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !dynamic_cast<DefInit*>(NodeToApply->getLeafValue()) || 6776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef() 6786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ->isSubClassOf("ValueType")) 6796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error(N->getOperator()->getName() + " expects a VT operand!"); 680825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::SimpleValueType VT = 6816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()); 682cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner 683cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner EEVT::TypeSet TypeListTmp(VT, TP); 6846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 6852e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned OResNo = 0; 6866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OtherNode = 6872e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisVTSmallerThanOp_Info.OtherOperandNum, N, NodeInfo, 6882e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner OResNo); 6892cacec55f947c716b058a39038889550d7e39b3cChris Lattner 690cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner return TypeListTmp.EnforceSmallerThan(OtherNode->getExtType(OResNo), TP); 6916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 6926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisOpSmallerThanOp: { 6932e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned BResNo = 0; 6946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *BigOperand = 6952e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisOpSmallerThanOp_Info.BigOperandNum, N, NodeInfo, 6962e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner BResNo); 697d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo). 698d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner EnforceSmallerThan(BigOperand->getExtType(BResNo), TP); 6996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 700b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman case SDTCisEltOfVec: { 7012e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned VResNo = 0; 7022cacec55f947c716b058a39038889550d7e39b3cChris Lattner TreePatternNode *VecOperand = 7032e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisEltOfVec_Info.OtherOperandNum, N, NodeInfo, 7042e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner VResNo); 7052cacec55f947c716b058a39038889550d7e39b3cChris Lattner 70666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // Filter vector types out of VecOperand that don't have the right element 70766fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // type. 70866fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner return VecOperand->getExtType(VResNo). 70966fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner EnforceVectorEltTypeIs(NodeToApply->getExtType(ResNo), TP); 710b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman } 7116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 7126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 7136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 7146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 7166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// SDNodeInfo implementation 7176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 7186cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSDNodeInfo::SDNodeInfo(Record *R) : Def(R) { 7196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner EnumName = R->getValueAsString("Opcode"); 7206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SDClassName = R->getValueAsString("SDClass"); 7216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *TypeProfile = R->getValueAsDef("TypeProfile"); 7226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NumResults = TypeProfile->getValueAsInt("NumResults"); 7236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NumOperands = TypeProfile->getValueAsInt("NumOperands"); 7246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the properties. 7266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties = 0; 7276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> PropList = R->getValueAsListOfDefs("Properties"); 7286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = PropList.size(); i != e; ++i) { 7296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (PropList[i]->getName() == "SDNPCommutative") { 7306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPCommutative; 7316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPAssociative") { 7326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPAssociative; 7336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPHasChain") { 7346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPHasChain; 7356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPOutFlag") { 736874ae251c317788391f9c3f113957802d390a063Dale Johannesen Properties |= 1 << SDNPOutFlag; 7376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPInFlag") { 7386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPInFlag; 7396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPOptInFlag") { 7406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPOptInFlag; 741c8478d8b12c2d7e4cea32d0c9940f5cac2baa4ddChris Lattner } else if (PropList[i]->getName() == "SDNPMayStore") { 742c8478d8b12c2d7e4cea32d0c9940f5cac2baa4ddChris Lattner Properties |= 1 << SDNPMayStore; 743710e995889c71812743f3f33861c24273f4569a7Chris Lattner } else if (PropList[i]->getName() == "SDNPMayLoad") { 744710e995889c71812743f3f33861c24273f4569a7Chris Lattner Properties |= 1 << SDNPMayLoad; 745bc0b9f70ae072d695e0eb7ceb729b3306b0679feChris Lattner } else if (PropList[i]->getName() == "SDNPSideEffect") { 746bc0b9f70ae072d695e0eb7ceb729b3306b0679feChris Lattner Properties |= 1 << SDNPSideEffect; 74728873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang } else if (PropList[i]->getName() == "SDNPMemOperand") { 74828873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang Properties |= 1 << SDNPMemOperand; 749e8cabf3c2eb835f9189a39c810654d9bd302f7eeChris Lattner } else if (PropList[i]->getName() == "SDNPVariadic") { 750e8cabf3c2eb835f9189a39c810654d9bd302f7eeChris Lattner Properties |= 1 << SDNPVariadic; 7516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 7521a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Unknown SD Node property '" << PropList[i]->getName() 7531a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar << "' on node '" << R->getName() << "'!\n"; 7546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 7556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 7566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 7576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the type constraints. 7606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> ConstraintList = 7616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TypeProfile->getValueAsListOfDefs("Constraints"); 7626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TypeConstraints.assign(ConstraintList.begin(), ConstraintList.end()); 7636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 7646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 765225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner/// getKnownType - If the type constraints on this node imply a fixed type 766225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner/// (e.g. all stores return void, etc), then return it as an 767aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner/// MVT::SimpleValueType. Otherwise, return EEVT::Other. 768084df627c82fdf4e1829723edf0a833b5bc31f89Chris LattnerMVT::SimpleValueType SDNodeInfo::getKnownType(unsigned ResNo) const { 769225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner unsigned NumResults = getNumResults(); 770225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner assert(NumResults <= 1 && 771225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner "We only work with nodes with zero or one result so far!"); 772084df627c82fdf4e1829723edf0a833b5bc31f89Chris Lattner assert(ResNo == 0 && "Only handles single result nodes so far"); 773225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner 774225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner for (unsigned i = 0, e = TypeConstraints.size(); i != e; ++i) { 775225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner // Make sure that this applies to the correct node result. 776225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner if (TypeConstraints[i].OperandNo >= NumResults) // FIXME: need value # 777225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner continue; 778225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner 779225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner switch (TypeConstraints[i].ConstraintType) { 780225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner default: break; 781225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner case SDTypeConstraint::SDTCisVT: 782225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner return TypeConstraints[i].x.SDTCisVT_Info.VT; 783225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner case SDTypeConstraint::SDTCisPtrTy: 784225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner return MVT::iPTR; 785225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner } 786225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner } 787aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner return MVT::Other; 788225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner} 789225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner 7906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 7916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// TreePatternNode implementation 7926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 7936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7946cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode::~TreePatternNode() { 7956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#if 0 // FIXME: implement refcounted tree nodes! 7966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 7976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete getChild(i); 7986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#endif 7996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 801d7349194650386d97a1d779369cb46f20ba9f252Chris Lattnerstatic unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) { 802d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->getName() == "set" || 803310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner Operator->getName() == "implicit") 804d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return 0; // All return nothing. 805d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 80693dc92e412fd06250e46951bffb6040eca9baebdChris Lattner if (Operator->isSubClassOf("Intrinsic")) 80793dc92e412fd06250e46951bffb6040eca9baebdChris Lattner return CDP.getIntrinsic(Operator).IS.RetVTs.size(); 808d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 809d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("SDNode")) 810d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return CDP.getSDNodeInfo(Operator).getNumResults(); 811d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 812d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("PatFrag")) { 813d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // If we've already parsed this pattern fragment, get it. Otherwise, handle 814d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // the forward reference case where one pattern fragment references another 815d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // before it is processed. 816d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (TreePattern *PFRec = CDP.getPatternFragmentIfRead(Operator)) 817d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return PFRec->getOnlyTree()->getNumTypes(); 818d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 819d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // Get the result tree. 820d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DagInit *Tree = Operator->getValueAsDag("Fragment"); 821d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Record *Op = 0; 822d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Tree && dynamic_cast<DefInit*>(Tree->getOperator())) 823d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Op = dynamic_cast<DefInit*>(Tree->getOperator())->getDef(); 824d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(Op && "Invalid Fragment"); 825d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return GetNumNodeResults(Op, CDP); 826d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 827d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 828d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("Instruction")) { 829d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CodeGenInstruction &InstInfo = CDP.getTargetInfo().getInstruction(Operator); 8300be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 8310be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: Should allow access to all the results here. 8320be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned NumDefsToAdd = InstInfo.NumDefs ? 1 : 0; 833d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 8349414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // Add on one implicit def if it has a resolvable type. 8359414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()) !=MVT::Other) 8369414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner ++NumDefsToAdd; 8370be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner return NumDefsToAdd; 838d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 839d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 840d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("SDNodeXForm")) 841d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return 1; // FIXME: Generalize SDNodeXForm 842d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 843d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Operator->dump(); 844d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner errs() << "Unhandled node in GetNumNodeResults\n"; 845d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner exit(1); 846d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner} 8476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8481a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePatternNode::print(raw_ostream &OS) const { 849d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (isLeaf()) 8506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << *getLeafValue(); 851d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner else 852ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner OS << '(' << getOperator()->getName(); 853d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 854d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 855d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OS << ':' << getExtType(i).getName(); 8566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isLeaf()) { 8586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getNumChildren() != 0) { 8596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << " "; 8606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(0)->print(OS); 8616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 1, e = getNumChildren(); i != e; ++i) { 8626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ", "; 8636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(i)->print(OS); 8646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ")"; 8676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8690540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = PredicateFns.size(); i != e; ++i) 8700540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman OS << "<<P:" << PredicateFns[i] << ">>"; 8716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (TransformFn) 8726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "<<X:" << TransformFn->getName() << ">>"; 8736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getName().empty()) 8746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ":$" << getName(); 8756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8776cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePatternNode::dump() const { 8781a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar print(errs()); 8796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 881327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isIsomorphicTo - Return true if this node is recursively 882327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isomorphic to the specified node. For this comparison, the node's 883327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// entire state is considered. The assigned name is ignored, since 884327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// nodes with differing names are considered isomorphic. However, if 885327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// the assigned name is present in the dependent variable set, then 886327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// the assigned name is considered significant and the node is 887327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isomorphic if the names match. 888327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michelbool TreePatternNode::isIsomorphicTo(const TreePatternNode *N, 889327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) const { 8906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N == this) return true; 891d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->isLeaf() != isLeaf() || getExtTypes() != N->getExtTypes() || 8920540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman getPredicateFns() != N->getPredicateFns() || 8936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getTransformFn() != N->getTransformFn()) 8946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 8956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 897327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { 898327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (DefInit *NDI = dynamic_cast<DefInit*>(N->getLeafValue())) { 89971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner return ((DI->getDef() == NDI->getDef()) 90071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner && (DepVars.find(getName()) == DepVars.end() 90171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner || getName() == N->getName())); 902327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 903327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 9046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return getLeafValue() == N->getLeafValue(); 9056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getOperator() != getOperator() || 9086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->getNumChildren() != getNumChildren()) return false; 9096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 910327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (!getChild(i)->isIsomorphicTo(N->getChild(i), DepVars)) 9116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 9126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 9136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 9146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// clone - Make a copy of this tree and all of its children. 9166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 9176cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode *TreePatternNode::clone() const { 9186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *New; 9196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 920d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(getLeafValue(), getNumTypes()); 9216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 9226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CChildren; 9236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CChildren.reserve(Children.size()); 9246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 9256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CChildren.push_back(getChild(i)->clone()); 926d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(getOperator(), CChildren, getNumTypes()); 9276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner New->setName(getName()); 929d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New->Types = Types; 9300540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman New->setPredicateFns(getPredicateFns()); 9316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner New->setTransformFn(getTransformFn()); 9326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return New; 9336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 9346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 93547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// RemoveAllTypes - Recursively strip all the types of this tree. 93647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnervoid TreePatternNode::RemoveAllTypes() { 937d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 938d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Types[i] = EEVT::TypeSet(); // Reset to unknown type. 93947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (isLeaf()) return; 94047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 94147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner getChild(i)->RemoveAllTypes(); 94247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 94347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 94447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 9456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// SubstituteFormalArguments - Replace the formal arguments in this tree 9466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// with actual values specified by ArgMap. 9476cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePatternNode:: 9486cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) { 9496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return; 9506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { 9526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = getChild(i); 9536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Child->isLeaf()) { 9546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Init *Val = Child->getLeafValue(); 9556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (dynamic_cast<DefInit*>(Val) && 9566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner static_cast<DefInit*>(Val)->getDef()->getName() == "node") { 9576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // We found a use of a formal argument, replace it with its value. 9580540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *NewChild = ArgMap[Child->getName()]; 9590540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert(NewChild && "Couldn't find formal argument!"); 9600540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert((Child->getPredicateFns().empty() || 9610540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman NewChild->getPredicateFns() == Child->getPredicateFns()) && 9620540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman "Non-empty child predicate clobbered!"); 9630540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman setChild(i, NewChild); 9646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 9666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(i)->SubstituteFormalArguments(ArgMap); 9676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 9706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// InlinePatternFragments - If this pattern refers to any pattern 9736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// fragments, inline them into place, giving us a pattern without any 9746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// PatFrag references. 9756cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode *TreePatternNode::InlinePatternFragments(TreePattern &TP) { 9766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return this; // nothing to do. 9776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Op = getOperator(); 9786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Op->isSubClassOf("PatFrag")) { 9806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Just recursively inline children nodes. 9810540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { 9820540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *Child = getChild(i); 9830540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *NewChild = Child->InlinePatternFragments(TP); 9840540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 9850540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert((Child->getPredicateFns().empty() || 9860540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman NewChild->getPredicateFns() == Child->getPredicateFns()) && 9870540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman "Non-empty child predicate clobbered!"); 9880540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 9890540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman setChild(i, NewChild); 9900540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman } 9916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return this; 9926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, we found a reference to a fragment. First, look up its 9956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // TreePattern record. 9966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *Frag = TP.getDAGPatterns().getPatternFragment(Op); 9976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we are passing the right number of operands. 9996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Frag->getNumArgs() != Children.size()) 10006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("'" + Op->getName() + "' fragment requires " + 10016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner utostr(Frag->getNumArgs()) + " operands!"); 10026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *FragTree = Frag->getOnlyTree()->clone(); 10046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10050540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman std::string Code = Op->getValueAsCode("Predicate"); 10060540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman if (!Code.empty()) 10070540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman FragTree->addPredicateFn("Predicate_"+Op->getName()); 10080540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 10096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Resolve formal arguments to their actual value. 10106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Frag->getNumArgs()) { 10116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Compute the map of formal to actual arguments. 10126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> ArgMap; 10136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Frag->getNumArgs(); i != e; ++i) 10146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ArgMap[Frag->getArgName(i)] = getChild(i)->InlinePatternFragments(TP); 10156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FragTree->SubstituteFormalArguments(ArgMap); 10176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 10186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FragTree->setName(getName()); 1020d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1021d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner FragTree->UpdateNodeType(i, getExtType(i), TP); 10220540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 10230540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman // Transfer in the old predicates. 10240540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = getPredicateFns().size(); i != e; ++i) 10250540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman FragTree->addPredicateFn(getPredicateFns()[i]); 10260540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 10276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Get a new copy of this fragment to stitch into here. 10286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner //delete this; // FIXME: implement refcounting! 10292ca698df93421327a459987b33b045756cb47d4dChris Lattner 10302ca698df93421327a459987b33b045756cb47d4dChris Lattner // The fragment we inlined could have recursive inlining that is needed. See 10312ca698df93421327a459987b33b045756cb47d4dChris Lattner // if there are any pattern fragments in it and inline them as needed. 10322ca698df93421327a459987b33b045756cb47d4dChris Lattner return FragTree->InlinePatternFragments(TP); 10336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 10346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// getImplicitType - Check to see if the specified record has an implicit 1036fc4c25530412907f566519dd4d0979a6570222b3Nick Lewycky/// type which should be applied to it. This will infer the type of register 10376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// references from the register file information, for example. 10386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 1039d7349194650386d97a1d779369cb46f20ba9f252Chris Lattnerstatic EEVT::TypeSet getImplicitType(Record *R, unsigned ResNo, 1040d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool NotRegisters, TreePattern &TP) { 10412cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Check to see if this is a register or a register class. 10426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("RegisterClass")) { 1043640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Regclass ref only has one result!"); 10446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NotRegisters) 10452cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 10462cacec55f947c716b058a39038889550d7e39b3cChris Lattner const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 10472cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(T.getRegisterClass(R).getValueTypes()); 1048640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1049640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 1050640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("PatFrag")) { 1051640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "FIXME: PatFrag with multiple results?"); 10526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Pattern fragment types will be resolved when they are inlined. 10532cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 1054640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1055640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 1056640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("Register")) { 1057640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Registers only produce one result!"); 10586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NotRegisters) 10592cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 10606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 10612cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(T.getRegisterVTs(R)); 1062640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 106373ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen 106473ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen if (R->isSubClassOf("SubRegIndex")) { 106573ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen assert(ResNo == 0 && "SubRegisterIndices only produce one result!"); 106673ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen return EEVT::TypeSet(); 106773ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen } 1068640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 1069640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("ValueType") || R->isSubClassOf("CondCode")) { 1070640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "This node only has one result!"); 10716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Using a VTSDNode or CondCodeSDNode. 10722cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::Other, TP); 1073640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1074640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 1075640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("ComplexPattern")) { 1076640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "FIXME: ComplexPattern with multiple results?"); 10776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NotRegisters) 10782cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 10792cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(TP.getDAGPatterns().getComplexPattern(R).getValueType(), 10802cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP); 1081640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1082640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("PointerLikeRegClass")) { 1083640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Regclass can only have one result!"); 10842cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::iPTR, TP); 1085640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1086640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 1087640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->getName() == "node" || R->getName() == "srcvalue" || 1088640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner R->getName() == "zero_reg") { 10896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Placeholder. 10902cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 10916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 10926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Unknown node flavor used in pattern: " + R->getName()); 10942cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::Other, TP); 10956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 10966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1097e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 1098e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner/// getIntrinsicInfo - If this node corresponds to an intrinsic, return the 1099e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner/// CodeGenIntrinsic information for it, otherwise return a null pointer. 1100e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattnerconst CodeGenIntrinsic *TreePatternNode:: 1101e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris LattnergetIntrinsicInfo(const CodeGenDAGPatterns &CDP) const { 1102e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner if (getOperator() != CDP.get_intrinsic_void_sdnode() && 1103e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner getOperator() != CDP.get_intrinsic_w_chain_sdnode() && 1104e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner getOperator() != CDP.get_intrinsic_wo_chain_sdnode()) 1105e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner return 0; 1106e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 1107e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner unsigned IID = 1108e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue(); 1109e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner return &CDP.getIntrinsicInfo(IID); 1110e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner} 1111e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 111247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// getComplexPatternInfo - If this node corresponds to a ComplexPattern, 111347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// return the ComplexPattern information, otherwise return null. 111447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerconst ComplexPattern * 111547661320363a8bf0bb1401a8c1893755fb77c8f6Chris LattnerTreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const { 111647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (!isLeaf()) return 0; 111747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 111847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner DefInit *DI = dynamic_cast<DefInit*>(getLeafValue()); 111947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (DI && DI->getDef()->isSubClassOf("ComplexPattern")) 112047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return &CGP.getComplexPattern(DI->getDef()); 112147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return 0; 112247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 112347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 112447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// NodeHasProperty - Return true if this node has the specified property. 112547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerbool TreePatternNode::NodeHasProperty(SDNP Property, 1126751d5aa1eadf041f00acf76f3b641549c8be3998Chris Lattner const CodeGenDAGPatterns &CGP) const { 112747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (isLeaf()) { 112847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (const ComplexPattern *CP = getComplexPatternInfo(CGP)) 112947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return CP->hasProperty(Property); 113047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return false; 113147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner } 113247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 113347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner Record *Operator = getOperator(); 113447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (!Operator->isSubClassOf("SDNode")) return false; 113547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 113647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return CGP.getSDNodeInfo(Operator).hasProperty(Property); 113747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 113847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 113947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 114047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 114147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 114247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// TreeHasProperty - Return true if any node in this tree has the specified 114347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// property. 114447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerbool TreePatternNode::TreeHasProperty(SDNP Property, 1145751d5aa1eadf041f00acf76f3b641549c8be3998Chris Lattner const CodeGenDAGPatterns &CGP) const { 114647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (NodeHasProperty(Property, CGP)) 114747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return true; 114847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 114947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (getChild(i)->TreeHasProperty(Property, CGP)) 115047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return true; 115147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return false; 115247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 115347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 11546bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng/// isCommutativeIntrinsic - Return true if the node corresponds to a 11556bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng/// commutative intrinsic. 11566bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Chengbool 11576bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan ChengTreePatternNode::isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const { 11586bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) 11596bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng return Int->isCommutative; 11606bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng return false; 11616bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng} 11626bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng 1163e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 11646c01ca9e29816e36e96112ed541ecf3414a7aad2Bob Wilson/// ApplyTypeConstraints - Apply all of the type constraints relevant to 11656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// this node and its children in the tree. This returns true if it makes a 11666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// change, false otherwise. If a type contradiction is found, throw an 11676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// exception. 11686cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) { 1169fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &CDP = TP.getDAGPatterns(); 11706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 11716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { 11726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If it's a regclass or something else known, include the type. 1173d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = false; 1174d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1175d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(i, getImplicitType(DI->getDef(), i, 1176d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner NotRegisters, TP), TP); 1177d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return MadeChange; 1178523f6a5848194c135168112751c36884dc704e54Chris Lattner } 1179523f6a5848194c135168112751c36884dc704e54Chris Lattner 1180523f6a5848194c135168112751c36884dc704e54Chris Lattner if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) { 1181d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(Types.size() == 1 && "Invalid IntInit"); 1182d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 11836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Int inits are always integers. :) 1184d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = Types[0].EnforceInteger(TP); 11856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1186d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (!Types[0].isConcrete()) 11872cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 11882cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1189d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType VT = getType(0); 11902cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VT == MVT::iPTR || VT == MVT::iPTRAny) 11912cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 11922cacec55f947c716b058a39038889550d7e39b3cChris Lattner 11932cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned Size = EVT(VT).getSizeInBits(); 11942cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Make sure that the value is representable for this type. 11952cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Size >= 32) return MadeChange; 11962cacec55f947c716b058a39038889550d7e39b3cChris Lattner 11972cacec55f947c716b058a39038889550d7e39b3cChris Lattner int Val = (II->getValue() << (32-Size)) >> (32-Size); 11982cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Val == II->getValue()) return MadeChange; 11992cacec55f947c716b058a39038889550d7e39b3cChris Lattner 12002cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If sign-extended doesn't fit, does it fit as unsigned? 12012cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned ValueMask; 12022cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned UnsignedVal; 12032cacec55f947c716b058a39038889550d7e39b3cChris Lattner ValueMask = unsigned(~uint32_t(0UL) >> (32-Size)); 12042cacec55f947c716b058a39038889550d7e39b3cChris Lattner UnsignedVal = unsigned(II->getValue()); 12052cacec55f947c716b058a39038889550d7e39b3cChris Lattner 12062cacec55f947c716b058a39038889550d7e39b3cChris Lattner if ((ValueMask & UnsignedVal) == UnsignedVal) 12072cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 12086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12092cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Integer value '" + itostr(II->getValue())+ 1210d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "' is out of range for type '" + getEnumName(getType(0)) + "'!"); 12116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 12126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 12146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // special handling for set, which isn't really an SDNode. 12176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getOperator()->getName() == "set") { 1218d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumTypes() == 0 && "Set doesn't produce a value"); 1219d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumChildren() >= 2 && "Missing RHS of a set?"); 12206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NC = getNumChildren(); 1221d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1222d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *SetVal = getChild(NC-1); 1223d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = SetVal->ApplyTypeConstraints(TP, NotRegisters); 1224d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 12256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i < NC-1; ++i) { 1226d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Child = getChild(i); 1227d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Child->ApplyTypeConstraints(TP, NotRegisters); 12286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Types of operands must match. 1230d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Child->UpdateNodeType(0, SetVal->getExtType(i), TP); 1231d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= SetVal->UpdateNodeType(i, Child->getExtType(0), TP); 12326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 12346eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 12356eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 1236310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner if (getOperator()->getName() == "implicit") { 1237d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumTypes() == 0 && "Node doesn't produce a value"); 1238d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 12396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = false; 12406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i < getNumChildren(); ++i) 12416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange = getChild(i)->ApplyTypeConstraints(TP, NotRegisters); 12426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 12436eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 12446eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 12456eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->getName() == "COPY_TO_REGCLASS") { 1246f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman bool MadeChange = false; 1247f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman MadeChange |= getChild(0)->ApplyTypeConstraints(TP, NotRegisters); 1248f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman MadeChange |= getChild(1)->ApplyTypeConstraints(TP, NotRegisters); 12492cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1250d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(0)->getNumTypes() == 1 && 1251d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner getChild(1)->getNumTypes() == 1 && "Unhandled case"); 1252d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 12532cacec55f947c716b058a39038889550d7e39b3cChris Lattner // child #1 of COPY_TO_REGCLASS should be a register class. We don't care 12542cacec55f947c716b058a39038889550d7e39b3cChris Lattner // what type it gets, so if it didn't get a concrete type just give it the 12552cacec55f947c716b058a39038889550d7e39b3cChris Lattner // first viable type from the reg class. 1256d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (!getChild(1)->hasTypeSet(0) && 1257d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner !getChild(1)->getExtType(0).isCompletelyUnknown()) { 1258d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType RCVT = getChild(1)->getExtType(0).getTypeList()[0]; 1259d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(1)->UpdateNodeType(0, RCVT, TP); 12602cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1261f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman return MadeChange; 12626eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 12636eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 12646eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) { 12656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = false; 126683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands 12676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the result type to the node. 1268cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling unsigned NumRetVTs = Int->IS.RetVTs.size(); 1269cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling unsigned NumParamVTs = Int->IS.ParamVTs.size(); 1270d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1271cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling for (unsigned i = 0, e = NumRetVTs; i != e; ++i) 1272d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(i, Int->IS.RetVTs[i], TP); 1273cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling 1274d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (getNumChildren() != NumParamVTs + 1) 1275e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner TP.error("Intrinsic '" + Int->Name + "' expects " + 1276d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner utostr(NumParamVTs) + " operands, not " + 1277cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling utostr(getNumChildren() - 1) + " operands!"); 12786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply type info to the intrinsic ID. 1280d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(0)->UpdateNodeType(0, MVT::iPTR, TP); 12816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1282d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = getNumChildren()-1; i != e; ++i) { 1283d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(i+1)->ApplyTypeConstraints(TP, NotRegisters); 1284d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1285d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType OpVT = Int->IS.ParamVTs[i]; 1286d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(i+1)->getNumTypes() == 1 && "Unhandled case"); 1287d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(i+1)->UpdateNodeType(0, OpVT, TP); 12886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 12906eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 12916eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 12926eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->isSubClassOf("SDNode")) { 12936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NI = CDP.getSDNodeInfo(getOperator()); 12946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12952a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner // Check that the number of operands is sane. Negative operands -> varargs. 12962a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner if (NI.getNumOperands() >= 0 && 12972a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner getNumChildren() != (unsigned)NI.getNumOperands()) 12982a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner TP.error(getOperator()->getName() + " node requires exactly " + 12992a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner itostr(NI.getNumOperands()) + " operands!"); 13002a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner 13016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = NI.ApplyTypeConstraints(this, TP); 13026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 13036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters); 1304d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return MadeChange; 13056eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 13066eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 13076eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->isSubClassOf("Instruction")) { 13086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const DAGInstruction &Inst = CDP.getInstruction(getOperator()); 13096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CodeGenInstruction &InstInfo = 1310f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CDP.getTargetInfo().getInstruction(getOperator()); 13116c6ba364931acb113973ad3e6d69736969c59299Chris Lattner 13120be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner bool MadeChange = false; 13130be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 13140be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // Apply the result types to the node, these come from the things in the 13150be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // (outs) list of the instruction. 13160be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: Cap at one result so far. 13170be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned NumResultsToAdd = InstInfo.NumDefs ? 1 : 0; 13180be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner for (unsigned ResNo = 0; ResNo != NumResultsToAdd; ++ResNo) { 13190be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner Record *ResultNode = Inst.getResult(ResNo); 13206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1321a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner if (ResultNode->isSubClassOf("PointerLikeRegClass")) { 13220be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= UpdateNodeType(ResNo, MVT::iPTR, TP); 13235b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb } else if (ResultNode->getName() == "unknown") { 13242cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Nothing to do. 13256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 13266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(ResultNode->isSubClassOf("RegisterClass") && 13276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "Operands should be register classes!"); 13286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenRegisterClass &RC = 13296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CDP.getTargetInfo().getRegisterClass(ResultNode); 13300be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= UpdateNodeType(ResNo, RC.getValueTypes(), TP); 13316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 13320be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner } 13330be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 13340be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // If the instruction has implicit defs, we apply the first one as a result. 13350be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: This sucks, it should apply all implicit defs. 13360be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner if (!InstInfo.ImplicitDefs.empty()) { 13370be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned ResNo = NumResultsToAdd; 13380be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 13399414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // FIXME: Generalize to multiple possible types and multiple possible 13409414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // ImplicitDefs. 13419414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner MVT::SimpleValueType VT = 13429414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()); 13439414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner 13449414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (VT != MVT::Other) 13459414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner MadeChange |= UpdateNodeType(ResNo, VT, TP); 13466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 13472cacec55f947c716b058a39038889550d7e39b3cChris Lattner 13482cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this is an INSERT_SUBREG, constrain the source and destination VTs to 13492cacec55f947c716b058a39038889550d7e39b3cChris Lattner // be the same. 13502cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (getOperator()->getName() == "INSERT_SUBREG") { 1351d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(0)->getNumTypes() == 1 && "FIXME: Unhandled"); 1352d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(0, getChild(0)->getExtType(0), TP); 1353d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(0)->UpdateNodeType(0, getExtType(0), TP); 13542cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 13556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned ChildNo = 0; 13576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Inst.getNumOperands(); i != e; ++i) { 13586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *OperandNode = Inst.getOperand(i); 13596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the instruction expects a predicate or optional def operand, we 13616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // codegen this by setting the operand to it's default value if it has a 13626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // non-empty DefaultOps field. 13636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if ((OperandNode->isSubClassOf("PredicateOperand") || 13646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OperandNode->isSubClassOf("OptionalDefOperand")) && 13656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !CDP.getDefaultOperand(OperandNode).DefaultOps.empty()) 13666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 13676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we didn't run out of provided operands. 13696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (ChildNo >= getNumChildren()) 13706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Instruction '" + getOperator()->getName() + 13716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' expects more operands than were provided."); 13726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1373825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::SimpleValueType VT; 13746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = getChild(ChildNo++); 13750be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned ChildResNo = 0; // Instructions always use res #0 of their op. 1376d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 13776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OperandNode->isSubClassOf("RegisterClass")) { 13786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenRegisterClass &RC = 13796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CDP.getTargetInfo().getRegisterClass(OperandNode); 13800be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= Child->UpdateNodeType(ChildResNo, RC.getValueTypes(), TP); 13816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (OperandNode->isSubClassOf("Operand")) { 13826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner VT = getValueType(OperandNode->getValueAsDef("Type")); 13830be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= Child->UpdateNodeType(ChildResNo, VT, TP); 1384a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner } else if (OperandNode->isSubClassOf("PointerLikeRegClass")) { 13850be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= Child->UpdateNodeType(ChildResNo, MVT::iPTR, TP); 13865b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb } else if (OperandNode->getName() == "unknown") { 13872cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Nothing to do. 13886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 13896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(0 && "Unknown operand type!"); 13906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner abort(); 13916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 13926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= Child->ApplyTypeConstraints(TP, NotRegisters); 13936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 13945b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb 139502f693708d0731cfd31f8ab69766f150c169231eChristopher Lamb if (ChildNo != getNumChildren()) 13966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Instruction '" + getOperator()->getName() + 13976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' was provided too many operands!"); 13986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 14006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14016eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 14026eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner assert(getOperator()->isSubClassOf("SDNodeXForm") && "Unknown node type!"); 14036eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 14046eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // Node transforms always take one operand. 14056eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getNumChildren() != 1) 14066eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner TP.error("Node transform '" + getOperator()->getName() + 14076eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner "' requires one operand!"); 14086eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 14092cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = getChild(0)->ApplyTypeConstraints(TP, NotRegisters); 14102cacec55f947c716b058a39038889550d7e39b3cChris Lattner 14112cacec55f947c716b058a39038889550d7e39b3cChris Lattner 14126eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // If either the output or input of the xform does not have exact 14136eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // type info. We assume they must be the same. Otherwise, it is perfectly 14146eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // legal to transform from one type to a completely different type. 14152cacec55f947c716b058a39038889550d7e39b3cChris Lattner#if 0 14166eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (!hasTypeSet() || !getChild(0)->hasTypeSet()) { 14172cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = UpdateNodeType(getChild(0)->getExtType(), TP); 14182cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= getChild(0)->UpdateNodeType(getExtType(), TP); 14196eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner return MadeChange; 14206eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 14212cacec55f947c716b058a39038889550d7e39b3cChris Lattner#endif 14222cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 14236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// OnlyOnRHSOfCommutative - Return true if this value is only allowed on the 14266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// RHS of a commutative operation, not the on LHS. 14276cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic bool OnlyOnRHSOfCommutative(TreePatternNode *N) { 14286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!N->isLeaf() && N->getOperator()->getName() == "imm") 14296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 14306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->isLeaf() && dynamic_cast<IntInit*>(N->getLeafValue())) 14316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 14326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 14336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// canPatternMatch - If it is impossible for this pattern to match on this 14376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// target, fill in Reason and return false. Otherwise, return true. This is 1438da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach/// used as a sanity check for .td files (to prevent people from writing stuff 14396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// that can never possibly work), and to prevent the pattern permuter from 14406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// generating stuff that is useless. 14416cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool TreePatternNode::canPatternMatch(std::string &Reason, 1442ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP) { 14436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return true; 14446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 14466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getChild(i)->canPatternMatch(Reason, CDP)) 14476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 14486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is an intrinsic, handle cases that would make it not match. For 14506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // example, if an operand is required to be an immediate. 14516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getOperator()->isSubClassOf("Intrinsic")) { 14526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // TODO: 14536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 14546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this node is a commutative operator, check that the LHS isn't an 14576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // immediate. 14586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(getOperator()); 14596bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool isCommIntrinsic = isCommutativeIntrinsic(CDP); 14606bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { 14616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan all of the operands of the node and make sure that only the last one 14626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // is a constant node, unless the RHS also is. 14636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OnlyOnRHSOfCommutative(getChild(getNumChildren()-1))) { 14646bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool Skip = isCommIntrinsic ? 1 : 0; // First operand is intrinsic id. 14656bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng for (unsigned i = Skip, e = getNumChildren()-1; i != e; ++i) 14666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OnlyOnRHSOfCommutative(getChild(i))) { 14676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Reason="Immediate value must be on the RHS of commutative operators!"; 14686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 14696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 14746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 14776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// TreePattern implementation 14786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 14796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14806cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput, 1481fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ 14822cacec55f947c716b058a39038889550d7e39b3cChris Lattner isInputPattern = isInput; 14832cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = RawPat->getSize(); i != e; ++i) 1484c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Trees.push_back(ParseTreePattern(RawPat->getElement(i), "")); 14856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14876cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput, 1488fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ 14896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner isInputPattern = isInput; 1490c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Trees.push_back(ParseTreePattern(Pat, "")); 14916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14936cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePattern::TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput, 1494fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ 14956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner isInputPattern = isInput; 14966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Trees.push_back(Pat); 14976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14996cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePattern::error(const std::string &Msg) const { 15006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner dump(); 1501a14b1ded69dc76f4e41ef60eeab89dc8575af44bChris Lattner throw TGError(TheRecord->getLoc(), "In " + TheRecord->getName() + ": " + Msg); 15026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 15036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15042cacec55f947c716b058a39038889550d7e39b3cChris Lattnervoid TreePattern::ComputeNamedNodes() { 15052cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) 15062cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(Trees[i]); 15072cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 15082cacec55f947c716b058a39038889550d7e39b3cChris Lattner 15092cacec55f947c716b058a39038889550d7e39b3cChris Lattnervoid TreePattern::ComputeNamedNodes(TreePatternNode *N) { 15102cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!N->getName().empty()) 15112cacec55f947c716b058a39038889550d7e39b3cChris Lattner NamedNodes[N->getName()].push_back(N); 15122cacec55f947c716b058a39038889550d7e39b3cChris Lattner 15132cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 15142cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(N->getChild(i)); 15152cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 15162cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1517d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1518c217305f764447eb65e7bf7f9205c14632885969Chris LattnerTreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){ 1519c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (DefInit *DI = dynamic_cast<DefInit*>(TheInit)) { 1520c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Record *R = DI->getDef(); 1521c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1522c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Direct reference to a leaf DagNode or PatFrag? Turn it into a 1523c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // TreePatternNode if its own. For example: 1524c217305f764447eb65e7bf7f9205c14632885969Chris Lattner /// (foo GPR, imm) -> (foo GPR, (imm)) 1525c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag")) 1526c217305f764447eb65e7bf7f9205c14632885969Chris Lattner return ParseTreePattern(new DagInit(DI, "", 1527c217305f764447eb65e7bf7f9205c14632885969Chris Lattner std::vector<std::pair<Init*, std::string> >()), 1528c217305f764447eb65e7bf7f9205c14632885969Chris Lattner OpName); 1529c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1530c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Input argument? 1531c217305f764447eb65e7bf7f9205c14632885969Chris Lattner TreePatternNode *Res = new TreePatternNode(DI, 1); 15322a22cdc716ea652d6c9ebdaae028b5c75ab2793aChris Lattner if (R->getName() == "node" && !OpName.empty()) { 1533c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (OpName.empty()) 1534c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("'node' argument requires a name to match with operand list"); 1535c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Args.push_back(OpName); 1536c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1537c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1538c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Res->setName(OpName); 1539c217305f764447eb65e7bf7f9205c14632885969Chris Lattner return Res; 1540c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1541c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1542c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (IntInit *II = dynamic_cast<IntInit*>(TheInit)) { 1543c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!OpName.empty()) 1544c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("Constant int argument should not have a name!"); 1545c217305f764447eb65e7bf7f9205c14632885969Chris Lattner return new TreePatternNode(II, 1); 1546c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1547c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1548c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (BitsInit *BI = dynamic_cast<BitsInit*>(TheInit)) { 1549c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Turn this into an IntInit. 1550c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Init *II = BI->convertInitializerTo(new IntRecTy()); 1551c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (II == 0 || !dynamic_cast<IntInit*>(II)) 1552c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("Bits value must be constants!"); 1553b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner return ParseTreePattern(II, OpName); 1554c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 1555c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1556c217305f764447eb65e7bf7f9205c14632885969Chris Lattner DagInit *Dag = dynamic_cast<DagInit*>(TheInit); 1557c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!Dag) { 1558c217305f764447eb65e7bf7f9205c14632885969Chris Lattner TheInit->dump(); 1559c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("Pattern has unexpected init kind!"); 1560c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 15616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator()); 15626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OpDef) error("Pattern has unexpected operator type!"); 15636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Operator = OpDef->getDef(); 15646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Operator->isSubClassOf("ValueType")) { 15666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the operator is a ValueType, then this must be "type cast" of a leaf 15676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // node. 15686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Dag->getNumArgs() != 1) 15696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Type cast only takes one operand!"); 15706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1571c217305f764447eb65e7bf7f9205c14632885969Chris Lattner TreePatternNode *New = ParseTreePattern(Dag->getArg(0), Dag->getArgName(0)); 15726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the type cast. 1574d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(New->getNumTypes() == 1 && "FIXME: Unhandled"); 1575d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New->UpdateNodeType(0, getValueType(Operator), *this); 1576c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1577c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!OpName.empty()) 1578c217305f764447eb65e7bf7f9205c14632885969Chris Lattner error("ValueType cast should not have a name!"); 15796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return New; 15806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that this is something that makes sense for an operator. 15837cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (!Operator->isSubClassOf("PatFrag") && 15847cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman !Operator->isSubClassOf("SDNode") && 15856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("Instruction") && 15866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("SDNodeXForm") && 15876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("Intrinsic") && 15886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator->getName() != "set" && 1589310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner Operator->getName() != "implicit") 15906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Unrecognized node '" + Operator->getName() + "'!"); 15916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check to see if this is something that is illegal in an input pattern. 1593b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (isInputPattern) { 1594b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (Operator->isSubClassOf("Instruction") || 1595b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->isSubClassOf("SDNodeXForm")) 1596b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner error("Cannot use '" + Operator->getName() + "' in an input pattern!"); 1597b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner } else { 1598b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (Operator->isSubClassOf("Intrinsic")) 1599b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner error("Cannot use '" + Operator->getName() + "' in an output pattern!"); 1600b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner 1601b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner if (Operator->isSubClassOf("SDNode") && 1602b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "imm" && 1603b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "fpimm" && 1604b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tglobaltlsaddr" && 1605b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tconstpool" && 1606b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tjumptable" && 1607b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tframeindex" && 1608b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "texternalsym" && 1609b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tblockaddress" && 1610b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "tglobaladdr" && 1611b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "bb" && 1612b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner Operator->getName() != "vt") 1613b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner error("Cannot use '" + Operator->getName() + "' in an output pattern!"); 1614b775b1e20bb9adc2a5130f7470f2f525280f1036Chris Lattner } 16156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 1617c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1618c217305f764447eb65e7bf7f9205c14632885969Chris Lattner // Parse all the operands. 1619c217305f764447eb65e7bf7f9205c14632885969Chris Lattner for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) 1620c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Children.push_back(ParseTreePattern(Dag->getArg(i), Dag->getArgName(i))); 16216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the operator is an intrinsic, then this is just syntactic sugar for for 16236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (intrinsic_* <number>, ..children..). Pick the right intrinsic node, and 16246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // convert the intrinsic name to a number. 16256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Operator->isSubClassOf("Intrinsic")) { 16266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenIntrinsic &Int = getDAGPatterns().getIntrinsic(Operator); 16276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned IID = getDAGPatterns().getIntrinsicID(Operator)+1; 16286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this intrinsic returns void, it must have side-effects and thus a 16306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // chain. 1631c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (Int.IS.RetVTs.empty()) 16326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_void_sdnode(); 1633c217305f764447eb65e7bf7f9205c14632885969Chris Lattner else if (Int.ModRef != CodeGenIntrinsic::NoMem) 16346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Has side-effects, requires chain. 16356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_w_chain_sdnode(); 1636c217305f764447eb65e7bf7f9205c14632885969Chris Lattner else // Otherwise, no chain. 16376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode(); 16386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1639d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *IIDNode = new TreePatternNode(new IntInit(IID), 1); 16406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.insert(Children.begin(), IIDNode); 16416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 16426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1643d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner unsigned NumResults = GetNumNodeResults(Operator, CDP); 1644d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Result = new TreePatternNode(Operator, Children, NumResults); 1645c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Result->setName(OpName); 1646c217305f764447eb65e7bf7f9205c14632885969Chris Lattner 1647c217305f764447eb65e7bf7f9205c14632885969Chris Lattner if (!Dag->getName().empty()) { 1648c217305f764447eb65e7bf7f9205c14632885969Chris Lattner assert(Result->getName().empty()); 1649c217305f764447eb65e7bf7f9205c14632885969Chris Lattner Result->setName(Dag->getName()); 1650c217305f764447eb65e7bf7f9205c14632885969Chris Lattner } 16517cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman return Result; 16526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 16536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16547a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// SimplifyTree - See if we can simplify this tree to eliminate something that 16557a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// will never match in favor of something obvious that will. This is here 16567a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// strictly as a convenience to target authors because it allows them to write 16577a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// more type generic things and have useless type casts fold away. 16587a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// 16597a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner/// This returns true if any change is made. 16607a0eb91b4c238542a11ca805af15933cc8290786Chris Lattnerstatic bool SimplifyTree(TreePatternNode *&N) { 16617a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner if (N->isLeaf()) 16627a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner return false; 16637a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 16647a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner // If we have a bitconvert with a resolved type and if the source and 16657a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner // destination types are the same, then the bitconvert is useless, remove it. 16667a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner if (N->getOperator()->getName() == "bitconvert" && 16677a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->getExtType(0).isConcrete() && 16687a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->getExtType(0) == N->getChild(0)->getExtType(0) && 16697a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->getName().empty()) { 16707a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N = N->getChild(0); 16717a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner SimplifyTree(N); 16727a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner return true; 16737a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner } 16747a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 16757a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner // Walk all children. 16767a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner bool MadeChange = false; 16777a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { 16787a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner TreePatternNode *Child = N->getChild(i); 16797a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner MadeChange |= SimplifyTree(Child); 16807a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner N->setChild(i, Child); 16817a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner } 16827a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner return MadeChange; 16837a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner} 16847a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 16857a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 16867a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner 16876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// InferAllTypes - Infer/propagate as many types throughout the expression 1688da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach/// patterns as possible. Return true if all types are inferred, false 16896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// otherwise. Throw an exception if a type contradiction is found. 16902cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool TreePattern:: 16912cacec55f947c716b058a39038889550d7e39b3cChris LattnerInferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) { 16922cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (NamedNodes.empty()) 16932cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(); 16942cacec55f947c716b058a39038889550d7e39b3cChris Lattner 16956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = true; 16966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (MadeChange) { 16976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange = false; 16987a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) { 16996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= Trees[i]->ApplyTypeConstraints(*this, false); 17007a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner MadeChange |= SimplifyTree(Trees[i]); 17017a0eb91b4c238542a11ca805af15933cc8290786Chris Lattner } 17022cacec55f947c716b058a39038889550d7e39b3cChris Lattner 17032cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If there are constraints on our named nodes, apply them. 17042cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (StringMap<SmallVector<TreePatternNode*,1> >::iterator 17052cacec55f947c716b058a39038889550d7e39b3cChris Lattner I = NamedNodes.begin(), E = NamedNodes.end(); I != E; ++I) { 17062cacec55f947c716b058a39038889550d7e39b3cChris Lattner SmallVectorImpl<TreePatternNode*> &Nodes = I->second; 17072cacec55f947c716b058a39038889550d7e39b3cChris Lattner 17082cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we have input named node types, propagate their types to the named 17092cacec55f947c716b058a39038889550d7e39b3cChris Lattner // values here. 17102cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InNamedTypes) { 17112cacec55f947c716b058a39038889550d7e39b3cChris Lattner // FIXME: Should be error? 17122cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(InNamedTypes->count(I->getKey()) && 17132cacec55f947c716b058a39038889550d7e39b3cChris Lattner "Named node in output pattern but not input pattern?"); 17142cacec55f947c716b058a39038889550d7e39b3cChris Lattner 17152cacec55f947c716b058a39038889550d7e39b3cChris Lattner const SmallVectorImpl<TreePatternNode*> &InNodes = 17162cacec55f947c716b058a39038889550d7e39b3cChris Lattner InNamedTypes->find(I->getKey())->second; 17172cacec55f947c716b058a39038889550d7e39b3cChris Lattner 17182cacec55f947c716b058a39038889550d7e39b3cChris Lattner // The input types should be fully resolved by now. 17192cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Nodes.size(); i != e; ++i) { 17202cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this node is a register class, and it is the root of the pattern 17212cacec55f947c716b058a39038889550d7e39b3cChris Lattner // then we're mapping something onto an input register. We allow 17222cacec55f947c716b058a39038889550d7e39b3cChris Lattner // changing the type of the input register in this case. This allows 17232cacec55f947c716b058a39038889550d7e39b3cChris Lattner // us to match things like: 17242cacec55f947c716b058a39038889550d7e39b3cChris Lattner // def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>; 17252cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) { 17262cacec55f947c716b058a39038889550d7e39b3cChris Lattner DefInit *DI = dynamic_cast<DefInit*>(Nodes[i]->getLeafValue()); 17272cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (DI && DI->getDef()->isSubClassOf("RegisterClass")) 17282cacec55f947c716b058a39038889550d7e39b3cChris Lattner continue; 17292cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 17302cacec55f947c716b058a39038889550d7e39b3cChris Lattner 173132f6a8b8bb9de0180036eaf7f7ac6dc030d85655Daniel Dunbar assert(Nodes[i]->getNumTypes() == 1 && 1732d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner InNodes[0]->getNumTypes() == 1 && 1733d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "FIXME: cannot name multiple result nodes yet"); 1734d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Nodes[i]->UpdateNodeType(0, InNodes[0]->getExtType(0), 1735d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner *this); 17362cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 17372cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 17382cacec55f947c716b058a39038889550d7e39b3cChris Lattner 17392cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If there are multiple nodes with the same name, they must all have the 17402cacec55f947c716b058a39038889550d7e39b3cChris Lattner // same type. 17412cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (I->second.size() > 1) { 17422cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Nodes.size()-1; i != e; ++i) { 1743d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *N1 = Nodes[i], *N2 = Nodes[i+1]; 174432f6a8b8bb9de0180036eaf7f7ac6dc030d85655Daniel Dunbar assert(N1->getNumTypes() == 1 && N2->getNumTypes() == 1 && 1745d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "FIXME: cannot name multiple result nodes yet"); 1746d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1747d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= N1->UpdateNodeType(0, N2->getExtType(0), *this); 1748d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= N2->UpdateNodeType(0, N1->getExtType(0), *this); 17492cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 17502cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 17512cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 17526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool HasUnresolvedTypes = false; 17556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) 17566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner HasUnresolvedTypes |= Trees[i]->ContainsUnresolvedType(); 17576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return !HasUnresolvedTypes; 17586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17601a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePattern::print(raw_ostream &OS) const { 17616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << getRecord()->getName(); 17626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Args.empty()) { 17636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "(" << Args[0]; 17646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) 17656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ", " << Args[i]; 17666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ")"; 17676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ": "; 17696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Trees.size() > 1) 17716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "[\n"; 17726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) { 17736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "\t"; 17746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Trees[i]->print(OS); 17756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "\n"; 17766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Trees.size() > 1) 17796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "]\n"; 17806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17821a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePattern::dump() const { print(errs()); } 17836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 1785fe71893183f504feff290e343bf740bd32432129Chris Lattner// CodeGenDAGPatterns implementation 17866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 17876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1788fe71893183f504feff290e343bf740bd32432129Chris LattnerCodeGenDAGPatterns::CodeGenDAGPatterns(RecordKeeper &R) : Records(R) { 178949de98214b82fefeb8f16efbf8cdd8813a85469bDale Johannesen Intrinsics = LoadIntrinsics(Records, false); 179049de98214b82fefeb8f16efbf8cdd8813a85469bDale Johannesen TgtIntrinsics = LoadIntrinsics(Records, true); 17916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseNodeInfo(); 1792443e3f9dd61b8d0974bb13d484195ce1a9b7536cChris Lattner ParseNodeTransforms(); 17936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseComplexPatterns(); 1794dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner ParsePatternFragments(); 17956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseDefaultOperands(); 17966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseInstructions(); 17976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParsePatterns(); 17986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Generate variants. For example, commutative patterns can match 18006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // multiple ways. Add them to PatternsToMatch as well. 18016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GenerateVariants(); 1802ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 1803ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Infer instruction flags. For example, we can detect loads, 1804ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // stores, and side effects in many cases by examining an 1805ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // instruction's pattern. 1806ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InferInstructionFlags(); 18076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1809fe71893183f504feff290e343bf740bd32432129Chris LattnerCodeGenDAGPatterns::~CodeGenDAGPatterns() { 18105b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer for (pf_iterator I = PatternFragments.begin(), 18116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner E = PatternFragments.end(); I != E; ++I) 18126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete I->second; 18136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1816fe71893183f504feff290e343bf740bd32432129Chris LattnerRecord *CodeGenDAGPatterns::getSDNodeNamed(const std::string &Name) const { 18176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *N = Records.getDef(Name); 18186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!N || !N->isSubClassOf("SDNode")) { 18191a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Error getting SDNode '" << Name << "'!\n"; 18206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 18216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 18226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return N; 18236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// Parse all of the SDNode definitions for the target, populating SDNodes. 1826fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseNodeInfo() { 18276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("SDNode"); 18286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!Nodes.empty()) { 18296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SDNodes.insert(std::make_pair(Nodes.back(), Nodes.back())); 18306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Nodes.pop_back(); 18316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 18326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1833da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // Get the builtin intrinsic nodes. 18346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_void_sdnode = getSDNodeNamed("intrinsic_void"); 18356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_w_chain_sdnode = getSDNodeNamed("intrinsic_w_chain"); 18366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_wo_chain_sdnode = getSDNodeNamed("intrinsic_wo_chain"); 18376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParseNodeTransforms - Parse all SDNodeXForm instances into the SDNodeXForms 18406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// map, and emit them to the file as functions. 1841fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseNodeTransforms() { 18426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Xforms = Records.getAllDerivedDefinitions("SDNodeXForm"); 18436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!Xforms.empty()) { 18446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *XFormNode = Xforms.back(); 18456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *SDNode = XFormNode->getValueAsDef("Opcode"); 18466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::string Code = XFormNode->getValueAsCode("XFormFunction"); 1847443e3f9dd61b8d0974bb13d484195ce1a9b7536cChris Lattner SDNodeXForms.insert(std::make_pair(XFormNode, NodeXForm(SDNode, Code))); 18486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Xforms.pop_back(); 18506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 18516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1853fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseComplexPatterns() { 18546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> AMs = Records.getAllDerivedDefinitions("ComplexPattern"); 18556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!AMs.empty()) { 18566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ComplexPatterns.insert(std::make_pair(AMs.back(), AMs.back())); 18576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AMs.pop_back(); 18586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 18596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParsePatternFragments - Parse all of the PatFrag definitions in the .td 18636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// file, building up the PatternFragments map. After we've collected them all, 18646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// inline fragments together as necessary, so that there are no references left 18656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// inside a pattern fragment to a pattern fragment. 18666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 1867fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParsePatternFragments() { 18686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Fragments = Records.getAllDerivedDefinitions("PatFrag"); 18696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1870dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // First step, parse all of the fragments. 18716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { 18726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DagInit *Tree = Fragments[i]->getValueAsDag("Fragment"); 18736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this); 18746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternFragments[Fragments[i]] = P; 18756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1876dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // Validate the argument list, converting it to set, to discard duplicates. 18776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::string> &Args = P->getArgList(); 1878dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner std::set<std::string> OperandsSet(Args.begin(), Args.end()); 18796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1880dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (OperandsSet.count("")) 18816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Cannot have unnamed 'node' values in pattern fragment!"); 18826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the operands list. 18846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DagInit *OpsList = Fragments[i]->getValueAsDag("Operands"); 18856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *OpsOp = dynamic_cast<DefInit*>(OpsList->getOperator()); 18866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Special cases: ops == outs == ins. Different names are used to 1887da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // improve readability. 18886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OpsOp || 18896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner (OpsOp->getDef()->getName() != "ops" && 18906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpsOp->getDef()->getName() != "outs" && 18916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpsOp->getDef()->getName() != "ins")) 18926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should start with '(ops ... '!"); 18936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy over the arguments. 18956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Args.clear(); 18966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) { 18976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!dynamic_cast<DefInit*>(OpsList->getArg(j)) || 18986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner static_cast<DefInit*>(OpsList->getArg(j))-> 18996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getDef()->getName() != "node") 19006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should all be 'node' values."); 19016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OpsList->getArgName(j).empty()) 19026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should have names for each operand!"); 1903dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!OperandsSet.count(OpsList->getArgName(j))) 19046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("'" + OpsList->getArgName(j) + 19056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' does not occur in pattern or was multiply specified!"); 1906dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner OperandsSet.erase(OpsList->getArgName(j)); 19076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Args.push_back(OpsList->getArgName(j)); 19086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1910dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!OperandsSet.empty()) 19116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list does not contain an entry for operand '" + 1912dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner *OperandsSet.begin() + "'!"); 19136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1914dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // If there is a code init for this fragment, keep track of the fact that 1915dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // this fragment uses it. 19166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::string Code = Fragments[i]->getValueAsCode("Predicate"); 1917dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!Code.empty()) 19180540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman P->getOnlyTree()->addPredicateFn("Predicate_"+Fragments[i]->getName()); 19196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If there is a node transformation corresponding to this, keep track of 19216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // it. 19226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Transform = Fragments[i]->getValueAsDef("OperandTransform"); 19236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getSDNodeTransform(Transform).second.empty()) // not noop xform? 19246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->getOnlyTree()->setTransformFn(Transform); 19256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Now that we've parsed all of the tree fragments, do a closure on them so 19286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // that there are not references to PatFrags left inside of them. 19292ca698df93421327a459987b33b045756cb47d4dChris Lattner for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { 19302ca698df93421327a459987b33b045756cb47d4dChris Lattner TreePattern *ThePat = PatternFragments[Fragments[i]]; 19316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ThePat->InlinePatternFragments(); 19326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. Don't worry about it if we don't infer 19346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // all of them, some may depend on the inputs of the pattern. 19356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner try { 19366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ThePat->InferAllTypes(); 19376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } catch (...) { 19386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this pattern fragment is not supported by this target (no types can 19396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // satisfy its constraints), just ignore it. If the bogus pattern is 19406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // actually used by instructions, the type consistency error will be 19416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // reported there. 19426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If debugging, print out the pattern fragment result. 19456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DEBUG(ThePat->dump()); 19466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 19486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1949fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseDefaultOperands() { 19506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> DefaultOps[2]; 19516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOps[0] = Records.getAllDerivedDefinitions("PredicateOperand"); 19526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOps[1] = Records.getAllDerivedDefinitions("OptionalDefOperand"); 19536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find some SDNode. 19556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(!SDNodes.empty() && "No SDNodes parsed?"); 19566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Init *SomeSDNode = new DefInit(SDNodes.begin()->first); 19576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned iter = 0; iter != 2; ++iter) { 19596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = DefaultOps[iter].size(); i != e; ++i) { 19606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps"); 19616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Clone the DefaultInfo dag node, changing the operator from 'ops' to 19636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // SomeSDnode so that we can parse this. 19646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::pair<Init*, std::string> > Ops; 19656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned op = 0, e = DefaultInfo->getNumArgs(); op != e; ++op) 19666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Ops.push_back(std::make_pair(DefaultInfo->getArg(op), 19676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultInfo->getArgName(op))); 19687cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman DagInit *DI = new DagInit(SomeSDNode, "", Ops); 19696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create a TreePattern to parse this. 19716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern P(DefaultOps[iter][i], DI, false, *this); 19726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(P.getNumTrees() == 1 && "This ctor can only produce one tree!"); 19736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy the operands over into a DAGDefaultOperand. 19756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGDefaultOperand DefaultOpInfo; 19766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *T = P.getTree(0); 19786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned op = 0, e = T->getNumChildren(); op != e; ++op) { 19796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *TPN = T->getChild(op); 19806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (TPN->ApplyTypeConstraints(P, false)) 19816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner /* Resolve all types */; 19826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1983ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov if (TPN->ContainsUnresolvedType()) { 19846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (iter == 0) 19856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner throw "Value #" + utostr(i) + " of PredicateOperand '" + 198653d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner DefaultOps[iter][i]->getName() +"' doesn't have a concrete type!"; 19876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 19886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner throw "Value #" + utostr(i) + " of OptionalDefOperand '" + 198953d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner DefaultOps[iter][i]->getName() +"' doesn't have a concrete type!"; 1990ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov } 19916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOpInfo.DefaultOps.push_back(TPN); 19926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Insert it into the DefaultOperands map so we can find it later. 19956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOperands[DefaultOps[iter][i]] = DefaultOpInfo; 19966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 19996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// HandleUse - Given "Pat" a leaf in the pattern, check to see if it is an 20016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// instruction input. Return true if this is a real use. 20026cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic bool HandleUse(TreePattern *I, TreePatternNode *Pat, 2003acfb70f75061975deda1deb167da8e83249f92edChris Lattner std::map<std::string, TreePatternNode*> &InstInputs) { 20046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // No name -> not interesting. 20056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getName().empty()) { 20066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 20076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); 20086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (DI && DI->getDef()->isSubClassOf("RegisterClass")) 20096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Input " + DI->getDef()->getName() + " must be named!"); 20106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 20126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Rec; 20156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 20166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); 20176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!"); 20186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Rec = DI->getDef(); 20196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 20206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Rec = Pat->getOperator(); 20216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // SRCVALUE nodes are ignored. 20246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Rec->getName() == "srcvalue") 20256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 20266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *&Slot = InstInputs[Pat->getName()]; 20286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Slot) { 20296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Slot = Pat; 203053d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner return true; 203153d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner } 203253d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner Record *SlotRec; 203353d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner if (Slot->isLeaf()) { 203453d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner SlotRec = dynamic_cast<DefInit*>(Slot->getLeafValue())->getDef(); 20356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 203653d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner assert(Slot->getNumChildren() == 0 && "can't be a use with children!"); 203753d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner SlotRec = Slot->getOperator(); 20386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 203953d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner 204053d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner // Ensure that the inputs agree if we've already seen this input. 204153d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner if (Rec != SlotRec) 204253d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner I->error("All $" + Pat->getName() + " inputs must agree with each other"); 2043d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Slot->getExtTypes() != Pat->getExtTypes()) 204453d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner I->error("All $" + Pat->getName() + " inputs must agree with each other"); 20456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 20466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// FindPatternInputsAndOutputs - Scan the specified TreePatternNode (which is 20496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// part of "I", the instruction), computing the set of inputs and outputs of 20506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// the pattern. Report errors if we see anything naughty. 2051fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns:: 20526cefb77a7073057fecd721ae141140d75ce76512Chris LattnerFindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat, 20536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> &InstInputs, 20546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*>&InstResults, 20556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> &InstImpResults) { 20566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 2057acfb70f75061975deda1deb167da8e83249f92edChris Lattner bool isUse = HandleUse(I, Pat, InstInputs); 20586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isUse && Pat->getTransformFn()) 20596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function for a non-input value!"); 20606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 206184aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 206284aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner 206384aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner if (Pat->getOperator()->getName() == "implicit") { 20646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { 20656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Dest = Pat->getChild(i); 20666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dest->isLeaf()) 20676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("implicitly defined value should be a register!"); 20686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); 20706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Val || !Val->getDef()->isSubClassOf("Register")) 20716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("implicitly defined value should be a register!"); 20726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpResults.push_back(Val->getDef()); 20736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 207584aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 207684aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner 207784aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner if (Pat->getOperator()->getName() != "set") { 20786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is not a set, verify that the children nodes are not void typed, 20796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // and recurse. 20806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { 2081d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Pat->getChild(i)->getNumTypes() == 0) 20826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot have void nodes inside of patterns!"); 20836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat->getChild(i), InstInputs, InstResults, 2084acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstImpResults); 20856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is a non-leaf node with no children, treat it basically as if 20886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // it were a leaf. This handles nodes like (imm). 2089acfb70f75061975deda1deb167da8e83249f92edChris Lattner bool isUse = HandleUse(I, Pat, InstInputs); 20906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isUse && Pat->getTransformFn()) 20926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function for a non-input value!"); 20936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 209484aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 20956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, this is a set, validate and collect instruction results. 20976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getNumChildren() == 0) 20986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set requires operands!"); 20996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getTransformFn()) 21016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function on a set node!"); 21026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check the set destinations. 21046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NumDests = Pat->getNumChildren()-1; 21056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i != NumDests; ++i) { 21066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Dest = Pat->getChild(i); 21076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dest->isLeaf()) 21086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 21096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); 21116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Val) 21126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 21136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Val->getDef()->isSubClassOf("RegisterClass") || 2115a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner Val->getDef()->isSubClassOf("PointerLikeRegClass")) { 21166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Dest->getName().empty()) 21176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination must have a name!"); 21186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InstResults.count(Dest->getName())) 21196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("cannot set '" + Dest->getName() +"' multiple times"); 21206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstResults[Dest->getName()] = Dest; 21216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (Val->getDef()->isSubClassOf("Register")) { 21226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpResults.push_back(Val->getDef()); 21236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 21246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 21256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 21266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 21276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify and collect info from the computation. 21296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat->getChild(NumDests), 2130acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstInputs, InstResults, InstImpResults); 21316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 21326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2133ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman//===----------------------------------------------------------------------===// 2134ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman// Instruction Analysis 2135ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman//===----------------------------------------------------------------------===// 2136ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2137ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanclass InstAnalyzer { 2138ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP; 2139ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &mayStore; 2140ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &mayLoad; 2141ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &HasSideEffects; 21421e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool &IsVariadic; 2143ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanpublic: 2144ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstAnalyzer(const CodeGenDAGPatterns &cdp, 21451e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool &maystore, bool &mayload, bool &hse, bool &isv) 21461e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner : CDP(cdp), mayStore(maystore), mayLoad(mayload), HasSideEffects(hse), 21471e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner IsVariadic(isv) { 2148ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2149ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2150ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman /// Analyze - Analyze the specified instruction, returning true if the 2151ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman /// instruction had a pattern. 2152ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool Analyze(Record *InstRecord) { 2153ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const TreePattern *Pattern = CDP.getInstruction(InstRecord).getPattern(); 2154ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Pattern == 0) { 2155ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = 1; 2156ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return false; // No pattern. 2157ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2158ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2159ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // FIXME: Assume only the first tree is the pattern. The others are clobber 2160ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // nodes. 2161ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman AnalyzeNode(Pattern->getTree(0)); 2162ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return true; 2163ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2164ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2165ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanprivate: 2166ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman void AnalyzeNode(const TreePatternNode *N) { 2167ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (N->isLeaf()) { 2168ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) { 2169ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Record *LeafRec = DI->getDef(); 2170ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Handle ComplexPattern leaves. 2171ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (LeafRec->isSubClassOf("ComplexPattern")) { 2172ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const ComplexPattern &CP = CDP.getComplexPattern(LeafRec); 2173ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPMayStore)) mayStore = true; 2174ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPMayLoad)) mayLoad = true; 2175ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPSideEffect)) HasSideEffects = true; 2176ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2177ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2178ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return; 2179ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2180ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2181ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Analyze children. 2182ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 2183ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman AnalyzeNode(N->getChild(i)); 2184ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2185ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Ignore set nodes, which are not SDNodes. 2186ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (N->getOperator()->getName() == "set") 2187ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return; 2188ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2189ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Get information about the SDNode for the operator. 2190ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const SDNodeInfo &OpInfo = CDP.getSDNodeInfo(N->getOperator()); 2191ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2192ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Notice properties of the node. 2193ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPMayStore)) mayStore = true; 2194ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPMayLoad)) mayLoad = true; 2195ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPSideEffect)) HasSideEffects = true; 21961e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner if (OpInfo.hasProperty(SDNPVariadic)) IsVariadic = true; 2197ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2198ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (const CodeGenIntrinsic *IntInfo = N->getIntrinsicInfo(CDP)) { 2199ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If this is an intrinsic, analyze it. 2200ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadArgMem) 2201ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman mayLoad = true;// These may load memory. 2202ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 22037365c091f92db5e68c98d7faedc6c34e1bbbc898Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadWriteArgMem) 2204ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman mayStore = true;// Intrinsics that can write to memory are 'mayStore'. 2205ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 22067365c091f92db5e68c98d7faedc6c34e1bbbc898Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadWriteMem) 2207ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // WriteMem intrinsics can have other strange effects. 2208ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = true; 2209ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2210ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2211ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2212ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman}; 2213ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2214ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanstatic void InferFromPattern(const CodeGenInstruction &Inst, 2215ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &MayStore, bool &MayLoad, 22161e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool &HasSideEffects, bool &IsVariadic, 2217ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP) { 22181e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner MayStore = MayLoad = HasSideEffects = IsVariadic = false; 2219ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2220ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool HadPattern = 22211e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner InstAnalyzer(CDP, MayStore, MayLoad, HasSideEffects, IsVariadic) 22221e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner .Analyze(Inst.TheDef); 2223ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2224ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // InstAnalyzer only correctly analyzes mayStore/mayLoad so far. 2225ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.mayStore) { // If the .td file explicitly sets mayStore, use it. 2226ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If we decided that this is a store from the pattern, then the .td file 2227ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // entry is redundant. 2228ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (MayStore) 2229ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, 2230ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "Warning: mayStore flag explicitly set on instruction '%s'" 2231ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman " but flag already inferred from pattern.\n", 2232ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Inst.TheDef->getName().c_str()); 2233ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman MayStore = true; 2234ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2235ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2236ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.mayLoad) { // If the .td file explicitly sets mayLoad, use it. 2237ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If we decided that this is a load from the pattern, then the .td file 2238ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // entry is redundant. 2239ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (MayLoad) 2240ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, 2241ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "Warning: mayLoad flag explicitly set on instruction '%s'" 2242ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman " but flag already inferred from pattern.\n", 2243ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Inst.TheDef->getName().c_str()); 2244ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman MayLoad = true; 2245ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2246ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2247ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.neverHasSideEffects) { 2248ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (HadPattern) 2249ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, "Warning: neverHasSideEffects set on instruction '%s' " 2250ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "which already has a pattern\n", Inst.TheDef->getName().c_str()); 2251ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = false; 2252ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2253ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2254ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.hasSideEffects) { 2255ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (HasSideEffects) 2256ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, "Warning: hasSideEffects set on instruction '%s' " 2257ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "which already inferred this.\n", Inst.TheDef->getName().c_str()); 2258ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = true; 2259ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 22601e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner 22611e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner if (Inst.isVariadic) 22621e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner IsVariadic = true; // Can warn if we want. 2263ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman} 2264ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 22656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParseInstructions - Parse all of the instructions, inlining and resolving 22666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// any fragments involved. This populates the Instructions list with fully 22676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// resolved instructions. 2268fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseInstructions() { 22696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction"); 22706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Instrs.size(); i != e; ++i) { 22726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ListInit *LI = 0; 22736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (dynamic_cast<ListInit*>(Instrs[i]->getValueInit("Pattern"))) 22756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner LI = Instrs[i]->getValueAsListInit("Pattern"); 22766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If there is no pattern, only collect minimal information about the 22786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // instruction for its operand list. We have to assume that there is one 22796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // result, as we have no detailed info. 22806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!LI || LI->getSize() == 0) { 22816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Results; 22826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Operands; 22836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2284f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CodeGenInstruction &InstInfo = Target.getInstruction(Instrs[i]); 22856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InstInfo.OperandList.size() != 0) { 22876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InstInfo.NumDefs == 0) { 22886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // These produce no results 22896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = InstInfo.OperandList.size(); j < e; ++j) 22906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operands.push_back(InstInfo.OperandList[j].Rec); 22916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 22926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Assume the first operand is the result. 22936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Results.push_back(InstInfo.OperandList[0].Rec); 22946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The rest are inputs. 22966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 1, e = InstInfo.OperandList.size(); j < e; ++j) 22976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operands.push_back(InstInfo.OperandList[j].Rec); 22986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create and insert the instruction. 23026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> ImpResults; 23036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Instructions.insert(std::make_pair(Instrs[i], 230462bcec82b2762d5cdc84fe39c7d634c784ed6673Chris Lattner DAGInstruction(0, Results, Operands, ImpResults))); 23056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; // no pattern. 23066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the instruction. 23096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *I = new TreePattern(Instrs[i], LI, true, *this); 23106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 23116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->InlinePatternFragments(); 23126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we can 23146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // never do anything with this instruction pattern: report it to the user. 23156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!I->InferAllTypes()) 23166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Could not infer all types in pattern!"); 23176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // InstInputs - Keep track of all of the inputs of the instruction, along 23196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // with the record they are declared as. 23206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputs; 23216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // InstResults - Keep track of all the virtual registers that are 'set' 23236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // in the instruction, including what reg class they are. 23246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstResults; 23256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpResults; 23276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that the top-level forms in the instruction are of void type, and 23296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // fill in the InstResults map. 23306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = I->getNumTrees(); j != e; ++j) { 23316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Pat = I->getTree(j); 2332d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Pat->getNumTypes() != 0) 23336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Top-level forms in instruction pattern should have" 23346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " void types"); 23356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find inputs and outputs, and verify the structure of the uses/defs. 23376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat, InstInputs, InstResults, 2338acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstImpResults); 23396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Now that we have inputs and outputs of the pattern, inspect the operands 23426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // list for the instruction. This determines the order that operands are 23436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // added to the machine instruction the node corresponds to. 23446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NumResults = InstResults.size(); 23456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the operands list from the (ops) list, validating it. 23476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(I->getArgList().empty() && "Args list should still be empty here!"); 2348f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CodeGenInstruction &CGI = Target.getInstruction(Instrs[i]); 23496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check that all of the results occur first in the list. 23516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Results; 2352d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Res0Node = 0; 23536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i != NumResults; ++i) { 23546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (i == CGI.OperandList.size()) 23556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("'" + InstResults.begin()->first + 23566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' set but does not appear in operand list!"); 23576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::string &OpName = CGI.OperandList[i].Name; 23586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check that it exists in InstResults. 23606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *RNode = InstResults[OpName]; 23616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (RNode == 0) 23626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " does not exist in operand list!"); 23636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (i == 0) 23656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Res0Node = RNode; 23666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *R = dynamic_cast<DefInit*>(RNode->getLeafValue())->getDef(); 23676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R == 0) 23686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " should be a set destination: all " 23696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "outputs must occur before inputs in operand list!"); 23706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (CGI.OperandList[i].Rec != R) 23726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " class mismatch!"); 23736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Remember the return type. 23756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Results.push_back(CGI.OperandList[i].Rec); 23766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Okay, this one checks out. 23786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstResults.erase(OpName); 23796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Loop over the inputs next. Make a copy of InstInputs so we can destroy 23826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // the copy while we're checking the inputs. 23836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputsCheck(InstInputs); 23846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ResultNodeOperands; 23866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Operands; 23876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = NumResults, e = CGI.OperandList.size(); i != e; ++i) { 23886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CodeGenInstruction::OperandInfo &Op = CGI.OperandList[i]; 23896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::string &OpName = Op.Name; 23906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OpName.empty()) 23916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand #" + utostr(i) + " in operands list has no name!"); 23926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InstInputsCheck.count(OpName)) { 23946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is an predicate operand or optional def operand with an 23956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // DefaultOps set filled in, we can ignore this. When we codegen it, 23966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // we will do so as always executed. 23976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Op.Rec->isSubClassOf("PredicateOperand") || 23986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Op.Rec->isSubClassOf("OptionalDefOperand")) { 23996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Does it have a non-empty DefaultOps field? If so, ignore this 24006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // operand. 24016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getDefaultOperand(Op.Rec).DefaultOps.empty()) 24026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 24036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + 24056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " does not appear in the instruction pattern"); 24066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *InVal = InstInputsCheck[OpName]; 24086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstInputsCheck.erase(OpName); // It occurred, remove from map. 24096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InVal->isLeaf() && 24116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner dynamic_cast<DefInit*>(InVal->getLeafValue())) { 24126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef(); 24136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Op.Rec != InRec && !InRec->isSubClassOf("ComplexPattern")) 24146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + "'s register class disagrees" 24156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " between the operand and pattern"); 24166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operands.push_back(Op.Rec); 24186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Construct the result for the dest-pattern operand list. 24206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OpNode = InVal->clone(); 24216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // No predicate is useful on the result. 24230540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman OpNode->clearPredicateFns(); 24246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Promote the xform function to be an explicit node if set. 24266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Record *Xform = OpNode->getTransformFn()) { 24276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpNode->setTransformFn(0); 24286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 24296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(OpNode); 2430d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); 24316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ResultNodeOperands.push_back(OpNode); 24346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InstInputsCheck.empty()) 24376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Input operand $" + InstInputsCheck.begin()->first + 24386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " occurs in pattern but not in operands list!"); 24396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *ResultPattern = 2441d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner new TreePatternNode(I->getRecord(), ResultNodeOperands, 2442d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner GetNumNodeResults(I->getRecord(), *this)); 24436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy fully inferred output node type to instruction result pattern. 2444d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0; i != NumResults; ++i) 2445d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ResultPattern->setType(i, Res0Node->getExtType(i)); 24466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create and insert the instruction. 2448acfb70f75061975deda1deb167da8e83249f92edChris Lattner // FIXME: InstImpResults should not be part of DAGInstruction. 244962bcec82b2762d5cdc84fe39c7d634c784ed6673Chris Lattner DAGInstruction TheInst(I, Results, Operands, InstImpResults); 24506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Instructions.insert(std::make_pair(I->getRecord(), TheInst)); 24516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Use a temporary tree pattern to infer all types and make sure that the 24536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // constructed result is correct. This depends on the instruction already 24546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // being inserted into the Instructions map. 24556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern Temp(I->getRecord(), ResultPattern, false, *this); 24562cacec55f947c716b058a39038889550d7e39b3cChris Lattner Temp.InferAllTypes(&I->getNamedNodesMap()); 24576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction &TheInsertedInst = Instructions.find(I->getRecord())->second; 24596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TheInsertedInst.setResultPattern(Temp.getOnlyTree()); 24606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DEBUG(I->dump()); 24626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If we can, convert the instructions to be patterns that are matched! 24655b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer for (std::map<Record*, DAGInstruction, RecordPtrCmp>::iterator II = 24665b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer Instructions.begin(), 24676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner E = Instructions.end(); II != E; ++II) { 24686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction &TheInst = II->second; 2469f1ab4f18aad3950d0b9ff1273a276bb8d195d2d6Chris Lattner const TreePattern *I = TheInst.getPattern(); 24706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (I == 0) continue; // No pattern. 24716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // FIXME: Assume only the first tree is the pattern. The others are clobber 24736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // nodes. 24746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Pattern = I->getTree(0); 24756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *SrcPattern; 24766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pattern->getOperator()->getName() == "set") { 24776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SrcPattern = Pattern->getChild(Pattern->getNumChildren()-1)->clone(); 24786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else{ 24796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Not a set (store or something?) 24806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SrcPattern = Pattern; 24816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Instr = II->first; 248425b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner AddPatternToMatch(I, 248525b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner PatternToMatch(Instr->getValueAsListInit("Predicates"), 2486967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner SrcPattern, 2487967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner TheInst.getResultPattern(), 248825b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner TheInst.getImpResults(), 2489117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Instr->getValueAsInt("AddedComplexity"), 2490117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Instr->getID())); 24916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 24936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24944ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 24954ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattnertypedef std::pair<const TreePatternNode*, unsigned> NameRecord; 24964ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 2497967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattnerstatic void FindNames(const TreePatternNode *P, 2498a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner std::map<std::string, NameRecord> &Names, 2499a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner const TreePattern *PatternTop) { 25004ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (!P->getName().empty()) { 25014ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner NameRecord &Rec = Names[P->getName()]; 25024ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // If this is the first instance of the name, remember the node. 25034ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (Rec.second++ == 0) 25044ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner Rec.first = P; 2505d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner else if (Rec.first->getExtTypes() != P->getExtTypes()) 2506a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner PatternTop->error("repetition of value: $" + P->getName() + 2507a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner " where different uses have different types!"); 25084ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner } 2509967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 2510967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner if (!P->isLeaf()) { 2511967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) 2512a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(P->getChild(i), Names, PatternTop); 2513967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner } 2514967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner} 2515967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 251625b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattnervoid CodeGenDAGPatterns::AddPatternToMatch(const TreePattern *Pattern, 251725b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner const PatternToMatch &PTM) { 2518967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Do some sanity checking on the pattern we're about to match. 251925b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner std::string Reason; 252025b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner if (!PTM.getSrcPattern()->canPatternMatch(Reason, *this)) 2521967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner Pattern->error("Pattern can never match: " + Reason); 252225b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 2523405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner // If the source pattern's root is a complex pattern, that complex pattern 2524405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner // must specify the nodes it can potentially match. 2525405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner if (const ComplexPattern *CP = 2526405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner PTM.getSrcPattern()->getComplexPatternInfo(*this)) 2527405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner if (CP->getRootNodes().empty()) 2528405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner Pattern->error("ComplexPattern at root must specify list of opcodes it" 2529405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner " could match"); 2530405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner 2531405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner 2532967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Find all of the named values in the input and output, ensure they have the 2533967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // same type. 25344ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner std::map<std::string, NameRecord> SrcNames, DstNames; 2535a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(PTM.getSrcPattern(), SrcNames, Pattern); 2536a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(PTM.getDstPattern(), DstNames, Pattern); 2537967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 2538967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Scan all of the named values in the destination pattern, rejecting them if 2539967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // they don't exist in the input pattern. 25404ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner for (std::map<std::string, NameRecord>::iterator 2541ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner I = DstNames.begin(), E = DstNames.end(); I != E; ++I) { 25424ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (SrcNames[I->first].first == 0) 2543967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner Pattern->error("Pattern has input without matching name in output: $" + 2544967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner I->first); 2545ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner } 25464ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 25474ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // Scan all of the named values in the source pattern, rejecting them if the 25484ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // name isn't used in the dest, and isn't used to tie two values together. 25494ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner for (std::map<std::string, NameRecord>::iterator 25504ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner I = SrcNames.begin(), E = SrcNames.end(); I != E; ++I) 25514ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (DstNames[I->first].first == 0 && SrcNames[I->first].second == 1) 25524ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner Pattern->error("Pattern has dead named input: $" + I->first); 25534ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 255425b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner PatternsToMatch.push_back(PTM); 255525b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner} 255625b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 255725b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 2558ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2559ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanvoid CodeGenDAGPatterns::InferInstructionFlags() { 2560f65027842e82027dd6e8020586a299aaa548e355Chris Lattner const std::vector<const CodeGenInstruction*> &Instructions = 2561f65027842e82027dd6e8020586a299aaa548e355Chris Lattner Target.getInstructionsByEnumValue(); 2562b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner for (unsigned i = 0, e = Instructions.size(); i != e; ++i) { 2563b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner CodeGenInstruction &InstInfo = 2564b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner const_cast<CodeGenInstruction &>(*Instructions[i]); 2565ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Determine properties of the instruction from its pattern. 25661e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool MayStore, MayLoad, HasSideEffects, IsVariadic; 25671e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner InferFromPattern(InstInfo, MayStore, MayLoad, HasSideEffects, IsVariadic, 25681e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner *this); 2569ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstInfo.mayStore = MayStore; 2570ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstInfo.mayLoad = MayLoad; 2571ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstInfo.hasSideEffects = HasSideEffects; 25721e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner InstInfo.isVariadic = IsVariadic; 2573ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2574ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman} 2575ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 25762cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// Given a pattern result with an unresolved type, see if we can find one 25772cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// instruction with an unresolved result type. Force this result type to an 25782cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// arbitrary element if it's possible types to converge results. 25792cacec55f947c716b058a39038889550d7e39b3cChris Lattnerstatic bool ForceArbitraryInstResultType(TreePatternNode *N, TreePattern &TP) { 25802cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (N->isLeaf()) 25812cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 25822cacec55f947c716b058a39038889550d7e39b3cChris Lattner 25832cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Analyze children. 25842cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 25852cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (ForceArbitraryInstResultType(N->getChild(i), TP)) 25862cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 25872cacec55f947c716b058a39038889550d7e39b3cChris Lattner 25882cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!N->getOperator()->isSubClassOf("Instruction")) 25892cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 25902cacec55f947c716b058a39038889550d7e39b3cChris Lattner 25912cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this type is already concrete or completely unknown we can't do 25922cacec55f947c716b058a39038889550d7e39b3cChris Lattner // anything. 2593d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = N->getNumTypes(); i != e; ++i) { 2594d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->getExtType(i).isCompletelyUnknown() || N->getExtType(i).isConcrete()) 2595d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner continue; 2596d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 2597d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // Otherwise, force its type to the first possibility (an arbitrary choice). 2598d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->getExtType(i).MergeInTypeInfo(N->getExtType(i).getTypeList()[0], TP)) 2599d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return true; 2600d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 26012cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2602d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return false; 26032cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 26042cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2605fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParsePatterns() { 26066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Patterns = Records.getAllDerivedDefinitions("Pattern"); 26076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Patterns.size(); i != e; ++i) { 2609d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Record *CurPattern = Patterns[i]; 2610d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch"); 2611310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this); 26126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 26146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Pattern->InlinePatternFragments(); 26156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2616d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs"); 26176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (LI->getSize() == 0) continue; // no pattern. 26186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the instruction. 2620d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePattern *Result = new TreePattern(CurPattern, LI, false, *this); 26216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 26236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->InlinePatternFragments(); 26246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Result->getNumTrees() != 1) 26266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->error("Cannot handle instructions producing instructions " 26276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "with temporaries yet!"); 26286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool IterateInference; 26306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool InferredAllPatternTypes, InferredAllResultTypes; 26316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner do { 26326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we 26336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // can never do anything with this pattern: report it to the user. 26342cacec55f947c716b058a39038889550d7e39b3cChris Lattner InferredAllPatternTypes = 26352cacec55f947c716b058a39038889550d7e39b3cChris Lattner Pattern->InferAllTypes(&Pattern->getNamedNodesMap()); 26366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we 26386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // can never do anything with this pattern: report it to the user. 26392cacec55f947c716b058a39038889550d7e39b3cChris Lattner InferredAllResultTypes = 26402cacec55f947c716b058a39038889550d7e39b3cChris Lattner Result->InferAllTypes(&Pattern->getNamedNodesMap()); 26416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26426c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference = false; 26436c6ba364931acb113973ad3e6d69736969c59299Chris Lattner 26446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the type of the result to the source pattern. This helps us 26456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // resolve cases where the input type is known to be a pointer type (which 26466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // is considered resolved), but the result knows it needs to be 32- or 26476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 64-bits. Infer the other way for good measure. 2648d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = std::min(Result->getTree(0)->getNumTypes(), 2649d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Pattern->getTree(0)->getNumTypes()); 2650d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner i != e; ++i) { 26516c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference = Pattern->getTree(0)-> 2652d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner UpdateNodeType(i, Result->getTree(0)->getExtType(i), *Result); 26536c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference |= Result->getTree(0)-> 2654d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner UpdateNodeType(i, Pattern->getTree(0)->getExtType(i), *Result); 26556c6ba364931acb113973ad3e6d69736969c59299Chris Lattner } 26562cacec55f947c716b058a39038889550d7e39b3cChris Lattner 26572cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If our iteration has converged and the input pattern's types are fully 26582cacec55f947c716b058a39038889550d7e39b3cChris Lattner // resolved but the result pattern is not fully resolved, we may have a 26592cacec55f947c716b058a39038889550d7e39b3cChris Lattner // situation where we have two instructions in the result pattern and 26602cacec55f947c716b058a39038889550d7e39b3cChris Lattner // the instructions require a common register class, but don't care about 26612cacec55f947c716b058a39038889550d7e39b3cChris Lattner // what actual MVT is used. This is actually a bug in our modelling: 26622cacec55f947c716b058a39038889550d7e39b3cChris Lattner // output patterns should have register classes, not MVTs. 26632cacec55f947c716b058a39038889550d7e39b3cChris Lattner // 26642cacec55f947c716b058a39038889550d7e39b3cChris Lattner // In any case, to handle this, we just go through and disambiguate some 26652cacec55f947c716b058a39038889550d7e39b3cChris Lattner // arbitrary types to the result pattern's nodes. 26662cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!IterateInference && InferredAllPatternTypes && 26672cacec55f947c716b058a39038889550d7e39b3cChris Lattner !InferredAllResultTypes) 26682cacec55f947c716b058a39038889550d7e39b3cChris Lattner IterateInference = ForceArbitraryInstResultType(Result->getTree(0), 26692cacec55f947c716b058a39038889550d7e39b3cChris Lattner *Result); 26706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } while (IterateInference); 26719008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 26726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we inferred enough types that we can do something with the 26736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // pattern and result. If these fire the user has to add type casts. 26746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InferredAllPatternTypes) 26756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Pattern->error("Could not infer all types in pattern!"); 26762cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!InferredAllResultTypes) { 26772cacec55f947c716b058a39038889550d7e39b3cChris Lattner Pattern->dump(); 26786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->error("Could not infer all types in pattern result!"); 26792cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 26806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Validate that the input pattern is correct. 26826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputs; 26836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstResults; 26846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpResults; 26856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, ee = Pattern->getNumTrees(); j != ee; ++j) 26866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(Pattern, Pattern->getTree(j), 26876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstInputs, InstResults, 2688acfb70f75061975deda1deb167da8e83249f92edChris Lattner InstImpResults); 26896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Promote the xform function to be an explicit node if set. 26916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *DstPattern = Result->getOnlyTree(); 26926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ResultNodeOperands; 26936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned ii = 0, ee = DstPattern->getNumChildren(); ii != ee; ++ii) { 26946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OpNode = DstPattern->getChild(ii); 26956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Record *Xform = OpNode->getTransformFn()) { 26966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpNode->setTransformFn(0); 26976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 26986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(OpNode); 2699d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); 27006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ResultNodeOperands.push_back(OpNode); 27026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DstPattern = Result->getOnlyTree(); 27046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!DstPattern->isLeaf()) 27056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DstPattern = new TreePatternNode(DstPattern->getOperator(), 2706d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ResultNodeOperands, 2707d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DstPattern->getNumTypes()); 2708d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 2709d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Result->getOnlyTree()->getNumTypes(); i != e; ++i) 2710d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DstPattern->setType(i, Result->getOnlyTree()->getExtType(i)); 2711d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 27126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern Temp(Result->getRecord(), DstPattern, false, *this); 27136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Temp.InferAllTypes(); 27146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 271625b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner AddPatternToMatch(Pattern, 2717d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner PatternToMatch(CurPattern->getValueAsListInit("Predicates"), 2718d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Pattern->getTree(0), 2719d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Temp.getOnlyTree(), InstImpResults, 2720d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CurPattern->getValueAsInt("AddedComplexity"), 2721d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CurPattern->getID())); 27226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 27246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// CombineChildVariants - Given a bunch of permutations of each child of the 27266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 'operator' node, put them together in all possible ways. 27276cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void CombineChildVariants(TreePatternNode *Orig, 27286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<std::vector<TreePatternNode*> > &ChildVariants, 27296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 2730327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 2731327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 27326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Make sure that each operand has at least one variant to choose from. 27336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i) 27346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (ChildVariants[i].empty()) 27356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 27366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The end result is an all-pairs construction of the resultant pattern. 27386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<unsigned> Idxs; 27396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Idxs.resize(ChildVariants.size()); 2740327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel bool NotDone; 2741327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel do { 2742327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel#ifndef NDEBUG 2743aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner DEBUG(if (!Idxs.empty()) { 2744aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << Orig->getOperator()->getName() << ": Idxs = [ "; 2745aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner for (unsigned i = 0; i < Idxs.size(); ++i) { 2746aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << Idxs[i] << " "; 2747aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner } 2748aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << "]\n"; 2749aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner }); 2750327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel#endif 27516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create the variant and add it to the output list. 27526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> NewChildren; 27536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i) 27546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NewChildren.push_back(ChildVariants[i][Idxs[i]]); 2755d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *R = new TreePatternNode(Orig->getOperator(), NewChildren, 2756d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Orig->getNumTypes()); 27576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy over properties. 27596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->setName(Orig->getName()); 27600540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman R->setPredicateFns(Orig->getPredicateFns()); 27616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->setTransformFn(Orig->getTransformFn()); 2762d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Orig->getNumTypes(); i != e; ++i) 2763d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner R->setType(i, Orig->getExtType(i)); 27646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2765327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // If this pattern cannot match, do not include it as a variant. 27666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::string ErrString; 27676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!R->canPatternMatch(ErrString, CDP)) { 27686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete R; 27696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 27706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool AlreadyExists = false; 27716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan to see if this pattern has already been emitted. We can get 27736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // duplication due to things like commuting: 27746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (and GPRC:$a, GPRC:$b) -> (and GPRC:$b, GPRC:$a) 27756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // which are the same pattern. Ignore the dups. 27766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = OutVariants.size(); i != e; ++i) 2777327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (R->isIsomorphicTo(OutVariants[i], DepVars)) { 27786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AlreadyExists = true; 27796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 27806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (AlreadyExists) 27836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete R; 27846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 27856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OutVariants.push_back(R); 27866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2788327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // Increment indices to the next permutation by incrementing the 2789327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // indicies from last index backward, e.g., generate the sequence 2790327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // [0, 0], [0, 1], [1, 0], [1, 1]. 2791327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel int IdxsIdx; 2792327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (IdxsIdx = Idxs.size() - 1; IdxsIdx >= 0; --IdxsIdx) { 2793327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (++Idxs[IdxsIdx] == ChildVariants[IdxsIdx].size()) 2794327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel Idxs[IdxsIdx] = 0; 2795327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel else 27966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 27976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2798327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel NotDone = (IdxsIdx >= 0); 2799327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } while (NotDone); 28006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 28016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// CombineChildVariants - A helper function for binary operators. 28036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 28046cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void CombineChildVariants(TreePatternNode *Orig, 28056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<TreePatternNode*> &LHS, 28066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<TreePatternNode*> &RHS, 28076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 2808327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 2809327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 28106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::vector<TreePatternNode*> > ChildVariants; 28116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.push_back(LHS); 28126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.push_back(RHS); 2813327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(Orig, ChildVariants, OutVariants, CDP, DepVars); 28146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 28156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28176cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void GatherChildrenOfAssociativeOpcode(TreePatternNode *N, 28186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode *> &Children) { 28196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(N->getNumChildren()==2 &&"Associative but doesn't have 2 children!"); 28206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Operator = N->getOperator(); 28216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Only permit raw nodes. 28230540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman if (!N->getName().empty() || !N->getPredicateFns().empty() || 28246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->getTransformFn()) { 28256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N); 28266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 28276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getChild(0)->isLeaf() || N->getChild(0)->getOperator() != Operator) 28306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N->getChild(0)); 28316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 28326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N->getChild(0), Children); 28336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getChild(1)->isLeaf() || N->getChild(1)->getOperator() != Operator) 28356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N->getChild(1)); 28366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 28376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N->getChild(1), Children); 28386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 28396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// GenerateVariantsOf - Given a pattern N, generate all permutations we can of 28416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// the (potentially recursive) pattern by using algebraic laws. 28426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 28436cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void GenerateVariantsOf(TreePatternNode *N, 28446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 2845327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 2846327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 28476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // We cannot permute leaves. 28486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->isLeaf()) { 28496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OutVariants.push_back(N); 28506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 28516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Look up interesting info about the node. 28546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(N->getOperator()); 28556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2856da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // If this node is associative, re-associate. 28576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NodeInfo.hasProperty(SDNPAssociative)) { 2858da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // Re-associate by pulling together all of the linked operators 28596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> MaximalChildren; 28606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N, MaximalChildren); 28616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Only handle child sizes of 3. Otherwise we'll end up trying too many 28636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // permutations. 28646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (MaximalChildren.size() == 3) { 28656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find the variants of all of our maximal children. 28666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> AVariants, BVariants, CVariants; 2867327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[0], AVariants, CDP, DepVars); 2868327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[1], BVariants, CDP, DepVars); 2869327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[2], CVariants, CDP, DepVars); 28706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // There are only two ways we can permute the tree: 28726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (A op B) op C and A op (B op C) 28736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Within these forms, we can also permute A/B/C. 28746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Generate legal pair permutations of A/B/C. 28766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ABVariants; 28776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> BAVariants; 28786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ACVariants; 28796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CAVariants; 28806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> BCVariants; 28816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CBVariants; 2882327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, BVariants, ABVariants, CDP, DepVars); 2883327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, AVariants, BAVariants, CDP, DepVars); 2884327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, CVariants, ACVariants, CDP, DepVars); 2885327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, AVariants, CAVariants, CDP, DepVars); 2886327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, CVariants, BCVariants, CDP, DepVars); 2887327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, BVariants, CBVariants, CDP, DepVars); 28886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Combine those into the result: (x op x) op x 2890327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ABVariants, CVariants, OutVariants, CDP, DepVars); 2891327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BAVariants, CVariants, OutVariants, CDP, DepVars); 2892327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ACVariants, BVariants, OutVariants, CDP, DepVars); 2893327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CAVariants, BVariants, OutVariants, CDP, DepVars); 2894327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BCVariants, AVariants, OutVariants, CDP, DepVars); 2895327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CBVariants, AVariants, OutVariants, CDP, DepVars); 28966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Combine those into the result: x op (x op x) 2898327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, ABVariants, OutVariants, CDP, DepVars); 2899327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, BAVariants, OutVariants, CDP, DepVars); 2900327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, ACVariants, OutVariants, CDP, DepVars); 2901327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, CAVariants, OutVariants, CDP, DepVars); 2902327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, BCVariants, OutVariants, CDP, DepVars); 2903327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, CBVariants, OutVariants, CDP, DepVars); 29046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 29056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Compute permutations of all children. 29096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::vector<TreePatternNode*> > ChildVariants; 29106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.resize(N->getNumChildren()); 29116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 2912327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(N->getChild(i), ChildVariants[i], CDP, DepVars); 29136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Build all permutations based on how the children were formed. 2915327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ChildVariants, OutVariants, CDP, DepVars); 29166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this node is commutative, consider the commuted order. 29186bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool isCommIntrinsic = N->isCommutativeIntrinsic(CDP); 29196bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { 29206bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng assert((N->getNumChildren()==2 || isCommIntrinsic) && 29216bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng "Commutative but doesn't have 2 children!"); 29226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Don't count children which are actually register references. 29236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NC = 0; 29246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { 29256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = N->getChild(i); 29266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Child->isLeaf()) 29276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) { 29286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *RR = DI->getDef(); 29296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (RR->isSubClassOf("Register")) 29306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 29316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NC++; 29336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Consider the commuted order. 29356bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (isCommIntrinsic) { 29366bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // Commutative intrinsic. First operand is the intrinsic id, 2nd and 3rd 29376bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // operands are the commutative operands, and there might be more operands 29386bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // after those. 29396bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng assert(NC >= 3 && 29406bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng "Commutative intrinsic should have at least 3 childrean!"); 29416bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng std::vector<std::vector<TreePatternNode*> > Variants; 29426bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[0]); // Intrinsic id. 29436bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[2]); 29446bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[1]); 29456bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng for (unsigned i = 3; i != NC; ++i) 29466bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[i]); 29476bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng CombineChildVariants(N, Variants, OutVariants, CDP, DepVars); 29486bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng } else if (NC == 2) 29496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CombineChildVariants(N, ChildVariants[1], ChildVariants[0], 2950327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel OutVariants, CDP, DepVars); 29516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 29536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// GenerateVariants - Generate variants. For example, commutative patterns can 29566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// match multiple ways. Add them to PatternsToMatch as well. 2957fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::GenerateVariants() { 2958569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "Generating instruction variants.\n"); 29596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Loop over all of the patterns we've collected, checking to see if we can 29616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // generate variants of the instruction, through the exploitation of 2962da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // identities. This permits the target to provide aggressive matching without 29636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // the .td file having to contain tons of variants of instructions. 29646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 29656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Note that this loop adds new patterns to the PatternsToMatch list, but we 29666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // intentionally do not reconsider these. Any variants of added patterns have 29676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // already been added. 29686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 29696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = PatternsToMatch.size(); i != e; ++i) { 2970327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel MultipleUseVarSet DepVars; 29716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Variants; 2972327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVars(PatternsToMatch[i].getSrcPattern(), DepVars); 2973569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "Dependent/multiply used variables: "); 2974327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DEBUG(DumpDepVars(DepVars)); 2975569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "\n"); 2976bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach GenerateVariantsOf(PatternsToMatch[i].getSrcPattern(), Variants, *this, 2977bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach DepVars); 29786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(!Variants.empty() && "Must create at least original variant!"); 29806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Variants.erase(Variants.begin()); // Remove the original pattern. 29816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Variants.empty()) // No variants for this pattern. 29836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 29846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2985569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "FOUND VARIANTS OF: "; 2986569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner PatternsToMatch[i].getSrcPattern()->dump(); 2987569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner errs() << "\n"); 29886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned v = 0, e = Variants.size(); v != e; ++v) { 29906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Variant = Variants[v]; 29916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2992569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << " VAR#" << v << ": "; 2993569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner Variant->dump(); 2994569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner errs() << "\n"); 29956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan to see if an instruction or explicit pattern already matches this. 29976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool AlreadyExists = false; 29986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned p = 0, e = PatternsToMatch.size(); p != e; ++p) { 2999c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng // Skip if the top level predicates do not match. 3000c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng if (PatternsToMatch[i].getPredicates() != 3001c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng PatternsToMatch[p].getPredicates()) 3002c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng continue; 30036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check to see if this variant already exists. 3004bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach if (Variant->isIsomorphicTo(PatternsToMatch[p].getSrcPattern(), 3005bb16824dc3e2ba660e8b79f49046c418aa8e1be7Jim Grosbach DepVars)) { 3006569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << " *** ALREADY EXISTS, ignoring variant.\n"); 30076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AlreadyExists = true; 30086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 30096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 30106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 30116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If we already have it, ignore the variant. 30126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (AlreadyExists) continue; 30136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 30146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, add it to the list of patterns we have. 30156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternsToMatch. 30166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner push_back(PatternToMatch(PatternsToMatch[i].getPredicates(), 30176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Variant, PatternsToMatch[i].getDstPattern(), 30186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternsToMatch[i].getDstRegs(), 3019117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner PatternsToMatch[i].getAddedComplexity(), 3020117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Record::getNewUID())); 30216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 30226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3023569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "\n"); 30246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 30256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 30266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 3027