LegalizeDAG.cpp revision eb516e7f0aa3223eab7967f4c0f8132d82efd841
13e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===-- LegalizeDAG.cpp - Implement SelectionDAG::Legalize ----------------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 33e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// The LLVM Compiler Infrastructure 43e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 53e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file was developed by the LLVM research group and is distributed under 63e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 83e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 93e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file implements the SelectionDAG::Legalize method. 113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineConstantPool.h" 163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineFunction.h" 1745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Target/TargetLowering.h" 19e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner#include "llvm/Target/TargetData.h" 200f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner#include "llvm/Target/TargetOptions.h" 213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Constants.h" 223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include <iostream> 233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerusing namespace llvm; 243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and 273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// hacks on it until the target machine can handle it. This involves 283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating value sizes the machine cannot handle (promoting small sizes to 293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// large sizes or splitting up large values into small values) as well as 303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating operations the machine cannot handle. 313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// This code also does a small amount of optimization and recognition of idioms 333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// as part of its processing. For example, if a target does not support a 343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 'setcc' instruction efficiently, but does support 'brcc' instruction, this 353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// will attempt merge setcc and brc instructions into brcc's. 363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnernamespace { 383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerclass SelectionDAGLegalize { 393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TargetLowering &TLI; 403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SelectionDAG &DAG; 413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizeAction - This enum indicates what action we should take for each 433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type the can occur in the program. 443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner enum LegalizeAction { 453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Legal, // The target natively supports this value type. 463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Promote, // This should be promoted to the next larger type. 473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Expand, // This integer type should be broken into smaller pieces. 483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner }; 493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ValueTypeActions - This is a bitvector that contains two bits for each 513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type, where the two bits correspond to the LegalizeAction enum. 523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// This can be queried with "getTypeAction(VT)". 533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner unsigned ValueTypeActions; 543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// NeedsAnotherIteration - This is set when we expand a large integer 563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// operation into smaller integer operations, but the smaller operations are 573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// not set. This occurs only rarely in practice, for targets that don't have 583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 32-bit or larger integer registers. 593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool NeedsAnotherIteration; 603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizedNodes - For nodes that are of legal width, and that have more 623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates what regularized operand to use. This 633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// allows us to avoid legalizing the same thing more than once. 643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, SDOperand> LegalizedNodes; 653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6603c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// PromotedNodes - For nodes that are below legal width, and that have more 6703c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// than one use, this map indicates what promoted value to use. This allows 6803c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// us to avoid promoting the same thing more than once. 6903c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::map<SDOperand, SDOperand> PromotedNodes; 7003c8546ec57523970874917854a2fb77b1ff598eChris Lattner 713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ExpandedNodes - For nodes that need to be expanded, and which have more 723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates which which operands are the expanded 733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// version of the input. This allows us to avoid expanding the same node 743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// more than once. 753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedNodes; 763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 778afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner void AddLegalizedOperand(SDOperand From, SDOperand To) { 788afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner bool isNew = LegalizedNodes.insert(std::make_pair(From, To)).second; 798afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner assert(isNew && "Got into the map somehow?"); 808afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner } 8103c8546ec57523970874917854a2fb77b1ff598eChris Lattner void AddPromotedOperand(SDOperand From, SDOperand To) { 8203c8546ec57523970874917854a2fb77b1ff598eChris Lattner bool isNew = PromotedNodes.insert(std::make_pair(From, To)).second; 8303c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isNew && "Got into the map somehow?"); 8403c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 858afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner 863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerpublic: 873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 889c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(SelectionDAG &DAG); 893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Run - While there is still lowering to do, perform a pass over the DAG. 913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Most regularization can be done in a single pass, but targets that require 923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// large values to be split into registers multiple times (e.g. i64 -> 4x 933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// i16) require iteration for these values (the first iteration will demote 943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// to i32, the second will demote to i16). 953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void Run() { 963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner do { 973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NeedsAnotherIteration = false; 983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeDAG(); 993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } while (NeedsAnotherIteration); 1003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// getTypeAction - Return how we should legalize values of this type, either 1033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// it is already legal or we need to expand it into multiple registers of 1043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// smaller integer type, or we need to promote it to a larger type. 1053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeAction getTypeAction(MVT::ValueType VT) const { 1063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return (LegalizeAction)((ValueTypeActions >> (2*VT)) & 3); 1073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// isTypeLegal - Return true if this type is legal on this target. 1103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 1113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isTypeLegal(MVT::ValueType VT) const { 1123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return getTypeAction(VT) == Legal; 1133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerprivate: 1163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void LegalizeDAG(); 1173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LegalizeOp(SDOperand O); 1193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void ExpandOp(SDOperand O, SDOperand &Lo, SDOperand &Hi); 12003c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand PromoteOp(SDOperand O); 1213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandLibCall(const char *Name, SDNode *Node, 12377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi); 12477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandIntToFP(bool isSigned, MVT::ValueType DestTy, 12577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Source); 126e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner bool ExpandShift(unsigned Opc, SDOperand Op, SDOperand Amt, 127e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi); 1285b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandShiftParts(unsigned NodeOp, SDOperand Op, SDOperand Amt, 1295b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi); 1305b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 1314759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi); 132e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 133b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner void SpliceCallInto(const SDOperand &CallResult, SDNode *OutChain); 134b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 1353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 1363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 1373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1429c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris LattnerSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag) 1439c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner : TLI(dag.getTargetLoweringInfo()), DAG(dag), 1449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner ValueTypeActions(TLI.getValueTypeActions()) { 1453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::LAST_VALUETYPE <= 16 && 1463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Too many value types for ValueTypeActions to hold!"); 1473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 1503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand OldRoot = DAG.getRoot(); 1513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand NewRoot = LegalizeOp(OldRoot); 1523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner DAG.setRoot(NewRoot); 1533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandedNodes.clear(); 1553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 15671c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner PromotedNodes.clear(); 1573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 15962fd269c146d9023efe32644e44cd97b88631d4fChris Lattner DAG.RemoveDeadNodes(OldRoot.Val); 1603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris LattnerSDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { 163e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner assert(getTypeAction(Op.getValueType()) == Legal && 164e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner "Caller should expand or promote operands that are not legal!"); 16545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner SDNode *Node = Op.Val; 166e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 1673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If this operation defines any values that cannot be represented in a 168e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner // register on this target, make sure to expand or promote them. 16945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Node->getNumValues() > 1) { 17045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 17145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner switch (getTypeAction(Node->getValueType(i))) { 1723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: break; // Nothing to do. 1733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 1743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand T1, T2; 1753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Op.getValue(i), T1, T2); 1763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(LegalizedNodes.count(Op) && 1773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Expansion didn't add legal operands!"); 1783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return LegalizedNodes[Op]; 1793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 18103c8546ec57523970874917854a2fb77b1ff598eChris Lattner PromoteOp(Op.getValue(i)); 18203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(LegalizedNodes.count(Op) && 18303c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Expansion didn't add legal operands!"); 18403c8546ec57523970874917854a2fb77b1ff598eChris Lattner return LegalizedNodes[Op]; 1853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 18845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 18945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 190e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::map<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op); 191e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 1923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 193fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner SDOperand Tmp1, Tmp2, Tmp3; 1943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Result = Op; 1963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 1983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 1993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 2003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 2013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 2023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EntryToken: 2033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::FrameIndex: 2043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 20503c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::ExternalSymbol: 20669a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::ConstantPool: // Nothing to do. 2073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(Node->getValueType(0)) == Legal && 2083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "This must be legal!"); 2093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 21069a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 21169a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 21269a52155d2eff066b49dbac385113002fd9dba14Chris Lattner if (Tmp1 != Node->getOperand(0)) 21369a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Result = DAG.getCopyFromReg(cast<RegSDNode>(Node)->getReg(), 21469a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Node->getValueType(0), Tmp1); 21513c184de29c09294ed63b01ac43e1b46c049278eChris Lattner else 21613c184de29c09294ed63b01ac43e1b46c049278eChris Lattner Result = Op.getValue(0); 21713c184de29c09294ed63b01ac43e1b46c049278eChris Lattner 21813c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 21913c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 22013c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 22113c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 22213c184de29c09294ed63b01ac43e1b46c049278eChris Lattner return Result.getValue(Op.ResNo); 22318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner case ISD::ImplicitDef: 22418c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 22518c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner if (Tmp1 != Node->getOperand(0)) 2262ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Result = DAG.getImplicitDef(Tmp1, cast<RegSDNode>(Node)->getReg()); 22718c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner break; 228fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 229fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman MVT::ValueType VT = Op.getValueType(); 230fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 231ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 232ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 233ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Promote: 234fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman if (MVT::isInteger(VT)) 235fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 236fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else if (MVT::isFloatingPoint(VT)) 237fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstantFP(0, VT); 238fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 239fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 240fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 241ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 242fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 243fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 244fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 245fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 2463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: 2473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 2483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 2493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: Maybe we should handle things like targets that don't support full 2513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // 32-bit immediates? 2523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 2543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 2553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 2563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 2573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 2583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 2603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Check to see if this FP immediate is already legal. 2623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isLegal = false; 2633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 2643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner E = TLI.legal_fpimm_end(); I != E; ++I) 2653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (CFP->isExactlyValue(*I)) { 2663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner isLegal = true; 2673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 2693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!isLegal) { 2713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Otherwise we need to spill the constant to memory. 2723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MachineConstantPool *CP = DAG.getMachineFunction().getConstantPool(); 2733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool Extend = false; 2753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If a FP immediate is precise when represented as a float, we put it 2773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // into the constant pool as a float, even if it's is statically typed 2783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // as a double. 2793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = CFP->getValueType(0); 2803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isDouble = VT == MVT::f64; 2813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy : 2823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Type::FloatTy, CFP->getValue()); 28399939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner if (isDouble && CFP->isExactlyValue((float)CFP->getValue()) && 28499939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // Only do this if the target has a native EXTLOAD instruction from 28599939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // f32. 28699939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner TLI.getOperationAction(ISD::EXTLOAD, 28799939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner MVT::f32) == TargetLowering::Legal) { 2883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LLVMC = cast<ConstantFP>(ConstantExpr::getCast(LLVMC, Type::FloatTy)); 2893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner VT = MVT::f32; 2903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Extend = true; 2913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 292edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand CPIdx = DAG.getConstantPool(CP->getConstantPoolIndex(LLVMC), 2943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TLI.getPointerTy()); 295f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner if (Extend) { 296f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), CPIdx, 2972d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth DAG.getSrcValue(NULL), MVT::f32); 298f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } else { 29952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, 30052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 301f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } 3023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 3043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 305a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner case ISD::TokenFactor: { 306a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner std::vector<SDOperand> Ops; 307a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner bool Changed = false; 308a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 3091e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner SDOperand Op = Node->getOperand(i); 3101e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner // Fold single-use TokenFactor nodes into this token factor as we go. 311e131e5b81e5853f3c2a8c63651898ecd37eaf6f8Chris Lattner // FIXME: This is something that the DAGCombiner should do!! 3121e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner if (Op.getOpcode() == ISD::TokenFactor && Op.hasOneUse()) { 3131e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Changed = true; 3141e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner for (unsigned j = 0, e = Op.getNumOperands(); j != e; ++j) 3151e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Ops.push_back(LegalizeOp(Op.getOperand(j))); 3161e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner } else { 3171e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Ops.push_back(LegalizeOp(Op)); // Legalize the operands 3181e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Changed |= Ops[i] != Op; 3191e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner } 320a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 321a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner if (Changed) 322a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); 323a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 324a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 325a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner 32616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_START: 32716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 3283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 329128b52d3d75f4b74367de43e891cd98b5a9b5483Chris Lattner // Do not try to legalize the target-specific arguments (#1+) 33045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner Tmp2 = Node->getOperand(0); 33145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Tmp1 != Tmp2) { 33288de6e77bfadea8962b017f372658204ab71448cChris Lattner Node->setAdjCallChain(Tmp1); 33345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 33445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // If moving the operand from pointing to Tmp2 dropped its use count to 1, 33545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // this will cause the maps used to memoize results to get confused. 33645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Create and add a dummy use, just to increase its use count. This will 33745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // be removed at the end of legalize when dead nodes are removed. 33845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Tmp2.Val->hasOneUse()) 33945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp2, 34045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner DAG.getConstant(0, MVT::i32)); 34145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } 34216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 34388de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 34488de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 34588de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 3463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 347fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner case ISD::DYNAMIC_STACKALLOC: 348fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 349fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 350fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 351fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 352fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 != Node->getOperand(2)) 353fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, Node->getValueType(0), 354fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1, Tmp2, Tmp3); 355513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner else 356513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 357fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 358fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // Since this op produces two values, make sure to remember that we 359fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // legalized both of them. 360fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 361fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 362fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner return Result.getValue(Op.ResNo); 363fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 3643d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner case ISD::CALL: { 3653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 3673d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 3683d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 3693d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 3703d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 3713d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 3723d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 3733d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 3743d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 3753d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Changed) { 3763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 3773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(Node->getNumValues()); 3783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 379ebda942efcb86634a6581aae76a0d0c92c4a232eChris Lattner RetTyVTs.push_back(Node->getValueType(i)); 3803d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Result = SDOperand(DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops), 0); 38138d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner } else { 38238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner Result = Result.getValue(0); 3833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 38438d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // Since calls produce multiple values, make sure to remember that we 38538d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // legalized all of them. 38638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 38738d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 38838d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner return Result.getValue(Op.ResNo); 3893d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 390c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 391c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 392c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 393c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 394c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 395c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 396c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 397c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 39847e9223e06390897c3834f8c527001df392570ffChris Lattner 39947e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 40047e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 40147e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 40247e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 40347e9223e06390897c3834f8c527001df392570ffChris Lattner break; 40447e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 40547e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 40647e9223e06390897c3834f8c527001df392570ffChris Lattner break; 40747e9223e06390897c3834f8c527001df392570ffChris Lattner } 408c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner // Basic block destination (Op#2) is always legal. 409c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 410c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 411c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Node->getOperand(2)); 412c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 413411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 414411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 415411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 416411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 417411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 418411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 419411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 420411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 421411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 422411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 423411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 424411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 425411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 426411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 427411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 428411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 429411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 430411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 431411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 432411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 433411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 434411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 435411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 436411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 437411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 438411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 439411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 440411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 441411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 442411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 443411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 444411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 445411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 446c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner 4473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: 4483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 4493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 4502d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 4513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 4523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 45352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(Node->getValueType(0), Tmp1, Tmp2, 45452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(2)); 4558afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner else 4568afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner Result = SDOperand(Node, 0); 457edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 4588afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // Since loads produce two values, make sure to remember that we legalized 4598afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // both of them. 4608afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 4618afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 4628afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner return Result.getValue(Op.ResNo); 4633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4640f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 4650f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 46601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 4670f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 4680f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 4690f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 47001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner MVT::ValueType SrcVT = cast<MVTSDNode>(Node)->getExtraValueType(); 47101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 47201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 4731c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 4741c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 4751c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), 4762d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 4771c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 4781c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 4791c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 4801c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 4811c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 482edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 48301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 48401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 48501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 48601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), 4872d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Tmp1, Tmp2, Node->getOperand(2), SrcVT); 48801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 48901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 49001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 49101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 49201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 49301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 49401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 49501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 49601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 49701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 49801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 49901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 50001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 50101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = DAG.getNode(ISD::EXTLOAD, Node->getValueType(0), 5022d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Tmp1, Tmp2, Node->getOperand(2), SrcVT); 50323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 50423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 50523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 50623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result, SrcVT); 50723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 50823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 50901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 51001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 51101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 51201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 51301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 51401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 51501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 51601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 5173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EXTRACT_ELEMENT: 5183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Get both the low and high parts. 5193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 5203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 5213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = Tmp2; // 1 -> Hi 5223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner else 5233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = Tmp1; // 0 -> Lo 5243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 5273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 528edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 5293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 5303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 5313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Legalize the incoming value (must be legal). 5323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 5333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 53418c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner Result = DAG.getCopyToReg(Tmp1, Tmp2, cast<RegSDNode>(Node)->getReg()); 5353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 536ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner case Promote: 537ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 538ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner Result = DAG.getCopyToReg(Tmp1, Tmp2, cast<RegSDNode>(Node)->getReg()); 539ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner break; 540ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner case Expand: 5413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 542edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman ExpandOp(Node->getOperand(1), Lo, Hi); 54318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner unsigned Reg = cast<RegSDNode>(Node)->getReg(); 544ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Lo = DAG.getCopyToReg(Tmp1, Lo, Reg); 545ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi = DAG.getCopyToReg(Tmp1, Hi, Reg+1); 546ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Note that the copytoreg nodes are independent of each other. 547ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 5483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Result.getValueType()) && 5493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand multiple times yet (i64 -> i16)"); 5503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 5553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 5563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 5573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 5583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 5593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 5603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 5618afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 5623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 5633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 5653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 5663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 5673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 568edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 5693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 5718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 5728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 5738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 5743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 5773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 5783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 5793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 5813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 5823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 5833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 5843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 5853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 5864e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 5873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 5893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 5903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 5913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 5923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 593edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 5943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 5968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 5973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 5993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::STORE: 6043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 6063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6075d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 60803c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 6095d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 6105d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner union { 6115d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner unsigned I; 6125d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner float F; 6135d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } V; 6145d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner V.F = CFP->getValue(); 6152d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 6166d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getConstant(V.I, MVT::i32), Tmp2, 61752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 6185d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 6195d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 6205d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner union { 6215d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner uint64_t I; 6225d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner double F; 6235d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } V; 6245d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner V.F = CFP->getValue(); 6252d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 62652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getConstant(V.I, MVT::i64), Tmp2, 62752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 6285d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 62984734ce8ef1a21eb347d4deca0bf32d59001f751Chris Lattner Node = Result.Val; 6305d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 6315d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 6323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 6333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 6343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 6353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 6363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 63752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 63852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 6393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 64203c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 64303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 64403c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 6452d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 6462d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(1).getValueType()); 64703c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 64803c8546ec57523970874917854a2fb77b1ff598eChris Lattner 6493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 6503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 6513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 6523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 6543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 6553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 656edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 657edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 658ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner unsigned IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 6593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 6603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 6613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 6623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 6632d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 664edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 665edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 666ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 667ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 6683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 67095762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 67195762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6722c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 6732c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 67495762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 6750f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::TRUNCSTORE: 6760f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6770f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 6780f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 6790f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 6800f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 6810f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 6820f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 6830f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 != Node->getOperand(2)) 68445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 6852d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 6860f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner cast<MVTSDNode>(Node)->getExtraValueType()); 6870f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 6880f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Promote: 6890f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Expand: 6900f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 6910f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 6920f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 6932ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 69447e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 69547e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 69647e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 69747e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 69847e9223e06390897c3834f8c527001df392570ffChris Lattner break; 69947e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 70047e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 70147e9223e06390897c3834f8c527001df392570ffChris Lattner break; 70247e9223e06390897c3834f8c527001df392570ffChris Lattner } 7033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 7042ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 70555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 70655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Tmp2.getValueType())) { 70755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 70855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 70955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 71055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 71155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 71255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 71355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 71455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 71555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 71655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 71755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 71855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 71955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::ZERO_EXTEND; 72055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 72155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 72255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 72355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 72455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 72555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 72655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 72755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 72855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 72955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 73055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 73155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 73255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 73355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 7343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 7353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 7363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 7373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 7383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 7393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 7403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 7413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getSetCC(cast<SetCCSDNode>(Node)->getCondition(), 742f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Node->getValueType(0), Tmp1, Tmp2); 7433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 7443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 7458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 7468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 7478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 7488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 7498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 7508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 75171c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 7528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 7538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 7548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 7558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 7568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 7578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (cast<SetCCSDNode>(Node)->getCondition()) { 7588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 7598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 7608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 7618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 7628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 7638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 7648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 7658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 7668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 7678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 76823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 76923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 7708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 7718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 7728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 7738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 7748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 7758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, VT); 7768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, VT); 7778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 7788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 7798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 7808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 7818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getSetCC(cast<SetCCSDNode>(Node)->getCondition(), 782f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Node->getValueType(0), Tmp1, Tmp2); 7833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 784edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 7853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 7863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 7873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 7883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (cast<SetCCSDNode>(Node)->getCondition()) { 7893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 7903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 79108b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 79208b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 79308b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 79408b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 79508b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 796edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getSetCC(cast<SetCCSDNode>(Node)->getCondition(), 79708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Node->getValueType(0), Tmp1, RHSLo); 798edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 79908b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 80008b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 8013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 8023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 8033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 804edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getSetCC(cast<SetCCSDNode>(Node)->getCondition(), 805f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Node->getValueType(0), Tmp1, 8063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner DAG.getConstant(0, Tmp1.getValueType())); 8073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 8083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 8095b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 8105b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 8115b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 812edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman if ((cast<SetCCSDNode>(Node)->getCondition() == ISD::SETLT && 8135b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 8145b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner (cast<SetCCSDNode>(Node)->getCondition() == ISD::SETGT && 8155b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner (CST->isAllOnesValue()))) // X > -1 8165b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner return DAG.getSetCC(cast<SetCCSDNode>(Node)->getCondition(), 8175b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner Node->getValueType(0), LHSHi, RHSHi); 8185b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 8193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 8203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 8213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (cast<SetCCSDNode>(Node)->getCondition()) { 8223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 8233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 8243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 8253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 8263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 8273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 8283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 8293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 8303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 8313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 832edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 8333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 8343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 8353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 8363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 8373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 8383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 839f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Tmp1 = DAG.getSetCC(LowCC, Node->getValueType(0), LHSLo, RHSLo); 8403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getSetCC(cast<SetCCSDNode>(Node)->getCondition(), 841f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Node->getValueType(0), LHSHi, RHSHi); 842f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Result = DAG.getSetCC(ISD::SETEQ, Node->getValueType(0), LHSHi, RHSHi); 843f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Result = DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 844f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Result, Tmp1, Tmp2); 8453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 8463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 8473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 8483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 8493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 850e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 851e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 852e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 853deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 854e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 855e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 856e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 857e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 858e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 859e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 860deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 861e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 862e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 863deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 864e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 865e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 866e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 867edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 868e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 869272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 870272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 871272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 872e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 873e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 874e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 875e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 876e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 877e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 878272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 879272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 880272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 881272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 882272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 883272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 884272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 885272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 886272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 887272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 888e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 889e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 890e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 89155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 89255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 89355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 89455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 895e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 896e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 897e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 898e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 899e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 900e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 901e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 902e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 90355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 90455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 905e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 906e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 907e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 908e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 909e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 910e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 9113bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 912e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 913e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 914e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 915e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 916e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 917e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 918e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 919e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 920e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 921e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 922e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 923e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 924e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 925e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 926e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 927e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 928e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 92945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 930e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 9319092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, 0, 932e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 933e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = LegalizeOp(CallResult.second); 93455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 93555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 93655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Custom: 93755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner std::vector<SDOperand> Ops; 93855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 93955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 94055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 94155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = TLI.LowerOperation(Result); 94255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = LegalizeOp(Result); 94355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 944e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 945e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 946e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 94752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 94852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 94952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 95052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 9516d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 95252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 9536d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::READPORT, Node->getValueType(0), Tmp1, Tmp2); 95452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner else 95552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 95652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 95752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 95852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 95952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 96052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 96152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 96252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 96352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 96452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 96552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 96652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 96752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 96852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 96952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 9706d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 9716d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 9726d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 9736d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 9746d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 9756d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 9766d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 9776d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 9786d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 9796d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), 9806d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1, Tmp2); 9816d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner else 9826d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 9836d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 9846d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 9856d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 9866d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 9876d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 9886d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 9896d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 9906d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 9916d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 9926d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 9936d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 9946d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 9956d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 9966d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 9976d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 9986d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 9996d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 10006d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 10016d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 10026d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 10036d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 10046d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 10056d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 10066d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 10076d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 10086d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 10096d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 10106d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 10116d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 10126d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 10136d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 10146d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 10156d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 10166d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 10176d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 10186d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 10196d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 10206d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 10216d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 102284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 10235b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 10245b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 10255b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 10265b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 102784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 102884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 102984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 103084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 103184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 103284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 103384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner if (Changed) 103484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Ops); 10352c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 10362c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 10372c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 10382c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 10392c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 10402c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 104184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 10422c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 10432c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 10443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 10453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 10463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 1047c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 1048c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 10493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 10503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 10513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 10523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 10533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 105403c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 105503c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 105603c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 10573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 10583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 10593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 10603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 10613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 10623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1063edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1064c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 1065c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 1066c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1067c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 1068c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1069c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Legal: 1070c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman if (Tmp1 != Node->getOperand(0) || 1071c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 != Node->getOperand(1)) 1072edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 1073c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2); 1074c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1075c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Promote: 1076c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Custom: 1077c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman assert(0 && "Cannot promote/custom handle this yet!"); 1078c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Expand: { 1079c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman MVT::ValueType VT = Node->getValueType(0); 1080c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 1081c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 1082c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 1083c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 1084c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1085c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1086c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1087c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 10882c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 1089691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1090691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1091691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1092691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 1093691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1094691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 1095691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 1096691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1097691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1098691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 1099691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 1100691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 1101edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 1102edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 1103691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 1104691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 1105691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1106691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 1107691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 1108691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1109691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 1110691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1111691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1112691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 111339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Tmp2 = DAG.getSetCC(ISD::SETEQ, TLI.getSetCCResultTy(), Tmp1, 1114691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(NVT), NVT)); 1115691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 1116691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 1117691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1118691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1119691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 1120691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 1121691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(NVT) - 1122691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 1123691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1124691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1125691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1126691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1127691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 1128691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 1129691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 1130ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 1131ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 1132ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 1133e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 1134e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 1135e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 1136e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 1137e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 1138ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 1139e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 1140e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 1141e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 1142ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 1143e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 1144e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 1145ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp1 = DAG.getNode(ISD::ADD, VT, 1146ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 1147ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 1148ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 1149ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 1150ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1151ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Result = Tmp1; 1152ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1153ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 115457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 115557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 11565c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 11575c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 11585c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 11595c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 11605c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>32); // for 64-bit input 11615c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 116257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina 11635c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 11645c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 116557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 116657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 116757ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 116857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 116957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 117057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 117157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 117257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 11735c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 117418aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 117557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 117657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 1177d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // for now, we use: { return popcount(~x & (x - 1)); } 1178d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 1179d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 1180d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 11815c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 11825c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 11835c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp3 = DAG.getNode(ISD::AND, VT, 11845c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 11855c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 11865c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 1187d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 1188d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman if (TLI.getOperationAction(ISD::CTPOP, VT) != TargetLowering::Legal && 1189d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman TLI.getOperationAction(ISD::CTLZ, VT) == TargetLowering::Legal) { 1190d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 1191d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 1192d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 1193d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 1194d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 1195d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 119618aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 119757ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 1198ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 1199ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 1200ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1201ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1202691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1203691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1204691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1205691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth 12062c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 12072c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 12082c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 1209da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 1210da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 1211da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 12122c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 12132c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 12142c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 12152c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 12162c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 12172c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 12182c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 12192c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 12202c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 12212c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 1222f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1223f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 12242c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 12252c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 12262c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::SUB, Node->getValueType(0), 12272c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 1228f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1229f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1230f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 12314af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 12324af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 12334af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 12344af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getSetCC(ISD::SETUGT, TLI.getSetCCResultTy(), Tmp1, Tmp2); 12354af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 12364af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 12374af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 1238f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1239f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1240f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 1241f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 1242f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 1243f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 1244f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner Type *T = VT == MVT::f32 ? Type::FloatTy : Type::DoubleTy; 1245f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 1246f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1247f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 1248f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 1249f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 1250f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 1251f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1252f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1253f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner Args.push_back(std::make_pair(Tmp1, T)); 12540d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // FIXME: should use ExpandLibCall! 1255f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 12569092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(DAG.getEntryNode(), T, false, 0, 1257f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner DAG.getExternalSymbol(FnName, VT), Args, DAG); 1258f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner Result = LegalizeOp(CallResult.first); 1259f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1260f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1261f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 12624af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 12632c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 12642c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 12652c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 12662c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 12672c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 12682c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 12693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 12703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 12717cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner case ISD::TRUNCATE: 127203c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 127303c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 1274ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner case ISD::FP_TO_SINT: 1275ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner case ISD::FP_TO_UINT: 1276ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner case ISD::SINT_TO_FP: 1277ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner case ISD::UINT_TO_FP: 12783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 12793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 12803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 12813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 12823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 12833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1284b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 128577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP || 128677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOpcode() == ISD::UINT_TO_FP) { 128777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 128877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getValueType(0), Node->getOperand(0)); 128977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 12902c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } else if (Node->getOpcode() == ISD::TRUNCATE) { 12912c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // In the expand case, we must be dealing with a truncate, because 12922c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // otherwise the result would be larger than the source. 12932c8086f4b9916b2d02842be5e375276023225fbaChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 1294edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 12952c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since the result is legal, we should just be able to truncate the low 12962c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // part of the source. 12972c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 12982c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 129977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 13002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 1301b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 130203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 130303c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 13041713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 13051713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 130647e9223e06390897c3834f8c527001df392570ffChris Lattner // NOTE: Any extend would work here... 130747e9223e06390897c3834f8c527001df392570ffChris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, Op.getValueType(), Result); 130823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 130923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 131003c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 131103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 13121713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 131347e9223e06390897c3834f8c527001df392570ffChris Lattner // NOTE: Any extend would work here... 1314d5d56825123665b60d4eada0a4ad7d0adc5cf3a3Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, Op.getValueType(), Result); 13151713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 13161713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result, Node->getOperand(0).getValueType()); 13171713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 131803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 13191713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 13201713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 13211713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 132203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 13231713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 13241713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 13251713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 13261713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 13271713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 132803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 132903c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_TO_SINT: 133003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_TO_UINT: 1331f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 1332f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 1333f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 133403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SINT_TO_FP: 1335f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 1336f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 1337f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result, Node->getOperand(0).getValueType()); 1338f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 1339f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 134003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::UINT_TO_FP: 1341f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 134223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 134323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 1344f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 1345f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 134603c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 13473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13490f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 135023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 13510f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 135245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::ValueType ExtraVT = cast<MVTSDNode>(Node)->getExtraValueType(); 135345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 135445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 135545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 135655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 135755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 135855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 135955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 136055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 136155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtraVT); 136255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 136355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 136445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 136523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 136645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 136745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 136845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 136945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 137027ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 137145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 137245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 137345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 137445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 137545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 137645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 137745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 137845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 137945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 138045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 138145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 138245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 138345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 138445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 138545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 1386edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 138745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 138845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 138945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 139052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 139152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL), ExtraVT); 139245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::EXTLOAD, Node->getValueType(0), 13932d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Result, StackSlot, DAG.getSrcValue(NULL), ExtraVT); 139445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 139545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 139645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 139745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 139855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 139945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 14000f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 14013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 140245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 14033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 140445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 140545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 140645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 14073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 14083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 14093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 14108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 14118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 14128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 14138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 141403c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 141503c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 141671c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 141703c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 141803c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 141903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 142003c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 142103c8546ec57523970874917854a2fb77b1ff598eChris Lattner 142203c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 142303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 142403c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 142503c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 142603c8546ec57523970874917854a2fb77b1ff598eChris Lattner 142745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (!Node->hasOneUse()) { 142845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 142945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (I != PromotedNodes.end()) return I->second; 143045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } else { 143145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner assert(!PromotedNodes.count(Op) && "Repromoted this node??"); 143245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } 143345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 14340f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 14350f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 14360f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 14370f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 14380f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 143903c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 144003c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 144103c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 144203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 144303c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 1444fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 1445fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 1446fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 144703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 144803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 144903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 145003c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 145103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 145203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 145303c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 145403c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 1455ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner case ISD::CopyFromReg: 1456ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner Result = DAG.getCopyFromReg(cast<RegSDNode>(Node)->getReg(), NVT, 1457ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner Node->getOperand(0)); 1458ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner // Remember that we legalized the chain. 1459ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 1460ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner break; 1461ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 146282fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 146382fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner assert(getTypeAction(TLI.getSetCCResultTy()) == Legal && 146482fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner "SetCC type is not legal??"); 146582fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = DAG.getSetCC(cast<SetCCSDNode>(Node)->getCondition(), 146682fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner TLI.getSetCCResultTy(), Node->getOperand(0), 146782fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Node->getOperand(1)); 146882fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 146982fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 147003c8546ec57523970874917854a2fb77b1ff598eChris Lattner 147103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 147203c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 147303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 147403c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 147503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 147603c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 147703c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 147803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 147903c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 1480e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 1481e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 1482e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 1483e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 1484e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 148503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 148679e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 148779e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 1488edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getNode(ISD::TRUNCATE, VT, Tmp1); 148903c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 149003c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 14918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 14928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 14938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 14948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 14958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 14968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 14978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 14988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 14998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 15018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 15028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 15038b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 15048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 1505595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 1506595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Node->getOperand(0).getValueType()); 15078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 150823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 150923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 15108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 15128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 15148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 15158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 15168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 15178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 15188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 15198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 15208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 15218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 15228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 15238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, VT); 15248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 15268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 15288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 15298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 15308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 15318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 15328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 153377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 153477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 15358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 15378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 15388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 15398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 15408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 15418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result, Node->getOperand(0).getValueType()); 15428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 154323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 154423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 154577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 154677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 15478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 154977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 155077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 155177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 155277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 155377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, VT); 155477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 15558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 15568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 15588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 15598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 15608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 15618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 15628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 15638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 15658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 15668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 15678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 15688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 15708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 15718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 15728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 15738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 15748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 15752c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 15762c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 15772c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 15782c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 15792c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 15802c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 15812c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 15822c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 15832c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 15842c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 1585da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 1586da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 1587da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 1588da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 1589da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 1590da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 1591da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 1592da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, VT); 1593da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 1594da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 159503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 159603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 159703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 15980f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 15998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 16000f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 16010f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 16020f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // these operations don't care. They may have wierd bits going out, but 16030f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 16040f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 16050f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 16060f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 16070f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 16080f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 16090f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // However, if this is a floating point operation, they will give excess 16100f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // precision that we may not be able to tolerate. If we DO allow excess 16110f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // precision, just leave it, otherwise excise it. 16128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 16138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 16140f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 16150f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, VT); 16160f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 16170f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 16188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 16198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 16208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 16218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 16228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 16238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 16248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, VT); 1625ff3e50cc39db6939b637165997283f59412387bbChris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, VT); 16268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 16278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 16288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 16298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 16308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 16318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, VT); 16328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 16338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 16348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 16358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 16368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 16378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 16388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 16398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 164023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 164123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 16428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 16438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 16448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 16458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 16468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 16478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 16488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 16498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 16508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 16518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 16528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 16538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, VT); 16548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 16558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 16568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 16578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 16588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 16598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 166023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 16618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 16628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 16638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 166403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 166503c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 166603c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 1667232ee95a09a583b7d66b90ee7ddf7fdb9c194a04Chris Lattner // FIXME: When the DAG combiner exists, change this to use EXTLOAD! 16686841dec8c1c071b5a417fb4172633c68301be36cChris Lattner if (MVT::isInteger(NVT)) 166952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::ZEXTLOAD, NVT, Tmp1, Tmp2, Node->getOperand(2), 167052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner VT); 16716841dec8c1c071b5a417fb4172633c68301be36cChris Lattner else 167252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::EXTLOAD, NVT, Tmp1, Tmp2, Node->getOperand(2), 167352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner VT); 167403c8546ec57523970874917854a2fb77b1ff598eChris Lattner 167503c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 167603c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 167703c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 167803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 167947e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 168047e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 168147e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 168247e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 168347e9223e06390897c3834f8c527001df392570ffChris Lattner break; 168447e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 168547e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 168647e9223e06390897c3834f8c527001df392570ffChris Lattner break; 168747e9223e06390897c3834f8c527001df392570ffChris Lattner } 168803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 168903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 169003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 169103c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 16928ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner case ISD::CALL: { 16938ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 16948ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 16958ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 16963d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 16973d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) 16983d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 16993d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 17008ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 17018ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner "Can only promote single result calls"); 17028ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner std::vector<MVT::ValueType> RetTyVTs; 17038ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.reserve(2); 17048ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(NVT); 17058ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(MVT::Other); 17063d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops); 17078ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Result = SDOperand(NC, 0); 17088ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 17098ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner // Insert the new chain mapping. 17108ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 17118ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner break; 1712edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 1713fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 1714fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 1715fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 1716fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 1717fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 1718fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 1719fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 1720fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 1721fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 1722fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 1723fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 1724fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 1725fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 1726fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 1727fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 1728fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp2 = DAG.getSetCC(ISD::SETEQ, MVT::i1, Tmp1, 1729fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(NVT), NVT)); 1730fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 1731fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 1732fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 1733fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 1734fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 1735fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 1736fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(NVT) - 1737fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 1738fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 1739fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 1740fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 174103c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 174203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 174303c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 174403c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 174503c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 174603c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 17473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 174884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 174984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 17504759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 17514759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 17524759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 175384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 175484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 175584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 175684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 175784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 1758bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner // FIXME: this should be moved to the dag combiner someday. 1759bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner if (NodeOp == ISD::ADD_PARTS || NodeOp == ISD::SUB_PARTS) 1760bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner if (LHSL.getValueType() == MVT::i32) { 1761bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner SDOperand LowEl; 1762bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHSL)) 1763bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner if (C->getValue() == 0) 1764bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner LowEl = RHSL; 1765bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHSL)) 1766bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner if (C->getValue() == 0) 1767bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner LowEl = LHSL; 1768bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner if (LowEl.Val) { 1769bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner // Turn this into an add/sub of the high part only. 1770bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner SDOperand HiEl = 1771bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner DAG.getNode(NodeOp == ISD::ADD_PARTS ? ISD::ADD : ISD::SUB, 1772bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner LowEl.getValueType(), LHSH, RHSH); 1773bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner Lo = LowEl; 1774bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner Hi = HiEl; 1775bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner return; 1776bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner } 1777bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner } 1778bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner 177984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 178084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 178184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 178284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 178384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 17844759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo = DAG.getNode(NodeOp, LHSL.getValueType(), Ops); 178584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 178684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 178784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 17885b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 17895b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 17905b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 17915b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 17925b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 17935b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 17945b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 17955b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 17965b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 17975b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 17985b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 17995b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo = DAG.getNode(NodeOp, LHSL.getValueType(), Ops); 18005b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 18015b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 18025b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 18035b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 1804e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 1805e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 1806e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 1807e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 1808e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 1809e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1810e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 1811e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 1812f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 1813e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 1814f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 1815f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 1816f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 1817f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 1818f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 1819f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 1820f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 1821f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 1822f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 1823f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 1824f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 1825f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 1826f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 1827f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 1828f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 1829f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 1830f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 1831f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 1832f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 1833f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 1834ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 1835ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 1836ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 1837f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 1838f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 1839f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 1840f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 1841f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 1842f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 1843f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 1844f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 1845f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 1846f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 1847f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 1848f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 1849f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 1850f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 1851ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 1852ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 1853ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 1854f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 1855f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 1856f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 1857f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 1858f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 1859f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 1860f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 1861f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 1862f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 1863edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 1864f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 1865f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 1866edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 1867f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 1868edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 1869f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 1870ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 1871ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 1872edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 1873ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1874f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 1875f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 1876f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 1877f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 1878f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 1879f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 1880f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 1881f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 1882f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 1883f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 1884f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 1885f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 1886f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 1887e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 1888e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 1889e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 1890e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getOperationAction(ISD::SELECT, NVT) != TargetLowering::Legal && 1891e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner !isa<ConstantSDNode>(Amt)) 1892e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 1893e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 1894e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 1895e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 1896e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 1897e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 1898e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 1899e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 1900e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand Cond = DAG.getSetCC(ISD::SETGE, TLI.getSetCCResultTy(), ShAmt, 1901e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner DAG.getConstant(NVTBits, ShTy)); 1902e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 1903e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 1904e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 1905e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1906e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 1907e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1908e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 1909e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 1910e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 1911e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 1912e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 1913e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 1914e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 1915edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1916e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 1917e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 1918e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 191977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 192077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getSetCC(ISD::SETEQ, 192177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TLI.getSetCCResultTy(), NAmt, 192277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(32, ShTy)), 192377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 192477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 1925e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 192677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 1927e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 1928e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 1929e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 1930e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 193177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 193277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 193377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1934e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 1935e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 1936e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 1937e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 1938e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 1939e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 1940e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 194177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 19429530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 19439530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 19449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 19459530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found) { 19469c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth()) return; 19479c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 194816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 19499c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 195016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 19519c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 19529c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 19539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 19549c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 19559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 19569c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 19579c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 19589c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 19599530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found); 19609c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 19619c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 19629530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 19639c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found); 19649c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 19659c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 19669c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 19679530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 19689530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 19699c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 19709530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found) { 19719c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Found && Node->getNodeDepth() >= Found->getNodeDepth()) return; 19729c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 197316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 19749c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 197516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 19769c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 19779c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 19789c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 19799c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 19809c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 19819c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 19829c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 19839c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 19849530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindEarliestCallSeqEnd(*UI, Found); 19859c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 19869c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 19879530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindEarliestCallSeqEnd(*UI, Found); 19889c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 19899c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 19909530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 199116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 19929530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 199316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 19949c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 1995f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 19969530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 19979c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 19989c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->hasOneUse()) // Simple case, only has one user to check. 19999530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqEnd(*Node->use_begin()); 2000edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 20019c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 20029c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(TheChain.getValueType() == MVT::Other && "Is not a token chain!"); 2003edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2004edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 20059c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner E = Node->use_end(); ; ++UI) { 200616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner assert(UI != E && "Didn't find a user of the tokchain, no CALLSEQ_END!"); 2007edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 20089c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 20099c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 20109c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 20119c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 2012eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 2013eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 20149c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 20159c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(0 && "Unreachable"); 20169c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner abort(); 20179c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 20189c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 20199530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 202016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 20219530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 20229530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 202316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 20240d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 20250d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 20260d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 20279530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 20280d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 20290d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 20300d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 20319c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 20329c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 20330d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 20340d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 20350d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 20360d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 20379c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 20389c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 20399530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 20409530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 20419530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart); 20429530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 2043edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 204416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 2045c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 204616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 204716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 20489530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) 20499530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 2050c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman else 20519530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 20529530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 2053edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 20540d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 20559530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 20560d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 20579530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain); 20589c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 20599530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 20600d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 20619530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 20629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 20639530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 20649c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 20659c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 20660d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 2067b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 2068b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 20690d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 20700d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 20710d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 20720d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 20730d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 20740d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 20750d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 20760d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 20770d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 20780d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 20790d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 20800d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 20819c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 20829c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 208377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 208477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 208577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 208677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 208777e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 208877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 20899c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 20909c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 20919c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 2092f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 2093f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 20949c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 209577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 209677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 209777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 209877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 209977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 210077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 210177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 2102edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 21030d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 210477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 21050d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 21069092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(InChain, RetTy, false, 0, Callee, Args, DAG); 2107b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallInfo.second, OutChain); 2108b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 2109b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner NeedsAnotherIteration = true; 21100d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 21110d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 211277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 211377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 21140d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallInfo.first; 211577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 211677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 211777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 211877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Lo; 21190d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner ExpandOp(CallInfo.first, Lo, Hi); 212077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner return Lo; 212177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 212277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 212377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 21249c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 212577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 212677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 212777e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 212877e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 212977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(DestTy) == Legal && "Destination type is not legal!"); 213077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 213177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 213277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 213377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 21340d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 2135e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 2136e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 2137e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 2138e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 2139e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 2140e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 2141e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 2142e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 214366de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 214466de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 214566de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 214666de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 214766de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 2148e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand SignSet = DAG.getSetCC(ISD::SETLT, TLI.getSetCCResultTy(), Hi, 2149e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner DAG.getConstant(0, Hi.getValueType())); 2150e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 2151e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 2152e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 2153383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 2154383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 2155383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 2156e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 2157e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner MachineConstantPool *CP = DAG.getMachineFunction().getConstantPool(); 2158e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CPIdx = DAG.getConstantPool(CP->getConstantPoolIndex(FudgeFactor), 2159e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner TLI.getPointerTy()); 2160e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 2161e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 2162e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 216352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 216452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 2165e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 2166e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 2167e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner FudgeInReg = DAG.getNode(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 21682d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth CPIdx, DAG.getSrcValue(NULL), MVT::f32); 2169e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 2170e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner return DAG.getNode(ISD::ADD, DestTy, SignedConv, FudgeInReg); 217177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 21720d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 217313689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 217413689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 217513689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 217613689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 217713689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 217813689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 21790d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 21800d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 21810d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 21820d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 21830d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 21840d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 21850d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 21860d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 21870d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 21880d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 21890d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 219077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 219177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 219277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 219377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 219444d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 219577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 219677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 219777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 219877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 219977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 220077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 22010d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 22020d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 22039092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(InChain, RetTy, false, 0, Callee, Args, DAG); 22040d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 2205b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 22060d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 220777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 2208edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2209e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2210e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 22113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 22123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 22133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 22143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 22153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 22163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 22173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 221871c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 22193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 22203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 22213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(VT) && "Cannot expand FP values!"); 22223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(NVT) && NVT < VT && 22233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 22243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 22253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If there is more than one use of this, see if we already expanded it. 22263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // There is no use remembering values that only have a single use, as the map 22273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // entries will never be reused. 22283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!Node->hasOneUse()) { 22293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 22303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner = ExpandedNodes.find(Op); 22313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (I != ExpandedNodes.end()) { 22323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = I->second.first; 22333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = I->second.second; 22343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return; 22353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 223645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } else { 223745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner assert(!ExpandedNodes.count(Op) && "Re-expanding a node!"); 22383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 22393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 22404e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 22414e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 22424e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 22434e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 22443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 22453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 22463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 22473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 22483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 22493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 2250fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2251fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 2252fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 2253fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 22543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 22553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 22563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 22573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 22583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 22593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 22603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 22613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyFromReg: { 226218c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner unsigned Reg = cast<RegSDNode>(Node)->getReg(); 22633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Aggregate register values are always in consequtive pairs. 226469a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Lo = DAG.getCopyFromReg(Reg, NVT, Node->getOperand(0)); 226569a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Hi = DAG.getCopyFromReg(Reg+1, NVT, Lo.getValue(1)); 2266edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 226769a52155d2eff066b49dbac385113002fd9dba14Chris Lattner // Remember that we legalized the chain. 226869a52155d2eff066b49dbac385113002fd9dba14Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(1)); 226969a52155d2eff066b49dbac385113002fd9dba14Chris Lattner 22703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 22713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 22723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 22733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2274d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 2275d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 2276d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 2277d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 2278d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 2279d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 2280d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 2281d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 2282edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 2283edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 22849b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 22859b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 22869b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 2287edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 2288edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 2289edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 229039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 229139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 22923becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 229339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 229439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 229539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand TopNotZero = DAG.getSetCC(ISD::SETNE, TLI.getSetCCResultTy(), 229639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HLZ, BitsC); 229739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 229839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 229939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 230039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 230139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 230239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 230339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 230439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 230539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 230639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 23073becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 230839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 230939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 231039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BotNotZero = DAG.getSetCC(ISD::SETNE, TLI.getSetCCResultTy(), 231139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LTZ, BitsC); 231239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 231339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 231439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 231539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 231639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 231739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 231839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 2319edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 23203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 23213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 23223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 23232d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 23243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 23253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 232638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 23273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 23283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 23292d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Is this safe? declaring that the two parts of the split load 23302d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 23312d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 2332ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 2333ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 2334ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 2335ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 2336ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 2337edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 23383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 2339ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 23403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 23413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 23423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 23433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 23443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CALL: { 23453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 23463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Callee = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 23473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 23483d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 23493d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 23503d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 23513d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 23523d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 23533d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 23543d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 23553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 23563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Can only expand a call once so far, not i64 -> i16!"); 23573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 23583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 23593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(3); 23603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 23613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 23623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(MVT::Other); 23633d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Chain, Callee, Ops); 23643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = SDOperand(NC, 0); 23653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = SDOperand(NC, 1); 23663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 23673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Insert the new chain mapping. 2368e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(2)); 23693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 23703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 23713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 23723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 23733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 23743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 23753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 23763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 23773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 23783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 23793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 23803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 23813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 23823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 238347e9223e06390897c3834f8c527001df392570ffChris Lattner 238447e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 238547e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 238647e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 238747e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 238847e9223e06390897c3834f8c527001df392570ffChris Lattner break; 238947e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 239047e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 239147e9223e06390897c3834f8c527001df392570ffChris Lattner break; 239247e9223e06390897c3834f8c527001df392570ffChris Lattner } 23933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 23943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 23953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 23963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 23973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 23983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 23993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 240006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 240106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 240206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 240306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 240406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 240506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 240606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 240706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 240806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Node->getOperand(0).getValueType()); 240906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 241006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 241106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 24123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 24133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 241406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 2415edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 24163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 24173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 24182dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 241927ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 242027ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 24213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 24223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 242306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 242406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 242506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 242606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 242706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 242806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 242906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 243006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 243123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 243206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 243306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 243406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 24353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 24363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 2437dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 2438edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 24393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 24403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 24413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 244206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 24434e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 24444e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 24454e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 24464e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 244777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 24484e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 244977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 24504e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 24514e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 24524e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 245377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 24544e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 245577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 24564e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 24574e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 2458e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SHL: 2459e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 246077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 2461e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 24624759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 24634759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 24644759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner if (TLI.getOperationAction(ISD::SHL_PARTS, NVT) == TargetLowering::Legal) { 24655b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), Node->getOperand(1), 24665b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 24674759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 24684759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 24694759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 2470e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 247177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 2472e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 2473e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2474e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRA: 2475e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 247677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 2477e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 24784759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 24794759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 24804759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner if (TLI.getOperationAction(ISD::SRA_PARTS, NVT) == TargetLowering::Legal) { 24815b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), Node->getOperand(1), 24825b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 24834759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 24844759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 24854759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 2486e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 248777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 2488e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 2489e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRL: 2490e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 249177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 2492e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 24934759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 24944759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 24954759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner if (TLI.getOperationAction(ISD::SRL_PARTS, NVT) == TargetLowering::Legal) { 24965b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), Node->getOperand(1), 24975b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 24984759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 24994759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 25004759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 2501e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 250277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 2503e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 2504e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2505edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 25064759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 25074759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 250884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 250984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 25104759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 25114759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 251284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 2513c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 2514c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman if (TLI.getOperationAction(ISD::MULHU, NVT) == TargetLowering::Legal) { 2515c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 2516c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 2517c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 2518c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 2519c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 2520c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 2521c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 2522c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 2523c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 2524c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 2525c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = ExpandLibCall("__muldi3" , Node, Hi); break; 2526c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 2527c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 2528c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 252977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 253077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 253177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 253277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 25333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 25343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 25353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember in a map if the values will be reused later. 25363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!Node->hasOneUse()) { 25373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isNew = ExpandedNodes.insert(std::make_pair(Op, 25383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::make_pair(Lo, Hi))).second; 25393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isNew && "Value already expanded?!?"); 25403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 25413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 25423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 25433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 25443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 25453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 25469c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 25473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 25483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 25499c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 25503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 25513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2552