CodeGenDAGPatterns.cpp revision 0d7952ed5ac10b6159d0e8e2449f0f471d117e0f
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: 476327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michelvoid DumpDepVars(MultipleUseVarSet &DepVars) { 477327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (DepVars.empty()) { 478569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "<empty set>"); 479327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } else { 480569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "[ "); 481327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (MultipleUseVarSet::const_iterator i = DepVars.begin(), e = DepVars.end(); 482327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel i != e; ++i) { 483569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << (*i) << " "); 484327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 485569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "]"); 486327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 487327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 488327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel} 489327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel 4906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 49122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman// PatternToMatch implementation 49222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman// 49322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 49422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// getPredicateCheck - Return a single string containing all of this 49522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// pattern's predicates concatenated with "&&" operators. 49622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman/// 49722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohmanstd::string PatternToMatch::getPredicateCheck() const { 49822bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman std::string PredicateCheck; 49922bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) { 50022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (DefInit *Pred = dynamic_cast<DefInit*>(Predicates->getElement(i))) { 50122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman Record *Def = Pred->getDef(); 50222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (!Def->isSubClassOf("Predicate")) { 50322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman#ifndef NDEBUG 50422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman Def->dump(); 50522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman#endif 50622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman assert(0 && "Unknown predicate type!"); 50722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 50822bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman if (!PredicateCheck.empty()) 50922bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman PredicateCheck += " && "; 51022bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman PredicateCheck += "(" + Def->getValueAsString("CondString") + ")"; 51122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 51222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman } 51322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 51422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman return PredicateCheck; 51522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman} 51622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman 51722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman//===----------------------------------------------------------------------===// 5186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// SDTypeConstraint implementation 5196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 5206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5216cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSDTypeConstraint::SDTypeConstraint(Record *R) { 5226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OperandNo = R->getValueAsInt("OperandNum"); 5236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("SDTCisVT")) { 5256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisVT; 5266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisVT_Info.VT = getValueType(R->getValueAsDef("VT")); 5276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisPtrTy")) { 5286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisPtrTy; 5296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisInt")) { 5306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisInt; 5316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisFP")) { 5326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisFP; 53336e3e668be0c4914660575d7cea800b0d51a4116Bob Wilson } else if (R->isSubClassOf("SDTCisVec")) { 53436e3e668be0c4914660575d7cea800b0d51a4116Bob Wilson ConstraintType = SDTCisVec; 5356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisSameAs")) { 5366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisSameAs; 5376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisSameAs_Info.OtherOperandNum = R->getValueAsInt("OtherOperandNum"); 5386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisVTSmallerThanOp")) { 5396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisVTSmallerThanOp; 5406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisVTSmallerThanOp_Info.OtherOperandNum = 5416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->getValueAsInt("OtherOperandNum"); 5426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (R->isSubClassOf("SDTCisOpSmallerThanOp")) { 5436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ConstraintType = SDTCisOpSmallerThanOp; 5446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner x.SDTCisOpSmallerThanOp_Info.BigOperandNum = 5456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->getValueAsInt("BigOperandNum"); 546b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman } else if (R->isSubClassOf("SDTCisEltOfVec")) { 547b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman ConstraintType = SDTCisEltOfVec; 5482cacec55f947c716b058a39038889550d7e39b3cChris Lattner x.SDTCisEltOfVec_Info.OtherOperandNum = R->getValueAsInt("OtherOpNum"); 5496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 5501a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Unrecognized SDTypeConstraint '" << R->getName() << "'!\n"; 5516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 5526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 5536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 5546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// getOperandNum - Return the node corresponding to operand #OpNo in tree 5562e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner/// N, and the result number in ResNo. 5572e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattnerstatic TreePatternNode *getOperandNum(unsigned OpNo, TreePatternNode *N, 5582e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner const SDNodeInfo &NodeInfo, 5592e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned &ResNo) { 5602e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned NumResults = NodeInfo.getNumResults(); 5612e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner if (OpNo < NumResults) { 5622e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner ResNo = OpNo; 5632e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner return N; 5642e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner } 5652e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner 5662e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner OpNo -= NumResults; 5672e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner 5682e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner if (OpNo >= N->getNumChildren()) { 5692e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner errs() << "Invalid operand number in type constraint " 5702e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner << (OpNo+NumResults) << " "; 5716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->dump(); 5721a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << '\n'; 5736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 5746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 5756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5762e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner return N->getChild(OpNo); 5776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 5786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ApplyTypeConstraint - Given a node in a pattern, apply this type 5806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// constraint to the nodes operands. This returns true if it makes a 5816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// change, false otherwise. If a type contradiction is found, throw an 5826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// exception. 5836cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N, 5846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo, 5856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern &TP) const { 5866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check that the number of operands is sane. Negative operands -> varargs. 5876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NodeInfo.getNumOperands() >= 0) { 5886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getNumChildren() != (unsigned)NodeInfo.getNumOperands()) 5896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error(N->getOperator()->getName() + " node requires exactly " + 5906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner itostr(NodeInfo.getNumOperands()) + " operands!"); 5916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 5926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5932e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned ResNo = 0; // The result number being referenced. 5942e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner TreePatternNode *NodeToApply = getOperandNum(OperandNo, N, NodeInfo, ResNo); 5956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 5966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner switch (ConstraintType) { 5976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner default: assert(0 && "Unknown constraint type!"); 5986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisVT: 5996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Operand must be a particular type. 600d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(ResNo, x.SDTCisVT_Info.VT, TP); 6012cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisPtrTy: 6026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Operand must be same as target pointer type. 603d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(ResNo, MVT::iPTR, TP); 6042cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisInt: 6052cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal integer VTs. 606d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceInteger(TP); 6072cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisFP: 6082cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal fp VTs. 609d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceFloatingPoint(TP); 6102cacec55f947c716b058a39038889550d7e39b3cChris Lattner case SDTCisVec: 6112cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Require it to be one of the legal vector VTs. 612d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo).EnforceVector(TP); 6136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisSameAs: { 6142e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned OResNo = 0; 6156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OtherNode = 6162e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisSameAs_Info.OtherOperandNum, N, NodeInfo, OResNo); 617d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->UpdateNodeType(OResNo, OtherNode->getExtType(ResNo),TP)| 618d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OtherNode->UpdateNodeType(ResNo,NodeToApply->getExtType(OResNo),TP); 6196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 6206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisVTSmallerThanOp: { 6216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The NodeToApply must be a leaf node that is a VT. OtherOperandNum must 6226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // have an integer type that is smaller than the VT. 6236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!NodeToApply->isLeaf() || 6246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !dynamic_cast<DefInit*>(NodeToApply->getLeafValue()) || 6256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef() 6266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ->isSubClassOf("ValueType")) 6276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error(N->getOperator()->getName() + " expects a VT operand!"); 628825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::SimpleValueType VT = 6296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()); 630cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner 631cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner EEVT::TypeSet TypeListTmp(VT, TP); 6326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 6332e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned OResNo = 0; 6346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OtherNode = 6352e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisVTSmallerThanOp_Info.OtherOperandNum, N, NodeInfo, 6362e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner OResNo); 6372cacec55f947c716b058a39038889550d7e39b3cChris Lattner 638cc8783073205dcc5feadaa0a722ab61c6d17fee7Chris Lattner return TypeListTmp.EnforceSmallerThan(OtherNode->getExtType(OResNo), TP); 6396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 6406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner case SDTCisOpSmallerThanOp: { 6412e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned BResNo = 0; 6426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *BigOperand = 6432e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisOpSmallerThanOp_Info.BigOperandNum, N, NodeInfo, 6442e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner BResNo); 645d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return NodeToApply->getExtType(ResNo). 646d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner EnforceSmallerThan(BigOperand->getExtType(BResNo), TP); 6476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 648b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman case SDTCisEltOfVec: { 6492e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner unsigned VResNo = 0; 6502cacec55f947c716b058a39038889550d7e39b3cChris Lattner TreePatternNode *VecOperand = 6512e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner getOperandNum(x.SDTCisEltOfVec_Info.OtherOperandNum, N, NodeInfo, 6522e68a02c264c26abc6ed62d59f18813fa7fdb95dChris Lattner VResNo); 6532cacec55f947c716b058a39038889550d7e39b3cChris Lattner 65466fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // Filter vector types out of VecOperand that don't have the right element 65566fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner // type. 65666fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner return VecOperand->getExtType(VResNo). 65766fb9d26c64b75ad6619608905c4005f0777bf5dChris Lattner EnforceVectorEltTypeIs(NodeToApply->getExtType(ResNo), TP); 658b5af3344c196de5ed3f45b250dfb864be6e9ddc5Nate Begeman } 6596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 6606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 6616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 6626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 6636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 6646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// SDNodeInfo implementation 6656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 6666cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSDNodeInfo::SDNodeInfo(Record *R) : Def(R) { 6676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner EnumName = R->getValueAsString("Opcode"); 6686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SDClassName = R->getValueAsString("SDClass"); 6696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *TypeProfile = R->getValueAsDef("TypeProfile"); 6706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NumResults = TypeProfile->getValueAsInt("NumResults"); 6716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NumOperands = TypeProfile->getValueAsInt("NumOperands"); 6726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 6736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the properties. 6746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties = 0; 6756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> PropList = R->getValueAsListOfDefs("Properties"); 6766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = PropList.size(); i != e; ++i) { 6776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (PropList[i]->getName() == "SDNPCommutative") { 6786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPCommutative; 6796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPAssociative") { 6806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPAssociative; 6816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPHasChain") { 6826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPHasChain; 6836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPOutFlag") { 684874ae251c317788391f9c3f113957802d390a063Dale Johannesen Properties |= 1 << SDNPOutFlag; 6856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPInFlag") { 6866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPInFlag; 6876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (PropList[i]->getName() == "SDNPOptInFlag") { 6886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Properties |= 1 << SDNPOptInFlag; 689c8478d8b12c2d7e4cea32d0c9940f5cac2baa4ddChris Lattner } else if (PropList[i]->getName() == "SDNPMayStore") { 690c8478d8b12c2d7e4cea32d0c9940f5cac2baa4ddChris Lattner Properties |= 1 << SDNPMayStore; 691710e995889c71812743f3f33861c24273f4569a7Chris Lattner } else if (PropList[i]->getName() == "SDNPMayLoad") { 692710e995889c71812743f3f33861c24273f4569a7Chris Lattner Properties |= 1 << SDNPMayLoad; 693bc0b9f70ae072d695e0eb7ceb729b3306b0679feChris Lattner } else if (PropList[i]->getName() == "SDNPSideEffect") { 694bc0b9f70ae072d695e0eb7ceb729b3306b0679feChris Lattner Properties |= 1 << SDNPSideEffect; 69528873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang } else if (PropList[i]->getName() == "SDNPMemOperand") { 69628873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang Properties |= 1 << SDNPMemOperand; 697e8cabf3c2eb835f9189a39c810654d9bd302f7eeChris Lattner } else if (PropList[i]->getName() == "SDNPVariadic") { 698e8cabf3c2eb835f9189a39c810654d9bd302f7eeChris Lattner Properties |= 1 << SDNPVariadic; 6996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 7001a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Unknown SD Node property '" << PropList[i]->getName() 7011a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar << "' on node '" << R->getName() << "'!\n"; 7026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 7036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 7046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 7056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the type constraints. 7086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> ConstraintList = 7096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TypeProfile->getValueAsListOfDefs("Constraints"); 7106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TypeConstraints.assign(ConstraintList.begin(), ConstraintList.end()); 7116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 7126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 713225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner/// getKnownType - If the type constraints on this node imply a fixed type 714225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner/// (e.g. all stores return void, etc), then return it as an 715aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner/// MVT::SimpleValueType. Otherwise, return EEVT::Other. 716084df627c82fdf4e1829723edf0a833b5bc31f89Chris LattnerMVT::SimpleValueType SDNodeInfo::getKnownType(unsigned ResNo) const { 717225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner unsigned NumResults = getNumResults(); 718225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner assert(NumResults <= 1 && 719225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner "We only work with nodes with zero or one result so far!"); 720084df627c82fdf4e1829723edf0a833b5bc31f89Chris Lattner assert(ResNo == 0 && "Only handles single result nodes so far"); 721225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner 722225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner for (unsigned i = 0, e = TypeConstraints.size(); i != e; ++i) { 723225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner // Make sure that this applies to the correct node result. 724225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner if (TypeConstraints[i].OperandNo >= NumResults) // FIXME: need value # 725225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner continue; 726225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner 727225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner switch (TypeConstraints[i].ConstraintType) { 728225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner default: break; 729225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner case SDTypeConstraint::SDTCisVT: 730225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner return TypeConstraints[i].x.SDTCisVT_Info.VT; 731225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner case SDTypeConstraint::SDTCisPtrTy: 732225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner return MVT::iPTR; 733225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner } 734225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner } 735aac5b5b2e5eaf2e5bd62f9b96270e31d46125f4fChris Lattner return MVT::Other; 736225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner} 737225798143dbec36685f9d1e2fa82f5c4e70b0bf5Chris Lattner 7386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 7396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// TreePatternNode implementation 7406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 7416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7426cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode::~TreePatternNode() { 7436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#if 0 // FIXME: implement refcounted tree nodes! 7446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 7456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete getChild(i); 7466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner#endif 7476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 7486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 749d7349194650386d97a1d779369cb46f20ba9f252Chris Lattnerstatic unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) { 750d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->getName() == "set" || 751310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner Operator->getName() == "implicit") 752d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return 0; // All return nothing. 753d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 75493dc92e412fd06250e46951bffb6040eca9baebdChris Lattner if (Operator->isSubClassOf("Intrinsic")) 75593dc92e412fd06250e46951bffb6040eca9baebdChris Lattner return CDP.getIntrinsic(Operator).IS.RetVTs.size(); 756d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 757d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("SDNode")) 758d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return CDP.getSDNodeInfo(Operator).getNumResults(); 759d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 760d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("PatFrag")) { 761d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // If we've already parsed this pattern fragment, get it. Otherwise, handle 762d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // the forward reference case where one pattern fragment references another 763d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // before it is processed. 764d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (TreePattern *PFRec = CDP.getPatternFragmentIfRead(Operator)) 765d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return PFRec->getOnlyTree()->getNumTypes(); 766d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 767d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // Get the result tree. 768d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DagInit *Tree = Operator->getValueAsDag("Fragment"); 769d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Record *Op = 0; 770d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Tree && dynamic_cast<DefInit*>(Tree->getOperator())) 771d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Op = dynamic_cast<DefInit*>(Tree->getOperator())->getDef(); 772d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(Op && "Invalid Fragment"); 773d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return GetNumNodeResults(Op, CDP); 774d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 775d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 776d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("Instruction")) { 777d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CodeGenInstruction &InstInfo = CDP.getTargetInfo().getInstruction(Operator); 7780be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 7790be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: Should allow access to all the results here. 7800be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned NumDefsToAdd = InstInfo.NumDefs ? 1 : 0; 781d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 7829414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // Add on one implicit def if it has a resolvable type. 7839414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()) !=MVT::Other) 7849414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner ++NumDefsToAdd; 7850be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner return NumDefsToAdd; 786d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 787d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 788d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Operator->isSubClassOf("SDNodeXForm")) 789d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return 1; // FIXME: Generalize SDNodeXForm 790d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 791d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Operator->dump(); 792d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner errs() << "Unhandled node in GetNumNodeResults\n"; 793d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner exit(1); 794d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner} 7956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 7961a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePatternNode::print(raw_ostream &OS) const { 797d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (isLeaf()) 7986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << *getLeafValue(); 799d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner else 800ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner OS << '(' << getOperator()->getName(); 801d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 802d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 803d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OS << ':' << getExtType(i).getName(); 8046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isLeaf()) { 8066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getNumChildren() != 0) { 8076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << " "; 8086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(0)->print(OS); 8096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 1, e = getNumChildren(); i != e; ++i) { 8106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ", "; 8116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(i)->print(OS); 8126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ")"; 8156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8170540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = PredicateFns.size(); i != e; ++i) 8180540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman OS << "<<P:" << PredicateFns[i] << ">>"; 8196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (TransformFn) 8206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "<<X:" << TransformFn->getName() << ">>"; 8216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getName().empty()) 8226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ":$" << getName(); 8236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8256cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePatternNode::dump() const { 8261a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar print(errs()); 8276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 829327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isIsomorphicTo - Return true if this node is recursively 830327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isomorphic to the specified node. For this comparison, the node's 831327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// entire state is considered. The assigned name is ignored, since 832327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// nodes with differing names are considered isomorphic. However, if 833327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// the assigned name is present in the dependent variable set, then 834327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// the assigned name is considered significant and the node is 835327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel/// isomorphic if the names match. 836327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michelbool TreePatternNode::isIsomorphicTo(const TreePatternNode *N, 837327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) const { 8386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N == this) return true; 839d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->isLeaf() != isLeaf() || getExtTypes() != N->getExtTypes() || 8400540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman getPredicateFns() != N->getPredicateFns() || 8416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getTransformFn() != N->getTransformFn()) 8426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 8436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 845327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { 846327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (DefInit *NDI = dynamic_cast<DefInit*>(N->getLeafValue())) { 84771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner return ((DI->getDef() == NDI->getDef()) 84871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner && (DepVars.find(getName()) == DepVars.end() 84971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner || getName() == N->getName())); 850327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 851327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } 8526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return getLeafValue() == N->getLeafValue(); 8536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getOperator() != getOperator() || 8566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->getNumChildren() != getNumChildren()) return false; 8576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 858327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (!getChild(i)->isIsomorphicTo(N->getChild(i), DepVars)) 8596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 8606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 8616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// clone - Make a copy of this tree and all of its children. 8646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 8656cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode *TreePatternNode::clone() const { 8666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *New; 8676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 868d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(getLeafValue(), getNumTypes()); 8696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 8706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CChildren; 8716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CChildren.reserve(Children.size()); 8726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 8736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CChildren.push_back(getChild(i)->clone()); 874d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(getOperator(), CChildren, getNumTypes()); 8756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 8766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner New->setName(getName()); 877d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New->Types = Types; 8780540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman New->setPredicateFns(getPredicateFns()); 8796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner New->setTransformFn(getTransformFn()); 8806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return New; 8816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 8826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 88347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// RemoveAllTypes - Recursively strip all the types of this tree. 88447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnervoid TreePatternNode::RemoveAllTypes() { 885d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 886d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Types[i] = EEVT::TypeSet(); // Reset to unknown type. 88747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (isLeaf()) return; 88847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 88947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner getChild(i)->RemoveAllTypes(); 89047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 89147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 89247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 8936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// SubstituteFormalArguments - Replace the formal arguments in this tree 8946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// with actual values specified by ArgMap. 8956cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePatternNode:: 8966cefb77a7073057fecd721ae141140d75ce76512Chris LattnerSubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) { 8976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return; 8986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 8996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { 9006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = getChild(i); 9016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Child->isLeaf()) { 9026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Init *Val = Child->getLeafValue(); 9036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (dynamic_cast<DefInit*>(Val) && 9046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner static_cast<DefInit*>(Val)->getDef()->getName() == "node") { 9056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // We found a use of a formal argument, replace it with its value. 9060540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *NewChild = ArgMap[Child->getName()]; 9070540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert(NewChild && "Couldn't find formal argument!"); 9080540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert((Child->getPredicateFns().empty() || 9090540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman NewChild->getPredicateFns() == Child->getPredicateFns()) && 9100540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman "Non-empty child predicate clobbered!"); 9110540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman setChild(i, NewChild); 9126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 9146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getChild(i)->SubstituteFormalArguments(ArgMap); 9156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 9186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// InlinePatternFragments - If this pattern refers to any pattern 9216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// fragments, inline them into place, giving us a pattern without any 9226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// PatFrag references. 9236cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode *TreePatternNode::InlinePatternFragments(TreePattern &TP) { 9246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return this; // nothing to do. 9256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Op = getOperator(); 9266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Op->isSubClassOf("PatFrag")) { 9286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Just recursively inline children nodes. 9290540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { 9300540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *Child = getChild(i); 9310540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman TreePatternNode *NewChild = Child->InlinePatternFragments(TP); 9320540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 9330540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman assert((Child->getPredicateFns().empty() || 9340540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman NewChild->getPredicateFns() == Child->getPredicateFns()) && 9350540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman "Non-empty child predicate clobbered!"); 9360540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 9370540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman setChild(i, NewChild); 9380540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman } 9396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return this; 9406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, we found a reference to a fragment. First, look up its 9436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // TreePattern record. 9446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *Frag = TP.getDAGPatterns().getPatternFragment(Op); 9456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we are passing the right number of operands. 9476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Frag->getNumArgs() != Children.size()) 9486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("'" + Op->getName() + "' fragment requires " + 9496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner utostr(Frag->getNumArgs()) + " operands!"); 9506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *FragTree = Frag->getOnlyTree()->clone(); 9526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9530540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman std::string Code = Op->getValueAsCode("Predicate"); 9540540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman if (!Code.empty()) 9550540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman FragTree->addPredicateFn("Predicate_"+Op->getName()); 9560540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 9576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Resolve formal arguments to their actual value. 9586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Frag->getNumArgs()) { 9596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Compute the map of formal to actual arguments. 9606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> ArgMap; 9616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Frag->getNumArgs(); i != e; ++i) 9626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ArgMap[Frag->getArgName(i)] = getChild(i)->InlinePatternFragments(TP); 9636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FragTree->SubstituteFormalArguments(ArgMap); 9656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 9666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FragTree->setName(getName()); 968d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 969d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner FragTree->UpdateNodeType(i, getExtType(i), TP); 9700540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 9710540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman // Transfer in the old predicates. 9720540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman for (unsigned i = 0, e = getPredicateFns().size(); i != e; ++i) 9730540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman FragTree->addPredicateFn(getPredicateFns()[i]); 9740540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman 9756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Get a new copy of this fragment to stitch into here. 9766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner //delete this; // FIXME: implement refcounting! 9772ca698df93421327a459987b33b045756cb47d4dChris Lattner 9782ca698df93421327a459987b33b045756cb47d4dChris Lattner // The fragment we inlined could have recursive inlining that is needed. See 9792ca698df93421327a459987b33b045756cb47d4dChris Lattner // if there are any pattern fragments in it and inline them as needed. 9802ca698df93421327a459987b33b045756cb47d4dChris Lattner return FragTree->InlinePatternFragments(TP); 9816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 9826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 9836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// getImplicitType - Check to see if the specified record has an implicit 984fc4c25530412907f566519dd4d0979a6570222b3Nick Lewycky/// type which should be applied to it. This will infer the type of register 9856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// references from the register file information, for example. 9866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 987d7349194650386d97a1d779369cb46f20ba9f252Chris Lattnerstatic EEVT::TypeSet getImplicitType(Record *R, unsigned ResNo, 988d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool NotRegisters, TreePattern &TP) { 9892cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Check to see if this is a register or a register class. 9906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("RegisterClass")) { 991640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Regclass ref only has one result!"); 9926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NotRegisters) 9932cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 9942cacec55f947c716b058a39038889550d7e39b3cChris Lattner const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 9952cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(T.getRegisterClass(R).getValueTypes()); 996640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 997640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 998640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("PatFrag")) { 999640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "FIXME: PatFrag with multiple results?"); 10006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Pattern fragment types will be resolved when they are inlined. 10012cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 1002640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1003640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 1004640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("Register")) { 1005640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Registers only produce one result!"); 10066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NotRegisters) 10072cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 10086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); 10092cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(T.getRegisterVTs(R)); 1010640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1011640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 1012640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("ValueType") || R->isSubClassOf("CondCode")) { 1013640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "This node only has one result!"); 10146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Using a VTSDNode or CondCodeSDNode. 10152cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::Other, TP); 1016640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1017640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 1018640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("ComplexPattern")) { 1019640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "FIXME: ComplexPattern with multiple results?"); 10206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NotRegisters) 10212cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 10222cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(TP.getDAGPatterns().getComplexPattern(R).getValueType(), 10232cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP); 1024640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1025640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->isSubClassOf("PointerLikeRegClass")) { 1026640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner assert(ResNo == 0 && "Regclass can only have one result!"); 10272cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::iPTR, TP); 1028640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner } 1029640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner 1030640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner if (R->getName() == "node" || R->getName() == "srcvalue" || 1031640a3f530904a9b08228fab07ea7826af0bcab5eChris Lattner R->getName() == "zero_reg") { 10326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Placeholder. 10332cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(); // Unknown. 10346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 10356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 10366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Unknown node flavor used in pattern: " + R->getName()); 10372cacec55f947c716b058a39038889550d7e39b3cChris Lattner return EEVT::TypeSet(MVT::Other, TP); 10386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 10396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1040e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 1041e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner/// getIntrinsicInfo - If this node corresponds to an intrinsic, return the 1042e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner/// CodeGenIntrinsic information for it, otherwise return a null pointer. 1043e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattnerconst CodeGenIntrinsic *TreePatternNode:: 1044e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris LattnergetIntrinsicInfo(const CodeGenDAGPatterns &CDP) const { 1045e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner if (getOperator() != CDP.get_intrinsic_void_sdnode() && 1046e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner getOperator() != CDP.get_intrinsic_w_chain_sdnode() && 1047e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner getOperator() != CDP.get_intrinsic_wo_chain_sdnode()) 1048e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner return 0; 1049e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 1050e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner unsigned IID = 1051e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue(); 1052e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner return &CDP.getIntrinsicInfo(IID); 1053e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner} 1054e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 105547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// getComplexPatternInfo - If this node corresponds to a ComplexPattern, 105647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// return the ComplexPattern information, otherwise return null. 105747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerconst ComplexPattern * 105847661320363a8bf0bb1401a8c1893755fb77c8f6Chris LattnerTreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const { 105947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (!isLeaf()) return 0; 106047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 106147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner DefInit *DI = dynamic_cast<DefInit*>(getLeafValue()); 106247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (DI && DI->getDef()->isSubClassOf("ComplexPattern")) 106347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return &CGP.getComplexPattern(DI->getDef()); 106447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return 0; 106547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 106647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 106747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// NodeHasProperty - Return true if this node has the specified property. 106847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerbool TreePatternNode::NodeHasProperty(SDNP Property, 1069751d5aa1eadf041f00acf76f3b641549c8be3998Chris Lattner const CodeGenDAGPatterns &CGP) const { 107047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (isLeaf()) { 107147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (const ComplexPattern *CP = getComplexPatternInfo(CGP)) 107247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return CP->hasProperty(Property); 107347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return false; 107447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner } 107547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 107647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner Record *Operator = getOperator(); 107747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (!Operator->isSubClassOf("SDNode")) return false; 107847661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 107947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return CGP.getSDNodeInfo(Operator).hasProperty(Property); 108047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 108147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 108247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 108347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 108447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 108547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// TreeHasProperty - Return true if any node in this tree has the specified 108647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner/// property. 108747661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattnerbool TreePatternNode::TreeHasProperty(SDNP Property, 1088751d5aa1eadf041f00acf76f3b641549c8be3998Chris Lattner const CodeGenDAGPatterns &CGP) const { 108947661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (NodeHasProperty(Property, CGP)) 109047661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return true; 109147661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 109247661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner if (getChild(i)->TreeHasProperty(Property, CGP)) 109347661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return true; 109447661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner return false; 109547661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner} 109647661320363a8bf0bb1401a8c1893755fb77c8f6Chris Lattner 10976bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng/// isCommutativeIntrinsic - Return true if the node corresponds to a 10986bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng/// commutative intrinsic. 10996bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Chengbool 11006bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan ChengTreePatternNode::isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const { 11016bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) 11026bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng return Int->isCommutative; 11036bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng return false; 11046bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng} 11056bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng 1106e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner 11076c01ca9e29816e36e96112ed541ecf3414a7aad2Bob Wilson/// ApplyTypeConstraints - Apply all of the type constraints relevant to 11086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// this node and its children in the tree. This returns true if it makes a 11096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// change, false otherwise. If a type contradiction is found, throw an 11106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// exception. 11116cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) { 1112fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &CDP = TP.getDAGPatterns(); 11136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) { 11146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { 11156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If it's a regclass or something else known, include the type. 1116d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = false; 1117d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Types.size(); i != e; ++i) 1118d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(i, getImplicitType(DI->getDef(), i, 1119d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner NotRegisters, TP), TP); 1120d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return MadeChange; 1121523f6a5848194c135168112751c36884dc704e54Chris Lattner } 1122523f6a5848194c135168112751c36884dc704e54Chris Lattner 1123523f6a5848194c135168112751c36884dc704e54Chris Lattner if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) { 1124d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(Types.size() == 1 && "Invalid IntInit"); 1125d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 11266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Int inits are always integers. :) 1127d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = Types[0].EnforceInteger(TP); 11286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1129d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (!Types[0].isConcrete()) 11302cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 11312cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1132d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType VT = getType(0); 11332cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (VT == MVT::iPTR || VT == MVT::iPTRAny) 11342cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 11352cacec55f947c716b058a39038889550d7e39b3cChris Lattner 11362cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned Size = EVT(VT).getSizeInBits(); 11372cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Make sure that the value is representable for this type. 11382cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Size >= 32) return MadeChange; 11392cacec55f947c716b058a39038889550d7e39b3cChris Lattner 11402cacec55f947c716b058a39038889550d7e39b3cChris Lattner int Val = (II->getValue() << (32-Size)) >> (32-Size); 11412cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Val == II->getValue()) return MadeChange; 11422cacec55f947c716b058a39038889550d7e39b3cChris Lattner 11432cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If sign-extended doesn't fit, does it fit as unsigned? 11442cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned ValueMask; 11452cacec55f947c716b058a39038889550d7e39b3cChris Lattner unsigned UnsignedVal; 11462cacec55f947c716b058a39038889550d7e39b3cChris Lattner ValueMask = unsigned(~uint32_t(0UL) >> (32-Size)); 11472cacec55f947c716b058a39038889550d7e39b3cChris Lattner UnsignedVal = unsigned(II->getValue()); 11482cacec55f947c716b058a39038889550d7e39b3cChris Lattner 11492cacec55f947c716b058a39038889550d7e39b3cChris Lattner if ((ValueMask & UnsignedVal) == UnsignedVal) 11502cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 11516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11522cacec55f947c716b058a39038889550d7e39b3cChris Lattner TP.error("Integer value '" + itostr(II->getValue())+ 1153d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "' is out of range for type '" + getEnumName(getType(0)) + "'!"); 11546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 11556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 11576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // special handling for set, which isn't really an SDNode. 11606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getOperator()->getName() == "set") { 1161d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumTypes() == 0 && "Set doesn't produce a value"); 1162d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumChildren() >= 2 && "Missing RHS of a set?"); 11636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NC = getNumChildren(); 1164d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1165d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *SetVal = getChild(NC-1); 1166d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner bool MadeChange = SetVal->ApplyTypeConstraints(TP, NotRegisters); 1167d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 11686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i < NC-1; ++i) { 1169d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Child = getChild(i); 1170d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Child->ApplyTypeConstraints(TP, NotRegisters); 11716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 11726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Types of operands must match. 1173d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Child->UpdateNodeType(0, SetVal->getExtType(i), TP); 1174d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= SetVal->UpdateNodeType(i, Child->getExtType(0), TP); 11756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 11766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 11776eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 11786eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 1179310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner if (getOperator()->getName() == "implicit") { 1180d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getNumTypes() == 0 && "Node doesn't produce a value"); 1181d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 11826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = false; 11836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i < getNumChildren(); ++i) 11846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange = getChild(i)->ApplyTypeConstraints(TP, NotRegisters); 11856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 11866eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 11876eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 11886eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->getName() == "COPY_TO_REGCLASS") { 1189f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman bool MadeChange = false; 1190f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman MadeChange |= getChild(0)->ApplyTypeConstraints(TP, NotRegisters); 1191f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman MadeChange |= getChild(1)->ApplyTypeConstraints(TP, NotRegisters); 11922cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1193d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(0)->getNumTypes() == 1 && 1194d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner getChild(1)->getNumTypes() == 1 && "Unhandled case"); 1195d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 11962cacec55f947c716b058a39038889550d7e39b3cChris Lattner // child #1 of COPY_TO_REGCLASS should be a register class. We don't care 11972cacec55f947c716b058a39038889550d7e39b3cChris Lattner // what type it gets, so if it didn't get a concrete type just give it the 11982cacec55f947c716b058a39038889550d7e39b3cChris Lattner // first viable type from the reg class. 1199d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (!getChild(1)->hasTypeSet(0) && 1200d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner !getChild(1)->getExtType(0).isCompletelyUnknown()) { 1201d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType RCVT = getChild(1)->getExtType(0).getTypeList()[0]; 1202d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(1)->UpdateNodeType(0, RCVT, TP); 12032cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 1204f8c7394781f7cf27ac52ca087e289436d36844daDan Gohman return MadeChange; 12056eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 12066eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 12076eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) { 12086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = false; 120983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands 12106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the result type to the node. 1211cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling unsigned NumRetVTs = Int->IS.RetVTs.size(); 1212cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling unsigned NumParamVTs = Int->IS.ParamVTs.size(); 1213d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1214cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling for (unsigned i = 0, e = NumRetVTs; i != e; ++i) 1215d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(i, Int->IS.RetVTs[i], TP); 1216cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling 1217d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (getNumChildren() != NumParamVTs + 1) 1218e67bde5bb1959dbd7085981cb0bcf6f7c749f724Chris Lattner TP.error("Intrinsic '" + Int->Name + "' expects " + 1219d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner utostr(NumParamVTs) + " operands, not " + 1220cdcc3e6e12b8b4e224bd62c96768c5f5e325aaceBill Wendling utostr(getNumChildren() - 1) + " operands!"); 12216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply type info to the intrinsic ID. 1223d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(0)->UpdateNodeType(0, MVT::iPTR, TP); 12246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1225d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = getNumChildren()-1; i != e; ++i) { 1226d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(i+1)->ApplyTypeConstraints(TP, NotRegisters); 1227d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1228d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MVT::SimpleValueType OpVT = Int->IS.ParamVTs[i]; 1229d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(i+1)->getNumTypes() == 1 && "Unhandled case"); 1230d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(i+1)->UpdateNodeType(0, OpVT, TP); 12316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 12336eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 12346eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 12356eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->isSubClassOf("SDNode")) { 12366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NI = CDP.getSDNodeInfo(getOperator()); 12376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = NI.ApplyTypeConstraints(this, TP); 12396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 12406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters); 1241d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return MadeChange; 12426eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 12436eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 12446eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getOperator()->isSubClassOf("Instruction")) { 12456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const DAGInstruction &Inst = CDP.getInstruction(getOperator()); 12466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CodeGenInstruction &InstInfo = 1247f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CDP.getTargetInfo().getInstruction(getOperator()); 12486c6ba364931acb113973ad3e6d69736969c59299Chris Lattner 12490be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner bool MadeChange = false; 12500be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 12510be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // Apply the result types to the node, these come from the things in the 12520be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // (outs) list of the instruction. 12530be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: Cap at one result so far. 12540be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned NumResultsToAdd = InstInfo.NumDefs ? 1 : 0; 12550be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner for (unsigned ResNo = 0; ResNo != NumResultsToAdd; ++ResNo) { 12560be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner Record *ResultNode = Inst.getResult(ResNo); 12576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1258a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner if (ResultNode->isSubClassOf("PointerLikeRegClass")) { 12590be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= UpdateNodeType(ResNo, MVT::iPTR, TP); 12605b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb } else if (ResultNode->getName() == "unknown") { 12612cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Nothing to do. 12626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 12636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(ResultNode->isSubClassOf("RegisterClass") && 12646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "Operands should be register classes!"); 12656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenRegisterClass &RC = 12666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CDP.getTargetInfo().getRegisterClass(ResultNode); 12670be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= UpdateNodeType(ResNo, RC.getValueTypes(), TP); 12686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12690be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner } 12700be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 12710be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // If the instruction has implicit defs, we apply the first one as a result. 12720be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner // FIXME: This sucks, it should apply all implicit defs. 12730be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner if (!InstInfo.ImplicitDefs.empty()) { 12740be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned ResNo = NumResultsToAdd; 12750be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner 12769414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // FIXME: Generalize to multiple possible types and multiple possible 12779414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner // ImplicitDefs. 12789414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner MVT::SimpleValueType VT = 12799414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()); 12809414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner 12819414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner if (VT != MVT::Other) 12829414ae52911f1d62cabd5108e0381b9d17476157Chris Lattner MadeChange |= UpdateNodeType(ResNo, VT, TP); 12836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 12842cacec55f947c716b058a39038889550d7e39b3cChris Lattner 12852cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this is an INSERT_SUBREG, constrain the source and destination VTs to 12862cacec55f947c716b058a39038889550d7e39b3cChris Lattner // be the same. 12872cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (getOperator()->getName() == "INSERT_SUBREG") { 1288d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(getChild(0)->getNumTypes() == 1 && "FIXME: Unhandled"); 1289d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= UpdateNodeType(0, getChild(0)->getExtType(0), TP); 1290d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= getChild(0)->UpdateNodeType(0, getExtType(0), TP); 12912cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 12926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned ChildNo = 0; 12946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Inst.getNumOperands(); i != e; ++i) { 12956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *OperandNode = Inst.getOperand(i); 12966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 12976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the instruction expects a predicate or optional def operand, we 12986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // codegen this by setting the operand to it's default value if it has a 12996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // non-empty DefaultOps field. 13006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if ((OperandNode->isSubClassOf("PredicateOperand") || 13016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OperandNode->isSubClassOf("OptionalDefOperand")) && 13026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !CDP.getDefaultOperand(OperandNode).DefaultOps.empty()) 13036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 13046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we didn't run out of provided operands. 13066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (ChildNo >= getNumChildren()) 13076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Instruction '" + getOperator()->getName() + 13086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' expects more operands than were provided."); 13096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1310825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::SimpleValueType VT; 13116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = getChild(ChildNo++); 13120be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner unsigned ChildResNo = 0; // Instructions always use res #0 of their op. 1313d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 13146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OperandNode->isSubClassOf("RegisterClass")) { 13156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenRegisterClass &RC = 13166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CDP.getTargetInfo().getRegisterClass(OperandNode); 13170be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= Child->UpdateNodeType(ChildResNo, RC.getValueTypes(), TP); 13186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (OperandNode->isSubClassOf("Operand")) { 13196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner VT = getValueType(OperandNode->getValueAsDef("Type")); 13200be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= Child->UpdateNodeType(ChildResNo, VT, TP); 1321a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner } else if (OperandNode->isSubClassOf("PointerLikeRegClass")) { 13220be6fe71390c50b211beb70e6c50e5fae060f746Chris Lattner MadeChange |= Child->UpdateNodeType(ChildResNo, MVT::iPTR, TP); 13235b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb } else if (OperandNode->getName() == "unknown") { 13242cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Nothing to do. 13256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 13266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(0 && "Unknown operand type!"); 13276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner abort(); 13286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 13296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= Child->ApplyTypeConstraints(TP, NotRegisters); 13306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 13315b4153710e0b94b0af10d4838216ee112d4b37bcChristopher Lamb 133202f693708d0731cfd31f8ab69766f150c169231eChristopher Lamb if (ChildNo != getNumChildren()) 13336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TP.error("Instruction '" + getOperator()->getName() + 13346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' was provided too many operands!"); 13356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return MadeChange; 13376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 13386eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 13396eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner assert(getOperator()->isSubClassOf("SDNodeXForm") && "Unknown node type!"); 13406eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 13416eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // Node transforms always take one operand. 13426eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (getNumChildren() != 1) 13436eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner TP.error("Node transform '" + getOperator()->getName() + 13446eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner "' requires one operand!"); 13456eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner 13462cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = getChild(0)->ApplyTypeConstraints(TP, NotRegisters); 13472cacec55f947c716b058a39038889550d7e39b3cChris Lattner 13482cacec55f947c716b058a39038889550d7e39b3cChris Lattner 13496eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // If either the output or input of the xform does not have exact 13506eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // type info. We assume they must be the same. Otherwise, it is perfectly 13516eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner // legal to transform from one type to a completely different type. 13522cacec55f947c716b058a39038889550d7e39b3cChris Lattner#if 0 13536eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner if (!hasTypeSet() || !getChild(0)->hasTypeSet()) { 13542cacec55f947c716b058a39038889550d7e39b3cChris Lattner bool MadeChange = UpdateNodeType(getChild(0)->getExtType(), TP); 13552cacec55f947c716b058a39038889550d7e39b3cChris Lattner MadeChange |= getChild(0)->UpdateNodeType(getExtType(), TP); 13566eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner return MadeChange; 13576eb3012b454b8dd3588236333a6bc57e9e6128b1Chris Lattner } 13582cacec55f947c716b058a39038889550d7e39b3cChris Lattner#endif 13592cacec55f947c716b058a39038889550d7e39b3cChris Lattner return MadeChange; 13606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 13616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// OnlyOnRHSOfCommutative - Return true if this value is only allowed on the 13636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// RHS of a commutative operation, not the on LHS. 13646cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic bool OnlyOnRHSOfCommutative(TreePatternNode *N) { 13656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!N->isLeaf() && N->getOperator()->getName() == "imm") 13666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 13676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->isLeaf() && dynamic_cast<IntInit*>(N->getLeafValue())) 13686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 13696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 13706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 13716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// canPatternMatch - If it is impossible for this pattern to match on this 13746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// target, fill in Reason and return false. Otherwise, return true. This is 1375da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach/// used as a sanity check for .td files (to prevent people from writing stuff 13766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// that can never possibly work), and to prevent the pattern permuter from 13776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// generating stuff that is useless. 13786cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerbool TreePatternNode::canPatternMatch(std::string &Reason, 1379ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP) { 13806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isLeaf()) return true; 13816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 13836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getChild(i)->canPatternMatch(Reason, CDP)) 13846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 13856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is an intrinsic, handle cases that would make it not match. For 13876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // example, if an operand is required to be an immediate. 13886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (getOperator()->isSubClassOf("Intrinsic")) { 13896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // TODO: 13906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 13916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 13926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 13936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this node is a commutative operator, check that the LHS isn't an 13946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // immediate. 13956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(getOperator()); 13966bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool isCommIntrinsic = isCommutativeIntrinsic(CDP); 13976bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { 13986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan all of the operands of the node and make sure that only the last one 13996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // is a constant node, unless the RHS also is. 14006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OnlyOnRHSOfCommutative(getChild(getNumChildren()-1))) { 14016bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool Skip = isCommIntrinsic ? 1 : 0; // First operand is intrinsic id. 14026bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng for (unsigned i = Skip, e = getNumChildren()-1; i != e; ++i) 14036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OnlyOnRHSOfCommutative(getChild(i))) { 14046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Reason="Immediate value must be on the RHS of commutative operators!"; 14056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 14066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 14096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 14116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 14146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// TreePattern implementation 14156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 14166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14176cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput, 1418fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ 14192cacec55f947c716b058a39038889550d7e39b3cChris Lattner isInputPattern = isInput; 14202cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = RawPat->getSize(); i != e; ++i) 14212cacec55f947c716b058a39038889550d7e39b3cChris Lattner Trees.push_back(ParseTreePattern((DagInit*)RawPat->getElement(i))); 14226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14246cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput, 1425fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ 14266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner isInputPattern = isInput; 14276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Trees.push_back(ParseTreePattern(Pat)); 14286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14306cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePattern::TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput, 1431fe71893183f504feff290e343bf740bd32432129Chris Lattner CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ 14326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner isInputPattern = isInput; 14336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Trees.push_back(Pat); 14346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14366cefb77a7073057fecd721ae141140d75ce76512Chris Lattnervoid TreePattern::error(const std::string &Msg) const { 14376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner dump(); 1438a14b1ded69dc76f4e41ef60eeab89dc8575af44bChris Lattner throw TGError(TheRecord->getLoc(), "In " + TheRecord->getName() + ": " + Msg); 14396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 14406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14412cacec55f947c716b058a39038889550d7e39b3cChris Lattnervoid TreePattern::ComputeNamedNodes() { 14422cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) 14432cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(Trees[i]); 14442cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 14452cacec55f947c716b058a39038889550d7e39b3cChris Lattner 14462cacec55f947c716b058a39038889550d7e39b3cChris Lattnervoid TreePattern::ComputeNamedNodes(TreePatternNode *N) { 14472cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!N->getName().empty()) 14482cacec55f947c716b058a39038889550d7e39b3cChris Lattner NamedNodes[N->getName()].push_back(N); 14492cacec55f947c716b058a39038889550d7e39b3cChris Lattner 14502cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 14512cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(N->getChild(i)); 14522cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 14532cacec55f947c716b058a39038889550d7e39b3cChris Lattner 1454d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 14556cefb77a7073057fecd721ae141140d75ce76512Chris LattnerTreePatternNode *TreePattern::ParseTreePattern(DagInit *Dag) { 14566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator()); 14576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OpDef) error("Pattern has unexpected operator type!"); 14586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Operator = OpDef->getDef(); 14596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Operator->isSubClassOf("ValueType")) { 14616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the operator is a ValueType, then this must be "type cast" of a leaf 14626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // node. 14636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Dag->getNumArgs() != 1) 14646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Type cast only takes one operand!"); 14656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 14666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Init *Arg = Dag->getArg(0); 14676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *New; 14686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (DefInit *DI = dynamic_cast<DefInit*>(Arg)) { 14696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *R = DI->getDef(); 14706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag")) { 14717cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Dag->setArg(0, new DagInit(DI, "", 14726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::pair<Init*, std::string> >())); 14736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return ParseTreePattern(Dag); 14746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 147543e4754817cfdd0e48e3dbe005211f1df4875f1fChris Lattner 147643e4754817cfdd0e48e3dbe005211f1df4875f1fChris Lattner // Input argument? 147743e4754817cfdd0e48e3dbe005211f1df4875f1fChris Lattner if (R->getName() == "node") { 147843e4754817cfdd0e48e3dbe005211f1df4875f1fChris Lattner if (Dag->getArgName(0).empty()) 147943e4754817cfdd0e48e3dbe005211f1df4875f1fChris Lattner error("'node' argument requires a name to match with operand list"); 148043e4754817cfdd0e48e3dbe005211f1df4875f1fChris Lattner Args.push_back(Dag->getArgName(0)); 148143e4754817cfdd0e48e3dbe005211f1df4875f1fChris Lattner } 148243e4754817cfdd0e48e3dbe005211f1df4875f1fChris Lattner 1483d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(DI, 1); 14846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (DagInit *DI = dynamic_cast<DagInit*>(Arg)) { 14856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner New = ParseTreePattern(DI); 14866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (IntInit *II = dynamic_cast<IntInit*>(Arg)) { 1487d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(II, 1); 14886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dag->getArgName(0).empty()) 14896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Constant int argument should not have a name!"); 14906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (BitsInit *BI = dynamic_cast<BitsInit*>(Arg)) { 14916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Turn this into an IntInit. 14926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Init *II = BI->convertInitializerTo(new IntRecTy()); 14936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (II == 0 || !dynamic_cast<IntInit*>(II)) 14946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Bits value must be constants!"); 14956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1496d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New = new TreePatternNode(dynamic_cast<IntInit*>(II), 1); 14976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dag->getArgName(0).empty()) 14986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Constant int argument should not have a name!"); 14996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 15006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Arg->dump(); 15016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Unknown leaf value for tree pattern!"); 15026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return 0; 15036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the type cast. 1506d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner assert(New->getNumTypes() == 1 && "FIXME: Unhandled"); 1507d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner New->UpdateNodeType(0, getValueType(Operator), *this); 15087cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (New->getNumChildren() == 0) 15097cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman New->setName(Dag->getArgName(0)); 15106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return New; 15116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that this is something that makes sense for an operator. 15147cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman if (!Operator->isSubClassOf("PatFrag") && 15157cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman !Operator->isSubClassOf("SDNode") && 15166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("Instruction") && 15176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("SDNodeXForm") && 15186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner !Operator->isSubClassOf("Intrinsic") && 15196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator->getName() != "set" && 1520310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner Operator->getName() != "implicit") 15216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Unrecognized node '" + Operator->getName() + "'!"); 15226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check to see if this is something that is illegal in an input pattern. 15246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (isInputPattern && (Operator->isSubClassOf("Instruction") || 15256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator->isSubClassOf("SDNodeXForm"))) 15266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Cannot use '" + Operator->getName() + "' in an input pattern!"); 15276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 15296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) { 15316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Init *Arg = Dag->getArg(i); 15326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (DagInit *DI = dynamic_cast<DagInit*>(Arg)) { 15336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(ParseTreePattern(DI)); 15346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Children.back()->getName().empty()) 15356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.back()->setName(Dag->getArgName(i)); 15366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (DefInit *DefI = dynamic_cast<DefInit*>(Arg)) { 15376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *R = DefI->getDef(); 15386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Direct reference to a leaf DagNode or PatFrag? Turn it into a 15396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // TreePatternNode if its own. 15406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag")) { 15417cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Dag->setArg(i, new DagInit(DefI, "", 15426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::pair<Init*, std::string> >())); 15436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner --i; // Revisit this node... 15446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 1545d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Node = new TreePatternNode(DefI, 1); 15466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Node->setName(Dag->getArgName(i)); 15476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(Node); 15486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Input argument? 15506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R->getName() == "node") { 15516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Dag->getArgName(i).empty()) 15526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("'node' argument requires a name to match with operand list"); 15536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Args.push_back(Dag->getArgName(i)); 15546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (IntInit *II = dynamic_cast<IntInit*>(Arg)) { 1557d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Node = new TreePatternNode(II, 1); 15586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dag->getArgName(i).empty()) 15596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Constant int argument should not have a name!"); 15606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(Node); 15616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (BitsInit *BI = dynamic_cast<BitsInit*>(Arg)) { 15626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Turn this into an IntInit. 15636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Init *II = BI->convertInitializerTo(new IntRecTy()); 15646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (II == 0 || !dynamic_cast<IntInit*>(II)) 15656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Bits value must be constants!"); 15666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1567d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Node = new TreePatternNode(dynamic_cast<IntInit*>(II),1); 15686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dag->getArgName(i).empty()) 15696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Constant int argument should not have a name!"); 15706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(Node); 15716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 15721a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << '"'; 15736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Arg->dump(); 15741a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "\": "; 15756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner error("Unknown leaf value for tree pattern!"); 15766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If the operator is an intrinsic, then this is just syntactic sugar for for 15806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (intrinsic_* <number>, ..children..). Pick the right intrinsic node, and 15816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // convert the intrinsic name to a number. 15826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Operator->isSubClassOf("Intrinsic")) { 15836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const CodeGenIntrinsic &Int = getDAGPatterns().getIntrinsic(Operator); 15846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned IID = getDAGPatterns().getIntrinsicID(Operator)+1; 15856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 15866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this intrinsic returns void, it must have side-effects and thus a 15876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // chain. 158893dc92e412fd06250e46951bffb6040eca9baebdChris Lattner if (Int.IS.RetVTs.empty()) { 15896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_void_sdnode(); 15906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (Int.ModRef != CodeGenIntrinsic::NoMem) { 15916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Has side-effects, requires chain. 15926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_w_chain_sdnode(); 15936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 15946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, no chain. 15956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode(); 15966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 15976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1598d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *IIDNode = new TreePatternNode(new IntInit(IID), 1); 15996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.insert(Children.begin(), IIDNode); 16006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 16016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1602d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner unsigned NumResults = GetNumNodeResults(Operator, CDP); 1603d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Result = new TreePatternNode(Operator, Children, NumResults); 16047cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman Result->setName(Dag->getName()); 16057cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman return Result; 16066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 16076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// InferAllTypes - Infer/propagate as many types throughout the expression 1609da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach/// patterns as possible. Return true if all types are inferred, false 16106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// otherwise. Throw an exception if a type contradiction is found. 16112cacec55f947c716b058a39038889550d7e39b3cChris Lattnerbool TreePattern:: 16122cacec55f947c716b058a39038889550d7e39b3cChris LattnerInferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) { 16132cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (NamedNodes.empty()) 16142cacec55f947c716b058a39038889550d7e39b3cChris Lattner ComputeNamedNodes(); 16152cacec55f947c716b058a39038889550d7e39b3cChris Lattner 16166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool MadeChange = true; 16176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (MadeChange) { 16186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange = false; 16196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) 16206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner MadeChange |= Trees[i]->ApplyTypeConstraints(*this, false); 16212cacec55f947c716b058a39038889550d7e39b3cChris Lattner 16222cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If there are constraints on our named nodes, apply them. 16232cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (StringMap<SmallVector<TreePatternNode*,1> >::iterator 16242cacec55f947c716b058a39038889550d7e39b3cChris Lattner I = NamedNodes.begin(), E = NamedNodes.end(); I != E; ++I) { 16252cacec55f947c716b058a39038889550d7e39b3cChris Lattner SmallVectorImpl<TreePatternNode*> &Nodes = I->second; 16262cacec55f947c716b058a39038889550d7e39b3cChris Lattner 16272cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If we have input named node types, propagate their types to the named 16282cacec55f947c716b058a39038889550d7e39b3cChris Lattner // values here. 16292cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (InNamedTypes) { 16302cacec55f947c716b058a39038889550d7e39b3cChris Lattner // FIXME: Should be error? 16312cacec55f947c716b058a39038889550d7e39b3cChris Lattner assert(InNamedTypes->count(I->getKey()) && 16322cacec55f947c716b058a39038889550d7e39b3cChris Lattner "Named node in output pattern but not input pattern?"); 16332cacec55f947c716b058a39038889550d7e39b3cChris Lattner 16342cacec55f947c716b058a39038889550d7e39b3cChris Lattner const SmallVectorImpl<TreePatternNode*> &InNodes = 16352cacec55f947c716b058a39038889550d7e39b3cChris Lattner InNamedTypes->find(I->getKey())->second; 16362cacec55f947c716b058a39038889550d7e39b3cChris Lattner 16372cacec55f947c716b058a39038889550d7e39b3cChris Lattner // The input types should be fully resolved by now. 16382cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Nodes.size(); i != e; ++i) { 16392cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this node is a register class, and it is the root of the pattern 16402cacec55f947c716b058a39038889550d7e39b3cChris Lattner // then we're mapping something onto an input register. We allow 16412cacec55f947c716b058a39038889550d7e39b3cChris Lattner // changing the type of the input register in this case. This allows 16422cacec55f947c716b058a39038889550d7e39b3cChris Lattner // us to match things like: 16432cacec55f947c716b058a39038889550d7e39b3cChris Lattner // def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>; 16442cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) { 16452cacec55f947c716b058a39038889550d7e39b3cChris Lattner DefInit *DI = dynamic_cast<DefInit*>(Nodes[i]->getLeafValue()); 16462cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (DI && DI->getDef()->isSubClassOf("RegisterClass")) 16472cacec55f947c716b058a39038889550d7e39b3cChris Lattner continue; 16482cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 16492cacec55f947c716b058a39038889550d7e39b3cChris Lattner 165032f6a8b8bb9de0180036eaf7f7ac6dc030d85655Daniel Dunbar assert(Nodes[i]->getNumTypes() == 1 && 1651d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner InNodes[0]->getNumTypes() == 1 && 1652d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "FIXME: cannot name multiple result nodes yet"); 1653d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= Nodes[i]->UpdateNodeType(0, InNodes[0]->getExtType(0), 1654d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner *this); 16552cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 16562cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 16572cacec55f947c716b058a39038889550d7e39b3cChris Lattner 16582cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If there are multiple nodes with the same name, they must all have the 16592cacec55f947c716b058a39038889550d7e39b3cChris Lattner // same type. 16602cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (I->second.size() > 1) { 16612cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = Nodes.size()-1; i != e; ++i) { 1662d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *N1 = Nodes[i], *N2 = Nodes[i+1]; 166332f6a8b8bb9de0180036eaf7f7ac6dc030d85655Daniel Dunbar assert(N1->getNumTypes() == 1 && N2->getNumTypes() == 1 && 1664d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner "FIXME: cannot name multiple result nodes yet"); 1665d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 1666d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= N1->UpdateNodeType(0, N2->getExtType(0), *this); 1667d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner MadeChange |= N2->UpdateNodeType(0, N1->getExtType(0), *this); 16682cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 16692cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 16702cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 16716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 16726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool HasUnresolvedTypes = false; 16746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) 16756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner HasUnresolvedTypes |= Trees[i]->ContainsUnresolvedType(); 16766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return !HasUnresolvedTypes; 16776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 16786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16791a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePattern::print(raw_ostream &OS) const { 16806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << getRecord()->getName(); 16816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Args.empty()) { 16826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "(" << Args[0]; 16836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 1, e = Args.size(); i != e; ++i) 16846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ", " << Args[i]; 16856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ")"; 16866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 16876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << ": "; 16886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Trees.size() > 1) 16906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "[\n"; 16916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Trees.size(); i != e; ++i) { 16926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "\t"; 16936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Trees[i]->print(OS); 16946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "\n"; 16956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 16966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 16976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Trees.size() > 1) 16986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OS << "]\n"; 16996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17011a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid TreePattern::dump() const { print(errs()); } 17026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner//===----------------------------------------------------------------------===// 1704fe71893183f504feff290e343bf740bd32432129Chris Lattner// CodeGenDAGPatterns implementation 17056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// 17066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1707fe71893183f504feff290e343bf740bd32432129Chris LattnerCodeGenDAGPatterns::CodeGenDAGPatterns(RecordKeeper &R) : Records(R) { 170849de98214b82fefeb8f16efbf8cdd8813a85469bDale Johannesen Intrinsics = LoadIntrinsics(Records, false); 170949de98214b82fefeb8f16efbf8cdd8813a85469bDale Johannesen TgtIntrinsics = LoadIntrinsics(Records, true); 17106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseNodeInfo(); 1711443e3f9dd61b8d0974bb13d484195ce1a9b7536cChris Lattner ParseNodeTransforms(); 17126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseComplexPatterns(); 1713dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner ParsePatternFragments(); 17146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseDefaultOperands(); 17156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParseInstructions(); 17166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ParsePatterns(); 17176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Generate variants. For example, commutative patterns can match 17196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // multiple ways. Add them to PatternsToMatch as well. 17206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GenerateVariants(); 1721ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 1722ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Infer instruction flags. For example, we can detect loads, 1723ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // stores, and side effects in many cases by examining an 1724ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // instruction's pattern. 1725ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InferInstructionFlags(); 17266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1728fe71893183f504feff290e343bf740bd32432129Chris LattnerCodeGenDAGPatterns::~CodeGenDAGPatterns() { 17295b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer for (pf_iterator I = PatternFragments.begin(), 17306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner E = PatternFragments.end(); I != E; ++I) 17316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete I->second; 17326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1735fe71893183f504feff290e343bf740bd32432129Chris LattnerRecord *CodeGenDAGPatterns::getSDNodeNamed(const std::string &Name) const { 17366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *N = Records.getDef(Name); 17376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!N || !N->isSubClassOf("SDNode")) { 17381a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar errs() << "Error getting SDNode '" << Name << "'!\n"; 17396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner exit(1); 17406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return N; 17426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// Parse all of the SDNode definitions for the target, populating SDNodes. 1745fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseNodeInfo() { 17466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("SDNode"); 17476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!Nodes.empty()) { 17486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SDNodes.insert(std::make_pair(Nodes.back(), Nodes.back())); 17496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Nodes.pop_back(); 17506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1752da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // Get the builtin intrinsic nodes. 17536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_void_sdnode = getSDNodeNamed("intrinsic_void"); 17546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_w_chain_sdnode = getSDNodeNamed("intrinsic_w_chain"); 17556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner intrinsic_wo_chain_sdnode = getSDNodeNamed("intrinsic_wo_chain"); 17566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParseNodeTransforms - Parse all SDNodeXForm instances into the SDNodeXForms 17596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// map, and emit them to the file as functions. 1760fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseNodeTransforms() { 17616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Xforms = Records.getAllDerivedDefinitions("SDNodeXForm"); 17626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!Xforms.empty()) { 17636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *XFormNode = Xforms.back(); 17646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *SDNode = XFormNode->getValueAsDef("Opcode"); 17656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::string Code = XFormNode->getValueAsCode("XFormFunction"); 1766443e3f9dd61b8d0974bb13d484195ce1a9b7536cChris Lattner SDNodeXForms.insert(std::make_pair(XFormNode, NodeXForm(SDNode, Code))); 17676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Xforms.pop_back(); 17696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1772fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseComplexPatterns() { 17736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> AMs = Records.getAllDerivedDefinitions("ComplexPattern"); 17746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (!AMs.empty()) { 17756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ComplexPatterns.insert(std::make_pair(AMs.back(), AMs.back())); 17766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AMs.pop_back(); 17776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 17786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 17796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 17816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParsePatternFragments - Parse all of the PatFrag definitions in the .td 17826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// file, building up the PatternFragments map. After we've collected them all, 17836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// inline fragments together as necessary, so that there are no references left 17846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// inside a pattern fragment to a pattern fragment. 17856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 1786fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParsePatternFragments() { 17876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Fragments = Records.getAllDerivedDefinitions("PatFrag"); 17886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1789dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // First step, parse all of the fragments. 17906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { 17916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DagInit *Tree = Fragments[i]->getValueAsDag("Fragment"); 17926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this); 17936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternFragments[Fragments[i]] = P; 17946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1795dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // Validate the argument list, converting it to set, to discard duplicates. 17966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::string> &Args = P->getArgList(); 1797dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner std::set<std::string> OperandsSet(Args.begin(), Args.end()); 17986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1799dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (OperandsSet.count("")) 18006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Cannot have unnamed 'node' values in pattern fragment!"); 18016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the operands list. 18036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DagInit *OpsList = Fragments[i]->getValueAsDag("Operands"); 18046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *OpsOp = dynamic_cast<DefInit*>(OpsList->getOperator()); 18056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Special cases: ops == outs == ins. Different names are used to 1806da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // improve readability. 18076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!OpsOp || 18086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner (OpsOp->getDef()->getName() != "ops" && 18096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpsOp->getDef()->getName() != "outs" && 18106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpsOp->getDef()->getName() != "ins")) 18116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should start with '(ops ... '!"); 18126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy over the arguments. 18146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Args.clear(); 18156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) { 18166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!dynamic_cast<DefInit*>(OpsList->getArg(j)) || 18176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner static_cast<DefInit*>(OpsList->getArg(j))-> 18186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner getDef()->getName() != "node") 18196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should all be 'node' values."); 18206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OpsList->getArgName(j).empty()) 18216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list should have names for each operand!"); 1822dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!OperandsSet.count(OpsList->getArgName(j))) 18236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("'" + OpsList->getArgName(j) + 18246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' does not occur in pattern or was multiply specified!"); 1825dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner OperandsSet.erase(OpsList->getArgName(j)); 18266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Args.push_back(OpsList->getArgName(j)); 18276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 18286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1829dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!OperandsSet.empty()) 18306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->error("Operands list does not contain an entry for operand '" + 1831dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner *OperandsSet.begin() + "'!"); 18326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1833dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // If there is a code init for this fragment, keep track of the fact that 1834dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner // this fragment uses it. 18356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::string Code = Fragments[i]->getValueAsCode("Predicate"); 1836dc32f9802adc139e3d7ee5e25fe656b1d3999bc2Chris Lattner if (!Code.empty()) 18370540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman P->getOnlyTree()->addPredicateFn("Predicate_"+Fragments[i]->getName()); 18386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If there is a node transformation corresponding to this, keep track of 18406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // it. 18416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Transform = Fragments[i]->getValueAsDef("OperandTransform"); 18426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getSDNodeTransform(Transform).second.empty()) // not noop xform? 18436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner P->getOnlyTree()->setTransformFn(Transform); 18446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 18456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Now that we've parsed all of the tree fragments, do a closure on them so 18476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // that there are not references to PatFrags left inside of them. 18482ca698df93421327a459987b33b045756cb47d4dChris Lattner for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { 18492ca698df93421327a459987b33b045756cb47d4dChris Lattner TreePattern *ThePat = PatternFragments[Fragments[i]]; 18506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ThePat->InlinePatternFragments(); 18516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. Don't worry about it if we don't infer 18536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // all of them, some may depend on the inputs of the pattern. 18546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner try { 18556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ThePat->InferAllTypes(); 18566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } catch (...) { 18576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this pattern fragment is not supported by this target (no types can 18586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // satisfy its constraints), just ignore it. If the bogus pattern is 18596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // actually used by instructions, the type consistency error will be 18606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // reported there. 18616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 18626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If debugging, print out the pattern fragment result. 18646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DEBUG(ThePat->dump()); 18656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 18666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 18676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1868fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseDefaultOperands() { 18696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> DefaultOps[2]; 18706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOps[0] = Records.getAllDerivedDefinitions("PredicateOperand"); 18716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOps[1] = Records.getAllDerivedDefinitions("OptionalDefOperand"); 18726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find some SDNode. 18746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(!SDNodes.empty() && "No SDNodes parsed?"); 18756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Init *SomeSDNode = new DefInit(SDNodes.begin()->first); 18766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned iter = 0; iter != 2; ++iter) { 18786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = DefaultOps[iter].size(); i != e; ++i) { 18796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps"); 18806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Clone the DefaultInfo dag node, changing the operator from 'ops' to 18826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // SomeSDnode so that we can parse this. 18836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::pair<Init*, std::string> > Ops; 18846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned op = 0, e = DefaultInfo->getNumArgs(); op != e; ++op) 18856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Ops.push_back(std::make_pair(DefaultInfo->getArg(op), 18866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultInfo->getArgName(op))); 18877cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman DagInit *DI = new DagInit(SomeSDNode, "", Ops); 18886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create a TreePattern to parse this. 18906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern P(DefaultOps[iter][i], DI, false, *this); 18916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(P.getNumTrees() == 1 && "This ctor can only produce one tree!"); 18926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy the operands over into a DAGDefaultOperand. 18946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGDefaultOperand DefaultOpInfo; 18956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 18966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *T = P.getTree(0); 18976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned op = 0, e = T->getNumChildren(); op != e; ++op) { 18986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *TPN = T->getChild(op); 18996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner while (TPN->ApplyTypeConstraints(P, false)) 19006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner /* Resolve all types */; 19016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 1902ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov if (TPN->ContainsUnresolvedType()) { 19036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (iter == 0) 19046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner throw "Value #" + utostr(i) + " of PredicateOperand '" + 190553d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner DefaultOps[iter][i]->getName() +"' doesn't have a concrete type!"; 19066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 19076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner throw "Value #" + utostr(i) + " of OptionalDefOperand '" + 190853d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner DefaultOps[iter][i]->getName() +"' doesn't have a concrete type!"; 1909ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov } 19106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOpInfo.DefaultOps.push_back(TPN); 19116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Insert it into the DefaultOperands map so we can find it later. 19146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefaultOperands[DefaultOps[iter][i]] = DefaultOpInfo; 19156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 19186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// HandleUse - Given "Pat" a leaf in the pattern, check to see if it is an 19206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// instruction input. Return true if this is a real use. 19216cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic bool HandleUse(TreePattern *I, TreePatternNode *Pat, 19226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> &InstInputs, 19236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> &InstImpInputs) { 19246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // No name -> not interesting. 19256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getName().empty()) { 19266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 19276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); 19286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (DI && DI->getDef()->isSubClassOf("RegisterClass")) 19296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Input " + DI->getDef()->getName() + " must be named!"); 19306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else if (DI && DI->getDef()->isSubClassOf("Register")) 19316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpInputs.push_back(DI->getDef()); 19326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 19346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Rec; 19376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 19386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); 19396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!"); 19406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Rec = DI->getDef(); 19416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 19426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Rec = Pat->getOperator(); 19436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // SRCVALUE nodes are ignored. 19466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Rec->getName() == "srcvalue") 19476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return false; 19486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *&Slot = InstInputs[Pat->getName()]; 19506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Slot) { 19516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Slot = Pat; 195253d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner return true; 195353d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner } 195453d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner Record *SlotRec; 195553d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner if (Slot->isLeaf()) { 195653d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner SlotRec = dynamic_cast<DefInit*>(Slot->getLeafValue())->getDef(); 19576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 195853d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner assert(Slot->getNumChildren() == 0 && "can't be a use with children!"); 195953d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner SlotRec = Slot->getOperator(); 19606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 196153d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner 196253d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner // Ensure that the inputs agree if we've already seen this input. 196353d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner if (Rec != SlotRec) 196453d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner I->error("All $" + Pat->getName() + " inputs must agree with each other"); 1965d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Slot->getExtTypes() != Pat->getExtTypes()) 196653d09bd0099e2ac400ad5ddcb928ad0d524fbe5cChris Lattner I->error("All $" + Pat->getName() + " inputs must agree with each other"); 19676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return true; 19686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 19696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// FindPatternInputsAndOutputs - Scan the specified TreePatternNode (which is 19716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// part of "I", the instruction), computing the set of inputs and outputs of 19726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// the pattern. Report errors if we see anything naughty. 1973fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns:: 19746cefb77a7073057fecd721ae141140d75ce76512Chris LattnerFindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat, 19756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> &InstInputs, 19766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*>&InstResults, 19776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> &InstImpInputs, 19786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> &InstImpResults) { 19796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->isLeaf()) { 19806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool isUse = HandleUse(I, Pat, InstInputs, InstImpInputs); 19816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isUse && Pat->getTransformFn()) 19826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function for a non-input value!"); 19836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 198484aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 198584aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner 198684aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner if (Pat->getOperator()->getName() == "implicit") { 19876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { 19886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Dest = Pat->getChild(i); 19896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dest->isLeaf()) 19906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("implicitly defined value should be a register!"); 19916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 19926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); 19936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Val || !Val->getDef()->isSubClassOf("Register")) 19946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("implicitly defined value should be a register!"); 19956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpResults.push_back(Val->getDef()); 19966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 19976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 199884aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 199984aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner 200084aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner if (Pat->getOperator()->getName() != "set") { 20016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is not a set, verify that the children nodes are not void typed, 20026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // and recurse. 20036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { 2004d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Pat->getChild(i)->getNumTypes() == 0) 20056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot have void nodes inside of patterns!"); 20066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat->getChild(i), InstInputs, InstResults, 20076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpInputs, InstImpResults); 20086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is a non-leaf node with no children, treat it basically as if 20116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // it were a leaf. This handles nodes like (imm). 20127cee81703de8333d457ec9e560b0537b71df5a48Nate Begeman bool isUse = HandleUse(I, Pat, InstInputs, InstImpInputs); 20136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!isUse && Pat->getTransformFn()) 20156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function for a non-input value!"); 20166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 201784aa60b522e6ff02214912968eba1c037dd7bba1Chris Lattner } 20186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, this is a set, validate and collect instruction results. 20206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getNumChildren() == 0) 20216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set requires operands!"); 20226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pat->getTransformFn()) 20246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Cannot specify a transform function on a set node!"); 20256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check the set destinations. 20276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NumDests = Pat->getNumChildren()-1; 20286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i != NumDests; ++i) { 20296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Dest = Pat->getChild(i); 20306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Dest->isLeaf()) 20316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 20326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); 20346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!Val) 20356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 20366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Val->getDef()->isSubClassOf("RegisterClass") || 2038a938ac6223c5fd315ab745086d843df5e0604e09Chris Lattner Val->getDef()->isSubClassOf("PointerLikeRegClass")) { 20396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Dest->getName().empty()) 20406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination must have a name!"); 20416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InstResults.count(Dest->getName())) 20426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("cannot set '" + Dest->getName() +"' multiple times"); 20436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstResults[Dest->getName()] = Dest; 20446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else if (Val->getDef()->isSubClassOf("Register")) { 20456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpResults.push_back(Val->getDef()); 20466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 20476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("set destination should be a register!"); 20486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 20506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 20516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify and collect info from the computation. 20526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat->getChild(NumDests), 20536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstInputs, InstResults, 20546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpInputs, InstImpResults); 20556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 20566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2057ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman//===----------------------------------------------------------------------===// 2058ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman// Instruction Analysis 2059ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman//===----------------------------------------------------------------------===// 2060ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2061ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanclass InstAnalyzer { 2062ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP; 2063ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &mayStore; 2064ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &mayLoad; 2065ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &HasSideEffects; 20661e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool &IsVariadic; 2067ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanpublic: 2068ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstAnalyzer(const CodeGenDAGPatterns &cdp, 20691e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool &maystore, bool &mayload, bool &hse, bool &isv) 20701e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner : CDP(cdp), mayStore(maystore), mayLoad(mayload), HasSideEffects(hse), 20711e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner IsVariadic(isv) { 2072ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2073ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2074ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman /// Analyze - Analyze the specified instruction, returning true if the 2075ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman /// instruction had a pattern. 2076ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool Analyze(Record *InstRecord) { 2077ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const TreePattern *Pattern = CDP.getInstruction(InstRecord).getPattern(); 2078ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Pattern == 0) { 2079ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = 1; 2080ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return false; // No pattern. 2081ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2082ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2083ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // FIXME: Assume only the first tree is the pattern. The others are clobber 2084ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // nodes. 2085ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman AnalyzeNode(Pattern->getTree(0)); 2086ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return true; 2087ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2088ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2089ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanprivate: 2090ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman void AnalyzeNode(const TreePatternNode *N) { 2091ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (N->isLeaf()) { 2092ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) { 2093ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Record *LeafRec = DI->getDef(); 2094ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Handle ComplexPattern leaves. 2095ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (LeafRec->isSubClassOf("ComplexPattern")) { 2096ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const ComplexPattern &CP = CDP.getComplexPattern(LeafRec); 2097ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPMayStore)) mayStore = true; 2098ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPMayLoad)) mayLoad = true; 2099ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (CP.hasProperty(SDNPSideEffect)) HasSideEffects = true; 2100ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2101ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2102ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return; 2103ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2104ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2105ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Analyze children. 2106ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 2107ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman AnalyzeNode(N->getChild(i)); 2108ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2109ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Ignore set nodes, which are not SDNodes. 2110ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (N->getOperator()->getName() == "set") 2111ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman return; 2112ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2113ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Get information about the SDNode for the operator. 2114ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const SDNodeInfo &OpInfo = CDP.getSDNodeInfo(N->getOperator()); 2115ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2116ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Notice properties of the node. 2117ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPMayStore)) mayStore = true; 2118ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPMayLoad)) mayLoad = true; 2119ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (OpInfo.hasProperty(SDNPSideEffect)) HasSideEffects = true; 21201e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner if (OpInfo.hasProperty(SDNPVariadic)) IsVariadic = true; 2121ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2122ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (const CodeGenIntrinsic *IntInfo = N->getIntrinsicInfo(CDP)) { 2123ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If this is an intrinsic, analyze it. 2124ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::ReadArgMem) 2125ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman mayLoad = true;// These may load memory. 2126ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2127ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::WriteArgMem) 2128ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman mayStore = true;// Intrinsics that can write to memory are 'mayStore'. 2129ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2130ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (IntInfo->ModRef >= CodeGenIntrinsic::WriteMem) 2131ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // WriteMem intrinsics can have other strange effects. 2132ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = true; 2133ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2134ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2135ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2136ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman}; 2137ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2138ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanstatic void InferFromPattern(const CodeGenInstruction &Inst, 2139ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool &MayStore, bool &MayLoad, 21401e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool &HasSideEffects, bool &IsVariadic, 2141ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman const CodeGenDAGPatterns &CDP) { 21421e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner MayStore = MayLoad = HasSideEffects = IsVariadic = false; 2143ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2144ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman bool HadPattern = 21451e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner InstAnalyzer(CDP, MayStore, MayLoad, HasSideEffects, IsVariadic) 21461e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner .Analyze(Inst.TheDef); 2147ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2148ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // InstAnalyzer only correctly analyzes mayStore/mayLoad so far. 2149ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.mayStore) { // If the .td file explicitly sets mayStore, use it. 2150ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If we decided that this is a store from the pattern, then the .td file 2151ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // entry is redundant. 2152ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (MayStore) 2153ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, 2154ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "Warning: mayStore flag explicitly set on instruction '%s'" 2155ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman " but flag already inferred from pattern.\n", 2156ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Inst.TheDef->getName().c_str()); 2157ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman MayStore = true; 2158ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2159ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2160ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.mayLoad) { // If the .td file explicitly sets mayLoad, use it. 2161ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // If we decided that this is a load from the pattern, then the .td file 2162ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // entry is redundant. 2163ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (MayLoad) 2164ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, 2165ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "Warning: mayLoad flag explicitly set on instruction '%s'" 2166ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman " but flag already inferred from pattern.\n", 2167ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman Inst.TheDef->getName().c_str()); 2168ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman MayLoad = true; 2169ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2170ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2171ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.neverHasSideEffects) { 2172ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (HadPattern) 2173ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, "Warning: neverHasSideEffects set on instruction '%s' " 2174ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "which already has a pattern\n", Inst.TheDef->getName().c_str()); 2175ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = false; 2176ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2177ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2178ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (Inst.hasSideEffects) { 2179ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman if (HasSideEffects) 2180ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman fprintf(stderr, "Warning: hasSideEffects set on instruction '%s' " 2181ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman "which already inferred this.\n", Inst.TheDef->getName().c_str()); 2182ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman HasSideEffects = true; 2183ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 21841e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner 21851e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner if (Inst.isVariadic) 21861e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner IsVariadic = true; // Can warn if we want. 2187ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman} 2188ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 21896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// ParseInstructions - Parse all of the instructions, inlining and resolving 21906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// any fragments involved. This populates the Instructions list with fully 21916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// resolved instructions. 2192fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParseInstructions() { 21936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction"); 21946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Instrs.size(); i != e; ++i) { 21966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ListInit *LI = 0; 21976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 21986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (dynamic_cast<ListInit*>(Instrs[i]->getValueInit("Pattern"))) 21996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner LI = Instrs[i]->getValueAsListInit("Pattern"); 22006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If there is no pattern, only collect minimal information about the 22026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // instruction for its operand list. We have to assume that there is one 22036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // result, as we have no detailed info. 22046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!LI || LI->getSize() == 0) { 22056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Results; 22066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Operands; 22076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2208f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CodeGenInstruction &InstInfo = Target.getInstruction(Instrs[i]); 22096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InstInfo.OperandList.size() != 0) { 22116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InstInfo.NumDefs == 0) { 22126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // These produce no results 22136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = InstInfo.OperandList.size(); j < e; ++j) 22146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operands.push_back(InstInfo.OperandList[j].Rec); 22156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 22166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Assume the first operand is the result. 22176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Results.push_back(InstInfo.OperandList[0].Rec); 22186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The rest are inputs. 22206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 1, e = InstInfo.OperandList.size(); j < e; ++j) 22216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operands.push_back(InstInfo.OperandList[j].Rec); 22226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create and insert the instruction. 22266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> ImpResults; 22276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> ImpOperands; 22286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Instructions.insert(std::make_pair(Instrs[i], 22296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction(0, Results, Operands, ImpResults, 22306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ImpOperands))); 22316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; // no pattern. 22326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the instruction. 22356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern *I = new TreePattern(Instrs[i], LI, true, *this); 22366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 22376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->InlinePatternFragments(); 22386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we can 22406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // never do anything with this instruction pattern: report it to the user. 22416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!I->InferAllTypes()) 22426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Could not infer all types in pattern!"); 22436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // InstInputs - Keep track of all of the inputs of the instruction, along 22456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // with the record they are declared as. 22466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputs; 22476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // InstResults - Keep track of all the virtual registers that are 'set' 22496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // in the instruction, including what reg class they are. 22506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstResults; 22516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpInputs; 22536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpResults; 22546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that the top-level forms in the instruction are of void type, and 22566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // fill in the InstResults map. 22576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, e = I->getNumTrees(); j != e; ++j) { 22586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Pat = I->getTree(j); 2259d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (Pat->getNumTypes() != 0) 22606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Top-level forms in instruction pattern should have" 22616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " void types"); 22626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find inputs and outputs, and verify the structure of the uses/defs. 22646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(I, Pat, InstInputs, InstResults, 22656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpInputs, InstImpResults); 22666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 22676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Now that we have inputs and outputs of the pattern, inspect the operands 22696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // list for the instruction. This determines the order that operands are 22706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // added to the machine instruction the node corresponds to. 22716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NumResults = InstResults.size(); 22726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the operands list from the (ops) list, validating it. 22746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(I->getArgList().empty() && "Args list should still be empty here!"); 2275f30187a36324fb75042d9ffd20c3fb70aff7763dChris Lattner CodeGenInstruction &CGI = Target.getInstruction(Instrs[i]); 22766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check that all of the results occur first in the list. 22786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Results; 2279d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *Res0Node = 0; 22806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0; i != NumResults; ++i) { 22816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (i == CGI.OperandList.size()) 22826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("'" + InstResults.begin()->first + 22836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "' set but does not appear in operand list!"); 22846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::string &OpName = CGI.OperandList[i].Name; 22856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check that it exists in InstResults. 22876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *RNode = InstResults[OpName]; 22886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (RNode == 0) 22896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " does not exist in operand list!"); 22906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (i == 0) 22926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Res0Node = RNode; 22936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *R = dynamic_cast<DefInit*>(RNode->getLeafValue())->getDef(); 22946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (R == 0) 22956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " should be a set destination: all " 22966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "outputs must occur before inputs in operand list!"); 22976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 22986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (CGI.OperandList[i].Rec != R) 22996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + " class mismatch!"); 23006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Remember the return type. 23026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Results.push_back(CGI.OperandList[i].Rec); 23036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Okay, this one checks out. 23056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstResults.erase(OpName); 23066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Loop over the inputs next. Make a copy of InstInputs so we can destroy 23096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // the copy while we're checking the inputs. 23106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputsCheck(InstInputs); 23116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ResultNodeOperands; 23136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Operands; 23146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = NumResults, e = CGI.OperandList.size(); i != e; ++i) { 23156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CodeGenInstruction::OperandInfo &Op = CGI.OperandList[i]; 23166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::string &OpName = Op.Name; 23176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (OpName.empty()) 23186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand #" + utostr(i) + " in operands list has no name!"); 23196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InstInputsCheck.count(OpName)) { 23216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this is an predicate operand or optional def operand with an 23226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // DefaultOps set filled in, we can ignore this. When we codegen it, 23236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // we will do so as always executed. 23246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Op.Rec->isSubClassOf("PredicateOperand") || 23256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Op.Rec->isSubClassOf("OptionalDefOperand")) { 23266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Does it have a non-empty DefaultOps field? If so, ignore this 23276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // operand. 23286cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!getDefaultOperand(Op.Rec).DefaultOps.empty()) 23296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 23306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + 23326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " does not appear in the instruction pattern"); 23336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *InVal = InstInputsCheck[OpName]; 23356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstInputsCheck.erase(OpName); // It occurred, remove from map. 23366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (InVal->isLeaf() && 23386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner dynamic_cast<DefInit*>(InVal->getLeafValue())) { 23396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef(); 23406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Op.Rec != InRec && !InRec->isSubClassOf("ComplexPattern")) 23416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Operand $" + OpName + "'s register class disagrees" 23426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " between the operand and pattern"); 23436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Operands.push_back(Op.Rec); 23456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Construct the result for the dest-pattern operand list. 23476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OpNode = InVal->clone(); 23486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // No predicate is useful on the result. 23500540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman OpNode->clearPredicateFns(); 23516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Promote the xform function to be an explicit node if set. 23536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Record *Xform = OpNode->getTransformFn()) { 23546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpNode->setTransformFn(0); 23556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 23566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(OpNode); 2357d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); 23586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ResultNodeOperands.push_back(OpNode); 23616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InstInputsCheck.empty()) 23646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner I->error("Input operand $" + InstInputsCheck.begin()->first + 23656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner " occurs in pattern but not in operands list!"); 23666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *ResultPattern = 2368d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner new TreePatternNode(I->getRecord(), ResultNodeOperands, 2369d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner GetNumNodeResults(I->getRecord(), *this)); 23706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy fully inferred output node type to instruction result pattern. 2371d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0; i != NumResults; ++i) 2372d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ResultPattern->setType(i, Res0Node->getExtType(i)); 23736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create and insert the instruction. 23756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // FIXME: InstImpResults and InstImpInputs should not be part of 23766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // DAGInstruction. 23776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction TheInst(I, Results, Operands, InstImpResults, InstImpInputs); 23786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Instructions.insert(std::make_pair(I->getRecord(), TheInst)); 23796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Use a temporary tree pattern to infer all types and make sure that the 23816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // constructed result is correct. This depends on the instruction already 23826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // being inserted into the Instructions map. 23836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern Temp(I->getRecord(), ResultPattern, false, *this); 23842cacec55f947c716b058a39038889550d7e39b3cChris Lattner Temp.InferAllTypes(&I->getNamedNodesMap()); 23856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction &TheInsertedInst = Instructions.find(I->getRecord())->second; 23876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TheInsertedInst.setResultPattern(Temp.getOnlyTree()); 23886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DEBUG(I->dump()); 23906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 23916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 23926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If we can, convert the instructions to be patterns that are matched! 23935b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer for (std::map<Record*, DAGInstruction, RecordPtrCmp>::iterator II = 23945b9e7ef627aa1e2f49a6ee85e718199799841f7eBenjamin Kramer Instructions.begin(), 23956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner E = Instructions.end(); II != E; ++II) { 23966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DAGInstruction &TheInst = II->second; 2397f1ab4f18aad3950d0b9ff1273a276bb8d195d2d6Chris Lattner const TreePattern *I = TheInst.getPattern(); 23986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (I == 0) continue; // No pattern. 23996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // FIXME: Assume only the first tree is the pattern. The others are clobber 24016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // nodes. 24026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Pattern = I->getTree(0); 24036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *SrcPattern; 24046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Pattern->getOperator()->getName() == "set") { 24056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SrcPattern = Pattern->getChild(Pattern->getNumChildren()-1)->clone(); 24066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else{ 24076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Not a set (store or something?) 24086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner SrcPattern = Pattern; 24096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Instr = II->first; 241225b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner AddPatternToMatch(I, 241325b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner PatternToMatch(Instr->getValueAsListInit("Predicates"), 2414967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner SrcPattern, 2415967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner TheInst.getResultPattern(), 241625b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner TheInst.getImpResults(), 2417117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Instr->getValueAsInt("AddedComplexity"), 2418117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Instr->getID())); 24196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 24206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 24216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 24224ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 24234ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattnertypedef std::pair<const TreePatternNode*, unsigned> NameRecord; 24244ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 2425967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattnerstatic void FindNames(const TreePatternNode *P, 2426a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner std::map<std::string, NameRecord> &Names, 2427a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner const TreePattern *PatternTop) { 24284ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (!P->getName().empty()) { 24294ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner NameRecord &Rec = Names[P->getName()]; 24304ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // If this is the first instance of the name, remember the node. 24314ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (Rec.second++ == 0) 24324ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner Rec.first = P; 2433d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner else if (Rec.first->getExtTypes() != P->getExtTypes()) 2434a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner PatternTop->error("repetition of value: $" + P->getName() + 2435a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner " where different uses have different types!"); 24364ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner } 2437967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 2438967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner if (!P->isLeaf()) { 2439967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) 2440a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(P->getChild(i), Names, PatternTop); 2441967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner } 2442967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner} 2443967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 244425b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattnervoid CodeGenDAGPatterns::AddPatternToMatch(const TreePattern *Pattern, 244525b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner const PatternToMatch &PTM) { 2446967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Do some sanity checking on the pattern we're about to match. 244725b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner std::string Reason; 244825b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner if (!PTM.getSrcPattern()->canPatternMatch(Reason, *this)) 2449967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner Pattern->error("Pattern can never match: " + Reason); 245025b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 2451405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner // If the source pattern's root is a complex pattern, that complex pattern 2452405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner // must specify the nodes it can potentially match. 2453405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner if (const ComplexPattern *CP = 2454405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner PTM.getSrcPattern()->getComplexPatternInfo(*this)) 2455405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner if (CP->getRootNodes().empty()) 2456405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner Pattern->error("ComplexPattern at root must specify list of opcodes it" 2457405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner " could match"); 2458405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner 2459405f1252b9f3937b9c30edf683375cf261967c79Chris Lattner 2460967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Find all of the named values in the input and output, ensure they have the 2461967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // same type. 24624ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner std::map<std::string, NameRecord> SrcNames, DstNames; 2463a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(PTM.getSrcPattern(), SrcNames, Pattern); 2464a27234e290a4809c5a60e28e99f2870142ff3a55Chris Lattner FindNames(PTM.getDstPattern(), DstNames, Pattern); 2465967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner 2466967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // Scan all of the named values in the destination pattern, rejecting them if 2467967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner // they don't exist in the input pattern. 24684ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner for (std::map<std::string, NameRecord>::iterator 2469ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner I = DstNames.begin(), E = DstNames.end(); I != E; ++I) { 24704ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (SrcNames[I->first].first == 0) 2471967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner Pattern->error("Pattern has input without matching name in output: $" + 2472967d54ae04d562e0d375bb1dda4289cc58590cfaChris Lattner I->first); 2473ba1cff4450e22415bfcb960342e6d5a5918e530aChris Lattner } 24744ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 24754ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // Scan all of the named values in the source pattern, rejecting them if the 24764ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner // name isn't used in the dest, and isn't used to tie two values together. 24774ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner for (std::map<std::string, NameRecord>::iterator 24784ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner I = SrcNames.begin(), E = SrcNames.end(); I != E; ++I) 24794ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner if (DstNames[I->first].first == 0 && SrcNames[I->first].second == 1) 24804ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner Pattern->error("Pattern has dead named input: $" + I->first); 24814ac7a0ca8fa22ff641e8469d7feca2ac0aea3cefChris Lattner 248225b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner PatternsToMatch.push_back(PTM); 248325b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner} 248425b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 248525b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner 2486ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 2487ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohmanvoid CodeGenDAGPatterns::InferInstructionFlags() { 2488f65027842e82027dd6e8020586a299aaa548e355Chris Lattner const std::vector<const CodeGenInstruction*> &Instructions = 2489f65027842e82027dd6e8020586a299aaa548e355Chris Lattner Target.getInstructionsByEnumValue(); 2490b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner for (unsigned i = 0, e = Instructions.size(); i != e; ++i) { 2491b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner CodeGenInstruction &InstInfo = 2492b61e09de6d0cd7241ddc6dee3efef416552eec3bChris Lattner const_cast<CodeGenInstruction &>(*Instructions[i]); 2493ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman // Determine properties of the instruction from its pattern. 24941e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner bool MayStore, MayLoad, HasSideEffects, IsVariadic; 24951e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner InferFromPattern(InstInfo, MayStore, MayLoad, HasSideEffects, IsVariadic, 24961e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner *this); 2497ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstInfo.mayStore = MayStore; 2498ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstInfo.mayLoad = MayLoad; 2499ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman InstInfo.hasSideEffects = HasSideEffects; 25001e50631675df50a0701ef8b527ced63d0d535a81Chris Lattner InstInfo.isVariadic = IsVariadic; 2501ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman } 2502ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman} 2503ee4fa1977dd3a495a8857eef924ee5961db765c6Dan Gohman 25042cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// Given a pattern result with an unresolved type, see if we can find one 25052cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// instruction with an unresolved result type. Force this result type to an 25062cacec55f947c716b058a39038889550d7e39b3cChris Lattner/// arbitrary element if it's possible types to converge results. 25072cacec55f947c716b058a39038889550d7e39b3cChris Lattnerstatic bool ForceArbitraryInstResultType(TreePatternNode *N, TreePattern &TP) { 25082cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (N->isLeaf()) 25092cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 25102cacec55f947c716b058a39038889550d7e39b3cChris Lattner 25112cacec55f947c716b058a39038889550d7e39b3cChris Lattner // Analyze children. 25122cacec55f947c716b058a39038889550d7e39b3cChris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 25132cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (ForceArbitraryInstResultType(N->getChild(i), TP)) 25142cacec55f947c716b058a39038889550d7e39b3cChris Lattner return true; 25152cacec55f947c716b058a39038889550d7e39b3cChris Lattner 25162cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!N->getOperator()->isSubClassOf("Instruction")) 25172cacec55f947c716b058a39038889550d7e39b3cChris Lattner return false; 25182cacec55f947c716b058a39038889550d7e39b3cChris Lattner 25192cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If this type is already concrete or completely unknown we can't do 25202cacec55f947c716b058a39038889550d7e39b3cChris Lattner // anything. 2521d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = N->getNumTypes(); i != e; ++i) { 2522d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->getExtType(i).isCompletelyUnknown() || N->getExtType(i).isConcrete()) 2523d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner continue; 2524d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 2525d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner // Otherwise, force its type to the first possibility (an arbitrary choice). 2526d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner if (N->getExtType(i).MergeInTypeInfo(N->getExtType(i).getTypeList()[0], TP)) 2527d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return true; 2528d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner } 25292cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2530d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner return false; 25312cacec55f947c716b058a39038889550d7e39b3cChris Lattner} 25322cacec55f947c716b058a39038889550d7e39b3cChris Lattner 2533fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::ParsePatterns() { 25346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> Patterns = Records.getAllDerivedDefinitions("Pattern"); 25356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = Patterns.size(); i != e; ++i) { 2537d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Record *CurPattern = Patterns[i]; 2538d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch"); 2539310adf1c6f58921b30fde145fd15cb1798050205Chris Lattner TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this); 25406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 25426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Pattern->InlinePatternFragments(); 25436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2544d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs"); 25456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (LI->getSize() == 0) continue; // no pattern. 25466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Parse the instruction. 2548d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePattern *Result = new TreePattern(CurPattern, LI, false, *this); 25496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Inline pattern fragments into it. 25516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->InlinePatternFragments(); 25526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Result->getNumTrees() != 1) 25546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->error("Cannot handle instructions producing instructions " 25556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner "with temporaries yet!"); 25566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool IterateInference; 25586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool InferredAllPatternTypes, InferredAllResultTypes; 25596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner do { 25606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we 25616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // can never do anything with this pattern: report it to the user. 25622cacec55f947c716b058a39038889550d7e39b3cChris Lattner InferredAllPatternTypes = 25632cacec55f947c716b058a39038889550d7e39b3cChris Lattner Pattern->InferAllTypes(&Pattern->getNamedNodesMap()); 25646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Infer as many types as possible. If we cannot infer all of them, we 25666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // can never do anything with this pattern: report it to the user. 25672cacec55f947c716b058a39038889550d7e39b3cChris Lattner InferredAllResultTypes = 25682cacec55f947c716b058a39038889550d7e39b3cChris Lattner Result->InferAllTypes(&Pattern->getNamedNodesMap()); 25696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 25706c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference = false; 25716c6ba364931acb113973ad3e6d69736969c59299Chris Lattner 25726cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Apply the type of the result to the source pattern. This helps us 25736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // resolve cases where the input type is known to be a pointer type (which 25746cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // is considered resolved), but the result knows it needs to be 32- or 25756cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 64-bits. Infer the other way for good measure. 2576d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = std::min(Result->getTree(0)->getNumTypes(), 2577d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Pattern->getTree(0)->getNumTypes()); 2578d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner i != e; ++i) { 25796c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference = Pattern->getTree(0)-> 2580d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner UpdateNodeType(i, Result->getTree(0)->getExtType(i), *Result); 25816c6ba364931acb113973ad3e6d69736969c59299Chris Lattner IterateInference |= Result->getTree(0)-> 2582d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner UpdateNodeType(i, Pattern->getTree(0)->getExtType(i), *Result); 25836c6ba364931acb113973ad3e6d69736969c59299Chris Lattner } 25842cacec55f947c716b058a39038889550d7e39b3cChris Lattner 25852cacec55f947c716b058a39038889550d7e39b3cChris Lattner // If our iteration has converged and the input pattern's types are fully 25862cacec55f947c716b058a39038889550d7e39b3cChris Lattner // resolved but the result pattern is not fully resolved, we may have a 25872cacec55f947c716b058a39038889550d7e39b3cChris Lattner // situation where we have two instructions in the result pattern and 25882cacec55f947c716b058a39038889550d7e39b3cChris Lattner // the instructions require a common register class, but don't care about 25892cacec55f947c716b058a39038889550d7e39b3cChris Lattner // what actual MVT is used. This is actually a bug in our modelling: 25902cacec55f947c716b058a39038889550d7e39b3cChris Lattner // output patterns should have register classes, not MVTs. 25912cacec55f947c716b058a39038889550d7e39b3cChris Lattner // 25922cacec55f947c716b058a39038889550d7e39b3cChris Lattner // In any case, to handle this, we just go through and disambiguate some 25932cacec55f947c716b058a39038889550d7e39b3cChris Lattner // arbitrary types to the result pattern's nodes. 25942cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!IterateInference && InferredAllPatternTypes && 25952cacec55f947c716b058a39038889550d7e39b3cChris Lattner !InferredAllResultTypes) 25962cacec55f947c716b058a39038889550d7e39b3cChris Lattner IterateInference = ForceArbitraryInstResultType(Result->getTree(0), 25972cacec55f947c716b058a39038889550d7e39b3cChris Lattner *Result); 25986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } while (IterateInference); 25999008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 26006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Verify that we inferred enough types that we can do something with the 26016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // pattern and result. If these fire the user has to add type casts. 26026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!InferredAllPatternTypes) 26036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Pattern->error("Could not infer all types in pattern!"); 26042cacec55f947c716b058a39038889550d7e39b3cChris Lattner if (!InferredAllResultTypes) { 26052cacec55f947c716b058a39038889550d7e39b3cChris Lattner Pattern->dump(); 26066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Result->error("Could not infer all types in pattern result!"); 26072cacec55f947c716b058a39038889550d7e39b3cChris Lattner } 26086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Validate that the input pattern is correct. 26106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstInputs; 26116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::map<std::string, TreePatternNode*> InstResults; 26126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpInputs; 26136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<Record*> InstImpResults; 26146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned j = 0, ee = Pattern->getNumTrees(); j != ee; ++j) 26156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner FindPatternInputsAndOutputs(Pattern, Pattern->getTree(j), 26166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstInputs, InstResults, 26176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner InstImpInputs, InstImpResults); 26186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Promote the xform function to be an explicit node if set. 26206cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *DstPattern = Result->getOnlyTree(); 26216cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ResultNodeOperands; 26226cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned ii = 0, ee = DstPattern->getNumChildren(); ii != ee; ++ii) { 26236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *OpNode = DstPattern->getChild(ii); 26246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Record *Xform = OpNode->getTransformFn()) { 26256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OpNode->setTransformFn(0); 26266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Children; 26276cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(OpNode); 2628d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); 26296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 26306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ResultNodeOperands.push_back(OpNode); 26316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 26326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DstPattern = Result->getOnlyTree(); 26336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!DstPattern->isLeaf()) 26346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner DstPattern = new TreePatternNode(DstPattern->getOperator(), 2635d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner ResultNodeOperands, 2636d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DstPattern->getNumTypes()); 2637d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 2638d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Result->getOnlyTree()->getNumTypes(); i != e; ++i) 2639d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner DstPattern->setType(i, Result->getOnlyTree()->getExtType(i)); 2640d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner 26416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePattern Temp(Result->getRecord(), DstPattern, false, *this); 26426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Temp.InferAllTypes(); 26436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 264525b6f91c549225ae4fc9855b9c82a46d05dfd4d8Chris Lattner AddPatternToMatch(Pattern, 2646d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner PatternToMatch(CurPattern->getValueAsListInit("Predicates"), 2647d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Pattern->getTree(0), 2648d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Temp.getOnlyTree(), InstImpResults, 2649d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CurPattern->getValueAsInt("AddedComplexity"), 2650d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner CurPattern->getID())); 26516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 26526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 26536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// CombineChildVariants - Given a bunch of permutations of each child of the 26556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 'operator' node, put them together in all possible ways. 26566cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void CombineChildVariants(TreePatternNode *Orig, 26576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<std::vector<TreePatternNode*> > &ChildVariants, 26586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 2659327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 2660327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 26616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Make sure that each operand has at least one variant to choose from. 26626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i) 26636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (ChildVariants[i].empty()) 26646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 26656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // The end result is an all-pairs construction of the resultant pattern. 26676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<unsigned> Idxs; 26686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Idxs.resize(ChildVariants.size()); 2669327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel bool NotDone; 2670327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel do { 2671327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel#ifndef NDEBUG 2672aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner DEBUG(if (!Idxs.empty()) { 2673aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << Orig->getOperator()->getName() << ": Idxs = [ "; 2674aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner for (unsigned i = 0; i < Idxs.size(); ++i) { 2675aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << Idxs[i] << " "; 2676aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner } 2677aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner errs() << "]\n"; 2678aaf5486b82f512ada7ca11cec27f96fb06db36d8Chris Lattner }); 2679327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel#endif 26806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Create the variant and add it to the output list. 26816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> NewChildren; 26826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i) 26836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NewChildren.push_back(ChildVariants[i][Idxs[i]]); 2684d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner TreePatternNode *R = new TreePatternNode(Orig->getOperator(), NewChildren, 2685d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner Orig->getNumTypes()); 26866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 26876cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Copy over properties. 26886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->setName(Orig->getName()); 26890540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman R->setPredicateFns(Orig->getPredicateFns()); 26906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner R->setTransformFn(Orig->getTransformFn()); 2691d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner for (unsigned i = 0, e = Orig->getNumTypes(); i != e; ++i) 2692d7349194650386d97a1d779369cb46f20ba9f252Chris Lattner R->setType(i, Orig->getExtType(i)); 26936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2694327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // If this pattern cannot match, do not include it as a variant. 26956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::string ErrString; 26966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (!R->canPatternMatch(ErrString, CDP)) { 26976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete R; 26986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } else { 26996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool AlreadyExists = false; 27006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan to see if this pattern has already been emitted. We can get 27026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // duplication due to things like commuting: 27036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (and GPRC:$a, GPRC:$b) -> (and GPRC:$b, GPRC:$a) 27046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // which are the same pattern. Ignore the dups. 27056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = OutVariants.size(); i != e; ++i) 2706327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (R->isIsomorphicTo(OutVariants[i], DepVars)) { 27076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AlreadyExists = true; 27086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 27096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (AlreadyExists) 27126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner delete R; 27136cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 27146cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OutVariants.push_back(R); 27156cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2717327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // Increment indices to the next permutation by incrementing the 2718327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // indicies from last index backward, e.g., generate the sequence 2719327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel // [0, 0], [0, 1], [1, 0], [1, 1]. 2720327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel int IdxsIdx; 2721327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel for (IdxsIdx = Idxs.size() - 1; IdxsIdx >= 0; --IdxsIdx) { 2722327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (++Idxs[IdxsIdx] == ChildVariants[IdxsIdx].size()) 2723327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel Idxs[IdxsIdx] = 0; 2724327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel else 27256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 27266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 2727327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel NotDone = (IdxsIdx >= 0); 2728327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel } while (NotDone); 27296cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 27306cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// CombineChildVariants - A helper function for binary operators. 27326cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 27336cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void CombineChildVariants(TreePatternNode *Orig, 27346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<TreePatternNode*> &LHS, 27356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const std::vector<TreePatternNode*> &RHS, 27366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 2737327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 2738327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 27396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::vector<TreePatternNode*> > ChildVariants; 27406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.push_back(LHS); 27416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.push_back(RHS); 2742327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(Orig, ChildVariants, OutVariants, CDP, DepVars); 27436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 27446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27466cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void GatherChildrenOfAssociativeOpcode(TreePatternNode *N, 27476cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode *> &Children) { 27486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(N->getNumChildren()==2 &&"Associative but doesn't have 2 children!"); 27496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *Operator = N->getOperator(); 27506cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Only permit raw nodes. 27520540e17788f0d09d784fb9bd9b354e02f1c5e4a4Dan Gohman if (!N->getName().empty() || !N->getPredicateFns().empty() || 27536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner N->getTransformFn()) { 27546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N); 27556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 27566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getChild(0)->isLeaf() || N->getChild(0)->getOperator() != Operator) 27596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N->getChild(0)); 27606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 27616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N->getChild(0), Children); 27626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->getChild(1)->isLeaf() || N->getChild(1)->getOperator() != Operator) 27646cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Children.push_back(N->getChild(1)); 27656cefb77a7073057fecd721ae141140d75ce76512Chris Lattner else 27666cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N->getChild(1), Children); 27676cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 27686cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27696cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// GenerateVariantsOf - Given a pattern N, generate all permutations we can of 27706cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// the (potentially recursive) pattern by using algebraic laws. 27716cefb77a7073057fecd721ae141140d75ce76512Chris Lattner/// 27726cefb77a7073057fecd721ae141140d75ce76512Chris Lattnerstatic void GenerateVariantsOf(TreePatternNode *N, 27736cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> &OutVariants, 2774327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CodeGenDAGPatterns &CDP, 2775327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel const MultipleUseVarSet &DepVars) { 27766cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // We cannot permute leaves. 27776cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (N->isLeaf()) { 27786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner OutVariants.push_back(N); 27796cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 27806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 27816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Look up interesting info about the node. 27836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(N->getOperator()); 27846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2785da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // If this node is associative, re-associate. 27866cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (NodeInfo.hasProperty(SDNPAssociative)) { 2787da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // Re-associate by pulling together all of the linked operators 27886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> MaximalChildren; 27896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner GatherChildrenOfAssociativeOpcode(N, MaximalChildren); 27906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 27916cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Only handle child sizes of 3. Otherwise we'll end up trying too many 27926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // permutations. 27936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (MaximalChildren.size() == 3) { 27946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Find the variants of all of our maximal children. 27956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> AVariants, BVariants, CVariants; 2796327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[0], AVariants, CDP, DepVars); 2797327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[1], BVariants, CDP, DepVars); 2798327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(MaximalChildren[2], CVariants, CDP, DepVars); 27996cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // There are only two ways we can permute the tree: 28016cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // (A op B) op C and A op (B op C) 28026cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Within these forms, we can also permute A/B/C. 28036cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28046cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Generate legal pair permutations of A/B/C. 28056cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ABVariants; 28066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> BAVariants; 28076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> ACVariants; 28086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CAVariants; 28096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> BCVariants; 28106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> CBVariants; 2811327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, BVariants, ABVariants, CDP, DepVars); 2812327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, AVariants, BAVariants, CDP, DepVars); 2813327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, CVariants, ACVariants, CDP, DepVars); 2814327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, AVariants, CAVariants, CDP, DepVars); 2815327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, CVariants, BCVariants, CDP, DepVars); 2816327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, BVariants, CBVariants, CDP, DepVars); 28176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Combine those into the result: (x op x) op x 2819327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ABVariants, CVariants, OutVariants, CDP, DepVars); 2820327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BAVariants, CVariants, OutVariants, CDP, DepVars); 2821327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ACVariants, BVariants, OutVariants, CDP, DepVars); 2822327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CAVariants, BVariants, OutVariants, CDP, DepVars); 2823327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BCVariants, AVariants, OutVariants, CDP, DepVars); 2824327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CBVariants, AVariants, OutVariants, CDP, DepVars); 28256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Combine those into the result: x op (x op x) 2827327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, ABVariants, OutVariants, CDP, DepVars); 2828327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, CVariants, BAVariants, OutVariants, CDP, DepVars); 2829327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, ACVariants, OutVariants, CDP, DepVars); 2830327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, BVariants, CAVariants, OutVariants, CDP, DepVars); 2831327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, BCVariants, OutVariants, CDP, DepVars); 2832327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, AVariants, CBVariants, OutVariants, CDP, DepVars); 28336cefb77a7073057fecd721ae141140d75ce76512Chris Lattner return; 28346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Compute permutations of all children. 28386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<std::vector<TreePatternNode*> > ChildVariants; 28396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner ChildVariants.resize(N->getNumChildren()); 28406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) 2841327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(N->getChild(i), ChildVariants[i], CDP, DepVars); 28426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Build all permutations based on how the children were formed. 2844327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel CombineChildVariants(N, ChildVariants, OutVariants, CDP, DepVars); 28456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28466cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If this node is commutative, consider the commuted order. 28476bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng bool isCommIntrinsic = N->isCommutativeIntrinsic(CDP); 28486bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { 28496bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng assert((N->getNumChildren()==2 || isCommIntrinsic) && 28506bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng "Commutative but doesn't have 2 children!"); 28516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Don't count children which are actually register references. 28526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner unsigned NC = 0; 28536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { 28546cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Child = N->getChild(i); 28556cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Child->isLeaf()) 28566cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) { 28576cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Record *RR = DI->getDef(); 28586cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (RR->isSubClassOf("Register")) 28596cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 28606cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28616cefb77a7073057fecd721ae141140d75ce76512Chris Lattner NC++; 28626cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28636cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Consider the commuted order. 28646bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng if (isCommIntrinsic) { 28656bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // Commutative intrinsic. First operand is the intrinsic id, 2nd and 3rd 28666bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // operands are the commutative operands, and there might be more operands 28676bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng // after those. 28686bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng assert(NC >= 3 && 28696bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng "Commutative intrinsic should have at least 3 childrean!"); 28706bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng std::vector<std::vector<TreePatternNode*> > Variants; 28716bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[0]); // Intrinsic id. 28726bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[2]); 28736bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[1]); 28746bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng for (unsigned i = 3; i != NC; ++i) 28756bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng Variants.push_back(ChildVariants[i]); 28766bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng CombineChildVariants(N, Variants, OutVariants, CDP, DepVars); 28776bd9567a6a1ba62118cdd258ddc52ea8f82ff511Evan Cheng } else if (NC == 2) 28786cefb77a7073057fecd721ae141140d75ce76512Chris Lattner CombineChildVariants(N, ChildVariants[1], ChildVariants[0], 2879327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel OutVariants, CDP, DepVars); 28806cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 28816cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 28826cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28836cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28846cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// GenerateVariants - Generate variants. For example, commutative patterns can 28856cefb77a7073057fecd721ae141140d75ce76512Chris Lattner// match multiple ways. Add them to PatternsToMatch as well. 2886fe71893183f504feff290e343bf740bd32432129Chris Lattnervoid CodeGenDAGPatterns::GenerateVariants() { 2887569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "Generating instruction variants.\n"); 28886cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 28896cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Loop over all of the patterns we've collected, checking to see if we can 28906cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // generate variants of the instruction, through the exploitation of 2891da4231f134989af7dc6bd3408821ba573def27b2Jim Grosbach // identities. This permits the target to provide aggressive matching without 28926cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // the .td file having to contain tons of variants of instructions. 28936cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 28946cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Note that this loop adds new patterns to the PatternsToMatch list, but we 28956cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // intentionally do not reconsider these. Any variants of added patterns have 28966cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // already been added. 28976cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // 28986cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned i = 0, e = PatternsToMatch.size(); i != e; ++i) { 2899327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel MultipleUseVarSet DepVars; 29006cefb77a7073057fecd721ae141140d75ce76512Chris Lattner std::vector<TreePatternNode*> Variants; 2901327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel FindDepVars(PatternsToMatch[i].getSrcPattern(), DepVars); 2902569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "Dependent/multiply used variables: "); 2903327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel DEBUG(DumpDepVars(DepVars)); 2904569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "\n"); 2905327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel GenerateVariantsOf(PatternsToMatch[i].getSrcPattern(), Variants, *this, DepVars); 29066cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29076cefb77a7073057fecd721ae141140d75ce76512Chris Lattner assert(!Variants.empty() && "Must create at least original variant!"); 29086cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Variants.erase(Variants.begin()); // Remove the original pattern. 29096cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29106cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (Variants.empty()) // No variants for this pattern. 29116cefb77a7073057fecd721ae141140d75ce76512Chris Lattner continue; 29126cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2913569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "FOUND VARIANTS OF: "; 2914569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner PatternsToMatch[i].getSrcPattern()->dump(); 2915569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner errs() << "\n"); 29166cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29176cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned v = 0, e = Variants.size(); v != e; ++v) { 29186cefb77a7073057fecd721ae141140d75ce76512Chris Lattner TreePatternNode *Variant = Variants[v]; 29196cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2920569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << " VAR#" << v << ": "; 2921569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner Variant->dump(); 2922569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner errs() << "\n"); 29236cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29246cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Scan to see if an instruction or explicit pattern already matches this. 29256cefb77a7073057fecd721ae141140d75ce76512Chris Lattner bool AlreadyExists = false; 29266cefb77a7073057fecd721ae141140d75ce76512Chris Lattner for (unsigned p = 0, e = PatternsToMatch.size(); p != e; ++p) { 2927c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng // Skip if the top level predicates do not match. 2928c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng if (PatternsToMatch[i].getPredicates() != 2929c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng PatternsToMatch[p].getPredicates()) 2930c0ad80fd9edbbe41461a62d26585bd6263328b90Evan Cheng continue; 29316cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Check to see if this variant already exists. 2932327d0651f8c3b1480d8fc1f4d96e07a1452eaa8cScott Michel if (Variant->isIsomorphicTo(PatternsToMatch[p].getSrcPattern(), DepVars)) { 2933569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << " *** ALREADY EXISTS, ignoring variant.\n"); 29346cefb77a7073057fecd721ae141140d75ce76512Chris Lattner AlreadyExists = true; 29356cefb77a7073057fecd721ae141140d75ce76512Chris Lattner break; 29366cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29376cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29386cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // If we already have it, ignore the variant. 29396cefb77a7073057fecd721ae141140d75ce76512Chris Lattner if (AlreadyExists) continue; 29406cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 29416cefb77a7073057fecd721ae141140d75ce76512Chris Lattner // Otherwise, add it to the list of patterns we have. 29426cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternsToMatch. 29436cefb77a7073057fecd721ae141140d75ce76512Chris Lattner push_back(PatternToMatch(PatternsToMatch[i].getPredicates(), 29446cefb77a7073057fecd721ae141140d75ce76512Chris Lattner Variant, PatternsToMatch[i].getDstPattern(), 29456cefb77a7073057fecd721ae141140d75ce76512Chris Lattner PatternsToMatch[i].getDstRegs(), 2946117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner PatternsToMatch[i].getAddedComplexity(), 2947117ccb7e518f05e4bf3df058fc402262f897ff0bChris Lattner Record::getNewUID())); 29486cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29496cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2950569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner DEBUG(errs() << "\n"); 29516cefb77a7073057fecd721ae141140d75ce76512Chris Lattner } 29526cefb77a7073057fecd721ae141140d75ce76512Chris Lattner} 29536cefb77a7073057fecd721ae141140d75ce76512Chris Lattner 2954