108d1275cb8137152dbfb13fab361b9b496725124Chris Lattner//===-- LegalizeTypes.cpp - Common code for DAG type legalizer ------------===// 201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner// 301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner// The LLVM Compiler Infrastructure 401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 701d029b82cb08367d81aa10cdc94d05360466649Chris Lattner// 801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner//===----------------------------------------------------------------------===// 901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner// 1001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner// This file implements the SelectionDAG::LegalizeTypes method. It transforms 1108d1275cb8137152dbfb13fab361b9b496725124Chris Lattner// an arbitrary well-formed SelectionDAG to only consist of legal types. This 1208d1275cb8137152dbfb13fab361b9b496725124Chris Lattner// is common code shared among the LegalizeTypes*.cpp files. 1301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner// 1401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner//===----------------------------------------------------------------------===// 1501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 16dff67f5770ada2942dd8c815323ad2480bfdde44Chris Lattner#include "LegalizeTypes.h" 17d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SetVector.h" 180b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/CallingConv.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 20a658baba78e9cb0a9efbc5e4921c63f7b92a920cChris Lattner#include "llvm/Support/CommandLine.h" 217d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 224437ae213d5435390f0750213b53ec807c047f22Chris Lattner#include "llvm/Support/raw_ostream.h" 2301d029b82cb08367d81aa10cdc94d05360466649Chris Lattnerusing namespace llvm; 2401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 25dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "legalize-types" 26dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 2747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sandsstatic cl::opt<bool> 2847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan SandsEnableExpensiveChecks("enable-legalize-types-checking", cl::Hidden); 2947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 30de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Do extensive, expensive, sanity checking. 3147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sandsvoid DAGTypeLegalizer::PerformExpensiveChecks() { 3247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // If a node is not processed, then none of its values should be mapped by any 3347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // of PromotedIntegers, ExpandedIntegers, ..., ReplacedValues. 3447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 3547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // If a node is processed, then each value with an illegal type must be mapped 3647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // by exactly one of PromotedIntegers, ExpandedIntegers, ..., ReplacedValues. 3747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Values with a legal type may be mapped by ReplacedValues, but not by any of 3847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // the other maps. 3947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 4047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Note that these invariants may not hold momentarily when processing a node: 4147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // the node being processed may be put in a map before being marked Processed. 4247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 4347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Note that it is possible to have nodes marked NewNode in the DAG. This can 4447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // occur in two ways. Firstly, a node may be created during legalization but 4547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // never passed to the legalization core. This is usually due to the implicit 4647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // folding that occurs when using the DAG.getNode operators. Secondly, a new 4747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // node may be passed to the legalization core, but when analyzed may morph 4847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // into a different node, leaving the original node as a NewNode in the DAG. 4947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // A node may morph if one of its operands changes during analysis. Whether 5047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // it actually morphs or not depends on whether, after updating its operands, 5147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // it is equivalent to an existing node: if so, it morphs into that existing 5247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // node (CSE). An operand can change during analysis if the operand is a new 5347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // node that morphs, or it is a processed value that was mapped to some other 5447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // value (as recorded in ReplacedValues) in which case the operand is turned 5547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // into that other value. If a node morphs then the node it morphed into will 5647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // be used instead of it for legalization, however the original node continues 5747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // to live on in the DAG. 5847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // The conclusion is that though there may be nodes marked NewNode in the DAG, 5947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // all uses of such nodes are also marked NewNode: the result is a fungus of 6047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // NewNodes growing on top of the useful nodes, and perhaps using them, but 6147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // not used by them. 6247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 6347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // If a value is mapped by ReplacedValues, then it must have no uses, except 6447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // by nodes marked NewNode (see above). 6547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 6647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // The final node obtained by mapping by ReplacedValues is not marked NewNode. 6747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Note that ReplacedValues should be applied iteratively. 6847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 69c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // Note that the ReplacedValues map may also map deleted nodes (by iterating 70c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // over the DAG we never dereference deleted nodes). This means that it may 71c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // also map nodes marked NewNode if the deallocated memory was reallocated as 72c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // another node, and that new node was not seen by the LegalizeTypes machinery 73c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // (for example because it was created but not used). In general, we cannot 74c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // distinguish between new nodes and deleted nodes. 7547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands SmallVector<SDNode*, 16> NewNodes; 76f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (SDNode &Node : DAG.allnodes()) { 7747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Remember nodes marked NewNode - they are subject to extra checking below. 78f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Node.getNodeId() == NewNode) 79f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar NewNodes.push_back(&Node); 8047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 81f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned i = 0, e = Node.getNumValues(); i != e; ++i) { 82f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar SDValue Res(&Node, i); 8347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands bool Failed = false; 8447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 8547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands unsigned Mapped = 0; 8647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (ReplacedValues.find(Res) != ReplacedValues.end()) { 8747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Mapped |= 1; 8847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Check that remapped values are only used by nodes marked NewNode. 89f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (SDNode::use_iterator UI = Node.use_begin(), UE = Node.use_end(); 9047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands UI != UE; ++UI) 91e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman if (UI.getUse().getResNo() == i) 9247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(UI->getNodeId() == NewNode && 9347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands "Remapped value has non-trivial use!"); 9447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 9547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Check that the final result of applying ReplacedValues is not 9647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // marked NewNode. 9747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands SDValue NewVal = ReplacedValues[Res]; 9847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands DenseMap<SDValue, SDValue>::iterator I = ReplacedValues.find(NewVal); 9947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands while (I != ReplacedValues.end()) { 10047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands NewVal = I->second; 10147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands I = ReplacedValues.find(NewVal); 10247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 10347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(NewVal.getNode()->getNodeId() != NewNode && 10447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands "ReplacedValues maps to a new node!"); 10547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 10647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (PromotedIntegers.find(Res) != PromotedIntegers.end()) 10747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Mapped |= 2; 10847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (SoftenedFloats.find(Res) != SoftenedFloats.end()) 10947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Mapped |= 4; 11047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (ScalarizedVectors.find(Res) != ScalarizedVectors.end()) 11147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Mapped |= 8; 11247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (ExpandedIntegers.find(Res) != ExpandedIntegers.end()) 11347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Mapped |= 16; 11447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (ExpandedFloats.find(Res) != ExpandedFloats.end()) 11547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Mapped |= 32; 11647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (SplitVectors.find(Res) != SplitVectors.end()) 11747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Mapped |= 64; 11887c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang if (WidenedVectors.find(Res) != WidenedVectors.end()) 11987c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang Mapped |= 128; 12047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 121f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Node.getNodeId() != Processed) { 122c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // Since we allow ReplacedValues to map deleted nodes, it may map nodes 123c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // marked NewNode too, since a deleted node may have been reallocated as 124c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // another node that has not been seen by the LegalizeTypes machinery. 125f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if ((Node.getNodeId() == NewNode && Mapped > 1) || 126f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar (Node.getNodeId() != NewNode && Mapped != 0)) { 127bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << "Unprocessed value in a map!"; 12847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Failed = true; 12947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 130f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } else if (isTypeLegal(Res.getValueType()) || IgnoreNodeResults(&Node)) { 1319771b91c2b4ce3baefdb9ba4ddfd9a9dd5077004Duncan Sands if (Mapped > 1) { 132bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << "Value with legal type was transformed!"; 13347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Failed = true; 13447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 13547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } else { 13647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Mapped == 0) { 137bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << "Processed value not in any map!"; 13847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Failed = true; 13947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } else if (Mapped & (Mapped - 1)) { 140bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << "Value in multiple maps!"; 14147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Failed = true; 14247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 14347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 14447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 14547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Failed) { 14647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Mapped & 1) 147bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << " ReplacedValues"; 14847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Mapped & 2) 149bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << " PromotedIntegers"; 15047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Mapped & 4) 151bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << " SoftenedFloats"; 15247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Mapped & 8) 153bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << " ScalarizedVectors"; 15447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Mapped & 16) 155bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << " ExpandedIntegers"; 15647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Mapped & 32) 157bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << " ExpandedFloats"; 15847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Mapped & 64) 159bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << " SplitVectors"; 16087c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang if (Mapped & 128) 161bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << " WidenedVectors"; 162bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << "\n"; 163dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines llvm_unreachable(nullptr); 16447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 16547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 16647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 16747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 16847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Checked that NewNodes are only used by other NewNodes. 16947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands for (unsigned i = 0, e = NewNodes.size(); i != e; ++i) { 17047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands SDNode *N = NewNodes[i]; 17147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands for (SDNode::use_iterator UI = N->use_begin(), UE = N->use_end(); 17247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands UI != UE; ++UI) 17347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(UI->getNodeId() == NewNode && "NewNode used by non-NewNode!"); 17447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 17547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands} 17647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 177de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// This is the main entry point for the type legalizer. This does a top-down 178de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// traversal of the dag, legalizing types as it goes. Returns "true" if it made 179de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// any changes. 18025cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sandsbool DAGTypeLegalizer::run() { 18125cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands bool Changed = false; 18225cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands 18301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Create a dummy node (which is not added to allnodes), that adds a reference 18401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // to the root node, preventing it from being deleted, and tracking any 18501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // changes of the root. 18601d029b82cb08367d81aa10cdc94d05360466649Chris Lattner HandleSDNode Dummy(DAG.getRoot()); 18747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Dummy.setNodeId(Unanalyzed); 18801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 18901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // The root of the dag may dangle to deleted nodes until the type legalizer is 19001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // done. Set it to null to avoid confusion. 191475871a144eb604ddaf37503397ba0941442e5fbDan Gohman DAG.setRoot(SDValue()); 19269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 193b99e740d71b68153284669c42ae9421d0f7e1cc2Duncan Sands // Walk all nodes in the graph, assigning them a NodeId of 'ReadyToProcess' 19447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // (and remembering them) if they are leaves and assigning 'Unanalyzed' if 19501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // non-leaves. 196f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (SDNode &Node : DAG.allnodes()) { 197f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Node.getNumOperands() == 0) { 198f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Node.setNodeId(ReadyToProcess); 199f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Worklist.push_back(&Node); 20001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } else { 201f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Node.setNodeId(Unanalyzed); 20201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 20301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 20469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 20501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Now that we have a set of nodes to process, handle them all. 20601d029b82cb08367d81aa10cdc94d05360466649Chris Lattner while (!Worklist.empty()) { 207de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#ifndef EXPENSIVE_CHECKS 20847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (EnableExpensiveChecks) 20947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands#endif 21047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands PerformExpensiveChecks(); 21147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 21201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner SDNode *N = Worklist.back(); 21301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner Worklist.pop_back(); 21401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner assert(N->getNodeId() == ReadyToProcess && 21501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner "Node should be ready if on worklist!"); 21669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 217d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands if (IgnoreNodeResults(N)) 218d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands goto ScanOperands; 219d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands 22001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Scan the values produced by the node, checking to see if any result 22101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // types are illegal. 222d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands for (unsigned i = 0, NumResults = N->getNumValues(); i < NumResults; ++i) { 223e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT ResultVT = N->getValueType(i); 224077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands switch (getTypeAction(ResultVT)) { 22596e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeLegal: 226077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands break; 22747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // The following calls must take care of *all* of the node's results, 22847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // not just the illegal result they were passed (this includes results 22947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // with a legal type). Results can be remapped using ReplaceValueWith, 23047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // or their promoted/expanded/etc values registered in PromotedIntegers, 23147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // ExpandedIntegers etc. 23296e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypePromoteInteger: 23369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands PromoteIntegerResult(N, i); 23425cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 23501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner goto NodeDone; 23696e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeExpandInteger: 23769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ExpandIntegerResult(N, i); 23825cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 239077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands goto NodeDone; 24096e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeSoftenFloat: 241f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Changed = SoftenFloatResult(N, i); 242f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Changed) 243f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar goto NodeDone; 244f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // If not changed, the result type should be legally in register. 245f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar assert(isLegalInHWReg(ResultVT) && 246f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar "Unchanged SoftenFloatResult should be legal in register!"); 247f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar goto ScanOperands; 24896e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeExpandFloat: 24969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ExpandFloatResult(N, i); 25025cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 251d8742eeb2f7cabc45a1c3736a2780bf87ba684baDuncan Sands goto NodeDone; 25296e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeScalarizeVector: 253f4e4629ee8c218f892ad8ae3e182fe40bc160895Duncan Sands ScalarizeVectorResult(N, i); 25425cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 255077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands goto NodeDone; 25696e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeSplitVector: 257f4e4629ee8c218f892ad8ae3e182fe40bc160895Duncan Sands SplitVectorResult(N, i); 25825cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 25901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner goto NodeDone; 26096e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeWidenVector: 26187c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang WidenVectorResult(N, i); 26287c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang Changed = true; 26387c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang goto NodeDone; 264a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar case TargetLowering::TypePromoteFloat: 265a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar PromoteFloatResult(N, i); 266a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar Changed = true; 267a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar goto NodeDone; 26801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 269d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands } 270077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands 271d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan SandsScanOperands: 27201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Scan the operand list for the node, handling any nodes with operands that 27301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // are illegal. 27401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner { 27501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner unsigned NumOperands = N->getNumOperands(); 27647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands bool NeedsReanalyzing = false; 277d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands unsigned i; 27801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner for (i = 0; i != NumOperands; ++i) { 279ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (IgnoreNodeResults(N->getOperand(i).getNode())) 280d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands continue; 281d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands 282e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OpVT = N->getOperand(i).getValueType(); 283077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands switch (getTypeAction(OpVT)) { 28496e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeLegal: 285077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands continue; 28647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // The following calls must either replace all of the node's results 28747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // using ReplaceValueWith, and return "false"; or update the node's 28847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // operands in place, and return "true". 28996e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypePromoteInteger: 29047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands NeedsReanalyzing = PromoteIntegerOperand(N, i); 29125cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 29269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 29396e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeExpandInteger: 29447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands NeedsReanalyzing = ExpandIntegerOperand(N, i); 29525cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 29601d029b82cb08367d81aa10cdc94d05360466649Chris Lattner break; 29796e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeSoftenFloat: 29847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands NeedsReanalyzing = SoftenFloatOperand(N, i); 29925cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 300077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands break; 30196e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeExpandFloat: 30247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands NeedsReanalyzing = ExpandFloatOperand(N, i); 30325cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 304d8742eeb2f7cabc45a1c3736a2780bf87ba684baDuncan Sands break; 30596e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeScalarizeVector: 30647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands NeedsReanalyzing = ScalarizeVectorOperand(N, i); 30725cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 308077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands break; 30996e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeSplitVector: 31047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands NeedsReanalyzing = SplitVectorOperand(N, i); 31125cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands Changed = true; 31201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner break; 31396e0c5477c41b316263e894bbb5821c7cdeb25efNadav Rotem case TargetLowering::TypeWidenVector: 31487c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang NeedsReanalyzing = WidenVectorOperand(N, i); 31587c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang Changed = true; 31687c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang break; 317a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar case TargetLowering::TypePromoteFloat: 318a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar NeedsReanalyzing = PromoteFloatOperand(N, i); 319a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar Changed = true; 320a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar break; 32101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 322077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands break; 32301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 32401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 32547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // The sub-method updated N in place. Check to see if any operands are new, 32647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // and if so, mark them. If the node needs revisiting, don't add all users 32747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // to the worklist etc. 32847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (NeedsReanalyzing) { 32947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(N->getNodeId() == ReadyToProcess && "Node ID recalculated?"); 33047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands N->setNodeId(NewNode); 33147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Recompute the NodeId and correct processed operands, adding the node to 33247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // the worklist if ready. 33347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands SDNode *M = AnalyzeNewNode(N); 33447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (M == N) 33547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // The node didn't morph - nothing special to do, it will be revisited. 33647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands continue; 33747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 33847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // The node morphed - this is equivalent to legalizing by replacing every 339c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // value of N with the corresponding value of M. So do that now. 34047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(N->getNumValues() == M->getNumValues() && 34147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands "Node morphing changed the number of results!"); 34247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands for (unsigned i = 0, e = N->getNumValues(); i != e; ++i) 343c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands // Replacing the value takes care of remapping the new value. 344c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands ReplaceValueWith(SDValue(N, i), SDValue(M, i)); 3455bb11b89ddbc0f47eee9743b93df5aa872750d13Duncan Sands assert(N->getNodeId() == NewNode && "Unexpected node state!"); 3465bb11b89ddbc0f47eee9743b93df5aa872750d13Duncan Sands // The node continues to live on as part of the NewNode fungus that 3475bb11b89ddbc0f47eee9743b93df5aa872750d13Duncan Sands // grows on top of the useful nodes. Nothing more needs to be done 3485bb11b89ddbc0f47eee9743b93df5aa872750d13Duncan Sands // with it - move on to the next node. 3495bb11b89ddbc0f47eee9743b93df5aa872750d13Duncan Sands continue; 35047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 35169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 3527a30bc4e7c034ecd0a3bcbfb385ac2a129e6583cDan Gohman if (i == NumOperands) { 353bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene DEBUG(dbgs() << "Legally typed node: "; N->dump(&DAG); dbgs() << "\n"); 35401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 3557a30bc4e7c034ecd0a3bcbfb385ac2a129e6583cDan Gohman } 35601d029b82cb08367d81aa10cdc94d05360466649Chris LattnerNodeDone: 35701d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 35801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // If we reach here, the node was processed, potentially creating new nodes. 35901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Mark it as processed and add its users to the worklist as appropriate. 36047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(N->getNodeId() == ReadyToProcess && "Node ID recalculated?"); 36101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner N->setNodeId(Processed); 36269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 36301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end(); 36401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner UI != E; ++UI) { 3658968450305c28444edc3c272d8752a8db0c2f34aDan Gohman SDNode *User = *UI; 366b99e740d71b68153284669c42ae9421d0f7e1cc2Duncan Sands int NodeId = User->getNodeId(); 36769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 36801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // This node has two options: it can either be a new node or its Node ID 36901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // may be a count of the number of operands it has that are not ready. 370b99e740d71b68153284669c42ae9421d0f7e1cc2Duncan Sands if (NodeId > 0) { 371b99e740d71b68153284669c42ae9421d0f7e1cc2Duncan Sands User->setNodeId(NodeId-1); 37269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 37301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // If this was the last use it was waiting on, add it to the ready list. 374b99e740d71b68153284669c42ae9421d0f7e1cc2Duncan Sands if (NodeId-1 == ReadyToProcess) 37501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner Worklist.push_back(User); 37601d029b82cb08367d81aa10cdc94d05360466649Chris Lattner continue; 37701d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 37869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 37947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // If this is an unreachable new node, then ignore it. If it ever becomes 38047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // reachable by being used by a newly created node then it will be handled 38147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // by AnalyzeNewNode. 38247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (NodeId == NewNode) 38347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands continue; 38447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 38501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Otherwise, this node is new: this is the first operand of it that 386b99e740d71b68153284669c42ae9421d0f7e1cc2Duncan Sands // became ready. Its new NodeId is the number of operands it has minus 1 38701d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // (as this node is now processed). 38847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(NodeId == Unanalyzed && "Unknown node ID!"); 38947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands User->setNodeId(User->getNumOperands() - 1); 39069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 39101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // If the node only has a single operand, it is now ready. 39201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner if (User->getNumOperands() == 1) 39301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner Worklist.push_back(User); 39401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 39501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 39669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 397de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#ifndef EXPENSIVE_CHECKS 39847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (EnableExpensiveChecks) 39947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands#endif 40047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands PerformExpensiveChecks(); 40101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 40247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // If the root changed (e.g. it was a dead load) update the root. 40347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands DAG.setRoot(Dummy.getValue()); 40401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 40501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Remove dead nodes. This is important to do for cleanliness but also before 40647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // the checking loop below. Implicit folding by the DAG.getNode operators and 40747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // node morphing can cause unreachable nodes to be around with their flags set 40847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // to new. 40901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner DAG.RemoveDeadNodes(); 41001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 41101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // In a debug build, scan all the nodes to make sure we found them all. This 41201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // ensures that there are no cycles and that everything got processed. 41301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner#ifndef NDEBUG 414f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (SDNode &Node : DAG.allnodes()) { 4151a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands bool Failed = false; 4161a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands 4171a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands // Check that all result types are legal. 418f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // A value type is illegal if its TypeAction is not TypeLegal, 419f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // and TLI.RegClassForVT does not have a register class for this type. 420f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // For example, the x86_64 target has f128 that is not TypeLegal, 421f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // to have softened operators, but it also has FR128 register class to 422f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // pass and return f128 values. Hence a legalized node can have f128 type. 423f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (!IgnoreNodeResults(&Node)) 424f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned i = 0, NumVals = Node.getNumValues(); i < NumVals; ++i) 425f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (!isTypeLegal(Node.getValueType(i)) && 426f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar !TLI.isTypeLegal(Node.getValueType(i))) { 427f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar dbgs() << "Result type " << i << " illegal: "; 428f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Node.dump(); 429d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands Failed = true; 430d164ea2fb07ab3540121ffe1c59ad2cdc0a7a0a3Duncan Sands } 4311a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands 4321a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands // Check that all operand types are legal. 433f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (unsigned i = 0, NumOps = Node.getNumOperands(); i < NumOps; ++i) 434f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (!IgnoreNodeResults(Node.getOperand(i).getNode()) && 435f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar !isTypeLegal(Node.getOperand(i).getValueType()) && 436f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar !TLI.isTypeLegal(Node.getOperand(i).getValueType())) { 437f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar dbgs() << "Operand type " << i << " illegal: "; 438f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Node.getOperand(i).dump(); 4391a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands Failed = true; 4401a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands } 4411a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands 442f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Node.getNodeId() != Processed) { 443f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Node.getNodeId() == NewNode) 444bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << "New node not analyzed?\n"; 445f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar else if (Node.getNodeId() == Unanalyzed) 446bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << "Unanalyzed node not noticed?\n"; 447f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar else if (Node.getNodeId() > 0) 448bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << "Operand not processed?\n"; 449f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar else if (Node.getNodeId() == ReadyToProcess) 450bb22223d5b4eb27d238bcc1b67b033975c43db7bDavid Greene dbgs() << "Not added to worklist?\n"; 4511a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands Failed = true; 4521a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands } 4531a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands 4541a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands if (Failed) { 455f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Node.dump(&DAG); dbgs() << "\n"; 456dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines llvm_unreachable(nullptr); 4571a9c9df1db4ab3bf39f0395a7086576b4491d50bDuncan Sands } 45801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 45901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner#endif 46025cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands 46125cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands return Changed; 46201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner} 46301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 464de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// The specified node is the root of a subtree of potentially new nodes. 465de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Correct any processed operands (this may change the node) and calculate the 466de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// NodeId. If the node itself changes to a processed node, it is not remapped - 467de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// the caller needs to take care of this. Returns the potentially changed node. 46823b10f5b64e594aa7c6b415805b563fed2a75874Duncan SandsSDNode *DAGTypeLegalizer::AnalyzeNewNode(SDNode *N) { 46901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // If this was an existing node that is already done, we're done. 47047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (N->getNodeId() != NewNode && N->getNodeId() != Unanalyzed) 47123b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands return N; 47201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 4733a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands // Remove any stale map entries. 4743a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands ExpungeNode(N); 4753a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands 47601d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Okay, we know that this node is new. Recursively walk all of its operands 47701d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // to see if they are new also. The depth of this walk is bounded by the size 47801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // of the new tree that was constructed (usually 2-3 nodes), so we don't worry 479cfc24007b13564c6720571a2e809cf84fda67737Chris Lattner // about revisiting of nodes. 48001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // 48101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // As we walk the operands, keep track of the number of nodes that are 48201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // processed. If non-zero, this will become the new nodeid of this node. 48347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Operands may morph when they are analyzed. If so, the node will be 48447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // updated after all operands have been analyzed. Since this is rare, 48547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // the code tries to minimize overhead in the non-morphing case. 486212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands 487475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> NewOps; 48801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner unsigned NumProcessed = 0; 48901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) { 490475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue OrigOp = N->getOperand(i); 491475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op = OrigOp; 492212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands 49347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands AnalyzeNewValue(Op); // Op may morph. 4941acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands 4951acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands if (Op.getNode()->getNodeId() == Processed) 49601d029b82cb08367d81aa10cdc94d05360466649Chris Lattner ++NumProcessed; 497212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands 498212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands if (!NewOps.empty()) { 499212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands // Some previous operand changed. Add this one to the list. 500212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands NewOps.push_back(Op); 501212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands } else if (Op != OrigOp) { 502212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands // This is the first operand to change - add all operands so far. 503403a8cdda5e76ea689693de16474650b4b0df818Dan Gohman NewOps.append(N->op_begin(), N->op_begin() + i); 504212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands NewOps.push_back(Op); 505212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands } 50601d029b82cb08367d81aa10cdc94d05360466649Chris Lattner } 507212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands 508212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands // Some operands changed - update the node. 5091acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands if (!NewOps.empty()) { 510dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDNode *M = DAG.UpdateNodeOperands(N, NewOps); 51123b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands if (M != N) { 51247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // The node morphed into a different node. Normally for this to happen 51347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // the original node would have to be marked NewNode. However this can 51447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // in theory momentarily not be the case while ReplaceValueWith is doing 51547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // its stuff. Mark the original node NewNode to help sanity checking. 51647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands N->setNodeId(NewNode); 51747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (M->getNodeId() != NewNode && M->getNodeId() != Unanalyzed) 51823b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands // It morphed into a previously analyzed node - nothing more to do. 51923b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands return M; 52020f04e9fdd437712b323661e5041fd88431185b3Duncan Sands 5211acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands // It morphed into a different new node. Do the equivalent of passing 52247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // it to AnalyzeNewNode: expunge it and calculate the NodeId. No need 52347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // to remap the operands, since they are the same as the operands we 52447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // remapped above. 52523b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands N = M; 5261acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands ExpungeNode(N); 5271acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands } 5281acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands } 52901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 5301acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands // Calculate the NodeId. 53147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands N->setNodeId(N->getNumOperands() - NumProcessed); 5321acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands if (N->getNodeId() == ReadyToProcess) 5331acb29c8ead8b7a6ac5dd63720711d397ac25ad9Duncan Sands Worklist.push_back(N); 53423b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands 53523b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands return N; 53623b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands} 53723b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands 538de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Call AnalyzeNewNode, updating the node in Val if needed. 53923b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands/// If the node changes to a processed node, then remap it. 54023b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sandsvoid DAGTypeLegalizer::AnalyzeNewValue(SDValue &Val) { 54147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands Val.setNode(AnalyzeNewNode(Val.getNode())); 54247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (Val.getNode()->getNodeId() == Processed) 54347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // We were passed a processed node, or it morphed into one - remap it. 54423b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(Val); 545ed63214fcbebcaf989dbc6a5bf7c3b6df67732f5Gabor Greif} 546ed63214fcbebcaf989dbc6a5bf7c3b6df67732f5Gabor Greif 547de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If N has a bogus mapping in ReplacedValues, eliminate it. 5483a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands/// This can occur when a node is deleted then reallocated as a new node - 54923b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands/// the mapping in ReplacedValues applies to the deleted node, not the new 5503a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands/// one. 55123b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands/// The only map that can have a deleted node as a source is ReplacedValues. 5523a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands/// Other maps can have deleted nodes as targets, but since their looked-up 55323b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands/// values are always immediately remapped using RemapValue, resulting in a 55423b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands/// not-deleted node, this is harmless as long as ReplacedValues/RemapValue 5553a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands/// always performs correct mappings. In order to keep the mapping correct, 5563a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands/// ExpungeNode should be called on any new nodes *before* adding them as 55723b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands/// either source or target to ReplacedValues (which typically means calling 5583a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands/// Expunge when a new node is first seen, since it may no longer be marked 55923b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands/// NewNode by the time it is added to ReplacedValues). 5603a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sandsvoid DAGTypeLegalizer::ExpungeNode(SDNode *N) { 5613a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands if (N->getNodeId() != NewNode) 5626f7e1cddf63f91af84996d59cdb5809088ac3fe3Duncan Sands return; 5636f7e1cddf63f91af84996d59cdb5809088ac3fe3Duncan Sands 56423b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands // If N is not remapped by ReplacedValues then there is nothing to do. 5653a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands unsigned i, e; 5663a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands for (i = 0, e = N->getNumValues(); i != e; ++i) 56723b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands if (ReplacedValues.find(SDValue(N, i)) != ReplacedValues.end()) 5683a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands break; 569edfcf598faab9ce294712551ecf67093acd1c66eDuncan Sands 5703a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands if (i == e) 5713a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands return; 572edfcf598faab9ce294712551ecf67093acd1c66eDuncan Sands 5733a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands // Remove N from all maps - this is expensive but rare. 574edfcf598faab9ce294712551ecf67093acd1c66eDuncan Sands 575475871a144eb604ddaf37503397ba0941442e5fbDan Gohman for (DenseMap<SDValue, SDValue>::iterator I = PromotedIntegers.begin(), 5763a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands E = PromotedIntegers.end(); I != E; ++I) { 577ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(I->first.getNode() != N); 57823b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second); 5793a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands } 580edfcf598faab9ce294712551ecf67093acd1c66eDuncan Sands 581475871a144eb604ddaf37503397ba0941442e5fbDan Gohman for (DenseMap<SDValue, SDValue>::iterator I = SoftenedFloats.begin(), 5823a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands E = SoftenedFloats.end(); I != E; ++I) { 583ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(I->first.getNode() != N); 58423b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second); 5853a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands } 586edfcf598faab9ce294712551ecf67093acd1c66eDuncan Sands 587475871a144eb604ddaf37503397ba0941442e5fbDan Gohman for (DenseMap<SDValue, SDValue>::iterator I = ScalarizedVectors.begin(), 5883a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands E = ScalarizedVectors.end(); I != E; ++I) { 589ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(I->first.getNode() != N); 59023b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second); 5913a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands } 59269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 5931bec3dd28a47b7e27e6f30de22a307521ce45b28Duncan Sands for (DenseMap<SDValue, SDValue>::iterator I = WidenedVectors.begin(), 5941bec3dd28a47b7e27e6f30de22a307521ce45b28Duncan Sands E = WidenedVectors.end(); I != E; ++I) { 5951bec3dd28a47b7e27e6f30de22a307521ce45b28Duncan Sands assert(I->first.getNode() != N); 5961bec3dd28a47b7e27e6f30de22a307521ce45b28Duncan Sands RemapValue(I->second); 5971bec3dd28a47b7e27e6f30de22a307521ce45b28Duncan Sands } 5981bec3dd28a47b7e27e6f30de22a307521ce45b28Duncan Sands 599475871a144eb604ddaf37503397ba0941442e5fbDan Gohman for (DenseMap<SDValue, std::pair<SDValue, SDValue> >::iterator 6003a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands I = ExpandedIntegers.begin(), E = ExpandedIntegers.end(); I != E; ++I){ 601ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(I->first.getNode() != N); 60223b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second.first); 60323b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second.second); 6043a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands } 605edfcf598faab9ce294712551ecf67093acd1c66eDuncan Sands 606475871a144eb604ddaf37503397ba0941442e5fbDan Gohman for (DenseMap<SDValue, std::pair<SDValue, SDValue> >::iterator 6073a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands I = ExpandedFloats.begin(), E = ExpandedFloats.end(); I != E; ++I) { 608ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(I->first.getNode() != N); 60923b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second.first); 61023b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second.second); 6113a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands } 6123a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands 613475871a144eb604ddaf37503397ba0941442e5fbDan Gohman for (DenseMap<SDValue, std::pair<SDValue, SDValue> >::iterator 6143a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands I = SplitVectors.begin(), E = SplitVectors.end(); I != E; ++I) { 615ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(I->first.getNode() != N); 61623b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second.first); 61723b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second.second); 618edfcf598faab9ce294712551ecf67093acd1c66eDuncan Sands } 6193a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands 62023b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands for (DenseMap<SDValue, SDValue>::iterator I = ReplacedValues.begin(), 62123b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands E = ReplacedValues.end(); I != E; ++I) 62223b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(I->second); 6233a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands 6243a38e5e3c465c10fe5f859114f9077cb00cc17b9Duncan Sands for (unsigned i = 0, e = N->getNumValues(); i != e; ++i) 62523b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands ReplacedValues.erase(SDValue(N, i)); 626edfcf598faab9ce294712551ecf67093acd1c66eDuncan Sands} 627edfcf598faab9ce294712551ecf67093acd1c66eDuncan Sands 628de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If the specified value was already legalized to another value, 62947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands/// replace it by that value. 63047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sandsvoid DAGTypeLegalizer::RemapValue(SDValue &N) { 63147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands DenseMap<SDValue, SDValue>::iterator I = ReplacedValues.find(N); 63247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (I != ReplacedValues.end()) { 63347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Use path compression to speed up future lookups if values get multiply 63447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // replaced with other values. 63547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands RemapValue(I->second); 63647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands N = I->second; 637d1654a769c06d20595398565de055b5ab3ede1f9Hal Finkel 638d1654a769c06d20595398565de055b5ab3ede1f9Hal Finkel // Note that it is possible to have N.getNode()->getNodeId() == NewNode at 639d1654a769c06d20595398565de055b5ab3ede1f9Hal Finkel // this point because it is possible for a node to be put in the map before 640d1654a769c06d20595398565de055b5ab3ede1f9Hal Finkel // being processed. 64147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 64247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands} 64347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 64447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sandsnamespace { 645de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar /// This class is a DAGUpdateListener that listens for updates to nodes and 646de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar /// recomputes their ready state. 6476726b6d75a8b679068a58cb954ba97cf9d1690baNick Lewycky class NodeUpdateListener : public SelectionDAG::DAGUpdateListener { 64847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands DAGTypeLegalizer &DTL; 6492ecf88d1751c847b87a7119bf34fff85a3d272e2Duncan Sands SmallSetVector<SDNode*, 16> &NodesToAnalyze; 65047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands public: 65147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands explicit NodeUpdateListener(DAGTypeLegalizer &dtl, 6522ecf88d1751c847b87a7119bf34fff85a3d272e2Duncan Sands SmallSetVector<SDNode*, 16> &nta) 653bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen : SelectionDAG::DAGUpdateListener(dtl.getDAG()), 654bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DTL(dtl), NodesToAnalyze(nta) {} 65547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 65636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void NodeDeleted(SDNode *N, SDNode *E) override { 65747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(N->getNodeId() != DAGTypeLegalizer::ReadyToProcess && 65847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands N->getNodeId() != DAGTypeLegalizer::Processed && 65947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands "Invalid node ID for RAUW deletion!"); 66047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // It is possible, though rare, for the deleted node N to occur as a 66147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // target in a map, so note the replacement N -> E in ReplacedValues. 66247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(E && "Node not replaced?"); 66347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands DTL.NoteDeletion(N, E); 66447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 66547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // In theory the deleted node could also have been scheduled for analysis. 66695c5f05641e0afdfcbeb430090e1cd0356dddfbcDuncan Sands // So remove it from the set of nodes which will be analyzed. 6672ecf88d1751c847b87a7119bf34fff85a3d272e2Duncan Sands NodesToAnalyze.remove(N); 66847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 66947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // In general nothing needs to be done for E, since it didn't change but 67047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // only gained new uses. However N -> E was just added to ReplacedValues, 67147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // and the result of a ReplacedValues mapping is not allowed to be marked 67247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // NewNode. So if E is marked NewNode, then it needs to be analyzed. 67347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (E->getNodeId() == DAGTypeLegalizer::NewNode) 6742ecf88d1751c847b87a7119bf34fff85a3d272e2Duncan Sands NodesToAnalyze.insert(E); 67547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 67647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 67736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void NodeUpdated(SDNode *N) override { 67847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Node updates can mean pretty much anything. It is possible that an 67947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // operand was set to something already processed (f.e.) in which case 68047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // this node could become ready. Recompute its flags. 68147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(N->getNodeId() != DAGTypeLegalizer::ReadyToProcess && 68247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands N->getNodeId() != DAGTypeLegalizer::Processed && 68347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands "Invalid node ID for RAUW deletion!"); 68495c5f05641e0afdfcbeb430090e1cd0356dddfbcDuncan Sands N->setNodeId(DAGTypeLegalizer::NewNode); 6852ecf88d1751c847b87a7119bf34fff85a3d272e2Duncan Sands NodesToAnalyze.insert(N); 68647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 68747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands }; 68847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands} 68947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 69047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 691de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// The specified value was legalized to the specified other value. 692de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Update the DAG and NodeIds replacing any uses of From to use To instead. 693c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sandsvoid DAGTypeLegalizer::ReplaceValueWith(SDValue From, SDValue To) { 69447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(From.getNode() != To.getNode() && "Potential legalization loop!"); 69547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 69647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // If expansion produced new nodes, make sure they are properly marked. 697c088ae8b84bfcdefb57efafb022430312bddf638Duncan Sands ExpungeNode(From.getNode()); 69847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands AnalyzeNewValue(To); // Expunges To. 69947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 70047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Anything that used the old node should now use the new one. Note that this 70147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // can potentially cause recursive merging. 7022ecf88d1751c847b87a7119bf34fff85a3d272e2Duncan Sands SmallSetVector<SDNode*, 16> NodesToAnalyze; 7032ecf88d1751c847b87a7119bf34fff85a3d272e2Duncan Sands NodeUpdateListener NUL(*this, NodesToAnalyze); 704f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang do { 705bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAG.ReplaceAllUsesOfValueWith(From, To); 706f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang 707f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // The old node may still be present in a map like ExpandedIntegers or 708f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // PromotedIntegers. Inform maps about the replacement. 709f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang ReplacedValues[From] = To; 710f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang 711f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // Process the list of nodes that need to be reanalyzed. 712f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang while (!NodesToAnalyze.empty()) { 713f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang SDNode *N = NodesToAnalyze.back(); 714f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang NodesToAnalyze.pop_back(); 715f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang if (N->getNodeId() != DAGTypeLegalizer::NewNode) 716f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // The node was analyzed while reanalyzing an earlier node - it is safe 717f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // to skip. Note that this is not a morphing node - otherwise it would 718f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // still be marked NewNode. 719f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang continue; 72047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 721f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // Analyze the node's operands and recalculate the node ID. 722f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang SDNode *M = AnalyzeNewNode(N); 723f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang if (M != N) { 724f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // The node morphed into a different node. Make everyone use the new 725f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // node instead. 726f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang assert(M->getNodeId() != NewNode && "Analysis resulted in NewNode!"); 727f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang assert(N->getNumValues() == M->getNumValues() && 728f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang "Node morphing changed the number of results!"); 729f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang for (unsigned i = 0, e = N->getNumValues(); i != e; ++i) { 730f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang SDValue OldVal(N, i); 731f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang SDValue NewVal(M, i); 732f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang if (M->getNodeId() == Processed) 733f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang RemapValue(NewVal); 734bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAG.ReplaceAllUsesOfValueWith(OldVal, NewVal); 735d9aa80038f630d72883ebe5b524e372a44e6695cDuncan Sands // OldVal may be a target of the ReplacedValues map which was marked 736d9aa80038f630d72883ebe5b524e372a44e6695cDuncan Sands // NewNode to force reanalysis because it was updated. Ensure that 737d9aa80038f630d72883ebe5b524e372a44e6695cDuncan Sands // anything that ReplacedValues mapped to OldVal will now be mapped 738d9aa80038f630d72883ebe5b524e372a44e6695cDuncan Sands // all the way to NewVal. 739d9aa80038f630d72883ebe5b524e372a44e6695cDuncan Sands ReplacedValues[OldVal] = NewVal; 740f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang } 741f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // The original node continues to exist in the DAG, marked NewNode. 74247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 74347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands } 744f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // When recursively update nodes with new nodes, it is possible to have 745f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // new uses of From due to CSE. If this happens, replace the new uses of 746f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang // From with To. 747f62546ab046d4bc2f055921f25f127fbb942b806Mon P Wang } while (!From.use_empty()); 74847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands} 74947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 750475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::SetPromotedInteger(SDValue Op, SDValue Result) { 75122d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng assert(Result.getValueType() == 75222d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng TLI.getTypeToTransformTo(*DAG.getContext(), Op.getValueType()) && 753f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands "Invalid type for promoted integer"); 75423b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands AnalyzeNewValue(Result); 75501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 756475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &OpEntry = PromotedIntegers[Op]; 757dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(!OpEntry.getNode() && "Node is already promoted!"); 75801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner OpEntry = Result; 75901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner} 76001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 761475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::SetSoftenedFloat(SDValue Op, SDValue Result) { 762f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // f128 of x86_64 could be kept in SSE registers, 763f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // but sometimes softened to i128. 764f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar assert((Result.getValueType() == 765f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar TLI.getTypeToTransformTo(*DAG.getContext(), Op.getValueType()) || 766f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Op.getValueType() == 767f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar TLI.getTypeToTransformTo(*DAG.getContext(), Op.getValueType())) && 768f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands "Invalid type for softened float"); 76923b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands AnalyzeNewValue(Result); 770d8742eeb2f7cabc45a1c3736a2780bf87ba684baDuncan Sands 771475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &OpEntry = SoftenedFloats[Op]; 772f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // Allow repeated calls to save f128 type nodes 773f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // or any node with type that transforms to itself. 774f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // Many operations on these types are not softened. 775f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar assert((!OpEntry.getNode()|| 776f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Op.getValueType() == 777f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar TLI.getTypeToTransformTo(*DAG.getContext(), Op.getValueType())) && 778f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar "Node is already converted to integer!"); 779d8742eeb2f7cabc45a1c3736a2780bf87ba684baDuncan Sands OpEntry = Result; 780d8742eeb2f7cabc45a1c3736a2780bf87ba684baDuncan Sands} 781d8742eeb2f7cabc45a1c3736a2780bf87ba684baDuncan Sands 782a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainarvoid DAGTypeLegalizer::SetPromotedFloat(SDValue Op, SDValue Result) { 783a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar assert(Result.getValueType() == 784a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar TLI.getTypeToTransformTo(*DAG.getContext(), Op.getValueType()) && 785a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar "Invalid type for promoted float"); 786a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar AnalyzeNewValue(Result); 787a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar 788a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar SDValue &OpEntry = PromotedFloats[Op]; 789a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar assert(!OpEntry.getNode() && "Node is already promoted!"); 790a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar OpEntry = Result; 791a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar} 792a18e6af1712fd41c4a705a19ad71f6e9ac7a4e68Pirama Arumuga Nainar 793475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::SetScalarizedVector(SDValue Op, SDValue Result) { 7948b7c3d0ee42938a9e6ca37239cc327bd9f4c0cd0Nadav Rotem // Note that in some cases vector operation operands may be greater than 7958b7c3d0ee42938a9e6ca37239cc327bd9f4c0cd0Nadav Rotem // the vector element type. For example BUILD_VECTOR of type <1 x i1> with 7968b7c3d0ee42938a9e6ca37239cc327bd9f4c0cd0Nadav Rotem // a constant i8 operand. 7978b7c3d0ee42938a9e6ca37239cc327bd9f4c0cd0Nadav Rotem assert(Result.getValueType().getSizeInBits() >= 7988b7c3d0ee42938a9e6ca37239cc327bd9f4c0cd0Nadav Rotem Op.getValueType().getVectorElementType().getSizeInBits() && 799f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands "Invalid type for scalarized vector"); 80023b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands AnalyzeNewValue(Result); 801212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands 802475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &OpEntry = ScalarizedVectors[Op]; 803dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(!OpEntry.getNode() && "Node is already scalarized!"); 80413c207b5c84cbac78147fa4472a4e14232cb6febChris Lattner OpEntry = Result; 80513c207b5c84cbac78147fa4472a4e14232cb6febChris Lattner} 80613c207b5c84cbac78147fa4472a4e14232cb6febChris Lattner 807475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::GetExpandedInteger(SDValue Op, SDValue &Lo, 808475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 809475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::pair<SDValue, SDValue> &Entry = ExpandedIntegers[Op]; 81023b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(Entry.first); 81123b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(Entry.second); 812ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(Entry.first.getNode() && "Operand isn't expanded"); 81369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Lo = Entry.first; 81469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Hi = Entry.second; 81569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 81669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 817475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::SetExpandedInteger(SDValue Op, SDValue Lo, 818475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Hi) { 81922d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng assert(Lo.getValueType() == 82022d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng TLI.getTypeToTransformTo(*DAG.getContext(), Op.getValueType()) && 821f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands Hi.getValueType() == Lo.getValueType() && 822f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands "Invalid type for expanded integer"); 82369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Lo/Hi may have been newly allocated, if so, add nodeid's as relevant. 82423b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands AnalyzeNewValue(Lo); 82523b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands AnalyzeNewValue(Hi); 82669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 82769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Remember that this is the result of the node. 828475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::pair<SDValue, SDValue> &Entry = ExpandedIntegers[Op]; 829dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(!Entry.first.getNode() && "Node already expanded"); 83069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Entry.first = Lo; 83169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Entry.second = Hi; 83269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 83369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 834475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::GetExpandedFloat(SDValue Op, SDValue &Lo, 835475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 836475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::pair<SDValue, SDValue> &Entry = ExpandedFloats[Op]; 83723b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(Entry.first); 83823b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(Entry.second); 839ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(Entry.first.getNode() && "Operand isn't expanded"); 84001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner Lo = Entry.first; 84101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner Hi = Entry.second; 84201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner} 84301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 844475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::SetExpandedFloat(SDValue Op, SDValue Lo, 845475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Hi) { 84622d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng assert(Lo.getValueType() == 84722d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng TLI.getTypeToTransformTo(*DAG.getContext(), Op.getValueType()) && 848f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands Hi.getValueType() == Lo.getValueType() && 849f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands "Invalid type for expanded float"); 850212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands // Lo/Hi may have been newly allocated, if so, add nodeid's as relevant. 85123b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands AnalyzeNewValue(Lo); 85223b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands AnalyzeNewValue(Hi); 853212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands 85401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Remember that this is the result of the node. 855475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::pair<SDValue, SDValue> &Entry = ExpandedFloats[Op]; 856dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(!Entry.first.getNode() && "Node already expanded"); 85701d029b82cb08367d81aa10cdc94d05360466649Chris Lattner Entry.first = Lo; 85801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner Entry.second = Hi; 85901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner} 86001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 861475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::GetSplitVector(SDValue Op, SDValue &Lo, 862475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 863475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::pair<SDValue, SDValue> &Entry = SplitVectors[Op]; 86423b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(Entry.first); 86523b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands RemapValue(Entry.second); 866ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(Entry.first.getNode() && "Operand isn't split"); 867e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner Lo = Entry.first; 868e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner Hi = Entry.second; 869e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner} 870e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner 871475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::SetSplitVector(SDValue Op, SDValue Lo, 872475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Hi) { 873f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands assert(Lo.getValueType().getVectorElementType() == 874f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands Op.getValueType().getVectorElementType() && 875f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands 2*Lo.getValueType().getVectorNumElements() == 876f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands Op.getValueType().getVectorNumElements() && 877f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands Hi.getValueType() == Lo.getValueType() && 878f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands "Invalid type for split vector"); 879212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands // Lo/Hi may have been newly allocated, if so, add nodeid's as relevant. 88023b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands AnalyzeNewValue(Lo); 88123b10f5b64e594aa7c6b415805b563fed2a75874Duncan Sands AnalyzeNewValue(Hi); 882212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands 883e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner // Remember that this is the result of the node. 884475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::pair<SDValue, SDValue> &Entry = SplitVectors[Op]; 885dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(!Entry.first.getNode() && "Node already split"); 886e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner Entry.first = Lo; 887e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner Entry.second = Hi; 888e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner} 889e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner 89087c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wangvoid DAGTypeLegalizer::SetWidenedVector(SDValue Op, SDValue Result) { 89122d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng assert(Result.getValueType() == 89222d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng TLI.getTypeToTransformTo(*DAG.getContext(), Op.getValueType()) && 893f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands "Invalid type for widened vector"); 89487c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang AnalyzeNewValue(Result); 89587c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang 89687c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang SDValue &OpEntry = WidenedVectors[Op]; 897dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(!OpEntry.getNode() && "Node already widened!"); 89887c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang OpEntry = Result; 89987c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang} 90087c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang 901e4af7b5a573593dcf2a37cd4590bf76d1322d6daChris Lattner 90278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===----------------------------------------------------------------------===// 90378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Utilities. 90478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===----------------------------------------------------------------------===// 90578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 906de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Convert to an integer of the same size. 907475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue DAGTypeLegalizer::BitConvertToInteger(SDValue Op) { 90883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned BitWidth = Op.getValueType().getSizeInBits(); 909ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick return DAG.getNode(ISD::BITCAST, SDLoc(Op), 91023b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT::getIntegerVT(*DAG.getContext(), BitWidth), Op); 911d8742eeb2f7cabc45a1c3736a2780bf87ba684baDuncan Sands} 912d8742eeb2f7cabc45a1c3736a2780bf87ba684baDuncan Sands 913de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Convert to a vector of integers of the same size. 914004e27cc1bba070f013589cc8e434b03589c3c22Duncan SandsSDValue DAGTypeLegalizer::BitConvertVectorToIntegerVector(SDValue Op) { 915004e27cc1bba070f013589cc8e434b03589c3c22Duncan Sands assert(Op.getValueType().isVector() && "Only applies to vectors!"); 916004e27cc1bba070f013589cc8e434b03589c3c22Duncan Sands unsigned EltWidth = Op.getValueType().getVectorElementType().getSizeInBits(); 91723b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT EltNVT = EVT::getIntegerVT(*DAG.getContext(), EltWidth); 918004e27cc1bba070f013589cc8e434b03589c3c22Duncan Sands unsigned NumElts = Op.getValueType().getVectorNumElements(); 919ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick return DAG.getNode(ISD::BITCAST, SDLoc(Op), 92023b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT::getVectorVT(*DAG.getContext(), EltNVT, NumElts), Op); 921004e27cc1bba070f013589cc8e434b03589c3c22Duncan Sands} 922004e27cc1bba070f013589cc8e434b03589c3c22Duncan Sands 923475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue DAGTypeLegalizer::CreateStackStoreLoad(SDValue Op, 924e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DestVT) { 925e4fae84b0b13bd5d66cf619fd2108dbb6064395dBenjamin Kramer SDLoc dl(Op); 926c5ffb45934a5f6c19b6279a42622f1b4d9e7ec88Duncan Sands // Create the stack frame object. Make sure it is aligned for both 927c5ffb45934a5f6c19b6279a42622f1b4d9e7ec88Duncan Sands // the source and destination types. 92847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands SDValue StackPtr = DAG.CreateStackTemporary(Op.getValueType(), DestVT); 929c224a53d7aa077d36f1495b242d7c8e4f324754dChris Lattner // Emit a store to the stack slot. 930ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op, StackPtr, 931ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner MachinePointerInfo(), false, false, 0); 932c224a53d7aa077d36f1495b242d7c8e4f324754dChris Lattner // Result is a load from the stack slot. 933ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner return DAG.getLoad(DestVT, dl, Store, StackPtr, MachinePointerInfo(), 934d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 935c224a53d7aa077d36f1495b242d7c8e4f324754dChris Lattner} 936c224a53d7aa077d36f1495b242d7c8e4f324754dChris Lattner 937de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Replace the node's results with custom code provided by the target and 938de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// return "true", or do nothing and return "false". 9399fbc7e2e7a765298fb4326885b407e0962f7ab62Duncan Sands/// The last parameter is FALSE if we are dealing with a node with legal 940b169426272b85ce28a9a56d13154e61b158fc47aSanjiv Gupta/// result types and illegal operand. The second parameter denotes the type of 941b169426272b85ce28a9a56d13154e61b158fc47aSanjiv Gupta/// illegal OperandNo in that case. 942bb326bbe88d0b243d5d9d224308eb0c028d4d4afSanjiv Gupta/// The last parameter being TRUE means we are dealing with a 943b169426272b85ce28a9a56d13154e61b158fc47aSanjiv Gupta/// node with illegal result types. The second parameter denotes the type of 944b169426272b85ce28a9a56d13154e61b158fc47aSanjiv Gupta/// illegal ResNo in that case. 945e50ed30282bb5b4a9ed952580523f2dda16215acOwen Andersonbool DAGTypeLegalizer::CustomLowerNode(SDNode *N, EVT VT, bool LegalizeResult) { 9461607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands // See if the target wants to custom lower this node. 9479fbc7e2e7a765298fb4326885b407e0962f7ab62Duncan Sands if (TLI.getOperationAction(N->getOpcode(), VT) != TargetLowering::Custom) 9481607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands return false; 9491607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands 9501607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands SmallVector<SDValue, 8> Results; 951bb326bbe88d0b243d5d9d224308eb0c028d4d4afSanjiv Gupta if (LegalizeResult) 952bb326bbe88d0b243d5d9d224308eb0c028d4d4afSanjiv Gupta TLI.ReplaceNodeResults(N, Results, DAG); 953bb326bbe88d0b243d5d9d224308eb0c028d4d4afSanjiv Gupta else 9549fbc7e2e7a765298fb4326885b407e0962f7ab62Duncan Sands TLI.LowerOperationWrapper(N, Results, DAG); 955bb326bbe88d0b243d5d9d224308eb0c028d4d4afSanjiv Gupta 9561607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands if (Results.empty()) 9571607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands // The target didn't want to custom lower it after all. 9581607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands return false; 9591607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands 960ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // When called from DAGTypeLegalizer::ExpandIntegerResult, we might need to 961ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // provide the same kind of custom splitting behavior. 962ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Results.size() == N->getNumValues() + 1 && LegalizeResult) { 963ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // We've legalized a return type by splitting it. If there is a chain, 964ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // replace that too. 965ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SetExpandedInteger(SDValue(N, 0), Results[0], Results[1]); 966ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (N->getNumValues() > 1) 967ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ReplaceValueWith(SDValue(N, 1), Results[2]); 968ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return true; 969ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 970ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 9711607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands // Make everything that once used N's values now use those in Results instead. 9721607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands assert(Results.size() == N->getNumValues() && 9731607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands "Custom lowering returned the wrong number of results!"); 974d73dc544f5e37e6d58befc71e57da3c132804543Justin Holewinski for (unsigned i = 0, e = Results.size(); i != e; ++i) { 9751607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands ReplaceValueWith(SDValue(N, i), Results[i]); 976d73dc544f5e37e6d58befc71e57da3c132804543Justin Holewinski } 977cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang return true; 978cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang} 979cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang 980cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang 981de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Widen the node's results with custom code provided by the target and return 982de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// "true", or do nothing and return "false". 983cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wangbool DAGTypeLegalizer::CustomWidenLowerNode(SDNode *N, EVT VT) { 984cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang // See if the target wants to custom lower this node. 985cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang if (TLI.getOperationAction(N->getOpcode(), VT) != TargetLowering::Custom) 986cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang return false; 987cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang 988cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang SmallVector<SDValue, 8> Results; 989cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang TLI.ReplaceNodeResults(N, Results, DAG); 990cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang 991cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang if (Results.empty()) 992de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // The target didn't want to custom widen lower its result after all. 993cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang return false; 994cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang 995cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang // Update the widening map. 996cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang assert(Results.size() == N->getNumValues() && 997cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang "Custom lowering returned the wrong number of results!"); 998cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang for (unsigned i = 0, e = Results.size(); i != e; ++i) 999cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang SetWidenedVector(SDValue(N, i), Results[i]); 10001607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands return true; 10011607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands} 10021607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands 10034c19e12d28749c717d3b384962c9ec92796af1c9Duncan SandsSDValue DAGTypeLegalizer::DisintegrateMERGE_VALUES(SDNode *N, unsigned ResNo) { 10044c19e12d28749c717d3b384962c9ec92796af1c9Duncan Sands for (unsigned i = 0, e = N->getNumValues(); i != e; ++i) 10054c19e12d28749c717d3b384962c9ec92796af1c9Duncan Sands if (i != ResNo) 10064c19e12d28749c717d3b384962c9ec92796af1c9Duncan Sands ReplaceValueWith(SDValue(N, i), SDValue(N->getOperand(i))); 100704b2c5042727b091ad425110d952491a40c88ee3Duncan Sands return SDValue(N->getOperand(ResNo)); 100862bb16cfd10dd271eab6c31d982bca4d79138602Eli Friedman} 100962bb16cfd10dd271eab6c31d982bca4d79138602Eli Friedman 1010de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Use ISD::EXTRACT_ELEMENT nodes to extract the low and high parts of the 1011de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// given value. 10122bee0afb7d023e029975abf7d3157759fa797d37Dan Gohmanvoid DAGTypeLegalizer::GetPairElements(SDValue Pair, 10132bee0afb7d023e029975abf7d3157759fa797d37Dan Gohman SDValue &Lo, SDValue &Hi) { 1014e4fae84b0b13bd5d66cf619fd2108dbb6064395dBenjamin Kramer SDLoc dl(Pair); 101523b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), Pair.getValueType()); 10162bee0afb7d023e029975abf7d3157759fa797d37Dan Gohman Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NVT, Pair, 10176948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar DAG.getIntPtrConstant(0, dl)); 10182bee0afb7d023e029975abf7d3157759fa797d37Dan Gohman Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NVT, Pair, 10196948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar DAG.getIntPtrConstant(1, dl)); 10202bee0afb7d023e029975abf7d3157759fa797d37Dan Gohman} 10212bee0afb7d023e029975abf7d3157759fa797d37Dan Gohman 1022e50ed30282bb5b4a9ed952580523f2dda16215acOwen AndersonSDValue DAGTypeLegalizer::GetVectorElementPointer(SDValue VecPtr, EVT EltVT, 1023b6e223a9e806921183da972253c49082a2e07944Duncan Sands SDValue Index) { 1024e4fae84b0b13bd5d66cf619fd2108dbb6064395dBenjamin Kramer SDLoc dl(Index); 1025b6e223a9e806921183da972253c49082a2e07944Duncan Sands // Make sure the index type is big enough to compute in. 1026f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Index = DAG.getZExtOrTrunc(Index, dl, TLI.getPointerTy(DAG.getDataLayout())); 1027b6e223a9e806921183da972253c49082a2e07944Duncan Sands 1028b6e223a9e806921183da972253c49082a2e07944Duncan Sands // Calculate the element offset and add it to the pointer. 1029aa9d854b334cab2f29ca6d95413a0946b8a38429Dan Gohman unsigned EltSize = EltVT.getSizeInBits() / 8; // FIXME: should be ABI size. 1030f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar assert(EltSize * 8 == EltVT.getSizeInBits() && 1031f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar "Converting bits to bytes lost precision"); 1032b6e223a9e806921183da972253c49082a2e07944Duncan Sands 10339c8ac447c464eedefa6acd8d71a3aff8280bb9d1Dale Johannesen Index = DAG.getNode(ISD::MUL, dl, Index.getValueType(), Index, 10346948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar DAG.getConstant(EltSize, dl, Index.getValueType())); 10359c8ac447c464eedefa6acd8d71a3aff8280bb9d1Dale Johannesen return DAG.getNode(ISD::ADD, dl, Index.getValueType(), Index, VecPtr); 1036b6e223a9e806921183da972253c49082a2e07944Duncan Sands} 1037b6e223a9e806921183da972253c49082a2e07944Duncan Sands 1038de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Build an integer with low bits Lo and high bits Hi. 1039475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue DAGTypeLegalizer::JoinIntegers(SDValue Lo, SDValue Hi) { 1040ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick // Arbitrarily use dlHi for result SDLoc 1041e4fae84b0b13bd5d66cf619fd2108dbb6064395dBenjamin Kramer SDLoc dlHi(Hi); 1042e4fae84b0b13bd5d66cf619fd2108dbb6064395dBenjamin Kramer SDLoc dlLo(Lo); 1043e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT LVT = Lo.getValueType(); 1044e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT HVT = Hi.getValueType(); 104522d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng EVT NVT = EVT::getIntegerVT(*DAG.getContext(), 104622d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng LVT.getSizeInBits() + HVT.getSizeInBits()); 1047ac7613a3263caa80d735f3fbf2b9f7b81deabc08Duncan Sands 10489c8ac447c464eedefa6acd8d71a3aff8280bb9d1Dale Johannesen Lo = DAG.getNode(ISD::ZERO_EXTEND, dlLo, NVT, Lo); 10499c8ac447c464eedefa6acd8d71a3aff8280bb9d1Dale Johannesen Hi = DAG.getNode(ISD::ANY_EXTEND, dlHi, NVT, Hi); 10509c8ac447c464eedefa6acd8d71a3aff8280bb9d1Dale Johannesen Hi = DAG.getNode(ISD::SHL, dlHi, NVT, Hi, 10516948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar DAG.getConstant(LVT.getSizeInBits(), dlHi, 1052f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar TLI.getPointerTy(DAG.getDataLayout()))); 10539c8ac447c464eedefa6acd8d71a3aff8280bb9d1Dale Johannesen return DAG.getNode(ISD::OR, dlHi, NVT, Lo, Hi); 1054ac7613a3263caa80d735f3fbf2b9f7b81deabc08Duncan Sands} 1055ac7613a3263caa80d735f3fbf2b9f7b81deabc08Duncan Sands 1056de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Convert the node into a libcall with the same prototype. 1057b6e223a9e806921183da972253c49082a2e07944Duncan SandsSDValue DAGTypeLegalizer::LibCallify(RTLIB::Libcall LC, SDNode *N, 1058b6e223a9e806921183da972253c49082a2e07944Duncan Sands bool isSigned) { 1059b6e223a9e806921183da972253c49082a2e07944Duncan Sands unsigned NumOps = N->getNumOperands(); 1060ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc dl(N); 1061b6e223a9e806921183da972253c49082a2e07944Duncan Sands if (NumOps == 0) { 1062f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return TLI.makeLibCall(DAG, LC, N->getValueType(0), None, isSigned, 10633add0679d24a00c4a585809c6ce54486f6a458f5Michael Gottesman dl).first; 1064b6e223a9e806921183da972253c49082a2e07944Duncan Sands } else if (NumOps == 1) { 1065b6e223a9e806921183da972253c49082a2e07944Duncan Sands SDValue Op = N->getOperand(0); 1066f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return TLI.makeLibCall(DAG, LC, N->getValueType(0), Op, isSigned, 10673add0679d24a00c4a585809c6ce54486f6a458f5Michael Gottesman dl).first; 1068b6e223a9e806921183da972253c49082a2e07944Duncan Sands } else if (NumOps == 2) { 1069b6e223a9e806921183da972253c49082a2e07944Duncan Sands SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) }; 1070f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return TLI.makeLibCall(DAG, LC, N->getValueType(0), Ops, isSigned, 10713add0679d24a00c4a585809c6ce54486f6a458f5Michael Gottesman dl).first; 1072b6e223a9e806921183da972253c49082a2e07944Duncan Sands } 1073b6e223a9e806921183da972253c49082a2e07944Duncan Sands SmallVector<SDValue, 8> Ops(NumOps); 1074b6e223a9e806921183da972253c49082a2e07944Duncan Sands for (unsigned i = 0; i < NumOps; ++i) 1075b6e223a9e806921183da972253c49082a2e07944Duncan Sands Ops[i] = N->getOperand(i); 1076245741d2a1ccec53a87bb5d02b711244c179f07aDuncan Sands 1077f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return TLI.makeLibCall(DAG, LC, N->getValueType(0), Ops, isSigned, dl).first; 1078ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1079ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 1080de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Expand a node into a call to a libcall. Similar to ExpandLibCall except that 1081de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// the first operand is the in-chain. 10828d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopherstd::pair<SDValue, SDValue> 1083de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga NainarDAGTypeLegalizer::ExpandChainLibCall(RTLIB::Libcall LC, SDNode *Node, 1084de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool isSigned) { 10858d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher SDValue InChain = Node->getOperand(0); 10868d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher 10878d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher TargetLowering::ArgListTy Args; 10888d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher TargetLowering::ArgListEntry Entry; 10898d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) { 10908d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher EVT ArgVT = Node->getOperand(i).getValueType(); 1091db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext()); 10928d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher Entry.Node = Node->getOperand(i); 10938d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher Entry.Ty = ArgTy; 10948d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher Entry.isSExt = isSigned; 10958d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher Entry.isZExt = !isSigned; 10968d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher Args.push_back(Entry); 10978d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher } 10988d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), 1099f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar TLI.getPointerTy(DAG.getDataLayout())); 11008d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher 1101db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext()); 1102dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 1103dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines TargetLowering::CallLoweringInfo CLI(DAG); 1104dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CLI.setDebugLoc(SDLoc(Node)).setChain(InChain) 1105de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar .setCallee(TLI.getLibcallCallingConv(LC), RetTy, Callee, std::move(Args)) 1106dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines .setSExtResult(isSigned).setZExtResult(!isSigned); 1107dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 1108d2ea0e10cbd158c93fb870cdd03001b9cd1156b8Justin Holewinski std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI); 11098d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher 11108d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher return CallInfo; 11118d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher} 11128d93d19076fb6a67eeb63cb0ba79d00c3aa8478aEric Christopher 1113de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Promote the given target boolean to a target boolean of the given type. 1114de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// A target boolean is an integer value, not necessarily of type i1, the bits 1115de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// of which conform to getBooleanContents. 1116c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines/// 1117c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines/// ValVT is the type of values that produced the boolean. 1118c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen HinesSDValue DAGTypeLegalizer::PromoteTargetBoolean(SDValue Bool, EVT ValVT) { 1119e4fae84b0b13bd5d66cf619fd2108dbb6064395dBenjamin Kramer SDLoc dl(Bool); 1120c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines EVT BoolVT = getSetCCResultType(ValVT); 112128b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands ISD::NodeType ExtendCode = 1122c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines TargetLowering::getExtendForContent(TLI.getBooleanContents(ValVT)); 1123c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return DAG.getNode(ExtendCode, dl, BoolVT, Bool); 112406f0aff69eb0289bdba19a364132bc522f44febaDuncan Sands} 112506f0aff69eb0289bdba19a364132bc522f44febaDuncan Sands 1126de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Widen the given target boolean to a target boolean of the given type. 1127de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// The boolean vector is widened and then promoted to match the target boolean 1128de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// type of the given ValVT. 1129f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga NainarSDValue DAGTypeLegalizer::WidenTargetBoolean(SDValue Bool, EVT ValVT, 1130f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar bool WithZeroes) { 1131f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar SDLoc dl(Bool); 1132f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar EVT BoolVT = Bool.getValueType(); 1133f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 1134f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar assert(ValVT.getVectorNumElements() > BoolVT.getVectorNumElements() && 1135f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar TLI.isTypeLegal(ValVT) && 1136f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar "Unexpected types in WidenTargetBoolean"); 1137f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar EVT WideVT = EVT::getVectorVT(*DAG.getContext(), BoolVT.getScalarType(), 1138f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ValVT.getVectorNumElements()); 1139f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Bool = ModifyToType(Bool, WideVT, WithZeroes); 1140f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return PromoteTargetBoolean(Bool, ValVT); 1141f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar} 1142f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 1143de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Return the lower LoVT bits of Op in Lo and the upper HiVT bits in Hi. 1144b6e223a9e806921183da972253c49082a2e07944Duncan Sandsvoid DAGTypeLegalizer::SplitInteger(SDValue Op, 1145e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT LoVT, EVT HiVT, 1146b6e223a9e806921183da972253c49082a2e07944Duncan Sands SDValue &Lo, SDValue &Hi) { 1147e4fae84b0b13bd5d66cf619fd2108dbb6064395dBenjamin Kramer SDLoc dl(Op); 1148b6e223a9e806921183da972253c49082a2e07944Duncan Sands assert(LoVT.getSizeInBits() + HiVT.getSizeInBits() == 1149b6e223a9e806921183da972253c49082a2e07944Duncan Sands Op.getValueType().getSizeInBits() && "Invalid integer splitting!"); 11509c8ac447c464eedefa6acd8d71a3aff8280bb9d1Dale Johannesen Lo = DAG.getNode(ISD::TRUNCATE, dl, LoVT, Op); 11519c8ac447c464eedefa6acd8d71a3aff8280bb9d1Dale Johannesen Hi = DAG.getNode(ISD::SRL, dl, Op.getValueType(), Op, 11526948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar DAG.getConstant(LoVT.getSizeInBits(), dl, 1153f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar TLI.getPointerTy(DAG.getDataLayout()))); 11549c8ac447c464eedefa6acd8d71a3aff8280bb9d1Dale Johannesen Hi = DAG.getNode(ISD::TRUNCATE, dl, HiVT, Hi); 11557d0d8460646d1a06ff561775d40123a4cf65bf4dDuncan Sands} 11567d0d8460646d1a06ff561775d40123a4cf65bf4dDuncan Sands 1157de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Return the lower and upper halves of Op's bits in a value type half the 1158de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// size of Op's. 1159b6e223a9e806921183da972253c49082a2e07944Duncan Sandsvoid DAGTypeLegalizer::SplitInteger(SDValue Op, 1160b6e223a9e806921183da972253c49082a2e07944Duncan Sands SDValue &Lo, SDValue &Hi) { 116122d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng EVT HalfVT = EVT::getIntegerVT(*DAG.getContext(), 116222d286b218f3267d57c507678b1af0fccc3a5df0Evan Cheng Op.getValueType().getSizeInBits()/2); 1163b6e223a9e806921183da972253c49082a2e07944Duncan Sands SplitInteger(Op, HalfVT, HalfVT, Lo, Hi); 116478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 116578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 11667d0d8460646d1a06ff561775d40123a4cf65bf4dDuncan Sands 116701d029b82cb08367d81aa10cdc94d05360466649Chris Lattner//===----------------------------------------------------------------------===// 116801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner// Entry Point 116901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner//===----------------------------------------------------------------------===// 117001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner 1171de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// This transforms the SelectionDAG into a SelectionDAG that only uses types 1172de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// natively supported by the target. Returns "true" if it made any changes. 117301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner/// 117401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner/// Note that this is an involved process that may invalidate pointers into 117501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner/// the graph. 117625cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sandsbool SelectionDAG::LegalizeTypes() { 117725cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands return DAGTypeLegalizer(*this).run(); 117801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner} 1179